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