1 /* 2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef MMI_LOG_H 17 #define MMI_LOG_H 18 19 #include <cinttypes> 20 #include <functional> 21 #include <future> 22 #include <string> 23 #include <sstream> 24 25 #include "hilog/log.h" 26 27 #include "util.h" 28 #include "klog.h" 29 30 #ifndef MMI_DISABLE_LOG_TRACE 31 32 namespace OHOS { 33 namespace MMI { 34 class LogTracer { 35 public: 36 LogTracer(); 37 38 LogTracer(int64_t, int32_t, int32_t); 39 40 LogTracer(LogTracer &&other) noexcept; 41 42 LogTracer &operator=(LogTracer &&other) noexcept; 43 44 ~LogTracer(); 45 46 private: 47 int64_t traceId_; 48 }; 49 50 void StartLogTraceId(int64_t, int32_t, int32_t); 51 52 void EndLogTraceId(int64_t); 53 54 const char *FormatLogTrace(); 55 56 void ResetLogTrace(); 57 } 58 } 59 60 #define MMI_FUNC_FMT "[%{public}s][%{public}s:%{public}d] " 61 #define MMI_FUNC_NOLINE_FMT "[%{public}s][%{public}s] " 62 #define INPUT_KEY_FLOW "InputKeyFlow" 63 #define MMI_TRACE_ID (OHOS::MMI::FormatLogTrace()), 64 #else 65 #define MMI_FUNC_FMT "[%{public}s:%{public}d] " 66 #define MMI_FUNC_NOLINE_FMT "[%{public}s] " 67 #define MMI_TRACE_ID 68 #endif //MMI_DISABLE_LOG_TRACE 69 70 #ifdef MMI_LOG_DOMAIN 71 #undef MMI_LOG_DOMAIN 72 #endif 73 #ifdef MMI_LOG_FRAMEWORK 74 #undef MMI_LOG_FRAMEWORK 75 #endif 76 #define MMI_LOG_FRAMEWORK 0XD002800 77 #ifdef MMI_LOG_SERVER 78 #undef MMI_LOG_SERVER 79 #endif 80 #define MMI_LOG_SERVER 0XD002801 81 #ifdef MMI_LOG_HANDLER 82 #undef MMI_LOG_HANDLER 83 #endif 84 #define MMI_LOG_HANDLER 0XD002802 85 #ifdef MMI_LOG_WINDOW 86 #undef MMI_LOG_WINDOW 87 #endif 88 #define MMI_LOG_WINDOW 0XD002803 89 #ifdef MMI_LOG_CURSOR 90 #undef MMI_LOG_CURSOR 91 #endif 92 #define MMI_LOG_CURSOR 0XD002804 93 #ifdef MMI_LOG_DISPATCH 94 #undef MMI_LOG_DISPATCH 95 #endif 96 #define MMI_LOG_DISPATCH 0XD002805 97 #ifdef MMI_LOG_ANRDETECT 98 #undef MMI_LOG_ANRDETECT 99 #endif 100 #define MMI_LOG_ANRDETECT 0XD002806 101 102 #define MMI_LOG_DOMAIN MMI_LOG_FRAMEWORK 103 104 #ifndef MMI_FUNC_INFO 105 #define MMI_FUNC_INFO __FUNCTION__ 106 #endif 107 108 #ifndef MMI_FILE_NAME 109 #define MMI_FILE_NAME (strrchr((__FILE__), '/') ? strrchr((__FILE__), '/') + 1 : (__FILE__)) 110 #endif 111 112 #ifndef MMI_LINE_INFO 113 #define MMI_LINE_INFO MMI_FILE_NAME, __LINE__ 114 #endif 115 116 #define MMI_HILOG_BASE(type, level, domain, tag, fmt, ...) do { \ 117 HILOG_IMPL(type, level, domain, tag, MMI_FUNC_FMT fmt, MMI_TRACE_ID MMI_FUNC_INFO, __LINE__, ##__VA_ARGS__); \ 118 } while (0) 119 #define MMI_HILOG_HEADER(level, lh, fmt, ...) do { \ 120 HILOG_IMPL(LOG_CORE, level, lh.domain, lh.tag, MMI_FUNC_FMT fmt, MMI_TRACE_ID lh.func, lh.line, \ 121 ##__VA_ARGS__); \ 122 } while (0) 123 #define MMI_HILOG_HEADER_NO_RELEASE(level, lh, fmt, ...) do { \ 124 HILOG_IMPL(LOG_ONLY_PRERELEASE, level, lh.domain, lh.tag, MMI_FUNC_FMT fmt, MMI_TRACE_ID lh.func, lh.line, \ 125 ##__VA_ARGS__); \ 126 } while (0) 127 128 #define MMI_HILOGD(fmt, ...) do { \ 129 if (HiLogIsLoggable(MMI_LOG_DOMAIN, MMI_LOG_TAG, LOG_DEBUG)) { \ 130 MMI_HILOG_BASE(LOG_CORE, LOG_DEBUG, MMI_LOG_DOMAIN, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 131 } \ 132 } while (0) 133 #define MMI_HILOGD_NO_RELEASE(fmt, ...) do { \ 134 if (HiLogIsLoggable(MMI_LOG_DOMAIN, MMI_LOG_TAG, LOG_DEBUG)) { \ 135 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_DEBUG, MMI_LOG_DOMAIN, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 136 } \ 137 } while (0) 138 139 #define MMI_HILOGI(fmt, ...) do { \ 140 MMI_HILOG_BASE(LOG_CORE, LOG_INFO, MMI_LOG_DOMAIN, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 141 } while (0) 142 #define MMI_HILOGI_NO_RELEASE(fmt, ...) do { \ 143 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_INFO, MMI_LOG_DOMAIN, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 144 } while (0) 145 146 #define MMI_HILOGW(fmt, ...) do { \ 147 MMI_HILOG_BASE(LOG_CORE, LOG_WARN, MMI_LOG_DOMAIN, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 148 } while (0) 149 #define MMI_HILOGW_NO_RELEASE(fmt, ...) do { \ 150 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_WARN, MMI_LOG_DOMAIN, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 151 } while (0) 152 153 #define MMI_HILOGE(fmt, ...) do { \ 154 MMI_HILOG_BASE(LOG_CORE, LOG_ERROR, MMI_LOG_DOMAIN, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 155 } while (0) 156 #define MMI_HILOGE_NO_RELEASE(fmt, ...) do { \ 157 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_ERROR, MMI_LOG_DOMAIN, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 158 } while (0) 159 160 #define MMI_HILOGF(fmt, ...) do { \ 161 MMI_HILOG_BASE(LOG_CORE, LOG_FATAL, MMI_LOG_DOMAIN, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 162 } while (0) 163 #define MMI_HILOGF_NO_RELEASE(fmt, ...) do { \ 164 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_FATAL, MMI_LOG_DOMAIN, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 165 } while (0) 166 167 #define MMI_HILOG_SERVERD(fmt, ...) do { \ 168 if (HiLogIsLoggable(MMI_LOG_SERVER, MMI_LOG_TAG, LOG_DEBUG)) { \ 169 MMI_HILOG_BASE(LOG_CORE, LOG_DEBUG, MMI_LOG_SERVER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 170 } \ 171 } while (0) 172 #define MMI_HILOG_SERVERD_NO_RELEASE(fmt, ...) do { \ 173 if (HiLogIsLoggable(MMI_LOG_SERVER, MMI_LOG_TAG, LOG_DEBUG)) { \ 174 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_DEBUG, MMI_LOG_SERVER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 175 } \ 176 } while (0) 177 178 #define MMI_HILOG_SERVERI(fmt, ...) do { \ 179 MMI_HILOG_BASE(LOG_CORE, LOG_INFO, MMI_LOG_SERVER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 180 } while (0) 181 #define MMI_HILOG_SERVERI_NO_RELEASE(fmt, ...) do { \ 182 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_INFO, MMI_LOG_SERVER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 183 } while (0) 184 185 #define MMI_HILOG_SERVERW(fmt, ...) do { \ 186 MMI_HILOG_BASE(LOG_CORE, LOG_WARN, MMI_LOG_SERVER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 187 } while (0) 188 #define MMI_HILOG_SERVERW_NO_RELEASE(fmt, ...) do { \ 189 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_WARN, MMI_LOG_SERVER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 190 } while (0) 191 192 #define MMI_HILOG_SERVERE(fmt, ...) do { \ 193 MMI_HILOG_BASE(LOG_CORE, LOG_ERROR, MMI_LOG_SERVER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 194 } while (0) 195 #define MMI_HILOG_SERVERE_NO_RELEASE(fmt, ...) do { \ 196 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_ERROR, MMI_LOG_SERVER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 197 } while (0) 198 199 #define MMI_HILOG_SERVERF(fmt, ...) do { \ 200 MMI_HILOG_BASE(LOG_CORE, LOG_FATAL, MMI_LOG_SERVER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 201 } while (0) 202 #define MMI_HILOG_SERVERF_NO_RELEASE(fmt, ...) do { \ 203 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_FATAL, MMI_LOG_SERVER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 204 } while (0) 205 206 #define MMI_HILOG_HANDLERD(fmt, ...) do { \ 207 if (HiLogIsLoggable(MMI_LOG_HANDLER, MMI_LOG_TAG, LOG_DEBUG)) { \ 208 MMI_HILOG_BASE(LOG_CORE, LOG_DEBUG, MMI_LOG_HANDLER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 209 } \ 210 } while (0) 211 #define MMI_HILOG_HANDLERD_NO_RELEASE(fmt, ...) do { \ 212 if (HiLogIsLoggable(MMI_LOG_HANDLER, MMI_LOG_TAG, LOG_DEBUG)) { \ 213 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_DEBUG, MMI_LOG_HANDLER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 214 } \ 215 } while (0) 216 217 #define MMI_HILOG_HANDLERI(fmt, ...) do { \ 218 MMI_HILOG_BASE(LOG_CORE, LOG_INFO, MMI_LOG_HANDLER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 219 } while (0) 220 #define MMI_HILOG_HANDLERI_NO_RELEASE(fmt, ...) do { \ 221 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_INFO, MMI_LOG_HANDLER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 222 } while (0) 223 224 #define MMI_HILOG_HANDLERW(fmt, ...) do { \ 225 MMI_HILOG_BASE(LOG_CORE, LOG_WARN, MMI_LOG_HANDLER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 226 } while (0) 227 #define MMI_HILOG_HANDLERW_NO_RELEASE(fmt, ...) do { \ 228 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_WARN, MMI_LOG_HANDLER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 229 } while (0) 230 231 #define MMI_HILOG_HANDLERE(fmt, ...) do { \ 232 MMI_HILOG_BASE(LOG_CORE, LOG_ERROR, MMI_LOG_HANDLER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 233 } while (0) 234 #define MMI_HILOG_HANDLERE_NO_RELEASE(fmt, ...) do { \ 235 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_ERROR, MMI_LOG_HANDLER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 236 } while (0) 237 238 #define MMI_HILOG_HANDLERF(fmt, ...) do { \ 239 MMI_HILOG_BASE(LOG_CORE, LOG_FATAL, MMI_LOG_HANDLER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 240 } while (0) 241 #define MMI_HILOG_HANDLERF_NO_RELEASE(fmt, ...) do { \ 242 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_FATAL, MMI_LOG_HANDLER, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 243 } while (0) 244 245 #define MMI_HILOG_WINDOWD(fmt, ...) do { \ 246 if (HiLogIsLoggable(MMI_LOG_WINDOW, MMI_LOG_TAG, LOG_DEBUG)) { \ 247 MMI_HILOG_BASE(LOG_CORE, LOG_DEBUG, MMI_LOG_WINDOW, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 248 } \ 249 } while (0) 250 #define MMI_HILOG_WINDOWD_NO_RELEASE(fmt, ...) do { \ 251 if (HiLogIsLoggable(MMI_LOG_WINDOW, MMI_LOG_TAG, LOG_DEBUG)) { \ 252 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_DEBUG, MMI_LOG_WINDOW, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 253 } \ 254 } while (0) 255 256 #define MMI_HILOG_WINDOWI(fmt, ...) do { \ 257 MMI_HILOG_BASE(LOG_CORE, LOG_INFO, MMI_LOG_WINDOW, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 258 } while (0) 259 #define MMI_HILOG_WINDOWI_NO_RELEASE(fmt, ...) do { \ 260 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_INFO, MMI_LOG_WINDOW, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 261 } while (0) 262 263 #define MMI_HILOG_WINDOWW(fmt, ...) do { \ 264 MMI_HILOG_BASE(LOG_CORE, LOG_WARN, MMI_LOG_WINDOW, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 265 } while (0) 266 #define MMI_HILOG_WINDOWW_NO_RELEASE(fmt, ...) do { \ 267 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_WARN, MMI_LOG_WINDOW, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 268 } while (0) 269 270 #define MMI_HILOG_WINDOWE(fmt, ...) do { \ 271 MMI_HILOG_BASE(LOG_CORE, LOG_ERROR, MMI_LOG_WINDOW, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 272 } while (0) 273 #define MMI_HILOG_WINDOWE_NO_RELEASE(fmt, ...) do { \ 274 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_ERROR, MMI_LOG_WINDOW, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 275 } while (0) 276 277 #define MMI_HILOG_WINDOWF(fmt, ...) do { \ 278 MMI_HILOG_BASE(LOG_CORE, LOG_FATAL, MMI_LOG_WINDOW, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 279 } while (0) 280 #define MMI_HILOG_WINDOWF_NO_RELEASE(fmt, ...) do { \ 281 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_FATAL, MMI_LOG_WINDOW, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 282 } while (0) 283 284 #define MMI_HILOG_CURSORD(fmt, ...) do { \ 285 if (HiLogIsLoggable(MMI_LOG_CURSOR, MMI_LOG_TAG, LOG_DEBUG)) { \ 286 MMI_HILOG_BASE(LOG_CORE, LOG_DEBUG, MMI_LOG_CURSOR, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 287 } \ 288 } while (0) 289 #define MMI_HILOG_CURSORD_NO_RELEASE(fmt, ...) do { \ 290 if (HiLogIsLoggable(MMI_LOG_CURSOR, MMI_LOG_TAG, LOG_DEBUG)) { \ 291 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_DEBUG, MMI_LOG_CURSOR, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 292 } \ 293 } while (0) 294 295 #define MMI_HILOG_CURSORI(fmt, ...) do { \ 296 MMI_HILOG_BASE(LOG_CORE, LOG_INFO, MMI_LOG_CURSOR, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 297 } while (0) 298 #define MMI_HILOG_CURSORI_NO_RELEASE(fmt, ...) do { \ 299 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_INFO, MMI_LOG_CURSOR, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 300 } while (0) 301 302 #define MMI_HILOG_CURSORW(fmt, ...) do { \ 303 MMI_HILOG_BASE(LOG_CORE, LOG_WARN, MMI_LOG_CURSOR, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 304 } while (0) 305 #define MMI_HILOG_CURSORW_NO_RELEASE(fmt, ...) do { \ 306 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_WARN, MMI_LOG_CURSOR, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 307 } while (0) 308 309 #define MMI_HILOG_CURSORE(fmt, ...) do { \ 310 MMI_HILOG_BASE(LOG_CORE, LOG_ERROR, MMI_LOG_CURSOR, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 311 } while (0) 312 #define MMI_HILOG_CURSORE_NO_RELEASE(fmt, ...) do { \ 313 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_ERROR, MMI_LOG_CURSOR, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 314 } while (0) 315 316 #define MMI_HILOG_CURSORF(fmt, ...) do { \ 317 MMI_HILOG_BASE(LOG_CORE, LOG_FATAL, MMI_LOG_CURSOR, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 318 } while (0) 319 #define MMI_HILOG_CURSORF_NO_RELEASE(fmt, ...) do { \ 320 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_FATAL, MMI_LOG_CURSOR, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 321 } while (0) 322 323 #define MMI_HILOG_DISPATCHD(fmt, ...) do { \ 324 if (HiLogIsLoggable(MMI_LOG_DISPATCH, MMI_LOG_TAG, LOG_DEBUG)) { \ 325 MMI_HILOG_BASE(LOG_CORE, LOG_DEBUG, MMI_LOG_DISPATCH, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 326 } \ 327 } while (0) 328 #define MMI_HILOG_DISPATCHD_NO_RELEASE(fmt, ...) do { \ 329 if (HiLogIsLoggable(MMI_LOG_DISPATCH, MMI_LOG_TAG, LOG_DEBUG)) { \ 330 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_DEBUG, MMI_LOG_DISPATCH, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 331 } \ 332 } while (0) 333 334 #define MMI_HILOG_DISPATCHI(fmt, ...) do { \ 335 MMI_HILOG_BASE(LOG_CORE, LOG_INFO, MMI_LOG_DISPATCH, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 336 } while (0) 337 #define MMI_HILOG_DISPATCHI_NO_RELEASE(fmt, ...) do { \ 338 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_INFO, MMI_LOG_DISPATCH, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 339 } while (0) 340 341 #define MMI_HILOG_DISPATCHW(fmt, ...) do { \ 342 MMI_HILOG_BASE(LOG_CORE, LOG_WARN, MMI_LOG_DISPATCH, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 343 } while (0) 344 #define MMI_HILOG_DISPATCHW_NO_RELEASE(fmt, ...) do { \ 345 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_WARN, MMI_LOG_DISPATCH, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 346 } while (0) 347 348 #define MMI_HILOG_DISPATCHE(fmt, ...) do { \ 349 MMI_HILOG_BASE(LOG_CORE, LOG_ERROR, MMI_LOG_DISPATCH, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 350 } while (0) 351 #define MMI_HILOG_DISPATCHE_NO_RELEASE(fmt, ...) do { \ 352 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_ERROR, MMI_LOG_DISPATCH, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 353 } while (0) 354 355 #define MMI_HILOG_DISPATCHF(fmt, ...) do { \ 356 MMI_HILOG_BASE(LOG_CORE, LOG_FATAL, MMI_LOG_DISPATCH, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 357 } while (0) 358 #define MMI_HILOG_DISPATCHF_NO_RELEASE(fmt, ...) do { \ 359 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_FATAL, MMI_LOG_DISPATCH, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 360 } while (0) 361 362 #define MMI_HILOG_FREEZEI(fmt, ...) do { \ 363 MMI_HILOG_BASE(LOG_CORE, LOG_INFO, MMI_LOG_DISPATCH, INPUT_KEY_FLOW, fmt, ##__VA_ARGS__); \ 364 } while (0) 365 #define MMI_HILOG_FREEZEI_NO_RELEASE(fmt, ...) do { \ 366 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_INFO, MMI_LOG_DISPATCH, INPUT_KEY_FLOW, fmt, ##__VA_ARGS__); \ 367 } while (0) 368 369 #define MMI_HILOG_FREEZEE(fmt, ...) do { \ 370 MMI_HILOG_BASE(LOG_CORE, LOG_ERROR, MMI_LOG_DISPATCH, INPUT_KEY_FLOW, fmt, ##__VA_ARGS__); \ 371 } while (0) 372 #define MMI_HILOG_FREEZEE_NO_RELEASE(fmt, ...) do { \ 373 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_ERROR, MMI_LOG_DISPATCH, INPUT_KEY_FLOW, fmt, ##__VA_ARGS__); \ 374 } while (0) 375 376 #define MMI_HILOG_ANRDETECTD(fmt, ...) do { \ 377 if (HiLogIsLoggable(MMI_LOG_DISPATCH, MMI_LOG_TAG, LOG_DEBUG)) { \ 378 MMI_HILOG_BASE(LOG_CORE, LOG_DEBUG, MMI_LOG_ANRDETECT, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 379 } \ 380 } while (0) 381 #define MMI_HILOG_ANRDETECTD_NO_RELEASE(fmt, ...) do { \ 382 if (HiLogIsLoggable(MMI_LOG_DISPATCH, MMI_LOG_TAG, LOG_DEBUG)) { \ 383 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_DEBUG, MMI_LOG_ANRDETECT, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 384 } \ 385 } while (0) 386 387 #define MMI_HILOG_ANRDETECTI(fmt, ...) do { \ 388 MMI_HILOG_BASE(LOG_CORE, LOG_INFO, MMI_LOG_ANRDETECT, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 389 } while (0) 390 #define MMI_HILOG_ANRDETECTI_NO_RELEASE(fmt, ...) do { \ 391 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_INFO, MMI_LOG_ANRDETECT, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 392 } while (0) 393 394 #define MMI_HILOG_ANRDETECTW(fmt, ...) do { \ 395 MMI_HILOG_BASE(LOG_CORE, LOG_WARN, MMI_LOG_ANRDETECT, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 396 } while (0) 397 #define MMI_HILOG_ANRDETECTW_NO_RELEASE(fmt, ...) do { \ 398 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_WARN, MMI_LOG_ANRDETECT, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 399 } while (0) 400 401 #define MMI_HILOG_ANRDETECTE(fmt, ...) do { \ 402 MMI_HILOG_BASE(LOG_CORE, LOG_ERROR, MMI_LOG_ANRDETECT, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 403 } while (0) 404 #define MMI_HILOG_ANRDETECTE_NO_RELEASE(fmt, ...) do { \ 405 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_ERROR, MMI_LOG_ANRDETECT, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 406 } while (0) 407 408 #define MMI_HILOG_ANRDETECTF(fmt, ...) do { \ 409 MMI_HILOG_BASE(LOG_CORE, LOG_FATAL, MMI_LOG_ANRDETECT, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 410 } while (0) 411 #define MMI_HILOG_ANRDETECTF_NO_RELEASE(fmt, ...) do { \ 412 MMI_HILOG_BASE(LOG_ONLY_PRERELEASE, LOG_FATAL, MMI_LOG_ANRDETECT, MMI_LOG_TAG, fmt, ##__VA_ARGS__); \ 413 } while (0) 414 415 #define MMI_HILOGDK(fmt, ...) do { \ 416 KMSG_LOGD(fmt, ##__VA_ARGS__); \ 417 MMI_HILOGD(fmt, ##__VA_ARGS__); \ 418 } while (0) 419 420 #define MMI_HILOGIK(fmt, ...) do { \ 421 KMSG_LOGI(fmt, ##__VA_ARGS__); \ 422 MMI_HILOGI(fmt, ##__VA_ARGS__); \ 423 } while (0) 424 425 #define MMI_HILOGWK(fmt, ...) do { \ 426 KMSG_LOGW(fmt, ##__VA_ARGS__); \ 427 MMI_HILOGW(fmt, ##__VA_ARGS__); \ 428 } while (0) 429 430 #define MMI_HILOGEK(fmt, ...) do { \ 431 KMSG_LOGE(fmt, ##__VA_ARGS__); \ 432 MMI_HILOGE(fmt, ##__VA_ARGS__); \ 433 } while (0) 434 435 #define MMI_HILOGFK(fmt, ...) do { \ 436 KMSG_LOGF(fmt, ##__VA_ARGS__); \ 437 MMI_HILOGF(fmt, ##__VA_ARGS__); \ 438 } while (0) 439 440 namespace OHOS { 441 namespace MMI { 442 inline constexpr int32_t EVENT_TYPE_POINTER { 0X00020000 }; 443 inline constexpr int32_t TIMEOUT { 100000 }; 444 inline constexpr int32_t POINTER_ACTION_UP { 4 }; 445 inline constexpr int32_t POINTER_ACTION_MOVE { 3 }; 446 inline constexpr int32_t FINAL_FINGER { 1 }; 447 448 class InnerFunctionTracer { 449 public: InnerFunctionTracer(LogLevel level,const char * tag,const char * logfn,uint32_t logline)450 InnerFunctionTracer(LogLevel level, const char* tag, const char* logfn, uint32_t logline) 451 : level_ { level }, tag_ { tag }, logfn_ { logfn }, logline_ { logline } 452 { 453 if (HiLogIsLoggable(MMI_LOG_DOMAIN, tag_, level_)) { 454 if (logfn_ != nullptr) { 455 HILOG_IMPL(LOG_CORE, level_, MMI_LOG_DOMAIN, tag_, MMI_FUNC_FMT "enter", MMI_TRACE_ID logfn_, logline_); 456 } 457 } 458 } ~InnerFunctionTracer()459 ~InnerFunctionTracer() 460 { 461 if (HiLogIsLoggable(MMI_LOG_DOMAIN, tag_, level_)) { 462 if (logfn_ != nullptr) { 463 HILOG_IMPL(LOG_CORE, level_, MMI_LOG_DOMAIN, tag_, MMI_FUNC_NOLINE_FMT "leave", MMI_TRACE_ID logfn_); 464 } 465 } 466 } 467 private: 468 LogLevel level_ { LOG_LEVEL_MIN }; 469 const char* tag_ { nullptr }; 470 const char* logfn_ { nullptr }; 471 const uint32_t logline_ { 0 }; 472 }; 473 474 struct LogHeader { 475 const uint32_t domain; 476 const char* tag; 477 const char* func; 478 const uint32_t line; 479 LogHeaderLogHeader480 LogHeader(uint32_t domain, const char* tag, const char* func, uint32_t line) 481 : domain(domain), tag(tag), func(func), line(line) {} 482 }; 483 } // namespace MMI 484 } // namespace OHOS 485 486 #define MMI_LOG_HEADER { MMI_LOG_DOMAIN, MMI_LOG_TAG, __FUNCTION__, __LINE__ } 487 #define MMI_LOG_FREEZE { MMI_LOG_DOMAIN, INPUT_KEY_FLOW, __FUNCTION__, __LINE__ } 488 489 #define CALL_DEBUG_ENTER ::OHOS::MMI::InnerFunctionTracer __innerFuncTracer_Debug___ \ 490 { LOG_DEBUG, MMI_LOG_TAG, __FUNCTION__, __LINE__ } 491 #define CALL_INFO_TRACE ::OHOS::MMI::InnerFunctionTracer ___innerFuncTracer_Info___ \ 492 { LOG_INFO, MMI_LOG_TAG, __FUNCTION__, __LINE__ } 493 #define CALL_TEST_DEBUG ::OHOS::MMI::InnerFunctionTracer ___innerFuncTracer_Info___ \ 494 { LOG_DEBUG, MMI_LOG_TAG, test_info_ == nullptr ? "TestBody" : test_info_->name(), __LINE__ } 495 #endif // MMI_LOG_H 496