1 /*
2  * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef OHOS_DEVICE_MANAGER_H
17 #define OHOS_DEVICE_MANAGER_H
18 
19 #include <map>
20 #include <memory>
21 #include <string>
22 #include <vector>
23 
24 #include "device_manager_callback.h"
25 #include "dm_device_info.h"
26 #include "dm_publish_info.h"
27 #include "dm_subscribe_info.h"
28 
29 namespace OHOS {
30 namespace DistributedHardware {
31 class DeviceManager {
32 public:
33     static DeviceManager &GetInstance();
34 
35 public:
36     /**
37      * @brief Initialize DeviceManager.
38      * @param pkgName        package name.
39      * @param dmInitCallback the callback to be invoked upon InitDeviceManager.
40      * @return Returns 0 if success.
41      */
42     virtual int32_t InitDeviceManager(const std::string &pkgName, std::shared_ptr<DmInitCallback> dmInitCallback) = 0;
43     /**
44      * @brief UnInitialize DeviceManager.
45      * @param pkgName package name.
46      * @return Returns 0 if success.
47      */
48     virtual int32_t UnInitDeviceManager(const std::string &pkgName) = 0;
49     /**
50      * @brief Get device info list of trusted devices.
51      * @param pkgName    package name.
52      * @param extra      extra info.This parameter can be null.
53      * @param deviceList device info list.
54      * @return Returns a list of trusted devices.
55      */
56     virtual int32_t GetTrustedDeviceList(const std::string &pkgName, const std::string &extra,
57         std::vector<DmDeviceInfo> &deviceList) = 0;
58     /**
59      * @brief Get device info list of trusted devices.
60      * @param pkgName    package name.
61      * @param extra      extra info.This parameter can be null.
62      * @param isRefresh  refresh the list quickly.
63      * @param deviceList device info list.
64      * @return Returns a list of trusted devices.
65      */
66     virtual int32_t GetTrustedDeviceList(const std::string &pkgName, const std::string &extra,
67         bool isRefresh, std::vector<DmDeviceInfo> &deviceList) = 0;
68 	/**
69      * @brief Get device info list of available devices.
70      * @param pkgName    package name.
71      * @param extra      extra info.This parameter can be null.
72      * @param deviceList device info list.
73      * @return Returns a list of available devices.
74      */
75     virtual int32_t GetAvailableDeviceList(const std::string &pkgName,
76         std::vector<DmDeviceBasicInfo> &deviceList) = 0;
77     /**
78      * @brief Get local device information.
79      * @param pkgName    package name.
80      * @param deviceInfo device info.
81      * @return Returns local device info.
82      */
83     virtual int32_t GetLocalDeviceInfo(const std::string &pkgName, DmDeviceInfo &deviceInfo) = 0;
84     /**
85      * @tc.name: DeviceManagerImpl::GetDeviceInfo
86      * @tc.desc: Get local device information by networkId
87      * @tc.type: FUNC
88      */
89     virtual int32_t GetDeviceInfo(const std::string &pkgName, const std::string networkId,
90         DmDeviceInfo &deviceInfo) = 0;
91     /**
92      * @brief Register device status callback.
93      * @param pkgName  package name.
94      * @param extra    extra info.This parameter can be null.
95      * @param callback device state callback.
96      * @return Returns 0 if success.
97      */
98     virtual int32_t RegisterDevStateCallback(const std::string &pkgName, const std::string &extra,
99         std::shared_ptr<DeviceStateCallback> callback) = 0;
100     /**
101      * @brief Register device status callback.
102      * @param pkgName  package name.
103      * @param callback device status callback.
104      * @return Returns 0 if success.
105      */
106     virtual int32_t RegisterDevStatusCallback(const std::string &pkgName, const std::string &extra,
107         std::shared_ptr<DeviceStatusCallback> callback) = 0;
108     /**
109      * @brief Unregister device status callback.
110      * @param pkgName package name.
111      * @return Returns 0 if success.
112      */
113     virtual int32_t UnRegisterDevStateCallback(const std::string &pkgName) = 0;
114     /**
115      * @brief Unregister device status callback.
116      * @param pkgName package name.
117      * @return Returns 0 if success.
118      */
119     virtual int32_t UnRegisterDevStatusCallback(const std::string &pkgName) = 0;
120     /**
121      * @brief Initiate device discovery.
122      * @param pkgName       package name.
123      * @param subscribeInfo subscribe info to discovery device.
124      * @param extra         extra info.This parameter can be null.
125      * @param callback      discovery callback.
126      * @return Returns 0 if success.
127      */
128     virtual int32_t StartDeviceDiscovery(const std::string &pkgName, const DmSubscribeInfo &subscribeInfo,
129         const std::string &extra, std::shared_ptr<DiscoveryCallback> callback) = 0;
130     /**
131      * @brief Initiate device discovery.
132      * @param pkgName       package name.
133      * @param subscribeId subscribe id to discovery device.
134      * @param extra         extra info.This parameter can be null.
135      * @param callback      discovery callback.
136      * @return Returns 0 if success.
137      */
138     virtual int32_t StartDeviceDiscovery(const std::string &pkgName, uint64_t tokenId,
139         const std::string &filterOptions, std::shared_ptr<DiscoveryCallback> callback) = 0;
140     /**
141      * @brief Stop device discovery.
142      * @param pkgName       package name.
143      * @param subscribeInfo subscribe info to discovery device.
144      * @return Returns 0 if success.
145      */
146     virtual int32_t StopDeviceDiscovery(const std::string &pkgName, uint16_t subscribeId) = 0;
147     /**
148      * @brief Stop device discovery.
149      * @param pkgName package name.
150      * @param tokenId app flag to discovery device.
151      * @return Returns 0 if success.
152      */
153     virtual int32_t StopDeviceDiscovery(uint64_t tokenId, const std::string &pkgName) = 0;
154     /**
155      * @brief Publish device discovery.
156      * @param pkgName     package name.
157      * @param publishInfo publish info to Publish discovery device.
158      * @param callback    the callback to be invoked upon PublishDeviceDiscovery.
159      * @return Returns 0 if success.
160      */
161     virtual int32_t PublishDeviceDiscovery(const std::string &pkgName, const DmPublishInfo &publishInfo,
162         std::shared_ptr<PublishCallback> callback) = 0;
163     /**
164      * @brief UnPublish device discovery.
165      * @param pkgName   package name.
166      * @param publishId service publish ID, identify a publish operation, should be a unique id in package range.
167      * @return Returns 0 if success.
168      */
169     virtual int32_t UnPublishDeviceDiscovery(const std::string &pkgName, int32_t publishId) = 0;
170     /**
171      * @brief Authenticate the specified device.
172      * @param pkgName    package name.
173      * @param authType   authType of device to authenticate.
174      * @param deviceInfo deviceInfo of device to authenticate.
175      * @param extra      extra info.This parameter can be null.
176      * @param callback   the callback to be invoked upon AuthenticateDevice.
177      * @return Returns 0 if success.
178      */
179     virtual int32_t AuthenticateDevice(const std::string &pkgName, int32_t authType, const DmDeviceInfo &deviceInfo,
180         const std::string &extra, std::shared_ptr<AuthenticateCallback> callback) = 0;
181     /**
182      * @brief Cancel complete verification of device.
183      * @param pkgName    package name.
184      * @param deviceInfo deviceInfo of device to authenticate.
185      * @return Returns 0 if success.
186      */
187     virtual int32_t UnAuthenticateDevice(const std::string &pkgName, const DmDeviceInfo &deviceInfo) = 0;
188     /**
189      * @brief Verify device authentication.
190      * @param pkgName  package name.
191      * @param authPara authPara of device to authenticate.
192      * @param callback the callback to be invoked upon VerifyAuthentication.
193      * @return Returns 0 if success.
194      */
195     [[deprecated]] virtual int32_t VerifyAuthentication(const std::string &pkgName, const std::string &authPara,
196         std::shared_ptr<VerifyAuthCallback> callback) = 0;
197     /**
198      * @brief Register Fa callback for device manager.
199      * @param pkgName  package name.
200      * @param callback device manager Fa callback.
201      * @return Returns 0 if success.
202      */
203     virtual int32_t RegisterDeviceManagerFaCallback(const std::string &pkgName,
204         std::shared_ptr<DeviceManagerUiCallback> callback) = 0;
205     /**
206      * @brief Unregister Fa callback for device manager.
207      * @param pkgName package name.
208      * @return Returns 0 if success.
209      */
210     virtual int32_t UnRegisterDeviceManagerFaCallback(const std::string &pkgName) = 0;
211     /**
212      * @brief Get Fa Param.
213      * @param pkgName package name.
214      * @param faParam fa param.
215      * @return Returns 0 if success.
216      */
217     [[deprecated]] virtual int32_t GetFaParam(const std::string &pkgName, DmAuthParam &faParam) = 0;
218     /**
219      * @brief Set User Actions.
220      * @param pkgName package name.
221      * @param action  user operation action.
222      * @param params  indicates the input param of the user.
223      * @return Returns 0 if success.
224      */
225     virtual int32_t SetUserOperation(const std::string &pkgName, int32_t action, const std::string &params) = 0;
226     /**
227      * @brief Get Udid by NetworkId.
228      * @param pkgName   package name.
229      * @param netWorkId netWork Id.
230      * @param udid      unique device id.
231      * @return Returns 0 if success.
232      */
233     virtual int32_t GetUdidByNetworkId(const std::string &pkgName, const std::string &netWorkId, std::string &udid) = 0;
234     /**
235      * @brief Get Uuid by NetworkId.
236      * @param pkgName   package name.
237      * @param netWorkId netWork Id.
238      * @param uuid      universally unique id.
239      * @return Returns 0 if success.
240      */
241     virtual int32_t GetUuidByNetworkId(const std::string &pkgName, const std::string &netWorkId, std::string &uuid) = 0;
242     /**
243      * @brief Unregister device status callback.
244      * @param pkgName package name.
245      * @param extra   extra info.This parameter can be null.
246      * @return Returns 0 if success.
247      */
248     [[deprecated]] virtual int32_t RegisterDevStateCallback(const std::string &pkgName,
249         const std::string &extra) = 0;
250     /**
251      * @brief Unregister device status callback.
252      * @param pkgName package name.
253      * @param extra   extra info.This parameter can be null.
254      * @return Returns 0 if success.
255      */
256     [[deprecated]] virtual int32_t UnRegisterDevStateCallback(const std::string &pkgName,
257         const std::string &extra) = 0;
258     /**
259      * @brief Request credential information.
260      * @param pkgName       package name.
261      * @param reqJsonStr    request credential params, the params is json string, it includes version and userId.
262      * @param returnJsonStr return json string, it includes deviceId, devicePk, useId and version.
263      * @return Returns 0 if success.
264      */
265     [[deprecated]] virtual int32_t RequestCredential(const std::string &pkgName, const std::string &reqJsonStr,
266         std::string &returnJsonStr) = 0;
267     /**
268      * @brief Import credential information.
269      * @param pkgName        package name.
270      * @param credentialInfo import credential params, the params is json string, it includes processType, authType,
271      * userId, deviceId, version, devicePk and credentialData, the credentialData is array, each array element
272      * includes credentialType, credentialId, serverPk, pkInfoSignature, pkInfo, authCode, peerDeviceId.
273      * @return Returns 0 if success.
274      */
275     [[deprecated]] virtual int32_t ImportCredential(const std::string &pkgName,
276         const std::string &credentialInfo) = 0;
277     /**
278      * @brief Delete credential information.
279      * @param pkgName    package name.
280      * @param deleteInfo delete credential params. the params is json string, it includes processType, authType, userId.
281      * @return Returns 0 if success.
282      */
283     [[deprecated]] virtual int32_t DeleteCredential(const std::string &pkgName, const std::string &deleteInfo) = 0;
284     /**
285      * @brief Register credential callback.
286      * @param pkgName  package name.
287      * @param callback credential callback.
288      * @return Returns 0 if success.
289      */
290     [[deprecated]] virtual int32_t RegisterCredentialCallback(const std::string &pkgName,
291         std::shared_ptr<CredentialCallback> callback) = 0;
292     /**
293      * @brief UnRegister credential callback.
294      * @param pkgName package name.
295      * @return Returns 0 if success.
296      */
297     [[deprecated]] virtual int32_t UnRegisterCredentialCallback(const std::string &pkgName) = 0;
298     /**
299      * @brief Notify event to device manager.
300      * @param pkgName package name.
301      * @param event   event info.
302      * @param event   event string.
303      * @return Returns 0 if success.
304      */
305     virtual int32_t NotifyEvent(const std::string &pkgName, const int32_t eventId, const std::string &event) = 0;
306 
307     /**
308      * @brief Get encrypted uuid.
309      * @param networkId device networkId.
310      * @return Returns encrypted uuid.
311      */
312     virtual int32_t GetEncryptedUuidByNetworkId(const std::string &pkgName, const std::string &networkId,
313         std::string &uuid) = 0;
314 
315     /**
316      * @brief Get encrypted uuid.
317      * @param uuid device uuid.
318      * @param tokenId tokenId.
319      * @return Returns encrypted uuid.
320      */
321     virtual int32_t GenerateEncryptedUuid(const std::string &pkgName, const std::string &uuid, const std::string &appId,
322         std::string &encryptedUuid) = 0;
323 
324     /**
325      * @tc.name: DeviceManagerImpl::CheckAPIAccessPermission
326      * @tc.desc: check permission for device manager API
327      * @tc.type: FUNC
328      */
329     virtual int32_t CheckAPIAccessPermission() = 0;
330 
331     /**
332      * @brief Get local device netWorkId.
333      * @param pkgName package name.
334      * @return Returns local device networkId.
335      */
336     virtual int32_t GetLocalDeviceNetWorkId(const std::string &pkgName, std::string &networkId) = 0;
337 
338     /**
339      * @brief Get local deviceId.
340      * @param pkgName package name.
341      * @return Returns local deviceId.
342      */
343     virtual int32_t GetLocalDeviceId(const std::string &pkgName, std::string &networkId) = 0;
344 
345     /**
346      * @brief Get local device name.
347      * @param pkgName package name.
348      * @return Returns device name.
349      */
350     virtual int32_t GetLocalDeviceName(const std::string &pkgName, std::string &deviceName) = 0;
351 
352     /**
353      * @brief Get local device type.
354      * @param pkgName package name.
355      * @return Returns device type.
356      */
357     virtual int32_t GetLocalDeviceType(const std::string &pkgName, int32_t &deviceType) = 0;
358 
359     /**
360      * @brief Get device name.
361      * @param pkgName package name.
362      * @param networkId device networkId.
363      * @return Returns device name.
364      */
365     virtual int32_t GetDeviceName(const std::string &pkgName, const std::string &networkId,
366         std::string &deviceName) = 0;
367 
368     /**
369      * @brief Get device type.
370      * @param pkgName package name.
371      * @param networkId device networkId.
372      * @return Returns device type.
373      */
374     virtual int32_t GetDeviceType(const std::string &pkgName, const std::string &networkId, int32_t &deviceType) = 0;
375 
376     /**
377      * @brief Bind the specified device.
378      * @param pkgName    package name.
379      * @param bindType   bindType of device to bind.
380      * @param deviceInfo device id of device to bind.
381      * @param extra      extra info.This parameter can be null.
382      * @param callback   callback.
383      * @return Returns 0 if success.
384      */
385     virtual int32_t BindDevice(const std::string &pkgName, int32_t bindType, const std::string &deviceId,
386         const std::string &extra, std::shared_ptr<AuthenticateCallback> callback) = 0;
387 
388     /**
389      * @brief UnBind the specified device.
390      * @param pkgName    package name.
391      * @param deviceId device id to UnBindDevice.
392      * @return Returns 0 if success.
393      */
394     virtual int32_t UnBindDevice(const std::string &pkgName, const std::string &deviceId) = 0;
395 
396     virtual int32_t CheckNewAPIAccessPermission() = 0;
397 
398     /**
399      * @brief Get Network Type by NetworkId.
400      * @param pkgName   package name.
401      * @param netWorkId netWork Id.
402      * @param netWorkType netWork Type.
403      * @return Returns 0 if success.
404      */
405     virtual int32_t GetNetworkTypeByNetworkId(const std::string &pkgName,
406         const std::string &netWorkId, int32_t &netWorkType) = 0;
407 
408     /**
409      * @brief Import Auth Code.
410      * @param pkgName  BindDevice caller package name.
411      * @param authCode  Authentication code.
412      * @return Returns 0 if success.
413      */
414     virtual int32_t ImportAuthCode(const std::string &pkgName, const std::string &authCode) = 0;
415 
416     /**
417      * @brief Export Auth Code.
418      * @param authCode  Authentication code.
419      * @return Returns 0 if success.
420      */
421     virtual int32_t ExportAuthCode(std::string &authCode) = 0;
422 
423     // The following interfaces are provided since OpenHarmony 4.1 Version.
424     /**
425      * @brief Start to discover nearby devices or services.
426      * @param pkgName       package name.
427      * @param discoverParam discover parameters.
428      * @param filterOptions filter option parameters.
429      * @param callback      discovery callback.
430      * @return Returns 0 if success.
431      */
432     virtual int32_t StartDiscovering(const std::string &pkgName, std::map<std::string, std::string> &discoverParam,
433         const std::map<std::string, std::string> &filterOptions, std::shared_ptr<DiscoveryCallback> callback) = 0;
434 
435     /**
436      * @brief Stop discovering nearby devices or services.
437      * @param pkgName       package name.
438      * @param discoverParam discover parameters.
439      * @return Returns 0 if success.
440      */
441     virtual int32_t StopDiscovering(const std::string &pkgName, std::map<std::string, std::string> &discoverParam) = 0;
442 
443     /**
444      * @brief Registerthe discovery callback.
445      * @param pkgName       package name.
446      * @param discoverParam discover parameters.
447      * @param filterOptions filter option parameters.
448      * @param callback      discovery callback.
449      * @return Returns 0 if success.
450      */
451     virtual int32_t RegisterDiscoveryCallback(const std::string &pkgName,
452         std::map<std::string, std::string> &discoverParam, const std::map<std::string, std::string> &filterOptions,
453         std::shared_ptr<DiscoveryCallback> callback) = 0;
454 
455     /**
456      * @brief UnRegisterthe discovery callback.
457      * @param pkgName       package name.
458      * @return Returns 0 if success.
459      */
460     virtual int32_t UnRegisterDiscoveryCallback(const std::string &pkgName) = 0;
461 
462     /**
463      * @brief Start to advertise the nearby devices or services.
464      * @param pkgName        package name.
465      * @param advertiseParam advertise parameters.
466      * @param callback       advertise callback.
467      * @return Returns 0 if success.
468      */
469     virtual int32_t StartAdvertising(const std::string &pkgName, std::map<std::string, std::string> &advertiseParam,
470         std::shared_ptr<PublishCallback> callback) = 0;
471 
472     /**
473      * @brief Stop to advertise the nearby devices or services.
474      * @param pkgName        package name.
475      * @param advertiseParam advertise parameters.
476      * @return Returns 0 if success.
477      */
478     virtual int32_t StopAdvertising(const std::string &pkgName, std::map<std::string, std::string> &advertiseParam) = 0;
479 
480     /**
481      * @brief Bind the specified target.
482      * @param pkgName    package name.
483      * @param targetId   id of target to bind.
484      * @param bindParam  bind parameters.
485      * @param callback   bind result callback.
486      * @return Returns 0 if success.
487      */
488     virtual int32_t BindTarget(const std::string &pkgName, const PeerTargetId &targetId,
489         std::map<std::string, std::string> &bindParam, std::shared_ptr<BindTargetCallback> callback) = 0;
490 
491     /**
492      * @brief Unbind the specified target.
493      * @param pkgName     package name.
494      * @param targetId    id of target to unbind.
495      * @param unbindParam unbind parameters.
496      * @param callback    bind result callback.
497      * @return Returns 0 if success.
498      */
499     virtual int32_t UnbindTarget(const std::string &pkgName, const PeerTargetId &targetId,
500         std::map<std::string, std::string> &unbindParam, std::shared_ptr<UnbindTargetCallback> callback) = 0;
501 
502     /**
503      * @brief Get device info list of trusted devices.
504      * @param pkgName        package name.
505      * @param filterOptions  filter option parameters.
506      * @param isRefresh      refresh the list quickly.
507      * @param deviceList     device info list.
508      * @return Returns a list of trusted devices.
509      */
510     virtual int32_t GetTrustedDeviceList(const std::string &pkgName,
511         const std::map<std::string, std::string> &filterOptions, bool isRefresh,
512         std::vector<DmDeviceInfo> &deviceList) = 0;
513 
514     /**
515      * @brief Register device state callback.
516      * @param pkgName     package name.
517      * @param extraParam  extra parameters.
518      * @param callback    device status callback.
519      * @return Returns 0 if success.
520      */
521     virtual int32_t RegisterDevStateCallback(const std::string &pkgName,
522         const std::map<std::string, std::string> &extraParam, std::shared_ptr<DeviceStateCallback> callback) = 0;
523 
524     /**
525      * @brief Check the specific caller whether has permission to access the target.
526      * @param tokenId  the caller token id.
527      * @param targetId the target id.
528      * @return Returns 0 if success.
529      */
530     virtual int32_t CheckAccessToTarget(uint64_t tokenId, const std::string &targetId) = 0;
531 
532     /**
533      * @brief Register Pin Code Holder Callback
534      * @param pkgName  package name.
535      * @param callback  the callback to be invoked upon CreateAuthCodeHolder or DestroyAuthCodeHolder.
536      * @return Returns 0 if success.
537      */
538     virtual int32_t RegisterPinHolderCallback(const std::string &pkgName,
539         std::shared_ptr<PinHolderCallback> callback) = 0;
540 
541     /**
542      * @brief Create Pin Code Holder
543      * @param pkgName  package name.
544      * @param targetId  id of target to create pin holder.
545      * @param pinType  pin code holder type.
546      * @param payload  business custom data.
547      * @return Returns 0 if success.
548      */
549     virtual int32_t CreatePinHolder(const std::string &pkgName, const PeerTargetId &targetId,
550         DmPinType pinType, const std::string &payload) = 0;
551 
552     /**
553      * @brief Destroy Pin Code Holder
554      * @param pkgName  package name.
555      * @param targetId  id of target to destroy pin holder.
556      * @param pinType  pin code holder type.
557      * @param payload  business custom data.
558      * @return Returns 0 if success.
559      */
560     virtual int32_t DestroyPinHolder(const std::string &pkgName, const PeerTargetId &targetId,
561         DmPinType pinType, const std::string &payload) = 0;
562 
563     /**
564     * @brief Request credential information.
565     * @param pkgName       package name.
566     * @param returnJsonStr return json string, it includes deviceId, devicePk, useId and version.
567     * @return Returns 0 if success.
568     */
569     virtual int32_t RequestCredential(const std::string &pkgName, std::string &returnJsonStr) = 0;
570 
571     /**
572      * @brief Check credential information.
573      * @param pkgName       package name.
574      * @param reqJsonStr    request credential params, the params is json string, it includes version and userId.
575      * @param returnJsonStr return json string, it includes deviceId, devicePk, useId and version.
576      * @return Returns 0 if success.
577      */
578     virtual int32_t CheckCredential(const std::string &pkgName, const std::string &reqJsonStr,
579                                     std::string &returnJsonStr) = 0;
580 
581     /**
582      * @brief Import credential information.
583      * @param pkgName       package name.
584      * @param reqJsonStr    request credential params, the params is json string, it includes version and userId.
585      * @param returnJsonStr return json string, it includes deviceId, devicePk, useId and version.
586      * @return Returns 0 if success.
587      */
588     virtual int32_t ImportCredential(const std::string &pkgName, const std::string &reqJsonStr,
589                                      std::string &returnJsonStr) = 0;
590 
591     /**
592      * @brief Delete credential information.
593      * @param pkgName       package name.
594      * @param reqJsonStr    request credential params, the params is json string, it includes version and userId.
595      * @param returnJsonStr return json string, it includes deviceId, devicePk, useId and version.
596      * @return Returns 0 if success.
597      */
598     virtual int32_t DeleteCredential(const std::string &pkgName, const std::string &reqJsonStr,
599                                      std::string &returnJsonStr) = 0;
600 
601     virtual int32_t DpAclAdd(const int64_t accessControlId, const std::string &udid, const int32_t bindType) = 0;
602     virtual int32_t GetDeviceSecurityLevel(const std::string &pkgName, const std::string &networkId,
603                                            int32_t &securityLevel) = 0;
604     virtual bool IsSameAccount(const std::string &netWorkId) = 0;
605     virtual bool CheckAccessControl(const DmAccessCaller &caller, const DmAccessCallee &callee) = 0;
606     virtual bool CheckIsSameAccount(const DmAccessCaller &caller, const DmAccessCallee &callee) = 0;
607     virtual int32_t GetErrCode(int32_t errCode) = 0;
608     virtual int32_t ShiftLNNGear(const std::string &pkgName) = 0;
609     /**
610      * @brief Set Dn Policy
611      * @param pkgName  package name.
612      * @param policy contain DM_POLICY_STRATEGY_FOR_BLE and DM_POLICY_TIMEOUT key and value.
613      *               DM_POLICY_STRATEGY_FOR_BLE: Strategy BLE networking go-online policy, suppress or restore.
614      *               DM_POLICY_TIMEOUT: Indicates the duration for suppressing ble networking.
615      * @return Returns 0 if success.
616      */
617     virtual int32_t SetDnPolicy(const std::string &pkgName, std::map<std::string, std::string> &policy) = 0;
618     virtual int32_t StopAuthenticateDevice(const std::string &pkgName) = 0;
619     virtual int32_t GetNetworkIdByUdid(const std::string &pkgName, const std::string &udid, std::string &networkId) = 0;
620     virtual int32_t RegisterDeviceScreenStatusCallback(const std::string &pkgName,
621         std::shared_ptr<DeviceScreenStatusCallback> callback) = 0;
622     virtual int32_t UnRegisterDeviceScreenStatusCallback(const std::string &pkgName) = 0;
623     virtual int32_t GetDeviceScreenStatus(const std::string &pkgName, const std::string &networkId,
624         int32_t &screenStatus) = 0;
625     virtual int32_t RegisterCredentialAuthStatusCallback(const std::string &pkgName,
626         std::shared_ptr<CredentialAuthStatusCallback> callback) = 0;
627     virtual int32_t UnRegisterCredentialAuthStatusCallback(const std::string &pkgName) = 0;
628 };
629 } // namespace DistributedHardware
630 } // namespace OHOS
631 #endif // DEVICE_MANAGER_H