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 "common/event/form_event_report.h"
17 #include "common/event/form_event_util.h"
18
19 #include <map>
20
21 #include "fms_log_wrapper.h"
22 #include "form_constants.h"
23
24 namespace OHOS {
25 namespace AppExecFwk {
26 namespace {
27 // event params
28 constexpr const char *EVENT_KEY_FORM_ID = "FORM_ID";
29 constexpr const char *EVENT_KEY_BUNDLE_NAME = "BUNDLE_NAME";
30 constexpr const char *EVENT_KEY_MODULE_NAME = "MODULE_NAME";
31 constexpr const char *EVENT_KEY_ABILITY_NAME = "ABILITY_NAME";
32 constexpr const char *EVENT_KEY_HOST_BUNDLE_NAME = "HOST_BUNDLE_NAME";
33 constexpr const char *EVENT_KEY_ERROR_NAME = "ERROR_NAME";
34 constexpr const char *EVENT_KEY_ERROR_TYPE = "ERROR_TYPE";
35 constexpr const char *EVENT_KEY_ERROR_CODE = "ERROR_CODE";
36 constexpr const char *EVENT_KEY_SESSION_ID = "SESSION_ID";
37 constexpr const char *EVENT_KEY_BIND_DURATION = "BIND_DURATION";
38 constexpr const char *EVENT_KEY_GET_DURATION = "GET_DURATION";
39 constexpr const char *EVENT_KEY_FORM_NAME = "FORM_NAME";
40 constexpr const char *EVENT_KEY_FORM_DIMENSION = "FORM_DIMENSION";
41 constexpr const char *EVENT_KEY_ACQUIRE_DURATION = "ACQUIRE_DURATION";
42 constexpr const char *EVENT_KEY_DURATION = "DURATION";
43 constexpr const char *EVENT_KEY_DURATION_TYPE = "DURATION_TYPE";
44 constexpr const char *EVENT_KEY_DAILY_REFRESH_TIMES = "DAILY_REFRESH_TIMES";
45 constexpr const char *EVENT_KEY_INVISIBLE_REFRESH_TIMES = "INVISIBLE_REFRESH_TIMES";
46 constexpr const char *EVENT_KEY_HF_REFRESH_BLOCK_TIMES = "HF_REFRESH_BLOCK_TIMES";
47 constexpr const char *EVENT_KEY_INVISIBLE_REFRESH_BLOCK_TIMES = "INVISIBLE_REFRESH_BLOCK_TIMES";
48 constexpr const char *EVENT_KEY_HILOG_REFRESH_BLOCK_TIMES = "HILOG_REFRESH_BLOCK_TIMES";
49 constexpr const char *EVENT_KEY_ACTIVE_RECOVER_REFRESH_TIMES = "ACTIVE_RECOVER_REFRESH_TIMES";
50 constexpr const char *EVENT_KEY_PASSIVER_RECOVER_REFRESH_TIMES = "PASSIVER_RECOVER_REFRESH_TIMES";
51 constexpr const char *EVENT_KEY_HF_RECOVER_REFRESH_TIMES = "HF_RECOVER_REFRESH_TIMES";
52 constexpr const char *EVENT_KEY_OFFLOAD_RECOVER_REFRESH_TIMES = "OFFLOAD_RECOVER_REFRESH_TIMER";
53 constexpr const char *EVENT_KEY_DISABLE_FORM_REFRESH_TIMES = "DISABLE_REFRESH_TIMES";
54 constexpr const char *EVENT_KEY_CLIENT_BUNDLE_NAME = "CLIENT_BUNDLE_NAME";
55 constexpr const char *EVENT_KEY_FORM_BUNDLE_NAME = "FORM_BUNDLE_NAME";
56 constexpr const char *EVENT_KEY_FORM_APP_PID = "FORM_APP_PID";
57 constexpr const char *EVENT_KEY_TIMESTAMP = "TIMESTAMP";
58 constexpr const char *EVENT_KEY_RENDERING_MODE = "RENDERING_MODE";
59 constexpr const char *EVENT_KEY_CONDITION_TYPE = "CONDITION_TYPE";
60 constexpr const char *EVENT_KEY_BUNDLE_FORMNAME = "BUNDLE_FORMNAME";
61 constexpr const char *EVENT_KEY_WITH_SNAPSHOT = "WITH_SNAPSHOT";
62 constexpr const char *EVENT_KEY_DISTRIBUTED_FORM = "DISTRIBUTED_FORM";
63 constexpr const char *INVALIDEVENTNAME = "INVALIDEVENTNAME";
64 constexpr const char *FORM_ERROR = "FORM_ERROR";
65 constexpr const char *FORM_STORAGE_DIR_PATH = "/data/service/el1/public/database/form_storage";
66 constexpr const char *EVENT_KEY_FORM_COUNT = "FORM_COUNT";
67 constexpr const char *EVENT_KEY_IS_LOW_MEMORY = "IS_LOW_MEMORY";
68 constexpr const char *EVENT_KEY_OCCURRENCE_TIME = "OCCURRENCE_TIME";
69 constexpr const char *EVENT_KEY_STATUS = "STATUS";
70 constexpr const char *FORM_RENDER_SERVICE_STATUS_ALTER = "FORM_RENDER_SERVICE_STATUS_ALTER";
71 const std::map<FormEventName, std::string> EVENT_NAME_MAP = {
72 std::map<FormEventName, std::string>::value_type(FormEventName::ADD_FORM, "ADD_FORM"),
73 std::map<FormEventName, std::string>::value_type(FormEventName::REQUEST_FORM, "REQUEST_FORM"),
74 std::map<FormEventName, std::string>::value_type(FormEventName::REQUEST_FORM, "REQUEST_FORM"),
75 std::map<FormEventName, std::string>::value_type(FormEventName::DELETE_FORM, "DELETE_FORM"),
76 std::map<FormEventName, std::string>::value_type(FormEventName::CASTTEMP_FORM, "CASTTEMP_FORM"),
77 std::map<FormEventName, std::string>::value_type(FormEventName::ACQUIREFORMSTATE_FORM, "ACQUIREFORMSTATE_FORM"),
78 std::map<FormEventName, std::string>::value_type(FormEventName::MESSAGE_EVENT_FORM, "MESSAGE_EVENT_FORM"),
79 std::map<FormEventName, std::string>::value_type(FormEventName::ROUTE_EVENT_FORM, "ROUTE_EVENT_FORM"),
80 std::map<FormEventName, std::string>::value_type(FormEventName::BACKGROUND_EVENT_FORM, "BACKGROUND_EVENT_FORM"),
81 std::map<FormEventName, std::string>::value_type(FormEventName::RELEASE_FORM, "RELEASE_FORM"),
82 std::map<FormEventName, std::string>::value_type(FormEventName::DELETE_INVALID_FORM, "DELETE_INVALID_FORM"),
83 std::map<FormEventName, std::string>::value_type(
84 FormEventName::SET_NEXT_REFRESH_TIME_FORM, "SET_NEXT_REFRESH_TIME_FORM"),
85 std::map<FormEventName, std::string>::value_type(FormEventName::FORM_RENDER_BLOCK, "FORM_RENDER_BLOCK"),
86 std::map<FormEventName, std::string>::value_type(FormEventName::INIT_FMS_FAILED, "INIT_FMS_FAILED"),
87 std::map<FormEventName, std::string>::value_type(FormEventName::CALLEN_DB_FAILED, "CALLEN_DB_FAILED"),
88 std::map<FormEventName, std::string>::value_type(FormEventName::ADD_FORM_FAILED, "ADD_FORM_FAILED"),
89 std::map<FormEventName, std::string>::value_type(
90 FormEventName::FIRST_ADD_FORM_DURATION, "FIRST_ADD_FORM_DURATION"),
91 std::map<FormEventName, std::string>::value_type(
92 FormEventName::FIRST_UPDATE_FORM_DURATION, "FIRST_UPDATE_FORM_DURATION"),
93 std::map<FormEventName, std::string>::value_type(
94 FormEventName::UPDATE_FORM_REFRESH_TIMES, "UPDATE_FORM_REFRESH_TIMES"),
95 std::map<FormEventName, std::string>::value_type(FormEventName::PROXY_UPDATE_FORM, "PROXY_UPDATE_FORM"),
96 std::map<FormEventName, std::string>::value_type(
97 FormEventName::INVALID_PUBLISH_FORM_TO_HOST, "INVALID_PUBLISH_FORM_TO_HOST"),
98 std::map<FormEventName, std::string>::value_type(FormEventName::UNBIND_FORM_APP, "UNBIND_FORM_APP"),
99 std::map<FormEventName, std::string>::value_type(
100 FormEventName::CONDITION_UPDATE_FORM, "CONDITION_UPDATE_FORM"),
101 std::map<FormEventName, std::string>::value_type(
102 FormEventName::LOAD_STAGE_FORM_CONFIG_INFO, "LOAD_STAGE_FORM_CONFIG_INFO"),
103 std::map<FormEventName, std::string>::value_type(FormEventName::DELETE_FORM_FAILED, "DELETE_FORM_FAILED"),
104 std::map<FormEventName, std::string>::value_type(FormEventName::UPDATE_FORM_FAILED, "UPDATE_FORM_FAILED"),
105 std::map<FormEventName, std::string>::value_type(
106 FormEventName::RECYCLE_RECOVER_FORM_FAILED, "RECYCLE_RECOVER_FORM_FAILED"),
107 std::map<FormEventName, std::string>::value_type(FormEventName::REQUEST_PUBLIC_FORM, "REQUEST_PUBLIC_FORM"),
108 std::map<FormEventName, std::string>::value_type(
109 FormEventName::CONNECT_FORM_ABILITY_FAILED, "CONNECT_FORM_ABILITY_FAILED"),
110 };
111 }
112
SendFormEvent(const FormEventName & eventName,HiSysEventType type,const FormEventInfo & eventInfo)113 void FormEventReport::SendFormEvent(const FormEventName &eventName, HiSysEventType type,
114 const FormEventInfo &eventInfo)
115 {
116 std::string name = ConvertEventName(eventName);
117 if (name == INVALIDEVENTNAME) {
118 HILOG_ERROR("invalid eventName");
119 return;
120 }
121
122 switch (eventName) {
123 case FormEventName::DELETE_INVALID_FORM:
124 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type);
125 break;
126 case FormEventName::ACQUIREFORMSTATE_FORM:
127 HiSysEventWrite(
128 HiSysEvent::Domain::FORM_MANAGER,
129 name,
130 type,
131 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
132 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
133 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
134 break;
135 case FormEventName::MESSAGE_EVENT_FORM:
136 HiSysEventWrite(
137 HiSysEvent::Domain::FORM_MANAGER,
138 name,
139 type,
140 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
141 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
142 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
143 EVENT_KEY_HOST_BUNDLE_NAME, eventInfo.hostBundleName);
144 break;
145 case FormEventName::ADD_FORM:
146 HiSysEventWrite(
147 HiSysEvent::Domain::FORM_MANAGER,
148 name,
149 type,
150 EVENT_KEY_DISTRIBUTED_FORM, eventInfo.distributedForm,
151 EVENT_KEY_FORM_DIMENSION, static_cast<int64_t>(eventInfo.formDimension));
152 break;
153 case FormEventName::ROUTE_EVENT_FORM:
154 HiSysEventWrite(
155 HiSysEvent::Domain::FORM_MANAGER, name, type,
156 EVENT_KEY_FORM_ID, eventInfo.formId,
157 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
158 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
159 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
160 EVENT_KEY_HOST_BUNDLE_NAME, eventInfo.hostBundleName);
161 break;
162 default:
163 break;
164 }
165 }
166
SendSecondFormEvent(const FormEventName & eventName,HiSysEventType type,const FormEventInfo & eventInfo)167 void FormEventReport::SendSecondFormEvent(const FormEventName &eventName, HiSysEventType type,
168 const FormEventInfo &eventInfo)
169 {
170 std::string name = ConvertEventName(eventName);
171 if (name == INVALIDEVENTNAME) {
172 HILOG_ERROR("invalid eventName");
173 return;
174 }
175
176 switch (eventName) {
177 case FormEventName::REQUEST_FORM:
178 case FormEventName::BACKGROUND_EVENT_FORM:
179 HiSysEventWrite(
180 HiSysEvent::Domain::FORM_MANAGER,
181 name,
182 type,
183 EVENT_KEY_FORM_ID, eventInfo.formId,
184 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
185 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
186 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
187 break;
188 case FormEventName::DELETE_FORM:
189 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
190 EVENT_KEY_FORM_ID, eventInfo.formId,
191 EVENT_KEY_HOST_BUNDLE_NAME, eventInfo.hostBundleName,
192 EVENT_KEY_DISTRIBUTED_FORM, eventInfo.distributedForm,
193 EVENT_KEY_FORM_DIMENSION, static_cast<int64_t>(eventInfo.formDimension));
194 break;
195 case FormEventName::CASTTEMP_FORM:
196 case FormEventName::RELEASE_FORM:
197 case FormEventName::SET_NEXT_REFRESH_TIME_FORM:
198 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type, EVENT_KEY_FORM_ID, eventInfo.formId);
199 break;
200 case FormEventName::FORM_RENDER_BLOCK:
201 HiSysEventWrite(
202 HiSysEvent::Domain::FORM_MANAGER,
203 name,
204 type,
205 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName);
206 break;
207 default:
208 break;
209 }
210 }
211
SendThirdFormEvent(const FormEventName & eventName,HiSysEventType type,const FormEventInfo & eventInfo)212 void FormEventReport::SendThirdFormEvent(const FormEventName &eventName, HiSysEventType type,
213 const FormEventInfo &eventInfo)
214 {
215 std::string name = ConvertEventName(eventName);
216 if (name == INVALIDEVENTNAME) {
217 HILOG_ERROR("invalid eventName");
218 return;
219 }
220
221 switch (eventName) {
222 case FormEventName::UNBIND_FORM_APP:
223 HiSysEventWrite(
224 HiSysEvent::Domain::FORM_MANAGER,
225 name,
226 type,
227 EVENT_KEY_TIMESTAMP, eventInfo.timeStamp,
228 EVENT_KEY_FORM_ID, eventInfo.formId,
229 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
230 EVENT_KEY_FORM_APP_PID, eventInfo.formAppPid);
231 break;
232 default:
233 break;
234 }
235 }
236
SendFormFailedEvent(const FormEventName & eventName,HiSysEventType type,int64_t errorType)237 void FormEventReport::SendFormFailedEvent(const FormEventName &eventName, HiSysEventType type, int64_t errorType)
238 {
239 std::string name = ConvertEventName(eventName);
240 if (name == INVALIDEVENTNAME) {
241 HILOG_ERROR("invalid eventName");
242 return;
243 }
244 switch (eventName) {
245 case FormEventName::INIT_FMS_FAILED:
246 case FormEventName::CALLEN_DB_FAILED:
247 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type, EVENT_KEY_ERROR_TYPE, errorType);
248 break;
249 default:
250 break;
251 }
252 }
253
SendFormRefreshCountEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo)254 void FormEventReport::SendFormRefreshCountEvent(const FormEventName &eventName, HiSysEventType type,
255 const NewFormEventInfo &eventInfo)
256 {
257 std::string name = ConvertEventName(eventName);
258 if (name == INVALIDEVENTNAME) {
259 HILOG_ERROR("invalid eventName");
260 return;
261 }
262 if (eventName == FormEventName::UPDATE_FORM_REFRESH_TIMES) {
263 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
264 EVENT_KEY_FORM_ID, eventInfo.formId,
265 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
266 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
267 EVENT_KEY_FORM_NAME, eventInfo.formName,
268 EVENT_KEY_DAILY_REFRESH_TIMES, static_cast<int32_t>(eventInfo.dailyRefreshTimes),
269 EVENT_KEY_INVISIBLE_REFRESH_TIMES, static_cast<int32_t>(eventInfo.invisibleRefreshTimes),
270 EVENT_KEY_HF_REFRESH_BLOCK_TIMES, static_cast<int32_t>(eventInfo.hfRefreshBlockTimes),
271 EVENT_KEY_INVISIBLE_REFRESH_BLOCK_TIMES, static_cast<int32_t>(eventInfo.invisibleRefreshBlockTimes),
272 EVENT_KEY_HILOG_REFRESH_BLOCK_TIMES, static_cast<int32_t>(eventInfo.highLoadRefreshBlockTimes),
273 EVENT_KEY_ACTIVE_RECOVER_REFRESH_TIMES, static_cast<int32_t>(eventInfo.activeRecoverRefreshTimes),
274 EVENT_KEY_PASSIVER_RECOVER_REFRESH_TIMES, static_cast<int32_t>(eventInfo.passiveRecoverRefreshTimes),
275 EVENT_KEY_HF_RECOVER_REFRESH_TIMES, static_cast<int32_t>(eventInfo.hfRecoverRefreshTimes),
276 EVENT_KEY_OFFLOAD_RECOVER_REFRESH_TIMES, static_cast<int32_t>(eventInfo.offloadRecoverRefreshTimes),
277 EVENT_KEY_DISABLE_FORM_REFRESH_TIMES, static_cast<int32_t>(eventInfo.disableFormRefreshTimes));
278 }
279 }
SendFourthFormEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo,const Want & want)280 void FormEventReport::SendFourthFormEvent(const FormEventName &eventName, HiSysEventType type,
281 const NewFormEventInfo &eventInfo, const Want &want)
282 {
283 std::string name = ConvertEventName(eventName);
284 if (name == INVALIDEVENTNAME) {
285 HILOG_ERROR("invalid eventName");
286 return;
287 }
288 switch (eventName) {
289 case FormEventName::PROXY_UPDATE_FORM:
290 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
291 EVENT_KEY_FORM_ID, eventInfo.formId,
292 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
293 EVENT_KEY_MODULE_NAME, want.GetStringParam(Constants::PARAM_MODULE_NAME_KEY),
294 EVENT_KEY_FORM_NAME, want.GetStringParam(Constants::PARAM_FORM_NAME_KEY),
295 EVENT_KEY_FORM_DIMENSION, static_cast<int64_t>(want.
296 GetIntParam(Constants::PARAM_FORM_DIMENSION_KEY, 0)),
297 EVENT_KEY_ABILITY_NAME, want.GetStringParam(Constants::PARAM_ABILITY_NAME_KEY),
298 EVENT_KEY_DISTRIBUTED_FORM, eventInfo.distributedForm);
299 break;
300 case FormEventName::INVALID_PUBLISH_FORM_TO_HOST:
301 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
302 EVENT_KEY_CLIENT_BUNDLE_NAME, want.GetStringParam(AppExecFwk::Constants::PARAM_CALLER_BUNDLE_NAME_KEY),
303 EVENT_KEY_HOST_BUNDLE_NAME, want.GetStringParam(AppExecFwk::Constants::PARAM_FORM_HOST_BUNDLENAME_KEY),
304 EVENT_KEY_FORM_BUNDLE_NAME, want.GetElement().GetBundleName(),
305 EVENT_KEY_MODULE_NAME, want.GetStringParam(Constants::PARAM_MODULE_NAME_KEY),
306 EVENT_KEY_FORM_NAME, want.GetStringParam(Constants::PARAM_FORM_NAME_KEY),
307 EVENT_KEY_FORM_DIMENSION, static_cast<int64_t>(want.
308 GetIntParam(AppExecFwk::Constants::PARAM_FORM_DIMENSION_KEY, 0)),
309 EVENT_KEY_ABILITY_NAME, want.GetElement().GetAbilityName());
310 break;
311 default:
312 break;
313 }
314 }
315
SendFirstAddFormEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo)316 void FormEventReport::SendFirstAddFormEvent(const FormEventName &eventName, HiSysEventType type,
317 const NewFormEventInfo &eventInfo)
318 {
319 std::string name = ConvertEventName(eventName);
320 if (name == INVALIDEVENTNAME) {
321 HILOG_ERROR("invalid eventName");
322 return;
323 }
324 if (eventName == FormEventName::FIRST_ADD_FORM_DURATION) {
325 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
326 EVENT_KEY_SESSION_ID, static_cast<int64_t>(eventInfo.sessionId),
327 EVENT_KEY_FORM_ID, eventInfo.formId,
328 EVENT_KEY_BIND_DURATION, static_cast<float>(eventInfo.bindDuration),
329 EVENT_KEY_GET_DURATION, static_cast<float>(eventInfo.getDuration),
330 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
331 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
332 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
333 EVENT_KEY_FORM_NAME, eventInfo.formName,
334 EVENT_KEY_FORM_DIMENSION, static_cast<int64_t>(eventInfo.formDimension),
335 EVENT_KEY_ACQUIRE_DURATION, static_cast<float>(eventInfo.acquireDuration));
336 }
337 }
338
SendFirstUpdateFormEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo)339 void FormEventReport::SendFirstUpdateFormEvent(const FormEventName &eventName, HiSysEventType type,
340 const NewFormEventInfo &eventInfo)
341 {
342 std::string name = ConvertEventName(eventName);
343 if (name == INVALIDEVENTNAME) {
344 HILOG_ERROR("invalid eventName");
345 return;
346 }
347 if (eventName == FormEventName::FIRST_UPDATE_FORM_DURATION) {
348 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
349 EVENT_KEY_SESSION_ID, static_cast<int64_t>(eventInfo.sessionId),
350 EVENT_KEY_FORM_ID, eventInfo.formId,
351 EVENT_KEY_DURATION, static_cast<float>(eventInfo.duration),
352 EVENT_KEY_DURATION_TYPE, eventInfo.durationType);
353 }
354 }
355
SendConditonUpdateFormEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo)356 void FormEventReport::SendConditonUpdateFormEvent(const FormEventName &eventName, HiSysEventType type,
357 const NewFormEventInfo &eventInfo)
358 {
359 std::string name = ConvertEventName(eventName);
360 if (name == INVALIDEVENTNAME) {
361 HILOG_ERROR("invalid eventName");
362 return;
363 }
364 if (eventName == FormEventName::CONDITION_UPDATE_FORM) {
365 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
366 EVENT_KEY_CONDITION_TYPE, static_cast<int32_t>(eventInfo.conditionType),
367 EVENT_KEY_BUNDLE_FORMNAME, eventInfo.bundleAndFormName,
368 EVENT_KEY_FORM_ID, eventInfo.formId,
369 EVENT_KEY_DISTRIBUTED_FORM, eventInfo.distributedForm,
370 EVENT_KEY_FORM_DIMENSION, static_cast<int64_t>(eventInfo.formDimension),
371 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
372 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
373 }
374 }
375
SendLoadStageFormConfigInfoEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo)376 void FormEventReport::SendLoadStageFormConfigInfoEvent(const FormEventName &eventName, HiSysEventType type,
377 const NewFormEventInfo &eventInfo)
378 {
379 std::string name = ConvertEventName(eventName);
380 if (name == INVALIDEVENTNAME) {
381 HILOG_ERROR("invalid eventName");
382 return;
383 }
384 if (eventName == FormEventName::LOAD_STAGE_FORM_CONFIG_INFO) {
385 HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
386 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
387 EVENT_KEY_FORM_NAME, eventInfo.formName,
388 EVENT_KEY_RENDERING_MODE, static_cast<int32_t>(eventInfo.renderingMode));
389 }
390 }
391
SendDiskUseEvent()392 void FormEventReport::SendDiskUseEvent()
393 {
394 std::vector<std::string> files;
395 std::vector<std::uint64_t> filesSize;
396 FormEventUtil::GetDirFiles(FORM_STORAGE_DIR_PATH, files);
397 if (files.empty()) {
398 HILOG_ERROR("files is empty, not report disk use info");
399 return;
400 }
401 FormEventUtil::GetFilesSize(files, filesSize);
402 files.push_back(FORM_STORAGE_DIR_PATH);
403 HiSysEventWrite(HiSysEvent::Domain::FILEMANAGEMENT, "USER_DATA_SIZE",
404 HiSysEvent::EventType::STATISTIC,
405 "COMPONENT_NAME", "form_fwk",
406 "FILE_OR_FOLDER_PATH", files,
407 "FILE_OR_FOLDER_SIZE", filesSize);
408 }
409
SendRequestPublicFormEvent(const std::string & callerBundleName,const std::string & formName,bool withSnapshot)410 void FormEventReport::SendRequestPublicFormEvent(const std::string &callerBundleName, const std::string &formName,
411 bool withSnapshot)
412 {
413 HiSysEventWrite(
414 HiSysEvent::Domain::FORM_MANAGER,
415 "REQUEST_PUBLIC_FORM",
416 HiSysEventType::STATISTIC,
417 EVENT_KEY_BUNDLE_NAME, callerBundleName,
418 EVENT_KEY_FORM_NAME, formName,
419 EVENT_KEY_WITH_SNAPSHOT, withSnapshot);
420 }
421
SendFormFailedEvent(const FormEventName & eventName,int64_t formId,const std::string & bundleName,const std::string & formName,int32_t errorType,int32_t errorCode)422 void FormEventReport::SendFormFailedEvent(const FormEventName &eventName, int64_t formId, const std::string &bundleName,
423 const std::string &formName, int32_t errorType, int32_t errorCode)
424 {
425 std::string name = ConvertEventName(eventName);
426 if (name == INVALIDEVENTNAME) {
427 HILOG_ERROR("invalid eventName");
428 return;
429 }
430 switch (eventName) {
431 case FormEventName::ADD_FORM_FAILED:
432 case FormEventName::DELETE_FORM_FAILED:
433 case FormEventName::UPDATE_FORM_FAILED:
434 case FormEventName::RECYCLE_RECOVER_FORM_FAILED:
435 case FormEventName::CONNECT_FORM_ABILITY_FAILED:
436 HiSysEventWrite(
437 HiSysEvent::Domain::FORM_MANAGER, FORM_ERROR,
438 HiSysEventType::FAULT,
439 EVENT_KEY_FORM_ID, formId,
440 EVENT_KEY_BUNDLE_NAME, bundleName,
441 EVENT_KEY_FORM_NAME, formName,
442 EVENT_KEY_ERROR_NAME, name,
443 EVENT_KEY_ERROR_TYPE, errorType,
444 EVENT_KEY_ERROR_CODE, errorCode);
445 break;
446 default:
447 break;
448 }
449 }
450
ConvertEventName(const FormEventName & eventName)451 std::string FormEventReport::ConvertEventName(const FormEventName &eventName)
452 {
453 auto it = EVENT_NAME_MAP.find(eventName);
454 if (it != EVENT_NAME_MAP.end()) {
455 return it->second;
456 }
457 return INVALIDEVENTNAME;
458 }
459
SendFRSStatusEvent(const std::vector<bool> & isLowMemoryList,const std::vector<uint8_t> & statusList,const std::vector<int32_t> & formCountList,const std::vector<int64_t> & occurrenceTimeList)460 void FormEventReport::SendFRSStatusEvent(
461 const std::vector<bool> &isLowMemoryList,
462 const std::vector<uint8_t> &statusList,
463 const std::vector<int32_t> &formCountList,
464 const std::vector<int64_t> &occurrenceTimeList)
465 {
466 HILOG_INFO("call");
467 HiSysEventWrite(
468 HiSysEvent::Domain::FORM_MANAGER,
469 FORM_RENDER_SERVICE_STATUS_ALTER,
470 HiSysEventType::STATISTIC,
471 EVENT_KEY_OCCURRENCE_TIME, occurrenceTimeList,
472 EVENT_KEY_FORM_COUNT, formCountList,
473 EVENT_KEY_IS_LOW_MEMORY, isLowMemoryList,
474 EVENT_KEY_STATUS, statusList);
475 }
476 } // namespace AppExecFwk
477 } // namespace OHOS
478