1 /*
2  * Copyright (c) 2023-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 "dm_radar_helper.h"
17 
18 #include <algorithm>
19 #include <cmath>
20 #include <sstream>
21 #include <iomanip>
22 #include <cJSON.h>
23 #include <errors.h>
24 #include "hisysevent.h"
25 #include "dm_constants.h"
26 #include "dm_log.h"
27 #include "parameter.h"
28 #include "accesstoken_kit.h"
29 #include "access_token.h"
30 #include "hap_token_info.h"
31 #include "ipc_skeleton.h"
32 #include "native_token_info.h"
33 #include "tokenid_kit.h"
34 using namespace OHOS::Security::AccessToken;
35 namespace OHOS {
36 namespace DistributedHardware {
37 DM_IMPLEMENT_SINGLE_INSTANCE(DmRadarHelper);
ReportDiscoverRegCallback(struct RadarInfo &info)38 bool DmRadarHelper::ReportDiscoverRegCallback(struct RadarInfo &info)
39 {
40     int32_t res = DM_OK;
41     if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_IDLE)) {
42         res = HiSysEventWrite(
43             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
44             DM_DISCOVER_BEHAVIOR,
45             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
46             "ORG_PKG", ORGPKGNAME,
47             "HOST_PKG", info.hostName,
48             "FUNC", info.funcName,
49             "API_TYPE", GetApiType(),
50             "BIZ_SCENE", static_cast<int32_t>(DiscoverScene::DM_DISCOVER),
51             "BIZ_STAGE", static_cast<int32_t>(DisCoverStage::DISCOVER_REGISTER_CALLBACK),
52             "STAGE_RES", info.stageRes,
53             "BIZ_STATE", info.bizState,
54             "TO_CALL_PKG", info.toCallPkg,
55             "COMM_SERV", info.commServ);
56     } else {
57         res = HiSysEventWrite(
58             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
59             DM_DISCOVER_BEHAVIOR,
60             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
61             "ORG_PKG", ORGPKGNAME,
62             "FUNC", info.funcName,
63             "API_TYPE", GetApiType(),
64             "BIZ_SCENE", static_cast<int32_t>(DiscoverScene::DM_DISCOVER),
65             "BIZ_STAGE", static_cast<int32_t>(DisCoverStage::DISCOVER_REGISTER_CALLBACK),
66             "STAGE_RES", info.stageRes,
67             "BIZ_STATE", info.bizState,
68             "TO_CALL_PKG", info.toCallPkg,
69             "COMM_SERV", info.commServ,
70             "ERROR_CODE", info.errCode);
71     }
72     if (res != DM_OK) {
73         LOGE("ReportDiscoverRegCallback error, res:%{public}d", res);
74         return false;
75     }
76     return true;
77 }
78 
ReportDiscoverResCallback(struct RadarInfo &info)79 bool DmRadarHelper::ReportDiscoverResCallback(struct RadarInfo &info)
80 {
81     int32_t res = DM_OK;
82     if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_SUCC)) {
83         res = HiSysEventWrite(
84             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
85             DM_DISCOVER_BEHAVIOR,
86             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
87             "ORG_PKG", ORGPKGNAME,
88             "HOST_PKG", SOFTBUSNAME,
89             "FUNC", info.funcName,
90             "API_TYPE", GetApiType(),
91             "BIZ_SCENE", static_cast<int32_t>(DiscoverScene::DM_DISCOVER),
92             "BIZ_STAGE", static_cast<int32_t>(DisCoverStage::DISCOVER_REGISTER_CALLBACK),
93             "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_SUCC),
94             "PEER_UDID", GetAnonyUdid(info.peerUdid),
95             "LOCAL_UDID", GetAnonyLocalUdid(),
96             "COMM_SERV", static_cast<int32_t>(CommServ::USE_SOFTBUS),
97             "PEER_NET_ID", GetAnonyUdid(info.peerNetId));
98     } else {
99         res = HiSysEventWrite(
100             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
101             DM_DISCOVER_BEHAVIOR,
102             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
103             "ORG_PKG", ORGPKGNAME,
104             "HOST_PKG", SOFTBUSNAME,
105             "FUNC", info.funcName,
106             "API_TYPE", GetApiType(),
107             "BIZ_SCENE", static_cast<int32_t>(DiscoverScene::DM_DISCOVER),
108             "BIZ_STAGE", static_cast<int32_t>(DisCoverStage::DISCOVER_REGISTER_CALLBACK),
109             "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_FAIL),
110             "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
111             "PEER_UDID", GetAnonyUdid(info.peerUdid),
112             "LOCAL_UDID", GetAnonyLocalUdid(),
113             "COMM_SERV", static_cast<int32_t>(CommServ::USE_SOFTBUS),
114             "ERROR_CODE", info.errCode);
115     }
116 
117     if (res != DM_OK) {
118         LOGE("ReportDiscoverResCallback error, res:%{public}d", res);
119         return false;
120     }
121     return true;
122 }
123 
ReportDiscoverUserRes(struct RadarInfo &info)124 bool DmRadarHelper::ReportDiscoverUserRes(struct RadarInfo &info)
125 {
126     int32_t res = DM_OK;
127     if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_CANCEL)) {
128         res = HiSysEventWrite(
129             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
130             DM_DISCOVER_BEHAVIOR,
131             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
132             "ORG_PKG", ORGPKGNAME,
133             "HOST_PKG", info.hostName,
134             "FUNC", info.funcName,
135             "API_TYPE", GetApiType(),
136             "BIZ_SCENE", static_cast<int32_t>(DiscoverScene::DM_DISCOVER),
137             "BIZ_STAGE", static_cast<int32_t>(DisCoverStage::DISCOVER_USER_DEAL_RES),
138             "STAGE_RES", info.stageRes,
139             "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
140             "COMM_SERV", static_cast<int32_t>(CommServ::USE_SOFTBUS));
141     } else if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_SUCC)) {
142         res = HiSysEventWrite(
143             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
144             DM_DISCOVER_BEHAVIOR,
145             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
146             "ORG_PKG", ORGPKGNAME,
147             "FUNC", info.funcName,
148             "API_TYPE", GetApiType(),
149             "BIZ_SCENE", static_cast<int32_t>(DiscoverScene::DM_DISCOVER),
150             "BIZ_STAGE", static_cast<int32_t>(DisCoverStage::DISCOVER_USER_DEAL_RES),
151             "STAGE_RES", info.stageRes,
152             "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END));
153     } else {
154         res = HiSysEventWrite(
155             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
156             DM_DISCOVER_BEHAVIOR,
157             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
158             "ORG_PKG", ORGPKGNAME,
159             "HOST_PKG", info.hostName,
160             "FUNC", info.funcName,
161             "API_TYPE", GetApiType(),
162             "BIZ_SCENE", static_cast<int32_t>(DiscoverScene::DM_DISCOVER),
163             "BIZ_STAGE", static_cast<int32_t>(DisCoverStage::DISCOVER_USER_DEAL_RES),
164             "STAGE_RES", info.stageRes,
165             "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
166             "COMM_SERV", static_cast<int32_t>(CommServ::USE_SOFTBUS),
167             "ERROR_CODE", info.errCode);
168     }
169     if (res != DM_OK) {
170         LOGE("ReportDiscoverUserRes error, res:%{public}d", res);
171         return false;
172     }
173     return true;
174 }
175 
ReportAuthStart(const std::string &peerUdid, const std::string &pkgName)176 bool DmRadarHelper::ReportAuthStart(const std::string &peerUdid, const std::string &pkgName)
177 {
178     int32_t res = HiSysEventWrite(
179         OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
180         DM_AUTHCATION_BEHAVIOR,
181         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
182         "ORG_PKG", ORGPKGNAME,
183         "FUNC", "AuthenticateDevice",
184         "HOST_PKG", pkgName,
185         "API_TYPE", GetApiType(),
186         "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
187         "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_START),
188         "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_SUCC),
189         "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_START),
190         "IS_TRUST", static_cast<int32_t>(TrustStatus::NOT_TRUST),
191         "PEER_UDID", GetAnonyUdid(peerUdid),
192         "LOCAL_UDID", GetAnonyLocalUdid());
193     if (res != DM_OK) {
194         LOGE("ReportAuthStart error, res:%{public}d", res);
195         return false;
196     }
197     return true;
198 }
199 
ReportAuthOpenSession(struct RadarInfo &info)200 bool DmRadarHelper::ReportAuthOpenSession(struct RadarInfo &info)
201 {
202     int32_t res = DM_OK;
203     if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_IDLE)) {
204         res = HiSysEventWrite(
205             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
206             DM_AUTHCATION_BEHAVIOR,
207             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
208             "ORG_PKG", ORGPKGNAME,
209             "FUNC", info.funcName,
210             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
211             "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_OPEN_SESSION),
212             "STAGE_RES", info.stageRes,
213             "PEER_UDID", GetAnonyUdid(info.peerUdid),
214             "LOCAL_UDID", GetAnonyLocalUdid(),
215             "CH_ID", info.channelId,
216             "IS_TRUST", info.isTrust,
217             "COMM_SERV", info.commServ,
218             "LOCAL_SESS_NAME", info.localSessName,
219             "PEER_SESS_NAME", info.peerSessName);
220     } else {
221         res = HiSysEventWrite(
222             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
223             DM_AUTHCATION_BEHAVIOR,
224             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
225             "ORG_PKG", ORGPKGNAME,
226             "FUNC", info.funcName,
227             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
228             "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_OPEN_SESSION),
229             "BIZ_STATE", info.bizState,
230             "STAGE_RES", info.stageRes,
231             "PEER_UDID", GetAnonyUdid(info.peerUdid),
232             "LOCAL_UDID", GetAnonyLocalUdid(),
233             "CH_ID", info.channelId,
234             "IS_TRUST", info.isTrust,
235             "COMM_SERV", info.commServ,
236             "LOCAL_SESS_NAME", info.localSessName,
237             "PEER_SESS_NAME", info.peerSessName,
238             "ERROR_CODE", info.errCode);
239     }
240     if (res != DM_OK) {
241         LOGE("ReportAuthOpenSession error, res:%{public}d", res);
242         return false;
243     }
244     return true;
245 }
246 
ReportAuthSessionOpenCb(struct RadarInfo &info)247 bool DmRadarHelper::ReportAuthSessionOpenCb(struct RadarInfo &info)
248 {
249     int32_t res = HiSysEventWrite(
250         OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
251         DM_AUTHCATION_BEHAVIOR,
252         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
253         "ORG_PKG", ORGPKGNAME,
254         "FUNC", info.funcName,
255         "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
256         "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_OPEN_SESSION),
257         "STAGE_RES", info.stageRes,
258         "PEER_UDID", GetAnonyUdid(info.peerUdid),
259         "LOCAL_UDID", GetAnonyLocalUdid(),
260         "CH_ID", info.channelId);
261     if (res != DM_OK) {
262         LOGE("ReportAuthSessionOpenCb error, res:%{public}d", res);
263         return false;
264     }
265     return true;
266 }
267 
ReportAuthSendRequest(struct RadarInfo &info)268 bool DmRadarHelper::ReportAuthSendRequest(struct RadarInfo &info)
269 {
270     int32_t res = HiSysEventWrite(
271         OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
272         DM_AUTHCATION_BEHAVIOR,
273         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
274         "ORG_PKG", ORGPKGNAME,
275         "FUNC", info.funcName,
276         "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
277         "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_SEND_REQUEST),
278         "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_SUCC),
279         "TO_CALL_PKG", SOFTBUSNAME,
280         "LOCAL_SESS_NAME", DM_SESSION_NAME,
281         "IS_TRUST", static_cast<int32_t>(TrustStatus::NOT_TRUST),
282         "COMM_SERV", static_cast<int32_t>(CommServ::USE_SOFTBUS));
283     if (res != DM_OK) {
284         LOGE("ReportAuthSessionOpenCb error, res:%{public}d", res);
285         return false;
286     }
287     return true;
288 }
289 
ReportAuthPullAuthBox(struct RadarInfo &info)290 bool DmRadarHelper::ReportAuthPullAuthBox(struct RadarInfo &info)
291 {
292     int32_t res = HiSysEventWrite(
293         OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
294         DM_AUTHCATION_BEHAVIOR,
295         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
296         "ORG_PKG", ORGPKGNAME,
297         "FUNC", info.funcName,
298         "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
299         "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_PULL_AUTH_BOX),
300         "STAGE_RES", info.stageRes);
301     if (res != DM_OK) {
302         LOGE("ReportAuthPullAuthBox error, res:%{public}d", res);
303         return false;
304     }
305     return true;
306 }
307 
ReportAuthConfirmBox(struct RadarInfo &info)308 bool DmRadarHelper::ReportAuthConfirmBox(struct RadarInfo &info)
309 {
310     int32_t res = DM_OK;
311     if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_SUCC)) {
312         res = HiSysEventWrite(
313             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
314             DM_AUTHCATION_BEHAVIOR,
315             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
316             "ORG_PKG", ORGPKGNAME,
317             "FUNC", info.funcName,
318             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
319             "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_PULL_AUTH_BOX),
320             "STAGE_RES", info.stageRes);
321     } else {
322         res = HiSysEventWrite(
323             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
324             DM_AUTHCATION_BEHAVIOR,
325             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
326             "ORG_PKG", ORGPKGNAME,
327             "FUNC", info.funcName,
328             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
329             "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_PULL_AUTH_BOX),
330             "STAGE_RES", info.stageRes,
331             "BIZ_STATE", info.bizState,
332             "ERROR_CODE", info.errCode);
333     }
334     if (res != DM_OK) {
335         LOGE("ReportAuthConfirmBox error, res:%{public}d", res);
336         return false;
337     }
338     return true;
339 }
340 
ReportAuthCreateGroup(struct RadarInfo &info)341 bool DmRadarHelper::ReportAuthCreateGroup(struct RadarInfo &info)
342 {
343     int32_t res = DM_OK;
344     if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_IDLE)) {
345         res = HiSysEventWrite(
346             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
347             DM_AUTHCATION_BEHAVIOR,
348             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
349             "ORG_PKG", ORGPKGNAME,
350             "FUNC", info.funcName,
351             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
352             "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_CREATE_HICHAIN_GROUP),
353             "STAGE_RES", info.stageRes,
354             "LOCAL_UDID", GetAnonyLocalUdid(),
355             "TO_CALL_PKG", info.toCallPkg);
356     } else {
357         res = HiSysEventWrite(
358             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
359             DM_AUTHCATION_BEHAVIOR,
360             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
361             "ORG_PKG", ORGPKGNAME,
362             "FUNC", info.funcName,
363             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
364             "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_CREATE_HICHAIN_GROUP),
365             "STAGE_RES", info.stageRes,
366             "BIZ_STATE", info.bizState,
367             "TO_CALL_PKG", info.toCallPkg,
368             "LOCAL_UDID", GetAnonyLocalUdid(),
369             "ERROR_CODE", info.errCode);
370     }
371     if (res != DM_OK) {
372         LOGE("ReportAuthCreateGroup error, res:%{public}d", res);
373         return false;
374     }
375     return true;
376 }
377 
ReportAuthCreateGroupCb(std::string funcName, int32_t stageRes)378 bool DmRadarHelper::ReportAuthCreateGroupCb(std::string funcName, int32_t stageRes)
379 {
380     int32_t res = DM_OK;
381     if (stageRes == static_cast<int32_t>(StageRes::STAGE_SUCC)) {
382         res = HiSysEventWrite(
383             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
384             DM_AUTHCATION_BEHAVIOR,
385             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
386             "ORG_PKG", ORGPKGNAME,
387             "FUNC", funcName,
388             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
389             "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_CREATE_HICHAIN_GROUP),
390             "STAGE_RES", stageRes,
391             "HOST_PKG", HICHAINNAME);
392     } else {
393         res = HiSysEventWrite(
394             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
395             DM_AUTHCATION_BEHAVIOR,
396             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
397             "ORG_PKG", ORGPKGNAME,
398             "FUNC", funcName,
399             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
400             "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_CREATE_HICHAIN_GROUP),
401             "STAGE_RES", stageRes,
402             "HOST_PKG", HICHAINNAME,
403             "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
404             "ERROR_CODE", GetErrCode(ERR_DM_CREATE_GROUP_FAILED));
405     }
406     if (res != DM_OK) {
407         LOGE("ReportAuthCreateGroupCb error, res:%{public}d", res);
408         return false;
409     }
410     return true;
411 }
412 
ReportAuthPullPinBox(struct RadarInfo &info)413 bool DmRadarHelper::ReportAuthPullPinBox(struct RadarInfo &info)
414 {
415     int32_t res = HiSysEventWrite(
416         OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
417         DM_AUTHCATION_BEHAVIOR,
418         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
419         "ORG_PKG", ORGPKGNAME,
420         "FUNC", info.funcName,
421         "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
422         "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_PULL_PIN_BOX_START),
423         "STAGE_RES", info.stageRes);
424     if (res != DM_OK) {
425         LOGE("ReportAuthPullPinBox error, res:%{public}d", res);
426         return false;
427     }
428     return true;
429 }
430 
ReportAuthInputPinBox(struct RadarInfo &info)431 bool DmRadarHelper::ReportAuthInputPinBox(struct RadarInfo &info)
432 {
433     int32_t res = DM_OK;
434     if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_SUCC)) {
435         res = HiSysEventWrite(
436             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
437             DM_AUTHCATION_BEHAVIOR,
438             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
439             "ORG_PKG", ORGPKGNAME,
440             "FUNC", info.funcName,
441             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
442             "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_PULL_PIN_INPUT_BOX_END),
443             "STAGE_RES", info.stageRes);
444     } else {
445         res = HiSysEventWrite(
446             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
447             DM_AUTHCATION_BEHAVIOR,
448             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
449             "ORG_PKG", ORGPKGNAME,
450             "FUNC", info.funcName,
451             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
452             "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_PULL_PIN_INPUT_BOX_END),
453             "STAGE_RES", info.stageRes,
454             "BIZ_STATE", info.bizState,
455             "ERROR_CODE", info.errCode);
456     }
457     if (res != DM_OK) {
458         LOGE("ReportAuthInputPinBox error, res:%{public}d", res);
459         return false;
460     }
461     return true;
462 }
463 
ReportAuthAddGroup(struct RadarInfo &info)464 bool DmRadarHelper::ReportAuthAddGroup(struct RadarInfo &info)
465 {
466     int32_t res = DM_OK;
467     if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_IDLE)) {
468         res = HiSysEventWrite(
469             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
470             DM_AUTHCATION_BEHAVIOR,
471             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
472             "ORG_PKG", ORGPKGNAME,
473             "FUNC", info.funcName,
474             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
475             "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_ADD_HICHAIN_GROUP),
476             "STAGE_RES", info.stageRes,
477             "LOCAL_UDID", GetAnonyLocalUdid(),
478             "PEER_UDID", GetAnonyUdid(info.peerUdid),
479             "TO_CALL_PKG", HICHAINNAME);
480     } else {
481         res = HiSysEventWrite(
482             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
483             DM_AUTHCATION_BEHAVIOR,
484             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
485             "ORG_PKG", ORGPKGNAME,
486             "FUNC", info.funcName,
487             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
488             "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_ADD_HICHAIN_GROUP),
489             "STAGE_RES", info.stageRes,
490             "LOCAL_UDID", GetAnonyLocalUdid(),
491             "PEER_UDID", GetAnonyUdid(info.peerUdid),
492             "TO_CALL_PKG", HICHAINNAME,
493             "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
494             "ERROR_CODE", info.errCode);
495     }
496     if (res != DM_OK) {
497         LOGE("ReportAuthAddGroup error, res:%{public}d", res);
498         return false;
499     }
500     return true;
501 }
502 
ReportAuthAddGroupCb(std::string funcName, int32_t stageRes)503 bool DmRadarHelper::ReportAuthAddGroupCb(std::string funcName, int32_t stageRes)
504 {
505     int32_t res = DM_OK;
506     if (stageRes == static_cast<int32_t>(StageRes::STAGE_SUCC)) {
507         res = HiSysEventWrite(
508             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
509             DM_AUTHCATION_BEHAVIOR,
510             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
511             "ORG_PKG", ORGPKGNAME,
512             "FUNC", funcName,
513             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
514             "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_ADD_HICHAIN_GROUP),
515             "STAGE_RES", stageRes,
516             "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
517             "HOST_PKG", HICHAINNAME);
518     } else {
519         res = HiSysEventWrite(
520             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
521             DM_AUTHCATION_BEHAVIOR,
522             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
523             "ORG_PKG", ORGPKGNAME,
524             "FUNC", funcName,
525             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_AUTHCATION),
526             "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_ADD_HICHAIN_GROUP),
527             "STAGE_RES", stageRes,
528             "HOST_PKG", HICHAINNAME,
529             "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
530             "ERROR_CODE", GetErrCode(ERR_DM_ADD_GROUP_FAILED));
531     }
532     if (res != DM_OK) {
533         LOGE("ReportAuthAddGroupCb error, res:%{public}d", res);
534         return false;
535     }
536     return true;
537 }
538 
ReportNetworkOnline(struct RadarInfo &info)539 bool DmRadarHelper::ReportNetworkOnline(struct RadarInfo &info)
540 {
541     int32_t res = HiSysEventWrite(
542         OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
543         DM_AUTHCATION_BEHAVIOR,
544         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
545         "ORG_PKG", ORGPKGNAME,
546         "FUNC", info.funcName,
547         "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_NETWORK),
548         "BIZ_STAGE", static_cast<int32_t>(NetworkStage::NETWORK_ONLINE),
549         "STAGE_RES", info.stageRes,
550         "BIZ_STATE", info.bizState,
551         "LOCAL_UDID", GetAnonyLocalUdid(),
552         "PEER_UDID", GetAnonyUdid(info.peerUdid),
553         "PEER_NET_ID", GetAnonyUdid(info.peerNetId),
554         "IS_TRUST", info.isTrust);
555     if (res != DM_OK) {
556         LOGE("ReportNetworkOnline error, res:%{public}d", res);
557         return false;
558     }
559     return true;
560 }
561 
ReportNetworkOffline(struct RadarInfo &info)562 bool DmRadarHelper::ReportNetworkOffline(struct RadarInfo &info)
563 {
564     int32_t res = HiSysEventWrite(
565         OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
566         DM_AUTHCATION_BEHAVIOR,
567         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
568         "ORG_PKG", ORGPKGNAME,
569         "FUNC", info.funcName,
570         "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_NETWORK),
571         "BIZ_STAGE", static_cast<int32_t>(NetworkStage::NETWORK_OFFLINE),
572         "STAGE_RES", info.stageRes,
573         "BIZ_STATE", info.bizState,
574         "LOCAL_UDID", GetAnonyLocalUdid(),
575         "PEER_UDID", GetAnonyUdid(info.peerUdid),
576         "PEER_NET_ID", GetAnonyUdid(info.peerNetId));
577     if (res != DM_OK) {
578         LOGE("ReportNetworkOffline error, res:%{public}d", res);
579         return false;
580     }
581     return true;
582 }
583 
ReportDeleteTrustRelation(struct RadarInfo &info)584 bool DmRadarHelper::ReportDeleteTrustRelation(struct RadarInfo &info)
585 {
586     int32_t res = HiSysEventWrite(
587         OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
588         DM_AUTHCATION_BEHAVIOR,
589         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
590         "ORG_PKG", ORGPKGNAME,
591         "HOST_PKG", info.hostName,
592         "FUNC", info.funcName,
593         "API_TYPE", GetApiType(),
594         "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_DELET_TRUST_RELATION),
595         "BIZ_STAGE", static_cast<int32_t>(DeleteTrust::DELETE_TRUST),
596         "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_SUCC),
597         "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
598         "LOCAL_UDID", GetAnonyLocalUdid(),
599         "PEER_UDID", GetAnonyUdid(info.peerUdid),
600         "PEER_NET_ID", GetAnonyUdid(info.peerNetId),
601         "TO_CALL_PKG", info.toCallPkg);
602     if (res != DM_OK) {
603         LOGE("ReportDeleteTrustRelation error, res:%{public}d", res);
604         return false;
605     }
606     return true;
607 }
608 
ReportCreatePinHolder(std::string hostName, int32_t channelId, std::string peerUdid, int32_t errCode, int32_t stageRes)609 void DmRadarHelper::ReportCreatePinHolder(std::string hostName,
610     int32_t channelId, std::string peerUdid, int32_t errCode, int32_t stageRes)
611 {
612     int32_t res = DM_OK;
613     if (stageRes == static_cast<int32_t>(StageRes::STAGE_SUCC)) {
614         res = HiSysEventWrite(
615             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
616             DM_AUTHCATION_BEHAVIOR,
617             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
618             "ORG_PKG", ORGPKGNAME,
619             "HOST_PKG", hostName,
620             "FUNC", "CreatePinHolder",
621             "API_TYPE", GetApiType(),
622             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_PIN_HOLDER),
623             "BIZ_STAGE", static_cast<int32_t>(PinHolderStage::CREATE_PIN_HOLDER),
624             "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_SUCC),
625             "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_START),
626             "CH_ID", channelId,
627             "LOCAL_UDID", GetAnonyLocalUdid(),
628             "PEER_UDID", GetAnonyUdid(peerUdid),
629             "TO_CALL_PKG", SOFTBUSNAME);
630         if (res != DM_OK) {
631             LOGE("ReportDeleteTrustRelation error, res:%{public}d", res);
632             return;
633         }
634     } else {
635         res = HiSysEventWrite(
636             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
637             DM_AUTHCATION_BEHAVIOR,
638             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
639             "ORG_PKG", ORGPKGNAME,
640             "HOST_PKG", hostName,
641             "FUNC", "CreatePinHolder",
642             "API_TYPE", GetApiType(),
643             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_PIN_HOLDER),
644             "BIZ_STAGE", static_cast<int32_t>(PinHolderStage::CREATE_PIN_HOLDER),
645             "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_FAIL),
646             "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
647             "CH_ID", channelId,
648             "LOCAL_UDID", GetAnonyLocalUdid(),
649             "PEER_UDID", GetAnonyUdid(peerUdid),
650             "TO_CALL_PKG", SOFTBUSNAME,
651             "ERROR_CODE", errCode);
652         if (res != DM_OK) {
653             LOGE("ReportDeleteTrustRelation error, res:%{public}d", res);
654             return;
655         }
656     }
657     return;
658 }
659 
ReportDestroyPinHolder(std::string hostName, std::string peerUdid, int32_t errCode, int32_t stageRes)660 void DmRadarHelper::ReportDestroyPinHolder(std::string hostName,
661     std::string peerUdid, int32_t errCode, int32_t stageRes)
662 {
663     int32_t res = DM_OK;
664     if (stageRes == static_cast<int32_t>(StageRes::STAGE_SUCC)) {
665         res = HiSysEventWrite(
666             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
667             DM_AUTHCATION_BEHAVIOR,
668             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
669             "ORG_PKG", ORGPKGNAME,
670             "HOST_PKG", hostName,
671             "FUNC", "DestroyPinHolder",
672             "API_TYPE", GetApiType(),
673             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_PIN_HOLDER),
674             "BIZ_STAGE", static_cast<int32_t>(PinHolderStage::DESTROY_PIN_HOLDER),
675             "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_SUCC),
676             "LOCAL_UDID", GetAnonyLocalUdid(),
677             "PEER_UDID", GetAnonyUdid(peerUdid),
678             "TO_CALL_PKG", SOFTBUSNAME);
679         if (res != DM_OK) {
680             LOGE("ReportDeleteTrustRelation error, res:%{public}d", res);
681             return;
682         }
683     } else {
684         res = HiSysEventWrite(
685             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
686             DM_AUTHCATION_BEHAVIOR,
687             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
688             "ORG_PKG", ORGPKGNAME,
689             "HOST_PKG", hostName,
690             "FUNC", "DestroyPinHolder",
691             "API_TYPE", GetApiType(),
692             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_PIN_HOLDER),
693             "BIZ_STAGE", static_cast<int32_t>(PinHolderStage::DESTROY_PIN_HOLDER),
694             "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_FAIL),
695             "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
696             "LOCAL_UDID", GetAnonyLocalUdid(),
697             "PEER_UDID", GetAnonyUdid(peerUdid),
698             "TO_CALL_PKG", SOFTBUSNAME,
699             "ERROR_CODE", errCode);
700         if (res != DM_OK) {
701             LOGE("ReportDeleteTrustRelation error, res:%{public}d", res);
702             return;
703         }
704     }
705     return;
706 }
707 
ReportSendOrReceiveHolderMsg(int32_t bizStage, std::string funcName, std::string peerUdid)708 void DmRadarHelper::ReportSendOrReceiveHolderMsg(int32_t bizStage, std::string funcName, std::string peerUdid)
709 {
710     int32_t res = DM_OK;
711     if (bizStage == static_cast<int32_t>(PinHolderStage::RECEIVE_DESTROY_PIN_HOLDER_MSG)) {
712         res = HiSysEventWrite(
713             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
714             DM_AUTHCATION_BEHAVIOR,
715             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
716             "ORG_PKG", ORGPKGNAME,
717             "FUNC", funcName,
718             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_PIN_HOLDER),
719             "BIZ_STAGE", bizStage,
720             "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_SUCC),
721             "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
722             "LOCAL_UDID", GetAnonyLocalUdid(),
723             "PEER_UDID", GetAnonyUdid(peerUdid),
724             "TO_CALL_PKG", SOFTBUSNAME);
725         if (res != DM_OK) {
726             LOGE("ReportSendOrReceiveHolderMsg error, res:%{public}d", res);
727             return;
728         }
729     } else {
730         res = HiSysEventWrite(
731             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
732             DM_AUTHCATION_BEHAVIOR,
733             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
734             "ORG_PKG", ORGPKGNAME,
735             "FUNC", funcName,
736             "BIZ_SCENE", static_cast<int32_t>(AuthScene::DM_PIN_HOLDER),
737             "BIZ_STAGE", bizStage,
738             "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_SUCC),
739             "LOCAL_UDID", GetAnonyLocalUdid(),
740             "PEER_UDID", GetAnonyUdid(peerUdid),
741             "TO_CALL_PKG", SOFTBUSNAME);
742         if (res != DM_OK) {
743             LOGE("ReportSendOrReceiveHolderMsg error, res:%{public}d", res);
744             return;
745         }
746     }
747     return;
748 }
749 
ReportGetTrustDeviceList(std::string hostName, std::string funcName, std::vector<DmDeviceInfo> &deviceInfoList, int32_t errCode)750 void DmRadarHelper::ReportGetTrustDeviceList(std::string hostName,
751     std::string funcName, std::vector<DmDeviceInfo> &deviceInfoList, int32_t errCode)
752 {
753     int32_t res = DM_OK;
754     std::string discoverDevList = GetDeviceInfoList(deviceInfoList);
755     if (errCode == DM_OK) {
756         int32_t deviceCount = static_cast<int32_t>(deviceInfoList.size());
757         static std::string TrustCallerName = "";
758         if (deviceCount > 0 && TrustCallerName != hostName) {
759             TrustCallerName = hostName;
760             res = HiSysEventWrite(
761                 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
762                 DM_DISCOVER_BEHAVIOR,
763                 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
764                 "ORG_PKG", ORGPKGNAME,
765                 "HOST_PKG", hostName,
766                 "FUNC", funcName,
767                 "API_TYPE", GetApiType(),
768                 "BIZ_SCENE", static_cast<int32_t>(DiscoverScene::DM_GET_TRUST_DEVICE_LIST),
769                 "BIZ_STAGE", static_cast<int32_t>(GetTrustDeviceList::GET_TRUST_DEVICE_LIST),
770                 "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_SUCC),
771                 "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
772                 "LOCAL_UDID", GetAnonyLocalUdid(),
773                 "DISCOVERY_DEVICE_LIST", discoverDevList);
774         }
775     } else {
776         res = HiSysEventWrite(
777             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
778             DM_DISCOVER_BEHAVIOR,
779             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
780             "ORG_PKG", ORGPKGNAME,
781             "HOST_PKG", hostName,
782             "FUNC", funcName,
783             "API_TYPE", GetApiType(),
784             "BIZ_SCENE", static_cast<int32_t>(DiscoverScene::DM_GET_TRUST_DEVICE_LIST),
785             "BIZ_STAGE", static_cast<int32_t>(GetTrustDeviceList::GET_TRUST_DEVICE_LIST),
786             "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_FAIL),
787             "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
788             "LOCAL_UDID", GetAnonyLocalUdid(),
789             "DISCOVERY_DEVICE_LIST", discoverDevList,
790             "ERROR_CODE", GetErrCode(errCode));
791     }
792     if (res != DM_OK) {
793         LOGE("ReportGetTrustDeviceList error, res:%{public}d", res);
794         return;
795     }
796 }
797 
ReportDmBehavior(std::string hostName, std::string funcName, int32_t errCode)798 void DmRadarHelper::ReportDmBehavior(std::string hostName, std::string funcName, int32_t errCode)
799 {
800     int32_t res = DM_OK;
801     if (errCode == DM_OK) {
802         res = HiSysEventWrite(
803             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
804             DM_DISCOVER_BEHAVIOR,
805             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
806             "ORG_PKG", ORGPKGNAME,
807             "HOST_PKG", hostName,
808             "FUNC", funcName,
809             "API_TYPE", GetApiType(),
810             "BIZ_SCENE", static_cast<int32_t>(DiscoverScene::DM_BEHAVIOR),
811             "BIZ_STAGE", DEFAULT_STAGE,
812             "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_SUCC),
813             "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
814             "LOCAL_UDID", GetAnonyLocalUdid());
815     } else {
816         res = HiSysEventWrite(
817             OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
818             DM_DISCOVER_BEHAVIOR,
819             HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
820             "ORG_PKG", ORGPKGNAME,
821             "HOST_PKG", hostName,
822             "FUNC", funcName,
823             "API_TYPE", GetApiType(),
824             "BIZ_SCENE", static_cast<int32_t>(DiscoverScene::DM_BEHAVIOR),
825             "BIZ_STAGE", DEFAULT_STAGE,
826             "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_FAIL),
827             "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
828             "LOCAL_UDID", GetAnonyLocalUdid(),
829             "ERROR_CODE", GetErrCode(errCode));
830     }
831     if (res != DM_OK) {
832         LOGE("ReportDmBehavior error, res:%{public}d", res);
833         return;
834     }
835 }
836 
ReportGetLocalDevInfo(std::string hostName, std::string funcName, DmDeviceInfo &info, int32_t errCode)837 void DmRadarHelper::ReportGetLocalDevInfo(std::string hostName,
838     std::string funcName, DmDeviceInfo &info, int32_t errCode)
839 {
840     int32_t res = DM_OK;
841     static std::string localCallerName = "";
842     if (localCallerName != hostName) {
843         localCallerName = hostName;
844         if (errCode == DM_OK) {
845             res = HiSysEventWrite(
846                 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
847                 DM_DISCOVER_BEHAVIOR,
848                 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
849                 "ORG_PKG", ORGPKGNAME,
850                 "HOST_PKG", hostName,
851                 "FUNC", funcName,
852                 "API_TYPE", GetApiType(),
853                 "BIZ_SCENE", static_cast<int32_t>(DiscoverScene::DM_GET_LOCAL_DEVICE_INFO),
854                 "BIZ_STAGE", DEFAULT_STAGE,
855                 "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_SUCC),
856                 "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
857                 "DEV_TYPE", ConvertHexToString(info.deviceTypeId),
858                 "LOCAL_UDID", GetAnonyLocalUdid(),
859                 "LOCAL_NET_ID", GetAnonyUdid(info.networkId));
860         } else {
861             res = HiSysEventWrite(
862                 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
863                 DM_DISCOVER_BEHAVIOR,
864                 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
865                 "ORG_PKG", ORGPKGNAME,
866                 "HOST_PKG", hostName,
867                 "FUNC", funcName,
868                 "API_TYPE", GetApiType(),
869                 "BIZ_SCENE", static_cast<int32_t>(DiscoverScene::DM_GET_LOCAL_DEVICE_INFO),
870                 "BIZ_STAGE", DEFAULT_STAGE,
871                 "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_FAIL),
872                 "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
873                 "DEV_TYPE", ConvertHexToString(info.deviceTypeId),
874                 "LOCAL_UDID", GetAnonyLocalUdid(),
875                 "LOCAL_NET_ID", GetAnonyUdid(info.networkId),
876                 "ERROR_CODE", GetErrCode(errCode));
877         }
878     }
879     if (res != DM_OK) {
880         LOGE("ReportGetLocalDevInfo error, res:%{public}d", res);
881         return;
882     }
883 }
884 
ReportGetDeviceInfo(std::string hostName, std::string funcName, DmDeviceInfo &info, int32_t errCode)885 void DmRadarHelper::ReportGetDeviceInfo(std::string hostName,
886     std::string funcName, DmDeviceInfo &info, int32_t errCode)
887 {
888     int32_t res = DM_OK;
889     static std::string callerName = "";
890     if (callerName != hostName) {
891         callerName = hostName;
892         if (errCode == DM_OK) {
893             res = HiSysEventWrite(
894                 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
895                 DM_DISCOVER_BEHAVIOR,
896                 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
897                 "ORG_PKG", ORGPKGNAME,
898                 "HOST_PKG", hostName,
899                 "FUNC", funcName,
900                 "API_TYPE", GetApiType(),
901                 "BIZ_SCENE", static_cast<int32_t>(DiscoverScene::DM_GET_DEVICE_INFO),
902                 "BIZ_STAGE", DEFAULT_STAGE,
903                 "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_SUCC),
904                 "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
905                 "LOCAL_UDID", GetAnonyLocalUdid(),
906                 "DEV_TYPE", ConvertHexToString(info.deviceTypeId),
907                 "PEER_UDID", GetAnonyUdid(info.deviceId),
908                 "PEER_NET_ID", GetAnonyUdid(info.networkId));
909         } else {
910             res = HiSysEventWrite(
911                 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
912                 DM_DISCOVER_BEHAVIOR,
913                 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
914                 "ORG_PKG", ORGPKGNAME,
915                 "HOST_PKG", hostName,
916                 "FUNC", funcName,
917                 "API_TYPE", GetApiType(),
918                 "BIZ_SCENE", static_cast<int32_t>(DiscoverScene::DM_GET_DEVICE_INFO),
919                 "BIZ_STAGE", DEFAULT_STAGE,
920                 "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_FAIL),
921                 "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
922                 "LOCAL_UDID", GetAnonyLocalUdid(),
923                 "DEV_TYPE", ConvertHexToString(info.deviceTypeId),
924                 "PEER_UDID", GetAnonyUdid(info.deviceId),
925                 "PEER_NET_ID", GetAnonyUdid(info.networkId),
926                 "ERROR_CODE", GetErrCode(errCode));
927         }
928     }
929     if (res != DM_OK) {
930         LOGE("ReportGetDeviceInfo error, res:%{public}d", res);
931         return;
932     }
933 }
934 
ConvertHexToString(uint16_t hex)935 std::string DmRadarHelper::ConvertHexToString(uint16_t hex)
936 {
937     std::stringstream str;
938     int32_t with = 3;
939     str << std::hex << std::setw(with) << std::setfill('0') << hex;
940     std::string hexStr = str.str();
941     transform(hexStr.begin(), hexStr.end(), hexStr.begin(), ::toupper);
942     return hexStr;
943 }
944 
GetDeviceInfoList(std::vector<DmDeviceInfo> &deviceInfoList)945 std::string DmRadarHelper::GetDeviceInfoList(std::vector<DmDeviceInfo> &deviceInfoList)
946 {
947     cJSON *deviceInfoJson = cJSON_CreateArray();
948     if (deviceInfoJson == nullptr) {
949         LOGE("deviceInfoJson is nullptr.");
950         return "";
951     }
952     for (size_t i = 0; i < deviceInfoList.size(); i++) {
953         cJSON *object = cJSON_CreateObject();
954         if (object == nullptr) {
955             LOGE("object is nullptr.");
956             cJSON_Delete(deviceInfoJson);
957             return "";
958         }
959         std::string devType = ConvertHexToString(deviceInfoList[i].deviceTypeId);
960         cJSON_AddStringToObject(object, "PEER_DEV_TYPE", devType.c_str());
961         cJSON_AddItemToArray(deviceInfoJson, object);
962     }
963     char *deviceInfoStr = cJSON_PrintUnformatted(deviceInfoJson);
964     if (deviceInfoStr == nullptr) {
965         LOGE("deviceInfoStr is nullptr.");
966         cJSON_Delete(deviceInfoJson);
967         return "";
968     }
969     std::string devInfoStr = std::string(deviceInfoStr);
970     cJSON_Delete(deviceInfoJson);
971     cJSON_free(deviceInfoStr);
972     return devInfoStr;
973 }
974 
GetAnonyUdid(std::string udid)975 std::string DmRadarHelper::GetAnonyUdid(std::string udid)
976 {
977     if (udid.empty() || udid.length() < INVALID_UDID_LENGTH) {
978         return "unknown";
979     }
980     return udid.substr(0, SUBSTR_UDID_LENGTH) + "**" + udid.substr(udid.length() - SUBSTR_UDID_LENGTH);
981 }
982 
GetAnonyLocalUdid()983 std::string DmRadarHelper::GetAnonyLocalUdid()
984 {
985     char localDeviceId[DEVICE_UUID_LENGTH] = {0};
986     GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH);
987     return GetAnonyUdid(std::string(localDeviceId));
988 }
989 
GetErrCode(int32_t errCode)990 int32_t DmRadarHelper::GetErrCode(int32_t errCode)
991 {
992     auto flag = MAP_ERROR_CODE.find(errCode);
993     if (flag == MAP_ERROR_CODE.end()) {
994         return errCode;
995     }
996     return flag->second;
997 }
998 
GetApiType()999 int32_t DmRadarHelper::GetApiType()
1000 {
1001     AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID();
1002     if (tokenCaller == 0) {
1003         LOGE("GetApiType GetCallingTokenID error.");
1004         return static_cast<int32_t>(ApiType::API_UNKNOW);
1005     }
1006     ATokenTypeEnum tokenTypeFlag = AccessTokenKit::GetTokenTypeFlag(tokenCaller);
1007     if (tokenTypeFlag == ATokenTypeEnum::TOKEN_HAP) {
1008         return static_cast<int32_t>(ApiType::API_JS);
1009     } else if (tokenTypeFlag == ATokenTypeEnum::TOKEN_NATIVE) {
1010         return static_cast<int32_t>(ApiType::API_NATIVE);
1011     }
1012     return static_cast<int32_t>(ApiType::API_UNKNOW);
1013 }
1014 
CreateDmRadarInstance()1015 IDmRadarHelper *CreateDmRadarInstance()
1016 {
1017     return &DmRadarHelper::GetInstance();
1018 }
1019 } // namespace DistributedHardware
1020 } // namespace OHOS