1 /*
2 * Copyright (c) 2022-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 "device_manager_impl.h"
17 #include <unistd.h>
18 #include <random>
19 #include "device_manager_ipc_interface_code.h"
20 #include "device_manager_notify.h"
21 #include "dm_anonymous.h"
22 #include "dm_constants.h"
23 #include "dm_device_info.h"
24 #include "dm_dfx_constants.h"
25 #include "dm_hisysevent.h"
26 #include "dm_hitrace.h"
27 #include "dm_log.h"
28 #include "ipc_acl_profile_req.h"
29 #include "ipc_authenticate_device_req.h"
30 #include "ipc_bind_device_req.h"
31 #include "ipc_bind_target_req.h"
32 #include "ipc_check_access_control.h"
33 #include "ipc_common_param_req.h"
34 #include "ipc_create_pin_holder_req.h"
35 #include "ipc_destroy_pin_holder_req.h"
36 #include "ipc_export_auth_code_rsp.h"
37 #include "ipc_generate_encrypted_uuid_req.h"
38 #include "ipc_get_device_info_rsp.h"
39 #include "ipc_get_device_screen_status_req.h"
40 #include "ipc_get_device_screen_status_rsp.h"
41 #include "ipc_get_encrypted_uuid_req.h"
42 #include "ipc_get_info_by_network_req.h"
43 #include "ipc_get_info_by_network_rsp.h"
44 #include "ipc_get_local_device_info_rsp.h"
45 #include "ipc_get_trustdevice_req.h"
46 #include "ipc_get_trustdevice_rsp.h"
47 #include "ipc_import_auth_code_req.h"
48 #include "ipc_notify_event_req.h"
49 #include "ipc_permission_req.h"
50 #include "ipc_publish_req.h"
51 #include "ipc_req.h"
52 #include "ipc_rsp.h"
53 #include "ipc_set_credential_req.h"
54 #include "ipc_set_credential_rsp.h"
55 #include "ipc_set_useroperation_req.h"
56 #include "ipc_start_discovery_req.h"
57 #include "ipc_start_discover_req.h"
58 #include "ipc_stop_discovery_req.h"
59 #include "ipc_unauthenticate_device_req.h"
60 #include "ipc_unbind_device_req.h"
61 #include "ipc_unpublish_req.h"
62 #include "securec.h"
63 #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
64 #include "iservice_registry.h"
65 #include "system_ability_definition.h"
66 #endif
67 namespace OHOS {
68 namespace DistributedHardware {
69
70 constexpr const char* DM_INIT_DEVICE_MANAGER_SUCCESS = "DM_INIT_DEVICE_MANAGER_SUCCESS";
71 constexpr const char* DM_INIT_DEVICE_MANAGER_FAILED = "DM_INIT_DEVICE_MANAGER_FAILED";
72 constexpr const char* START_DEVICE_DISCOVERY_SUCCESS = "START_DEVICE_DISCOVERY_SUCCESS";
73 constexpr const char* START_DEVICE_DISCOVERY_FAILED = "START_DEVICE_DISCOVERY_FAILED";
74 constexpr const char* GET_LOCAL_DEVICE_INFO_SUCCESS = "GET_LOCAL_DEVICE_INFO_SUCCESS";
75 constexpr const char* GET_LOCAL_DEVICE_INFO_FAILED = "GET_LOCAL_DEVICE_INFO_FAILED";
76 constexpr const char* DM_SEND_REQUEST_SUCCESS = "DM_SEND_REQUEST_SUCCESS";
77 constexpr const char* DM_SEND_REQUEST_FAILED = "DM_SEND_REQUEST_FAILED";
78 constexpr const char* UNAUTHENTICATE_DEVICE_SUCCESS = "UNAUTHENTICATE_DEVICE_SUCCESS";
79 constexpr const char* UNAUTHENTICATE_DEVICE_FAILED = "UNAUTHENTICATE_DEVICE_FAILED";
80 constexpr const char* DM_INIT_DEVICE_MANAGER_SUCCESS_MSG = "init devicemanager success.";
81 constexpr const char* DM_INIT_DEVICE_MANAGER_FAILED_MSG = "init devicemanager failed.";
82 constexpr const char* START_DEVICE_DISCOVERY_SUCCESS_MSG = "device manager discovery success.";
83 constexpr const char* START_DEVICE_DISCOVERY_FAILED_MSG = "device manager discovery failed.";
84 constexpr const char* GET_LOCAL_DEVICE_INFO_SUCCESS_MSG = "get local device info success.";
85 constexpr const char* GET_LOCAL_DEVICE_INFO_FAILED_MSG = "get local device info failed.";
86 constexpr const char* DM_SEND_REQUEST_SUCCESS_MSG = "send request success.";
87 constexpr const char* DM_SEND_REQUEST_FAILED_MSG = "send request failed.";
88 constexpr const char* UNAUTHENTICATE_DEVICE_SUCCESS_MSG = "unauthenticate device success.";
89 constexpr const char* UNAUTHENTICATE_DEVICE_FAILED_MSG = "unauthenticate device failed.";
90 constexpr const char* DM_HITRACE_START_DEVICE = "DM_HITRACE_START_DEVICE";
91 constexpr const char* DM_HITRACE_GET_LOCAL_DEVICE_INFO = "DM_HITRACE_GET_LOCAL_DEVICE_INFO";
92 constexpr const char* DM_HITRACE_AUTH_TO_CONSULT = "DM_HITRACE_AUTH_TO_CONSULT";
93 constexpr const char* DM_HITRACE_INIT = "DM_HITRACE_INIT";
94
95 const uint16_t DM_MIN_RANDOM = 1;
96 const uint16_t DM_MAX_RANDOM = 65535;
97 const uint16_t DM_INVALID_FLAG_ID = 0;
98 const uint16_t DM_IMPORT_AUTH_CODE_LENGTH = 6;
99 const int32_t NORMAL = 0;
100 const int32_t SYSTEM_BASIC = 1;
101 const int32_t SYSTEM_CORE = 2;
102 const int32_t USLEEP_TIME_MS = 100000; // 100ms
GenRandUint(uint16_t randMin,uint16_t randMax)103 uint16_t GenRandUint(uint16_t randMin, uint16_t randMax)
104 {
105 std::random_device randDevice;
106 std::mt19937 genRand(randDevice());
107 std::uniform_int_distribution<int> disRand(randMin, randMax);
108 return disRand(genRand);
109 }
110
GetInstance()111 DeviceManagerImpl &DeviceManagerImpl::GetInstance()
112 {
113 static DeviceManagerImpl instance;
114 return instance;
115 }
116
InitDeviceManager(const std::string & pkgName,std::shared_ptr<DmInitCallback> dmInitCallback)117 int32_t DeviceManagerImpl::InitDeviceManager(const std::string &pkgName, std::shared_ptr<DmInitCallback> dmInitCallback)
118 {
119 if (pkgName.empty() || dmInitCallback == nullptr) {
120 LOGE("DeviceManagerImpl::InitDeviceManager error: Invalid parameter, pkgName: %{public}s", pkgName.c_str());
121 return ERR_DM_INPUT_PARA_INVALID;
122 }
123 DmTraceStart(std::string(DM_HITRACE_INIT));
124 LOGI("Start, pkgName: %{public}s", GetAnonyString(pkgName).c_str());
125
126 int32_t ret = DM_OK;
127 int32_t retryNum = 0;
128 while (retryNum < SERVICE_INIT_TRY_MAX_NUM) {
129 ret = ipcClientProxy_->Init(pkgName);
130 if (ret == DM_OK) {
131 break;
132 }
133 usleep(USLEEP_TIME_MS);
134 retryNum++;
135 if (retryNum == SERVICE_INIT_TRY_MAX_NUM) {
136 LOGE("InitDeviceManager error, wait for device manager service starting timeout.");
137 return ERR_DM_NOT_INIT;
138 }
139 }
140 if (ret != DM_OK) {
141 LOGE("InitDeviceManager error, proxy init failed ret: %{public}d", ret);
142 SysEventWrite(std::string(DM_INIT_DEVICE_MANAGER_FAILED), DM_HISYEVENT_FAULT,
143 std::string(DM_INIT_DEVICE_MANAGER_FAILED_MSG));
144 return ERR_DM_INIT_FAILED;
145 }
146
147 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback);
148 DmTraceEnd();
149 LOGI("Success");
150 SysEventWrite(std::string(DM_INIT_DEVICE_MANAGER_SUCCESS), DM_HISYEVENT_BEHAVIOR,
151 std::string(DM_INIT_DEVICE_MANAGER_SUCCESS_MSG));
152 return DM_OK;
153 }
154
UnInitDeviceManager(const std::string & pkgName)155 int32_t DeviceManagerImpl::UnInitDeviceManager(const std::string &pkgName)
156 {
157 if (pkgName.empty()) {
158 LOGE("UnInitDeviceManager Invalid parameter, pkgName is empty.");
159 return ERR_DM_INPUT_PARA_INVALID;
160 }
161 LOGI("Start, pkgName: %{public}s", GetAnonyString(pkgName).c_str());
162
163 int32_t ret = ipcClientProxy_->UnInit(pkgName);
164 if (ret != DM_OK) {
165 LOGE("UnInitDeviceManager error, proxy unInit failed ret: %{public}d", ret);
166 return ERR_DM_FAILED;
167 }
168
169 DeviceManagerNotify::GetInstance().UnRegisterPackageCallback(pkgName);
170 LOGI("Success");
171 return DM_OK;
172 }
173
ConvertDeviceInfoToDeviceBasicInfo(const DmDeviceInfo & info,DmDeviceBasicInfo & deviceBasicInfo)174 void DeviceManagerImpl::ConvertDeviceInfoToDeviceBasicInfo(const DmDeviceInfo &info,
175 DmDeviceBasicInfo &deviceBasicInfo)
176 {
177 (void)memset_s(&deviceBasicInfo, sizeof(DmDeviceBasicInfo), 0, sizeof(DmDeviceBasicInfo));
178 if (memcpy_s(deviceBasicInfo.deviceName, sizeof(deviceBasicInfo.deviceName), info.deviceName,
179 std::min(sizeof(deviceBasicInfo.deviceName), sizeof(info.deviceName))) != DM_OK) {
180 LOGE("ConvertDeviceInfoToDmDevice copy deviceName data failed.");
181 }
182 if (memcpy_s(deviceBasicInfo.networkId, sizeof(deviceBasicInfo.networkId), info.networkId,
183 std::min(sizeof(deviceBasicInfo.networkId), sizeof(info.networkId))) != DM_OK) {
184 LOGE("ConvertNodeBasicInfoToDmDevice copy networkId data failed.");
185 }
186 if (memcpy_s(deviceBasicInfo.deviceId, sizeof(deviceBasicInfo.deviceId), info.deviceId,
187 std::min(sizeof(deviceBasicInfo.deviceId), sizeof(info.deviceId))) != DM_OK) {
188 LOGE("ConvertNodeBasicInfoToDmDevice copy deviceId data failed.");
189 }
190 deviceBasicInfo.deviceTypeId = info.deviceTypeId;
191 }
192
GetTrustedDeviceList(const std::string & pkgName,const std::string & extra,std::vector<DmDeviceInfo> & deviceList)193 int32_t DeviceManagerImpl::GetTrustedDeviceList(const std::string &pkgName, const std::string &extra,
194 std::vector<DmDeviceInfo> &deviceList)
195 {
196 if (pkgName.empty()) {
197 LOGE("Invalid parameter, pkgName is empty.");
198 return ERR_DM_INPUT_PARA_INVALID;
199 }
200 LOGI("Start, pkgName: %{public}s, extra: %{public}s", GetAnonyString(pkgName).c_str(), extra.c_str());
201
202 std::shared_ptr<IpcGetTrustDeviceReq> req = std::make_shared<IpcGetTrustDeviceReq>();
203 std::shared_ptr<IpcGetTrustDeviceRsp> rsp = std::make_shared<IpcGetTrustDeviceRsp>();
204 req->SetPkgName(pkgName);
205 req->SetExtra(extra);
206 int32_t ret = ipcClientProxy_->SendRequest(GET_TRUST_DEVICE_LIST, req, rsp);
207 if (ret != DM_OK) {
208 LOGE("DeviceManagerImpl::GetTrustedDeviceList error, Send Request failed ret: %{public}d", ret);
209 return ERR_DM_IPC_SEND_REQUEST_FAILED;
210 }
211
212 ret = rsp->GetErrCode();
213 if (ret != DM_OK) {
214 LOGI("GetTrustedDeviceList error, failed ret: %{public}d", ret);
215 return ret;
216 }
217
218 deviceList = rsp->GetDeviceVec();
219 LOGI("Completed, device size %{public}zu", deviceList.size());
220 return DM_OK;
221 }
222
GetTrustedDeviceList(const std::string & pkgName,const std::string & extra,bool isRefresh,std::vector<DmDeviceInfo> & deviceList)223 int32_t DeviceManagerImpl::GetTrustedDeviceList(const std::string &pkgName, const std::string &extra,
224 bool isRefresh, std::vector<DmDeviceInfo> &deviceList)
225 {
226 if (pkgName.empty()) {
227 LOGE("Invalid parameter, pkgName is empty.");
228 return ERR_DM_INPUT_PARA_INVALID;
229 }
230 LOGI("Start, pkgName: %{public}s, extra: %{public}s, isRefresh: %{public}d", GetAnonyString(pkgName).c_str(),
231 extra.c_str(), isRefresh);
232
233 std::shared_ptr<IpcGetTrustDeviceReq> req = std::make_shared<IpcGetTrustDeviceReq>();
234 std::shared_ptr<IpcGetTrustDeviceRsp> rsp = std::make_shared<IpcGetTrustDeviceRsp>();
235 req->SetPkgName(pkgName);
236 req->SetExtra(extra);
237 req->SetRefresh(isRefresh);
238 int32_t ret = ipcClientProxy_->SendRequest(GET_TRUST_DEVICE_LIST, req, rsp);
239 if (ret != DM_OK) {
240 LOGE("DeviceManagerImpl::GetTrustedDeviceList error, Send Request failed ret: %{public}d", ret);
241 return ERR_DM_IPC_SEND_REQUEST_FAILED;
242 }
243
244 ret = rsp->GetErrCode();
245 if (ret != DM_OK) {
246 LOGE("GetTrustedDeviceList error, failed ret: %{public}d", ret);
247 return ret;
248 }
249 deviceList = rsp->GetDeviceVec();
250 LOGI("Completed, device size %{public}zu", deviceList.size());
251 return DM_OK;
252 }
253
GetAvailableDeviceList(const std::string & pkgName,std::vector<DmDeviceBasicInfo> & deviceList)254 int32_t DeviceManagerImpl::GetAvailableDeviceList(const std::string &pkgName,
255 std::vector<DmDeviceBasicInfo> &deviceList)
256 {
257 LOGI("Start, pkgName: %{public}s.", GetAnonyString(pkgName).c_str());
258 std::vector<DmDeviceInfo> deviceListTemp;
259 std::string extra = "";
260 int32_t ret = GetTrustedDeviceList(pkgName, extra, false, deviceListTemp);
261 if (ret != DM_OK) {
262 LOGE("DeviceManagerImpl::GetTrustedDeviceList error.");
263 return ret;
264 }
265 for (auto &item : deviceListTemp) {
266 DmDeviceBasicInfo deviceBasicInfo;
267 ConvertDeviceInfoToDeviceBasicInfo(item, deviceBasicInfo);
268 deviceList.push_back(deviceBasicInfo);
269 }
270 LOGI("Completed, device size %{public}zu", deviceList.size());
271 return DM_OK;
272 }
273
GetDeviceInfo(const std::string & pkgName,const std::string networkId,DmDeviceInfo & deviceInfo)274 int32_t DeviceManagerImpl::GetDeviceInfo(const std::string &pkgName, const std::string networkId,
275 DmDeviceInfo &deviceInfo)
276 {
277 if (pkgName.empty() || networkId.empty()) {
278 LOGE("Invalid parameter, pkgName: %{public}s, netWorkId: %{public}s", pkgName.c_str(),
279 GetAnonyString(networkId).c_str());
280 return ERR_DM_INPUT_PARA_INVALID;
281 }
282 LOGI("Start, pkgName: %{public}s networKId : %{public}s", pkgName.c_str(),
283 GetAnonyString(networkId).c_str());
284 std::shared_ptr<IpcGetInfoByNetWorkReq> req = std::make_shared<IpcGetInfoByNetWorkReq>();
285 std::shared_ptr<IpcGetDeviceInfoRsp> rsp = std::make_shared<IpcGetDeviceInfoRsp>();
286 req->SetPkgName(pkgName);
287 req->SetNetWorkId(networkId);
288 int32_t ret = ipcClientProxy_->SendRequest(GET_DEVICE_INFO, req, rsp);
289 if (ret != DM_OK) {
290 LOGE("DeviceManagerImpl::GetDeviceInfo error, Send Request failed ret: %{public}d", ret);
291 return ERR_DM_IPC_SEND_REQUEST_FAILED;
292 }
293
294 ret = rsp->GetErrCode();
295 if (ret != DM_OK) {
296 LOGE("DeviceManagerImpl::GetDeviceInfo error, failed ret: %{public}d", ret);
297 return ret;
298 }
299
300 deviceInfo = rsp->GetDeviceInfo();
301 LOGI("Completed, networKId = %{public}s deviceName = %{public}s", GetAnonyString(req->GetNetWorkId()).c_str(),
302 GetAnonyString(deviceInfo.deviceName).c_str());
303 return DM_OK;
304 }
305
GetLocalDeviceInfo(const std::string & pkgName,DmDeviceInfo & info)306 int32_t DeviceManagerImpl::GetLocalDeviceInfo(const std::string &pkgName, DmDeviceInfo &info)
307 {
308 LOGD("Start, pkgName: %{public}s", GetAnonyString(pkgName).c_str());
309 DmTraceStart(std::string(DM_HITRACE_GET_LOCAL_DEVICE_INFO));
310 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
311 std::shared_ptr<IpcGetLocalDeviceInfoRsp> rsp = std::make_shared<IpcGetLocalDeviceInfoRsp>();
312 req->SetPkgName(pkgName);
313 int32_t ret = ipcClientProxy_->SendRequest(GET_LOCAL_DEVICE_INFO, req, rsp);
314 if (ret != DM_OK) {
315 LOGE("DeviceManagerImpl::GetLocalDeviceInfo error, Send Request failed ret: %{public}d", ret);
316 return ERR_DM_IPC_SEND_REQUEST_FAILED;
317 }
318
319 ret = rsp->GetErrCode();
320 if (ret != DM_OK) {
321 LOGI("DeviceManagerImpl::GetLocalDeviceInfo error, failed ret: %{public}d", ret);
322 SysEventWrite(std::string(GET_LOCAL_DEVICE_INFO_FAILED), DM_HISYEVENT_BEHAVIOR,
323 std::string(GET_LOCAL_DEVICE_INFO_FAILED_MSG));
324 return ret;
325 }
326
327 info = rsp->GetLocalDeviceInfo();
328 DmTraceEnd();
329 LOGI("Completed");
330 SysEventWrite(std::string(GET_LOCAL_DEVICE_INFO_SUCCESS), DM_HISYEVENT_BEHAVIOR,
331 std::string(GET_LOCAL_DEVICE_INFO_SUCCESS_MSG));
332 return DM_OK;
333 }
334
RegisterDevStateCallback(const std::string & pkgName,const std::string & extra,std::shared_ptr<DeviceStateCallback> callback)335 int32_t DeviceManagerImpl::RegisterDevStateCallback(const std::string &pkgName, const std::string &extra,
336 std::shared_ptr<DeviceStateCallback> callback)
337 {
338 if (pkgName.empty() || callback == nullptr) {
339 LOGE("RegisterDevStateCallback error: Invalid para");
340 return ERR_DM_INPUT_PARA_INVALID;
341 }
342 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
343 #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
344 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
345 if (samgr == nullptr) {
346 LOGE("Get SystemAbilityManager Failed");
347 return ERR_DM_INIT_FAILED;
348 }
349 while (samgr->CheckSystemAbility(ACCESS_TOKEN_MANAGER_SERVICE_ID) == nullptr) {
350 LOGD("Access_token SA not start.");
351 usleep(USLEEP_TIME_MS);
352 }
353 int32_t ret = CheckApiPermission(SYSTEM_CORE);
354 if (ret != DM_OK) {
355 LOGE("System SA not have permission, ret: %{public}d.", ret);
356 return ret;
357 }
358 #endif
359 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback);
360 LOGI("Completed");
361 return DM_OK;
362 }
363
RegisterDevStatusCallback(const std::string & pkgName,const std::string & extra,std::shared_ptr<DeviceStatusCallback> callback)364 int32_t DeviceManagerImpl::RegisterDevStatusCallback(const std::string &pkgName, const std::string &extra,
365 std::shared_ptr<DeviceStatusCallback> callback)
366 {
367 if (pkgName.empty() || callback == nullptr) {
368 LOGE("RegisterDevStatusCallback error: Invalid para");
369 return ERR_DM_INPUT_PARA_INVALID;
370 }
371 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
372 DeviceManagerNotify::GetInstance().RegisterDeviceStatusCallback(pkgName, callback);
373 LOGI("Completed");
374 return DM_OK;
375 }
376
UnRegisterDevStateCallback(const std::string & pkgName)377 int32_t DeviceManagerImpl::UnRegisterDevStateCallback(const std::string &pkgName)
378 {
379 if (pkgName.empty()) {
380 LOGE("UnRegisterDevStateCallback Invalid parameter, pkgName is empty.");
381 return ERR_DM_INPUT_PARA_INVALID;
382 }
383 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
384 DeviceManagerNotify::GetInstance().UnRegisterDeviceStateCallback(pkgName);
385 LOGI("Completed");
386 return DM_OK;
387 }
388
UnRegisterDevStatusCallback(const std::string & pkgName)389 int32_t DeviceManagerImpl::UnRegisterDevStatusCallback(const std::string &pkgName)
390 {
391 if (pkgName.empty()) {
392 LOGE("UnRegisterDevStatusCallback Invalid parameter, pkgName is empty.");
393 return ERR_DM_INPUT_PARA_INVALID;
394 }
395 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
396 DeviceManagerNotify::GetInstance().UnRegisterDeviceStatusCallback(pkgName);
397 LOGI("Completed");
398 return DM_OK;
399 }
400
401
StartDeviceDiscovery(const std::string & pkgName,const DmSubscribeInfo & subscribeInfo,const std::string & extra,std::shared_ptr<DiscoveryCallback> callback)402 int32_t DeviceManagerImpl::StartDeviceDiscovery(const std::string &pkgName, const DmSubscribeInfo &subscribeInfo,
403 const std::string &extra, std::shared_ptr<DiscoveryCallback> callback)
404 {
405 if (pkgName.empty() || callback == nullptr) {
406 LOGE("DeviceManagerImpl::StartDeviceDiscovery error: Invalid para, pkgName: %{public}s", pkgName.c_str());
407 return ERR_DM_INPUT_PARA_INVALID;
408 }
409
410 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
411 DmTraceStart(std::string(DM_HITRACE_START_DEVICE));
412 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeInfo.subscribeId, callback);
413
414 std::shared_ptr<IpcStartDiscoveryReq> req = std::make_shared<IpcStartDiscoveryReq>();
415 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
416 req->SetPkgName(pkgName);
417 req->SetExtra(extra);
418 req->SetSubscribeInfo(subscribeInfo);
419 int32_t ret = ipcClientProxy_->SendRequest(START_DEVICE_DISCOVER, req, rsp);
420 if (ret != DM_OK) {
421 LOGE("StartDeviceDiscovery error: Send Request failed ret: %{public}d", ret);
422 return ERR_DM_IPC_SEND_REQUEST_FAILED;
423 }
424
425 ret = rsp->GetErrCode();
426 if (ret != DM_OK) {
427 LOGE("StartDeviceDiscovery error: Failed with ret %{public}d", ret);
428 SysEventWrite(std::string(START_DEVICE_DISCOVERY_FAILED), DM_HISYEVENT_BEHAVIOR,
429 std::string(START_DEVICE_DISCOVERY_FAILED_MSG));
430 return ret;
431 }
432
433 DmTraceEnd();
434 LOGI("Completed");
435 SysEventWrite(std::string(START_DEVICE_DISCOVERY_SUCCESS), DM_HISYEVENT_BEHAVIOR,
436 std::string(START_DEVICE_DISCOVERY_SUCCESS_MSG));
437 return DM_OK;
438 }
439
StartDeviceDiscovery(const std::string & pkgName,uint64_t tokenId,const std::string & filterOptions,std::shared_ptr<DiscoveryCallback> callback)440 int32_t DeviceManagerImpl::StartDeviceDiscovery(const std::string &pkgName, uint64_t tokenId,
441 const std::string &filterOptions, std::shared_ptr<DiscoveryCallback> callback)
442 {
443 if (pkgName.empty() || callback == nullptr) {
444 LOGE("DeviceManagerImpl::StartDeviceDiscovery error: Invalid para, pkgName: %{public}s", pkgName.c_str());
445 return ERR_DM_INPUT_PARA_INVALID;
446 }
447
448 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
449 uint16_t subscribeId = 0;
450 {
451 std::lock_guard<std::mutex> autoLock(subscribIdLock);
452 if (subscribIdMap_.find(tokenId) != subscribIdMap_.end()) {
453 return ERR_DM_DISCOVERY_REPEATED;
454 }
455 subscribeId = GenRandUint(0, DM_MAX_RANDOM);
456 subscribIdMap_[tokenId] = subscribeId;
457 }
458 DmTraceStart(std::string(DM_HITRACE_START_DEVICE));
459 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback);
460 std::shared_ptr<IpcStartDevDiscoveryByIdReq> req = std::make_shared<IpcStartDevDiscoveryByIdReq>();
461 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
462 req->SetPkgName(pkgName);
463 req->SetFilterOption(filterOptions);
464 req->SetSubscribeId(subscribeId);
465 int32_t ret = ipcClientProxy_->SendRequest(START_DEVICE_DISCOVERY, req, rsp);
466 if (ret != DM_OK) {
467 LOGE("StartDeviceDiscovery error: Send Request failed ret: %{public}d", ret);
468 return ERR_DM_IPC_SEND_REQUEST_FAILED;
469 }
470
471 ret = rsp->GetErrCode();
472 if (ret != DM_OK) {
473 LOGE("StartDeviceDiscovery error: Failed with ret %{public}d", ret);
474 SysEventWrite(std::string(START_DEVICE_DISCOVERY_FAILED), DM_HISYEVENT_BEHAVIOR,
475 std::string(START_DEVICE_DISCOVERY_FAILED_MSG));
476 return ret;
477 }
478
479 DmTraceEnd();
480 LOGI("Completed");
481 SysEventWrite(std::string(START_DEVICE_DISCOVERY_SUCCESS), DM_HISYEVENT_BEHAVIOR,
482 std::string(START_DEVICE_DISCOVERY_SUCCESS_MSG));
483 return DM_OK;
484 }
485
StopDeviceDiscovery(const std::string & pkgName,uint16_t subscribeId)486 int32_t DeviceManagerImpl::StopDeviceDiscovery(const std::string &pkgName, uint16_t subscribeId)
487 {
488 if (pkgName.empty()) {
489 LOGE("DeviceManagerImpl::StopDeviceDiscovery Invalid parameter, pkgName is empty.");
490 return ERR_DM_INPUT_PARA_INVALID;
491 }
492 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
493 std::shared_ptr<IpcStopDiscoveryReq> req = std::make_shared<IpcStopDiscoveryReq>();
494 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
495 req->SetPkgName(pkgName);
496 req->SetSubscribeId(subscribeId);
497 int32_t ret = ipcClientProxy_->SendRequest(STOP_DEVICE_DISCOVER, req, rsp);
498 if (ret != DM_OK) {
499 LOGE("StopDeviceDiscovery error: Send Request failed ret: %{public}d", ret);
500 return ERR_DM_IPC_SEND_REQUEST_FAILED;
501 }
502
503 ret = rsp->GetErrCode();
504 if (ret != DM_OK) {
505 LOGE("StopDeviceDiscovery error: Failed with ret %{public}d", ret);
506 return ret;
507 }
508
509 DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(pkgName, subscribeId);
510 LOGI("Completed");
511 return DM_OK;
512 }
513
StopDeviceDiscovery(uint64_t tokenId,const std::string & pkgName)514 int32_t DeviceManagerImpl::StopDeviceDiscovery(uint64_t tokenId, const std::string &pkgName)
515 {
516 if (pkgName.empty()) {
517 LOGE("DeviceManagerImpl::StopDeviceDiscovery Invalid parameter, pkgName is empty.");
518 return ERR_DM_INPUT_PARA_INVALID;
519 }
520 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
521 uint16_t subscribeId = 0;
522 {
523 std::lock_guard<std::mutex> autoLock(subscribIdLock);
524 if (subscribIdMap_.find(tokenId) == subscribIdMap_.end()) {
525 return ERR_DM_STOP_DISCOVERY;
526 }
527 subscribeId = subscribIdMap_[tokenId];
528 subscribIdMap_.erase(tokenId);
529 }
530 std::shared_ptr<IpcStopDiscoveryReq> req = std::make_shared<IpcStopDiscoveryReq>();
531 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
532 req->SetPkgName(pkgName);
533 req->SetSubscribeId(subscribeId);
534 int32_t ret = ipcClientProxy_->SendRequest(STOP_DEVICE_DISCOVER, req, rsp);
535 if (ret != DM_OK) {
536 LOGE("StopDeviceDiscovery error: Send Request failed ret: %{public}d", ret);
537 return ERR_DM_IPC_SEND_REQUEST_FAILED;
538 }
539
540 ret = rsp->GetErrCode();
541 if (ret != DM_OK) {
542 LOGE("StopDeviceDiscovery error: Failed with ret %{public}d", ret);
543 return ret;
544 }
545
546 DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(pkgName, subscribeId);
547 LOGI("Completed");
548 return DM_OK;
549 }
550
PublishDeviceDiscovery(const std::string & pkgName,const DmPublishInfo & publishInfo,std::shared_ptr<PublishCallback> callback)551 int32_t DeviceManagerImpl::PublishDeviceDiscovery(const std::string &pkgName, const DmPublishInfo &publishInfo,
552 std::shared_ptr<PublishCallback> callback)
553 {
554 if (pkgName.empty() || callback == nullptr) {
555 LOGE("PublishDeviceDiscovery error: pkgName %{public}s invalid para", pkgName.c_str());
556 return ERR_DM_INPUT_PARA_INVALID;
557 }
558
559 LOGI("Start, pkgName %{public}s", pkgName.c_str());
560 DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishInfo.publishId, callback);
561
562 std::shared_ptr<IpcPublishReq> req = std::make_shared<IpcPublishReq>();
563 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
564 req->SetPkgName(pkgName);
565 req->SetPublishInfo(publishInfo);
566 int32_t ret = ipcClientProxy_->SendRequest(PUBLISH_DEVICE_DISCOVER, req, rsp);
567 if (ret != DM_OK) {
568 LOGE("PublishDeviceDiscovery error: Send Request failed ret: %{public}d", ret);
569 DeviceManagerNotify::GetInstance().UnRegisterPublishCallback(pkgName, publishInfo.publishId);
570 return ERR_DM_IPC_SEND_REQUEST_FAILED;
571 }
572
573 ret = rsp->GetErrCode();
574 if (ret != DM_OK) {
575 LOGE("PublishDeviceDiscovery error: Failed with ret %{public}d", ret);
576 return ret;
577 }
578
579 LOGI("Completed");
580 return DM_OK;
581 }
582
UnPublishDeviceDiscovery(const std::string & pkgName,int32_t publishId)583 int32_t DeviceManagerImpl::UnPublishDeviceDiscovery(const std::string &pkgName, int32_t publishId)
584 {
585 if (pkgName.empty()) {
586 LOGE("Invalid parameter, pkgName is empty.");
587 return ERR_DM_INPUT_PARA_INVALID;
588 }
589
590 LOGI("Start, pkgName %{public}s", pkgName.c_str());
591 std::shared_ptr<IpcUnPublishReq> req = std::make_shared<IpcUnPublishReq>();
592 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
593 req->SetPkgName(pkgName);
594 req->SetPublishId(publishId);
595 int32_t ret = ipcClientProxy_->SendRequest(UNPUBLISH_DEVICE_DISCOVER, req, rsp);
596 if (ret != DM_OK) {
597 LOGE("UnPublishDeviceDiscovery error: Send Request failed ret: %{public}d", ret);
598 return ERR_DM_IPC_SEND_REQUEST_FAILED;
599 }
600
601 ret = rsp->GetErrCode();
602 if (ret != DM_OK) {
603 LOGE("UnPublishDeviceDiscovery error: Failed with ret %{public}d", ret);
604 return ret;
605 }
606
607 DeviceManagerNotify::GetInstance().UnRegisterPublishCallback(pkgName, publishId);
608 LOGI("Completed");
609 return DM_OK;
610 }
611
AuthenticateDevice(const std::string & pkgName,int32_t authType,const DmDeviceInfo & deviceInfo,const std::string & extra,std::shared_ptr<AuthenticateCallback> callback)612 int32_t DeviceManagerImpl::AuthenticateDevice(const std::string &pkgName, int32_t authType,
613 const DmDeviceInfo &deviceInfo, const std::string &extra,
614 std::shared_ptr<AuthenticateCallback> callback)
615 {
616 if (pkgName.empty() || callback == nullptr) {
617 LOGE("Invalid parameter, pkgName is empty or callback is nullptr.");
618 return ERR_DM_INPUT_PARA_INVALID;
619 }
620 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
621 DmTraceStart(std::string(DM_HITRACE_AUTH_TO_CONSULT));
622
623 std::string strDeviceId = deviceInfo.deviceId;
624 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, strDeviceId, callback);
625 std::shared_ptr<IpcAuthenticateDeviceReq> req = std::make_shared<IpcAuthenticateDeviceReq>();
626 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
627 req->SetPkgName(pkgName);
628 req->SetExtra(extra);
629 req->SetAuthType(authType);
630 req->SetDeviceInfo(deviceInfo);
631 int32_t ret = ipcClientProxy_->SendRequest(AUTHENTICATE_DEVICE, req, rsp);
632 if (ret != DM_OK) {
633 LOGE("AuthenticateDevice error: Send Request failed ret: %{public}d", ret);
634 SysEventWrite(std::string(DM_SEND_REQUEST_FAILED), DM_HISYEVENT_BEHAVIOR,
635 std::string(DM_SEND_REQUEST_FAILED_MSG));
636 return ERR_DM_IPC_SEND_REQUEST_FAILED;
637 }
638 SysEventWrite(std::string(DM_SEND_REQUEST_SUCCESS), DM_HISYEVENT_BEHAVIOR,
639 std::string(DM_SEND_REQUEST_SUCCESS_MSG));
640
641 ret = rsp->GetErrCode();
642 if (ret != DM_OK) {
643 LOGE("AuthenticateDevice error: Failed with ret %{public}d", ret);
644 return ret;
645 }
646 DmTraceEnd();
647 LOGI("Completed");
648 return DM_OK;
649 }
650
UnAuthenticateDevice(const std::string & pkgName,const DmDeviceInfo & deviceInfo)651 int32_t DeviceManagerImpl::UnAuthenticateDevice(const std::string &pkgName, const DmDeviceInfo &deviceInfo)
652 {
653 if (pkgName.empty() || (deviceInfo.networkId[0] == '\0')) {
654 LOGE("UnAuthenticateDevice error: Invalid para. pkgName %{public}s", pkgName.c_str());
655 return ERR_DM_INPUT_PARA_INVALID;
656 }
657 LOGI("Start, pkgName: %{public}s, networkId: %{public}s", pkgName.c_str(),
658 GetAnonyString(std::string(deviceInfo.networkId)).c_str());
659 std::shared_ptr<IpcUnAuthenticateDeviceReq> req = std::make_shared<IpcUnAuthenticateDeviceReq>();
660 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
661 req->SetPkgName(pkgName);
662 req->SetDeviceInfo(deviceInfo);
663 int32_t ret = ipcClientProxy_->SendRequest(UNAUTHENTICATE_DEVICE, req, rsp);
664 if (ret != DM_OK) {
665 LOGE("UnAuthenticateDevice error: Send Request failed ret: %{public}d", ret);
666 return ERR_DM_IPC_SEND_REQUEST_FAILED;
667 }
668 ret = rsp->GetErrCode();
669 if (ret != DM_OK) {
670 LOGE("UnAuthenticateDevice error: Failed with ret %{public}d", ret);
671 SysEventWrite(std::string(UNAUTHENTICATE_DEVICE_FAILED), DM_HISYEVENT_BEHAVIOR,
672 std::string(UNAUTHENTICATE_DEVICE_FAILED_MSG));
673 return ret;
674 }
675 SysEventWrite(std::string(UNAUTHENTICATE_DEVICE_SUCCESS), DM_HISYEVENT_BEHAVIOR,
676 std::string(UNAUTHENTICATE_DEVICE_SUCCESS_MSG));
677
678 LOGI("Completed");
679 return DM_OK;
680 }
681
StopAuthenticateDevice(const std::string & pkgName)682 int32_t DeviceManagerImpl::StopAuthenticateDevice(const std::string &pkgName)
683 {
684 if (pkgName.empty()) {
685 LOGE("StopAuthenticateDevice error: Invalid para. pkgName %{public}s", pkgName.c_str());
686 return ERR_DM_INPUT_PARA_INVALID;
687 }
688 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
689 std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
690 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
691 req->SetPkgName(pkgName);
692 int32_t ret = ipcClientProxy_->SendRequest(STOP_AUTHENTICATE_DEVICE, req, rsp);
693 if (ret != DM_OK) {
694 LOGE("StopAuthenticateDevice error: Send Request failed ret: %{public}d", ret);
695 return ERR_DM_IPC_SEND_REQUEST_FAILED;
696 }
697 ret = rsp->GetErrCode();
698 if (ret != DM_OK) {
699 LOGE("StopAuthenticateDevice error: Failed with ret %{public}d", ret);
700 return ret;
701 }
702
703 LOGI("Completed");
704 return DM_OK;
705 }
706
RegisterDeviceManagerFaCallback(const std::string & pkgName,std::shared_ptr<DeviceManagerUiCallback> callback)707 int32_t DeviceManagerImpl::RegisterDeviceManagerFaCallback(const std::string &pkgName,
708 std::shared_ptr<DeviceManagerUiCallback> callback)
709 {
710 if (pkgName.empty() || callback == nullptr) {
711 LOGE("RegisterDeviceManagerFaCallback error: Invalid para");
712 return ERR_DM_INPUT_PARA_INVALID;
713 }
714
715 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
716 DeviceManagerNotify::GetInstance().RegisterDeviceManagerFaCallback(pkgName, callback);
717 RegisterUiStateCallback(pkgName);
718 LOGI("Completed");
719 return DM_OK;
720 }
721
UnRegisterDeviceManagerFaCallback(const std::string & pkgName)722 int32_t DeviceManagerImpl::UnRegisterDeviceManagerFaCallback(const std::string &pkgName)
723 {
724 if (pkgName.empty()) {
725 LOGE("Invalid parameter, pkgName is empty.");
726 return ERR_DM_INPUT_PARA_INVALID;
727 }
728
729 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
730 DeviceManagerNotify::GetInstance().UnRegisterDeviceManagerFaCallback(pkgName);
731 UnRegisterUiStateCallback(pkgName);
732 LOGI("Completed");
733 return DM_OK;
734 }
735
VerifyAuthentication(const std::string & pkgName,const std::string & authPara,std::shared_ptr<VerifyAuthCallback> callback)736 int32_t DeviceManagerImpl::VerifyAuthentication(const std::string &pkgName, const std::string &authPara,
737 std::shared_ptr<VerifyAuthCallback> callback)
738 {
739 (void)pkgName;
740 (void)authPara;
741 (void)callback;
742 LOGI("VerifyAuthentication not support method.");
743 return DM_OK;
744 }
745
GetFaParam(const std::string & pkgName,DmAuthParam & dmFaParam)746 int32_t DeviceManagerImpl::GetFaParam(const std::string &pkgName, DmAuthParam &dmFaParam)
747 {
748 (void)pkgName;
749 (void)dmFaParam;
750 LOGI("GetFaParam not support method.");
751 return DM_OK;
752 }
753
SetUserOperation(const std::string & pkgName,int32_t action,const std::string & params)754 int32_t DeviceManagerImpl::SetUserOperation(const std::string &pkgName, int32_t action, const std::string ¶ms)
755 {
756 if (pkgName.empty() || params.empty()) {
757 LOGE("DeviceManager::SetUserOperation start, pkgName: %{public}s, params: %{public}s", pkgName.c_str(),
758 params.c_str());
759 return ERR_DM_INPUT_PARA_INVALID;
760 }
761 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
762
763 std::shared_ptr<IpcGetOperationReq> req = std::make_shared<IpcGetOperationReq>();
764 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
765 req->SetPkgName(pkgName);
766 req->SetOperation(action);
767 req->SetParams(params);
768
769 int32_t ret = ipcClientProxy_->SendRequest(SERVER_USER_AUTH_OPERATION, req, rsp);
770 if (ret != DM_OK) {
771 LOGI("SetUserOperation Send Request failed ret: %{public}d", ret);
772 return ERR_DM_IPC_SEND_REQUEST_FAILED;
773 }
774
775 ret = rsp->GetErrCode();
776 if (ret != DM_OK) {
777 LOGE("CheckAuthentication Failed with ret %{public}d", ret);
778 return ret;
779 }
780 LOGI("Completed");
781 return DM_OK;
782 }
783
GetUdidByNetworkId(const std::string & pkgName,const std::string & netWorkId,std::string & udid)784 int32_t DeviceManagerImpl::GetUdidByNetworkId(const std::string &pkgName, const std::string &netWorkId,
785 std::string &udid)
786 {
787 if (pkgName.empty() || netWorkId.empty()) {
788 LOGE("DeviceManagerImpl::GetUdidByNetworkId error: Invalid para, pkgName: %{public}s, netWorkId: %{public}s",
789 pkgName.c_str(), GetAnonyString(netWorkId).c_str());
790 return ERR_DM_INPUT_PARA_INVALID;
791 }
792 LOGD("Start, pkgName: %{public}s", GetAnonyString(pkgName).c_str());
793
794 std::shared_ptr<IpcGetInfoByNetWorkReq> req = std::make_shared<IpcGetInfoByNetWorkReq>();
795 std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>();
796 req->SetPkgName(pkgName);
797 req->SetNetWorkId(netWorkId);
798
799 int32_t ret = ipcClientProxy_->SendRequest(GET_UDID_BY_NETWORK, req, rsp);
800 if (ret != DM_OK) {
801 LOGI("GetUdidByNetworkId Send Request failed ret: %{public}d", ret);
802 return ERR_DM_IPC_SEND_REQUEST_FAILED;
803 }
804
805 ret = rsp->GetErrCode();
806 if (ret != DM_OK) {
807 LOGE("CheckAuthentication Failed with ret %{public}d", ret);
808 return ret;
809 }
810 udid = rsp->GetUdid();
811 return DM_OK;
812 }
813
GetUuidByNetworkId(const std::string & pkgName,const std::string & netWorkId,std::string & uuid)814 int32_t DeviceManagerImpl::GetUuidByNetworkId(const std::string &pkgName, const std::string &netWorkId,
815 std::string &uuid)
816 {
817 if (pkgName.empty() || netWorkId.empty()) {
818 LOGE("DeviceManagerImpl::GetUuidByNetworkId error: Invalid para, pkgName: %{public}s, netWorkId: %{public}s",
819 pkgName.c_str(), GetAnonyString(netWorkId).c_str());
820 return ERR_DM_INPUT_PARA_INVALID;
821 }
822 LOGI("Start, pkgName: %{public}s", GetAnonyString(pkgName).c_str());
823
824 std::shared_ptr<IpcGetInfoByNetWorkReq> req = std::make_shared<IpcGetInfoByNetWorkReq>();
825 std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>();
826 req->SetPkgName(pkgName);
827 req->SetNetWorkId(netWorkId);
828
829 int32_t ret = ipcClientProxy_->SendRequest(GET_UUID_BY_NETWORK, req, rsp);
830 if (ret != DM_OK) {
831 LOGI("GetUuidByNetworkId Send Request failed ret: %{public}d", ret);
832 return ERR_DM_IPC_SEND_REQUEST_FAILED;
833 }
834
835 ret = rsp->GetErrCode();
836 if (ret != DM_OK) {
837 LOGE("CheckAuthentication Failed with ret %{public}d", ret);
838 return ret;
839 }
840 uuid = rsp->GetUuid();
841 return DM_OK;
842 }
843
RegisterDevStateCallback(const std::string & pkgName,const std::string & extra)844 int32_t DeviceManagerImpl::RegisterDevStateCallback(const std::string &pkgName, const std::string &extra)
845 {
846 (void)pkgName;
847 (void)extra;
848 LOGI("RegisterDevStateCallback not support method.");
849 return DM_OK;
850 }
851
UnRegisterDevStateCallback(const std::string & pkgName,const std::string & extra)852 int32_t DeviceManagerImpl::UnRegisterDevStateCallback(const std::string &pkgName, const std::string &extra)
853 {
854 (void)pkgName;
855 (void)extra;
856 LOGI("UnRegisterDevStateCallback not support method.");
857 return DM_OK;
858 }
859
RegisterUiStateCallback(const std::string & pkgName)860 int32_t DeviceManagerImpl::RegisterUiStateCallback(const std::string &pkgName)
861 {
862 if (pkgName.empty()) {
863 LOGE("Invalid parameter, pkgName is empty.");
864 return ERR_DM_INPUT_PARA_INVALID;
865 }
866 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
867
868 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
869 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
870 req->SetPkgName(pkgName);
871
872 int32_t ret = ipcClientProxy_->SendRequest(REGISTER_UI_STATE_CALLBACK, req, rsp);
873 if (ret != DM_OK) {
874 LOGI("RegisterUiStateCallback Send Request failed ret: %{public}d", ret);
875 return ERR_DM_IPC_SEND_REQUEST_FAILED;
876 }
877
878 ret = rsp->GetErrCode();
879 if (ret != DM_OK) {
880 LOGE("RegisterUiStateCallback Failed with ret %{public}d", ret);
881 return ret;
882 }
883 return DM_OK;
884 }
885
UnRegisterUiStateCallback(const std::string & pkgName)886 int32_t DeviceManagerImpl::UnRegisterUiStateCallback(const std::string &pkgName)
887 {
888 if (pkgName.empty()) {
889 LOGE("Invalid parameter, pkgName is empty.");
890 return ERR_DM_INPUT_PARA_INVALID;
891 }
892
893 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
894 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
895 req->SetPkgName(pkgName);
896
897 int32_t ret = ipcClientProxy_->SendRequest(UNREGISTER_UI_STATE_CALLBACK, req, rsp);
898 if (ret != DM_OK) {
899 LOGI("UnRegisterUiStateCallback Send Request failed ret: %{public}d", ret);
900 return ERR_DM_IPC_SEND_REQUEST_FAILED;
901 }
902
903 ret = rsp->GetErrCode();
904 if (ret != DM_OK) {
905 LOGE("UnRegisterUiStateCallback Failed with ret %{public}d", ret);
906 return ret;
907 }
908 return DM_OK;
909 }
910
RequestCredential(const std::string & pkgName,const std::string & reqJsonStr,std::string & returnJsonStr)911 int32_t DeviceManagerImpl::RequestCredential(const std::string &pkgName, const std::string &reqJsonStr,
912 std::string &returnJsonStr)
913 {
914 if (pkgName.empty() || reqJsonStr.empty()) {
915 LOGE("DeviceManagerImpl::RequestCredential error: Invalid para, pkgName is %{public}s, reqJsonStr is"
916 "%{public}s", pkgName.c_str(), GetAnonyString(reqJsonStr).c_str());
917 return ERR_DM_INPUT_PARA_INVALID;
918 }
919 LOGI("start to RequestCredential.");
920 std::map<std::string, std::string> requestParam;
921 requestParam.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_OH);
922 requestParam.emplace(DM_CREDENTIAL_REQJSONSTR, reqJsonStr);
923 std::string reqParaStr = ConvertMapToJsonString(requestParam);
924 std::shared_ptr<IpcSetCredentialReq> req = std::make_shared<IpcSetCredentialReq>();
925 std::shared_ptr<IpcSetCredentialRsp> rsp = std::make_shared<IpcSetCredentialRsp>();
926 req->SetPkgName(pkgName);
927 req->SetCredentialParam(reqParaStr);
928
929 int32_t ret = ipcClientProxy_->SendRequest(REQUEST_CREDENTIAL, req, rsp);
930 if (ret != DM_OK) {
931 LOGI("RequestCredential Send Request failed ret: %{public}d", ret);
932 return ERR_DM_IPC_SEND_REQUEST_FAILED;
933 }
934
935 ret = rsp->GetErrCode();
936 if (ret != DM_OK) {
937 LOGE("failed to get return errcode while request credential.");
938 return ret;
939 }
940 returnJsonStr = rsp->GetCredentialResult();
941 LOGI("request device credential completed.");
942 return DM_OK;
943 }
944
ImportCredential(const std::string & pkgName,const std::string & credentialInfo)945 int32_t DeviceManagerImpl::ImportCredential(const std::string &pkgName, const std::string &credentialInfo)
946 {
947 if (pkgName.empty() || credentialInfo.empty()) {
948 LOGE("DeviceManagerImpl::ImportCredential failed, pkgName is %{public}s, credentialInfo is %{public}s",
949 pkgName.c_str(), GetAnonyString(credentialInfo).c_str());
950 return ERR_DM_INPUT_PARA_INVALID;
951 }
952 LOGI("start to ImportCredential.");
953 std::map<std::string, std::string> requestParam;
954 requestParam.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_OH);
955 requestParam.emplace(DM_CREDENTIAL_REQJSONSTR, credentialInfo);
956 std::string reqParaStr = ConvertMapToJsonString(requestParam);
957 std::shared_ptr<IpcSetCredentialReq> req = std::make_shared<IpcSetCredentialReq>();
958 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
959 req->SetPkgName(pkgName);
960 req->SetCredentialParam(reqParaStr);
961
962 int32_t ret = ipcClientProxy_->SendRequest(IMPORT_CREDENTIAL, req, rsp);
963 if (ret != DM_OK) {
964 LOGI("ImportCredential Send Request failed ret: %{public}d", ret);
965 return ERR_DM_IPC_SEND_REQUEST_FAILED;
966 }
967
968 ret = rsp->GetErrCode();
969 if (ret != DM_OK) {
970 LOGE("failed to get return errcode while import credential.");
971 return ret;
972 }
973 LOGI("import credential to device completed.");
974 return DM_OK;
975 }
976
DeleteCredential(const std::string & pkgName,const std::string & deleteInfo)977 int32_t DeviceManagerImpl::DeleteCredential(const std::string &pkgName, const std::string &deleteInfo)
978 {
979 if (pkgName.empty() || deleteInfo.empty()) {
980 LOGE("DeviceManagerImpl::DeleteCredential failed, pkgName is %{public}s, deleteInfo is %{public}s",
981 pkgName.c_str(), GetAnonyString(deleteInfo).c_str());
982 return ERR_DM_INPUT_PARA_INVALID;
983 }
984 LOGI("start to DeleteCredential.");
985 std::map<std::string, std::string> requestParam;
986 requestParam.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_OH);
987 requestParam.emplace(DM_CREDENTIAL_REQJSONSTR, deleteInfo);
988 std::string reqParaStr = ConvertMapToJsonString(requestParam);
989 std::shared_ptr<IpcSetCredentialReq> req = std::make_shared<IpcSetCredentialReq>();
990 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
991 req->SetPkgName(pkgName);
992 req->SetCredentialParam(reqParaStr);
993
994 int32_t ret = ipcClientProxy_->SendRequest(DELETE_CREDENTIAL, req, rsp);
995 if (ret != DM_OK) {
996 LOGI("DeleteCredential Send Request failed ret: %{public}d", ret);
997 return ERR_DM_IPC_SEND_REQUEST_FAILED;
998 }
999
1000 ret = rsp->GetErrCode();
1001 if (ret != DM_OK) {
1002 LOGE("failed to get return errcode while import credential.");
1003 return ret;
1004 }
1005 LOGI("delete credential from device completed.");
1006 return DM_OK;
1007 }
1008
RegisterCredentialCallback(const std::string & pkgName,std::shared_ptr<CredentialCallback> callback)1009 int32_t DeviceManagerImpl::RegisterCredentialCallback(const std::string &pkgName,
1010 std::shared_ptr<CredentialCallback> callback)
1011 {
1012 if (pkgName.empty() || callback == nullptr) {
1013 LOGE("RegisterCredentialCallback error: Invalid para");
1014 return ERR_DM_INPUT_PARA_INVALID;
1015 }
1016
1017 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1018 DeviceManagerNotify::GetInstance().RegisterCredentialCallback(pkgName, callback);
1019 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
1020 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1021 req->SetPkgName(pkgName);
1022
1023 int32_t ret = ipcClientProxy_->SendRequest(REGISTER_CREDENTIAL_CALLBACK, req, rsp);
1024 if (ret != DM_OK) {
1025 LOGI("RegisterCredentialCallback Send Request failed ret: %{public}d", ret);
1026 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1027 }
1028
1029 ret = rsp->GetErrCode();
1030 if (ret != DM_OK) {
1031 LOGE("RegisterCredentialCallback error: Failed with ret %{public}d", ret);
1032 return ret;
1033 }
1034 LOGI("Completed, pkgName: %{public}s", pkgName.c_str());
1035 return DM_OK;
1036 }
1037
UnRegisterCredentialCallback(const std::string & pkgName)1038 int32_t DeviceManagerImpl::UnRegisterCredentialCallback(const std::string &pkgName)
1039 {
1040 if (pkgName.empty()) {
1041 LOGE("Invalid parameter, pkgName is empty.");
1042 return ERR_DM_INPUT_PARA_INVALID;
1043 }
1044 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1045
1046 DeviceManagerNotify::GetInstance().UnRegisterCredentialCallback(pkgName);
1047 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
1048 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1049 req->SetPkgName(pkgName);
1050
1051 int32_t ret = ipcClientProxy_->SendRequest(UNREGISTER_CREDENTIAL_CALLBACK, req, rsp);
1052 if (ret != DM_OK) {
1053 LOGI("UnRegisterCredentialCallback Send Request failed ret: %{public}d", ret);
1054 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1055 }
1056
1057 ret = rsp->GetErrCode();
1058 if (ret != DM_OK) {
1059 LOGE("UnRegisterCredentialCallback Failed with ret %{public}d", ret);
1060 return ret;
1061 }
1062 LOGI("Completed");
1063 return DM_OK;
1064 }
1065
NotifyEvent(const std::string & pkgName,const int32_t eventId,const std::string & event)1066 int32_t DeviceManagerImpl::NotifyEvent(const std::string &pkgName, const int32_t eventId, const std::string &event)
1067 {
1068 if (pkgName.empty()) {
1069 LOGE("NotifyEvent error: pkgName empty");
1070 return ERR_DM_INPUT_PARA_INVALID;
1071 }
1072 if ((eventId <= DM_NOTIFY_EVENT_START) || (eventId >= DM_NOTIFY_EVENT_BUTT)) {
1073 LOGE("NotifyEvent eventId invalid");
1074 return ERR_DM_INPUT_PARA_INVALID;
1075 }
1076 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1077 std::shared_ptr<IpcNotifyEventReq> req = std::make_shared<IpcNotifyEventReq>();
1078 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1079 req->SetPkgName(pkgName);
1080 req->SetEventId(eventId);
1081 req->SetEvent(event);
1082
1083 int32_t ret = ipcClientProxy_->SendRequest(NOTIFY_EVENT, req, rsp);
1084 if (ret != DM_OK) {
1085 LOGI("NotifyEvent Send Request failed ret: %{public}d", ret);
1086 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1087 }
1088
1089 ret = rsp->GetErrCode();
1090 if (ret != DM_OK) {
1091 LOGE("NotifyEvent failed with ret %{public}d", ret);
1092 return ret;
1093 }
1094 LOGI("Completed");
1095 return DM_OK;
1096 }
1097
RequestCredential(const std::string & pkgName,std::string & returnJsonStr)1098 int32_t DeviceManagerImpl::RequestCredential(const std::string &pkgName, std::string &returnJsonStr)
1099 {
1100 if (pkgName.empty()) {
1101 LOGE("RequestCredential failed, pkgName is empty.");
1102 return ERR_DM_INPUT_PARA_INVALID;
1103 }
1104 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1105 std::map<std::string, std::string> requestParam;
1106 requestParam.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_MINE);
1107 std::string reqParaStr = ConvertMapToJsonString(requestParam);
1108 std::shared_ptr<IpcSetCredentialReq> req = std::make_shared<IpcSetCredentialReq>();
1109 std::shared_ptr<IpcSetCredentialRsp> rsp = std::make_shared<IpcSetCredentialRsp>();
1110 req->SetPkgName(pkgName);
1111 req->SetCredentialParam(reqParaStr);
1112 int32_t ret = ipcClientProxy_->SendRequest(REQUEST_CREDENTIAL, req, rsp);
1113 if (ret != DM_OK) {
1114 LOGI("RequestCredential Send Request failed ret: %{public}d", ret);
1115 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1116 }
1117 ret = rsp->GetErrCode();
1118 if (ret != DM_OK) {
1119 LOGE("failed to get return errcode while request credential.");
1120 return ret;
1121 }
1122 returnJsonStr = rsp->GetCredentialResult();
1123 LOGI("Completed.");
1124 return DM_OK;
1125 }
1126
CheckCredential(const std::string & pkgName,const std::string & reqJsonStr,std::string & returnJsonStr)1127 int32_t DeviceManagerImpl::CheckCredential(const std::string &pkgName, const std::string &reqJsonStr,
1128 std::string &returnJsonStr)
1129 {
1130 if (pkgName.empty() || reqJsonStr.empty()) {
1131 LOGE("Check the credential is invalid para.");
1132 return ERR_DM_INPUT_PARA_INVALID;
1133 }
1134 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1135 std::shared_ptr<IpcSetCredentialReq> req = std::make_shared<IpcSetCredentialReq>();
1136 std::shared_ptr<IpcSetCredentialRsp> rsp = std::make_shared<IpcSetCredentialRsp>();
1137 req->SetPkgName(pkgName);
1138 req->SetCredentialParam(reqJsonStr);
1139
1140 int32_t ret = ipcClientProxy_->SendRequest(SERVER_GET_DMFA_INFO, req, rsp);
1141 if (ret != DM_OK) {
1142 LOGI("CheckCredential Send Request failed ret: %{public}d", ret);
1143 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1144 }
1145
1146 ret = rsp->GetErrCode();
1147 if (ret != DM_OK) {
1148 LOGE("failed to get return errcode while Check credential.");
1149 return ret;
1150 }
1151 returnJsonStr = rsp->GetCredentialResult();
1152 LOGI("Completed.");
1153 return DM_OK;
1154 }
1155
ImportCredential(const std::string & pkgName,const std::string & reqJsonStr,std::string & returnJsonStr)1156 int32_t DeviceManagerImpl::ImportCredential(const std::string &pkgName, const std::string &reqJsonStr,
1157 std::string &returnJsonStr)
1158 {
1159 if (pkgName.empty() || reqJsonStr.empty()) {
1160 LOGE("import the credential is invalid para.");
1161 return ERR_DM_INPUT_PARA_INVALID;
1162 }
1163 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1164 std::map<std::string, std::string> requestParam;
1165 requestParam.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_MINE);
1166 requestParam.emplace(DM_CREDENTIAL_REQJSONSTR, reqJsonStr);
1167 std::string reqParaStr = ConvertMapToJsonString(requestParam);
1168 std::shared_ptr<IpcSetCredentialReq> req = std::make_shared<IpcSetCredentialReq>();
1169 std::shared_ptr<IpcSetCredentialRsp> rsp = std::make_shared<IpcSetCredentialRsp>();
1170 req->SetPkgName(pkgName);
1171 req->SetCredentialParam(reqParaStr);
1172
1173 int32_t ret = ipcClientProxy_->SendRequest(IMPORT_CREDENTIAL, req, rsp);
1174 if (ret != DM_OK) {
1175 LOGI("ImportCredential Send Request failed ret: %{public}d", ret);
1176 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1177 }
1178
1179 ret = rsp->GetErrCode();
1180 if (ret != DM_OK) {
1181 LOGE("failed to get return errcode while import credential.");
1182 return ret;
1183 }
1184 returnJsonStr = rsp->GetCredentialResult();
1185 LOGI("Completed.");
1186 return DM_OK;
1187 }
1188
DeleteCredential(const std::string & pkgName,const std::string & reqJsonStr,std::string & returnJsonStr)1189 int32_t DeviceManagerImpl::DeleteCredential(const std::string &pkgName, const std::string &reqJsonStr,
1190 std::string &returnJsonStr)
1191 {
1192 if (pkgName.empty() || reqJsonStr.empty()) {
1193 LOGE("Delete the credential is invalid para.");
1194 return ERR_DM_INPUT_PARA_INVALID;
1195 }
1196 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1197 std::map<std::string, std::string> requestParam;
1198 requestParam.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_MINE);
1199 requestParam.emplace(DM_CREDENTIAL_REQJSONSTR, reqJsonStr);
1200 std::string reqParaStr = ConvertMapToJsonString(requestParam);
1201 std::shared_ptr<IpcSetCredentialReq> req = std::make_shared<IpcSetCredentialReq>();
1202 std::shared_ptr<IpcSetCredentialRsp> rsp = std::make_shared<IpcSetCredentialRsp>();
1203 req->SetPkgName(pkgName);
1204 req->SetCredentialParam(reqParaStr);
1205
1206 int32_t ret = ipcClientProxy_->SendRequest(DELETE_CREDENTIAL, req, rsp);
1207 if (ret != DM_OK) {
1208 LOGI("DeleteCredential Send Request failed ret: %{public}d", ret);
1209 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1210 }
1211
1212 ret = rsp->GetErrCode();
1213 if (ret != DM_OK) {
1214 LOGE("failed to get return errcode while import credential.");
1215 return ret;
1216 }
1217 returnJsonStr = rsp->GetCredentialResult();
1218 LOGI("Completed.");
1219 return DM_OK;
1220 }
1221
OnDmServiceDied()1222 int32_t DeviceManagerImpl::OnDmServiceDied()
1223 {
1224 LOGI("Start");
1225 int32_t ret = ipcClientProxy_->OnDmServiceDied();
1226 if (ret != DM_OK) {
1227 LOGE("OnDmServiceDied failed, ret: %{public}d", ret);
1228 return ERR_DM_FAILED;
1229 }
1230 return DM_OK;
1231 }
1232
GetEncryptedUuidByNetworkId(const std::string & pkgName,const std::string & networkId,std::string & uuid)1233 int32_t DeviceManagerImpl::GetEncryptedUuidByNetworkId(const std::string &pkgName, const std::string &networkId,
1234 std::string &uuid)
1235 {
1236 if (pkgName.empty() || networkId.empty()) {
1237 LOGE("DeviceManagerImpl::GetEncryptedUuidByNetworkId error: Invalid para, pkgName: %{public}s, netWorkId:"
1238 "%{public}s", pkgName.c_str(), GetAnonyString(networkId).c_str());
1239 return ERR_DM_INPUT_PARA_INVALID;
1240 }
1241 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1242
1243 std::shared_ptr<IpcGetInfoByNetWorkReq> req = std::make_shared<IpcGetInfoByNetWorkReq>();
1244 std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>();
1245 req->SetPkgName(pkgName);
1246 req->SetNetWorkId(networkId);
1247
1248 int32_t ret = ipcClientProxy_->SendRequest(GET_ENCRYPTED_UUID_BY_NETWOEKID, req, rsp);
1249 if (ret != DM_OK) {
1250 LOGI("GetEncryptedUuidByNetworkId Send Request failed ret: %{public}d", ret);
1251 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1252 }
1253
1254 ret = rsp->GetErrCode();
1255 if (ret != DM_OK) {
1256 LOGE("CheckAuthentication Failed with ret %{public}d", ret);
1257 return ret;
1258 }
1259 uuid = rsp->GetUuid();
1260 LOGI("Complete, uuid: %{public}s", GetAnonyString(uuid).c_str());
1261 return DM_OK;
1262 }
1263
GenerateEncryptedUuid(const std::string & pkgName,const std::string & uuid,const std::string & appId,std::string & encryptedUuid)1264 int32_t DeviceManagerImpl::GenerateEncryptedUuid(const std::string &pkgName, const std::string &uuid,
1265 const std::string &appId, std::string &encryptedUuid)
1266 {
1267 if (pkgName.empty() || uuid.empty()) {
1268 LOGE("DeviceManagerImpl::GenerateEncryptedUuid error: Invalid para, pkgName: %{public}s", pkgName.c_str());
1269 return ERR_DM_INPUT_PARA_INVALID;
1270 }
1271 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1272
1273 std::shared_ptr<IpcGenerateEncryptedUuidReq> req = std::make_shared<IpcGenerateEncryptedUuidReq>();
1274 std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>();
1275 req->SetPkgName(pkgName);
1276 req->SetUuid(uuid);
1277 req->SetAppId(appId);
1278
1279 int32_t ret = ipcClientProxy_->SendRequest(GENERATE_ENCRYPTED_UUID, req, rsp);
1280 if (ret != DM_OK) {
1281 LOGI("GenerateEncryptedUuid Send Request failed ret: %{public}d", ret);
1282 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1283 }
1284
1285 ret = rsp->GetErrCode();
1286 if (ret != DM_OK) {
1287 LOGE("CheckAuthentication Failed with ret %{public}d", ret);
1288 return ret;
1289 }
1290 encryptedUuid = rsp->GetUuid();
1291 LOGI("Complete, encryptedUuid: %{public}s", GetAnonyString(encryptedUuid).c_str());
1292 return DM_OK;
1293 }
1294
CheckAPIAccessPermission()1295 int32_t DeviceManagerImpl::CheckAPIAccessPermission()
1296 {
1297 LOGI("Start");
1298 return CheckApiPermission(SYSTEM_BASIC);
1299 }
1300
CheckNewAPIAccessPermission()1301 int32_t DeviceManagerImpl::CheckNewAPIAccessPermission()
1302 {
1303 LOGI("Start");
1304 return CheckApiPermission(NORMAL);
1305 }
1306
GetLocalDeviceNetWorkId(const std::string & pkgName,std::string & networkId)1307 int32_t DeviceManagerImpl::GetLocalDeviceNetWorkId(const std::string &pkgName, std::string &networkId)
1308 {
1309 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1310 DmDeviceInfo info;
1311 int32_t ret = GetLocalDeviceInfo(pkgName, info);
1312 if (ret != DM_OK) {
1313 LOGI("DeviceManagerImpl::GetLocalDeviceNetWorkId failed.");
1314 return ret;
1315 }
1316 networkId = std::string(info.networkId);
1317 LOGI("End, networkId : %{public}s", GetAnonyString(networkId).c_str());
1318 return DM_OK;
1319 }
1320
GetLocalDeviceId(const std::string & pkgName,std::string & deviceId)1321 int32_t DeviceManagerImpl::GetLocalDeviceId(const std::string &pkgName, std::string &deviceId)
1322 {
1323 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1324 DmDeviceInfo info;
1325 int32_t ret = GetLocalDeviceInfo(pkgName, info);
1326 if (ret != DM_OK) {
1327 LOGI("DeviceManagerImpl::GetLocalDeviceNetWorkId failed.");
1328 return ret;
1329 }
1330 deviceId = std::string(info.deviceId);
1331 LOGI("End, deviceId : %{public}s", GetAnonyString(deviceId).c_str());
1332 return DM_OK;
1333 }
1334
GetLocalDeviceName(const std::string & pkgName,std::string & deviceName)1335 int32_t DeviceManagerImpl::GetLocalDeviceName(const std::string &pkgName, std::string &deviceName)
1336 {
1337 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1338 DmDeviceInfo info;
1339 int32_t ret = GetLocalDeviceInfo(pkgName, info);
1340 if (ret != DM_OK) {
1341 LOGI("DeviceManagerImpl::GetLocalDeviceNetWorkId failed.");
1342 return ret;
1343 }
1344 deviceName = std::string(info.deviceName);
1345 LOGI("End, deviceName : %{public}s", GetAnonyString(deviceName).c_str());
1346 return DM_OK;
1347 }
1348
GetLocalDeviceType(const std::string & pkgName,int32_t & deviceType)1349 int32_t DeviceManagerImpl::GetLocalDeviceType(const std::string &pkgName, int32_t &deviceType)
1350 {
1351 LOGI("Start, pkgName : %{public}s", pkgName.c_str());
1352 DmDeviceInfo info;
1353 int32_t ret = GetLocalDeviceInfo(pkgName, info);
1354 if (ret != DM_OK) {
1355 LOGI("DeviceManagerImpl::GetLocalDeviceNetWorkId failed.");
1356 return ret;
1357 }
1358 deviceType = info.deviceTypeId;
1359 LOGI("End, deviceType : %{public}d", deviceType);
1360 return DM_OK;
1361 }
1362
GetDeviceName(const std::string & pkgName,const std::string & networkId,std::string & deviceName)1363 int32_t DeviceManagerImpl::GetDeviceName(const std::string &pkgName, const std::string &networkId,
1364 std::string &deviceName)
1365 {
1366 DmDeviceInfo deviceInfo;
1367 int32_t ret = GetDeviceInfo(pkgName, networkId, deviceInfo);
1368 if (ret != DM_OK) {
1369 LOGE("DeviceManagerImpl::GetDeviceName error, failed ret: %{public}d", ret);
1370 return ret;
1371 }
1372 deviceName = std::string(deviceInfo.deviceName);
1373 LOGI("End, pkgName : %{public}s, networkId : %{public}s, deviceName = %{public}s",
1374 pkgName.c_str(), GetAnonyString(networkId).c_str(), GetAnonyString(deviceName).c_str());
1375 return DM_OK;
1376 }
1377
GetDeviceType(const std::string & pkgName,const std::string & networkId,int32_t & deviceType)1378 int32_t DeviceManagerImpl::GetDeviceType(const std::string &pkgName, const std::string &networkId, int32_t &deviceType)
1379 {
1380 DmDeviceInfo deviceInfo;
1381 int32_t ret = GetDeviceInfo(pkgName, networkId, deviceInfo);
1382 if (ret != DM_OK) {
1383 LOGE("DeviceManagerImpl::GetDeviceType error, failed ret: %{public}d", ret);
1384 return ret;
1385 }
1386 deviceType = deviceInfo.deviceTypeId;
1387 LOGI("End, pkgName : %{public}s, networkId : %{public}s, deviceType = %{public}d",
1388 pkgName.c_str(), GetAnonyString(networkId).c_str(), deviceType);
1389 return DM_OK;
1390 }
1391
BindDevice(const std::string & pkgName,int32_t bindType,const std::string & deviceId,const std::string & bindParam,std::shared_ptr<AuthenticateCallback> callback)1392 int32_t DeviceManagerImpl::BindDevice(const std::string &pkgName, int32_t bindType, const std::string &deviceId,
1393 const std::string &bindParam, std::shared_ptr<AuthenticateCallback> callback)
1394 {
1395 if (pkgName.empty() || deviceId.empty()) {
1396 LOGE("BindDevice error: Invalid para. pkgName : %{public}s", pkgName.c_str());
1397 return ERR_DM_INPUT_PARA_INVALID;
1398 }
1399 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1400 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback);
1401 std::shared_ptr<IpcBindDeviceReq> req = std::make_shared<IpcBindDeviceReq>();
1402 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1403 req->SetPkgName(pkgName);
1404 req->SetBindParam(bindParam);
1405 req->SetBindType(bindType);
1406 req->SetDeviceId(deviceId);
1407 int32_t ret = ipcClientProxy_->SendRequest(BIND_DEVICE, req, rsp);
1408 if (ret != DM_OK) {
1409 LOGE("BindDevice error: Send Request failed ret: %{public}d", ret);
1410 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1411 }
1412
1413 ret = rsp->GetErrCode();
1414 if (ret != DM_OK) {
1415 LOGE("BindDevice error: Failed with ret %{public}d", ret);
1416 return ret;
1417 }
1418 DmTraceEnd();
1419 LOGI("End");
1420 return DM_OK;
1421 }
1422
UnBindDevice(const std::string & pkgName,const std::string & deviceId)1423 int32_t DeviceManagerImpl::UnBindDevice(const std::string &pkgName, const std::string &deviceId)
1424 {
1425 if (pkgName.empty() || deviceId.empty()) {
1426 LOGE("UnBindDevice error: Invalid para. pkgName %{public}s", pkgName.c_str());
1427 return ERR_DM_INPUT_PARA_INVALID;
1428 }
1429 LOGI("Start, pkgName: %{public}s, deviceId: %{public}s", pkgName.c_str(),
1430 GetAnonyString(std::string(deviceId)).c_str());
1431 std::shared_ptr<IpcUnBindDeviceReq> req = std::make_shared<IpcUnBindDeviceReq>();
1432 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1433 req->SetPkgName(pkgName);
1434 req->SetDeviceId(deviceId);
1435 int32_t ret = ipcClientProxy_->SendRequest(UNBIND_DEVICE, req, rsp);
1436 if (ret != DM_OK) {
1437 LOGE("UnBindDevice error: Send Request failed ret: %{public}d", ret);
1438 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1439 }
1440 ret = rsp->GetErrCode();
1441 if (ret != DM_OK) {
1442 LOGE("UnBindDevice error: Failed with ret %{public}d", ret);
1443 return ret;
1444 }
1445
1446 LOGI("End");
1447 return DM_OK;
1448 }
1449
GetNetworkTypeByNetworkId(const std::string & pkgName,const std::string & netWorkId,int32_t & netWorkType)1450 int32_t DeviceManagerImpl::GetNetworkTypeByNetworkId(const std::string &pkgName, const std::string &netWorkId,
1451 int32_t &netWorkType)
1452 {
1453 if (pkgName.empty() || netWorkId.empty()) {
1454 LOGE("GetNetworkTypeByNetworkId error: Invalid para, pkgName: %{public}s, netWorkId: %{public}s, netWorkType:"
1455 "%{public}d", pkgName.c_str(), GetAnonyString(netWorkId).c_str(), netWorkType);
1456 return ERR_DM_INPUT_PARA_INVALID;
1457 }
1458 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1459
1460 std::shared_ptr<IpcGetInfoByNetWorkReq> req = std::make_shared<IpcGetInfoByNetWorkReq>();
1461 std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>();
1462 req->SetPkgName(pkgName);
1463 req->SetNetWorkId(netWorkId);
1464
1465 int32_t ret = ipcClientProxy_->SendRequest(GET_NETWORKTYPE_BY_NETWORK, req, rsp);
1466 if (ret != DM_OK) {
1467 LOGI("GetNetworkTypeByNetworkId Send Request failed ret: %{public}d", ret);
1468 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1469 }
1470
1471 ret = rsp->GetErrCode();
1472 if (ret != DM_OK) {
1473 LOGE("CheckAuthentication Failed with ret %{public}d", ret);
1474 return ret;
1475 }
1476 netWorkType = rsp->GetNetworkType();
1477 return DM_OK;
1478 }
1479
ImportAuthCode(const std::string & pkgName,const std::string & authCode)1480 int32_t DeviceManagerImpl::ImportAuthCode(const std::string &pkgName, const std::string &authCode)
1481 {
1482 if (authCode.empty() || pkgName.empty()) {
1483 LOGE("ImportAuthCode error: Invalid para, authCode: %{public}s, pkgName: %{public}s",
1484 GetAnonyString(authCode).c_str(), pkgName.c_str());
1485 return ERR_DM_INPUT_PARA_INVALID;
1486 }
1487 LOGI("Start, authCode: %{public}s", GetAnonyString(authCode).c_str());
1488 int32_t length = static_cast<int32_t>(authCode.length());
1489 if (length != DM_IMPORT_AUTH_CODE_LENGTH) {
1490 LOGE("ImportAuthCode error: Invalid para, authCode size error.");
1491 return ERR_DM_INPUT_PARA_INVALID;
1492 }
1493
1494 for (int32_t i = 0; i < length; i++) {
1495 if (!isdigit(authCode[i])) {
1496 LOGE("ImportAuthCode error: Invalid para, authCode format error.");
1497 return ERR_DM_INPUT_PARA_INVALID;
1498 }
1499 }
1500
1501 std::shared_ptr<IpcImportAuthCodeReq> req = std::make_shared<IpcImportAuthCodeReq>();
1502 req->SetAuthCode(authCode);
1503 req->SetPkgName(pkgName);
1504 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1505
1506 int32_t ret = ipcClientProxy_->SendRequest(IMPORT_AUTH_CODE, req, rsp);
1507 if (ret != DM_OK) {
1508 LOGI("ImportAuthCode Send Request failed ret: %{public}d", ret);
1509 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1510 }
1511
1512 ret = rsp->GetErrCode();
1513 if (ret != DM_OK) {
1514 LOGE("ImportAuthCode Failed with ret %{public}d", ret);
1515 return ret;
1516 }
1517 return DM_OK;
1518 }
1519
ExportAuthCode(std::string & authCode)1520 int32_t DeviceManagerImpl::ExportAuthCode(std::string &authCode)
1521 {
1522 LOGI("Start");
1523
1524 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
1525 std::shared_ptr<IpcExportAuthCodeRsp> rsp = std::make_shared<IpcExportAuthCodeRsp>();
1526
1527 int32_t ret = ipcClientProxy_->SendRequest(EXPORT_AUTH_CODE, req, rsp);
1528 if (ret != DM_OK) {
1529 LOGI("ExportAuthCode Send Request failed ret: %{public}d", ret);
1530 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1531 }
1532
1533 ret = rsp->GetErrCode();
1534 if (ret != DM_OK) {
1535 LOGE("ExportAuthCode Failed with ret %{public}d", ret);
1536 return ret;
1537 }
1538
1539 authCode = rsp->GetAuthCode();
1540 LOGI("Success, authCode: %{public}s.", GetAnonyString(authCode).c_str());
1541 return DM_OK;
1542 }
1543
StartDiscovering(const std::string & pkgName,std::map<std::string,std::string> & discoverParam,const std::map<std::string,std::string> & filterOptions,std::shared_ptr<DiscoveryCallback> callback)1544 int32_t DeviceManagerImpl::StartDiscovering(const std::string &pkgName,
1545 std::map<std::string, std::string> &discoverParam, const std::map<std::string, std::string> &filterOptions,
1546 std::shared_ptr<DiscoveryCallback> callback)
1547 {
1548 if (pkgName.empty() || callback == nullptr) {
1549 LOGE("DeviceManagerImpl::StartDiscovering failed: input callback is null or pkgName is empty.");
1550 return ERR_DM_INPUT_PARA_INVALID;
1551 }
1552 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1553 DmTraceStart(std::string(DM_HITRACE_START_DEVICE));
1554
1555 uint16_t subscribeId = AddDiscoveryCallback(pkgName, callback);
1556 discoverParam.emplace(PARAM_KEY_SUBSCRIBE_ID, std::to_string(subscribeId));
1557 std::string discParaStr = ConvertMapToJsonString(discoverParam);
1558 std::string filterOpStr = ConvertMapToJsonString(filterOptions);
1559
1560 std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
1561 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1562 req->SetPkgName(pkgName);
1563 req->SetFirstParam(discParaStr);
1564 req->SetSecondParam(filterOpStr);
1565 int32_t ret = ipcClientProxy_->SendRequest(START_DISCOVERING, req, rsp);
1566 if (ret != DM_OK) {
1567 LOGE("StartDiscovering error: Send Request failed ret: %{public}d", ret);
1568 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1569 }
1570 ret = rsp->GetErrCode();
1571 if (ret != DM_OK) {
1572 LOGE("StartDiscovering error: Failed with ret %{public}d", ret);
1573 return ret;
1574 }
1575
1576 DmTraceEnd();
1577 LOGI("Completed");
1578 SysEventWrite(std::string(START_DEVICE_DISCOVERY_SUCCESS), DM_HISYEVENT_BEHAVIOR,
1579 std::string(START_DEVICE_DISCOVERY_SUCCESS_MSG));
1580 return DM_OK;
1581 }
1582
StopDiscovering(const std::string & pkgName,std::map<std::string,std::string> & discoverParam)1583 int32_t DeviceManagerImpl::StopDiscovering(const std::string &pkgName,
1584 std::map<std::string, std::string> &discoverParam)
1585 {
1586 if (pkgName.empty()) {
1587 LOGE("DeviceManagerImpl::StopDiscovering failed: input pkgName is empty.");
1588 return ERR_DM_INPUT_PARA_INVALID;
1589 }
1590 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1591 uint16_t subscribeId = DM_INVALID_FLAG_ID;
1592 {
1593 std::lock_guard<std::mutex> autoLock(subMapLock);
1594 if (pkgName2SubIdMap_.find(pkgName) != pkgName2SubIdMap_.end()) {
1595 subscribeId = pkgName2SubIdMap_[pkgName];
1596 }
1597 }
1598 if (subscribeId == DM_INVALID_FLAG_ID) {
1599 LOGE("DeviceManagerImpl::StopDiscovering failed: cannot find pkgName in cache map.");
1600 return ERR_DM_INPUT_PARA_INVALID;
1601 }
1602 discoverParam.emplace(PARAM_KEY_SUBSCRIBE_ID, std::to_string(subscribeId));
1603 std::string discParaStr = ConvertMapToJsonString(discoverParam);
1604
1605 std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
1606 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1607 req->SetPkgName(pkgName);
1608 req->SetFirstParam(discParaStr);
1609 int32_t ret = ipcClientProxy_->SendRequest(STOP_DISCOVERING, req, rsp);
1610 if (ret != DM_OK) {
1611 LOGE("StopDiscovering error: Send Request failed ret: %{public}d", ret);
1612 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1613 }
1614 ret = rsp->GetErrCode();
1615 if (ret != DM_OK) {
1616 LOGE("StopDiscovering error: Failed with ret %{public}d", ret);
1617 return ret;
1618 }
1619 RemoveDiscoveryCallback(pkgName);
1620 LOGI("Completed");
1621 return DM_OK;
1622 }
1623
RegisterDiscoveryCallback(const std::string & pkgName,std::map<std::string,std::string> & discoverParam,const std::map<std::string,std::string> & filterOptions,std::shared_ptr<DiscoveryCallback> callback)1624 int32_t DeviceManagerImpl::RegisterDiscoveryCallback(const std::string &pkgName,
1625 std::map<std::string, std::string> &discoverParam, const std::map<std::string, std::string> &filterOptions,
1626 std::shared_ptr<DiscoveryCallback> callback)
1627 {
1628 if (pkgName.empty() || callback == nullptr) {
1629 LOGE("DeviceManagerImpl::RegisterDiscoveryCallback failed: input callback is null or pkgName is empty.");
1630 return ERR_DM_INPUT_PARA_INVALID;
1631 }
1632 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1633
1634 uint16_t subscribeId = AddDiscoveryCallback(pkgName, callback);
1635 discoverParam.emplace(PARAM_KEY_SUBSCRIBE_ID, std::to_string(subscribeId));
1636 std::string discParaStr = ConvertMapToJsonString(discoverParam);
1637 std::string filterOpStr = ConvertMapToJsonString(filterOptions);
1638
1639 std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
1640 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1641 req->SetPkgName(pkgName);
1642 req->SetFirstParam(discParaStr);
1643 req->SetSecondParam(filterOpStr);
1644 int32_t ret = ipcClientProxy_->SendRequest(REGISTER_DISCOVERY_CALLBACK, req, rsp);
1645 if (ret != DM_OK) {
1646 LOGE("RegisterDiscoveryCallback error: Send Request failed ret: %{public}d", ret);
1647 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1648 }
1649 ret = rsp->GetErrCode();
1650 if (ret != DM_OK) {
1651 LOGE("RegisterDiscoveryCallback error: Failed with ret %{public}d", ret);
1652 return ret;
1653 }
1654 LOGI("Completed");
1655 return DM_OK;
1656 }
1657
UnRegisterDiscoveryCallback(const std::string & pkgName)1658 int32_t DeviceManagerImpl::UnRegisterDiscoveryCallback(const std::string &pkgName)
1659 {
1660 if (pkgName.empty()) {
1661 LOGE("DeviceManagerImpl::UnRegisterDiscoveryCallback failed: input pkgName is empty.");
1662 return ERR_DM_INPUT_PARA_INVALID;
1663 }
1664 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1665
1666 uint16_t subscribeId = RemoveDiscoveryCallback(pkgName);
1667 if (subscribeId == DM_INVALID_FLAG_ID) {
1668 LOGE("DeviceManagerImpl::UnRegisterDiscoveryCallback failed: cannot find pkgName in cache map.");
1669 return ERR_DM_INPUT_PARA_INVALID;
1670 }
1671 std::map<std::string, std::string> extraParam;
1672 extraParam.emplace(PARAM_KEY_SUBSCRIBE_ID, std::to_string(subscribeId));
1673 std::string extraParaStr = ConvertMapToJsonString(extraParam);
1674
1675 std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
1676 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1677 req->SetPkgName(pkgName);
1678 req->SetFirstParam(extraParaStr);
1679 int32_t ret = ipcClientProxy_->SendRequest(UNREGISTER_DISCOVERY_CALLBACK, req, rsp);
1680 if (ret != DM_OK) {
1681 LOGE("UnRegisterDiscoveryCallback error: Send Request failed ret: %{public}d", ret);
1682 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1683 }
1684 ret = rsp->GetErrCode();
1685 if (ret != DM_OK) {
1686 LOGE("UnRegisterDiscoveryCallback error: Failed with ret %{public}d", ret);
1687 return ret;
1688 }
1689 LOGI("Completed");
1690 return DM_OK;
1691 }
1692
StartAdvertising(const std::string & pkgName,std::map<std::string,std::string> & advertiseParam,std::shared_ptr<PublishCallback> callback)1693 int32_t DeviceManagerImpl::StartAdvertising(const std::string &pkgName,
1694 std::map<std::string, std::string> &advertiseParam, std::shared_ptr<PublishCallback> callback)
1695 {
1696 if (pkgName.empty() || callback == nullptr) {
1697 LOGE("DeviceManagerImpl::StartAdvertising error: pkgName %{public}s invalid para", pkgName.c_str());
1698 return ERR_DM_INPUT_PARA_INVALID;
1699 }
1700 LOGI("Start, pkgName %{public}s", pkgName.c_str());
1701
1702 int32_t publishId;
1703 if (advertiseParam.find(PARAM_KEY_PUBLISH_ID) == advertiseParam.end()) {
1704 publishId = AddPublishCallback(pkgName);
1705 advertiseParam[PARAM_KEY_PUBLISH_ID] = std::to_string(publishId);
1706 } else {
1707 publishId = std::atoi((advertiseParam.find(PARAM_KEY_PUBLISH_ID)->second).c_str());
1708 }
1709 std::string adverParaStr = ConvertMapToJsonString(advertiseParam);
1710
1711 std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
1712 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1713 req->SetPkgName(pkgName);
1714 req->SetFirstParam(adverParaStr);
1715 int32_t ret = ipcClientProxy_->SendRequest(START_ADVERTISING, req, rsp);
1716 if (ret != DM_OK) {
1717 LOGE("StartAdvertising error: Send Request failed ret: %{public}d", ret);
1718 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1719 }
1720 ret = rsp->GetErrCode();
1721 if (ret != DM_OK) {
1722 LOGE("StartAdvertising error: Failed with ret %{public}d", ret);
1723 return ret;
1724 }
1725 DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishId, callback);
1726 LOGI("Completed");
1727 return DM_OK;
1728 }
1729
StopAdvertising(const std::string & pkgName,std::map<std::string,std::string> & advertiseParam)1730 int32_t DeviceManagerImpl::StopAdvertising(const std::string &pkgName,
1731 std::map<std::string, std::string> &advertiseParam)
1732 {
1733 if (pkgName.empty()) {
1734 LOGE("DeviceManagerImpl::StopAdvertising failed: input pkgName is empty.");
1735 return ERR_DM_INPUT_PARA_INVALID;
1736 }
1737 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1738
1739 int32_t publishId;
1740 if (advertiseParam.find(PARAM_KEY_PUBLISH_ID) == advertiseParam.end()) {
1741 publishId = RemovePublishCallback(pkgName);
1742 advertiseParam[PARAM_KEY_PUBLISH_ID] = std::to_string(publishId);
1743 } else {
1744 publishId = std::atoi((advertiseParam.find(PARAM_KEY_PUBLISH_ID)->second).c_str());
1745 }
1746 if (publishId == DM_INVALID_FLAG_ID) {
1747 LOGE("DeviceManagerImpl::StopAdvertising failed: cannot find pkgName in cache map.");
1748 return ERR_DM_INPUT_PARA_INVALID;
1749 }
1750 std::string adverParaStr = ConvertMapToJsonString(advertiseParam);
1751
1752 std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
1753 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1754 req->SetPkgName(pkgName);
1755 req->SetFirstParam(adverParaStr);
1756 int32_t ret = ipcClientProxy_->SendRequest(STOP_ADVERTISING, req, rsp);
1757 if (ret != DM_OK) {
1758 LOGE("StopAdvertising error: Send Request failed ret: %{public}d", ret);
1759 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1760 }
1761 ret = rsp->GetErrCode();
1762 if (ret != DM_OK) {
1763 LOGE("StopAdvertising error: Failed with ret %{public}d", ret);
1764 return ret;
1765 }
1766 DeviceManagerNotify::GetInstance().UnRegisterPublishCallback(pkgName, publishId);
1767 LOGI("Completed");
1768 return DM_OK;
1769 }
1770
BindTarget(const std::string & pkgName,const PeerTargetId & targetId,std::map<std::string,std::string> & bindParam,std::shared_ptr<BindTargetCallback> callback)1771 int32_t DeviceManagerImpl::BindTarget(const std::string &pkgName, const PeerTargetId &targetId,
1772 std::map<std::string, std::string> &bindParam, std::shared_ptr<BindTargetCallback> callback)
1773 {
1774 if (pkgName.empty() || IsInvalidPeerTargetId(targetId)) {
1775 LOGE("DeviceManagerImpl::BindTarget failed: input pkgName or targetId is empty.");
1776 return ERR_DM_INPUT_PARA_INVALID;
1777 }
1778 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1779 std::string bindParamStr = ConvertMapToJsonString(bindParam);
1780 DeviceManagerNotify::GetInstance().RegisterBindCallback(pkgName, targetId, callback);
1781 std::shared_ptr<IpcBindTargetReq> req = std::make_shared<IpcBindTargetReq>();
1782 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1783 req->SetPkgName(pkgName);
1784 req->SetPeerTargetId(targetId);
1785 req->SetBindParam(bindParamStr);
1786 int32_t ret = ipcClientProxy_->SendRequest(BIND_TARGET, req, rsp);
1787 if (ret != DM_OK) {
1788 LOGE("BindTarget error: Send Request failed ret: %{public}d", ret);
1789 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1790 }
1791 ret = rsp->GetErrCode();
1792 if (ret != DM_OK) {
1793 LOGE("BindTarget error: Failed with ret %{public}d", ret);
1794 return ret;
1795 }
1796
1797 LOGI("Completed");
1798 return DM_OK;
1799 }
1800
UnbindTarget(const std::string & pkgName,const PeerTargetId & targetId,std::map<std::string,std::string> & unbindParam,std::shared_ptr<UnbindTargetCallback> callback)1801 int32_t DeviceManagerImpl::UnbindTarget(const std::string &pkgName, const PeerTargetId &targetId,
1802 std::map<std::string, std::string> &unbindParam, std::shared_ptr<UnbindTargetCallback> callback)
1803 {
1804 if (pkgName.empty() || IsInvalidPeerTargetId(targetId)) {
1805 LOGE("DeviceManagerImpl::UnbindTarget failed: input pkgName or targetId is empty.");
1806 return ERR_DM_INPUT_PARA_INVALID;
1807 }
1808 LOGI("Start, pkgName: %{public}s", pkgName.c_str());
1809 std::string unbindParamStr = ConvertMapToJsonString(unbindParam);
1810
1811 std::shared_ptr<IpcBindTargetReq> req = std::make_shared<IpcBindTargetReq>();
1812 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1813 req->SetPkgName(pkgName);
1814 req->SetPeerTargetId(targetId);
1815 req->SetBindParam(unbindParamStr);
1816 int32_t ret = ipcClientProxy_->SendRequest(UNBIND_TARGET, req, rsp);
1817 if (ret != DM_OK) {
1818 LOGE("UnbindTarget error: Send Request failed ret: %{public}d", ret);
1819 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1820 }
1821 ret = rsp->GetErrCode();
1822 if (ret != DM_OK) {
1823 LOGE("UnbindTarget error: Failed with ret %{public}d", ret);
1824 return ret;
1825 }
1826 DeviceManagerNotify::GetInstance().RegisterUnbindCallback(pkgName, targetId, callback);
1827
1828 LOGI("Completed");
1829 return DM_OK;
1830 }
1831
GetTrustedDeviceList(const std::string & pkgName,const std::map<std::string,std::string> & filterOptions,bool isRefresh,std::vector<DmDeviceInfo> & deviceList)1832 int32_t DeviceManagerImpl::GetTrustedDeviceList(const std::string &pkgName,
1833 const std::map<std::string, std::string> &filterOptions, bool isRefresh,
1834 std::vector<DmDeviceInfo> &deviceList)
1835 {
1836 if (pkgName.empty()) {
1837 LOGE("DeviceManagerImpl::GetTrustedDeviceList failed: input pkgName is empty.");
1838 return ERR_DM_INPUT_PARA_INVALID;
1839 }
1840 std::string filterOpStr = ConvertMapToJsonString(filterOptions);
1841 return GetTrustedDeviceList(pkgName, filterOpStr, isRefresh, deviceList);
1842 }
1843
RegisterDevStateCallback(const std::string & pkgName,const std::map<std::string,std::string> & extraParam,std::shared_ptr<DeviceStateCallback> callback)1844 int32_t DeviceManagerImpl::RegisterDevStateCallback(const std::string &pkgName,
1845 const std::map<std::string, std::string> &extraParam, std::shared_ptr<DeviceStateCallback> callback)
1846 {
1847 (void)extraParam;
1848 if (pkgName.empty() || callback == nullptr) {
1849 LOGE("DeviceManagerImpl::RegisterDeviceStateCallback failed: input pkgName or callback is empty.");
1850 return ERR_DM_INPUT_PARA_INVALID;
1851 }
1852 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback);
1853 LOGI("Completed, pkgName: %{public}s", pkgName.c_str());
1854 return DM_OK;
1855 }
1856
CheckAccessToTarget(uint64_t tokenId,const std::string & targetId)1857 int32_t DeviceManagerImpl::CheckAccessToTarget(uint64_t tokenId, const std::string &targetId)
1858 {
1859 (void)tokenId;
1860 (void)targetId;
1861 LOGI("Start");
1862 return ERR_DM_UNSUPPORTED_METHOD;
1863 }
1864
AddDiscoveryCallback(const std::string & pkgName,std::shared_ptr<DiscoveryCallback> callback)1865 uint16_t DeviceManagerImpl::AddDiscoveryCallback(const std::string &pkgName,
1866 std::shared_ptr<DiscoveryCallback> callback)
1867 {
1868 uint16_t subscribeId = DM_INVALID_FLAG_ID;
1869 {
1870 std::lock_guard<std::mutex> autoLock(subMapLock);
1871 if (pkgName2SubIdMap_.find(pkgName) != pkgName2SubIdMap_.end()) {
1872 subscribeId = pkgName2SubIdMap_[pkgName];
1873 } else {
1874 subscribeId = GenRandUint(DM_MIN_RANDOM, DM_MAX_RANDOM);
1875 pkgName2SubIdMap_[pkgName] = subscribeId;
1876 }
1877 }
1878 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback);
1879 return subscribeId;
1880 }
1881
RemoveDiscoveryCallback(const std::string & pkgName)1882 uint16_t DeviceManagerImpl::RemoveDiscoveryCallback(const std::string &pkgName)
1883 {
1884 uint16_t subscribeId = DM_INVALID_FLAG_ID;
1885 {
1886 std::lock_guard<std::mutex> autoLock(subMapLock);
1887 if (pkgName2SubIdMap_.find(pkgName) != pkgName2SubIdMap_.end()) {
1888 subscribeId = pkgName2SubIdMap_[pkgName];
1889 pkgName2SubIdMap_.erase(pkgName);
1890 }
1891 }
1892 DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(pkgName, subscribeId);
1893 return subscribeId;
1894 }
1895
AddPublishCallback(const std::string & pkgName)1896 int32_t DeviceManagerImpl::AddPublishCallback(const std::string &pkgName)
1897 {
1898 int32_t publishId = DM_INVALID_FLAG_ID;
1899 {
1900 std::lock_guard<std::mutex> autoLock(pubMapLock);
1901 if (pkgName2PubIdMap_.find(pkgName) != pkgName2PubIdMap_.end()) {
1902 publishId = pkgName2PubIdMap_[pkgName];
1903 } else {
1904 publishId = GenRandUint(DM_MIN_RANDOM, DM_MAX_RANDOM);
1905 pkgName2PubIdMap_[pkgName] = publishId;
1906 }
1907 }
1908 return publishId;
1909 }
1910
RemovePublishCallback(const std::string & pkgName)1911 int32_t DeviceManagerImpl::RemovePublishCallback(const std::string &pkgName)
1912 {
1913 uint16_t publishId = DM_INVALID_FLAG_ID;
1914 {
1915 std::lock_guard<std::mutex> autoLock(subMapLock);
1916 if (pkgName2PubIdMap_.find(pkgName) != pkgName2PubIdMap_.end()) {
1917 publishId = pkgName2PubIdMap_[pkgName];
1918 pkgName2PubIdMap_.erase(pkgName);
1919 }
1920 }
1921
1922 return publishId;
1923 }
1924
RegisterPinHolderCallback(const std::string & pkgName,std::shared_ptr<PinHolderCallback> callback)1925 int32_t DeviceManagerImpl::RegisterPinHolderCallback(const std::string &pkgName,
1926 std::shared_ptr<PinHolderCallback> callback)
1927 {
1928 if (pkgName.empty() || callback == nullptr) {
1929 LOGE("RegisterPinHolderCallback error: Invalid para, pkgName: %{public}s", pkgName.c_str());
1930 return ERR_DM_INPUT_PARA_INVALID;
1931 }
1932 DeviceManagerNotify::GetInstance().RegisterPinHolderCallback(pkgName, callback);
1933 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
1934 req->SetPkgName(pkgName);
1935 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1936
1937 int32_t ret = ipcClientProxy_->SendRequest(REGISTER_PIN_HOLDER_CALLBACK, req, rsp);
1938 if (ret != DM_OK) {
1939 LOGI("RegisterPinHolderCallback Send Request failed ret: %{public}d", ret);
1940 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1941 }
1942 ret = rsp->GetErrCode();
1943 if (ret != DM_OK) {
1944 LOGE("RegisterPinHolderCallback Failed with ret %{public}d", ret);
1945 return ret;
1946 }
1947 return DM_OK;
1948 }
1949
CreatePinHolder(const std::string & pkgName,const PeerTargetId & targetId,DmPinType pinType,const std::string & payload)1950 int32_t DeviceManagerImpl::CreatePinHolder(const std::string &pkgName, const PeerTargetId &targetId,
1951 DmPinType pinType, const std::string &payload)
1952 {
1953 if (pkgName.empty() || IsInvalidPeerTargetId(targetId) ||
1954 pinType > DmPinType::SUPER_SONIC || pinType < DmPinType::NUMBER_PIN_CODE ||
1955 payload.length() > DM_STRING_LENGTH_MAX) {
1956 LOGE("CreatePinHolder error: Invalid para, pkgName: %{public}s, pinType: %{public}d, payload.length:"
1957 "%{public}zu", pkgName.c_str(), pinType, payload.length());
1958 return ERR_DM_INPUT_PARA_INVALID;
1959 }
1960 std::shared_ptr<IpcCreatePinHolderReq> req = std::make_shared<IpcCreatePinHolderReq>();
1961 req->SetPkgName(pkgName);
1962 req->SetPeerTargetId(targetId);
1963 req->SetPinType(pinType);
1964 req->SetPayload(payload);
1965 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1966
1967 int32_t ret = ipcClientProxy_->SendRequest(CREATE_PIN_HOLDER, req, rsp);
1968 if (ret != DM_OK) {
1969 LOGI("CreatePinHolder Send Request failed ret: %{public}d", ret);
1970 return ERR_DM_IPC_SEND_REQUEST_FAILED;
1971 }
1972 ret = rsp->GetErrCode();
1973 if (ret != DM_OK) {
1974 LOGE("CreatePinHolder Failed with ret %{public}d", ret);
1975 return ret;
1976 }
1977 return DM_OK;
1978 }
1979
DestroyPinHolder(const std::string & pkgName,const PeerTargetId & targetId,DmPinType pinType,const std::string & payload)1980 int32_t DeviceManagerImpl::DestroyPinHolder(const std::string &pkgName, const PeerTargetId &targetId,
1981 DmPinType pinType, const std::string &payload)
1982 {
1983 if (pkgName.empty() || IsInvalidPeerTargetId(targetId) ||
1984 pinType > DmPinType::SUPER_SONIC || pinType < DmPinType::NUMBER_PIN_CODE ||
1985 payload.length() > DM_STRING_LENGTH_MAX) {
1986 LOGE("DestroyPinHolder error: Invalid para, pkgName: %{public}s, pinType: %{public}d, payload.length"
1987 "%{public}zu", pkgName.c_str(), pinType, payload.length());
1988 return ERR_DM_INPUT_PARA_INVALID;
1989 }
1990 std::shared_ptr<IpcDestroyPinHolderReq> req = std::make_shared<IpcDestroyPinHolderReq>();
1991 req->SetPkgName(pkgName);
1992 req->SetPeerTargetId(targetId);
1993 req->SetPinType(pinType);
1994 req->SetPayload(payload);
1995 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
1996
1997 int32_t ret = ipcClientProxy_->SendRequest(DESTROY_PIN_HOLDER, req, rsp);
1998 if (ret != DM_OK) {
1999 LOGI("DestroyPinHolder Send Request failed ret: %{public}d", ret);
2000 return ERR_DM_IPC_SEND_REQUEST_FAILED;
2001 }
2002 ret = rsp->GetErrCode();
2003 if (ret != DM_OK) {
2004 LOGE("DestroyPinHolder Failed with ret %{public}d", ret);
2005 return ret;
2006 }
2007 return DM_OK;
2008 }
2009
DpAclAdd(const int64_t accessControlId,const std::string & udid,const int32_t bindType)2010 int32_t DeviceManagerImpl::DpAclAdd(const int64_t accessControlId, const std::string &udid, const int32_t bindType)
2011 {
2012 LOGI("Start.");
2013 if (bindType != IDENTICAL_ACCOUNT) {
2014 LOGI("DeviceManagerImpl::DpAclAdd is not identical account");
2015 return DM_OK;
2016 }
2017 std::shared_ptr<IpcAclProfileReq> req = std::make_shared<IpcAclProfileReq>();
2018 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
2019 req->SetStr(udid);
2020 int32_t ret = ipcClientProxy_->SendRequest(DP_ACL_ADD, req, rsp);
2021 if (ret != DM_OK) {
2022 LOGE("DpAclAdd error: Send Request failed ret: %{public}d", ret);
2023 return ERR_DM_IPC_SEND_REQUEST_FAILED;
2024 }
2025 ret = rsp->GetErrCode();
2026 if (ret != DM_OK) {
2027 LOGE("DpAclAdd error: Failed with ret %{public}d", ret);
2028 return ret;
2029 }
2030 LOGI("Completed");
2031 return DM_OK;
2032 }
2033
GetDeviceSecurityLevel(const std::string & pkgName,const std::string & networkId,int32_t & securityLevel)2034 int32_t DeviceManagerImpl::GetDeviceSecurityLevel(const std::string &pkgName, const std::string &networkId,
2035 int32_t &securityLevel)
2036 {
2037 if (pkgName.empty() || networkId.empty()) {
2038 LOGE("DeviceManagerImpl::GetDeviceSecurityLevel error: pkgName: %{public}s, networkId: %{public}s",
2039 pkgName.c_str(), GetAnonyString(networkId).c_str());
2040 return ERR_DM_INPUT_PARA_INVALID;
2041 }
2042 LOGI("Start: pkgName: %{public}s, networkId: %{public}s", pkgName.c_str(),
2043 GetAnonyString(networkId).c_str());
2044
2045 std::shared_ptr<IpcGetInfoByNetWorkReq> req = std::make_shared<IpcGetInfoByNetWorkReq>();
2046 std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>();
2047 req->SetPkgName(pkgName);
2048 req->SetNetWorkId(networkId);
2049
2050 int32_t ret = ipcClientProxy_->SendRequest(GET_SECURITY_LEVEL, req, rsp);
2051 if (ret != DM_OK) {
2052 LOGE("GetDeviceSecurityLevel Send Request failed ret: %{public}d", ret);
2053 return ERR_DM_IPC_SEND_REQUEST_FAILED;
2054 }
2055
2056 ret = rsp->GetErrCode();
2057 if (ret != DM_OK) {
2058 LOGE("GetDeviceSecurityLevel Failed with ret %{public}d", ret);
2059 return ret;
2060 }
2061 securityLevel = rsp->GetSecurityLevel();
2062 return DM_OK;
2063 }
2064
CheckApiPermission(int32_t permissionLevel)2065 int32_t DeviceManagerImpl::CheckApiPermission(int32_t permissionLevel)
2066 {
2067 LOGI("PermissionLevel: %{public}d", permissionLevel);
2068 std::shared_ptr<IpcPermissionReq> req = std::make_shared<IpcPermissionReq>();
2069 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
2070 req->SetPermissionLevel(permissionLevel);
2071 int32_t ret = ipcClientProxy_->SendRequest(CHECK_API_PERMISSION, req, rsp);
2072 if (ret != DM_OK) {
2073 LOGE("Send Request failed ret: %{public}d", ret);
2074 return ERR_DM_IPC_SEND_REQUEST_FAILED;
2075 }
2076
2077 ret = rsp->GetErrCode();
2078 if (ret != DM_OK) {
2079 LOGE("Check permission failed with ret: %{public}d", ret);
2080 return ret;
2081 }
2082 LOGD("The caller declare the DM permission!");
2083 return DM_OK;
2084 }
2085
IsSameAccount(const std::string & netWorkId)2086 bool DeviceManagerImpl::IsSameAccount(const std::string &netWorkId)
2087 {
2088 if (netWorkId.empty()) {
2089 LOGE("DeviceManagerImpl::IsSameAccount error: netWorkId: %{public}s", GetAnonyString(netWorkId).c_str());
2090 return false;
2091 }
2092 std::shared_ptr<IpcAclProfileReq> req = std::make_shared<IpcAclProfileReq>();
2093 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
2094 req->SetStr(netWorkId);
2095 int32_t ret = ipcClientProxy_->SendRequest(IS_SAME_ACCOUNT, req, rsp);
2096 if (ret != DM_OK) {
2097 LOGE("IsSameAccount Send Request failed ret: %{public}d", ret);
2098 return false;
2099 }
2100 ret = rsp->GetErrCode();
2101 if (ret != DM_OK) {
2102 LOGE("IsSameAccount Failed with ret: %{public}d", ret);
2103 return false;
2104 }
2105 return true;
2106 }
2107
CheckAccessControl(const DmAccessCaller & caller,const DmAccessCallee & callee)2108 bool DeviceManagerImpl::CheckAccessControl(const DmAccessCaller &caller, const DmAccessCallee &callee)
2109 {
2110 LOGI("Start");
2111 std::shared_ptr<IpcCheckAcl> req = std::make_shared<IpcCheckAcl>();
2112 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
2113 req->SetAccessCaller(caller);
2114 req->SetAccessCallee(callee);
2115 int32_t ret = ipcClientProxy_->SendRequest(CHECK_ACCESS_CONTROL, req, rsp);
2116 if (ret != DM_OK) {
2117 LOGE("CheckAccessControl Send Request failed ret: %{public}d", ret);
2118 return false;
2119 }
2120 ret = rsp->GetErrCode();
2121 if (ret != DM_OK) {
2122 LOGE("CheckAccessControl Failed with ret: %{public}d", ret);
2123 return false;
2124 }
2125 return true;
2126 }
2127
CheckIsSameAccount(const DmAccessCaller & caller,const DmAccessCallee & callee)2128 bool DeviceManagerImpl::CheckIsSameAccount(const DmAccessCaller &caller, const DmAccessCallee &callee)
2129 {
2130 LOGI("Start");
2131 std::shared_ptr<IpcCheckAcl> req = std::make_shared<IpcCheckAcl>();
2132 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
2133 req->SetAccessCaller(caller);
2134 req->SetAccessCallee(callee);
2135 int32_t ret = ipcClientProxy_->SendRequest(CHECK_SAME_ACCOUNT, req, rsp);
2136 if (ret != DM_OK) {
2137 LOGE("CheckIsSameAccount Send Request failed ret: %{public}d", ret);
2138 return false;
2139 }
2140 ret = rsp->GetErrCode();
2141 if (ret != DM_OK) {
2142 LOGE("CheckIsSameAccount Failed with ret: %{public}d", ret);
2143 return false;
2144 }
2145 return true;
2146 }
2147
GetErrCode(int32_t errCode)2148 int32_t DeviceManagerImpl::GetErrCode(int32_t errCode)
2149 {
2150 auto flag = MAP_ERROR_CODE.find(errCode);
2151 if (flag == MAP_ERROR_CODE.end()) {
2152 return errCode;
2153 }
2154 return flag->second;
2155 }
2156
ShiftLNNGear(const std::string & pkgName)2157 int32_t DeviceManagerImpl::ShiftLNNGear(const std::string &pkgName)
2158 {
2159 LOGI("Start. pkgName = %{public}s", pkgName.c_str());
2160 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
2161 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
2162 req->SetPkgName(pkgName);
2163 int32_t ret = ipcClientProxy_->SendRequest(SHIFT_LNN_GEAR, req, rsp);
2164 if (ret != DM_OK) {
2165 LOGE("ShiftLNNGear error: Send Request failed ret: %{public}d", ret);
2166 return ERR_DM_IPC_SEND_REQUEST_FAILED;
2167 }
2168 ret = rsp->GetErrCode();
2169 if (ret != DM_OK) {
2170 LOGE("ShiftLNNGear error: Failed with ret %{public}d", ret);
2171 return ret;
2172 }
2173 LOGI("Completed");
2174 return DM_OK;
2175 }
2176
SetDnPolicy(const std::string & pkgName,std::map<std::string,std::string> & policy)2177 int32_t DeviceManagerImpl::SetDnPolicy(const std::string &pkgName, std::map<std::string, std::string> &policy)
2178 {
2179 const size_t SET_DN_POLICY_PARAM_SIZE = 2;
2180 if (pkgName.empty() || policy.size() != SET_DN_POLICY_PARAM_SIZE) {
2181 LOGE("Para invalid: policy is less than two or pkgName is empty.");
2182 return ERR_DM_INPUT_PARA_INVALID;
2183 }
2184 LOGI("Start");
2185 std::string strategy = ConvertMapToJsonString(policy);
2186
2187 std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
2188 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
2189 req->SetPkgName(pkgName);
2190 req->SetFirstParam(strategy);
2191 int32_t ret = ipcClientProxy_->SendRequest(SET_DN_POLICY, req, rsp);
2192 if (ret != DM_OK) {
2193 LOGE("Send Request failed ret: %{public}d", ret);
2194 return ERR_DM_IPC_SEND_REQUEST_FAILED;
2195 }
2196 ret = rsp->GetErrCode();
2197 if (ret != DM_OK) {
2198 LOGE("Failed with ret %{public}d", ret);
2199 return ret;
2200 }
2201 LOGI("Completed");
2202 return DM_OK;
2203 }
2204
GetNetworkIdByUdid(const std::string & pkgName,const std::string & udid,std::string & networkId)2205 int32_t DeviceManagerImpl::GetNetworkIdByUdid(const std::string &pkgName, const std::string &udid,
2206 std::string &networkId)
2207 {
2208 if (pkgName.empty() || udid.empty()) {
2209 LOGE("DeviceManagerImpl::GetNetworkIdByUdid error: Invalid para, pkgName: %{public}s, udid: %{public}s",
2210 pkgName.c_str(), GetAnonyString(udid).c_str());
2211 return ERR_DM_INPUT_PARA_INVALID;
2212 }
2213 LOGD("Start, pkgName: %{public}s", GetAnonyString(pkgName).c_str());
2214
2215 std::shared_ptr<IpcGetInfoByNetWorkReq> req = std::make_shared<IpcGetInfoByNetWorkReq>();
2216 std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>();
2217 req->SetPkgName(pkgName);
2218 req->SetUdid(udid);
2219
2220 int32_t ret = ipcClientProxy_->SendRequest(GET_NETWORKID_BY_UDID, req, rsp);
2221 if (ret != DM_OK) {
2222 LOGI("GetNetworkIdByUdid Send Request failed ret: %{public}d", ret);
2223 return ERR_DM_IPC_SEND_REQUEST_FAILED;
2224 }
2225
2226 ret = rsp->GetErrCode();
2227 if (ret != DM_OK) {
2228 LOGE("GetNetworkIdByUdid Failed with ret %{public}d", ret);
2229 return ret;
2230 }
2231 networkId = rsp->GetNetWorkId();
2232 return DM_OK;
2233 }
2234
RegisterDeviceScreenStatusCallback(const std::string & pkgName,std::shared_ptr<DeviceScreenStatusCallback> callback)2235 int32_t DeviceManagerImpl::RegisterDeviceScreenStatusCallback(const std::string &pkgName,
2236 std::shared_ptr<DeviceScreenStatusCallback> callback)
2237 {
2238 if (pkgName.empty() || callback == nullptr) {
2239 LOGE("Error: Invalid para");
2240 return ERR_DM_INPUT_PARA_INVALID;
2241 }
2242 DeviceManagerNotify::GetInstance().RegisterDeviceScreenStatusCallback(pkgName, callback);
2243 LOGI("Completed, pkgName: %{public}s", pkgName.c_str());
2244 return DM_OK;
2245 }
2246
UnRegisterDeviceScreenStatusCallback(const std::string & pkgName)2247 int32_t DeviceManagerImpl::UnRegisterDeviceScreenStatusCallback(const std::string &pkgName)
2248 {
2249 if (pkgName.empty()) {
2250 LOGE("Error: Invalid para");
2251 return ERR_DM_INPUT_PARA_INVALID;
2252 }
2253 DeviceManagerNotify::GetInstance().UnRegisterDeviceScreenStatusCallback(pkgName);
2254 LOGI("Completed, pkgName: %{public}s", pkgName.c_str());
2255 return DM_OK;
2256 }
2257
GetDeviceScreenStatus(const std::string & pkgName,const std::string & networkId,int32_t & screenStatus)2258 int32_t DeviceManagerImpl::GetDeviceScreenStatus(const std::string &pkgName, const std::string &networkId,
2259 int32_t &screenStatus)
2260 {
2261 if (pkgName.empty() || networkId.empty()) {
2262 LOGE("Error: Invalid para");
2263 return ERR_DM_INPUT_PARA_INVALID;
2264 }
2265 LOGI("Start: pkgName: %{public}s, networkId: %{public}s", pkgName.c_str(), GetAnonyString(networkId).c_str());
2266
2267 std::shared_ptr<IpcGetDeviceScreenStatusReq> req = std::make_shared<IpcGetDeviceScreenStatusReq>();
2268 std::shared_ptr<IpcGetDeviceScreenStatusRsp> rsp = std::make_shared<IpcGetDeviceScreenStatusRsp>();
2269 req->SetPkgName(pkgName);
2270 req->SetNetWorkId(networkId);
2271
2272 int32_t ret = ipcClientProxy_->SendRequest(GET_DEVICE_SCREEN_STATUS, req, rsp);
2273 if (ret != DM_OK) {
2274 LOGE("Send Request failed ret: %{public}d", ret);
2275 return ERR_DM_IPC_SEND_REQUEST_FAILED;
2276 }
2277
2278 ret = rsp->GetErrCode();
2279 if (ret != DM_OK) {
2280 LOGE("Failed with ret %{public}d", ret);
2281 return ret;
2282 }
2283 screenStatus = rsp->GetScreenStatus();
2284 return DM_OK;
2285 }
2286
RegisterCredentialAuthStatusCallback(const std::string & pkgName,std::shared_ptr<CredentialAuthStatusCallback> callback)2287 int32_t DeviceManagerImpl::RegisterCredentialAuthStatusCallback(const std::string &pkgName,
2288 std::shared_ptr<CredentialAuthStatusCallback> callback)
2289 {
2290 if (pkgName.empty() || callback == nullptr) {
2291 LOGE("Error: Invalid para");
2292 return ERR_DM_INPUT_PARA_INVALID;
2293 }
2294 DeviceManagerNotify::GetInstance().RegisterCredentialAuthStatusCallback(pkgName, callback);
2295 LOGI("Completed, pkgName: %{public}s", pkgName.c_str());
2296 return DM_OK;
2297 }
2298
UnRegisterCredentialAuthStatusCallback(const std::string & pkgName)2299 int32_t DeviceManagerImpl::UnRegisterCredentialAuthStatusCallback(const std::string &pkgName)
2300 {
2301 if (pkgName.empty()) {
2302 LOGE("Error: Invalid para");
2303 return ERR_DM_INPUT_PARA_INVALID;
2304 }
2305 DeviceManagerNotify::GetInstance().UnRegisterCredentialAuthStatusCallback(pkgName);
2306 LOGI("Completed, pkgName: %{public}s", pkgName.c_str());
2307 return DM_OK;
2308 }
2309 } // namespace DistributedHardware
2310 } // namespace OHOS