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 "adapter/dnetwork_adapter.h"
17
18 #include <chrono>
19 #include <functional>
20 #include <thread>
21 #include <unistd.h>
22
23 #include "errors.h"
24 #include "dtbschedmgr_device_info_storage.h"
25 #include "dtbschedmgr_log.h"
26 #include "event_runner.h"
27
28 namespace OHOS {
29 namespace DistributedSchedule {
30 using namespace std::chrono_literals;
31 using namespace DistributedHardware;
32
33 namespace {
34 constexpr int32_t RETRY_REGISTER_CALLBACK_TIMES = 5;
35 const std::string PKG_NAME = "DBinderBus_Dms_" + std::to_string(getpid());
36
37 constexpr int32_t NON_ANONYMIZED_LENGTH = 6;
38 const std::string EMPTY_DEVICE_ID = "";
39 const std::string TAG = "DnetworkAdapter";
40 }
41
42 std::shared_ptr<AppExecFwk::EventHandler> DnetworkAdapter::dnetworkHandler_;
43 std::mutex DnetworkAdapter::listenerSetMutex_;
44 std::set<std::shared_ptr<DeviceListener>> DnetworkAdapter::listenerSet_;
45
GetInstance()46 std::shared_ptr<DnetworkAdapter> DnetworkAdapter::GetInstance()
47 {
48 static auto instance = std::make_shared<DnetworkAdapter>();
49 return instance;
50 }
51
Init()52 void DnetworkAdapter::Init()
53 {
54 initCallback_ = std::make_shared<DeviceInitCallBack>();
55 stateCallback_ = std::make_shared<DmsDeviceStateCallback>();
56 auto runner = AppExecFwk::EventRunner::Create("dmsDnetwork");
57 dnetworkHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
58 }
59
OnRemoteDied()60 void DnetworkAdapter::DeviceInitCallBack::OnRemoteDied()
61 {
62 HILOGI("DeviceInitCallBack OnRemoteDied");
63 DtbschedmgrDeviceInfoStorage::GetInstance().Init();
64 }
65
OnDeviceOnline(const DmDeviceInfo & deviceInfo)66 void DnetworkAdapter::DmsDeviceStateCallback::OnDeviceOnline(const DmDeviceInfo& deviceInfo)
67 {
68 HILOGI("OnNodeOnline netwokId = %{public}s", AnonymizeDeviceId(deviceInfo.deviceId).c_str());
69 auto onlineNotifyTask = [deviceInfo]() {
70 std::lock_guard<std::mutex> autoLock(listenerSetMutex_);
71 for (auto& listener : listenerSet_) {
72 listener->OnDeviceOnline(deviceInfo);
73 }
74 };
75 if (!dnetworkHandler_->PostTask(onlineNotifyTask)) {
76 HILOGE("OnNodeOnline post task failed");
77 return;
78 }
79 }
80
OnDeviceOffline(const DmDeviceInfo & deviceInfo)81 void DnetworkAdapter::DmsDeviceStateCallback::OnDeviceOffline(const DmDeviceInfo& deviceInfo)
82 {
83 HILOGI("OnNodeOffline networkId = %{public}s", AnonymizeDeviceId(deviceInfo.deviceId).c_str());
84 auto offlineNotifyTask = [deviceInfo]() {
85 std::lock_guard<std::mutex> autoLock(listenerSetMutex_);
86 for (auto& listener : listenerSet_) {
87 listener->OnDeviceOffline(deviceInfo);
88 }
89 };
90 if (!dnetworkHandler_->PostTask(offlineNotifyTask)) {
91 HILOGE("OnNodeOffline post task failed");
92 return;
93 }
94 }
95
OnDeviceChanged(const DmDeviceInfo & deviceInfo)96 void DnetworkAdapter::DmsDeviceStateCallback::OnDeviceChanged(const DmDeviceInfo& deviceInfo)
97 {
98 HILOGD("called");
99 }
100
OnDeviceReady(const DmDeviceInfo & deviceInfo)101 void DnetworkAdapter::DmsDeviceStateCallback::OnDeviceReady(const DmDeviceInfo& deviceInfo)
102 {
103 HILOGD("called");
104 }
105
AddDeviceChangeListener(const std::shared_ptr<DeviceListener> & listener)106 bool DnetworkAdapter::AddDeviceChangeListener(const std::shared_ptr<DeviceListener>& listener)
107 {
108 HILOGD("AddDeviceChangeListener called");
109 if (dnetworkHandler_ == nullptr) {
110 HILOGE("handler is null");
111 return false;
112 }
113
114 {
115 std::lock_guard<std::mutex> autoLock(listenerSetMutex_);
116 if (listenerSet_.find(listener) == listenerSet_.end()) {
117 listenerSet_.insert(listener);
118 }
119 if (listenerSet_.size() > 1) {
120 return true;
121 }
122 }
123
124 auto registerTask = [this]() {
125 HILOGD("AddDeviceChangeListener register mission...");
126 int32_t retryTimes = 0;
127 int32_t errCode = ERR_OK;
128 while (retryTimes++ < RETRY_REGISTER_CALLBACK_TIMES) {
129 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(PKG_NAME, initCallback_);
130 if (ret != ERR_OK) {
131 HILOGE("init device manager failed, ret:%{public}d", ret);
132 std::this_thread::sleep_for(1s);
133 continue;
134 }
135
136 errCode = DeviceManager::GetInstance().RegisterDevStateCallback(PKG_NAME, "", stateCallback_);
137 if (errCode == ERR_OK) {
138 break;
139 }
140
141 HILOGD("AddDeviceChangeListener Reg errCode = %{public}d, retrying...", errCode);
142 errCode = DeviceManager::GetInstance().UnRegisterDevStateCallback(PKG_NAME);
143 HILOGD("AddDeviceChangeListener Unreg errCode = %{public}d", errCode);
144 std::this_thread::sleep_for(1s);
145 }
146 HILOGI("AddDeviceChangeListener %{public}s", (errCode == ERR_OK) ? "success" : "timeout");
147 };
148 if (!dnetworkHandler_->PostTask(registerTask)) {
149 HILOGE("AddDeviceChangeListener post task failed");
150 return false;
151 }
152 return true;
153 }
154
RemoveDeviceChangeListener(const std::shared_ptr<DeviceListener> & listener)155 void DnetworkAdapter::RemoveDeviceChangeListener(const std::shared_ptr<DeviceListener>& listener)
156 {
157 HILOGD("RemoveDeviceChangeListener called");
158 {
159 std::lock_guard<std::mutex> autoLock(listenerSetMutex_);
160 listenerSet_.erase(listener);
161 if (listenerSet_.size() > 0) {
162 return;
163 }
164 }
165
166 int32_t errCode = DeviceManager::GetInstance().UnRegisterDevStateCallback(PKG_NAME);
167 if (errCode != ERR_OK) {
168 HILOGE("RemoveDeviceChangeListener remove failed, errCode = %{public}d", errCode);
169 }
170 HILOGD("RemoveDeviceChangeListener remove ok");
171 }
172
GetLocalBasicInfo(DmDeviceInfo & dmDeviceInfo)173 bool DnetworkAdapter::GetLocalBasicInfo(DmDeviceInfo& dmDeviceInfo)
174 {
175 int32_t errCode = DeviceManager::GetInstance().GetLocalDeviceInfo(PKG_NAME, dmDeviceInfo);
176 if (errCode != ERR_OK) {
177 HILOGE("GetLocalBasicInfo errCode = %{public}d", errCode);
178 return false;
179 }
180 return true;
181 }
182
GetUdidByNetworkId(const std::string & networkId)183 std::string DnetworkAdapter::GetUdidByNetworkId(const std::string& networkId)
184 {
185 if (networkId.empty()) {
186 HILOGE("networkId is empty");
187 return "";
188 }
189 std::string udid = "";
190 int32_t errCode = DeviceManager::GetInstance().GetUdidByNetworkId(PKG_NAME, networkId, udid);
191 if (errCode != ERR_OK) {
192 HILOGE("GetUdidByNetworkId errCode = %{public}d", errCode);
193 return "";
194 }
195 return udid;
196 }
197
GetUuidByNetworkId(const std::string & networkId)198 std::string DnetworkAdapter::GetUuidByNetworkId(const std::string& networkId)
199 {
200 if (networkId.empty()) {
201 HILOGE("networkId is empty");
202 return "";
203 }
204 std::string uuid = "";
205 int32_t errCode = DeviceManager::GetInstance().GetUuidByNetworkId(PKG_NAME, networkId, uuid);
206 if (errCode != ERR_OK) {
207 HILOGE("GetUuidByNetworkId errCode = %{public}d", errCode);
208 return "";
209 }
210 return uuid;
211 }
212
AnonymizeDeviceId(const std::string & deviceId)213 std::string DnetworkAdapter::AnonymizeDeviceId(const std::string& deviceId)
214 {
215 if (deviceId.length() < NON_ANONYMIZED_LENGTH) {
216 return EMPTY_DEVICE_ID;
217 }
218 std::string anonDeviceId = deviceId.substr(0, NON_ANONYMIZED_LENGTH);
219 anonDeviceId.append("******");
220 return anonDeviceId;
221 }
222 } // namespace DistributedSchedule
223 } // namespace OHOS
224