1 /*
2 * Copyright (c) 2024 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 "dfx/distributed_radar.h"
17
18 #include "bundle/bundle_manager_internal.h"
19 #include "dtbschedmgr_device_info_storage.h"
20 #include "hisysevent.h"
21
22 namespace OHOS {
23 namespace DistributedSchedule {
24 const std::string TAG = "DmsRadar";
25 IMPLEMENT_SINGLE_INSTANCE(DmsRadar);
26
RegisterFocusedRes(const std::string & func,int32_t errCode)27 bool DmsRadar::RegisterFocusedRes(const std::string& func, int32_t errCode)
28 {
29 int32_t res = ERR_OK;
30 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
31 if (stageRes == StageRes::STAGE_SUCC) {
32 res = HiSysEventWrite(
33 APP_CONTINUE_DOMAIN,
34 APPLICATION_CONTINUE_BEHAVIOR,
35 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
36 ORG_PKG, ORG_PKG_NAME,
37 FUNC, func,
38 BIZ_SCENE, static_cast<int32_t>(BizScene::DMS_INIT),
39 BIZ_STAGE, static_cast<int32_t>(DmsInit::REGISTER_ABILITY_FOCUSED),
40 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
41 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_START));
42 } else {
43 res = HiSysEventWrite(
44 APP_CONTINUE_DOMAIN,
45 APPLICATION_CONTINUE_BEHAVIOR,
46 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
47 ORG_PKG, ORG_PKG_NAME,
48 FUNC, func,
49 BIZ_SCENE, static_cast<int32_t>(BizScene::DMS_INIT),
50 BIZ_STAGE, static_cast<int32_t>(DmsInit::REGISTER_ABILITY_FOCUSED),
51 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
52 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_START),
53 ERROR_CODE, errCode);
54 }
55 if (res != ERR_OK) {
56 HILOGE("RegisterFocusedRes error, res:%{public}d", res);
57 return false;
58 }
59 return true;
60 }
61
RegisterSoftbusCallbackRes(const std::string & func,int32_t errCode)62 bool DmsRadar::RegisterSoftbusCallbackRes(const std::string& func, int32_t errCode)
63 {
64 int32_t res = ERR_OK;
65 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
66 if (stageRes == StageRes::STAGE_SUCC) {
67 res = HiSysEventWrite(
68 APP_CONTINUE_DOMAIN,
69 APPLICATION_CONTINUE_BEHAVIOR,
70 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
71 ORG_PKG, ORG_PKG_NAME,
72 FUNC, func,
73 BIZ_SCENE, static_cast<int32_t>(BizScene::DMS_INIT),
74 BIZ_STAGE, static_cast<int32_t>(DmsInit::REGISTER_SOFTBUS_CALLBACK),
75 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
76 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
77 TO_CALL_PKG, ABILITY_MANAGER_SERVICE);
78 } else {
79 res = HiSysEventWrite(
80 APP_CONTINUE_DOMAIN,
81 APPLICATION_CONTINUE_BEHAVIOR,
82 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
83 ORG_PKG, ORG_PKG_NAME,
84 FUNC, func,
85 BIZ_SCENE, static_cast<int32_t>(BizScene::DMS_INIT),
86 BIZ_STAGE, static_cast<int32_t>(DmsInit::REGISTER_SOFTBUS_CALLBACK),
87 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
88 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
89 TO_CALL_PKG, ABILITY_MANAGER_SERVICE,
90 ERROR_CODE, errCode);
91 }
92 if (res != ERR_OK) {
93 HILOGE("RegisterSoftbusCallbackRes error, res:%{public}d", res);
94 return false;
95 }
96 return true;
97 }
98
DmsFocused(const std::string & func,std::string focusMode)99 bool DmsRadar::DmsFocused(const std::string& func, std::string focusMode)
100 {
101 int32_t res = HiSysEventWrite(
102 APP_CONTINUE_DOMAIN,
103 APPLICATION_CONTINUE_BEHAVIOR,
104 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
105 ORG_PKG, ORG_PKG_NAME,
106 FUNC, func,
107 BIZ_SCENE, static_cast<int32_t>(BizScene::NORMAL_MULTIMODE_FOCUSED),
108 BIZ_STAGE, static_cast<int32_t>(NormalOrMultimodeFocused::DMS_FOCUSED),
109 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
110 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_START),
111 "FOCUS_MODE", focusMode);
112 if (res != ERR_OK) {
113 HILOGE("DmsFocused error, res:%{public}d", res);
114 return false;
115 }
116 return true;
117 }
118
NormalFocusedGetAccessTokenIdRes(const std::string & func,int32_t errCode)119 bool DmsRadar::NormalFocusedGetAccessTokenIdRes(const std::string& func, int32_t errCode)
120 {
121 int32_t res = ERR_OK;
122 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
123 if (stageRes == StageRes::STAGE_SUCC) {
124 res = HiSysEventWrite(
125 APP_CONTINUE_DOMAIN,
126 APPLICATION_CONTINUE_BEHAVIOR,
127 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
128 ORG_PKG, ORG_PKG_NAME,
129 FUNC, func,
130 BIZ_SCENE, static_cast<int32_t>(BizScene::NORMAL_MULTIMODE_FOCUSED),
131 BIZ_STAGE, static_cast<int32_t>(NormalOrMultimodeFocused::GET_BMS_ACCESSTOKENID),
132 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
133 TO_CALL_PKG, BMS_PKG_NAME);
134 } else {
135 res = HiSysEventWrite(
136 APP_CONTINUE_DOMAIN,
137 APPLICATION_CONTINUE_BEHAVIOR,
138 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
139 ORG_PKG, ORG_PKG_NAME,
140 FUNC, func,
141 BIZ_SCENE, static_cast<int32_t>(BizScene::NORMAL_MULTIMODE_FOCUSED),
142 BIZ_STAGE, static_cast<int32_t>(NormalOrMultimodeFocused::GET_BMS_ACCESSTOKENID),
143 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
144 TO_CALL_PKG, BMS_PKG_NAME,
145 ERROR_CODE, errCode);
146 }
147 if (res != ERR_OK) {
148 HILOGE("NormalFocusedGetAccessTokenIdRes error, res:%{public}d", res);
149 return false;
150 }
151 return true;
152 }
153
NormalFocusedSendEventRes(const std::string & func,int32_t errCode)154 bool DmsRadar::NormalFocusedSendEventRes(const std::string& func, int32_t errCode)
155 {
156 int32_t res = ERR_OK;
157 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
158 if (stageRes == StageRes::STAGE_SUCC) {
159 res = HiSysEventWrite(
160 APP_CONTINUE_DOMAIN,
161 APPLICATION_CONTINUE_BEHAVIOR,
162 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
163 ORG_PKG, ORG_PKG_NAME,
164 FUNC, func,
165 BIZ_SCENE, static_cast<int32_t>(BizScene::NORMAL_MULTIMODE_FOCUSED),
166 BIZ_STAGE, static_cast<int32_t>(NormalOrMultimodeFocused::SOFTBUS_SENDEVENT),
167 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
168 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
169 TO_CALL_PKG, DSOFTBUS_PKG_NAME);
170 } else {
171 res = HiSysEventWrite(
172 APP_CONTINUE_DOMAIN,
173 APPLICATION_CONTINUE_BEHAVIOR,
174 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
175 ORG_PKG, ORG_PKG_NAME,
176 FUNC, func,
177 BIZ_SCENE, static_cast<int32_t>(BizScene::NORMAL_MULTIMODE_FOCUSED),
178 BIZ_STAGE, static_cast<int32_t>(NormalOrMultimodeFocused::SOFTBUS_SENDEVENT),
179 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
180 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
181 TO_CALL_PKG, DSOFTBUS_PKG_NAME,
182 ERROR_CODE, errCode);
183 }
184 if (res != ERR_OK) {
185 HILOGE("NormalFocusedSendEventRes error, res:%{public}d", res);
186 return false;
187 }
188 return true;
189 }
190
SetFocusedState(const std::string & func)191 bool DmsRadar::SetFocusedState(const std::string& func)
192 {
193 int32_t res = HiSysEventWrite(
194 APP_CONTINUE_DOMAIN,
195 APPLICATION_CONTINUE_BEHAVIOR,
196 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
197 ORG_PKG, ORG_PKG_NAME,
198 FUNC, func,
199 BIZ_SCENE, static_cast<int32_t>(BizScene::CHANGE_STATE_FOCUSED),
200 BIZ_STAGE, static_cast<int32_t>(ChangeStateFocused::SET_STATE),
201 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
202 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_START));
203 if (res != ERR_OK) {
204 HILOGE("SetFocusedState error, res:%{public}d", res);
205 return false;
206 }
207 return true;
208 }
209
ChangeStateFocusedGetAccessTokenIdRes(const std::string & func,int32_t errCode)210 bool DmsRadar::ChangeStateFocusedGetAccessTokenIdRes(const std::string& func, int32_t errCode)
211 {
212 int32_t res = ERR_OK;
213 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
214 if (stageRes == StageRes::STAGE_SUCC) {
215 res = HiSysEventWrite(
216 APP_CONTINUE_DOMAIN,
217 APPLICATION_CONTINUE_BEHAVIOR,
218 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
219 ORG_PKG, ORG_PKG_NAME,
220 FUNC, func,
221 BIZ_SCENE, static_cast<int32_t>(BizScene::CHANGE_STATE_FOCUSED),
222 BIZ_STAGE, static_cast<int32_t>(ChangeStateFocused::GET_BMS_ACCESSTOKENID),
223 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
224 TO_CALL_PKG, BMS_PKG_NAME);
225 } else {
226 res = HiSysEventWrite(
227 APP_CONTINUE_DOMAIN,
228 APPLICATION_CONTINUE_BEHAVIOR,
229 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
230 ORG_PKG, ORG_PKG_NAME,
231 FUNC, func,
232 BIZ_SCENE, static_cast<int32_t>(BizScene::CHANGE_STATE_FOCUSED),
233 BIZ_STAGE, static_cast<int32_t>(ChangeStateFocused::GET_BMS_ACCESSTOKENID),
234 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
235 TO_CALL_PKG, BMS_PKG_NAME,
236 ERROR_CODE, errCode);
237 }
238 if (res != ERR_OK) {
239 HILOGE("ChangeStateFocusedGetAccessTokenIdRes error, res:%{public}d", res);
240 return false;
241 }
242 return true;
243 }
244
ChangeStateFocusedSendEventRes(const std::string & func,int32_t errCode)245 bool DmsRadar::ChangeStateFocusedSendEventRes(const std::string& func, int32_t errCode)
246 {
247 int32_t res = ERR_OK;
248 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
249 if (stageRes == StageRes::STAGE_SUCC) {
250 res = HiSysEventWrite(
251 APP_CONTINUE_DOMAIN,
252 APPLICATION_CONTINUE_BEHAVIOR,
253 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
254 ORG_PKG, ORG_PKG_NAME,
255 FUNC, func,
256 BIZ_SCENE, static_cast<int32_t>(BizScene::CHANGE_STATE_FOCUSED),
257 BIZ_STAGE, static_cast<int32_t>(ChangeStateFocused::SOFTBUS_SENDEVENT),
258 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
259 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
260 TO_CALL_PKG, DSOFTBUS_PKG_NAME);
261 } else {
262 res = HiSysEventWrite(
263 APP_CONTINUE_DOMAIN,
264 APPLICATION_CONTINUE_BEHAVIOR,
265 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
266 ORG_PKG, ORG_PKG_NAME,
267 FUNC, func,
268 BIZ_SCENE, static_cast<int32_t>(BizScene::CHANGE_STATE_FOCUSED),
269 BIZ_STAGE, static_cast<int32_t>(ChangeStateFocused::SOFTBUS_SENDEVENT),
270 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
271 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
272 TO_CALL_PKG, DSOFTBUS_PKG_NAME,
273 ERROR_CODE, errCode);
274 }
275 if (res != ERR_OK) {
276 HILOGE("ChangeStateFocusedSendEventRes error, res:%{public}d", res);
277 return false;
278 }
279 return true;
280 }
281
DmsUnfocused(const std::string & func)282 bool DmsRadar::DmsUnfocused(const std::string& func)
283 {
284 int32_t res = HiSysEventWrite(
285 APP_CONTINUE_DOMAIN,
286 APPLICATION_CONTINUE_BEHAVIOR,
287 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
288 ORG_PKG, ORG_PKG_NAME,
289 FUNC, func,
290 BIZ_SCENE, static_cast<int32_t>(BizScene::NORMAL_UNFOCUSED),
291 BIZ_STAGE, static_cast<int32_t>(NormalUnfocused::DMS_UNFOCUSED),
292 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
293 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_START));
294 if (res != ERR_OK) {
295 HILOGE("DmsUnfocused error, res:%{public}d", res);
296 return false;
297 }
298 return true;
299 }
300
NormalUnfocusedGetAccessTokenIdRes(const std::string & func,int32_t errCode)301 bool DmsRadar::NormalUnfocusedGetAccessTokenIdRes(const std::string& func, int32_t errCode)
302 {
303 int32_t res = ERR_OK;
304 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
305 if (stageRes == StageRes::STAGE_SUCC) {
306 res = HiSysEventWrite(
307 APP_CONTINUE_DOMAIN,
308 APPLICATION_CONTINUE_BEHAVIOR,
309 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
310 ORG_PKG, ORG_PKG_NAME,
311 FUNC, func,
312 BIZ_SCENE, static_cast<int32_t>(BizScene::NORMAL_UNFOCUSED),
313 BIZ_STAGE, static_cast<int32_t>(NormalUnfocused::GET_BMS_ACCESSTOKENID),
314 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
315 TO_CALL_PKG, BMS_PKG_NAME);
316 } else {
317 res = HiSysEventWrite(
318 APP_CONTINUE_DOMAIN,
319 APPLICATION_CONTINUE_BEHAVIOR,
320 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
321 ORG_PKG, ORG_PKG_NAME,
322 FUNC, func,
323 BIZ_SCENE, static_cast<int32_t>(BizScene::NORMAL_UNFOCUSED),
324 BIZ_STAGE, static_cast<int32_t>(NormalUnfocused::GET_BMS_ACCESSTOKENID),
325 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
326 TO_CALL_PKG, BMS_PKG_NAME,
327 ERROR_CODE, errCode);
328 }
329 if (res != ERR_OK) {
330 HILOGE("NormalUnfocusedGetAccessTokenIdRes error, res:%{public}d", res);
331 return false;
332 }
333 return true;
334 }
335
NormalUnfocusedSendEventRes(const std::string & func,int32_t errCode)336 bool DmsRadar::NormalUnfocusedSendEventRes(const std::string& func, int32_t errCode)
337 {
338 int32_t res = ERR_OK;
339 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
340 if (stageRes == StageRes::STAGE_SUCC) {
341 res = HiSysEventWrite(
342 APP_CONTINUE_DOMAIN,
343 APPLICATION_CONTINUE_BEHAVIOR,
344 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
345 ORG_PKG, ORG_PKG_NAME,
346 FUNC, func,
347 BIZ_SCENE, static_cast<int32_t>(BizScene::NORMAL_UNFOCUSED),
348 BIZ_STAGE, static_cast<int32_t>(NormalUnfocused::SOFTBUS_SENDEVENT),
349 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
350 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
351 TO_CALL_PKG, DSOFTBUS_PKG_NAME);
352 } else {
353 res = HiSysEventWrite(
354 APP_CONTINUE_DOMAIN,
355 APPLICATION_CONTINUE_BEHAVIOR,
356 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
357 ORG_PKG, ORG_PKG_NAME,
358 FUNC, func,
359 BIZ_SCENE, static_cast<int32_t>(BizScene::NORMAL_UNFOCUSED),
360 BIZ_STAGE, static_cast<int32_t>(NormalUnfocused::SOFTBUS_SENDEVENT),
361 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
362 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
363 TO_CALL_PKG, DSOFTBUS_PKG_NAME,
364 ERROR_CODE, errCode);
365 }
366 if (res != ERR_OK) {
367 HILOGE("NormalUnfocusedSendEventRes error, res:%{public}d", res);
368 return false;
369 }
370 return true;
371 }
372
RecordTime(const std::string & func)373 bool DmsRadar::RecordTime(const std::string& func)
374 {
375 int32_t res = HiSysEventWrite(
376 APP_CONTINUE_DOMAIN,
377 APPLICATION_CONTINUE_BEHAVIOR,
378 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
379 ORG_PKG, ORG_PKG_NAME,
380 FUNC, func,
381 BIZ_SCENE, static_cast<int32_t>(BizScene::MULTIMODE_UNFOCUSED),
382 BIZ_STAGE, static_cast<int32_t>(MultimodeUnfocused::RECORD_TIME),
383 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
384 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_START));
385 if (res != ERR_OK) {
386 HILOGE("RecordTime error, res:%{public}d", res);
387 return false;
388 }
389 return true;
390 }
391
MultimodeUnfocusedGetAccessTokenIdRes(const std::string & func,int32_t errCode)392 bool DmsRadar::MultimodeUnfocusedGetAccessTokenIdRes(const std::string& func, int32_t errCode)
393 {
394 int32_t res = ERR_OK;
395 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
396 if (stageRes == StageRes::STAGE_SUCC) {
397 res = HiSysEventWrite(
398 APP_CONTINUE_DOMAIN,
399 APPLICATION_CONTINUE_BEHAVIOR,
400 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
401 ORG_PKG, ORG_PKG_NAME,
402 FUNC, func,
403 BIZ_SCENE, static_cast<int32_t>(BizScene::MULTIMODE_UNFOCUSED),
404 BIZ_STAGE, static_cast<int32_t>(MultimodeUnfocused::GET_BMS_ACCESSTOKENID),
405 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
406 TO_CALL_PKG, BMS_PKG_NAME);
407 } else {
408 res = HiSysEventWrite(
409 APP_CONTINUE_DOMAIN,
410 APPLICATION_CONTINUE_BEHAVIOR,
411 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
412 ORG_PKG, ORG_PKG_NAME,
413 FUNC, func,
414 BIZ_SCENE, static_cast<int32_t>(BizScene::MULTIMODE_UNFOCUSED),
415 BIZ_STAGE, static_cast<int32_t>(MultimodeUnfocused::GET_BMS_ACCESSTOKENID),
416 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
417 TO_CALL_PKG, BMS_PKG_NAME,
418 ERROR_CODE, errCode);
419 }
420 if (res != ERR_OK) {
421 HILOGE("MultimodeUnfocusedGetAccessTokenIdRes error, res:%{public}d", res);
422 return false;
423 }
424 return true;
425 }
426
MultimodeUnfocusedSendEventRes(const std::string & func,int32_t errCode)427 bool DmsRadar::MultimodeUnfocusedSendEventRes(const std::string& func, int32_t errCode)
428 {
429 int32_t res = ERR_OK;
430 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
431 if (stageRes == StageRes::STAGE_SUCC) {
432 res = HiSysEventWrite(
433 APP_CONTINUE_DOMAIN,
434 APPLICATION_CONTINUE_BEHAVIOR,
435 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
436 ORG_PKG, ORG_PKG_NAME,
437 FUNC, func,
438 BIZ_SCENE, static_cast<int32_t>(BizScene::MULTIMODE_UNFOCUSED),
439 BIZ_STAGE, static_cast<int32_t>(MultimodeUnfocused::SOFTBUS_SENDEVENT),
440 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
441 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
442 TO_CALL_PKG, DSOFTBUS_PKG_NAME);
443 } else {
444 res = HiSysEventWrite(
445 APP_CONTINUE_DOMAIN,
446 APPLICATION_CONTINUE_BEHAVIOR,
447 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
448 ORG_PKG, ORG_PKG_NAME,
449 FUNC, func,
450 BIZ_SCENE, static_cast<int32_t>(BizScene::MULTIMODE_UNFOCUSED),
451 BIZ_STAGE, static_cast<int32_t>(MultimodeUnfocused::SOFTBUS_SENDEVENT),
452 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
453 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
454 TO_CALL_PKG, DSOFTBUS_PKG_NAME,
455 ERROR_CODE, errCode);
456 }
457 if (res != ERR_OK) {
458 HILOGE("MultimodeUnfocusedSendEventRes error, res:%{public}d", res);
459 return false;
460 }
461 return true;
462 }
463
SetUnfocusedState(const std::string & func)464 bool DmsRadar::SetUnfocusedState(const std::string& func)
465 {
466 int32_t res = HiSysEventWrite(
467 APP_CONTINUE_DOMAIN,
468 APPLICATION_CONTINUE_BEHAVIOR,
469 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
470 ORG_PKG, ORG_PKG_NAME,
471 FUNC, func,
472 BIZ_SCENE, static_cast<int32_t>(BizScene::CHANGE_STATE_UNFOCUSED),
473 BIZ_STAGE, static_cast<int32_t>(ChangeStateUnfocused::SET_STATE),
474 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
475 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_START));
476 if (res != ERR_OK) {
477 HILOGE("SetFocusedState error, res:%{public}d", res);
478 return false;
479 }
480 return true;
481 }
482
ChangeStateUnfocusedGetAccessTokenIdRes(const std::string & func,int32_t errCode)483 bool DmsRadar::ChangeStateUnfocusedGetAccessTokenIdRes(const std::string& func, int32_t errCode)
484 {
485 int32_t res = ERR_OK;
486 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
487 if (stageRes == StageRes::STAGE_SUCC) {
488 res = HiSysEventWrite(
489 APP_CONTINUE_DOMAIN,
490 APPLICATION_CONTINUE_BEHAVIOR,
491 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
492 ORG_PKG, ORG_PKG_NAME,
493 FUNC, func,
494 BIZ_SCENE, static_cast<int32_t>(BizScene::CHANGE_STATE_UNFOCUSED),
495 BIZ_STAGE, static_cast<int32_t>(ChangeStateUnfocused::GET_BMS_ACCESSTOKENID),
496 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
497 TO_CALL_PKG, BMS_PKG_NAME);
498 } else {
499 res = HiSysEventWrite(
500 APP_CONTINUE_DOMAIN,
501 APPLICATION_CONTINUE_BEHAVIOR,
502 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
503 ORG_PKG, ORG_PKG_NAME,
504 FUNC, func,
505 BIZ_SCENE, static_cast<int32_t>(BizScene::CHANGE_STATE_UNFOCUSED),
506 BIZ_STAGE, static_cast<int32_t>(ChangeStateUnfocused::GET_BMS_ACCESSTOKENID),
507 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
508 TO_CALL_PKG, BMS_PKG_NAME,
509 ERROR_CODE, errCode);
510 }
511 if (res != ERR_OK) {
512 HILOGE("ChangeStateUnfocusedGetAccessTokenIdRes error, res:%{public}d", res);
513 return false;
514 }
515 return true;
516 }
517
ChangeStateUnfocusedSendEventRes(const std::string & func,int32_t errCode)518 bool DmsRadar::ChangeStateUnfocusedSendEventRes(const std::string& func, int32_t errCode)
519 {
520 int32_t res = ERR_OK;
521 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
522 if (stageRes == StageRes::STAGE_SUCC) {
523 res = HiSysEventWrite(
524 APP_CONTINUE_DOMAIN,
525 APPLICATION_CONTINUE_BEHAVIOR,
526 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
527 ORG_PKG, ORG_PKG_NAME,
528 FUNC, func,
529 BIZ_SCENE, static_cast<int32_t>(BizScene::CHANGE_STATE_UNFOCUSED),
530 BIZ_STAGE, static_cast<int32_t>(ChangeStateUnfocused::SOFTBUS_SENDEVENT),
531 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
532 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
533 TO_CALL_PKG, DSOFTBUS_PKG_NAME);
534 } else {
535 res = HiSysEventWrite(
536 APP_CONTINUE_DOMAIN,
537 APPLICATION_CONTINUE_BEHAVIOR,
538 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
539 ORG_PKG, ORG_PKG_NAME,
540 FUNC, func,
541 BIZ_SCENE, static_cast<int32_t>(BizScene::CHANGE_STATE_UNFOCUSED),
542 BIZ_STAGE, static_cast<int32_t>(ChangeStateUnfocused::SOFTBUS_SENDEVENT),
543 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
544 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
545 TO_CALL_PKG, DSOFTBUS_PKG_NAME,
546 ERROR_CODE, errCode);
547 }
548 if (res != ERR_OK) {
549 HILOGE("ChangeStateUnfocusedSendEventRes error, res:%{public}d", res);
550 return false;
551 }
552 return true;
553 }
554
RecvFocused(const std::string & func)555 bool DmsRadar::RecvFocused(const std::string& func)
556 {
557 int32_t res = HiSysEventWrite(
558 APP_CONTINUE_DOMAIN,
559 APPLICATION_CONTINUE_BEHAVIOR,
560 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
561 ORG_PKG, ORG_PKG_NAME,
562 FUNC, func,
563 BIZ_SCENE, static_cast<int32_t>(BizScene::RECV_FOCUSED),
564 BIZ_STAGE, static_cast<int32_t>(RecvFocused::RECV_FOCUSED),
565 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
566 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_START),
567 "BROADCAST_INFO", FOCUSED,
568 HOST_PKG, DSOFTBUS_PKG_NAME);
569 if (res != ERR_OK) {
570 HILOGE("RecvFocused error, res:%{public}d", res);
571 return false;
572 }
573 return true;
574 }
575
FocusedGetBundleName(const std::string & func,int32_t errCode)576 bool DmsRadar::FocusedGetBundleName(const std::string& func, int32_t errCode)
577 {
578 int32_t res = ERR_OK;
579 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
580 if (stageRes == StageRes::STAGE_SUCC) {
581 res = HiSysEventWrite(
582 APP_CONTINUE_DOMAIN,
583 APPLICATION_CONTINUE_BEHAVIOR,
584 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
585 ORG_PKG, ORG_PKG_NAME,
586 FUNC, func,
587 BIZ_SCENE, static_cast<int32_t>(BizScene::RECV_FOCUSED),
588 BIZ_STAGE, static_cast<int32_t>(RecvFocused::GET_DBMS_BUNDLENAME),
589 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
590 TO_CALL_PKG, DBMS_PKG_NAME);
591 } else {
592 res = HiSysEventWrite(
593 APP_CONTINUE_DOMAIN,
594 APPLICATION_CONTINUE_BEHAVIOR,
595 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
596 ORG_PKG, ORG_PKG_NAME,
597 FUNC, func,
598 BIZ_SCENE, static_cast<int32_t>(BizScene::RECV_FOCUSED),
599 BIZ_STAGE, static_cast<int32_t>(RecvFocused::GET_DBMS_BUNDLENAME),
600 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
601 TO_CALL_PKG, DBMS_PKG_NAME,
602 ERROR_CODE, errCode);
603 }
604 if (res != ERR_OK) {
605 HILOGE("FocusedGetBundleName error, res:%{public}d", res);
606 return false;
607 }
608 return true;
609 }
610
NotifyDockFocused(const std::string & func,int32_t errCode)611 bool DmsRadar::NotifyDockFocused(const std::string& func, int32_t errCode)
612 {
613 int32_t res = ERR_OK;
614 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
615 if (stageRes == StageRes::STAGE_SUCC) {
616 res = HiSysEventWrite(
617 APP_CONTINUE_DOMAIN,
618 APPLICATION_CONTINUE_BEHAVIOR,
619 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
620 ORG_PKG, ORG_PKG_NAME,
621 FUNC, func,
622 BIZ_SCENE, static_cast<int32_t>(BizScene::RECV_FOCUSED),
623 BIZ_STAGE, static_cast<int32_t>(RecvFocused::NOTIFY_DOCK_FOCUSED),
624 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC));
625 } else {
626 res = HiSysEventWrite(
627 APP_CONTINUE_DOMAIN,
628 APPLICATION_CONTINUE_BEHAVIOR,
629 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
630 ORG_PKG, ORG_PKG_NAME,
631 FUNC, func,
632 BIZ_SCENE, static_cast<int32_t>(BizScene::RECV_FOCUSED),
633 BIZ_STAGE, static_cast<int32_t>(RecvFocused::NOTIFY_DOCK_FOCUSED),
634 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
635 ERROR_CODE, errCode);
636 }
637 if (res != ERR_OK) {
638 HILOGE("NotifyDockFocused error, res:%{public}d", res);
639 return false;
640 }
641 return true;
642 }
643
RecvUnfocused(const std::string & func)644 bool DmsRadar::RecvUnfocused(const std::string& func)
645 {
646 int32_t res = HiSysEventWrite(
647 APP_CONTINUE_DOMAIN,
648 APPLICATION_CONTINUE_BEHAVIOR,
649 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
650 ORG_PKG, ORG_PKG_NAME,
651 FUNC, func,
652 BIZ_SCENE, static_cast<int32_t>(BizScene::RECV_UNFOCUSED),
653 BIZ_STAGE, static_cast<int32_t>(RecvUnfocused::RECV_UNFOCUSED),
654 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
655 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_START),
656 "BROADCAST_INFO", UNFOCUSED,
657 TO_CALL_PKG, DSOFTBUS_PKG_NAME);
658 if (res != ERR_OK) {
659 HILOGE("RecvUnfocused error, res:%{public}d", res);
660 return false;
661 }
662 return true;
663 }
664
UnfocusedGetBundleName(const std::string & func,int32_t errCode)665 bool DmsRadar::UnfocusedGetBundleName(const std::string& func, int32_t errCode)
666 {
667 int32_t res = ERR_OK;
668 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
669 if (stageRes == StageRes::STAGE_SUCC) {
670 res = HiSysEventWrite(
671 APP_CONTINUE_DOMAIN,
672 APPLICATION_CONTINUE_BEHAVIOR,
673 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
674 ORG_PKG, ORG_PKG_NAME,
675 FUNC, func,
676 BIZ_SCENE, static_cast<int32_t>(BizScene::RECV_UNFOCUSED),
677 BIZ_STAGE, static_cast<int32_t>(RecvUnfocused::GET_DBMS_BUNDLENAME),
678 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
679 TO_CALL_PKG, DBMS_PKG_NAME);
680 } else {
681 res = HiSysEventWrite(
682 APP_CONTINUE_DOMAIN,
683 APPLICATION_CONTINUE_BEHAVIOR,
684 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
685 ORG_PKG, ORG_PKG_NAME,
686 FUNC, func,
687 BIZ_SCENE, static_cast<int32_t>(BizScene::RECV_UNFOCUSED),
688 BIZ_STAGE, static_cast<int32_t>(RecvUnfocused::GET_DBMS_BUNDLENAME),
689 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
690 TO_CALL_PKG, DBMS_PKG_NAME,
691 ERROR_CODE, errCode);
692 }
693 if (res != ERR_OK) {
694 HILOGE("UnfocusedGetBundleName error, res:%{public}d", res);
695 return false;
696 }
697 return true;
698 }
699
NotifyDockUnfocused(const std::string & func,int32_t errCode)700 bool DmsRadar::NotifyDockUnfocused(const std::string& func, int32_t errCode)
701 {
702 int32_t res = ERR_OK;
703 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
704 if (stageRes == StageRes::STAGE_SUCC) {
705 res = HiSysEventWrite(
706 APP_CONTINUE_DOMAIN,
707 APPLICATION_CONTINUE_BEHAVIOR,
708 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
709 ORG_PKG, ORG_PKG_NAME,
710 FUNC, func,
711 BIZ_SCENE, static_cast<int32_t>(BizScene::RECV_UNFOCUSED),
712 BIZ_STAGE, static_cast<int32_t>(RecvUnfocused::NOTIFY_DOCK_UNFOCUSED),
713 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC));
714 } else {
715 res = HiSysEventWrite(
716 APP_CONTINUE_DOMAIN,
717 APPLICATION_CONTINUE_BEHAVIOR,
718 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
719 ORG_PKG, ORG_PKG_NAME,
720 FUNC, func,
721 BIZ_SCENE, static_cast<int32_t>(BizScene::RECV_UNFOCUSED),
722 BIZ_STAGE, static_cast<int32_t>(RecvUnfocused::NOTIFY_DOCK_UNFOCUSED),
723 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
724 ERROR_CODE, errCode);
725 }
726 if (res != ERR_OK) {
727 HILOGE("NotifyDockUnfocused error, res:%{public}d", res);
728 return false;
729 }
730 return true;
731 }
732
ClickIconDmsContinue(const std::string & func,int32_t errCode,std::string peerDeviceId,const std::string & srcBundleName,const std::string & dstBundleName)733 bool DmsRadar::ClickIconDmsContinue(const std::string& func, int32_t errCode, std::string peerDeviceId,
734 const std::string& srcBundleName, const std::string& dstBundleName)
735 {
736 std::string peerUdid = DtbschedmgrDeviceInfoStorage::GetInstance().GetUdidByNetworkId(peerDeviceId);
737
738 DmsBundleInfo srcBundleInfo;
739 DmsBmStorage::GetInstance()->GetStorageDistributeInfo(peerDeviceId, srcBundleName, srcBundleInfo);
740
741 AppExecFwk::BundleInfo dstBundleInfo;
742 BundleManagerInternal::GetLocalBundleInfoV9(dstBundleName, dstBundleInfo);
743
744 int32_t res = ERR_OK;
745 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
746 if (stageRes == StageRes::STAGE_SUCC) {
747 res = HiSysEventWrite(
748 APP_CONTINUE_DOMAIN,
749 APPLICATION_CONTINUE_BEHAVIOR,
750 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
751 ORG_PKG, ORG_PKG_NAME,
752 FUNC, func,
753 BIZ_SCENE, static_cast<int32_t>(BizScene::CLICK_ICON),
754 BIZ_STAGE, static_cast<int32_t>(ClickIcon::DMS_CONTINUE),
755 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
756 PEER_UDID, GetAnonyUdid(peerUdid),
757 APP_CALLEE, srcBundleName,
758 APP_CALLER, dstBundleName,
759 LOCAL_APP_VERSION, dstBundleInfo.versionName,
760 PEER_APP_VERSION, srcBundleInfo.versionName);
761 } else {
762 res = HiSysEventWrite(
763 APP_CONTINUE_DOMAIN,
764 APPLICATION_CONTINUE_BEHAVIOR,
765 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
766 ORG_PKG, ORG_PKG_NAME,
767 FUNC, func,
768 BIZ_SCENE, static_cast<int32_t>(BizScene::CLICK_ICON),
769 BIZ_STAGE, static_cast<int32_t>(ClickIcon::DMS_CONTINUE),
770 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
771 PEER_UDID, GetAnonyUdid(peerUdid),
772 APP_CALLEE, srcBundleName,
773 APP_CALLER, dstBundleName,
774 LOCAL_APP_VERSION, dstBundleInfo.versionName,
775 PEER_APP_VERSION, srcBundleInfo.versionName,
776 ERROR_CODE, errCode);
777 }
778 if (res != ERR_OK) {
779 HILOGE("ClickIconDmsContinue error, res:%{public}d", res);
780 return false;
781 }
782 return true;
783 }
784
ClickIconDmsStartAbility(const std::string & func,int32_t errCode)785 bool DmsRadar::ClickIconDmsStartAbility(const std::string& func, int32_t errCode)
786 {
787 int32_t res = ERR_OK;
788 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
789 if (stageRes == StageRes::STAGE_SUCC) {
790 res = HiSysEventWrite(
791 APP_CONTINUE_DOMAIN,
792 APPLICATION_CONTINUE_BEHAVIOR,
793 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
794 ORG_PKG, ORG_PKG_NAME,
795 FUNC, func,
796 BIZ_SCENE, static_cast<int32_t>(BizScene::CLICK_ICON),
797 BIZ_STAGE, static_cast<int32_t>(ClickIcon::DMS_STARTABILITY),
798 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
799 TO_CALL_PKG, ABILITY_MANAGER_SERVICE);
800 } else {
801 res = HiSysEventWrite(
802 APP_CONTINUE_DOMAIN,
803 APPLICATION_CONTINUE_BEHAVIOR,
804 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
805 ORG_PKG, ORG_PKG_NAME,
806 FUNC, func,
807 BIZ_SCENE, static_cast<int32_t>(BizScene::CLICK_ICON),
808 BIZ_STAGE, static_cast<int32_t>(ClickIcon::DMS_STARTABILITY),
809 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
810 TO_CALL_PKG, ABILITY_MANAGER_SERVICE,
811 ERROR_CODE, errCode);
812 }
813 if (res != ERR_OK) {
814 HILOGE("ClickIconDmsStartAbility error, res:%{public}d", res);
815 return false;
816 }
817 return true;
818 }
819
ClickIconDmsRecvOver(const std::string & func,int32_t errCode)820 bool DmsRadar::ClickIconDmsRecvOver(const std::string& func, int32_t errCode)
821 {
822 int32_t res = ERR_OK;
823 StageRes stageRes = (errCode == ERR_OK || errCode == MISSION_NOT_FOCUSED ||
824 errCode == MISSION_NOT_CONTINUE_ACTIVE || errCode == CONTINUE_ON_CONTINUE_FAILED ||
825 errCode == CONTINUE_REMOTE_VERSION_MISMATCH) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
826 if (stageRes == StageRes::STAGE_SUCC) {
827 res = HiSysEventWrite(
828 APP_CONTINUE_DOMAIN,
829 APPLICATION_CONTINUE_BEHAVIOR,
830 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
831 ORG_PKG, ORG_PKG_NAME,
832 FUNC, func,
833 BIZ_SCENE, static_cast<int32_t>(BizScene::CLICK_ICON),
834 BIZ_STAGE, static_cast<int32_t>(ClickIcon::DMS_RECV_OVER),
835 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
836 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END));
837 } else {
838 res = HiSysEventWrite(
839 APP_CONTINUE_DOMAIN,
840 APPLICATION_CONTINUE_BEHAVIOR,
841 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
842 ORG_PKG, ORG_PKG_NAME,
843 FUNC, func,
844 BIZ_SCENE, static_cast<int32_t>(BizScene::CLICK_ICON),
845 BIZ_STAGE, static_cast<int32_t>(ClickIcon::DMS_RECV_OVER),
846 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
847 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
848 ERROR_CODE, errCode);
849 }
850 if (res != ERR_OK) {
851 HILOGE("ClickIconDmsRecvOver error, res:%{public}d", res);
852 return false;
853 }
854 return true;
855 }
856
SaveDataDmsContinue(const std::string & func,int32_t errCode)857 bool DmsRadar::SaveDataDmsContinue(const std::string& func, int32_t errCode)
858 {
859 int32_t res = ERR_OK;
860 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
861 if (stageRes == StageRes::STAGE_SUCC) {
862 res = HiSysEventWrite(
863 APP_CONTINUE_DOMAIN,
864 APPLICATION_CONTINUE_BEHAVIOR,
865 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
866 ORG_PKG, ORG_PKG_NAME,
867 FUNC, func,
868 BIZ_SCENE, static_cast<int32_t>(BizScene::SAVE_DATA),
869 BIZ_STAGE, static_cast<int32_t>(SaveData::DMS_CONTINUE),
870 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
871 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_START),
872 TO_CALL_PKG, ABILITY_MANAGER_SERVICE);
873 } else {
874 res = HiSysEventWrite(
875 APP_CONTINUE_DOMAIN,
876 APPLICATION_CONTINUE_BEHAVIOR,
877 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
878 ORG_PKG, ORG_PKG_NAME,
879 FUNC, func,
880 BIZ_SCENE, static_cast<int32_t>(BizScene::SAVE_DATA),
881 BIZ_STAGE, static_cast<int32_t>(SaveData::DMS_CONTINUE),
882 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
883 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_START),
884 TO_CALL_PKG, ABILITY_MANAGER_SERVICE,
885 ERROR_CODE, errCode);
886 }
887 if (res != ERR_OK) {
888 HILOGE("SaveDataDmsContinue error, res:%{public}d", res);
889 return false;
890 }
891 return true;
892 }
893
SaveDataDmsRemoteWant(const std::string & func,int32_t errCode)894 bool DmsRadar::SaveDataDmsRemoteWant(const std::string& func, int32_t errCode)
895 {
896 int32_t res = ERR_OK;
897 StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
898 if (stageRes == StageRes::STAGE_SUCC) {
899 res = HiSysEventWrite(
900 APP_CONTINUE_DOMAIN,
901 APPLICATION_CONTINUE_BEHAVIOR,
902 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
903 ORG_PKG, ORG_PKG_NAME,
904 FUNC, func,
905 BIZ_SCENE, static_cast<int32_t>(BizScene::SAVE_DATA),
906 BIZ_STAGE, static_cast<int32_t>(SaveData::DMS_REMOTE_WANT),
907 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
908 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END));
909 } else {
910 res = HiSysEventWrite(
911 APP_CONTINUE_DOMAIN,
912 APPLICATION_CONTINUE_BEHAVIOR,
913 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
914 ORG_PKG, ORG_PKG_NAME,
915 FUNC, func,
916 BIZ_SCENE, static_cast<int32_t>(BizScene::SAVE_DATA),
917 BIZ_STAGE, static_cast<int32_t>(SaveData::DMS_REMOTE_WANT),
918 STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
919 BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
920 ERROR_CODE, errCode);
921 }
922 if (res != ERR_OK) {
923 HILOGE("SaveDataDmsRemoteWant error, res:%{public}d", res);
924 return false;
925 }
926 return true;
927 }
928
GetAnonyUdid(std::string udid)929 std::string DmsRadar::GetAnonyUdid(std::string udid)
930 {
931 if (udid.empty() || udid.length() < ANONYM_MIN_LENGTH) {
932 return "";
933 }
934 return udid.substr(0, SUBSTR_UDID_LENGTH) + "**" + udid.substr(udid.length() - SUBSTR_UDID_LENGTH);
935 }
936 } // namespace DistributedSchedule
937 } // namespace OHOS