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