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
22namespace OHOS {
23namespace DistributedSchedule {
24const std::string TAG = "DmsRadar";
25IMPLEMENT_SINGLE_INSTANCE(DmsRadar);
26
27bool 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
62bool 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
99bool 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
119bool 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
154bool 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
191bool 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
210bool 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
245bool 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
282bool 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
301bool 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
336bool 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
373bool 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
392bool 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
427bool 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
464bool 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
483bool 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
518bool 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
555bool 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
576bool 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
611bool 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
644bool 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
665bool 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
700bool 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
733bool 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, srcBundleInfo.versionName,
760            PEER_APP_VERSION, dstBundleInfo.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, srcBundleInfo.versionName,
775            PEER_APP_VERSION, dstBundleInfo.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
785bool 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
820bool 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) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
825    if (stageRes == StageRes::STAGE_SUCC) {
826        res = HiSysEventWrite(
827            APP_CONTINUE_DOMAIN,
828            APPLICATION_CONTINUE_BEHAVIOR,
829            HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
830            ORG_PKG, ORG_PKG_NAME,
831            FUNC, func,
832            BIZ_SCENE, static_cast<int32_t>(BizScene::CLICK_ICON),
833            BIZ_STAGE, static_cast<int32_t>(ClickIcon::DMS_RECV_OVER),
834            STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
835            BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END));
836    } else {
837        res = HiSysEventWrite(
838            APP_CONTINUE_DOMAIN,
839            APPLICATION_CONTINUE_BEHAVIOR,
840            HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
841            ORG_PKG, ORG_PKG_NAME,
842            FUNC, func,
843            BIZ_SCENE, static_cast<int32_t>(BizScene::CLICK_ICON),
844            BIZ_STAGE, static_cast<int32_t>(ClickIcon::DMS_RECV_OVER),
845            STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
846            BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
847            ERROR_CODE, errCode);
848    }
849    if (res != ERR_OK) {
850        HILOGE("ClickIconDmsRecvOver error, res:%{public}d", res);
851        return false;
852    }
853    return true;
854}
855
856bool DmsRadar::SaveDataDmsContinue(const std::string& func, int32_t errCode)
857{
858    int32_t res = ERR_OK;
859    StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
860    if (stageRes == StageRes::STAGE_SUCC) {
861        res = HiSysEventWrite(
862            APP_CONTINUE_DOMAIN,
863            APPLICATION_CONTINUE_BEHAVIOR,
864            HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
865            ORG_PKG, ORG_PKG_NAME,
866            FUNC, func,
867            BIZ_SCENE, static_cast<int32_t>(BizScene::SAVE_DATA),
868            BIZ_STAGE, static_cast<int32_t>(SaveData::DMS_CONTINUE),
869            STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
870            BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_START),
871            TO_CALL_PKG, ABILITY_MANAGER_SERVICE);
872    } else {
873        res = HiSysEventWrite(
874            APP_CONTINUE_DOMAIN,
875            APPLICATION_CONTINUE_BEHAVIOR,
876            HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
877            ORG_PKG, ORG_PKG_NAME,
878            FUNC, func,
879            BIZ_SCENE, static_cast<int32_t>(BizScene::SAVE_DATA),
880            BIZ_STAGE, static_cast<int32_t>(SaveData::DMS_CONTINUE),
881            STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
882            BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_START),
883            TO_CALL_PKG, ABILITY_MANAGER_SERVICE,
884            ERROR_CODE, errCode);
885    }
886    if (res != ERR_OK) {
887        HILOGE("SaveDataDmsContinue error, res:%{public}d", res);
888        return false;
889    }
890    return true;
891}
892
893bool DmsRadar::SaveDataDmsRemoteWant(const std::string& func, int32_t errCode)
894{
895    int32_t res = ERR_OK;
896    StageRes stageRes = (errCode == ERR_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL;
897    if (stageRes == StageRes::STAGE_SUCC) {
898        res = HiSysEventWrite(
899            APP_CONTINUE_DOMAIN,
900            APPLICATION_CONTINUE_BEHAVIOR,
901            HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
902            ORG_PKG, ORG_PKG_NAME,
903            FUNC, func,
904            BIZ_SCENE, static_cast<int32_t>(BizScene::SAVE_DATA),
905            BIZ_STAGE, static_cast<int32_t>(SaveData::DMS_REMOTE_WANT),
906            STAGE_RES, static_cast<int32_t>(StageRes::STAGE_SUCC),
907            BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END));
908    } else {
909        res = HiSysEventWrite(
910            APP_CONTINUE_DOMAIN,
911            APPLICATION_CONTINUE_BEHAVIOR,
912            HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
913            ORG_PKG, ORG_PKG_NAME,
914            FUNC, func,
915            BIZ_SCENE, static_cast<int32_t>(BizScene::SAVE_DATA),
916            BIZ_STAGE, static_cast<int32_t>(SaveData::DMS_REMOTE_WANT),
917            STAGE_RES, static_cast<int32_t>(StageRes::STAGE_FAIL),
918            BIZ_STATE, static_cast<int32_t>(BizState::BIZ_STATE_END),
919            ERROR_CODE, errCode);
920    }
921    if (res != ERR_OK) {
922        HILOGE("SaveDataDmsRemoteWant error, res:%{public}d", res);
923        return false;
924    }
925    return true;
926}
927
928std::string DmsRadar::GetAnonyUdid(std::string udid)
929{
930    if (udid.empty() || udid.length() < ANONYM_MIN_LENGTH) {
931        return "";
932    }
933    return udid.substr(0, SUBSTR_UDID_LENGTH) + "**" + udid.substr(udid.length() - SUBSTR_UDID_LENGTH);
934}
935} // namespace DistributedSchedule
936} // namespace OHOS