1 /*
2 * Copyright (c) 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 "form_event_report.h"
17
18 #include <map>
19
20 #include "fms_log_wrapper.h"
21 #include "form_constants.h"
22
23 namespace OHOS {
24 namespace AppExecFwk {
25 namespace {
26 // event params
27 constexpr const char *EVENT_KEY_FORM_ID = "FORM_ID";
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_HOST_BUNDLE_NAME = "HOST_BUNDLE_NAME";
32 constexpr const char *EVENT_KEY_ERROR_TYPE = "ERROR_TYPE";
33 constexpr const char *EVENT_KEY_SESSION_ID = "SESSION_ID";
34 constexpr const char *EVENT_KEY_BIND_DURATION = "BIND_DURATION";
35 constexpr const char *EVENT_KEY_GET_DURATION = "GET_DURATION";
36 constexpr const char *EVENT_KEY_FORM_NAME = "FORM_NAME";
37 constexpr const char *EVENT_KEY_FORM_DIMENSION = "FORM_DIMENSION";
38 constexpr const char *EVENT_KEY_ACQUIRE_DURATION = "ACQUIRE_DURATION";
39 constexpr const char *EVENT_KEY_DURATION = "DURATION";
40 constexpr const char *EVENT_KEY_DURATION_TYPE = "DURATION_TYPE";
41 constexpr const char *EVENT_KEY_DAILY_REFRESH_TIMES = "DAILY_REFRESH_TIMES";
42 constexpr const char *EVENT_KEY_INVISIBLE_REFRESH_TIMES = "INVISIBLE_REFRESH_TIMES";
43 constexpr const char *EVENT_KEY_HF_REFRESH_BLOCK_TIMES = "HF_REFRESH_BLOCK_TIMES";
44 constexpr const char *EVENT_KEY_INVISIBLE_REFRESH_BLOCK_TIMES = "INVISIBLE_REFRESH_BLOCK_TIMES";
45 constexpr const char *EVENT_KEY_HILOG_REFRESH_BLOCK_TIMES = "HILOG_REFRESH_BLOCK_TIMES";
46 constexpr const char *EVENT_KEY_ACTIVE_RECOVER_REFRESH_TIMES = "ACTIVE_RECOVER_REFRESH_TIMES";
47 constexpr const char *EVENT_KEY_PASSIVER_RECOVER_REFRESH_TIMES = "PASSIVER_RECOVER_REFRESH_TIMES";
48 constexpr const char *EVENT_KEY_HF_RECOVER_REFRESH_TIMES = "HF_RECOVER_REFRESH_TIMES";
49 constexpr const char *EVENT_KEY_OFFLOAD_RECOVER_REFRESH_TIMES = "OFFLOAD_RECOVER_REFRESH_TIMER";
50 constexpr const char *EVENT_KEY_CLIENT_BUNDLE_NAME = "CLIENT_BUNDLE_NAME";
51 constexpr const char *EVENT_KEY_FORM_BUNDLE_NAME = "FORM_BUNDLE_NAME";
52 constexpr const char *EVENT_KEY_FORM_APP_PID = "FORM_APP_PID";
53 constexpr const char *EVENT_KEY_TIMESTAMP = "TIMESTAMP";
54 constexpr const char *EVENT_KEY_RENDERING_MODE = "RENDERING_MODE";
55 constexpr const char *EVENT_KEY_CONDITION_TYPE = "CONDITION_TYPE";
56 constexpr const char *EVENT_KEY_BUNDLE_FORMNAME = "BUNDLE_FORMNAME";
57 const std::map<FormEventName, std::string> EVENT_NAME_MAP = {
58 std::map<FormEventName, std::string>::value_type(FormEventName::ADD_FORM, "ADD_FORM"),
59 std::map<FormEventName, std::string>::value_type(FormEventName::REQUEST_FORM, "REQUEST_FORM"),
60 std::map<FormEventName, std::string>::value_type(FormEventName::REQUEST_FORM, "REQUEST_FORM"),
61 std::map<FormEventName, std::string>::value_type(FormEventName::DELETE_FORM, "DELETE_FORM"),
62 std::map<FormEventName, std::string>::value_type(FormEventName::CASTTEMP_FORM, "CASTTEMP_FORM"),
63 std::map<FormEventName, std::string>::value_type(FormEventName::ACQUIREFORMSTATE_FORM, "ACQUIREFORMSTATE_FORM"),
64 std::map<FormEventName, std::string>::value_type(FormEventName::MESSAGE_EVENT_FORM, "MESSAGE_EVENT_FORM"),
65 std::map<FormEventName, std::string>::value_type(FormEventName::ROUTE_EVENT_FORM, "ROUTE_EVENT_FORM"),
66 std::map<FormEventName, std::string>::value_type(FormEventName::BACKGROUND_EVENT_FORM, "BACKGROUND_EVENT_FORM"),
67 std::map<FormEventName, std::string>::value_type(FormEventName::RELEASE_FORM, "RELEASE_FORM"),
68 std::map<FormEventName, std::string>::value_type(FormEventName::DELETE_INVALID_FORM, "DELETE_INVALID_FORM"),
69 std::map<FormEventName, std::string>::value_type(
70 FormEventName::SET_NEXT_REFRESH_TIME_FORM, "SET_NEXT_REFRESH_TIME_FORM"),
71 std::map<FormEventName, std::string>::value_type(FormEventName::FORM_RENDER_BLOCK, "FORM_RENDER_BLOCK"),
72 std::map<FormEventName, std::string>::value_type(FormEventName::INIT_FMS_FAILED, "INIT_FMS_FAILED"),
73 std::map<FormEventName, std::string>::value_type(FormEventName::CALLEN_DB_FAILED, "CALLEN_DB_FAILED"),
74 std::map<FormEventName, std::string>::value_type(FormEventName::ADD_FORM_FAILED, "ADD_FORM_FAILED"),
75 std::map<FormEventName, std::string>::value_type(
76 FormEventName::FIRST_ADD_FORM_DURATION, "FIRST_ADD_FORM_DURATION"),
77 std::map<FormEventName, std::string>::value_type(
78 FormEventName::FIRST_UPDATE_FORM_DURATION, "FIRST_UPDATE_FORM_DURATION"),
79 std::map<FormEventName, std::string>::value_type(
80 FormEventName::UPDATE_FORM_REFRESH_TIMES, "UPDATE_FORM_REFRESH_TIMES"),
81 std::map<FormEventName, std::string>::value_type(FormEventName::PROXY_UPDATE_FORM, "PROXY_UPDATE_FORM"),
82 std::map<FormEventName, std::string>::value_type(
83 FormEventName::INVALID_PUBLISH_FORM_TO_HOST, "INVALID_PUBLISH_FORM_TO_HOST"),
84 std::map<FormEventName, std::string>::value_type(FormEventName::UNBIND_FORM_APP, "UNBIND_FORM_APP"),
85 std::map<FormEventName, std::string>::value_type(
86 FormEventName::CONDITION_UPDATE_FORM, "CONDITION_UPDATE_FORM"),
87 std::map<FormEventName, std::string>::value_type(
88 FormEventName::LOAD_STAGE_FORM_CONFIG_INFO, "LOAD_STAGE_FORM_CONFIG_INFO"),
89 };
90 }
91
SendFormEvent(const FormEventName & eventName,HiSysEventType type,const FormEventInfo & eventInfo)92 void FormEventReport::SendFormEvent(const FormEventName &eventName, HiSysEventType type,
93 const FormEventInfo &eventInfo)
94 {
95 std::string name = ConvertEventName(eventName);
96 if (name == "INVALIDEVENTNAME") {
97 HILOG_ERROR("invalid eventName");
98 return;
99 }
100
101 switch (eventName) {
102 case FormEventName::DELETE_INVALID_FORM:
103 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type);
104 break;
105 case FormEventName::ACQUIREFORMSTATE_FORM:
106 HiSysEventWrite(
107 HiSysEvent::Domain::FORM_MANAGER,
108 name,
109 type,
110 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
111 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
112 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
113 break;
114 case FormEventName::MESSAGE_EVENT_FORM:
115 HiSysEventWrite(
116 HiSysEvent::Domain::FORM_MANAGER,
117 name,
118 type,
119 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
120 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
121 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
122 EVENT_KEY_HOST_BUNDLE_NAME, eventInfo.hostBundleName);
123 break;
124 case FormEventName::ADD_FORM:
125 case FormEventName::ROUTE_EVENT_FORM:
126 HiSysEventWrite(
127 HiSysEvent::Domain::FORM_MANAGER, name, type,
128 EVENT_KEY_FORM_ID, eventInfo.formId,
129 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
130 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
131 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
132 EVENT_KEY_HOST_BUNDLE_NAME, eventInfo.hostBundleName);
133 break;
134 default:
135 break;
136 }
137 }
138
SendSecondFormEvent(const FormEventName & eventName,HiSysEventType type,const FormEventInfo & eventInfo)139 void FormEventReport::SendSecondFormEvent(const FormEventName &eventName, HiSysEventType type,
140 const FormEventInfo &eventInfo)
141 {
142 std::string name = ConvertEventName(eventName);
143 if (name == "INVALIDEVENTNAME") {
144 HILOG_ERROR("invalid eventName");
145 return;
146 }
147
148 switch (eventName) {
149 case FormEventName::REQUEST_FORM:
150 case FormEventName::BACKGROUND_EVENT_FORM:
151 HiSysEventWrite(
152 HiSysEvent::Domain::FORM_MANAGER,
153 name,
154 type,
155 EVENT_KEY_FORM_ID, eventInfo.formId,
156 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
157 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
158 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
159 break;
160 case FormEventName::DELETE_FORM:
161 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
162 EVENT_KEY_FORM_ID, eventInfo.formId,
163 EVENT_KEY_HOST_BUNDLE_NAME, eventInfo.hostBundleName);
164 break;
165 case FormEventName::CASTTEMP_FORM:
166 case FormEventName::RELEASE_FORM:
167 case FormEventName::SET_NEXT_REFRESH_TIME_FORM:
168 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type, EVENT_KEY_FORM_ID, eventInfo.formId);
169 break;
170 case FormEventName::FORM_RENDER_BLOCK:
171 HiSysEventWrite(
172 HiSysEvent::Domain::FORM_MANAGER,
173 name,
174 type,
175 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName);
176 break;
177 default:
178 break;
179 }
180 }
181
SendThirdFormEvent(const FormEventName & eventName,HiSysEventType type,const FormEventInfo & eventInfo)182 void FormEventReport::SendThirdFormEvent(const FormEventName &eventName, HiSysEventType type,
183 const FormEventInfo &eventInfo)
184 {
185 std::string name = ConvertEventName(eventName);
186 if (name == "INVALIDEVENTNAME") {
187 HILOG_ERROR("invalid eventName");
188 return;
189 }
190
191 switch (eventName) {
192 case FormEventName::UNBIND_FORM_APP:
193 HiSysEventWrite(
194 HiSysEvent::Domain::FORM_MANAGER,
195 name,
196 type,
197 EVENT_KEY_TIMESTAMP, eventInfo.timeStamp,
198 EVENT_KEY_FORM_ID, eventInfo.formId,
199 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
200 EVENT_KEY_FORM_APP_PID, eventInfo.formAppPid);
201 break;
202 default:
203 break;
204 }
205 }
206
SendFormFailedEvent(const FormEventName & eventName,HiSysEventType type,int64_t errorType)207 void FormEventReport::SendFormFailedEvent(const FormEventName &eventName, HiSysEventType type, int64_t errorType)
208 {
209 std::string name = ConvertEventName(eventName);
210 if (name == "INVALIDEVENTNAME") {
211 HILOG_ERROR("invalid eventName");
212 return;
213 }
214 switch (eventName) {
215 case FormEventName::INIT_FMS_FAILED:
216 case FormEventName::CALLEN_DB_FAILED:
217 case FormEventName::ADD_FORM_FAILED:
218 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type, EVENT_KEY_ERROR_TYPE, errorType);
219 break;
220 default:
221 break;
222 }
223 }
224
SendFormRefreshCountEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo)225 void FormEventReport::SendFormRefreshCountEvent(const FormEventName &eventName, HiSysEventType type,
226 const NewFormEventInfo &eventInfo)
227 {
228 std::string name = ConvertEventName(eventName);
229 if (name == "INVALIDEVENTNAME") {
230 HILOG_ERROR("invalid eventName");
231 return;
232 }
233 if (eventName == FormEventName::UPDATE_FORM_REFRESH_TIMES) {
234 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
235 EVENT_KEY_FORM_ID, eventInfo.formId,
236 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
237 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
238 EVENT_KEY_FORM_NAME, eventInfo.formName,
239 EVENT_KEY_DAILY_REFRESH_TIMES, static_cast<int32_t>(eventInfo.dailyRefreshTimes),
240 EVENT_KEY_INVISIBLE_REFRESH_TIMES, static_cast<int32_t>(eventInfo.invisibleRefreshTimes),
241 EVENT_KEY_HF_REFRESH_BLOCK_TIMES, static_cast<int32_t>(eventInfo.hfRefreshBlockTimes),
242 EVENT_KEY_INVISIBLE_REFRESH_BLOCK_TIMES, static_cast<int32_t>(eventInfo.invisibleRefreshBlockTimes),
243 EVENT_KEY_HILOG_REFRESH_BLOCK_TIMES, static_cast<int32_t>(eventInfo.highLoadRefreshBlockTimes),
244 EVENT_KEY_ACTIVE_RECOVER_REFRESH_TIMES, static_cast<int32_t>(eventInfo.activeRecoverRefreshTimes),
245 EVENT_KEY_PASSIVER_RECOVER_REFRESH_TIMES, static_cast<int32_t>(eventInfo.passiveRecoverRefreshTimes),
246 EVENT_KEY_HF_RECOVER_REFRESH_TIMES, static_cast<int32_t>(eventInfo.hfRecoverRefreshTimes),
247 EVENT_KEY_OFFLOAD_RECOVER_REFRESH_TIMES, static_cast<int32_t>(eventInfo.offloadRecoverRefreshTimes));
248 }
249 }
SendFourthFormEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo,const Want & want)250 void FormEventReport::SendFourthFormEvent(const FormEventName &eventName, HiSysEventType type,
251 const NewFormEventInfo &eventInfo, const Want &want)
252 {
253 std::string name = ConvertEventName(eventName);
254 if (name == "INVALIDEVENTNAME") {
255 HILOG_ERROR("invalid eventName");
256 return;
257 }
258 switch (eventName) {
259 case FormEventName::PROXY_UPDATE_FORM:
260 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
261 EVENT_KEY_FORM_ID, eventInfo.formId,
262 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
263 EVENT_KEY_MODULE_NAME, want.GetStringParam(Constants::PARAM_MODULE_NAME_KEY),
264 EVENT_KEY_FORM_NAME, want.GetStringParam(Constants::PARAM_FORM_NAME_KEY),
265 EVENT_KEY_FORM_DIMENSION, static_cast<int64_t>(want.
266 GetIntParam(Constants::PARAM_FORM_DIMENSION_KEY, 0)),
267 EVENT_KEY_ABILITY_NAME, want.GetStringParam(Constants::PARAM_ABILITY_NAME_KEY));
268 break;
269 case FormEventName::INVALID_PUBLISH_FORM_TO_HOST:
270 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
271 EVENT_KEY_CLIENT_BUNDLE_NAME, want.GetStringParam(AppExecFwk::Constants::PARAM_CALLER_BUNDLE_NAME_KEY),
272 EVENT_KEY_HOST_BUNDLE_NAME, want.GetStringParam(AppExecFwk::Constants::PARAM_FORM_HOST_BUNDLENAME_KEY),
273 EVENT_KEY_FORM_BUNDLE_NAME, want.GetElement().GetBundleName(),
274 EVENT_KEY_MODULE_NAME, want.GetStringParam(Constants::PARAM_MODULE_NAME_KEY),
275 EVENT_KEY_FORM_NAME, want.GetStringParam(Constants::PARAM_FORM_NAME_KEY),
276 EVENT_KEY_FORM_DIMENSION, static_cast<int64_t>(want.
277 GetIntParam(AppExecFwk::Constants::PARAM_FORM_DIMENSION_KEY, 0)),
278 EVENT_KEY_ABILITY_NAME, want.GetElement().GetAbilityName());
279 break;
280 default:
281 break;
282 }
283 }
284
SendFirstAddFormEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo)285 void FormEventReport::SendFirstAddFormEvent(const FormEventName &eventName, HiSysEventType type,
286 const NewFormEventInfo &eventInfo)
287 {
288 std::string name = ConvertEventName(eventName);
289 if (name == "INVALIDEVENTNAME") {
290 HILOG_ERROR("invalid eventName");
291 return;
292 }
293 if (eventName == FormEventName::FIRST_ADD_FORM_DURATION) {
294 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
295 EVENT_KEY_SESSION_ID, static_cast<int64_t>(eventInfo.sessionId),
296 EVENT_KEY_FORM_ID, eventInfo.formId,
297 EVENT_KEY_BIND_DURATION, static_cast<float>(eventInfo.bindDuration),
298 EVENT_KEY_GET_DURATION, static_cast<float>(eventInfo.getDuration),
299 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
300 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
301 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
302 EVENT_KEY_FORM_NAME, eventInfo.formName,
303 EVENT_KEY_FORM_DIMENSION, static_cast<int64_t>(eventInfo.formDimension),
304 EVENT_KEY_ACQUIRE_DURATION, static_cast<float>(eventInfo.acquireDuration));
305 }
306 }
307
SendFirstUpdateFormEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo)308 void FormEventReport::SendFirstUpdateFormEvent(const FormEventName &eventName, HiSysEventType type,
309 const NewFormEventInfo &eventInfo)
310 {
311 std::string name = ConvertEventName(eventName);
312 if (name == "INVALIDEVENTNAME") {
313 HILOG_ERROR("invalid eventName");
314 return;
315 }
316 if (eventName == FormEventName::FIRST_UPDATE_FORM_DURATION) {
317 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
318 EVENT_KEY_SESSION_ID, static_cast<int64_t>(eventInfo.sessionId),
319 EVENT_KEY_FORM_ID, eventInfo.formId,
320 EVENT_KEY_DURATION, static_cast<float>(eventInfo.duration),
321 EVENT_KEY_DURATION_TYPE, eventInfo.durationType);
322 }
323 }
324
SendConditonUpdateFormEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo)325 void FormEventReport::SendConditonUpdateFormEvent(const FormEventName &eventName, HiSysEventType type,
326 const NewFormEventInfo &eventInfo)
327 {
328 std::string name = ConvertEventName(eventName);
329 if (name == "INVALIDEVENTNAME") {
330 HILOG_ERROR("invalid eventName");
331 return;
332 }
333 if (eventName == FormEventName::CONDITION_UPDATE_FORM) {
334 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
335 EVENT_KEY_CONDITION_TYPE, static_cast<int32_t>(eventInfo.conditionType),
336 EVENT_KEY_BUNDLE_FORMNAME, eventInfo.bundleAndFormName);
337 }
338 }
339
SendLoadStageFormConfigInfoEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo)340 void FormEventReport::SendLoadStageFormConfigInfoEvent(const FormEventName &eventName, HiSysEventType type,
341 const NewFormEventInfo &eventInfo)
342 {
343 std::string name = ConvertEventName(eventName);
344 if (name == "INVALIDEVENTNAME") {
345 HILOG_ERROR("invalid eventName");
346 return;
347 }
348 if (eventName == FormEventName::LOAD_STAGE_FORM_CONFIG_INFO) {
349 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
350 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
351 EVENT_KEY_FORM_NAME, eventInfo.formName,
352 EVENT_KEY_RENDERING_MODE, static_cast<int32_t>(eventInfo.renderingMode));
353 }
354 }
355
ConvertEventName(const FormEventName & eventName)356 std::string FormEventReport::ConvertEventName(const FormEventName &eventName)
357 {
358 auto it = EVENT_NAME_MAP.find(eventName);
359 if (it != EVENT_NAME_MAP.end()) {
360 return it->second;
361 }
362 return "INVALIDEVENTNAME";
363 }
364 } // namespace AppExecFwk
365 } // namespace OHOS
366