• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021 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 "softbus_connector.h"
17 
18 #include <securec.h>
19 #include <unistd.h>
20 #if defined(__LITEOS_M__)
21 #include "dm_mutex.h"
22 #include "dm_thread.h"
23 #else
24 #include <thread>
25 #include <mutex>
26 #endif
27 
28 #include "dm_anonymous.h"
29 #include "dm_constants.h"
30 #include "dm_device_info.h"
31 #include "dm_log.h"
32 #include "nlohmann/json.hpp"
33 #include "parameter.h"
34 #include "system_ability_definition.h"
35 
36 namespace OHOS {
37 namespace DistributedHardware {
38 SoftbusConnector::PulishStatus SoftbusConnector::publishStatus = SoftbusConnector::STATUS_UNKNOWN;
39 std::map<std::string, std::shared_ptr<DeviceInfo>> SoftbusConnector::discoveryDeviceInfoMap_ = {};
40 std::map<std::string, std::shared_ptr<ISoftbusStateCallback>> SoftbusConnector::stateCallbackMap_ = {};
41 std::map<std::string, std::shared_ptr<ISoftbusDiscoveryCallback>> SoftbusConnector::discoveryCallbackMap_ = {};
42 
43 IPublishCallback SoftbusConnector::softbusPublishCallback_ = {.OnPublishSuccess = SoftbusConnector::OnPublishSuccess,
44                                                               .OnPublishFail = SoftbusConnector::OnPublishFail};
45 
46 IDiscoveryCallback SoftbusConnector::softbusDiscoveryCallback_ = {
47     .OnDeviceFound = SoftbusConnector::OnSoftbusDeviceFound,
48     .OnDiscoverFailed = SoftbusConnector::OnSoftbusDiscoveryFailed,
49     .OnDiscoverySuccess = SoftbusConnector::OnSoftbusDiscoverySuccess};
50 
51 INodeStateCb SoftbusConnector::softbusNodeStateCb_ = {
52     .events = EVENT_NODE_STATE_ONLINE | EVENT_NODE_STATE_OFFLINE | EVENT_NODE_STATE_INFO_CHANGED,
53     .onNodeOnline = SoftbusConnector::OnSoftBusDeviceOnline,
54     .onNodeOffline = SoftbusConnector::OnSoftbusDeviceOffline,
55     .onNodeBasicInfoChanged = SoftbusConnector::OnSoftbusDeviceInfoChanged};
56 
DeviceOnLine(std::map<std::string,std::shared_ptr<ISoftbusStateCallback>> stateCallbackMap,DmDeviceInfo deviceInfo)57 void DeviceOnLine(std::map<std::string, std::shared_ptr<ISoftbusStateCallback>> stateCallbackMap,
58     DmDeviceInfo deviceInfo)
59 {
60     LOGI("Device on line start");
61 #if defined(__LITEOS_M__)
62     DmMutex lockDeviceOnLine;
63 #else
64     std::mutex lockDeviceOnLine;
65     std::lock_guard<std::mutex> lock(lockDeviceOnLine);
66 #endif
67     for (auto &iter : stateCallbackMap) {
68         iter.second->OnDeviceOnline(iter.first, deviceInfo);
69     }
70     LOGI("Device on line end");
71 }
72 
DeviceOffLine(std::map<std::string,std::shared_ptr<ISoftbusStateCallback>> stateCallbackMap,DmDeviceInfo deviceInfo)73 void DeviceOffLine(std::map<std::string, std::shared_ptr<ISoftbusStateCallback>> stateCallbackMap,
74     DmDeviceInfo deviceInfo)
75 {
76     LOGI("Device off line start");
77 #if defined(__LITEOS_M__)
78     DmMutex lockDeviceOffLine;
79 #else
80     std::mutex lockDeviceOffLine;
81     std::lock_guard<std::mutex> lock(lockDeviceOffLine);
82 #endif
83     for (auto &iter : stateCallbackMap) {
84         iter.second->OnDeviceOffline(iter.first, deviceInfo);
85     }
86     LOGI("Device off line end");
87 }
88 
SoftbusConnector()89 SoftbusConnector::SoftbusConnector()
90 {
91     softbusSession_ = std::make_shared<SoftbusSession>();
92     Init();
93 }
94 
~SoftbusConnector()95 SoftbusConnector::~SoftbusConnector()
96 {
97     LOGI("SoftbusConnector destructor");
98 }
99 
Init()100 int32_t SoftbusConnector::Init()
101 {
102     int32_t ret;
103     int32_t retryTimes = 0;
104     do {
105         ret = RegNodeDeviceStateCb(DM_PKG_NAME.c_str(), &softbusNodeStateCb_);
106         if (ret != DM_OK) {
107             ++retryTimes;
108             LOGE("RegNodeDeviceStateCb failed with ret %d, retryTimes %d", ret, retryTimes);
109             usleep(SOFTBUS_CHECK_INTERVAL);
110         }
111     } while (ret != DM_OK);
112 
113     PublishInfo dmPublishInfo;
114     dmPublishInfo.publishId = DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID;
115     dmPublishInfo.mode = DiscoverMode::DISCOVER_MODE_ACTIVE;
116     dmPublishInfo.medium = ExchanageMedium::AUTO;
117     dmPublishInfo.freq = ExchangeFreq::HIGH;
118     dmPublishInfo.capability = DM_CAPABILITY_OSD;
119     dmPublishInfo.capabilityData = nullptr;
120     dmPublishInfo.dataLen = 0;
121 #if (defined(__LITEOS_M__) || defined(LITE_DEVICE))
122     ret = PublishService(DM_PKG_NAME.c_str(), &dmPublishInfo, &softbusPublishCallback_);
123     if (ret == DM_OK) {
124         publishStatus = ALLOW_BE_DISCOVERY;
125     }
126 #else
127     char discoverStatus[DISCOVER_STATUS_LEN + 1] = {0};
128     ret = GetParameter(DISCOVER_STATUS_KEY.c_str(), "not exist", discoverStatus, DISCOVER_STATUS_LEN);
129     if (strcmp(discoverStatus, "not exist") == 0) {
130         ret = SetParameter(DISCOVER_STATUS_KEY.c_str(), DISCOVER_STATUS_ON.c_str());
131         LOGI("service set poatrameter result is : %d", ret);
132 
133         ret = PublishService(DM_PKG_NAME.c_str(), &dmPublishInfo, &softbusPublishCallback_);
134         if (ret == DM_OK) {
135             publishStatus = ALLOW_BE_DISCOVERY;
136         }
137         LOGI("service publish result is : %d", ret);
138     } else if (ret >= 0 && strcmp(discoverStatus, DISCOVER_STATUS_ON.c_str()) == 0) {
139         ret = PublishService(DM_PKG_NAME.c_str(), &dmPublishInfo, &softbusPublishCallback_);
140         if (ret == DM_OK) {
141             publishStatus = ALLOW_BE_DISCOVERY;
142         }
143         LOGI("service publish result is : %d", ret);
144     } else if (ret >= 0 && strcmp(discoverStatus, DISCOVER_STATUS_OFF.c_str()) == 0) {
145         ret = UnPublishService(DM_PKG_NAME.c_str(), DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID);
146         if (ret == DM_OK) {
147             publishStatus = NOT_ALLOW_BE_DISCOVERY;
148         }
149         LOGI("service unpublish result is : %d", ret);
150     }
151 
152     ret = WatchParameter(DISCOVER_STATUS_KEY.c_str(), &SoftbusConnector::OnParameterChgCallback, nullptr);
153 #endif
154     return ret;
155 }
156 
RegisterSoftbusDiscoveryCallback(const std::string & pkgName,const std::shared_ptr<ISoftbusDiscoveryCallback> callback)157 int32_t SoftbusConnector::RegisterSoftbusDiscoveryCallback(const std::string &pkgName,
158                                                            const std::shared_ptr<ISoftbusDiscoveryCallback> callback)
159 {
160     discoveryCallbackMap_.emplace(pkgName, callback);
161     return DM_OK;
162 }
163 
UnRegisterSoftbusDiscoveryCallback(const std::string & pkgName)164 int32_t SoftbusConnector::UnRegisterSoftbusDiscoveryCallback(const std::string &pkgName)
165 {
166     discoveryCallbackMap_.erase(pkgName);
167     return DM_OK;
168 }
169 
RegisterSoftbusStateCallback(const std::string & pkgName,const std::shared_ptr<ISoftbusStateCallback> callback)170 int32_t SoftbusConnector::RegisterSoftbusStateCallback(const std::string &pkgName,
171                                                        const std::shared_ptr<ISoftbusStateCallback> callback)
172 {
173     stateCallbackMap_.emplace(pkgName, callback);
174     return DM_OK;
175 }
176 
UnRegisterSoftbusStateCallback(const std::string & pkgName)177 int32_t SoftbusConnector::UnRegisterSoftbusStateCallback(const std::string &pkgName)
178 {
179     stateCallbackMap_.erase(pkgName);
180     return DM_OK;
181 }
182 
GetTrustedDeviceList(std::vector<DmDeviceInfo> & deviceInfoList)183 int32_t SoftbusConnector::GetTrustedDeviceList(std::vector<DmDeviceInfo> &deviceInfoList)
184 {
185     LOGI("SoftbusConnector::GetTrustDevices start");
186     int32_t infoNum = 0;
187     NodeBasicInfo *nodeInfo = nullptr;
188     int32_t ret = GetAllNodeDeviceInfo(DM_PKG_NAME.c_str(), &nodeInfo, &infoNum);
189     if (ret != 0) {
190         LOGE("GetAllNodeDeviceInfo failed with ret %d", ret);
191         return DM_FAILED;
192     }
193     DmDeviceInfo *info = (DmDeviceInfo *)malloc(sizeof(DmDeviceInfo) * (infoNum));
194     if (info == nullptr) {
195         FreeNodeInfo(nodeInfo);
196         return DM_MALLOC_ERROR;
197     }
198     DmDeviceInfo **pInfoList = &info;
199     for (int32_t i = 0; i < infoNum; ++i) {
200         NodeBasicInfo *nodeBasicInfo = nodeInfo + i;
201         DmDeviceInfo *deviceInfo = *pInfoList + i;
202         CovertNodeBasicInfoToDmDevice(*nodeBasicInfo, *deviceInfo);
203         deviceInfoList.push_back(*deviceInfo);
204     }
205     FreeNodeInfo(nodeInfo);
206     free(info);
207     LOGI("SoftbusConnector::GetTrustDevices success, deviceCount %d", infoNum);
208     return DM_OK;
209 }
210 
GetLocalDeviceInfo(DmDeviceInfo & deviceInfo)211 int32_t SoftbusConnector::GetLocalDeviceInfo(DmDeviceInfo &deviceInfo)
212 {
213     LOGI("SoftbusConnector::GetLocalDeviceInfo start");
214     NodeBasicInfo nodeBasicInfo;
215     int32_t ret = GetLocalNodeDeviceInfo(DM_PKG_NAME.c_str(), &nodeBasicInfo);
216     if (ret != 0) {
217         LOGE("GetLocalNodeDeviceInfo failed with ret %d", ret);
218         return DM_FAILED;
219     }
220     CovertNodeBasicInfoToDmDevice(nodeBasicInfo, deviceInfo);
221     LOGI("SoftbusConnector::GetLocalDeviceInfo success");
222     return DM_OK;
223 }
224 
StartDiscovery(const DmSubscribeInfo & dmSubscribeInfo)225 int32_t SoftbusConnector::StartDiscovery(const DmSubscribeInfo &dmSubscribeInfo)
226 {
227     SubscribeInfo subscribeInfo;
228     subscribeInfo.subscribeId = dmSubscribeInfo.subscribeId;
229     subscribeInfo.mode = (DiscoverMode)dmSubscribeInfo.mode;
230     subscribeInfo.medium = (ExchanageMedium)dmSubscribeInfo.medium;
231     subscribeInfo.freq = (ExchangeFreq)dmSubscribeInfo.freq;
232     subscribeInfo.isSameAccount = dmSubscribeInfo.isSameAccount;
233     subscribeInfo.isWakeRemote = dmSubscribeInfo.isWakeRemote;
234     subscribeInfo.capability = dmSubscribeInfo.capability;
235     subscribeInfo.capabilityData = nullptr;
236     subscribeInfo.dataLen = 0;
237     int32_t ret = ::StartDiscovery(DM_PKG_NAME.c_str(), &subscribeInfo, &softbusDiscoveryCallback_);
238     if (ret != 0) {
239         LOGE("StartDiscovery failed with ret %d.", ret);
240         return DM_DISCOVERY_FAILED;
241     }
242     return DM_OK;
243 }
244 
StopDiscovery(uint16_t subscribeId)245 int32_t SoftbusConnector::StopDiscovery(uint16_t subscribeId)
246 {
247     LOGI("StopDiscovery begin, subscribeId:%d", (int32_t)subscribeId);
248     int32_t ret = ::StopDiscovery(DM_PKG_NAME.c_str(), subscribeId);
249     if (ret != 0) {
250         LOGE("StopDiscovery failed with ret %d", ret);
251         return ret;
252     }
253     LOGI("SoftbusConnector::StopDiscovery completed");
254     return DM_OK;
255 }
256 
GetUdidByNetworkId(const char * networkId,std::string & udid)257 int32_t SoftbusConnector::GetUdidByNetworkId(const char *networkId, std::string &udid)
258 {
259     LOGI("GetUdidByNetworkId begin");
260     uint8_t mUdid[UDID_BUF_LEN] = {0};
261     int32_t ret =
262         GetNodeKeyInfo(DM_PKG_NAME.c_str(), networkId, NodeDeviceInfoKey::NODE_KEY_UDID, mUdid, sizeof(mUdid));
263     if (ret != DM_OK) {
264         LOGE("GetUdidByNetworkId GetNodeKeyInfo failed");
265         return DM_FAILED;
266     }
267     udid = (char *)mUdid;
268     LOGI("SoftbusConnector::GetUdidByNetworkId completed");
269     return DM_OK;
270 }
271 
GetUuidByNetworkId(const char * networkId,std::string & uuid)272 int32_t SoftbusConnector::GetUuidByNetworkId(const char *networkId, std::string &uuid)
273 {
274     LOGI("GetUuidByNetworkId begin");
275     uint8_t mUuid[UUID_BUF_LEN] = {0};
276     int32_t ret =
277         GetNodeKeyInfo(DM_PKG_NAME.c_str(), networkId, NodeDeviceInfoKey::NODE_KEY_UUID, mUuid, sizeof(mUuid));
278     if (ret != DM_OK) {
279         LOGE("GetUuidByNetworkId GetNodeKeyInfo failed");
280         return DM_FAILED;
281     }
282     uuid = (char *)mUuid;
283     LOGI("SoftbusConnector::GetUuidByNetworkId completed");
284     return DM_OK;
285 }
286 
IsDeviceOnLine(const std::string & deviceId)287 bool SoftbusConnector::IsDeviceOnLine(const std::string &deviceId)
288 {
289     NodeBasicInfo *info = nullptr;
290     int32_t infoNum = 0;
291     if (GetAllNodeDeviceInfo(DM_PKG_NAME.c_str(), &info, &infoNum) != DM_OK) {
292         LOGE("GetAllNodeDeviceInfo failed");
293         return false;
294     }
295     bool bDeviceOnline = false;
296     for (int32_t i = 0; i < infoNum; ++i) {
297         NodeBasicInfo *nodeBasicInfo = info + i;
298         if (nodeBasicInfo == nullptr) {
299             LOGE("nodeBasicInfo is empty for index %d, infoNum %d.", i, infoNum);
300             continue;
301         }
302         std::string networkId = nodeBasicInfo->networkId;
303         if (networkId == deviceId) {
304             LOGI("DM_IsDeviceOnLine device %s online", GetAnonyString(deviceId).c_str());
305             bDeviceOnline = true;
306             break;
307         }
308         uint8_t udid[UDID_BUF_LEN] = {0};
309         int32_t ret = GetNodeKeyInfo(DM_PKG_NAME.c_str(), networkId.c_str(), NodeDeviceInfoKey::NODE_KEY_UDID, udid,
310                                      sizeof(udid));
311         if (ret != DM_OK) {
312             LOGE("DM_IsDeviceOnLine GetNodeKeyInfo failed");
313             break;
314         }
315         if (strcmp((char *)udid, deviceId.c_str()) == 0) {
316             LOGI("DM_IsDeviceOnLine device %s online", GetAnonyString(deviceId).c_str());
317             bDeviceOnline = true;
318             break;
319         }
320     }
321     FreeNodeInfo(info);
322     return bDeviceOnline;
323 }
324 
GetSoftbusSession()325 std::shared_ptr<SoftbusSession> SoftbusConnector::GetSoftbusSession()
326 {
327     return softbusSession_;
328 }
329 
HaveDeviceInMap(std::string deviceId)330 bool SoftbusConnector::HaveDeviceInMap(std::string deviceId)
331 {
332     auto iter = discoveryDeviceInfoMap_.find(deviceId);
333     if (iter == discoveryDeviceInfoMap_.end()) {
334         LOGE("deviceInfo not found by deviceId %s", GetAnonyString(deviceId).c_str());
335         return false;
336     }
337     return true;
338 }
339 
GetConnectionIpAddress(const std::string & deviceId,std::string & ipAddress)340 int32_t SoftbusConnector::GetConnectionIpAddress(const std::string &deviceId, std::string &ipAddress)
341 {
342     auto iter = discoveryDeviceInfoMap_.find(deviceId);
343     if (iter == discoveryDeviceInfoMap_.end()) {
344         LOGE("deviceInfo not found by deviceId %s", GetAnonyString(deviceId).c_str());
345         return DM_FAILED;
346     }
347     DeviceInfo *deviceInfo = iter->second.get();
348     if (deviceInfo->addrNum <= 0 || deviceInfo->addrNum >= CONNECTION_ADDR_MAX) {
349         LOGE("deviceInfo address num not valid, addrNum %d", deviceInfo->addrNum);
350         return DM_FAILED;
351     }
352     for (uint32_t i = 0; i < deviceInfo->addrNum; ++i) {
353         // currently, only support CONNECT_ADDR_WLAN
354         if (deviceInfo->addr[i].type != ConnectionAddrType::CONNECTION_ADDR_WLAN &&
355             deviceInfo->addr[i].type != ConnectionAddrType::CONNECTION_ADDR_ETH) {
356             continue;
357         }
358         ipAddress = deviceInfo->addr[i].info.ip.ip;
359         LOGI("DM_GetConnectionIpAddr get ip ok.");
360         return DM_OK;
361     }
362     LOGE("failed to get ipAddress for deviceId %s", GetAnonyString(deviceId).c_str());
363     return DM_FAILED;
364 }
365 
GetConnectAddrByType(DeviceInfo * deviceInfo,ConnectionAddrType type)366 ConnectionAddr *SoftbusConnector::GetConnectAddrByType(DeviceInfo *deviceInfo, ConnectionAddrType type)
367 {
368     if (deviceInfo == nullptr) {
369         return nullptr;
370     }
371     for (uint32_t i = 0; i < deviceInfo->addrNum; ++i) {
372         if (deviceInfo->addr[i].type == type) {
373             return &deviceInfo->addr[i];
374         }
375     }
376     return nullptr;
377 }
378 
GetConnectAddr(const std::string & deviceId,std::string & connectAddr)379 ConnectionAddr *SoftbusConnector::GetConnectAddr(const std::string &deviceId, std::string &connectAddr)
380 {
381     auto iter = discoveryDeviceInfoMap_.find(deviceId);
382     if (iter == discoveryDeviceInfoMap_.end()) {
383         LOGE("deviceInfo not found by deviceId %s", GetAnonyString(deviceId).c_str());
384         return nullptr;
385     }
386     DeviceInfo *deviceInfo = iter->second.get();
387     if (deviceInfo->addrNum <= 0 || deviceInfo->addrNum >= CONNECTION_ADDR_MAX) {
388         LOGE("deviceInfo addrNum not valid, addrNum %d", deviceInfo->addrNum);
389         return nullptr;
390     }
391     nlohmann::json jsonPara;
392     ConnectionAddr *addr = nullptr;
393     addr = GetConnectAddrByType(deviceInfo, ConnectionAddrType::CONNECTION_ADDR_ETH);
394     if (addr != nullptr) {
395         LOGI("get ETH ConnectionAddr for deviceId %s", GetAnonyString(deviceId).c_str());
396         jsonPara[ETH_IP] = addr->info.ip.ip;
397         jsonPara[ETH_PORT] = addr->info.ip.port;
398         connectAddr = jsonPara.dump();
399         return addr;
400     }
401     addr = GetConnectAddrByType(deviceInfo, ConnectionAddrType::CONNECTION_ADDR_WLAN);
402     if (addr != nullptr) {
403         jsonPara[WIFI_IP] = addr->info.ip.ip;
404         jsonPara[WIFI_PORT] = addr->info.ip.port;
405         LOGI("get WLAN ConnectionAddr for deviceId %s", GetAnonyString(deviceId).c_str());
406         connectAddr = jsonPara.dump();
407         return addr;
408     }
409     addr = GetConnectAddrByType(deviceInfo, ConnectionAddrType::CONNECTION_ADDR_BLE);
410     if (addr != nullptr) {
411         jsonPara[BR_MAC] = addr->info.br.brMac;
412         LOGI("get BLE ConnectionAddr for deviceId %s", GetAnonyString(deviceId).c_str());
413         connectAddr = jsonPara.dump();
414         return addr;
415     }
416     addr = GetConnectAddrByType(deviceInfo, ConnectionAddrType::CONNECTION_ADDR_BR);
417     if (addr != nullptr) {
418         jsonPara[BLE_MAC] = addr->info.ble.bleMac;
419         LOGI("get BR ConnectionAddr for deviceId %s", GetAnonyString(deviceId).c_str());
420         connectAddr = jsonPara.dump();
421         return addr;
422     }
423     LOGE("failed to get ConnectionAddr for deviceId %s", GetAnonyString(deviceId).c_str());
424     return nullptr;
425 }
426 
CovertNodeBasicInfoToDmDevice(const NodeBasicInfo & nodeBasicInfo,DmDeviceInfo & dmDeviceInfo)427 int32_t SoftbusConnector::CovertNodeBasicInfoToDmDevice(const NodeBasicInfo &nodeBasicInfo, DmDeviceInfo &dmDeviceInfo)
428 {
429     (void)memset_s(&dmDeviceInfo, sizeof(DmDeviceInfo), 0, sizeof(DmDeviceInfo));
430     if (memcpy_s(dmDeviceInfo.deviceId, sizeof(dmDeviceInfo.deviceId), nodeBasicInfo.networkId,
431                  std::min(sizeof(dmDeviceInfo.deviceId), sizeof(nodeBasicInfo.networkId))) != DM_OK) {
432         LOGE("CovertNodeBasicInfoToDmDevice copy deviceId data failed");
433     }
434 
435     if (memcpy_s(dmDeviceInfo.networkId, sizeof(dmDeviceInfo.networkId), nodeBasicInfo.networkId,
436                  std::min(sizeof(dmDeviceInfo.networkId), sizeof(nodeBasicInfo.networkId))) != DM_OK) {
437         LOGE("CovertNodeBasicInfoToDmDevice copy networkId data failed");
438     }
439 
440     if (memcpy_s(dmDeviceInfo.deviceName, sizeof(dmDeviceInfo.deviceName), nodeBasicInfo.deviceName,
441                  std::min(sizeof(dmDeviceInfo.deviceName), sizeof(nodeBasicInfo.deviceName))) != DM_OK) {
442         LOGE("CovertNodeBasicInfoToDmDevice copy deviceName data failed");
443     }
444     dmDeviceInfo.deviceTypeId = nodeBasicInfo.deviceTypeId;
445     return DM_OK;
446 }
447 
CovertDeviceInfoToDmDevice(const DeviceInfo & deviceInfo,DmDeviceInfo & dmDeviceInfo)448 void SoftbusConnector::CovertDeviceInfoToDmDevice(const DeviceInfo &deviceInfo, DmDeviceInfo &dmDeviceInfo)
449 {
450     (void)memset_s(&dmDeviceInfo, sizeof(DmDeviceInfo), 0, sizeof(DmDeviceInfo));
451     if (memcpy_s(dmDeviceInfo.deviceId, sizeof(dmDeviceInfo.deviceId), deviceInfo.devId,
452                  std::min(sizeof(dmDeviceInfo.deviceId), sizeof(deviceInfo.devId))) != DM_OK) {
453         LOGE("CovertDeviceInfoToDmDevice copy deviceId data failed");
454     }
455 
456     if (memcpy_s(dmDeviceInfo.networkId, sizeof(dmDeviceInfo.networkId), 0,
457                  sizeof(dmDeviceInfo.networkId)) != DM_OK) {
458         LOGE("CovertDeviceInfoToDmDevice copy networkId data failed");
459     }
460 
461     if (memcpy_s(dmDeviceInfo.deviceName, sizeof(dmDeviceInfo.deviceName), deviceInfo.devName,
462                  std::min(sizeof(dmDeviceInfo.deviceName), sizeof(deviceInfo.devName))) != DM_OK) {
463         LOGE("CovertDeviceInfoToDmDevice copy deviceName data failed");
464     }
465     dmDeviceInfo.deviceTypeId = deviceInfo.devType;
466 }
467 
OnPublishSuccess(int publishId)468 void SoftbusConnector::OnPublishSuccess(int publishId)
469 {
470     LOGI("SoftbusConnector::OnPublishSuccess, publishId: %d", publishId);
471 }
472 
OnPublishFail(int publishId,PublishFailReason reason)473 void SoftbusConnector::OnPublishFail(int publishId, PublishFailReason reason)
474 {
475     LOGI("SoftbusConnector::OnPublishFail failed, publishId: %d, reason: %d", publishId, reason);
476 }
477 
OnSoftBusDeviceOnline(NodeBasicInfo * info)478 void SoftbusConnector::OnSoftBusDeviceOnline(NodeBasicInfo *info)
479 {
480     LOGI("device online");
481     if (info == nullptr) {
482         LOGE("SoftbusConnector::OnSoftbusDeviceOffline NodeBasicInfo is nullptr");
483         return;
484     }
485 
486     DmDeviceInfo dmDeviceInfo;
487     CovertNodeBasicInfoToDmDevice(*info, dmDeviceInfo);
488 #if defined(__LITEOS_M__)
489     DmThread deviceOnLine(DeviceOnLine, stateCallbackMap_, dmDeviceInfo);
490     deviceOnLine.DmCreatThread();
491 #else
492     std::thread deviceOnLine(DeviceOnLine, stateCallbackMap_, dmDeviceInfo);
493     deviceOnLine.detach();
494 #endif
495 
496     if (discoveryDeviceInfoMap_.empty()) {
497         return;
498     }
499     // remove the discovery node map
500     uint8_t udid[UDID_BUF_LEN] = {0};
501     int32_t ret =
502         GetNodeKeyInfo(DM_PKG_NAME.c_str(), info->networkId, NodeDeviceInfoKey::NODE_KEY_UDID, udid, sizeof(udid));
503     if (ret != DM_OK) {
504         LOGE("GetNodeKeyInfo failed");
505         return;
506     }
507     std::string deviceId = (char *)udid;
508     LOGI("device online, deviceId: %s", GetAnonyString(deviceId).c_str());
509     discoveryDeviceInfoMap_.erase(deviceId);
510 }
511 
OnSoftbusDeviceOffline(NodeBasicInfo * info)512 void SoftbusConnector::OnSoftbusDeviceOffline(NodeBasicInfo *info)
513 {
514     if (info == nullptr) {
515         LOGE("OnSoftbusDeviceOffline NodeBasicInfo is nullptr");
516         return;
517     }
518     DmDeviceInfo dmDeviceInfo;
519     CovertNodeBasicInfoToDmDevice(*info, dmDeviceInfo);
520 #if defined(__LITEOS_M__)
521     DmThread deviceOffLine(DeviceOffLine, stateCallbackMap_, dmDeviceInfo);
522     deviceOffLine.DmCreatThread();
523 #else
524     std::thread deviceOffLine(DeviceOffLine, stateCallbackMap_, dmDeviceInfo);
525     deviceOffLine.detach();
526 #endif
527 }
528 
OnSoftbusDeviceInfoChanged(NodeBasicInfoType type,NodeBasicInfo * info)529 void SoftbusConnector::OnSoftbusDeviceInfoChanged(NodeBasicInfoType type, NodeBasicInfo *info)
530 {
531     LOGI("SoftbusConnector::OnSoftbusDeviceInfoChanged.");
532 }
533 
OnSoftbusDeviceFound(const DeviceInfo * device)534 void SoftbusConnector::OnSoftbusDeviceFound(const DeviceInfo *device)
535 {
536     if (device == nullptr) {
537         LOGE("device is null");
538         return;
539     }
540     std::string deviceId = device->devId;
541     LOGI("SoftbusConnector::OnSoftbusDeviceFound device %s found.", GetAnonyString(deviceId).c_str());
542     if (IsDeviceOnLine(deviceId)) {
543         return;
544     }
545     std::shared_ptr<DeviceInfo> infoPtr = std::make_shared<DeviceInfo>();
546     DeviceInfo *srcInfo = infoPtr.get();
547     if (memcpy_s(srcInfo, sizeof(DeviceInfo), device, sizeof(DeviceInfo)) != 0) {
548         LOGE("save discovery device info failed");
549         return;
550     }
551     discoveryDeviceInfoMap_[deviceId] = infoPtr;
552     // Remove the earliest element when reached the max size
553     if (discoveryDeviceInfoMap_.size() == SOFTBUS_DISCOVER_DEVICE_INFO_MAX_SIZE) {
554         auto iter = discoveryDeviceInfoMap_.begin();
555         discoveryDeviceInfoMap_.erase(iter->second->devId);
556     }
557     DmDeviceInfo dmDeviceInfo;
558     CovertDeviceInfoToDmDevice(*device, dmDeviceInfo);
559     for (auto &iter : discoveryCallbackMap_) {
560         iter.second->OnDeviceFound(iter.first, dmDeviceInfo);
561     }
562 }
563 
OnSoftbusDiscoveryFailed(int subscribeId,DiscoveryFailReason failReason)564 void SoftbusConnector::OnSoftbusDiscoveryFailed(int subscribeId, DiscoveryFailReason failReason)
565 {
566     LOGI("In, subscribeId %d, failReason %d", subscribeId, (int32_t)failReason);
567     uint16_t originId = (uint16_t)(((uint32_t)subscribeId) & SOFTBUS_SUBSCRIBE_ID_MASK);
568     for (auto &iter : discoveryCallbackMap_) {
569         iter.second->OnDiscoveryFailed(iter.first, originId, (int32_t)failReason);
570     }
571 }
572 
OnSoftbusDiscoverySuccess(int subscribeId)573 void SoftbusConnector::OnSoftbusDiscoverySuccess(int subscribeId)
574 {
575     LOGI("In, subscribeId %d", subscribeId);
576     uint16_t originId = (uint16_t)(((uint32_t)subscribeId) & SOFTBUS_SUBSCRIBE_ID_MASK);
577     for (auto &iter : discoveryCallbackMap_) {
578         iter.second->OnDiscoverySuccess(iter.first, originId);
579     }
580 }
581 
OnParameterChgCallback(const char * key,const char * value,void * context)582 void SoftbusConnector::OnParameterChgCallback(const char *key, const char *value, void *context)
583 {
584     if (strcmp(value, DISCOVER_STATUS_ON.c_str()) == 0 && publishStatus != ALLOW_BE_DISCOVERY) {
585         PublishInfo dmPublishInfo;
586         dmPublishInfo.publishId = DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID;
587         dmPublishInfo.mode = DiscoverMode::DISCOVER_MODE_ACTIVE;
588         dmPublishInfo.medium = ExchanageMedium::AUTO;
589         dmPublishInfo.freq = ExchangeFreq::HIGH;
590         dmPublishInfo.capability = DM_CAPABILITY_OSD;
591         dmPublishInfo.capabilityData = nullptr;
592         dmPublishInfo.dataLen = 0;
593         int32_t ret = PublishService(DM_PKG_NAME.c_str(), &dmPublishInfo, &softbusPublishCallback_);
594         if (ret == DM_OK) {
595             publishStatus = ALLOW_BE_DISCOVERY;
596         }
597         LOGI("service publish result is : %d", ret);
598     } else if (strcmp(value, DISCOVER_STATUS_OFF.c_str()) == 0 && publishStatus != NOT_ALLOW_BE_DISCOVERY) {
599         int32_t ret = UnPublishService(DM_PKG_NAME.c_str(), DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID);
600         if (ret == DM_OK) {
601             publishStatus = NOT_ALLOW_BE_DISCOVERY;
602         }
603         LOGI("service unpublish result is : %d", ret);
604     }
605 }
606 } // namespace DistributedHardware
607 } // namespace OHOS
608