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