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