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