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