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