1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "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_log.h"
28 #include "dm_softbus_adapter_crypto.h"
29 #include "parameter.h"
30
31 namespace OHOS {
32 namespace DistributedHardware {
33 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 "FUNC", info.funcName,
44 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_DISCOVER),
45 "BIZ_STAGE", static_cast<int32_t>(DisCoverStage::DISCOVER_REGISTER_CALLBACK),
46 "STAGE_RES", info.stageRes,
47 "BIZ_STATE", info.bizState,
48 "TO_CALL_PKG", info.toCallPkg,
49 "COMM_SERV", info.commServ);
50 } else {
51 res = HiSysEventWrite(
52 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
53 DM_DISCOVER_BEHAVIOR,
54 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
55 "ORG_PKG", ORGPKGNAME,
56 "FUNC", info.funcName,
57 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_DISCOVER),
58 "BIZ_STAGE", static_cast<int32_t>(DisCoverStage::DISCOVER_REGISTER_CALLBACK),
59 "STAGE_RES", info.stageRes,
60 "BIZ_STATE", info.bizState,
61 "TO_CALL_PKG", info.toCallPkg,
62 "COMM_SERV", info.commServ,
63 "ERROR_CODE", std::abs(info.errCode));
64 }
65 if (res != DM_OK) {
66 LOGE("ReportDiscoverRegCallback error, res:%d", res);
67 return false;
68 }
69 return true;
70 }
71
ReportDiscoverResCallback(struct RadarInfo & info)72 bool DmRadarHelper::ReportDiscoverResCallback(struct RadarInfo &info)
73 {
74 int32_t res = DM_OK;
75 if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_SUCC)) {
76 res = HiSysEventWrite(
77 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
78 DM_DISCOVER_BEHAVIOR,
79 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
80 "ORG_PKG", ORGPKGNAME,
81 "HOST_PKG", SOFTBUSNAME,
82 "FUNC", info.funcName,
83 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_DISCOVER),
84 "BIZ_STAGE", static_cast<int32_t>(DisCoverStage::DISCOVER_REGISTER_CALLBACK),
85 "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_SUCC),
86 "PEER_UDID", GetUdidHashByUdid(info.peerUdid),
87 "LOCAL_UDID", GetUdidHashByUdid(GetLocalUdid()),
88 "COMM_SERV", static_cast<int32_t>(CommServ::USE_SOFTBUS),
89 "PEER_NET_ID", GetAnonyUdid(info.peerNetId));
90 } else {
91 res = HiSysEventWrite(
92 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
93 DM_DISCOVER_BEHAVIOR,
94 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
95 "ORG_PKG", ORGPKGNAME,
96 "HOST_PKG", SOFTBUSNAME,
97 "FUNC", info.funcName,
98 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_DISCOVER),
99 "BIZ_STAGE", static_cast<int32_t>(DisCoverStage::DISCOVER_REGISTER_CALLBACK),
100 "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_FAIL),
101 "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
102 "COMM_SERV", static_cast<int32_t>(CommServ::USE_SOFTBUS),
103 "ERROR_CODE", std::abs(GetErrorCode(info.errCode, static_cast<int32_t>(Module::SOFTBUS))));
104 }
105
106 if (res != DM_OK) {
107 LOGE("ReportDiscoverResCallback error, res:%d", res);
108 return false;
109 }
110 return true;
111 }
112
ReportDiscoverUserRes(struct RadarInfo & info)113 bool DmRadarHelper::ReportDiscoverUserRes(struct RadarInfo &info)
114 {
115 int32_t res = DM_OK;
116 if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_CANCEL)) {
117 res = HiSysEventWrite(
118 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
119 DM_DISCOVER_BEHAVIOR,
120 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
121 "ORG_PKG", ORGPKGNAME,
122 "HOST_PKG", info.hostName,
123 "FUNC", info.funcName,
124 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_DISCOVER),
125 "BIZ_STAGE", static_cast<int32_t>(DisCoverStage::DISCOVER_USER_DEAL_RES),
126 "STAGE_RES", info.stageRes,
127 "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
128 "COMM_SERV", static_cast<int32_t>(CommServ::USE_SOFTBUS));
129 } else if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_SUCC)) {
130 res = HiSysEventWrite(
131 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
132 DM_DISCOVER_BEHAVIOR,
133 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
134 "ORG_PKG", ORGPKGNAME,
135 "FUNC", info.funcName,
136 "BIZ_SCENE", static_cast<int32_t>(BizScene::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 } else {
141 res = HiSysEventWrite(
142 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
143 DM_DISCOVER_BEHAVIOR,
144 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
145 "ORG_PKG", ORGPKGNAME,
146 "HOST_PKG", info.hostName,
147 "FUNC", info.funcName,
148 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_DISCOVER),
149 "BIZ_STAGE", static_cast<int32_t>(DisCoverStage::DISCOVER_USER_DEAL_RES),
150 "STAGE_RES", info.stageRes,
151 "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
152 "COMM_SERV", static_cast<int32_t>(CommServ::USE_SOFTBUS),
153 "ERROR_CODE", std::abs(info.errCode));
154 }
155 if (res != DM_OK) {
156 LOGE("ReportDiscoverUserRes error, res:%d", res);
157 return false;
158 }
159 return true;
160 }
161
ReportAuthStart(std::string peerUdid)162 bool DmRadarHelper::ReportAuthStart(std::string peerUdid)
163 {
164 int32_t res = HiSysEventWrite(
165 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
166 DM_AUTHCATION_BEHAVIOR,
167 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
168 "ORG_PKG", ORGPKGNAME,
169 "FUNC", "AuthenticateDevice",
170 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
171 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_START),
172 "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_SUCC),
173 "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_START),
174 "IS_TRUST", static_cast<int32_t>(TrustStatus::NOT_TRUST),
175 "PEER_UDID", GetUdidHashByUdid(peerUdid),
176 "LOCAL_UDID", GetUdidHashByUdid(GetLocalUdid()));
177 if (res != DM_OK) {
178 LOGE("ReportAuthStart error, res:%d", res);
179 return false;
180 }
181 return true;
182 }
183
ReportAuthOpenSession(struct RadarInfo & info)184 bool DmRadarHelper::ReportAuthOpenSession(struct RadarInfo &info)
185 {
186 int32_t res = DM_OK;
187 if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_IDLE)) {
188 res = HiSysEventWrite(
189 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
190 DM_AUTHCATION_BEHAVIOR,
191 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
192 "ORG_PKG", ORGPKGNAME,
193 "FUNC", info.funcName,
194 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
195 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_OPEN_SESSION),
196 "STAGE_RES", info.stageRes,
197 "PEER_UDID", GetUdidHashByUdid(info.peerUdid),
198 "LOCAL_UDID", GetUdidHashByUdid(info.localUdid),
199 "CH_ID", info.channelId,
200 "IS_TRUST", info.isTrust,
201 "COMM_SERV", info.commServ,
202 "LOCAL_SESS_NAME", info.localSessName,
203 "PEER_SESS_NAME", info.peerSessName);
204 } else {
205 res = HiSysEventWrite(
206 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
207 DM_AUTHCATION_BEHAVIOR,
208 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
209 "ORG_PKG", ORGPKGNAME,
210 "FUNC", info.funcName,
211 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
212 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_OPEN_SESSION),
213 "BIZ_STATE", info.bizState,
214 "STAGE_RES", info.stageRes,
215 "PEER_UDID", GetUdidHashByUdid(info.peerUdid),
216 "LOCAL_UDID", GetUdidHashByUdid(info.localUdid),
217 "CH_ID", info.channelId,
218 "IS_TRUST", info.isTrust,
219 "COMM_SERV", info.commServ,
220 "LOCAL_SESS_NAME", info.localSessName,
221 "PEER_SESS_NAME", info.peerSessName,
222 "ERROR_CODE", std::abs(GetErrorCode(info.errCode, static_cast<int32_t>(Module::SOFTBUS))));
223 }
224 if (res != DM_OK) {
225 LOGE("ReportAuthOpenSession error, res:%d", res);
226 return false;
227 }
228 return true;
229 }
230
ReportAuthSessionOpenCb(struct RadarInfo & info)231 bool DmRadarHelper::ReportAuthSessionOpenCb(struct RadarInfo &info)
232 {
233 int32_t res = HiSysEventWrite(
234 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
235 DM_AUTHCATION_BEHAVIOR,
236 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
237 "ORG_PKG", ORGPKGNAME,
238 "FUNC", info.funcName,
239 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
240 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_OPEN_SESSION),
241 "STAGE_RES", info.stageRes,
242 "CH_ID", info.channelId);
243 if (res != DM_OK) {
244 LOGE("ReportAuthSessionOpenCb error, res:%d", res);
245 return false;
246 }
247 return true;
248 }
249
ReportAuthSendRequest(struct RadarInfo & info)250 bool DmRadarHelper::ReportAuthSendRequest(struct RadarInfo &info)
251 {
252 int32_t res = HiSysEventWrite(
253 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
254 DM_AUTHCATION_BEHAVIOR,
255 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
256 "ORG_PKG", ORGPKGNAME,
257 "FUNC", info.funcName,
258 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
259 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_SEND_REQUEST),
260 "STAGE_RES", static_cast<int32_t>(StageRes::STAGE_SUCC),
261 "TO_CALL_PKG", SOFTBUSNAME,
262 "LOCAL_SESS_NAME", DM_SESSION_NAME,
263 "IS_TRUST", static_cast<int32_t>(TrustStatus::NOT_TRUST),
264 "COMM_SERV", static_cast<int32_t>(CommServ::USE_SOFTBUS));
265 if (res != DM_OK) {
266 LOGE("ReportAuthSessionOpenCb error, res:%d", res);
267 return false;
268 }
269 return true;
270 }
271
ReportAuthPullAuthBox(struct RadarInfo & info)272 bool DmRadarHelper::ReportAuthPullAuthBox(struct RadarInfo &info)
273 {
274 int32_t res = HiSysEventWrite(
275 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
276 DM_AUTHCATION_BEHAVIOR,
277 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
278 "ORG_PKG", ORGPKGNAME,
279 "FUNC", info.funcName,
280 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
281 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_PULL_AUTH_BOX),
282 "STAGE_RES", info.stageRes);
283 if (res != DM_OK) {
284 LOGE("ReportAuthPullAuthBox error, res:%d", res);
285 return false;
286 }
287 return true;
288 }
289
ReportAuthConfirmBox(struct RadarInfo & info)290 bool DmRadarHelper::ReportAuthConfirmBox(struct RadarInfo &info)
291 {
292 int32_t res = DM_OK;
293 if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_SUCC)) {
294 res = HiSysEventWrite(
295 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
296 DM_AUTHCATION_BEHAVIOR,
297 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
298 "ORG_PKG", ORGPKGNAME,
299 "FUNC", info.funcName,
300 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
301 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_PULL_AUTH_BOX),
302 "STAGE_RES", info.stageRes);
303 } else {
304 res = HiSysEventWrite(
305 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
306 DM_AUTHCATION_BEHAVIOR,
307 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
308 "ORG_PKG", ORGPKGNAME,
309 "FUNC", info.funcName,
310 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
311 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_PULL_AUTH_BOX),
312 "STAGE_RES", info.stageRes,
313 "BIZ_STATE", info.bizState,
314 "ERROR_CODE", std::abs(GetErrorCode(info.errCode, static_cast<int32_t>(Module::USER))));
315 }
316 if (res != DM_OK) {
317 LOGE("ReportAuthConfirmBox error, res:%d", res);
318 return false;
319 }
320 return true;
321 }
322
ReportAuthCreateGroup(struct RadarInfo & info)323 bool DmRadarHelper::ReportAuthCreateGroup(struct RadarInfo &info)
324 {
325 int32_t res = DM_OK;
326 if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_IDLE)) {
327 res = HiSysEventWrite(
328 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
329 DM_AUTHCATION_BEHAVIOR,
330 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
331 "ORG_PKG", ORGPKGNAME,
332 "FUNC", info.funcName,
333 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
334 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_CREATE_HICHAIN_GROUP),
335 "STAGE_RES", info.stageRes,
336 "LOCAL_UDID", GetUdidHashByUdid(info.localUdid),
337 "TO_CALL_PKG", info.toCallPkg);
338 } else {
339 res = HiSysEventWrite(
340 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
341 DM_AUTHCATION_BEHAVIOR,
342 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
343 "ORG_PKG", ORGPKGNAME,
344 "FUNC", info.funcName,
345 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
346 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_CREATE_HICHAIN_GROUP),
347 "STAGE_RES", info.stageRes,
348 "BIZ_STATE", info.bizState,
349 "TO_CALL_PKG", info.toCallPkg,
350 "LOCAL_UDID", GetUdidHashByUdid(info.localUdid),
351 "ERROR_CODE", std::abs(GetErrorCode(info.errCode, static_cast<int32_t>(Module::HICHAIN))));
352 }
353 if (res != DM_OK) {
354 LOGE("ReportAuthCreateGroup error, res:%d", res);
355 return false;
356 }
357 return true;
358 }
359
ReportAuthCreateGroupCb(std::string funcName,int32_t stageRes)360 bool DmRadarHelper::ReportAuthCreateGroupCb(std::string funcName, int32_t stageRes)
361 {
362 int32_t res = DM_OK;
363 if (stageRes == static_cast<int32_t>(StageRes::STAGE_SUCC)) {
364 res = HiSysEventWrite(
365 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
366 DM_AUTHCATION_BEHAVIOR,
367 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
368 "ORG_PKG", ORGPKGNAME,
369 "FUNC", funcName,
370 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
371 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_CREATE_HICHAIN_GROUP),
372 "STAGE_RES", stageRes,
373 "HOST_NAME", HICHAINNAME);
374 } else {
375 res = HiSysEventWrite(
376 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
377 DM_AUTHCATION_BEHAVIOR,
378 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
379 "ORG_PKG", ORGPKGNAME,
380 "FUNC", funcName,
381 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
382 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_CREATE_HICHAIN_GROUP),
383 "STAGE_RES", stageRes,
384 "HOST_NAME", HICHAINNAME,
385 "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
386 "ERROR_CODE", std::abs(GetErrorCode(ERR_DM_CREATE_GROUP_FAILED, static_cast<int32_t>(Module::HICHAIN))));
387 }
388 if (res != DM_OK) {
389 LOGE("ReportAuthCreateGroupCb error, res:%d", res);
390 return false;
391 }
392 return true;
393 }
394
ReportAuthPullPinBox(struct RadarInfo & info)395 bool DmRadarHelper::ReportAuthPullPinBox(struct RadarInfo &info)
396 {
397 int32_t res = HiSysEventWrite(
398 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
399 DM_AUTHCATION_BEHAVIOR,
400 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
401 "ORG_PKG", ORGPKGNAME,
402 "FUNC", info.funcName,
403 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
404 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_PULL_PIN_BOX_START),
405 "STAGE_RES", info.stageRes);
406 if (res != DM_OK) {
407 LOGE("ReportAuthPullPinBox error, res:%d", res);
408 return false;
409 }
410 return true;
411 }
412
ReportAuthInputPinBox(struct RadarInfo & info)413 bool DmRadarHelper::ReportAuthInputPinBox(struct RadarInfo &info)
414 {
415 int32_t res = DM_OK;
416 if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_SUCC)) {
417 res = HiSysEventWrite(
418 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
419 DM_AUTHCATION_BEHAVIOR,
420 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
421 "ORG_PKG", ORGPKGNAME,
422 "FUNC", info.funcName,
423 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
424 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_PULL_PIN_INPUT_BOX_END),
425 "STAGE_RES", info.stageRes);
426 } else {
427 res = HiSysEventWrite(
428 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
429 DM_AUTHCATION_BEHAVIOR,
430 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
431 "ORG_PKG", ORGPKGNAME,
432 "FUNC", info.funcName,
433 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
434 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_PULL_PIN_INPUT_BOX_END),
435 "STAGE_RES", info.stageRes,
436 "BIZ_STATE", info.bizState,
437 "ERROR_CODE", std::abs(GetErrorCode(info.errCode, static_cast<int32_t>(Module::USER))));
438 }
439 if (res != DM_OK) {
440 LOGE("ReportAuthInputPinBox error, res:%d", res);
441 return false;
442 }
443 return true;
444 }
445
ReportAuthAddGroup(struct RadarInfo & info)446 bool DmRadarHelper::ReportAuthAddGroup(struct RadarInfo &info)
447 {
448 int32_t res = DM_OK;
449 if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_IDLE)) {
450 res = HiSysEventWrite(
451 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
452 DM_AUTHCATION_BEHAVIOR,
453 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
454 "ORG_PKG", ORGPKGNAME,
455 "FUNC", info.funcName,
456 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
457 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_ADD_HICHAIN_GROUP),
458 "STAGE_RES", info.stageRes,
459 "LOCAL_UDID", GetUdidHashByUdid(GetLocalUdid()),
460 "PEER_UDID", GetUdidHashByUdid(info.peerUdid),
461 "TO_CALL_PKG", HICHAINNAME);
462 } else {
463 res = HiSysEventWrite(
464 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
465 DM_AUTHCATION_BEHAVIOR,
466 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
467 "ORG_PKG", ORGPKGNAME,
468 "FUNC", info.funcName,
469 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
470 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_ADD_HICHAIN_GROUP),
471 "STAGE_RES", info.stageRes,
472 "LOCAL_UDID", GetUdidHashByUdid(GetLocalUdid()),
473 "PEER_UDID", GetUdidHashByUdid(info.peerUdid),
474 "TO_CALL_PKG", HICHAINNAME,
475 "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
476 "ERROR_CODE", std::abs(GetErrorCode(info.errCode, static_cast<int32_t>(Module::HICHAIN))));
477 }
478 if (res != DM_OK) {
479 LOGE("ReportAuthAddGroup error, res:%d", res);
480 return false;
481 }
482 return true;
483 }
484
ReportAuthAddGroupCb(std::string funcName,int32_t stageRes)485 bool DmRadarHelper::ReportAuthAddGroupCb(std::string funcName, int32_t stageRes)
486 {
487 int32_t res = DM_OK;
488 if (stageRes == static_cast<int32_t>(StageRes::STAGE_SUCC)) {
489 res = HiSysEventWrite(
490 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
491 DM_AUTHCATION_BEHAVIOR,
492 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
493 "ORG_PKG", ORGPKGNAME,
494 "FUNC", funcName,
495 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
496 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_ADD_HICHAIN_GROUP),
497 "STAGE_RES", stageRes,
498 "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
499 "HOST_NAME", HICHAINNAME);
500 } else {
501 res = HiSysEventWrite(
502 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
503 DM_AUTHCATION_BEHAVIOR,
504 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
505 "ORG_PKG", ORGPKGNAME,
506 "FUNC", funcName,
507 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_AUTHCATION),
508 "BIZ_STAGE", static_cast<int32_t>(AuthStage::AUTH_ADD_HICHAIN_GROUP),
509 "STAGE_RES", stageRes,
510 "HOST_NAME", HICHAINNAME,
511 "BIZ_STATE", static_cast<int32_t>(BizState::BIZ_STATE_END),
512 "ERROR_CODE", std::abs(GetErrorCode(ERR_DM_ADD_GROUP_FAILED, static_cast<int32_t>(Module::HICHAIN))));
513 }
514 if (res != DM_OK) {
515 LOGE("ReportAuthAddGroupCb error, res:%d", res);
516 return false;
517 }
518 return true;
519 }
520
ReportNetworkOnline(struct RadarInfo & info)521 bool DmRadarHelper::ReportNetworkOnline(struct RadarInfo &info)
522 {
523 int32_t res = HiSysEventWrite(
524 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
525 DM_AUTHCATION_BEHAVIOR,
526 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
527 "ORG_PKG", ORGPKGNAME,
528 "FUNC", info.funcName,
529 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_NETWORK),
530 "BIZ_STAGE", static_cast<int32_t>(NetworkStage::NETWORK_ONLINE),
531 "STAGE_RES", info.stageRes,
532 "BIZ_STATE", info.bizState,
533 "LOCAL_UDID", GetUdidHashByUdid(info.localUdid),
534 "PEER_UDID", GetUdidHashByUdid(info.peerUdid),
535 "PEER_NET_ID", GetAnonyUdid(info.peerNetId),
536 "IS_TRUST", info.isTrust);
537 if (res != DM_OK) {
538 LOGE("ReportNetworkOnline error, res:%d", res);
539 return false;
540 }
541 return true;
542 }
543
ReportNetworkOffline(struct RadarInfo & info)544 bool DmRadarHelper::ReportNetworkOffline(struct RadarInfo &info)
545 {
546 int32_t res = HiSysEventWrite(
547 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
548 DM_AUTHCATION_BEHAVIOR,
549 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
550 "ORG_PKG", ORGPKGNAME,
551 "FUNC", info.funcName,
552 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_NETWORK),
553 "BIZ_STAGE", static_cast<int32_t>(NetworkStage::NETWORK_OFFLINE),
554 "STAGE_RES", info.stageRes,
555 "BIZ_STATE", info.bizState,
556 "LOCAL_UDID", GetUdidHashByUdid(info.localUdid),
557 "PEER_UDID", GetUdidHashByUdid(info.peerUdid),
558 "PEER_NET_ID", GetAnonyUdid(info.peerNetId));
559 if (res != DM_OK) {
560 LOGE("ReportNetworkOffline error, res:%d", res);
561 return false;
562 }
563 return true;
564 }
565
ReportDeleteTrustRelation(struct RadarInfo & info)566 bool DmRadarHelper::ReportDeleteTrustRelation(struct RadarInfo &info)
567 {
568 int32_t res = HiSysEventWrite(
569 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
570 DM_AUTHCATION_BEHAVIOR,
571 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
572 "ORG_PKG", ORGPKGNAME,
573 "FUNC", info.funcName,
574 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_DELET_TRUST_RELATION),
575 "BIZ_STAGE", static_cast<int32_t>(DeleteTrust::DELETE_TRUST),
576 "STAGE_RES", info.stageRes,
577 "BIZ_STATE", info.bizState,
578 "LOCAL_UDID", GetUdidHashByUdid(info.localUdid),
579 "PEER_UDID", GetUdidHashByUdid(info.peerUdid),
580 "PEER_NET_ID", GetAnonyUdid(info.peerNetId),
581 "TO_CALL_PKG", info.toCallPkg);
582 if (res != DM_OK) {
583 LOGE("ReportDeleteTrustRelation error, res:%d", res);
584 return false;
585 }
586 return true;
587 }
588
ReportGetTrustDeviceList(struct RadarInfo & info)589 bool DmRadarHelper::ReportGetTrustDeviceList(struct RadarInfo &info)
590 {
591 int32_t res = DM_OK;
592 if (info.stageRes == static_cast<int32_t>(StageRes::STAGE_SUCC)) {
593 res = HiSysEventWrite(
594 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
595 DM_AUTHCATION_BEHAVIOR,
596 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
597 "ORG_PKG", ORGPKGNAME,
598 "FUNC", info.funcName,
599 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_DISCOVER),
600 "BIZ_STAGE", static_cast<int32_t>(GetTrustDeviceList::GET_TRUST_DEVICE_LIST),
601 "STAGE_RES", info.stageRes,
602 "BIZ_STATE", info.bizState,
603 "LOCAL_UDID", GetUdidHashByUdid(info.localUdid),
604 "DISCOVERY_DEVICE_LIST", info.discoverDevList);
605 } else {
606 res = HiSysEventWrite(
607 OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DEVICE_MANAGER,
608 DM_AUTHCATION_BEHAVIOR,
609 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
610 "ORG_PKG", ORGPKGNAME,
611 "FUNC", info.funcName,
612 "BIZ_SCENE", static_cast<int32_t>(BizScene::DM_DISCOVER),
613 "BIZ_STAGE", static_cast<int32_t>(GetTrustDeviceList::GET_TRUST_DEVICE_LIST),
614 "STAGE_RES", info.stageRes,
615 "BIZ_STATE", info.bizState,
616 "LOCAL_UDID", GetUdidHashByUdid(info.localUdid),
617 "DISCOVERY_DEVICE_LIST", info.discoverDevList,
618 "ERROR_CODE", std::abs(GetErrorCode(info.errCode, static_cast<int32_t>(Module::SOFTBUS))));
619 }
620 if (res != DM_OK) {
621 LOGE("ReportDeleteTrustRelation error, res:%d", res);
622 return false;
623 }
624 return true;
625 }
626
ConvertHexToString(uint16_t hex)627 std::string DmRadarHelper::ConvertHexToString(uint16_t hex)
628 {
629 std::stringstream str;
630 int32_t with = 3;
631 str << std::hex << std::setw(with) << std::setfill('0') << hex;
632 std::string hexStr = str.str();
633 transform(hexStr.begin(), hexStr.end(), hexStr.begin(), ::toupper);
634 return hexStr;
635 }
636
GetDeviceInfoList(std::vector<DmDeviceInfo> & deviceInfoList)637 std::string DmRadarHelper::GetDeviceInfoList(std::vector<DmDeviceInfo> &deviceInfoList)
638 {
639 cJSON* deviceInfoJson = cJSON_CreateArray();
640 for (size_t i = 0; i < deviceInfoList.size(); i++) {
641 cJSON* object = cJSON_CreateObject();
642 std::string udidHash = GetUdidHashByUdid(std::string(deviceInfoList[i].deviceId));
643 cJSON_AddStringToObject(object, "PEER_UDID", udidHash.c_str());
644 std::string peerNetId = GetAnonyUdid(deviceInfoList[i].networkId);
645 cJSON_AddStringToObject(object, "PEER_NET_ID", peerNetId.c_str());
646 std::string devType = ConvertHexToString(deviceInfoList[i].deviceTypeId);
647 cJSON_AddStringToObject(object, "PEER_DEV_TYPE", devType.c_str());
648 cJSON_AddStringToObject(object, "PEER_DEV_NAME", deviceInfoList[i].deviceName);
649 cJSON_AddItemToArray(deviceInfoJson, object);
650 }
651 return std::string(cJSON_PrintUnformatted(deviceInfoJson));
652 }
653
GetUdidHashByUdid(std::string udid)654 std::string DmRadarHelper::GetUdidHashByUdid(std::string udid)
655 {
656 char udidHash[DM_MAX_DEVICE_ID_LEN] = {0};
657 if (DmSoftbusAdapterCrypto::GetUdidHash(udid, reinterpret_cast<uint8_t *>(udidHash)) != DM_OK) {
658 return "";
659 }
660 return GetAnonyUdid(std::string(udidHash));
661 }
662
GetErrorCode(int32_t errCode,int32_t module)663 int32_t DmRadarHelper::GetErrorCode(int32_t errCode, int32_t module)
664 {
665 return ErrCodeOffset(SUBSYS_DISTRIBUTEDHARDWARE_DM, module) + errCode;
666 }
667
GetAnonyUdid(std::string udid)668 std::string DmRadarHelper::GetAnonyUdid(std::string udid)
669 {
670 if (udid.empty() || udid.length() < INVALID_UDID_LENGTH) {
671 return "unknown";
672 }
673 return udid.substr(0, SUBSTR_UDID_LENGTH) + "**" + udid.substr(udid.length() - SUBSTR_UDID_LENGTH);
674 }
675
GetLocalUdid()676 std::string DmRadarHelper::GetLocalUdid()
677 {
678 char localDeviceId[DEVICE_UUID_LENGTH] = {0};
679 GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH);
680 return std::string(localDeviceId);
681 }
682
CreateDmRadarInstance()683 IDmRadarHelper *CreateDmRadarInstance()
684 {
685 return &DmRadarHelper::GetInstance();
686 }
687 } // namespace DistributedHardware
688 } // namespace OHOS