1 /*
2  * Copyright (c) 2021-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 "dtbschedmgr_device_info_storage.h"
17 
18 #include <chrono>
19 #include <thread>
20 
21 #include "device_manager.h"
22 #include "ipc_object_proxy.h"
23 #include "ipc_skeleton.h"
24 #include "iservice_registry.h"
25 #include "system_ability_definition.h"
26 
27 #include "distributed_device_node_listener.h"
28 #include "distributed_sched_service.h"
29 #include "distributed_sched_utils.h"
30 #include "dtbschedmgr_log.h"
31 #include "mission/dms_continue_recv_manager.h"
32 
33 using namespace std;
34 namespace OHOS {
35 namespace DistributedSchedule {
36 using namespace std::chrono_literals;
37 using namespace DistributedHardware;
38 
39 namespace {
40 constexpr int32_t RETRY_TIMES = 30;
41 constexpr int32_t CONNECT_SOFTBUS_RETRY_TIMES = 60;
42 const std::string TAG = "DtbschedmgrDeviceInfoStorage";
43 const std::string PKG_NAME = "DBinderBus_Dms_" + std::to_string(getprocpid());
44 }
45 
46 IMPLEMENT_SINGLE_INSTANCE(DtbschedmgrDeviceInfoStorage);
47 
Init()48 bool DtbschedmgrDeviceInfoStorage::Init()
49 {
50     if (initHandler_ == nullptr) {
51         auto deviceInfoStorageRunner = AppExecFwk::EventRunner::Create("DmsDeviceInfoStorageManager");
52         initHandler_ = std::make_shared<AppExecFwk::EventHandler>(deviceInfoStorageRunner);
53     }
54 
55     auto func = [this]() {
56         HILOGI("begin connect softbus");
57         for (int32_t retryTimes = 0; retryTimes <= CONNECT_SOFTBUS_RETRY_TIMES; retryTimes++) {
58             if (ConnectSoftbus()) {
59                 return;
60             }
61             HILOGE("retry connect softbus %{public}d times", retryTimes);
62             std::this_thread::sleep_for(1s);
63         }
64         HILOGE("connect softbus 60times * 30s, error!!");
65     };
66     if (!initHandler_->PostTask(func)) {
67         HILOGE("Init handler postTask failed");
68         return false;
69     }
70     return true;
71 }
72 
ConnectSoftbus()73 bool DtbschedmgrDeviceInfoStorage::ConnectSoftbus()
74 {
75     ClearAllDevices();
76     bool isReady = WaitForDnetworkReady();
77     if (!isReady) {
78         HILOGE("ConnectSoftbus wait Dnetwork failed!");
79         return false;
80     }
81     std::shared_ptr<DnetworkAdapter> dnetworkAdapter = DnetworkAdapter::GetInstance();
82     if (dnetworkAdapter == nullptr) {
83         HILOGE("DnetworkAdapter::GetInstance is null");
84         return false;
85     }
86     if (!InitNetworkIdManager(dnetworkAdapter)) {
87         HILOGE("InitNetworkIdManager failed");
88         return false;
89     }
90     HILOGI("ConnectSoftbus success");
91     return true;
92 }
93 
InitNetworkIdManager(std::shared_ptr<DnetworkAdapter> dnetworkAdapter)94 bool DtbschedmgrDeviceInfoStorage::InitNetworkIdManager(std::shared_ptr<DnetworkAdapter> dnetworkAdapter)
95 {
96     if (dnetworkAdapter == nullptr) {
97         HILOGE("dnetworkAdapter is null");
98         return false;
99     }
100     if (networkIdMgrHandler_ == nullptr) {
101         auto runner = AppExecFwk::EventRunner::Create("DmsNetworkIdManager");
102         networkIdMgrHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
103     }
104 
105     deviceNodeListener_ = std::make_shared<DistributedDeviceNodeListener>();
106     if (!dnetworkAdapter->AddDeviceChangeListener(deviceNodeListener_)) {
107         deviceNodeListener_ = nullptr;
108         HILOGE("AddDeviceChangeListener failed!");
109         return false;
110     }
111     return true;
112 }
113 
Stop()114 void DtbschedmgrDeviceInfoStorage::Stop()
115 {
116     ClearAllDevices();
117     if (deviceNodeListener_ != nullptr) {
118         DnetworkAdapter::GetInstance()->RemoveDeviceChangeListener(deviceNodeListener_);
119         deviceNodeListener_ = nullptr;
120     }
121 }
122 
WaitForDnetworkReady()123 bool DtbschedmgrDeviceInfoStorage::WaitForDnetworkReady()
124 {
125     auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
126     if (samgr == nullptr) {
127         HILOGE("WaitForDnetworkReady failed to get samgr!");
128         return false;
129     }
130     int32_t retryTimeout = RETRY_TIMES;
131     do {
132         auto dnetwork = samgr->CheckSystemAbility(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID);
133         if (dnetwork != nullptr) {
134             IPCObjectProxy* proxy = reinterpret_cast<IPCObjectProxy*>(dnetwork.GetRefPtr());
135             // make sure the proxy is not dead
136             if (proxy != nullptr && !proxy->IsObjectDead()) {
137                 return true;
138             }
139         }
140         HILOGI("Waiting for dnentwork service...");
141         std::this_thread::sleep_for(1s);
142         if (--retryTimeout <= 0) {
143             HILOGI("Waiting for dnentwork service timeout(30)s");
144             return false;
145         }
146     } while (true);
147     return false;
148 }
149 
RegisterUuidNetworkIdMap(const std::string & networkId)150 void DtbschedmgrDeviceInfoStorage::RegisterUuidNetworkIdMap(const std::string& networkId)
151 {
152     std::string uuid = DnetworkAdapter::GetInstance()->GetUuidByNetworkId(networkId);
153     if (uuid.empty()) {
154         HILOGE("GetUuidByNetworkId return an empty uuid!");
155         return;
156     }
157     {
158         std::lock_guard<std::mutex> autoLock(uuidNetworkIdLock_);
159         uuidNetworkIdMap_[uuid] = networkId;
160     }
161 }
162 
UnregisterUuidNetworkIdMap(const std::string & networkId)163 void DtbschedmgrDeviceInfoStorage::UnregisterUuidNetworkIdMap(const std::string& networkId)
164 {
165     std::string uuid = DnetworkAdapter::GetInstance()->GetUuidByNetworkId(networkId);
166     if (uuid.empty()) {
167         HILOGE("GetUuidByNetworkId return an empty uuid");
168         return;
169     }
170     {
171         std::lock_guard<std::mutex> autoLock(uuidNetworkIdLock_);
172         uuidNetworkIdMap_.erase(uuid);
173     }
174 }
175 
GetDeviceIdSet(std::set<std::string> & deviceIdSet)176 void DtbschedmgrDeviceInfoStorage::GetDeviceIdSet(std::set<std::string>& deviceIdSet)
177 {
178     deviceIdSet.clear();
179     lock_guard<mutex> autoLock(deviceLock_);
180     for (const auto& device : remoteDevices_) {
181         deviceIdSet.emplace(device.first);
182     }
183 }
184 
UpdateDeviceInfoStorage()185 bool DtbschedmgrDeviceInfoStorage::UpdateDeviceInfoStorage()
186 {
187     std::vector<DistributedHardware::DmDeviceInfo> dmDeviceInfoList;
188     int32_t errCode = DeviceManager::GetInstance().GetTrustedDeviceList(PKG_NAME, "", dmDeviceInfoList);
189     if (errCode != ERR_OK) {
190         HILOGE("Get device manager trusted device list fail, errCode %{public}d", errCode);
191         return false;
192     }
193     for (const auto& dmDeviceInfo : dmDeviceInfoList) {
194         auto deviceInfo = std::make_shared<DmsDeviceInfo>(
195             dmDeviceInfo.deviceName, dmDeviceInfo.deviceTypeId, dmDeviceInfo.networkId);
196         std::string networkId = deviceInfo->GetNetworkId();
197         RegisterUuidNetworkIdMap(networkId);
198         {
199             HILOGI("Add remote device networkId %{public}s", GetAnonymStr(networkId).c_str());
200             lock_guard<mutex> autoLock(deviceLock_);
201             remoteDevices_[networkId] = deviceInfo;
202         }
203     }
204     HILOGI("Update remote devices info storage success.");
205     return true;
206 }
207 
GetLocalDeviceId(std::string & networkId)208 bool DtbschedmgrDeviceInfoStorage::GetLocalDeviceId(std::string& networkId)
209 {
210     auto dnetworkAdapter = DnetworkAdapter::GetInstance();
211     if (dnetworkAdapter == nullptr) {
212         HILOGE("GetLocalDeviceFromDnet dnetworkAdapter null");
213         return false;
214     }
215     DmDeviceInfo dmDeviceInfo;
216     if (!dnetworkAdapter->GetLocalBasicInfo(dmDeviceInfo)) {
217         HILOGE("GetLocalBasicInfo error");
218         return false;
219     }
220     networkId = dmDeviceInfo.networkId;
221     HILOGI("get local networkId from DnetworkAdapter, networkId = %{public}s", GetAnonymStr(networkId).c_str());
222     return true;
223 }
224 
GetLocalUdid(std::string & udid)225 bool DtbschedmgrDeviceInfoStorage::GetLocalUdid(std::string& udid)
226 {
227     auto dnetworkAdapter = DnetworkAdapter::GetInstance();
228     if (dnetworkAdapter == nullptr) {
229         HILOGE("GetLocalDeviceFromDnet dnetworkAdapter null");
230         return false;
231     }
232     DmDeviceInfo dmDeviceInfo;
233     if (!dnetworkAdapter->GetLocalBasicInfo(dmDeviceInfo)) {
234         HILOGE("GetLocalBasicInfo error");
235         return false;
236     }
237     udid = GetUdidByNetworkId(dmDeviceInfo.networkId);
238     HILOGD("GetLocalDeviceUdid = %{public}s", GetAnonymStr(udid).c_str());
239     return true;
240 }
241 
GetLocalUuid(std::string & uuid)242 bool DtbschedmgrDeviceInfoStorage::GetLocalUuid(std::string& uuid)
243 {
244     auto dnetworkAdapter = DnetworkAdapter::GetInstance();
245     if (dnetworkAdapter == nullptr) {
246         HILOGE("GetLocalDeviceFromDnet dnetworkAdapter null");
247         return false;
248     }
249     DmDeviceInfo dmDeviceInfo;
250     if (!dnetworkAdapter->GetLocalBasicInfo(dmDeviceInfo)) {
251         HILOGE("GetLocalBasicInfo error");
252         return false;
253     }
254     uuid = GetUuidByNetworkId(dmDeviceInfo.networkId);
255     HILOGD("GetLocalDeviceUuid = %{public}s", GetAnonymStr(uuid).c_str());
256     return true;
257 }
258 
ClearAllDevices()259 void DtbschedmgrDeviceInfoStorage::ClearAllDevices()
260 {
261     lock_guard<mutex> autoLock(deviceLock_);
262     remoteDevices_.clear();
263 }
264 
FindDeviceInfoInStorage(const std::string & networkId)265 std::shared_ptr<DmsDeviceInfo> DtbschedmgrDeviceInfoStorage::FindDeviceInfoInStorage(const std::string& networkId)
266 {
267     lock_guard<mutex> autoLock(deviceLock_);
268     auto iter = remoteDevices_.find(networkId);
269     if (iter == remoteDevices_.end()) {
270         HILOGE("Get remote device info from storage fail, networkId %{public}s.", GetAnonymStr(networkId).c_str());
271         return nullptr;
272     }
273     HILOGI("Get remote device info from storage success, networkId %{public}s.", GetAnonymStr(networkId).c_str());
274     return iter->second;
275 }
276 
GetDeviceInfoById(const std::string & networkId)277 std::shared_ptr<DmsDeviceInfo> DtbschedmgrDeviceInfoStorage::GetDeviceInfoById(const std::string& networkId)
278 {
279     HILOGI("Get device info by networkId %{public}s start.", GetAnonymStr(networkId).c_str());
280     auto devInfo = FindDeviceInfoInStorage(networkId);
281     if (devInfo != nullptr) {
282         return devInfo;
283     }
284 
285     HILOGI("NetworkId %{public}s not in storage, update devices info from device manager.",
286         GetAnonymStr(networkId).c_str());
287     if (!UpdateDeviceInfoStorage()) {
288         HILOGE("Update device info storage from device manager trusted device list fail.");
289         return nullptr;
290     }
291 
292     devInfo = FindDeviceInfoInStorage(networkId);
293     return devInfo;
294 }
295 
GetUuidByNetworkId(const std::string & networkId)296 std::string DtbschedmgrDeviceInfoStorage::GetUuidByNetworkId(const std::string& networkId)
297 {
298     if (networkId.empty()) {
299         HILOGW("GetUuidByNetworkId networkId empty!");
300         return "";
301     }
302     {
303         std::lock_guard<std::mutex> autoLock(uuidNetworkIdLock_);
304         auto iter = uuidNetworkIdMap_.begin();
305         while (iter != uuidNetworkIdMap_.end()) {
306             if (iter->second == networkId) {
307                 return iter->first;
308             } else {
309                 ++iter;
310             }
311         }
312     }
313     std::string uuid = DnetworkAdapter::GetInstance()->GetUuidByNetworkId(networkId);
314     return uuid;
315 }
316 
GetUdidByNetworkId(const std::string & networkId)317 std::string DtbschedmgrDeviceInfoStorage::GetUdidByNetworkId(const std::string& networkId)
318 {
319     if (networkId.empty()) {
320         HILOGW("GetUdidByNetworkId networkId empty!");
321         return "";
322     }
323     std::string udid = DnetworkAdapter::GetInstance()->GetUdidByNetworkId(networkId);
324     return udid;
325 }
326 
GetNetworkIdByUuid(const std::string & uuid)327 std::string DtbschedmgrDeviceInfoStorage::GetNetworkIdByUuid(const std::string& uuid)
328 {
329     if (uuid.empty()) {
330         HILOGW("GetNetworkIdByUuid uuid empty!");
331         return "";
332     }
333     {
334         std::lock_guard<std::mutex> autoLock(uuidNetworkIdLock_);
335         auto iter = uuidNetworkIdMap_.find(uuid);
336         if (iter != uuidNetworkIdMap_.end()) {
337             return iter->second;
338         }
339         return "";
340     }
341 }
342 
DeviceOnlineNotify(const std::shared_ptr<DmsDeviceInfo> devInfo)343 void DtbschedmgrDeviceInfoStorage::DeviceOnlineNotify(const std::shared_ptr<DmsDeviceInfo> devInfo)
344 {
345     if (devInfo == nullptr) {
346         HILOGE("DeviceOnlineNotify devInfo null");
347         return;
348     }
349 
350     if (networkIdMgrHandler_ == nullptr) {
351         HILOGE("networkIdMgrHandler null");
352         return;
353     }
354     auto nodeOnline = [this, devInfo]() {
355         std::string networkId = devInfo->GetNetworkId();
356         RegisterUuidNetworkIdMap(networkId);
357         std::string uuid = GetUuidByNetworkId(networkId);
358         HILOGI("networkId: %{public}s, uuid: %{public}s, deviceName: %{public}s", GetAnonymStr(networkId).c_str(),
359             GetAnonymStr(uuid).c_str(), devInfo->GetDeviceName().c_str());
360         {
361             lock_guard<mutex> autoLock(deviceLock_);
362             remoteDevices_[networkId] = devInfo;
363         }
364         DistributedSchedService::GetInstance().DeviceOnlineNotify(networkId);
365     };
366     if (!networkIdMgrHandler_->PostTask(nodeOnline)) {
367         HILOGE("DeviceOnlineNotify handler postTask failed");
368     }
369 }
370 
DeviceOfflineNotify(const std::string & networkId)371 void DtbschedmgrDeviceInfoStorage::DeviceOfflineNotify(const std::string& networkId)
372 {
373     if (networkId.empty()) {
374         HILOGE("DeviceOfflineNotify networkId empty");
375         return;
376     }
377     HILOGD("DeviceOfflineNotify networkId: %{public}s", GetAnonymStr(networkId).c_str());
378     if (networkIdMgrHandler_ == nullptr) {
379         HILOGE("DeviceOfflineNotify networkIdMgrHandler null");
380         return;
381     }
382     auto nodeOffline = [this, networkId]() {
383         std::string uuid = GetUuidByNetworkId(networkId);
384         HILOGI("DeviceOfflineNotify process networkId: %{public}s, uuid: %{public}s",
385             GetAnonymStr(networkId).c_str(), GetAnonymStr(uuid).c_str());
386         DistributedSchedService::GetInstance().DeviceOfflineNotify(networkId);
387         UnregisterUuidNetworkIdMap(networkId);
388         lock_guard<mutex> autoLock(deviceLock_);
389         remoteDevices_.erase(networkId);
390     };
391     if (!networkIdMgrHandler_->PostTask(nodeOffline)) {
392         HILOGE("DeviceOfflineNotify handler postTask failed");
393     }
394 }
395 
OnDeviceInfoChanged(const std::string & deviceId)396 void DtbschedmgrDeviceInfoStorage::OnDeviceInfoChanged(const std::string& deviceId)
397 {
398     HILOGI("OnDeviceInfoChanged called");
399     if (!DMSContinueRecvMgr::GetInstance().CheckRegSoftbusListener() &&
400         DistributedHardware::DeviceManager::GetInstance().IsSameAccount(deviceId)) {
401         HILOGI("DMSContinueRecvMgr need init");
402         DMSContinueRecvMgr::GetInstance().Init();
403     }
404 }
405 
OnRemoteDied(const wptr<IRemoteObject> & remote)406 void DnetServiceDeathRecipient::OnRemoteDied(const wptr<IRemoteObject>& remote)
407 {
408     HILOGI("OnRemoteDied dnetwork service died");
409     DtbschedmgrDeviceInfoStorage::GetInstance().Init();
410 }
411 
GetDeviceName(std::string netWorkId)412 std::string DtbschedmgrDeviceInfoStorage::GetDeviceName(std::string netWorkId)
413 {
414     for (auto device = remoteDevices_.begin(); device != remoteDevices_.end(); ++device) {
415         if (device->second != nullptr && device->second->GetNetworkId() == netWorkId) {
416             HILOGI("deviceName = %{public}s", device->second->GetDeviceName().c_str());
417             return device->second->GetDeviceName();
418         }
419     }
420     return "";
421 }
422 
GetNetworkIdList()423 std::vector<std::string> DtbschedmgrDeviceInfoStorage::GetNetworkIdList()
424 {
425     std::vector<std::string> devices;
426     for (auto device = remoteDevices_.begin(); device != remoteDevices_.end(); ++device) {
427         if (device->second != nullptr) {
428             HILOGI("NetworkId: %{public}s", GetAnonymStr(device->second->GetNetworkId()).c_str());
429             devices.push_back(device->second->GetNetworkId());
430         }
431     }
432     return devices;
433 }
434 }
435 }
436