1 /*
2  * Copyright (c) 2022 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 <gtest/gtest.h>
17 #include <securec.h>
18 
19 #include "lnn_log.h"
20 #include "lnn_net_ledger_mock.h"
21 #include "softbus_adapter_mem.h"
22 #include "softbus_errcode.h"
23 
24 using namespace testing;
25 using namespace testing::ext;
26 
27 #define LNN_RELATION_JOIN_THREAD 1
28 #define LNN_MOCK_ONLINE_NODE_CNT 2
29 constexpr int64_t SEQ_LIST_1 = 1;
30 constexpr int64_t SEQ_LIST_2 = 2;
31 constexpr uint64_t AUTH_VERIFY_TIME_1 = 1000;
32 constexpr uint64_t AUTH_VERIFY_TIME_2 = 1001;
33 namespace OHOS {
34 
35 void *g_netLedgerinterface;
LnnNetLedgertInterfaceMock()36 LnnNetLedgertInterfaceMock::LnnNetLedgertInterfaceMock()
37 {
38     g_netLedgerinterface = reinterpret_cast<void *>(this);
39 }
40 
~LnnNetLedgertInterfaceMock()41 LnnNetLedgertInterfaceMock::~LnnNetLedgertInterfaceMock()
42 {
43     g_netLedgerinterface = nullptr;
44 }
45 
GetNetLedgerInterface()46 static LnnNetLedgerInterface *GetNetLedgerInterface()
47 {
48     return reinterpret_cast<LnnNetLedgerInterface *>(g_netLedgerinterface);
49 }
50 
ActionOfLnnGetAllOnline(NodeBasicInfo ** info,int32_t * infoNum)51 int32_t LnnNetLedgertInterfaceMock::ActionOfLnnGetAllOnline(NodeBasicInfo **info, int32_t *infoNum)
52 {
53     if (info == NULL || infoNum == NULL) {
54         LNN_LOGW(LNN_TEST, "invalid para");
55         return SOFTBUS_ERR;
56     }
57     *infoNum = 1;
58     *info = reinterpret_cast<NodeBasicInfo *>(SoftBusMalloc((*infoNum) * sizeof(NodeBasicInfo)));
59     if (*info == NULL) {
60         LNN_LOGI(LNN_TEST, "malloc info fail");
61         return SOFTBUS_ERR;
62     }
63     if (memcpy_s((*info)->networkId, sizeof((*info)->networkId), "abc", strlen("abc") + 1) != EOK) {
64         LNN_LOGI(LNN_TEST, "memcpy networkId fail");
65         return SOFTBUS_ERR;
66     }
67     return SOFTBUS_OK;
68 }
69 
ActionOfLnnConvertDlId(const char * srcId,IdCategory srcIdType,IdCategory dstIdType,char * dstIdBuf,uint32_t dstIdBufLen)70 int32_t LnnNetLedgertInterfaceMock::ActionOfLnnConvertDlId(const char *srcId, IdCategory srcIdType,
71     IdCategory dstIdType, char *dstIdBuf, uint32_t dstIdBufLen)
72 {
73     if (srcId == NULL || dstIdBuf == NULL) {
74         LNN_LOGW(LNN_TEST, "invalid para");
75         return SOFTBUS_ERR;
76     }
77     if (memcpy_s(dstIdBuf, dstIdBufLen, "abc", strlen("abc") + 1) != EOK) {
78         LNN_LOGI(LNN_TEST, "memcpy dstIdBuf fail");
79         return SOFTBUS_ERR;
80     }
81     return SOFTBUS_OK;
82 }
83 
ActionOfLnnConvertDlId1(const char * srcId,IdCategory srcIdType,IdCategory dstIdType,char * dstIdBuf,uint32_t dstIdBufLen)84 int32_t LnnNetLedgertInterfaceMock::ActionOfLnnConvertDlId1(const char *srcId, IdCategory srcIdType,
85     IdCategory dstIdType, char *dstIdBuf, uint32_t dstIdBufLen)
86 {
87     if (srcId == NULL || dstIdBuf == NULL) {
88         LNN_LOGW(LNN_TEST, "invalid para");
89         return SOFTBUS_ERR;
90     }
91     if (strcpy_s(dstIdBuf, dstIdBufLen, peerId.c_str()) != EOK) {
92         LNN_LOGI(LNN_TEST, "memcpy dstIdBuf fail");
93         return SOFTBUS_ERR;
94     }
95     return SOFTBUS_OK;
96 }
97 
ActionOfLnnGetAllOnlineNodeInfo(NodeBasicInfo ** info,int32_t * infoNum)98 int32_t LnnNetLedgertInterfaceMock::ActionOfLnnGetAllOnlineNodeInfo(NodeBasicInfo **info, int32_t *infoNum)
99 {
100     if (info == NULL || infoNum == NULL) {
101         LNN_LOGW(LNN_TEST, "invalid para");
102         return SOFTBUS_ERR;
103     }
104     *infoNum = 1;
105     *info = reinterpret_cast<NodeBasicInfo *>(SoftBusMalloc((*infoNum) * sizeof(NodeBasicInfo)));
106     if (*info == NULL) {
107         LNN_LOGI(LNN_TEST, "malloc info fail");
108         return SOFTBUS_ERR;
109     }
110     if (memcpy_s((*info)->networkId, sizeof((*info)->networkId), "abc", strlen("abc") + 1) != EOK) {
111         LNN_LOGE(LNN_TEST, "memcpy networkId fail");
112         return SOFTBUS_ERR;
113     }
114     return SOFTBUS_OK;
115 }
116 
ActionOfLnnGetAllOnlineNodeInfo1(NodeBasicInfo ** info,int32_t * infoNum)117 int32_t LnnNetLedgertInterfaceMock::ActionOfLnnGetAllOnlineNodeInfo1(NodeBasicInfo **info, int32_t *infoNum)
118 {
119     if (info == NULL || infoNum == NULL) {
120         LNN_LOGW(LNN_TEST, "invalid para");
121         return SOFTBUS_ERR;
122     }
123     *infoNum = LNN_MOCK_ONLINE_NODE_CNT;
124     *info = reinterpret_cast<NodeBasicInfo *>(SoftBusMalloc((*infoNum) * sizeof(NodeBasicInfo)));
125     if (*info == NULL) {
126         LNN_LOGI(LNN_TEST, "malloc info fail");
127         return SOFTBUS_ERR;
128     }
129     if (memcpy_s((*info)->networkId, sizeof((*info)->networkId), "abc", strlen("abc") + 1) != EOK) {
130         LNN_LOGI(LNN_TEST, "memcpy networkId fail");
131         return SOFTBUS_ERR;
132     }
133     if (memcpy_s((*info + 1)->networkId, sizeof((*info + 1)->networkId), peerId.c_str(), peerId.length() + 1) != EOK) {
134         LNN_LOGI(LNN_TEST, "memcpy networkId fail");
135         return SOFTBUS_ERR;
136     }
137     return SOFTBUS_OK;
138 }
139 
ActionOfLnnGetLnnRelation(const char * id,IdCategory type,uint8_t * relation,uint32_t len)140 int32_t LnnNetLedgertInterfaceMock::ActionOfLnnGetLnnRelation(const char *id, IdCategory type,
141     uint8_t *relation, uint32_t len)
142 {
143     if (len <= CONNECTION_ADDR_BR) {
144         LNN_LOGW(LNN_TEST, "set relation fail");
145         return SOFTBUS_ERR;
146     }
147     relation[CONNECTION_ADDR_BR] = LNN_RELATION_JOIN_THREAD;
148     return SOFTBUS_OK;
149 }
150 
ActionOfLnnGetLnnRelation1(const char * id,IdCategory type,uint8_t * relation,uint32_t len)151 int32_t LnnNetLedgertInterfaceMock::ActionOfLnnGetLnnRelation1(const char *id, IdCategory type,
152     uint8_t *relation, uint32_t len)
153 {
154     if (len <= CONNECTION_ADDR_BR) {
155         LNN_LOGW(LNN_TEST, "set relation fail");
156         return SOFTBUS_ERR;
157     }
158     relation[CONNECTION_ADDR_BR] = LNN_RELATION_JOIN_THREAD;
159     relation[CONNECTION_ADDR_BLE] = LNN_RELATION_JOIN_THREAD;
160     return SOFTBUS_OK;
161 }
162 
ActionOfLnnGetLocalStrInfo(InfoKey key,char * info,uint32_t len)163 int32_t LnnNetLedgertInterfaceMock::ActionOfLnnGetLocalStrInfo(InfoKey key, char *info, uint32_t len)
164 {
165     if (info == NULL) {
166         LNN_LOGW(LNN_TEST, "invalid para");
167         return SOFTBUS_ERR;
168     }
169     if (memcpy_s(info, len, "abc", strlen("abc") + 1) != EOK) {
170         LNN_LOGE(LNN_TEST, "memcpy info fail");
171         return SOFTBUS_ERR;
172     }
173     return SOFTBUS_OK;
174 }
175 
ActionOfLnnGetLocalStrInfo1(InfoKey key,char * info,uint32_t len)176 int32_t LnnNetLedgertInterfaceMock::ActionOfLnnGetLocalStrInfo1(InfoKey key, char *info, uint32_t len)
177 {
178     if (info == NULL) {
179         LNN_LOGW(LNN_TEST, "invalid para");
180         return SOFTBUS_ERR;
181     }
182     if (memcpy_s(info, len, localId.c_str(), localId.length() + 1) != EOK) {
183         LNN_LOGE(LNN_TEST, "memcpy info fail");
184         return SOFTBUS_ERR;
185     }
186     return SOFTBUS_OK;
187 }
188 
ActionOfLnnGetLocalStrInfo2(InfoKey key,char * info,uint32_t len)189 int32_t LnnNetLedgertInterfaceMock::ActionOfLnnGetLocalStrInfo2(InfoKey key, char *info, uint32_t len)
190 {
191     if (key == STRING_KEY_NET_IF_NAME) {
192         if (strcpy_s(info, len, "deviceName") != EOK) {
193             return SOFTBUS_ERR;
194         }
195         return SOFTBUS_OK;
196     }
197     if (key == STRING_KEY_WLAN_IP) {
198         if (strcpy_s(info, len, "127.0.0.2") != EOK) {
199             return SOFTBUS_ERR;
200         }
201         return SOFTBUS_OK;
202     }
203     return SOFTBUS_ERR;
204 }
205 
ActionOfLnnGetAuthHandle(const char * uuid,AuthLinkType type,AuthHandle * authHandle)206 int32_t LnnNetLedgertInterfaceMock::ActionOfLnnGetAuthHandle(const char *uuid, AuthLinkType type,
207     AuthHandle *authHandle)
208 {
209     (void)uuid;
210     if (authHandle == NULL) {
211         LNN_LOGW(LNN_TEST, "invalid para");
212         return SOFTBUS_ERR;
213     }
214     authHandle->authId = 1;
215     authHandle->type = AUTH_LINK_TYPE_BLE;
216     return SOFTBUS_OK;
217 }
218 
ActionOfLnnGetAuthSeqList(const char * udid,int64_t * seqList,uint64_t * authVerifyTime,DiscoveryType type)219 int32_t LnnNetLedgertInterfaceMock::ActionOfLnnGetAuthSeqList(const char *udid, int64_t *seqList,
220     uint64_t *authVerifyTime, DiscoveryType type)
221 {
222     (void)udid;
223     (void)type;
224     seqList[0] = SEQ_LIST_1;
225     seqList[1] = SEQ_LIST_2;
226 
227     authVerifyTime[0] = AUTH_VERIFY_TIME_1;
228     authVerifyTime[1] = AUTH_VERIFY_TIME_2;
229 
230     return SOFTBUS_OK;
231 }
232 
233 extern "C" {
LnnGetLocalStrInfo(InfoKey key,char * info,uint32_t len)234 int32_t LnnGetLocalStrInfo(InfoKey key, char *info, uint32_t len)
235 {
236     return GetNetLedgerInterface()->LnnGetLocalStrInfo(key, info, len);
237 }
238 
LnnGetLocalNodeInfo(void)239 const NodeInfo *LnnGetLocalNodeInfo(void)
240 {
241     return GetNetLedgerInterface()->LnnGetLocalNodeInfo();
242 }
243 
LnnGetAuthPort(const NodeInfo * info)244 int32_t LnnGetAuthPort(const NodeInfo *info)
245 {
246     return GetNetLedgerInterface()->LnnGetAuthPort(info);
247 }
248 
LnnGetSessionPort(const NodeInfo * info)249 int32_t LnnGetSessionPort(const NodeInfo *info)
250 {
251     return GetNetLedgerInterface()->LnnGetSessionPort(info);
252 }
253 
LnnGetProxyPort(const NodeInfo * info)254 int32_t LnnGetProxyPort(const NodeInfo *info)
255 {
256     return GetNetLedgerInterface()->LnnGetProxyPort(info);
257 }
258 
LnnGetBtMac(const NodeInfo * info)259 const char *LnnGetBtMac(const NodeInfo *info)
260 {
261     return GetNetLedgerInterface()->LnnGetBtMac(info);
262 }
263 
LnnGetDeviceName(const DeviceBasicInfo * info)264 const char *LnnGetDeviceName(const DeviceBasicInfo *info)
265 {
266     return GetNetLedgerInterface()->LnnGetDeviceName(info);
267 }
268 
LnnConvertIdToDeviceType(uint16_t typeId)269 char *LnnConvertIdToDeviceType(uint16_t typeId)
270 {
271     return GetNetLedgerInterface()->LnnConvertIdToDeviceType(typeId);
272 }
273 
LnnGetP2pRole(const NodeInfo * info)274 int32_t LnnGetP2pRole(const NodeInfo *info)
275 {
276     return GetNetLedgerInterface()->LnnGetP2pRole(info);
277 }
278 
LnnGetP2pMac(const NodeInfo * info)279 const char *LnnGetP2pMac(const NodeInfo *info)
280 {
281     return GetNetLedgerInterface()->LnnGetP2pMac(info);
282 }
283 
LnnGetWifiDirectAddr(const NodeInfo * info)284 const char *LnnGetWifiDirectAddr(const NodeInfo *info)
285 {
286     return GetNetLedgerInterface()->LnnGetWifiDirectAddr(info);
287 }
288 
LnnGetSupportedProtocols(const NodeInfo * info)289 uint64_t LnnGetSupportedProtocols(const NodeInfo *info)
290 {
291     return GetNetLedgerInterface()->LnnGetSupportedProtocols(info);
292 }
293 
LnnConvertDeviceTypeToId(const char * deviceType,uint16_t * typeId)294 int32_t LnnConvertDeviceTypeToId(const char *deviceType, uint16_t *typeId)
295 {
296     return GetNetLedgerInterface()->LnnConvertDeviceTypeToId(deviceType, typeId);
297 }
298 
LnnGetLocalNumInfo(InfoKey key,int32_t * info)299 int32_t LnnGetLocalNumInfo(InfoKey key, int32_t *info)
300 {
301     return GetNetLedgerInterface()->LnnGetLocalNumInfo(key, info);
302 }
303 
LnnGetLocalNumU32Info(InfoKey key,uint32_t * info)304 int32_t LnnGetLocalNumU32Info(InfoKey key, uint32_t *info)
305 {
306     return GetNetLedgerInterface()->LnnGetLocalNumU32Info(key, info);
307 }
308 
LnnConvertDlId(const char * srcId,IdCategory srcIdType,IdCategory dstIdType,char * dstIdBuf,uint32_t dstIdBufLen)309 int32_t LnnConvertDlId(const char *srcId, IdCategory srcIdType, IdCategory dstIdType,
310     char *dstIdBuf, uint32_t dstIdBufLen)
311 {
312     return GetNetLedgerInterface()->LnnConvertDlId(srcId, srcIdType,
313         dstIdType, dstIdBuf, dstIdBufLen);
314 }
315 
LnnHasCapability(uint32_t capability,NetCapability type)316 bool LnnHasCapability(uint32_t capability, NetCapability type)
317 {
318     return GetNetLedgerInterface()->LnnHasCapability(capability, type);
319 }
320 
LnnSetNetCapability(uint32_t * capability,NetCapability type)321 int32_t LnnSetNetCapability(uint32_t *capability, NetCapability type)
322 {
323     return GetNetLedgerInterface()->LnnSetNetCapability(capability, type);
324 }
325 
LnnClearNetCapability(uint32_t * capability,NetCapability type)326 int32_t LnnClearNetCapability(uint32_t *capability, NetCapability type)
327 {
328     return GetNetLedgerInterface()->LnnClearNetCapability(capability, type);
329 }
330 
LnnSetP2pRole(NodeInfo * info,int32_t role)331 int32_t LnnSetP2pRole(NodeInfo *info, int32_t role)
332 {
333     return GetNetLedgerInterface()->LnnSetP2pRole(info, role);
334 }
335 
LnnSetP2pMac(NodeInfo * info,const char * p2pMac)336 int32_t LnnSetP2pMac(NodeInfo *info, const char *p2pMac)
337 {
338     return GetNetLedgerInterface()->LnnSetP2pMac(info, p2pMac);
339 }
340 
LnnSetP2pGoMac(NodeInfo * info,const char * goMac)341 int32_t LnnSetP2pGoMac(NodeInfo *info, const char *goMac)
342 {
343     return GetNetLedgerInterface()->LnnSetP2pGoMac(info, goMac);
344 }
345 
LnnSetWifiDirectAddr(NodeInfo * info,const char * wifiDirectAddr)346 int32_t LnnSetWifiDirectAddr(NodeInfo *info, const char *wifiDirectAddr)
347 {
348     return GetNetLedgerInterface()->LnnSetWifiDirectAddr(info, wifiDirectAddr);
349 }
350 
LnnGetAllOnlineAndMetaNodeInfo(NodeBasicInfo ** info,int32_t * infoNum)351 int32_t LnnGetAllOnlineAndMetaNodeInfo(NodeBasicInfo **info, int32_t *infoNum)
352 {
353     return GetNetLedgerInterface()->LnnGetAllOnlineAndMetaNodeInfo(info, infoNum);
354 }
355 
LnnGetAllOnlineNodeInfo(NodeBasicInfo ** info,int32_t * infoNum)356 int32_t LnnGetAllOnlineNodeInfo(NodeBasicInfo **info, int32_t *infoNum)
357 {
358     return GetNetLedgerInterface()->LnnGetAllOnlineNodeInfo(info, infoNum);
359 }
360 
LnnIsLSANode(const NodeBasicInfo * info)361 bool LnnIsLSANode(const NodeBasicInfo *info)
362 {
363     return GetNetLedgerInterface()->LnnIsLSANode(info);
364 }
365 
LnnGetNodeInfoById(const char * id,IdCategory type)366 NodeInfo *LnnGetNodeInfoById(const char *id, IdCategory type)
367 {
368     return GetNetLedgerInterface()->LnnGetNodeInfoById(id, type);
369 }
370 
LnnGetLnnRelation(const char * id,IdCategory type,uint8_t * relation,uint32_t len)371 int32_t LnnGetLnnRelation(const char *id, IdCategory type, uint8_t *relation, uint32_t len)
372 {
373     return GetNetLedgerInterface()->LnnGetLnnRelation(id, type, relation, len);
374 }
375 
LnnSetDLConnCapability(const char * networkId,uint32_t connCapability)376 int32_t LnnSetDLConnCapability(const char *networkId, uint32_t connCapability)
377 {
378     return GetNetLedgerInterface()->LnnSetDLConnCapability(networkId, connCapability);
379 }
380 
LnnHasDiscoveryType(const NodeInfo * info,DiscoveryType type)381 bool LnnHasDiscoveryType(const NodeInfo *info, DiscoveryType type)
382 {
383     return GetNetLedgerInterface()->LnnHasDiscoveryType(info, type);
384 }
385 
LnnSetLocalStrInfo(InfoKey key,const char * info)386 int32_t LnnSetLocalStrInfo(InfoKey key, const char *info)
387 {
388     return GetNetLedgerInterface()->LnnSetLocalStrInfo(key, info);
389 }
390 
LnnSetLocalNumInfo(InfoKey key,int32_t info)391 int32_t LnnSetLocalNumInfo(InfoKey key, int32_t info)
392 {
393     return GetNetLedgerInterface()->LnnSetLocalNumInfo(key, info);
394 }
395 
LnnSetDLP2pInfo(const char * networkId,const P2pInfo * info)396 bool LnnSetDLP2pInfo(const char *networkId, const P2pInfo *info)
397 {
398     return GetNetLedgerInterface()->LnnSetDLP2pInfo(networkId, info);
399 }
400 
LnnSetDLWifiDirectAddr(const char * networkId,const char * addr)401 bool LnnSetDLWifiDirectAddr(const char *networkId, const char *addr)
402 {
403     return GetNetLedgerInterface()->LnnSetDLWifiDirectAddr(networkId, addr);
404 }
405 
LnnIsNodeOnline(const NodeInfo * info)406 bool LnnIsNodeOnline(const NodeInfo *info)
407 {
408     return GetNetLedgerInterface()->LnnIsNodeOnline(info);
409 }
410 
LnnGetCnnCode(const char * uuid,DiscoveryType type)411 short LnnGetCnnCode(const char *uuid, DiscoveryType type)
412 {
413     return GetNetLedgerInterface()->LnnGetCnnCode(uuid, type);
414 }
415 
LnnAddOnlineNode(NodeInfo * info)416 ReportCategory LnnAddOnlineNode(NodeInfo *info)
417 {
418     return GetNetLedgerInterface()->LnnAddOnlineNode(info);
419 }
420 
LnnGetBasicInfoByUdid(const char * udid,NodeBasicInfo * basicInfo)421 int32_t LnnGetBasicInfoByUdid(const char *udid, NodeBasicInfo *basicInfo)
422 {
423     return GetNetLedgerInterface()->LnnGetBasicInfoByUdid(udid, basicInfo);
424 }
425 
LnnInsertSpecificTrustedDevInfo(const char * udid)426 int32_t LnnInsertSpecificTrustedDevInfo(const char *udid)
427 {
428     return GetNetLedgerInterface()->LnnInsertSpecificTrustedDevInfo(udid);
429 }
430 
LnnSetNodeOffline(const char * udid,ConnectionAddrType type,int32_t authId)431 ReportCategory LnnSetNodeOffline(const char *udid, ConnectionAddrType type, int32_t authId)
432 {
433     return GetNetLedgerInterface()->LnnSetNodeOffline(udid, type, authId);
434 }
435 
LnnRemoveNode(const char * udid)436 void LnnRemoveNode(const char *udid)
437 {
438     return GetNetLedgerInterface()->LnnRemoveNode(udid);
439 }
440 
LnnSetSupportDiscoveryType(char * info,const char * type)441 int32_t LnnSetSupportDiscoveryType(char *info, const char *type)
442 {
443     return GetNetLedgerInterface()->LnnSetSupportDiscoveryType(info, type);
444 }
445 
LnnHasSupportDiscoveryType(const char * destType,const char * type)446 bool LnnHasSupportDiscoveryType(const char *destType, const char *type)
447 {
448     return GetNetLedgerInterface()->LnnHasSupportDiscoveryType(destType, type);
449 }
450 
LnnPeerHasExchangeDiscoveryType(const NodeInfo * info,DiscoveryType type)451 bool LnnPeerHasExchangeDiscoveryType(const NodeInfo *info, DiscoveryType type)
452 {
453     return GetNetLedgerInterface()->LnnPeerHasExchangeDiscoveryType(info, type);
454 }
455 
LnnGetDeviceUdid(const NodeInfo * info)456 const char *LnnGetDeviceUdid(const NodeInfo *info)
457 {
458     return GetNetLedgerInterface()->LnnGetDeviceUdid(info);
459 }
460 
LnnGetNetworkIdByBtMac(const char * btMac,char * buf,uint32_t len)461 int32_t LnnGetNetworkIdByBtMac(const char *btMac, char *buf, uint32_t len)
462 {
463     return GetNetLedgerInterface()->LnnGetNetworkIdByBtMac(btMac, buf, len);
464 }
465 
LnnSetLocalNum64Info(InfoKey key,int64_t info)466 int32_t LnnSetLocalNum64Info(InfoKey key, int64_t info)
467 {
468     return GetNetLedgerInterface()->LnnSetLocalNum64Info(key, info);
469 }
470 
LnnGetNodeKeyInfo(const char * networkId,int key,uint8_t * info,uint32_t infoLen)471 int32_t LnnGetNodeKeyInfo(const char *networkId, int key, uint8_t *info, uint32_t infoLen)
472 {
473     return GetNetLedgerInterface()->LnnGetNodeKeyInfo(networkId, key, info, infoLen);
474 }
475 
LnnGetRemoteNumInfo(const char * netWorkId,InfoKey key,int32_t * info)476 int32_t LnnGetRemoteNumInfo(const char *netWorkId, InfoKey key, int32_t *info)
477 {
478     return GetNetLedgerInterface()->LnnGetRemoteNumInfo(netWorkId, key, info);
479 }
480 
LnnGetLocalDeviceInfo(NodeBasicInfo * info)481 int32_t LnnGetLocalDeviceInfo(NodeBasicInfo *info)
482 {
483     return GetNetLedgerInterface()->LnnGetLocalDeviceInfo(info);
484 }
485 
LnnGetLocalByteInfo(InfoKey key,uint8_t * info,uint32_t len)486 int32_t LnnGetLocalByteInfo(InfoKey key, uint8_t *info, uint32_t len)
487 {
488     return GetNetLedgerInterface()->LnnGetLocalByteInfo(key, info, len);
489 }
490 
LnnIsDefaultOhosAccount()491 bool LnnIsDefaultOhosAccount()
492 {
493     return GetNetLedgerInterface()->LnnIsDefaultOhosAccount();
494 }
495 
LnnIsPotentialHomeGroup(const char * udid)496 bool LnnIsPotentialHomeGroup(const char *udid)
497 {
498     return GetNetLedgerInterface()->LnnIsPotentialHomeGroup(udid);
499 }
500 
LnnGetRemoteNodeInfoById(const char * id,IdCategory type,NodeInfo * info)501 int32_t LnnGetRemoteNodeInfoById(const char *id, IdCategory type, NodeInfo *info)
502 {
503     return GetNetLedgerInterface()->LnnGetRemoteNodeInfoById(id, type, info);
504 }
505 
IsPotentialTrustedDevice(TrustedRelationIdType idType,const char * deviceId,bool isPrecise,bool isPointToPoint)506 bool IsPotentialTrustedDevice(TrustedRelationIdType idType, const char *deviceId, bool isPrecise, bool isPointToPoint)
507 {
508     return GetNetLedgerInterface()->IsPotentialTrustedDevice(idType, deviceId, isPrecise, isPointToPoint);
509 }
510 
LnnRegisterBleLpDeviceMediumMgr(void)511 int32_t LnnRegisterBleLpDeviceMediumMgr(void)
512 {
513     return GetNetLedgerInterface()->LnnRegisterBleLpDeviceMediumMgr();
514 }
515 
LnnGetLocalNumU64Info(InfoKey key,uint64_t * info)516 int32_t LnnGetLocalNumU64Info(InfoKey key, uint64_t *info)
517 {
518     return GetNetLedgerInterface()->LnnGetLocalNumU64Info(key, info);
519 }
520 
IsActiveOsAccountUnlocked(void)521 bool IsActiveOsAccountUnlocked(void)
522 {
523     return GetNetLedgerInterface()->IsActiveOsAccountUnlocked();
524 }
525 
GetActiveOsAccountIds(void)526 int32_t GetActiveOsAccountIds(void)
527 {
528     return GetNetLedgerInterface()->GetActiveOsAccountIds();
529 }
530 
AuthDeviceGetLatestIdByUuid(const char * uuid,AuthLinkType type,AuthHandle * authHandle)531 int32_t AuthDeviceGetLatestIdByUuid(const char *uuid, AuthLinkType type, AuthHandle *authHandle)
532 {
533     return GetNetLedgerInterface()->AuthDeviceGetLatestIdByUuid(uuid, type, authHandle);
534 }
535 
AuthGetLatestAuthSeqListByType(const char * udid,int64_t * seqList,uint64_t * authVerifyTime,DiscoveryType type)536 int32_t AuthGetLatestAuthSeqListByType(const char *udid, int64_t *seqList, uint64_t *authVerifyTime,
537     DiscoveryType type)
538 {
539     return GetNetLedgerInterface()->AuthGetLatestAuthSeqListByType(udid, seqList, authVerifyTime, type);
540 }
541 
LnnSetDLUnifiedDeviceName(const char * udid,const char * name)542 int32_t LnnSetDLUnifiedDeviceName(const char *udid, const char *name)
543 {
544     return GetNetLedgerInterface()->LnnSetDLUnifiedDeviceName(udid, name);
545 }
546 
LnnSetDLUnifiedDefaultDeviceName(const char * udid,const char * name)547 int32_t LnnSetDLUnifiedDefaultDeviceName(const char *udid, const char *name)
548 {
549     return GetNetLedgerInterface()->LnnSetDLUnifiedDefaultDeviceName(udid, name);
550 }
551 
LnnSetDLDeviceNickNameByUdid(const char * udid,const char * name)552 int32_t LnnSetDLDeviceNickNameByUdid(const char *udid, const char *name)
553 {
554     return GetNetLedgerInterface()->LnnSetDLDeviceNickNameByUdid(udid, name);
555 }
556 
LnnSetDLDeviceStateVersion(const char * udid,int32_t stateVersion)557 int32_t LnnSetDLDeviceStateVersion(const char *udid, int32_t stateVersion)
558 {
559     return GetNetLedgerInterface()->LnnSetDLDeviceStateVersion(udid, stateVersion);
560 }
561 
LnnUpdateDistributedNodeInfo(NodeInfo * newInfo,const char * udid)562 int32_t LnnUpdateDistributedNodeInfo(NodeInfo *newInfo, const char *udid)
563 {
564     return GetNetLedgerInterface()->LnnUpdateDistributedNodeInfo(newInfo, udid);
565 }
566 
LnnSetDLDeviceBroadcastCipherKey(const char * udid,const void * cipherKey)567 int32_t LnnSetDLDeviceBroadcastCipherKey(const char *udid, const void *cipherKey)
568 {
569     return GetNetLedgerInterface()->LnnSetDLDeviceBroadcastCipherKey(udid, cipherKey);
570 }
571 
LnnSetDLDeviceBroadcastCipherIv(const char * udid,const void * cipherIv)572 int32_t LnnSetDLDeviceBroadcastCipherIv(const char *udid, const void *cipherIv)
573 {
574     return GetNetLedgerInterface()->LnnSetDLDeviceBroadcastCipherIv(udid, cipherIv);
575 }
576 
LnnSetDLDeviceInfoName(const char * udid,const char * name)577 bool LnnSetDLDeviceInfoName(const char *udid, const char *name)
578 {
579     return GetNetLedgerInterface()->LnnSetDLDeviceInfoName(udid, name);
580 }
581 
LnnSetDLBssTransInfo(const char * networkId,const BssTransInfo * info)582 int32_t LnnSetDLBssTransInfo(const char *networkId, const BssTransInfo *info)
583 {
584     return GetNetLedgerInterface()->LnnSetDLBssTransInfo(networkId, info);
585 }
586 
LnnSetDLBatteryInfo(const char * networkId,const BatteryInfo * info)587 int32_t LnnSetDLBatteryInfo(const char *networkId, const BatteryInfo *info)
588 {
589     return GetNetLedgerInterface()->LnnSetDLBatteryInfo(networkId, info);
590 }
591 
LnnGetOsTypeByNetworkId(const char * networkId,int32_t * osType)592 int32_t LnnGetOsTypeByNetworkId(const char *networkId, int32_t *osType)
593 {
594     return GetNetLedgerInterface()->LnnGetOsTypeByNetworkId(networkId, osType);
595 }
596 
LnnSetDLDeviceNickName(const char * networkId,const char * name)597 bool LnnSetDLDeviceNickName(const char *networkId, const char *name)
598 {
599     return GetNetLedgerInterface()->LnnSetDLDeviceNickName(networkId, name);
600 }
601 
LnnUpdateLocalScreenStatus(bool isScreenOn)602 int32_t LnnUpdateLocalScreenStatus(bool isScreenOn)
603 {
604     return GetNetLedgerInterface()->LnnUpdateLocalScreenStatus(isScreenOn);
605 }
606 }
607 } // namespace OHOS
608