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 "lnn_network_info.h"
17
18 #include <securec.h>
19
20 #include "anonymizer.h"
21 #include "bus_center_event.h"
22 #include "bus_center_manager.h"
23 #include "lnn_async_callback_utils.h"
24 #include "lnn_distributed_net_ledger.h"
25 #include "lnn_deviceinfo_to_profile.h"
26 #include "lnn_feature_capability.h"
27 #include "lnn_heartbeat_strategy.h"
28 #include "lnn_local_net_ledger.h"
29 #include "lnn_log.h"
30 #include "lnn_net_capability.h"
31 #include "lnn_node_info.h"
32 #include "lnn_net_builder.h"
33 #include "lnn_sync_info_manager.h"
34 #include "softbus_adapter_mem.h"
35 #include "softbus_errcode.h"
36 #include "softbus_wifi_api_adapter.h"
37 #include "softbus_json_utils.h"
38 #include "softbus_def.h"
39 #include "wifi_direct_manager.h"
40
41 #define MSG_LEN 10
42 #define BITS 8
43 #define BITLEN 4
44 #define STRING_INTERFACE_BUFFER_LEN 16
45
46 static bool g_isWifiDirectSupported = false;
47 static bool g_isApCoexistSupported = false;
48 static bool g_isWifiEnable = false;
49 static bool g_isApEnable = false;
50
ConvertMsgToCapability(uint32_t * capability,const uint8_t * msg,uint32_t len)51 static uint32_t ConvertMsgToCapability(uint32_t *capability, const uint8_t *msg, uint32_t len)
52 {
53 if (capability == NULL || msg == NULL || len < BITS) {
54 return SOFTBUS_ERR;
55 }
56 for (uint32_t i = 0; i < BITLEN; i++) {
57 *capability = *capability | (*(msg + i) << (BITS * i));
58 }
59 return SOFTBUS_OK;
60 }
61
PostNetchangedInfo(const char * networkId,ConnectionAddrType type)62 static void PostNetchangedInfo(const char *networkId, ConnectionAddrType type)
63 {
64 LNN_LOGI(LNN_BUILDER, "start post offline, conntype=%{public}d", type);
65 if (LnnRequestLeaveSpecific(networkId, type) != SOFTBUS_OK) {
66 LNN_LOGE(LNN_BUILDER, "send request to NetBuilder fail");
67 }
68 }
69
HandlePeerNetCapchanged(const char * networkId,uint32_t capability)70 static void HandlePeerNetCapchanged(const char *networkId, uint32_t capability)
71 {
72 if (!LnnHasCapability(capability, BIT_WIFI) || networkId == NULL) {
73 LNN_LOGI(LNN_BUILDER, "only support close ble");
74 return;
75 }
76 NodeInfo info;
77 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
78 if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &info) != SOFTBUS_OK) {
79 LNN_LOGE(LNN_BUILDER, "get node info fail");
80 return;
81 }
82 if (LnnHasDiscoveryType(&info, DISCOVERY_TYPE_BLE) && !LnnHasCapability(capability, BIT_BLE)) {
83 LNN_LOGI(LNN_BUILDER, "remote device lost ble, ble need offline");
84 PostNetchangedInfo(networkId, CONNECTION_ADDR_BLE);
85 }
86 if (LnnHasDiscoveryType(&info, DISCOVERY_TYPE_BR) && !LnnHasCapability(capability, BIT_BR)) {
87 LNN_LOGI(LNN_BUILDER, "remote device lost br, br need offline");
88 PostNetchangedInfo(networkId, CONNECTION_ADDR_BR);
89 }
90 }
91
UpdateNetworkInfo(const char * udid)92 static void UpdateNetworkInfo(const char *udid)
93 {
94 NodeBasicInfo basic;
95 (void)memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
96 if (LnnGetBasicInfoByUdid(udid, &basic) != SOFTBUS_OK) {
97 LNN_LOGE(LNN_BUILDER, "GetBasicInfoByUdid fail");
98 return;
99 }
100 LnnNotifyBasicInfoChanged(&basic, TYPE_NETWORK_INFO);
101 }
102
OnReceiveCapaSyncInfoMsg(LnnSyncInfoType type,const char * networkId,const uint8_t * msg,uint32_t len)103 static void OnReceiveCapaSyncInfoMsg(LnnSyncInfoType type, const char *networkId, const uint8_t *msg, uint32_t len)
104 {
105 LNN_LOGI(LNN_BUILDER, "Recv capability info. type=%{public}d, len=%{public}d", type, len);
106 if (type != LNN_INFO_TYPE_CAPABILITY) {
107 return;
108 }
109 if (networkId == NULL) {
110 return;
111 }
112 if (msg == NULL || len == 0) {
113 return;
114 }
115 uint32_t capability = 0;
116 if (ConvertMsgToCapability(&capability, msg, len) != SOFTBUS_OK) {
117 LNN_LOGE(LNN_BUILDER, "convert msg to capability fail");
118 return;
119 }
120 char *anonyNetworkId = NULL;
121 Anonymize(networkId, &anonyNetworkId);
122 LNN_LOGI(LNN_BUILDER, "recv capability change=%{public}d, networkId=%{public}s", capability, anonyNetworkId);
123 AnonymizeFree(anonyNetworkId);
124 // update ledger
125 NodeInfo info;
126 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
127 if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &info) != SOFTBUS_OK) {
128 LNN_LOGE(LNN_BUILDER, "get node info fail");
129 return;
130 }
131 if (info.discoveryType != capability) {
132 LNN_LOGI(LNN_BUILDER, "capability change, need to updateProfile");
133 UpdateProfile(&info);
134 UpdateNetworkInfo(info.deviceInfo.deviceUdid);
135 }
136 if (LnnSetDLConnCapability(networkId, capability)) {
137 LNN_LOGE(LNN_BUILDER, "update conn capability fail.");
138 return;
139 }
140 HandlePeerNetCapchanged(networkId, capability);
141 }
142
ConvertCapabilityToMsg(uint32_t localCapability)143 static uint8_t *ConvertCapabilityToMsg(uint32_t localCapability)
144 {
145 LNN_LOGD(LNN_BUILDER, "convert capability to msg enter");
146 uint8_t *arr = (uint8_t *)SoftBusCalloc(MSG_LEN);
147 if (arr == NULL) {
148 LNN_LOGE(LNN_BUILDER, "convert capability to msg calloc msg fail");
149 return NULL;
150 }
151 for (uint32_t i = 0; i < BITLEN; i++) {
152 *(arr + i) = (localCapability >> (i * BITS)) & 0xFF;
153 }
154 return arr;
155 }
156
IsNeedToSend(NodeInfo * nodeInfo,uint32_t type)157 static bool IsNeedToSend(NodeInfo *nodeInfo, uint32_t type)
158 {
159 if ((type & (1 << (uint32_t)DISCOVERY_TYPE_BR)) && (LnnHasDiscoveryType(nodeInfo, DISCOVERY_TYPE_BR))) {
160 return true;
161 } else if ((type & (1 << (uint32_t)DISCOVERY_TYPE_BLE)) && (LnnHasDiscoveryType(nodeInfo, DISCOVERY_TYPE_BLE))) {
162 return true;
163 } else if ((type & (1 << (uint32_t)DISCOVERY_TYPE_WIFI)) && (LnnHasDiscoveryType(nodeInfo, DISCOVERY_TYPE_WIFI))) {
164 return true;
165 } else {
166 LNN_LOGI(LNN_BUILDER, "online device discovery type not match select link");
167 return false;
168 }
169 }
170
DoSendCapability(NodeInfo nodeInfo,NodeBasicInfo netInfo,uint8_t * msg,uint32_t netCapability,uint32_t type)171 static void DoSendCapability(NodeInfo nodeInfo, NodeBasicInfo netInfo, uint8_t *msg, uint32_t netCapability,
172 uint32_t type)
173 {
174 int32_t ret = SOFTBUS_OK;
175 if (IsNeedToSend(&nodeInfo, type)) {
176 if (!IsFeatureSupport(nodeInfo.feature, BIT_CLOUD_SYNC_DEVICE_INFO)) {
177 ret = LnnSendSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, netInfo.networkId, msg, MSG_LEN, NULL);
178 } else {
179 if (type == ((1 << (uint32_t)DISCOVERY_TYPE_BLE) | (1 << (uint32_t)DISCOVERY_TYPE_BR))) {
180 ret = LnnStartHbByTypeAndStrategy(HEARTBEAT_TYPE_BLE_V0, STRATEGY_HB_SEND_SINGLE, false);
181 } else {
182 ret = LnnSendSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, netInfo.networkId, msg, MSG_LEN, NULL);
183 }
184 }
185 char *anonyNetworkId = NULL;
186 Anonymize(netInfo.networkId, &anonyNetworkId);
187 LNN_LOGE(LNN_BUILDER,
188 "sync cap info ret=%{public}d, peerNetworkId=%{public}s, type=%{public}u.", ret, anonyNetworkId, type);
189 AnonymizeFree(anonyNetworkId);
190 } else if ((type & (1 << (uint32_t)DISCOVERY_TYPE_WIFI)) != 0 && !LnnHasCapability(netCapability, BIT_BLE)) {
191 LnnSendP2pSyncInfoMsg(netInfo.networkId, netCapability);
192 }
193 }
194
SendNetCapabilityToRemote(uint32_t netCapability,uint32_t type)195 static void SendNetCapabilityToRemote(uint32_t netCapability, uint32_t type)
196 {
197 uint8_t *msg = ConvertCapabilityToMsg(netCapability);
198 if (msg ==NULL) {
199 return;
200 }
201 int32_t infoNum = 0;
202 NodeBasicInfo *netInfo = NULL;
203 if (LnnGetAllOnlineNodeInfo(&netInfo, &infoNum) != SOFTBUS_OK) {
204 LNN_LOGE(LNN_BUILDER, "get all online node info fail.");
205 SoftBusFree(msg);
206 return;
207 }
208 if (infoNum == 0) {
209 LNN_LOGI(LNN_BUILDER, "online device num is 0, not need to send network info");
210 SoftBusFree(msg);
211 return;
212 }
213 NodeInfo nodeInfo;
214 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
215 for (int32_t i = 0; i < infoNum; i++) {
216 if (LnnIsLSANode(&netInfo[i])) {
217 continue;
218 }
219 if (LnnGetRemoteNodeInfoById(netInfo[i].networkId, CATEGORY_NETWORK_ID, &nodeInfo) != SOFTBUS_OK) {
220 continue;
221 }
222 DoSendCapability(nodeInfo, netInfo[i], msg, netCapability, type);
223 }
224 SoftBusFree(netInfo);
225 SoftBusFree(msg);
226 }
227
WifiStateProcess(uint32_t netCapability,bool isSend)228 static void WifiStateProcess(uint32_t netCapability, bool isSend)
229 {
230 if (LnnSetLocalNumInfo(NUM_KEY_NET_CAP, (int32_t)netCapability) != SOFTBUS_OK) {
231 return;
232 }
233 if (!isSend) {
234 return;
235 }
236 uint32_t type = (1 << (uint32_t)DISCOVERY_TYPE_BLE) | (1 << (uint32_t)DISCOVERY_TYPE_BR);
237 SendNetCapabilityToRemote(netCapability, type);
238 LNN_LOGI(LNN_BUILDER, "WifiStateEventHandler exit");
239 return;
240 }
241
IsP2pAvailable(bool isApSwitchOn)242 static bool IsP2pAvailable(bool isApSwitchOn)
243 {
244 bool isTripleMode = SoftBusIsWifiTripleMode();
245 return g_isWifiDirectSupported && (g_isApCoexistSupported || !isApSwitchOn || isTripleMode) && g_isWifiEnable;
246 }
247
LnnSetNetworkCapability(uint32_t * capability)248 static void LnnSetNetworkCapability(uint32_t *capability)
249 {
250 (void)LnnSetNetCapability(capability, BIT_WIFI);
251 (void)LnnSetNetCapability(capability, BIT_WIFI_5G);
252 (void)LnnSetNetCapability(capability, BIT_WIFI_24G);
253 }
254
LnnClearNetworkCapability(uint32_t * capability)255 static void LnnClearNetworkCapability(uint32_t *capability)
256 {
257 (void)LnnClearNetCapability(capability, BIT_WIFI);
258 (void)LnnClearNetCapability(capability, BIT_WIFI_5G);
259 (void)LnnClearNetCapability(capability, BIT_WIFI_24G);
260 }
261
LnnSetNetBandCapability(uint32_t * capability)262 static void LnnSetNetBandCapability(uint32_t *capability)
263 {
264 SoftBusBand band = SoftBusGetLinkBand();
265 if (band == BAND_24G) {
266 (void)LnnSetNetCapability(capability, BIT_WIFI_24G);
267 (void)LnnClearNetCapability(capability, BIT_WIFI_5G);
268 } else if (band == BAND_5G) {
269 (void)LnnSetNetCapability(capability, BIT_WIFI_5G);
270 (void)LnnClearNetCapability(capability, BIT_WIFI_24G);
271 } else {
272 (void)LnnSetNetCapability(capability, BIT_WIFI_5G);
273 (void)LnnSetNetCapability(capability, BIT_WIFI_24G);
274 }
275 }
276
LnnClearNetBandCapability(uint32_t * capability)277 static void LnnClearNetBandCapability(uint32_t *capability)
278 {
279 if (!g_isApEnable) {
280 (void)LnnClearNetCapability(capability, BIT_WIFI_5G);
281 (void)LnnClearNetCapability(capability, BIT_WIFI_24G);
282 }
283 }
284
LnnSetP2pNetCapability(uint32_t * capability)285 static void LnnSetP2pNetCapability(uint32_t *capability)
286 {
287 SoftBusWifiDetailState wifiState = SoftBusGetWifiState();
288 if (wifiState == SOFTBUS_WIFI_STATE_INACTIVE || wifiState == SOFTBUS_WIFI_STATE_DEACTIVATING) {
289 (void)LnnClearNetCapability(capability, BIT_WIFI_P2P);
290 } else {
291 (void)LnnSetNetCapability(capability, BIT_WIFI_P2P);
292 }
293 }
294
ProcessApEnabled(uint32_t * capability,bool * needSync)295 static void ProcessApEnabled(uint32_t *capability, bool *needSync)
296 {
297 g_isApEnable = true;
298 LnnSetNetworkCapability(capability);
299 if (IsP2pAvailable(true)) {
300 (void)LnnSetNetCapability(capability, BIT_WIFI_P2P);
301 }
302 *needSync = true;
303 }
304
ProcessApDisabled(uint32_t * capability,bool * needSync)305 static void ProcessApDisabled(uint32_t *capability, bool *needSync)
306 {
307 g_isApEnable = false;
308 if (IsP2pAvailable(false)) {
309 (void)LnnSetNetCapability(capability, BIT_WIFI_P2P);
310 }
311 *needSync = true;
312 }
313
GetNetworkCapability(SoftBusWifiState wifiState,uint32_t * capability,bool * needSync)314 static void GetNetworkCapability(SoftBusWifiState wifiState, uint32_t *capability, bool *needSync)
315 {
316 switch (wifiState) {
317 case SOFTBUS_WIFI_OBTAINING_IPADDR:
318 (void)LnnSetNetCapability(capability, BIT_WIFI);
319 LnnSetNetBandCapability(capability);
320 break;
321 case SOFTBUS_WIFI_ENABLED:
322 g_isWifiEnable = true;
323 (void)LnnSetNetCapability(capability, BIT_WIFI);
324 (void)LnnSetNetCapability(capability, BIT_WIFI_P2P);
325 *needSync = true;
326 break;
327 case SOFTBUS_WIFI_CONNECTED:
328 (void)LnnSetNetCapability(capability, BIT_WIFI);
329 (void)LnnSetNetCapability(capability, BIT_WIFI_P2P);
330 LnnSetNetBandCapability(capability);
331 *needSync = true;
332 break;
333 case SOFTBUS_WIFI_DISCONNECTED:
334 LnnClearNetBandCapability(capability);
335 *needSync = true;
336 break;
337 case SOFTBUS_WIFI_DISABLED:
338 g_isWifiEnable = false;
339 if (!g_isApEnable) {
340 LnnClearNetworkCapability(capability);
341 LnnSetP2pNetCapability(capability);
342 }
343 *needSync = true;
344 break;
345 case SOFTBUS_AP_ENABLED:
346 ProcessApEnabled(capability, needSync);
347 break;
348 case SOFTBUS_AP_DISABLED:
349 ProcessApDisabled(capability, needSync);
350 break;
351 case SOFTBUS_WIFI_SEMI_ACTIVE:
352 g_isWifiEnable = true;
353 (void)LnnSetNetCapability(capability, BIT_WIFI_P2P);
354 *needSync = true;
355 break;
356 default:
357 break;
358 }
359 }
360
WifiStateEventHandler(const LnnEventBasicInfo * info)361 static void WifiStateEventHandler(const LnnEventBasicInfo *info)
362 {
363 if (info == NULL || info->event != LNN_EVENT_WIFI_STATE_CHANGED) {
364 LNN_LOGE(LNN_BUILDER, "bt state change evt handler get invalid param");
365 return;
366 }
367 const LnnMonitorWlanStateChangedEvent *event = (const LnnMonitorWlanStateChangedEvent *)info;
368 SoftBusWifiState wifiState = (SoftBusWifiState)event->status;
369 uint32_t oldNetCap = 0;
370 if (LnnGetLocalNumU32Info(NUM_KEY_NET_CAP, &oldNetCap) != SOFTBUS_OK) {
371 LNN_LOGE(LNN_BUILDER, "wifi state handler get capability fail from local.");
372 return;
373 }
374 bool needSync = false;
375 uint32_t netCapability = oldNetCap;
376 GetNetworkCapability(wifiState, &netCapability, &needSync);
377 LNN_LOGI(LNN_BUILDER, "WifiState=%{public}d, local capabilty change:%{public}u->%{public}u, needSync=%{public}d",
378 wifiState, oldNetCap, netCapability, needSync);
379 WifiStateProcess(netCapability, needSync);
380 }
381
BtStateChangeEventHandler(const LnnEventBasicInfo * info)382 static void BtStateChangeEventHandler(const LnnEventBasicInfo *info)
383 {
384 if (info == NULL || info->event != LNN_EVENT_BT_STATE_CHANGED) {
385 LNN_LOGE(LNN_BUILDER, "HB bt state change evt handler get invalid param");
386 return;
387 }
388 uint32_t netCapability = 0;
389 if (LnnGetLocalNumU32Info(NUM_KEY_NET_CAP, &netCapability) != SOFTBUS_OK) {
390 LNN_LOGE(LNN_BUILDER, "get netcap fail");
391 return;
392 }
393 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
394 SoftBusBtState btState = (SoftBusBtState)event->status;
395 bool isSend = false;
396 LNN_LOGI(LNN_BUILDER, "bt state change btState=%{public}d", btState);
397 switch (btState) {
398 case SOFTBUS_BR_TURN_ON:
399 (void)LnnSetNetCapability(&netCapability, BIT_BR);
400 break;
401 case SOFTBUS_BLE_TURN_ON:
402 (void)LnnSetNetCapability(&netCapability, BIT_BLE);
403 break;
404 case SOFTBUS_BR_TURN_OFF:
405 (void)LnnClearNetCapability(&netCapability, BIT_BR);
406 break;
407 case SOFTBUS_BLE_TURN_OFF:
408 (void)LnnClearNetCapability(&netCapability, BIT_BLE);
409 isSend = true;
410 break;
411 default:
412 return;
413 }
414
415 LNN_LOGI(LNN_BUILDER, "bt state change. netCapability=%{public}d, isSend=%{public}d",
416 netCapability, isSend);
417 if (LnnSetLocalNumInfo(NUM_KEY_NET_CAP, (int32_t)netCapability) != SOFTBUS_OK) {
418 LNN_LOGE(LNN_BUILDER, "set cap to local ledger fail");
419 return;
420 }
421 if (!isSend) {
422 return;
423 }
424 SendNetCapabilityToRemote(netCapability, 1 << (uint32_t)DISCOVERY_TYPE_WIFI);
425 return;
426 }
427
IsSupportApCoexist(const char * coexistCap)428 static bool IsSupportApCoexist(const char *coexistCap)
429 {
430 cJSON *coexistObj = cJSON_ParseWithLength(coexistCap, strlen(coexistCap) + 1);
431 LNN_CHECK_AND_RETURN_RET_LOGE(coexistObj, false, LNN_BUILDER, "create json object failed");
432
433 if (!cJSON_IsArray(coexistObj)) {
434 cJSON_Delete(coexistObj);
435 LNN_LOGE(LNN_BUILDER, "coexistObj is not a array");
436 return false;
437 }
438
439 for (int i = 0; i < cJSON_GetArraySize(coexistObj); i++) {
440 cJSON *subItems = cJSON_GetArrayItem(coexistObj, i);
441 if (!cJSON_IsArray(subItems)) {
442 LNN_LOGE(LNN_BUILDER, "item is not array, i=%{public}d", i);
443 continue;
444 }
445
446 bool apCap = false;
447 bool p2pCap = false;
448 for (int j = 0; j < cJSON_GetArraySize(subItems); j++) {
449 cJSON *subItem = cJSON_GetArrayItem(subItems, j);
450 char interface[NET_IF_NAME_LEN] = {0};
451 if (!GetJsonObjectStringItem(subItem, "IF", interface, sizeof(interface))) {
452 LNN_LOGE(LNN_BUILDER, "get interface failed");
453 continue;
454 }
455
456 enum WifiDirectApiRole mode = WIFI_DIRECT_API_ROLE_NONE;
457 if (!GetJsonObjectInt32Item(subItem, "MODE", (int32_t *)&mode)) {
458 LNN_LOGE(LNN_BUILDER, "interface get mode failed. interface=%{public}s", interface);
459 continue;
460 }
461
462 LNN_LOGI(LNN_BUILDER, "interface=%{public}s, mode=%{public}d", interface, mode);
463 if ((mode & WIFI_DIRECT_API_ROLE_AP)) {
464 apCap = true;
465 } else if ((mode & WIFI_DIRECT_API_ROLE_GC) || (mode & WIFI_DIRECT_API_ROLE_GO)) {
466 p2pCap = true;
467 }
468 if (apCap && p2pCap) {
469 cJSON_Delete(coexistObj);
470 return true;
471 }
472 }
473 }
474
475 cJSON_Delete(coexistObj);
476 return false;
477 }
478
InitWifiDirectCapability(void)479 static void InitWifiDirectCapability(void)
480 {
481 g_isWifiDirectSupported = SoftBusHasWifiDirectCapability();
482 char *coexistCap = SoftBusGetWifiInterfaceCoexistCap();
483 LNN_CHECK_AND_RETURN_LOGE(coexistCap != NULL, LNN_INIT, "coexistCap is null");
484 LNN_LOGI(LNN_BUILDER, "coexistCap=%{public}s", coexistCap);
485 g_isApCoexistSupported = IsSupportApCoexist(coexistCap);
486 SoftBusFree(coexistCap);
487 LNN_LOGI(LNN_BUILDER, "g_isWifiDirectSupported=%{public}d, g_isApCoexistSupported=%{public}d",
488 g_isWifiDirectSupported, g_isApCoexistSupported);
489 }
490
LnnInitNetworkInfo(void)491 int32_t LnnInitNetworkInfo(void)
492 {
493 InitWifiDirectCapability();
494 if (LnnRegisterEventHandler(LNN_EVENT_BT_STATE_CHANGED, BtStateChangeEventHandler) != SOFTBUS_OK) {
495 LNN_LOGE(LNN_BUILDER, "network info register bt state change fail");
496 return SOFTBUS_ERR;
497 }
498 if (LnnRegisterEventHandler(LNN_EVENT_WIFI_STATE_CHANGED, WifiStateEventHandler) != SOFTBUS_OK) {
499 LNN_LOGE(LNN_BUILDER, "network info register wifi state change fail");
500 return SOFTBUS_ERR;
501 }
502 if (LnnRegSyncInfoHandler(LNN_INFO_TYPE_CAPABILITY, OnReceiveCapaSyncInfoMsg) != SOFTBUS_OK) {
503 return SOFTBUS_ERR;
504 }
505 LNN_LOGE(LNN_BUILDER, "lnn init network info sync done");
506 return SOFTBUS_OK;
507 }
508
LnnDeinitNetworkInfo(void)509 void LnnDeinitNetworkInfo(void)
510 {
511 (void)LnnUnregSyncInfoHandler(LNN_INFO_TYPE_CAPABILITY, OnReceiveCapaSyncInfoMsg);
512 }
513