1 /*
2 * Copyright (c) 2022-2024 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 #include "event_report.h"
17 #include "hilog_tag_wrapper.h"
18 #include "hitrace_meter.h"
19
20 namespace OHOS {
21 namespace AAFwk {
22 namespace {
23 // event params
24 constexpr const char *EVENT_KEY_APP_PID = "APP_PID";
25 constexpr const char *EVENT_KEY_USERID = "USER_ID";
26 constexpr const char *EVENT_KEY_ERROR_CODE = "ERROR_CODE";
27 constexpr const char *EVENT_KEY_BUNDLE_NAME = "BUNDLE_NAME";
28 constexpr const char *EVENT_KEY_MODULE_NAME = "MODULE_NAME";
29 constexpr const char *EVENT_KEY_ABILITY_NAME = "ABILITY_NAME";
30 constexpr const char *EVENT_KEY_ABILITY_NUMBER = "ABILITY_NUMBER";
31 constexpr const char *EVENT_KEY_ABILITY_TYPE = "ABILITY_TYPE";
32 constexpr const char *EVENT_KEY_VERSION_NAME = "VERSION_NAME";
33 constexpr const char *EVENT_KEY_VERSION_CODE = "VERSION_CODE";
34 constexpr const char *EVENT_KEY_PROCESS_NAME = "PROCESS_NAME";
35 constexpr const char *EVENT_KEY_EXTENSION_TYPE = "EXTENSION_TYPE";
36 constexpr const char *EVENT_KEY_STARTUP_TIME = "STARTUP_TIME";
37 constexpr const char *EVENT_KEY_STARTUP_ABILITY_TYPE = "STARTUP_ABILITY_TYPE";
38 constexpr const char *EVENT_KEY_STARTUP_EXTENSION_TYPE = "STARTUP_EXTENSION_TYPE";
39 constexpr const char *EVENT_KEY_CALLER_BUNDLE_NAME = "CALLER_BUNDLE_NAME";
40 constexpr const char *EVENT_KEY_CALLER_UID = "CALLER_UID";
41 constexpr const char *EVENT_KEY_CALLER_PROCESS_NAME = "CALLER_PROCESS_NAME";
42 constexpr const char *EVENT_KEY_CALLER_PROCESS_ID = "CALLER_PROCESS_ID";
43 constexpr const char *EVENT_KEY_EXIT_TIME = "EXIT_TIME";
44 constexpr const char *EVENT_KEY_EXIT_RESULT = "EXIT_RESULT";
45 constexpr const char *EVENT_KEY_EXIT_PID = "EXIT_PID";
46 constexpr const char *EVENT_KEY_EXIT_REASON = "EXIT_REASON";
47 constexpr const char *EVENT_KEY_BUNDLE_TYPE = "BUNDLE_TYPE";
48 constexpr const char *EVENT_KEY_START_TYPE = "START_TYPE";
49 constexpr const char *EVENT_KEY_START_REASON = "START_REASON";
50 constexpr const char *EVENT_KEY_CALLER_STATE = "CALLER_STATE";
51 constexpr const char *EVENT_KEY_CALLER_VERSION_NAME = "CALLER_VERSION_NAME";
52 constexpr const char *EVENT_KEY_CALLER_VERSION_CODE = "CALLER_VERSION_CODE";
53 constexpr const char *EVENT_KEY_URI = "URI";
54 constexpr const char *EVENT_KEY_RESTART_TIME = "RESTART_TIME";
55 constexpr const char *EVENT_KEY_APP_UID = "APP_UID";
56 constexpr const char *EVENT_KEY_PROCESS_TYPE = "PROCESS_TYPE";
57 constexpr const char *EVENT_KEY_TIME = "TIME";
58 constexpr const char *EVENT_KEY_PID = "PID";
59 constexpr const char *EVENT_KEY_REASON = "REASON";
60 constexpr const char *EVENT_KEY_SUB_REASON = "SUB_REASON";
61 constexpr const char *INVALID_EVENT_NAME = "INVALIDEVENTNAME";
62
63 constexpr const int32_t DEFAULT_EXTENSION_TYPE = -1;
64 }
65
SendAppEvent(const EventName & eventName,HiSysEventType type,const EventInfo & eventInfo)66 void EventReport::SendAppEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
67 {
68 std::string name = ConvertEventName(eventName);
69 if (name == INVALID_EVENT_NAME) {
70 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
71 return;
72 }
73 switch (eventName) {
74 case EventName::APP_STARTUP_TYPE:
75 HiSysEventWrite(
76 HiSysEvent::Domain::AAFWK,
77 name,
78 type,
79 EVENT_KEY_APP_PID, eventInfo.pid,
80 EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
81 EVENT_KEY_VERSION_NAME, eventInfo.versionName,
82 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
83 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
84 EVENT_KEY_START_TYPE, eventInfo.startType,
85 EVENT_KEY_START_REASON, eventInfo.startReason);
86 break;
87 case EventName::DRAWN_COMPLETED:
88 TAG_LOGI(AAFwkTag::DEFAULT,
89 "DRAWN_COMPLETED, bundle: %{public}s, ability: %{public}s",
90 eventInfo.bundleName.c_str(), eventInfo.abilityName.c_str());
91 HiSysEventWrite(
92 HiSysEvent::Domain::AAFWK,
93 name,
94 type,
95 EVENT_KEY_USERID, eventInfo.userId,
96 EVENT_KEY_APP_PID, eventInfo.pid,
97 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
98 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
99 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
100 break;
101 default:
102 HiSysEventWrite(
103 HiSysEvent::Domain::AAFWK,
104 name,
105 type,
106 EVENT_KEY_APP_PID, eventInfo.pid,
107 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
108 EVENT_KEY_VERSION_NAME, eventInfo.versionName,
109 EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
110 EVENT_KEY_PROCESS_NAME, eventInfo.processName);
111 break;
112 }
113 }
114
LogErrorEvent(const std::string & name,HiSysEventType type,const EventInfo & eventInfo)115 void EventReport::LogErrorEvent(const std::string &name, HiSysEventType type, const EventInfo &eventInfo)
116 {
117 HiSysEventWrite(
118 HiSysEvent::Domain::AAFWK,
119 name,
120 type,
121 EVENT_KEY_USERID, eventInfo.userId,
122 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
123 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
124 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
125 EVENT_KEY_ERROR_CODE, eventInfo.errCode);
126 }
127
LogStartAbilityEvent(const std::string & name,HiSysEventType type,const EventInfo & eventInfo)128 void EventReport::LogStartAbilityEvent(const std::string &name, HiSysEventType type, const EventInfo &eventInfo)
129 {
130 HiSysEventWrite(
131 HiSysEvent::Domain::AAFWK,
132 name,
133 type,
134 EVENT_KEY_USERID, eventInfo.userId,
135 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
136 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
137 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
138 }
139
LogTerminateAbilityEvent(const std::string & name,HiSysEventType type,const EventInfo & eventInfo)140 void EventReport::LogTerminateAbilityEvent(const std::string &name, HiSysEventType type, const EventInfo &eventInfo)
141 {
142 HiSysEventWrite(
143 HiSysEvent::Domain::AAFWK,
144 name,
145 type,
146 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
147 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
148 }
149
LogAbilityOnForegroundEvent(const std::string & name,HiSysEventType type,const EventInfo & eventInfo)150 void EventReport::LogAbilityOnForegroundEvent(const std::string &name, HiSysEventType type, const EventInfo &eventInfo)
151 {
152 HiSysEventWrite(
153 HiSysEvent::Domain::AAFWK,
154 name,
155 type,
156 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
157 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
158 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
159 EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType,
160 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName);
161 }
162
LogAbilityOnBackgroundEvent(const std::string & name,HiSysEventType type,const EventInfo & eventInfo)163 void EventReport::LogAbilityOnBackgroundEvent(const std::string &name, HiSysEventType type, const EventInfo &eventInfo)
164 {
165 HiSysEventWrite(
166 HiSysEvent::Domain::AAFWK,
167 name,
168 type,
169 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
170 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
171 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
172 EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType);
173 }
174
LogAbilityOnActiveEvent(const std::string & name,HiSysEventType type,const EventInfo & eventInfo)175 void EventReport::LogAbilityOnActiveEvent(const std::string &name, HiSysEventType type, const EventInfo &eventInfo)
176 {
177 HiSysEventWrite(
178 HiSysEvent::Domain::AAFWK,
179 name,
180 type,
181 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
182 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
183 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
184 EVENT_KEY_ABILITY_TYPE, eventInfo.abilityType,
185 EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType,
186 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName);
187 }
188
LogStartStandardEvent(const std::string & name,HiSysEventType type,const EventInfo & eventInfo)189 void EventReport::LogStartStandardEvent(const std::string &name, HiSysEventType type, const EventInfo &eventInfo)
190 {
191 TAG_LOGD(AAFwkTag::DEFAULT, "EventInfo: [%{public}d, %{public}s, %{public}s, %{public}s]",
192 eventInfo.userId, eventInfo.bundleName.c_str(), eventInfo.moduleName.c_str(),
193 eventInfo.abilityName.c_str());
194 HiSysEventWrite(
195 HiSysEvent::Domain::AAFWK,
196 name,
197 type,
198 EVENT_KEY_USERID, eventInfo.userId,
199 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
200 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
201 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
202 EVENT_KEY_ABILITY_NUMBER, eventInfo.abilityNumber);
203 }
204
LogStartAbilityByAppLinking(const std::string & name,HiSysEventType type,const EventInfo & eventInfo)205 void EventReport::LogStartAbilityByAppLinking(const std::string &name, HiSysEventType type, const EventInfo &eventInfo)
206 {
207 TAG_LOGD(AAFwkTag::DEFAULT, "EventInfo, bundleName: %{public}s, callerBundleName: %{public}s, uri: %{public}s",
208 eventInfo.bundleName.c_str(), eventInfo.callerBundleName.c_str(), eventInfo.uri.c_str());
209 auto ret = HiSysEventWrite(
210 HiSysEvent::Domain::AAFWK,
211 name,
212 type,
213 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
214 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
215 EVENT_KEY_URI, eventInfo.uri);
216 if (ret != 0) {
217 TAG_LOGE(AAFwkTag::DEFAULT, "Write event fail: %{public}s, ret %{public}d", name.c_str(), ret);
218 }
219 }
220
SendAbilityEvent(const EventName & eventName,HiSysEventType type,const EventInfo & eventInfo)221 void EventReport::SendAbilityEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
222 {
223 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
224 std::string name = ConvertEventName(eventName);
225 if (name == INVALID_EVENT_NAME) {
226 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
227 return;
228 }
229 switch (eventName) {
230 case EventName::START_ABILITY_ERROR:
231 case EventName::TERMINATE_ABILITY_ERROR:
232 LogErrorEvent(name, type, eventInfo);
233 break;
234 case EventName::START_ABILITY:
235 LogStartAbilityEvent(name, type, eventInfo);
236 break;
237 case EventName::TERMINATE_ABILITY:
238 case EventName::CLOSE_ABILITY:
239 LogTerminateAbilityEvent(name, type, eventInfo);
240 break;
241 case EventName::ABILITY_ONFOREGROUND:
242 LogAbilityOnForegroundEvent(name, type, eventInfo);
243 break;
244 case EventName::ABILITY_ONBACKGROUND:
245 case EventName::ABILITY_ONINACTIVE:
246 LogAbilityOnBackgroundEvent(name, type, eventInfo);
247 break;
248 case EventName::ABILITY_ONACTIVE:
249 LogAbilityOnActiveEvent(name, type, eventInfo);
250 break;
251 case EventName::START_STANDARD_ABILITIES:
252 LogStartStandardEvent(name, type, eventInfo);
253 break;
254 case EventName::START_ABILITY_BY_APP_LINKING:
255 LogStartAbilityByAppLinking(name, type, eventInfo);
256 break;
257 default:
258 break;
259 }
260 }
261
SendAtomicServiceEvent(const EventName & eventName,HiSysEventType type,const EventInfo & eventInfo)262 void EventReport::SendAtomicServiceEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
263 {
264 std::string name = ConvertEventName(eventName);
265 if (name == INVALID_EVENT_NAME) {
266 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
267 return;
268 }
269 switch (eventName) {
270 case EventName::ATOMIC_SERVICE_DRAWN_COMPLETE:
271 HiSysEventWrite(
272 HiSysEvent::Domain::AAFWK,
273 name,
274 type,
275 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
276 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
277 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
278 break;
279 case EventName::CREATE_ATOMIC_SERVICE_PROCESS:
280 HiSysEventWrite(
281 HiSysEvent::Domain::AAFWK,
282 name,
283 type,
284 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
285 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
286 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
287 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
288 EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName,
289 EVENT_KEY_CALLER_UID, eventInfo.callerUid);
290 break;
291 default:
292 break;
293 }
294 }
295
SendGrantUriPermissionEvent(const EventName & eventName,const EventInfo & eventInfo)296 void EventReport::SendGrantUriPermissionEvent(const EventName &eventName, const EventInfo &eventInfo)
297 {
298 std::string name = ConvertEventName(eventName);
299 if (name == INVALID_EVENT_NAME) {
300 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName: %{public}s", name.c_str());
301 return;
302 }
303 switch (eventName) {
304 case EventName::GRANT_URI_PERMISSION:
305 HiSysEventWrite(
306 HiSysEvent::Domain::AAFWK,
307 name,
308 HiSysEventType::BEHAVIOR,
309 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
310 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
311 EVENT_KEY_URI, eventInfo.uri);
312 break;
313 case EventName::SHARE_UNPRIVILEGED_FILE_URI:
314 HiSysEventWrite(
315 HiSysEvent::Domain::AAFWK,
316 name,
317 HiSysEventType::BEHAVIOR,
318 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
319 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName);
320 break;
321 default:
322 break;
323 }
324 }
325
SendExtensionEvent(const EventName & eventName,HiSysEventType type,const EventInfo & eventInfo)326 void EventReport::SendExtensionEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
327 {
328 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
329 std::string name = ConvertEventName(eventName);
330 if (name == INVALID_EVENT_NAME) {
331 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
332 return;
333 }
334 switch (eventName) {
335 case EventName::START_EXTENSION_ERROR:
336 case EventName::STOP_EXTENSION_ERROR:
337 case EventName::CONNECT_SERVICE_ERROR:
338 HiSysEventWrite(
339 HiSysEvent::Domain::AAFWK,
340 name,
341 type,
342 EVENT_KEY_USERID, eventInfo.userId,
343 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
344 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
345 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
346 EVENT_KEY_ERROR_CODE, eventInfo.errCode);
347 break;
348 case EventName::DISCONNECT_SERVICE_ERROR:
349 HiSysEventWrite(HiSysEvent::Domain::AAFWK, name, type, EVENT_KEY_ERROR_CODE, eventInfo.errCode);
350 break;
351 default:
352 break;
353 }
354 }
355
SendKeyEvent(const EventName & eventName,HiSysEventType type,const EventInfo & eventInfo)356 void EventReport::SendKeyEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
357 {
358 std::string name = ConvertEventName(eventName);
359 if (name == INVALID_EVENT_NAME) {
360 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
361 return;
362 }
363 TAG_LOGI(AAFwkTag::DEFAULT, "name: %{public}s", name.c_str());
364 switch (eventName) {
365 case EventName::FA_SHOW_ON_LOCK:
366 case EventName::START_PRIVATE_ABILITY:
367 HiSysEventWrite(
368 HiSysEvent::Domain::AAFWK,
369 name,
370 type,
371 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
372 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
373 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
374 break;
375 case EventName::RESTART_PROCESS_BY_SAME_APP:
376 HiSysEventWrite(
377 HiSysEvent::Domain::AAFWK,
378 name,
379 type,
380 EVENT_KEY_RESTART_TIME, eventInfo.time,
381 EVENT_KEY_APP_UID, eventInfo.appUid,
382 EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName,
383 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
384 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName);
385 break;
386 default:
387 break;
388 }
389 }
390
SendAppLaunchEvent(const EventName & eventName,const EventInfo & eventInfo)391 void EventReport::SendAppLaunchEvent(const EventName &eventName, const EventInfo &eventInfo)
392 {
393 std::string name = ConvertEventName(eventName);
394 if (name == INVALID_EVENT_NAME) {
395 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
396 return;
397 }
398 HiSysEventWrite(
399 HiSysEvent::Domain::AAFWK,
400 name,
401 HiSysEventType::BEHAVIOR,
402 EVENT_KEY_APP_PID, eventInfo.pid,
403 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
404 EVENT_KEY_VERSION_NAME, eventInfo.versionName,
405 EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
406 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
407 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
408 EVENT_KEY_CALLER_VERSION_NAME, eventInfo.callerVersionName,
409 EVENT_KEY_CALLER_VERSION_CODE, eventInfo.callerVersionCode,
410 EVENT_KEY_CALLER_UID, eventInfo.callerUid,
411 EVENT_KEY_CALLER_STATE, eventInfo.callerState);
412 }
413
SendAppForegroundEvent(const EventName & eventName,const EventInfo & eventInfo)414 void EventReport::SendAppForegroundEvent(const EventName &eventName, const EventInfo &eventInfo)
415 {
416 std::string name = ConvertEventName(eventName);
417 if (name == INVALID_EVENT_NAME) {
418 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
419 return;
420 }
421 auto ret = HiSysEventWrite(
422 HiSysEvent::Domain::AAFWK,
423 name,
424 HiSysEventType::BEHAVIOR,
425 EVENT_KEY_APP_PID, eventInfo.pid,
426 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
427 EVENT_KEY_VERSION_NAME, eventInfo.versionName,
428 EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
429 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
430 EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType,
431 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
432 EVENT_KEY_PROCESS_TYPE, eventInfo.processType);
433 if (ret != 0) {
434 TAG_LOGE(AAFwkTag::DEFAULT, "fail: %{public}s, ret %{public}d", name.c_str(), ret);
435 }
436 }
437
SendAppBackgroundEvent(const EventName & eventName,const EventInfo & eventInfo)438 void EventReport::SendAppBackgroundEvent(const EventName &eventName, const EventInfo &eventInfo)
439 {
440 std::string name = ConvertEventName(eventName);
441 if (name == INVALID_EVENT_NAME) {
442 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
443 return;
444 }
445 auto ret = HiSysEventWrite(
446 HiSysEvent::Domain::AAFWK,
447 name,
448 HiSysEventType::BEHAVIOR,
449 EVENT_KEY_APP_PID, eventInfo.pid,
450 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
451 EVENT_KEY_VERSION_NAME, eventInfo.versionName,
452 EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
453 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
454 EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType,
455 EVENT_KEY_PROCESS_TYPE, eventInfo.processType);
456 if (ret != 0) {
457 TAG_LOGE(AAFwkTag::DEFAULT, "fail: %{public}s, ret %{public}d", name.c_str(), ret);
458 }
459 }
460
SendProcessStartEvent(const EventName & eventName,const EventInfo & eventInfo)461 void EventReport::SendProcessStartEvent(const EventName &eventName, const EventInfo &eventInfo)
462 {
463 constexpr int32_t defaultVal = -1;
464 std::string name = ConvertEventName(eventName);
465 if (name == INVALID_EVENT_NAME) {
466 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
467 return;
468 }
469 if (eventInfo.extensionType == defaultVal) {
470 HiSysEventWrite(
471 HiSysEvent::Domain::AAFWK,
472 name,
473 HiSysEventType::BEHAVIOR,
474 EVENT_KEY_STARTUP_TIME, eventInfo.time,
475 EVENT_KEY_STARTUP_ABILITY_TYPE, eventInfo.abilityType,
476 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
477 EVENT_KEY_CALLER_UID, eventInfo.callerUid,
478 EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName,
479 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
480 EVENT_KEY_PID, eventInfo.pid,
481 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
482 EVENT_KEY_CALLER_PROCESS_ID, eventInfo.callerPid);
483 } else {
484 HiSysEventWrite(
485 HiSysEvent::Domain::AAFWK,
486 name,
487 HiSysEventType::BEHAVIOR,
488 EVENT_KEY_STARTUP_TIME, eventInfo.time,
489 EVENT_KEY_STARTUP_ABILITY_TYPE, eventInfo.abilityType,
490 EVENT_KEY_STARTUP_EXTENSION_TYPE, eventInfo.extensionType,
491 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
492 EVENT_KEY_CALLER_UID, eventInfo.callerUid,
493 EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName,
494 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
495 EVENT_KEY_PID, eventInfo.pid,
496 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
497 EVENT_KEY_CALLER_PROCESS_ID, eventInfo.callerPid);
498 }
499 }
500
SendProcessStartFailedEvent(const EventName & eventName,const EventInfo & eventInfo)501 void EventReport::SendProcessStartFailedEvent(const EventName &eventName, const EventInfo &eventInfo)
502 {
503 std::string name = ConvertEventName(eventName);
504 if (name == INVALID_EVENT_NAME) {
505 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
506 return;
507 }
508 TAG_LOGD(AAFwkTag::DEFAULT, "eventName:%{public}s,processName:%{public}s,reason:%{public}d,subReason:%{public}d",
509 name.c_str(), eventInfo.processName.c_str(), eventInfo.reason, eventInfo.subReason);
510 if (eventInfo.extensionType == DEFAULT_EXTENSION_TYPE) {
511 HiSysEventWrite(
512 HiSysEvent::Domain::AAFWK,
513 name,
514 HiSysEventType::FAULT,
515 EVENT_KEY_STARTUP_TIME, eventInfo.time,
516 EVENT_KEY_STARTUP_ABILITY_TYPE, eventInfo.abilityType,
517 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
518 EVENT_KEY_CALLER_UID, eventInfo.callerUid,
519 EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName,
520 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
521 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
522 EVENT_KEY_CALLER_PROCESS_ID, eventInfo.callerPid,
523 EVENT_KEY_PROCESS_TYPE, eventInfo.processType,
524 EVENT_KEY_REASON, eventInfo.reason,
525 EVENT_KEY_SUB_REASON, eventInfo.subReason);
526 } else {
527 HiSysEventWrite(
528 HiSysEvent::Domain::AAFWK,
529 name,
530 HiSysEventType::FAULT,
531 EVENT_KEY_STARTUP_TIME, eventInfo.time,
532 EVENT_KEY_STARTUP_ABILITY_TYPE, eventInfo.abilityType,
533 EVENT_KEY_STARTUP_EXTENSION_TYPE, eventInfo.extensionType,
534 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
535 EVENT_KEY_CALLER_UID, eventInfo.callerUid,
536 EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName,
537 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
538 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
539 EVENT_KEY_CALLER_PROCESS_ID, eventInfo.callerPid,
540 EVENT_KEY_PROCESS_TYPE, eventInfo.processType,
541 EVENT_KEY_REASON, eventInfo.reason,
542 EVENT_KEY_SUB_REASON, eventInfo.subReason);
543 }
544 }
545
SendProcessExitEvent(const EventName & eventName,const EventInfo & eventInfo)546 void EventReport::SendProcessExitEvent(const EventName &eventName, const EventInfo &eventInfo)
547 {
548 std::string name = ConvertEventName(eventName);
549 if (name == INVALID_EVENT_NAME) {
550 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
551 return;
552 }
553 HiSysEventWrite(
554 HiSysEvent::Domain::AAFWK,
555 name,
556 HiSysEventType::BEHAVIOR,
557 EVENT_KEY_EXIT_TIME, eventInfo.time,
558 EVENT_KEY_EXIT_RESULT, eventInfo.exitResult,
559 EVENT_KEY_EXIT_PID, eventInfo.pid,
560 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
561 EVENT_KEY_EXTENSION_TYPE, eventInfo.extensionType,
562 EVENT_KEY_EXIT_REASON, eventInfo.exitReason);
563 }
564
SendStartServiceEvent(const EventName & eventName,const EventInfo & eventInfo)565 void EventReport::SendStartServiceEvent(const EventName &eventName, const EventInfo &eventInfo)
566 {
567 std::string name = ConvertEventName(eventName);
568 if (name == INVALID_EVENT_NAME) {
569 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
570 return;
571 }
572 HiSysEventWrite(
573 HiSysEvent::Domain::AAFWK,
574 name,
575 HiSysEventType::BEHAVIOR,
576 EVENT_KEY_TIME, eventInfo.time,
577 EVENT_KEY_USERID, eventInfo.userId,
578 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
579 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
580 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
581 EVENT_KEY_EXTENSION_TYPE, eventInfo.extensionType,
582 EVENT_KEY_PID, eventInfo.pid,
583 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
584 EVENT_KEY_CALLER_PROCESS_ID, eventInfo.callerPid,
585 EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName);
586 }
587
SendStopServiceEvent(const EventName & eventName,const EventInfo & eventInfo)588 void EventReport::SendStopServiceEvent(const EventName &eventName, const EventInfo &eventInfo)
589 {
590 std::string name = ConvertEventName(eventName);
591 if (name == INVALID_EVENT_NAME) {
592 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
593 return;
594 }
595 HiSysEventWrite(
596 HiSysEvent::Domain::AAFWK,
597 name,
598 HiSysEventType::BEHAVIOR,
599 EVENT_KEY_USERID, eventInfo.userId,
600 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
601 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
602 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
603 EVENT_KEY_EXTENSION_TYPE, eventInfo.extensionType,
604 EVENT_KEY_TIME, eventInfo.time,
605 EVENT_KEY_PID, eventInfo.pid,
606 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
607 EVENT_KEY_CALLER_PROCESS_ID, eventInfo.callerPid,
608 EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName);
609 }
610
SendConnectServiceEvent(const EventName & eventName,const EventInfo & eventInfo)611 void EventReport::SendConnectServiceEvent(const EventName &eventName, const EventInfo &eventInfo)
612 {
613 std::string name = ConvertEventName(eventName);
614 if (name == INVALID_EVENT_NAME) {
615 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
616 return;
617 }
618 HiSysEventWrite(
619 HiSysEvent::Domain::AAFWK,
620 name,
621 HiSysEventType::BEHAVIOR,
622 EVENT_KEY_TIME, eventInfo.time,
623 EVENT_KEY_USERID, eventInfo.userId,
624 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
625 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
626 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
627 EVENT_KEY_PID, eventInfo.pid,
628 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
629 EVENT_KEY_CALLER_PROCESS_ID, eventInfo.callerPid,
630 EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName);
631 }
632
SendDisconnectServiceEvent(const EventName & eventName,const EventInfo & eventInfo)633 void EventReport::SendDisconnectServiceEvent(const EventName &eventName, const EventInfo &eventInfo)
634 {
635 std::string name = ConvertEventName(eventName);
636 if (name == INVALID_EVENT_NAME) {
637 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
638 return;
639 }
640 HiSysEventWrite(HiSysEvent::Domain::AAFWK,
641 name,
642 HiSysEventType::BEHAVIOR,
643 EVENT_KEY_TIME, eventInfo.time,
644 EVENT_KEY_PID, eventInfo.pid,
645 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
646 EVENT_KEY_CALLER_PROCESS_ID, eventInfo.callerPid,
647 EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName);
648 }
649
SendStartAbilityOtherExtensionEvent(const EventName & eventName,const EventInfo & eventInfo)650 void EventReport::SendStartAbilityOtherExtensionEvent(const EventName &eventName, const EventInfo &eventInfo)
651 {
652 std::string name = ConvertEventName(eventName);
653 if (name == INVALID_EVENT_NAME) {
654 TAG_LOGE(AAFwkTag::DEFAULT, "invalid eventName");
655 return;
656 }
657 HiSysEventWrite(HiSysEvent::Domain::AAFWK,
658 name,
659 HiSysEventType::BEHAVIOR,
660 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
661 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
662 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
663 EVENT_KEY_EXTENSION_TYPE, eventInfo.extensionType,
664 // Historical reason: Word spelling error during event definition
665 "CALLER_BUNLED_NAME", eventInfo.callerBundleName);
666 }
667
ConvertEventName(const EventName & eventName)668 std::string EventReport::ConvertEventName(const EventName &eventName)
669 {
670 const char* eventNames[] = {
671 // fault event
672 "START_ABILITY_ERROR", "TERMINATE_ABILITY_ERROR", "START_EXTENSION_ERROR",
673 "STOP_EXTENSION_ERROR", "CONNECT_SERVICE_ERROR", "DISCONNECT_SERVICE_ERROR",
674
675 // ability behavior event
676 "START_ABILITY", "TERMINATE_ABILITY", "CLOSE_ABILITY",
677 "ABILITY_ONFOREGROUND", "ABILITY_ONBACKGROUND", "ABILITY_ONACTIVE", "ABILITY_ONINACTIVE",
678 "START_ABILITY_BY_APP_LINKING",
679
680 // serviceExtensionAbility behavior event
681 "START_SERVICE", "STOP_SERVICE", "CONNECT_SERVICE", "DISCONNECT_SERVICE", "START_ABILITY_OTHER_EXTENSION",
682
683 // app behavior event
684 "APP_ATTACH", "APP_LAUNCH", "APP_FOREGROUND", "APP_BACKGROUND", "APP_TERMINATE",
685 "PROCESS_START", "PROCESS_EXIT", "DRAWN_COMPLETED", "APP_STARTUP_TYPE", "PROCESS_START_FAILED",
686
687 // key behavior event
688 "GRANT_URI_PERMISSION", "FA_SHOW_ON_LOCK", "START_PRIVATE_ABILITY",
689 "RESTART_PROCESS_BY_SAME_APP", "START_STANDARD_ABILITIES",
690
691 // atomic service event
692 "CREATE_ATOMIC_SERVICE_PROCESS", "ATOMIC_SERVICE_DRAWN_COMPLETE",
693
694 // uri permission
695 "SHARE_UNPRIVILEGED_FILE_URI"
696 };
697 uint32_t eventIndex = static_cast<uint32_t> (eventName);
698 if (eventIndex >= sizeof(eventNames) / sizeof(const char*)) {
699 return INVALID_EVENT_NAME;
700 }
701 return eventNames[eventIndex];
702 }
703 } // namespace AAFwk
704 } // namespace OHOS
705