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 const std::map<FormEventName, std::string> EVENT_NAME_MAP = {
55     std::map<FormEventName, std::string>::value_type(FormEventName::ADD_FORM, "ADD_FORM"),
56     std::map<FormEventName, std::string>::value_type(FormEventName::REQUEST_FORM, "REQUEST_FORM"),
57     std::map<FormEventName, std::string>::value_type(FormEventName::REQUEST_FORM, "REQUEST_FORM"),
58     std::map<FormEventName, std::string>::value_type(FormEventName::DELETE_FORM, "DELETE_FORM"),
59     std::map<FormEventName, std::string>::value_type(FormEventName::CASTTEMP_FORM, "CASTTEMP_FORM"),
60     std::map<FormEventName, std::string>::value_type(FormEventName::ACQUIREFORMSTATE_FORM, "ACQUIREFORMSTATE_FORM"),
61     std::map<FormEventName, std::string>::value_type(FormEventName::MESSAGE_EVENT_FORM, "MESSAGE_EVENT_FORM"),
62     std::map<FormEventName, std::string>::value_type(FormEventName::ROUTE_EVENT_FORM, "ROUTE_EVENT_FORM"),
63     std::map<FormEventName, std::string>::value_type(FormEventName::BACKGROUND_EVENT_FORM, "BACKGROUND_EVENT_FORM"),
64     std::map<FormEventName, std::string>::value_type(FormEventName::RELEASE_FORM, "RELEASE_FORM"),
65     std::map<FormEventName, std::string>::value_type(FormEventName::DELETE_INVALID_FORM, "DELETE_INVALID_FORM"),
66     std::map<FormEventName, std::string>::value_type(
67         FormEventName::SET_NEXT_REFRESH_TIME_FORM, "SET_NEXT_REFRESH_TIME_FORM"),
68     std::map<FormEventName, std::string>::value_type(FormEventName::FORM_RENDER_BLOCK, "FORM_RENDER_BLOCK"),
69     std::map<FormEventName, std::string>::value_type(FormEventName::INIT_FMS_FAILED, "INIT_FMS_FAILED"),
70     std::map<FormEventName, std::string>::value_type(FormEventName::CALLEN_DB_FAILED, "CALLEN_DB_FAILED"),
71     std::map<FormEventName, std::string>::value_type(FormEventName::ADD_FORM_FAILED, "ADD_FORM_FAILED"),
72     std::map<FormEventName, std::string>::value_type(
73         FormEventName::FIRST_ADD_FORM_DURATION, "FIRST_ADD_FORM_DURATION"),
74     std::map<FormEventName, std::string>::value_type(
75         FormEventName::FIRST_UPDATE_FORM_DURATION, "FIRST_UPDATE_FORM_DURATION"),
76     std::map<FormEventName, std::string>::value_type(
77         FormEventName::UPDATE_FORM_REFRESH_TIMES, "UPDATE_FORM_REFRESH_TIMES"),
78     std::map<FormEventName, std::string>::value_type(FormEventName::PROXY_UPDATE_FORM, "PROXY_UPDATE_FORM"),
79     std::map<FormEventName, std::string>::value_type(
80         FormEventName::INVALID_PUBLISH_FORM_TO_HOST, "INVALID_PUBLISH_FORM_TO_HOST"),
81     std::map<FormEventName, std::string>::value_type(FormEventName::UNBIND_FORM_APP, "UNBIND_FORM_APP"),
82 };
83 }
84 
SendFormEvent(const FormEventName & eventName,HiSysEventType type,const FormEventInfo & eventInfo)85 void FormEventReport::SendFormEvent(const FormEventName &eventName, HiSysEventType type,
86     const FormEventInfo &eventInfo)
87 {
88     std::string name = ConvertEventName(eventName);
89     if (name == "INVALIDEVENTNAME") {
90         HILOG_ERROR("invalid eventName");
91         return;
92     }
93 
94     switch (eventName) {
95         case FormEventName::DELETE_INVALID_FORM:
96             HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type);
97             break;
98         case FormEventName::ACQUIREFORMSTATE_FORM:
99             HiSysEventWrite(
100                 HiSysEvent::Domain::FORM_MANAGER,
101                 name,
102                 type,
103                 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
104                 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
105                 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
106             break;
107         case FormEventName::MESSAGE_EVENT_FORM:
108             HiSysEventWrite(
109                 HiSysEvent::Domain::FORM_MANAGER,
110                 name,
111                 type,
112                 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
113                 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
114                 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
115                 EVENT_KEY_HOST_BUNDLE_NAME, eventInfo.hostBundleName);
116             break;
117         case FormEventName::ADD_FORM:
118         case FormEventName::ROUTE_EVENT_FORM:
119             HiSysEventWrite(
120                 HiSysEvent::Domain::FORM_MANAGER, name, type,
121                 EVENT_KEY_FORM_ID, eventInfo.formId,
122                 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
123                 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
124                 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
125                 EVENT_KEY_HOST_BUNDLE_NAME, eventInfo.hostBundleName);
126             break;
127         default:
128             break;
129     }
130 }
131 
SendSecondFormEvent(const FormEventName & eventName,HiSysEventType type,const FormEventInfo & eventInfo)132 void FormEventReport::SendSecondFormEvent(const FormEventName &eventName, HiSysEventType type,
133     const FormEventInfo &eventInfo)
134 {
135     std::string name = ConvertEventName(eventName);
136     if (name == "INVALIDEVENTNAME") {
137         HILOG_ERROR("invalid eventName");
138         return;
139     }
140 
141     switch (eventName) {
142         case FormEventName::REQUEST_FORM:
143         case FormEventName::BACKGROUND_EVENT_FORM:
144             HiSysEventWrite(
145                 HiSysEvent::Domain::FORM_MANAGER,
146                 name,
147                 type,
148                 EVENT_KEY_FORM_ID, eventInfo.formId,
149                 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
150                 EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
151                 EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
152             break;
153         case FormEventName::DELETE_FORM:
154             HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
155                 EVENT_KEY_FORM_ID, eventInfo.formId,
156                 EVENT_KEY_HOST_BUNDLE_NAME, eventInfo.hostBundleName);
157             break;
158         case FormEventName::CASTTEMP_FORM:
159         case FormEventName::RELEASE_FORM:
160         case FormEventName::SET_NEXT_REFRESH_TIME_FORM:
161             HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type, EVENT_KEY_FORM_ID, eventInfo.formId);
162             break;
163         case FormEventName::FORM_RENDER_BLOCK:
164             HiSysEventWrite(
165                 HiSysEvent::Domain::FORM_MANAGER,
166                 name,
167                 type,
168                 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName);
169             break;
170         default:
171             break;
172     }
173 }
174 
SendThirdFormEvent(const FormEventName & eventName,HiSysEventType type,const FormEventInfo & eventInfo)175 void FormEventReport::SendThirdFormEvent(const FormEventName &eventName, HiSysEventType type,
176     const FormEventInfo &eventInfo)
177 {
178     std::string name = ConvertEventName(eventName);
179     if (name == "INVALIDEVENTNAME") {
180         HILOG_ERROR("invalid eventName");
181         return;
182     }
183 
184     switch (eventName) {
185         case FormEventName::UNBIND_FORM_APP:
186             HiSysEventWrite(
187                 HiSysEvent::Domain::FORM_MANAGER,
188                 name,
189                 type,
190                 EVENT_KEY_TIMESTAMP, eventInfo.timeStamp,
191                 EVENT_KEY_FORM_ID, eventInfo.formId,
192                 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
193                 EVENT_KEY_FORM_APP_PID, eventInfo.formAppPid);
194             break;
195         default:
196             break;
197     }
198 }
199 
SendFormFailedEvent(const FormEventName & eventName,HiSysEventType type,int64_t errorType)200 void FormEventReport::SendFormFailedEvent(const FormEventName &eventName, HiSysEventType type, int64_t errorType)
201 {
202     std::string name = ConvertEventName(eventName);
203     if (name == "INVALIDEVENTNAME") {
204         HILOG_ERROR("invalid eventName");
205         return;
206     }
207     switch (eventName) {
208         case FormEventName::INIT_FMS_FAILED:
209         case FormEventName::CALLEN_DB_FAILED:
210         case FormEventName::ADD_FORM_FAILED:
211             HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type, EVENT_KEY_ERROR_TYPE, errorType);
212             break;
213         default:
214             break;
215     }
216 }
217 
SendFormRefreshCountEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo)218 void FormEventReport::SendFormRefreshCountEvent(const FormEventName &eventName, HiSysEventType type,
219     const NewFormEventInfo &eventInfo)
220 {
221     std::string name = ConvertEventName(eventName);
222     if (name == "INVALIDEVENTNAME") {
223         HILOG_ERROR("invalid eventName");
224         return;
225     }
226     if (eventName == FormEventName::UPDATE_FORM_REFRESH_TIMES) {
227         HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
228             EVENT_KEY_FORM_ID, eventInfo.formId,
229             EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
230             EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
231             EVENT_KEY_FORM_NAME, eventInfo.formName,
232             EVENT_KEY_DAILY_REFRESH_TIMES, static_cast<int32_t>(eventInfo.dailyRefreshTimes),
233             EVENT_KEY_INVISIBLE_REFRESH_TIMES, static_cast<int32_t>(eventInfo.invisibleRefreshTimes),
234             EVENT_KEY_HF_REFRESH_BLOCK_TIMES, static_cast<int32_t>(eventInfo.hfRefreshBlockTimes),
235             EVENT_KEY_INVISIBLE_REFRESH_BLOCK_TIMES, static_cast<int32_t>(eventInfo.invisibleRefreshBlockTimes),
236             EVENT_KEY_HILOG_REFRESH_BLOCK_TIMES, static_cast<int32_t>(eventInfo.highLoadRefreshBlockTimes),
237             EVENT_KEY_ACTIVE_RECOVER_REFRESH_TIMES, static_cast<int32_t>(eventInfo.activeRecoverRefreshTimes),
238             EVENT_KEY_PASSIVER_RECOVER_REFRESH_TIMES, static_cast<int32_t>(eventInfo.passiveRecoverRefreshTimes),
239             EVENT_KEY_HF_RECOVER_REFRESH_TIMES, static_cast<int32_t>(eventInfo.hfRecoverRefreshTimes),
240             EVENT_KEY_OFFLOAD_RECOVER_REFRESH_TIMES, static_cast<int32_t>(eventInfo.offloadRecoverRefreshTimes));
241     }
242 }
SendFourthFormEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo,const Want & want)243 void FormEventReport::SendFourthFormEvent(const FormEventName &eventName, HiSysEventType type,
244     const NewFormEventInfo &eventInfo, const Want &want)
245 {
246     std::string name = ConvertEventName(eventName);
247     if (name == "INVALIDEVENTNAME") {
248         HILOG_ERROR("invalid eventName");
249         return;
250     }
251     switch (eventName) {
252         case FormEventName::PROXY_UPDATE_FORM:
253             HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
254                 EVENT_KEY_FORM_ID, eventInfo.formId,
255                 EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
256                 EVENT_KEY_MODULE_NAME, want.GetStringParam(Constants::PARAM_MODULE_NAME_KEY),
257                 EVENT_KEY_FORM_NAME, want.GetStringParam(Constants::PARAM_FORM_NAME_KEY),
258                 EVENT_KEY_FORM_DIMENSION, static_cast<int64_t>(want.
259                     GetIntParam(Constants::PARAM_FORM_DIMENSION_KEY, 0)),
260                 EVENT_KEY_ABILITY_NAME, want.GetStringParam(Constants::PARAM_ABILITY_NAME_KEY));
261             break;
262         case FormEventName::INVALID_PUBLISH_FORM_TO_HOST:
263             HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
264                 EVENT_KEY_CLIENT_BUNDLE_NAME, want.GetStringParam(AppExecFwk::Constants::PARAM_CALLER_BUNDLE_NAME_KEY),
265                 EVENT_KEY_HOST_BUNDLE_NAME, want.GetStringParam(AppExecFwk::Constants::PARAM_FORM_HOST_BUNDLENAME_KEY),
266                 EVENT_KEY_FORM_BUNDLE_NAME, want.GetElement().GetBundleName(),
267                 EVENT_KEY_MODULE_NAME, want.GetStringParam(Constants::PARAM_MODULE_NAME_KEY),
268                 EVENT_KEY_FORM_NAME, want.GetStringParam(Constants::PARAM_FORM_NAME_KEY),
269                 EVENT_KEY_FORM_DIMENSION, static_cast<int64_t>(want.
270                     GetIntParam(AppExecFwk::Constants::PARAM_FORM_DIMENSION_KEY, 0)),
271                 EVENT_KEY_ABILITY_NAME, want.GetElement().GetAbilityName());
272             break;
273         default:
274             break;
275     }
276 }
277 
SendFirstAddFormEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo)278 void FormEventReport::SendFirstAddFormEvent(const FormEventName &eventName, HiSysEventType type,
279     const NewFormEventInfo &eventInfo)
280 {
281     std::string name = ConvertEventName(eventName);
282     if (name == "INVALIDEVENTNAME") {
283         HILOG_ERROR("invalid eventName");
284         return;
285     }
286     if (eventName == FormEventName::FIRST_ADD_FORM_DURATION) {
287         HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
288             EVENT_KEY_SESSION_ID, static_cast<int64_t>(eventInfo.sessionId),
289             EVENT_KEY_FORM_ID, eventInfo.formId,
290             EVENT_KEY_BIND_DURATION, static_cast<float>(eventInfo.bindDuration),
291             EVENT_KEY_GET_DURATION, static_cast<float>(eventInfo.getDuration),
292             EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
293             EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
294             EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
295             EVENT_KEY_FORM_NAME, eventInfo.formName,
296             EVENT_KEY_FORM_DIMENSION, static_cast<int64_t>(eventInfo.formDimension),
297             EVENT_KEY_ACQUIRE_DURATION, static_cast<float>(eventInfo.acquireDuration));
298     }
299 }
300 
SendFirstUpdateFormEvent(const FormEventName & eventName,HiSysEventType type,const NewFormEventInfo & eventInfo)301 void FormEventReport::SendFirstUpdateFormEvent(const FormEventName &eventName, HiSysEventType type,
302     const NewFormEventInfo &eventInfo)
303 {
304     std::string name = ConvertEventName(eventName);
305     if (name == "INVALIDEVENTNAME") {
306         HILOG_ERROR("invalid eventName");
307         return;
308     }
309     if (eventName == FormEventName::FIRST_UPDATE_FORM_DURATION) {
310         HiSysEventWrite(HiSysEvent::Domain::FORM_MANAGER, name, type,
311             EVENT_KEY_SESSION_ID, static_cast<int64_t>(eventInfo.sessionId),
312             EVENT_KEY_FORM_ID, eventInfo.formId,
313             EVENT_KEY_DURATION, static_cast<float>(eventInfo.duration),
314             EVENT_KEY_DURATION_TYPE, eventInfo.durationType);
315     }
316 }
317 
ConvertEventName(const FormEventName & eventName)318 std::string FormEventReport::ConvertEventName(const FormEventName &eventName)
319 {
320     auto it = EVENT_NAME_MAP.find(eventName);
321     if (it != EVENT_NAME_MAP.end()) {
322         return it->second;
323     }
324     return "INVALIDEVENTNAME";
325 }
326 } // namespace AppExecFwk
327 } // namespace OHOS
328