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