1 /*
2 * Copyright (c) 2022-2023 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 <map>
17
18 #include "event_report.h"
19 #include "hilog_wrapper.h"
20
21 namespace OHOS {
22 namespace AAFwk {
23 namespace {
24 // event params
25 constexpr const char *EVENT_KEY_APP_PID = "APP_PID";
26 constexpr const char *EVENT_KEY_USERID = "USER_ID";
27 constexpr const char *EVENT_KEY_ERROR_CODE = "ERROR_CODE";
28 constexpr const char *EVENT_KEY_BUNDLE_NAME = "BUNDLE_NAME";
29 constexpr const char *EVENT_KEY_MODULE_NAME = "MODULE_NAME";
30 constexpr const char *EVENT_KEY_ABILITY_NAME = "ABILITY_NAME";
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_EXIT_TIME = "EXIT_TIME";
43 constexpr const char *EVENT_KEY_EXIT_RESULT = "EXIT_RESULT";
44 constexpr const char *EVENT_KEY_EXIT_PID = "EXIT_PID";
45 constexpr const char *EVENT_KEY_BUNDLE_TYPE = "BUNDLE_TYPE";
46 constexpr const char *EVENT_KEY_START_TYPE = "START_TYPE";
47 constexpr const char *EVENT_KEY_CALLER_STATE = "CALLER_STATE";
48 constexpr const char *EVENT_KEY_CALLER_VERSION_NAME = "CALLER_VERSION_NAME";
49 constexpr const char *EVENT_KEY_CALLER_VERSION_CODE = "CALLER_VERSION_CODE";
50 constexpr const char *EVENT_KEY_URI = "URI";
51 constexpr const char *EVENT_KEY_RESTART_TIME = "RESTART_TIME";
52 constexpr const char *EVENT_KEY_APP_UID = "APP_UID";
53 constexpr const char *EVENT_KEY_PROCESS_TYPE = "PROCESS_TYPE";
54 const std::map<EventName, std::string> eventNameToStrMap_ = {
55 std::map<EventName, std::string>::value_type(EventName::START_ABILITY_ERROR, "START_ABILITY_ERROR"),
56 std::map<EventName, std::string>::value_type(EventName::TERMINATE_ABILITY_ERROR, "TERMINATE_ABILITY_ERROR"),
57 std::map<EventName, std::string>::value_type(EventName::START_EXTENSION_ERROR, "START_EXTENSION_ERROR"),
58 std::map<EventName, std::string>::value_type(EventName::STOP_EXTENSION_ERROR, "STOP_EXTENSION_ERROR"),
59 std::map<EventName, std::string>::value_type(EventName::CONNECT_SERVICE_ERROR, "CONNECT_SERVICE_ERROR"),
60 std::map<EventName, std::string>::value_type(EventName::DISCONNECT_SERVICE_ERROR, "DISCONNECT_SERVICE_ERROR"),
61 std::map<EventName, std::string>::value_type(EventName::START_ABILITY, "START_ABILITY"),
62 std::map<EventName, std::string>::value_type(EventName::TERMINATE_ABILITY, "TERMINATE_ABILITY"),
63 std::map<EventName, std::string>::value_type(EventName::CLOSE_ABILITY, "CLOSE_ABILITY"),
64 std::map<EventName, std::string>::value_type(EventName::ABILITY_ONFOREGROUND, "ABILITY_ONFOREGROUND"),
65 std::map<EventName, std::string>::value_type(EventName::ABILITY_ONBACKGROUND, "ABILITY_ONBACKGROUND"),
66 std::map<EventName, std::string>::value_type(EventName::ABILITY_ONACTIVE, "ABILITY_ONACTIVE"),
67 std::map<EventName, std::string>::value_type(EventName::ABILITY_ONINACTIVE, "ABILITY_ONINACTIVE"),
68 std::map<EventName, std::string>::value_type(EventName::START_SERVICE, "START_SERVICE"),
69 std::map<EventName, std::string>::value_type(EventName::STOP_SERVICE, "STOP_SERVICE"),
70 std::map<EventName, std::string>::value_type(EventName::CONNECT_SERVICE, "CONNECT_SERVICE"),
71 std::map<EventName, std::string>::value_type(EventName::DISCONNECT_SERVICE, "DISCONNECT_SERVICE"),
72 std::map<EventName, std::string>::value_type(EventName::APP_ATTACH, "APP_ATTACH"),
73 std::map<EventName, std::string>::value_type(EventName::APP_LAUNCH, "APP_LAUNCH"),
74 std::map<EventName, std::string>::value_type(EventName::APP_FOREGROUND, "APP_FOREGROUND"),
75 std::map<EventName, std::string>::value_type(EventName::APP_BACKGROUND, "APP_BACKGROUND"),
76 std::map<EventName, std::string>::value_type(EventName::APP_TERMINATE, "APP_TERMINATE"),
77 std::map<EventName, std::string>::value_type(EventName::PROCESS_START, "PROCESS_START"),
78 std::map<EventName, std::string>::value_type(EventName::PROCESS_EXIT, "PROCESS_EXIT"),
79 std::map<EventName, std::string>::value_type(EventName::DRAWN_COMPLETED, "DRAWN_COMPLETED"),
80 std::map<EventName, std::string>::value_type(EventName::APP_STARTUP_TYPE, "APP_STARTUP_TYPE"),
81 std::map<EventName, std::string>::value_type(EventName::GRANT_URI_PERMISSION, "GRANT_URI_PERMISSION"),
82 std::map<EventName, std::string>::value_type(EventName::FA_SHOW_ON_LOCK, "FA_SHOW_ON_LOCK"),
83 std::map<EventName, std::string>::value_type(EventName::START_PRIVATE_ABILITY, "START_PRIVATE_ABILITY"),
84 std::map<EventName, std::string>::value_type(EventName::RESTART_PROCESS_BY_SAME_APP,
85 "RESTART_PROCESS_BY_SAME_APP"),
86 };
87 }
88
SendAppEvent(const EventName & eventName,HiSysEventType type,const EventInfo & eventInfo)89 void EventReport::SendAppEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
90 {
91 constexpr int32_t defaultVal = -1;
92 std::string name = ConvertEventName(eventName);
93 if (name == "INVALIDEVENTNAME") {
94 HILOG_ERROR("invalid eventName");
95 return;
96 }
97 switch (eventName) {
98 case EventName::PROCESS_START:
99 if (eventInfo.extensionType == defaultVal) {
100 HiSysEventWrite(
101 HiSysEvent::Domain::AAFWK,
102 name,
103 type,
104 EVENT_KEY_STARTUP_TIME, eventInfo.time,
105 EVENT_KEY_STARTUP_ABILITY_TYPE, eventInfo.abilityType,
106 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
107 EVENT_KEY_CALLER_UID, eventInfo.callerUid,
108 EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName,
109 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName);
110 } else {
111 HiSysEventWrite(
112 HiSysEvent::Domain::AAFWK,
113 name,
114 type,
115 EVENT_KEY_STARTUP_TIME, eventInfo.time,
116 EVENT_KEY_STARTUP_ABILITY_TYPE, eventInfo.abilityType,
117 EVENT_KEY_STARTUP_EXTENSION_TYPE, eventInfo.extensionType,
118 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
119 EVENT_KEY_CALLER_UID, eventInfo.callerUid,
120 EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName,
121 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName);
122 }
123 break;
124 case EventName::PROCESS_EXIT:
125 HiSysEventWrite(
126 HiSysEvent::Domain::AAFWK,
127 name,
128 type,
129 EVENT_KEY_EXIT_TIME, eventInfo.time,
130 EVENT_KEY_EXIT_RESULT, eventInfo.exitResult,
131 EVENT_KEY_EXIT_PID, eventInfo.pid);
132 break;
133 case EventName::APP_STARTUP_TYPE:
134 HiSysEventWrite(
135 HiSysEvent::Domain::AAFWK,
136 name,
137 type,
138 EVENT_KEY_APP_PID, eventInfo.pid,
139 EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
140 EVENT_KEY_VERSION_NAME, eventInfo.versionName,
141 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
142 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
143 EVENT_KEY_START_TYPE, eventInfo.startType);
144 break;
145 case EventName::APP_FOREGROUND:
146 HiSysEventWrite(
147 HiSysEvent::Domain::AAFWK,
148 name,
149 type,
150 EVENT_KEY_APP_PID, eventInfo.pid,
151 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
152 EVENT_KEY_VERSION_NAME, eventInfo.versionName,
153 EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
154 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
155 EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType,
156 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
157 EVENT_KEY_PROCESS_TYPE, eventInfo.processType);
158 break;
159 case EventName::APP_BACKGROUND:
160 HiSysEventWrite(
161 HiSysEvent::Domain::AAFWK,
162 name,
163 type,
164 EVENT_KEY_APP_PID, eventInfo.pid,
165 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
166 EVENT_KEY_VERSION_NAME, eventInfo.versionName,
167 EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
168 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
169 EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType,
170 EVENT_KEY_PROCESS_TYPE, eventInfo.processType);
171 break;
172 case EventName::DRAWN_COMPLETED:
173 HILOG_INFO("HiSysEvent name: DRAWN_COMPLETED, bundleName: %{public}s, abilityName: %{public}s",
174 eventInfo.bundleName.c_str(), eventInfo.abilityName.c_str());
175 HiSysEventWrite(
176 HiSysEvent::Domain::AAFWK,
177 name,
178 type,
179 EVENT_KEY_USERID, eventInfo.userId,
180 EVENT_KEY_APP_PID, eventInfo.pid,
181 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
182 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
183 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
184 break;
185 case EventName::APP_LAUNCH:
186 HiSysEventWrite(
187 HiSysEvent::Domain::AAFWK,
188 name,
189 type,
190 EVENT_KEY_APP_PID, eventInfo.pid,
191 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
192 EVENT_KEY_VERSION_NAME, eventInfo.versionName,
193 EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
194 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
195 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
196 EVENT_KEY_CALLER_VERSION_NAME, eventInfo.callerVersionName,
197 EVENT_KEY_CALLER_VERSION_CODE, eventInfo.callerVersionCode,
198 EVENT_KEY_CALLER_UID, eventInfo.callerUid,
199 EVENT_KEY_CALLER_STATE, eventInfo.callerState);
200 break;
201 default:
202 HiSysEventWrite(
203 HiSysEvent::Domain::AAFWK,
204 name,
205 type,
206 EVENT_KEY_APP_PID, eventInfo.pid,
207 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
208 EVENT_KEY_VERSION_NAME, eventInfo.versionName,
209 EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
210 EVENT_KEY_PROCESS_NAME, eventInfo.processName);
211 break;
212 }
213 }
214
SendAbilityEvent(const EventName & eventName,HiSysEventType type,const EventInfo & eventInfo)215 void EventReport::SendAbilityEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
216 {
217 std::string name = ConvertEventName(eventName);
218 if (name == "INVALIDEVENTNAME") {
219 HILOG_ERROR("invalid eventName");
220 return;
221 }
222 switch (eventName) {
223 case EventName::START_ABILITY_ERROR:
224 case EventName::TERMINATE_ABILITY_ERROR:
225 HiSysEventWrite(
226 HiSysEvent::Domain::AAFWK,
227 name,
228 type,
229 EVENT_KEY_USERID, eventInfo.userId,
230 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
231 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
232 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
233 EVENT_KEY_ERROR_CODE, eventInfo.errCode);
234 break;
235 case EventName::START_ABILITY:
236 HiSysEventWrite(
237 HiSysEvent::Domain::AAFWK,
238 name,
239 type,
240 EVENT_KEY_USERID, eventInfo.userId,
241 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
242 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
243 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
244 break;
245 case EventName::TERMINATE_ABILITY:
246 case EventName::CLOSE_ABILITY:
247 HiSysEventWrite(
248 HiSysEvent::Domain::AAFWK,
249 name,
250 type,
251 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
252 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
253 break;
254 case EventName::ABILITY_ONFOREGROUND:
255 HiSysEventWrite(
256 HiSysEvent::Domain::AAFWK,
257 name,
258 type,
259 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
260 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
261 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
262 EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType,
263 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName);
264 break;
265 case EventName::ABILITY_ONBACKGROUND:
266 case EventName::ABILITY_ONINACTIVE:
267 HiSysEventWrite(
268 HiSysEvent::Domain::AAFWK,
269 name,
270 type,
271 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
272 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
273 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
274 EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType);
275 break;
276 case EventName::ABILITY_ONACTIVE:
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_ABILITY_TYPE, eventInfo.abilityType,
285 EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType,
286 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName);
287 break;
288 default:
289 break;
290 }
291 }
292
SendExtensionEvent(const EventName & eventName,HiSysEventType type,const EventInfo & eventInfo)293 void EventReport::SendExtensionEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
294 {
295 std::string name = ConvertEventName(eventName);
296 if (name == "INVALIDEVENTNAME") {
297 HILOG_ERROR("invalid eventName");
298 return;
299 }
300 switch (eventName) {
301 case EventName::DISCONNECT_SERVICE:
302 HiSysEventWrite(HiSysEvent::Domain::AAFWK, name, type);
303 break;
304 case EventName::CONNECT_SERVICE:
305 HiSysEventWrite(
306 HiSysEvent::Domain::AAFWK,
307 name,
308 type,
309 EVENT_KEY_USERID, eventInfo.userId,
310 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
311 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
312 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
313 break;
314 case EventName::START_SERVICE:
315 case EventName::STOP_SERVICE:
316 HiSysEventWrite(
317 HiSysEvent::Domain::AAFWK,
318 name,
319 type,
320 EVENT_KEY_USERID, eventInfo.userId,
321 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
322 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
323 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
324 EVENT_KEY_EXTENSION_TYPE, eventInfo.extensionType);
325 break;
326 case EventName::START_EXTENSION_ERROR:
327 case EventName::STOP_EXTENSION_ERROR:
328 case EventName::CONNECT_SERVICE_ERROR:
329 HiSysEventWrite(
330 HiSysEvent::Domain::AAFWK,
331 name,
332 type,
333 EVENT_KEY_USERID, eventInfo.userId,
334 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
335 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
336 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
337 EVENT_KEY_ERROR_CODE, eventInfo.errCode);
338 break;
339 case EventName::DISCONNECT_SERVICE_ERROR:
340 HiSysEventWrite(HiSysEvent::Domain::AAFWK, name, type, EVENT_KEY_ERROR_CODE, eventInfo.errCode);
341 break;
342 default:
343 break;
344 }
345 }
346
SendKeyEvent(const EventName & eventName,HiSysEventType type,const EventInfo & eventInfo)347 void EventReport::SendKeyEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
348 {
349 std::string name = ConvertEventName(eventName);
350 if (name == "INVALIDEVENTNAME") {
351 HILOG_ERROR("invalid eventName");
352 return;
353 }
354 HILOG_INFO("name is %{public}s", name.c_str());
355 switch (eventName) {
356 case EventName::GRANT_URI_PERMISSION:
357 HiSysEventWrite(
358 HiSysEvent::Domain::AAFWK,
359 name,
360 type,
361 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
362 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
363 EVENT_KEY_URI, eventInfo.uri);
364 break;
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
ConvertEventName(const EventName & eventName)391 std::string EventReport::ConvertEventName(const EventName &eventName)
392 {
393 auto it = eventNameToStrMap_.find(eventName);
394 if (it != eventNameToStrMap_.end()) {
395 return it->second;
396 }
397 return "INVALIDEVENTNAME";
398 }
399 } // namespace AAFwk
400 } // namespace OHOS
401