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 const std::map<EventName, std::string> eventNameToStrMap_ = {
48 std::map<EventName, std::string>::value_type(EventName::START_ABILITY_ERROR, "START_ABILITY_ERROR"),
49 std::map<EventName, std::string>::value_type(EventName::TERMINATE_ABILITY_ERROR, "TERMINATE_ABILITY_ERROR"),
50 std::map<EventName, std::string>::value_type(EventName::START_EXTENSION_ERROR, "START_EXTENSION_ERROR"),
51 std::map<EventName, std::string>::value_type(EventName::STOP_EXTENSION_ERROR, "STOP_EXTENSION_ERROR"),
52 std::map<EventName, std::string>::value_type(EventName::CONNECT_SERVICE_ERROR, "CONNECT_SERVICE_ERROR"),
53 std::map<EventName, std::string>::value_type(EventName::DISCONNECT_SERVICE_ERROR, "DISCONNECT_SERVICE_ERROR"),
54 std::map<EventName, std::string>::value_type(EventName::START_ABILITY, "START_ABILITY"),
55 std::map<EventName, std::string>::value_type(EventName::TERMINATE_ABILITY, "TERMINATE_ABILITY"),
56 std::map<EventName, std::string>::value_type(EventName::CLOSE_ABILITY, "CLOSE_ABILITY"),
57 std::map<EventName, std::string>::value_type(EventName::ABILITY_ONFOREGROUND, "ABILITY_ONFOREGROUND"),
58 std::map<EventName, std::string>::value_type(EventName::ABILITY_ONBACKGROUND, "ABILITY_ONBACKGROUND"),
59 std::map<EventName, std::string>::value_type(EventName::ABILITY_ONACTIVE, "ABILITY_ONACTIVE"),
60 std::map<EventName, std::string>::value_type(EventName::ABILITY_ONINACTIVE, "ABILITY_ONINACTIVE"),
61 std::map<EventName, std::string>::value_type(EventName::START_SERVICE, "START_SERVICE"),
62 std::map<EventName, std::string>::value_type(EventName::STOP_SERVICE, "STOP_SERVICE"),
63 std::map<EventName, std::string>::value_type(EventName::CONNECT_SERVICE, "CONNECT_SERVICE"),
64 std::map<EventName, std::string>::value_type(EventName::DISCONNECT_SERVICE, "DISCONNECT_SERVICE"),
65 std::map<EventName, std::string>::value_type(EventName::APP_ATTACH, "APP_ATTACH"),
66 std::map<EventName, std::string>::value_type(EventName::APP_LAUNCH, "APP_LAUNCH"),
67 std::map<EventName, std::string>::value_type(EventName::APP_FOREGROUND, "APP_FOREGROUND"),
68 std::map<EventName, std::string>::value_type(EventName::APP_BACKGROUND, "APP_BACKGROUND"),
69 std::map<EventName, std::string>::value_type(EventName::APP_TERMINATE, "APP_TERMINATE"),
70 std::map<EventName, std::string>::value_type(EventName::PROCESS_START, "PROCESS_START"),
71 std::map<EventName, std::string>::value_type(EventName::PROCESS_EXIT, "PROCESS_EXIT"),
72 std::map<EventName, std::string>::value_type(EventName::DRAWN_COMPLETED, "DRAWN_COMPLETED"),
73 std::map<EventName, std::string>::value_type(EventName::APP_STARTUP_TYPE, "APP_STARTUP_TYPE"),
74 };
75 }
76
SendAppEvent(const EventName & eventName,HiSysEventType type,const EventInfo & eventInfo)77 void EventReport::SendAppEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
78 {
79 constexpr int32_t defaultVal = -1;
80 std::string name = ConvertEventName(eventName);
81 if (name == "INVALIDEVENTNAME") {
82 HILOG_ERROR("invalid eventName");
83 return;
84 }
85 switch (eventName) {
86 case EventName::PROCESS_START:
87 if (eventInfo.extensionType == defaultVal) {
88 HiSysEventWrite(
89 HiSysEvent::Domain::AAFWK,
90 name,
91 type,
92 EVENT_KEY_STARTUP_TIME, eventInfo.time,
93 EVENT_KEY_STARTUP_ABILITY_TYPE, eventInfo.abilityType,
94 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
95 EVENT_KEY_CALLER_UID, eventInfo.callerUid,
96 EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName,
97 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName);
98 } else {
99 HiSysEventWrite(
100 HiSysEvent::Domain::AAFWK,
101 name,
102 type,
103 EVENT_KEY_STARTUP_TIME, eventInfo.time,
104 EVENT_KEY_STARTUP_ABILITY_TYPE, eventInfo.abilityType,
105 EVENT_KEY_STARTUP_EXTENSION_TYPE, eventInfo.extensionType,
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 }
111 break;
112 case EventName::PROCESS_EXIT:
113 HiSysEventWrite(
114 HiSysEvent::Domain::AAFWK,
115 name,
116 type,
117 EVENT_KEY_EXIT_TIME, eventInfo.time,
118 EVENT_KEY_EXIT_RESULT, eventInfo.exitResult,
119 EVENT_KEY_EXIT_PID, eventInfo.pid);
120 break;
121 case EventName::APP_STARTUP_TYPE:
122 HiSysEventWrite(
123 HiSysEvent::Domain::AAFWK,
124 name,
125 type,
126 EVENT_KEY_APP_PID, eventInfo.pid,
127 EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
128 EVENT_KEY_VERSION_NAME, eventInfo.versionName,
129 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
130 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
131 EVENT_KEY_START_TYPE, eventInfo.startType);
132 break;
133 case EventName::APP_FOREGROUND:
134 HiSysEventWrite(
135 HiSysEvent::Domain::AAFWK,
136 name,
137 type,
138 EVENT_KEY_APP_PID, eventInfo.pid,
139 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
140 EVENT_KEY_VERSION_NAME, eventInfo.versionName,
141 EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
142 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
143 EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType,
144 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName);
145 break;
146 case EventName::APP_BACKGROUND:
147 HiSysEventWrite(
148 HiSysEvent::Domain::AAFWK,
149 name,
150 type,
151 EVENT_KEY_APP_PID, eventInfo.pid,
152 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
153 EVENT_KEY_VERSION_NAME, eventInfo.versionName,
154 EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
155 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
156 EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType);
157 break;
158 case EventName::DRAWN_COMPLETED:
159 HiSysEventWrite(
160 HiSysEvent::Domain::AAFWK,
161 name,
162 type,
163 EVENT_KEY_USERID, eventInfo.userId,
164 EVENT_KEY_APP_PID, eventInfo.pid,
165 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
166 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
167 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
168 break;
169 case EventName::APP_LAUNCH:
170 HiSysEventWrite(
171 HiSysEvent::Domain::AAFWK,
172 name,
173 type,
174 EVENT_KEY_APP_PID, eventInfo.pid,
175 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
176 EVENT_KEY_VERSION_NAME, eventInfo.versionName,
177 EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
178 EVENT_KEY_PROCESS_NAME, eventInfo.processName,
179 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName);
180 break;
181 default:
182 HiSysEventWrite(
183 HiSysEvent::Domain::AAFWK,
184 name,
185 type,
186 EVENT_KEY_APP_PID, eventInfo.pid,
187 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
188 EVENT_KEY_VERSION_NAME, eventInfo.versionName,
189 EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
190 EVENT_KEY_PROCESS_NAME, eventInfo.processName);
191 break;
192 }
193 }
194
SendAbilityEvent(const EventName & eventName,HiSysEventType type,const EventInfo & eventInfo)195 void EventReport::SendAbilityEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
196 {
197 std::string name = ConvertEventName(eventName);
198 if (name == "INVALIDEVENTNAME") {
199 HILOG_ERROR("invalid eventName");
200 return;
201 }
202 switch (eventName) {
203 case EventName::START_ABILITY_ERROR:
204 case EventName::TERMINATE_ABILITY_ERROR:
205 HiSysEventWrite(
206 HiSysEvent::Domain::AAFWK,
207 name,
208 type,
209 EVENT_KEY_USERID, eventInfo.userId,
210 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
211 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
212 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
213 EVENT_KEY_ERROR_CODE, eventInfo.errCode);
214 break;
215 case EventName::START_ABILITY:
216 HiSysEventWrite(
217 HiSysEvent::Domain::AAFWK,
218 name,
219 type,
220 EVENT_KEY_USERID, eventInfo.userId,
221 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
222 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
223 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
224 break;
225 case EventName::TERMINATE_ABILITY:
226 case EventName::CLOSE_ABILITY:
227 HiSysEventWrite(
228 HiSysEvent::Domain::AAFWK,
229 name,
230 type,
231 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
232 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
233 break;
234 case EventName::ABILITY_ONFOREGROUND:
235 HiSysEventWrite(
236 HiSysEvent::Domain::AAFWK,
237 name,
238 type,
239 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
240 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
241 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
242 EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType,
243 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName);
244 break;
245 case EventName::ABILITY_ONBACKGROUND:
246 case EventName::ABILITY_ONINACTIVE:
247 HiSysEventWrite(
248 HiSysEvent::Domain::AAFWK,
249 name,
250 type,
251 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
252 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
253 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
254 EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType);
255 break;
256 case EventName::ABILITY_ONACTIVE:
257 HiSysEventWrite(
258 HiSysEvent::Domain::AAFWK,
259 name,
260 type,
261 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
262 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
263 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
264 EVENT_KEY_ABILITY_TYPE, eventInfo.abilityType,
265 EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType,
266 EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName);
267 break;
268 default:
269 break;
270 }
271 }
272
SendExtensionEvent(const EventName & eventName,HiSysEventType type,const EventInfo & eventInfo)273 void EventReport::SendExtensionEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
274 {
275 std::string name = ConvertEventName(eventName);
276 if (name == "INVALIDEVENTNAME") {
277 HILOG_ERROR("invalid eventName");
278 return;
279 }
280 switch (eventName) {
281 case EventName::DISCONNECT_SERVICE:
282 HiSysEventWrite(HiSysEvent::Domain::AAFWK, name, type);
283 break;
284 case EventName::CONNECT_SERVICE:
285 HiSysEventWrite(
286 HiSysEvent::Domain::AAFWK,
287 name,
288 type,
289 EVENT_KEY_USERID, eventInfo.userId,
290 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
291 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
292 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
293 break;
294 case EventName::START_SERVICE:
295 case EventName::STOP_SERVICE:
296 HiSysEventWrite(
297 HiSysEvent::Domain::AAFWK,
298 name,
299 type,
300 EVENT_KEY_USERID, eventInfo.userId,
301 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
302 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
303 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
304 EVENT_KEY_EXTENSION_TYPE, eventInfo.extensionType);
305 break;
306 case EventName::START_EXTENSION_ERROR:
307 case EventName::STOP_EXTENSION_ERROR:
308 case EventName::CONNECT_SERVICE_ERROR:
309 HiSysEventWrite(
310 HiSysEvent::Domain::AAFWK,
311 name,
312 type,
313 EVENT_KEY_USERID, eventInfo.userId,
314 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
315 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
316 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
317 EVENT_KEY_ERROR_CODE, eventInfo.errCode);
318 break;
319 case EventName::DISCONNECT_SERVICE_ERROR:
320 HiSysEventWrite(HiSysEvent::Domain::AAFWK, name, type, EVENT_KEY_ERROR_CODE, eventInfo.errCode);
321 break;
322 default:
323 break;
324 }
325 }
326
ConvertEventName(const EventName & eventName)327 std::string EventReport::ConvertEventName(const EventName &eventName)
328 {
329 auto it = eventNameToStrMap_.find(eventName);
330 if (it != eventNameToStrMap_.end()) {
331 return it->second;
332 }
333 return "INVALIDEVENTNAME";
334 }
335 } // namespace AAFwk
336 } // namespace OHOS
337