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 #include "lnn_heartbeat_ctrl.h"
17 
18 #include <securec.h>
19 #include <stdatomic.h>
20 #include <string.h>
21 
22 #include "anonymizer.h"
23 #include "auth_device_common_key.h"
24 #include "auth_interface.h"
25 #include "auth_manager.h"
26 #include "bus_center_manager.h"
27 #include "lnn_async_callback_utils.h"
28 #include "lnn_ble_heartbeat.h"
29 #include "lnn_common_utils.h"
30 #include "lnn_data_cloud_sync.h"
31 #include "lnn_decision_db.h"
32 #include "lnn_device_info_recovery.h"
33 #include "lnn_deviceinfo_to_profile.h"
34 #include "lnn_devicename_info.h"
35 #include "lnn_distributed_net_ledger.h"
36 #include "lnn_feature_capability.h"
37 #include "lnn_heartbeat_strategy.h"
38 #include "lnn_heartbeat_utils.h"
39 #include "lnn_kv_adapter_wrapper.h"
40 #include "lnn_local_net_ledger.h"
41 #include "lnn_log.h"
42 #include "lnn_meta_node_ledger.h"
43 #include "lnn_net_builder.h"
44 #include "lnn_network_manager.h"
45 #include "lnn_ohos_account.h"
46 #include "lnn_parameter_utils.h"
47 
48 #include "softbus_adapter_bt_common.h"
49 #include "softbus_adapter_mem.h"
50 #include "softbus_broadcast_type.h"
51 #include "softbus_def.h"
52 #include "softbus_errcode.h"
53 #include "softbus_hisysevt_bus_center.h"
54 #include "softbus_utils.h"
55 
56 #define HB_LOOPBACK_IP "127.0.0.1"
57 
58 typedef struct {
59     SoftBusBtState btState;
60     SoftBusScreenLockState lockState;
61     SoftBusScreenState screenState;
62     SoftBusAccountState accountState;
63     SoftBusUserState backgroundState;
64     SoftBusNightModeState nightModeState;
65     SoftBusOOBEState OOBEState;
66     bool hasTrustedRelation;
67     bool heartbeatEnable;
68     bool isRequestDisable;
69 } HbConditionState;
70 
71 static HbConditionState g_hbConditionState;
72 static int64_t g_lastScreenOnTime = 0;
73 static int64_t g_lastScreenOffTime = 0;
74 static atomic_bool g_enableState = false;
75 static bool g_isScreenOnOnce = false;
76 
InitHbConditionState(void)77 static void InitHbConditionState(void)
78 {
79     g_hbConditionState.btState = SOFTBUS_BT_UNKNOWN;
80     g_hbConditionState.screenState = SOFTBUS_SCREEN_UNKNOWN;
81     g_hbConditionState.lockState = SOFTBUS_SCREEN_LOCK_UNKNOWN;
82     // need suit for same account
83     g_hbConditionState.accountState = SOFTBUS_ACCOUNT_UNKNOWN;
84     g_hbConditionState.backgroundState = SOFTBUS_USER_FOREGROUND;
85     g_hbConditionState.nightModeState = SOFTBUS_NIGHT_MODE_UNKNOWN;
86     g_hbConditionState.hasTrustedRelation = false;
87     g_hbConditionState.isRequestDisable = false;
88     g_hbConditionState.heartbeatEnable = false;
89     g_hbConditionState.OOBEState = SOFTBUS_OOBE_UNKNOWN;
90     LNN_LOGI(LNN_INIT, "condition state:heartbeat=%{public}d", g_hbConditionState.heartbeatEnable);
91 }
92 
InitHbSpecificConditionState(void)93 static void InitHbSpecificConditionState(void)
94 {
95     int32_t localDevTypeId = 0;
96     if (LnnGetLocalNumInfo(NUM_KEY_DEV_TYPE_ID, &localDevTypeId) != SOFTBUS_OK) {
97         return;
98     }
99     if (localDevTypeId == TYPE_WATCH_ID) {
100         LNN_LOGD(LNN_INIT, "localDevTypeId=%{public}d", localDevTypeId);
101         g_hbConditionState.isRequestDisable = true;
102     }
103 }
104 
IsHeartbeatEnable(void)105 bool IsHeartbeatEnable(void)
106 {
107     if ((g_hbConditionState.lockState == SOFTBUS_SCREEN_LOCK_UNKNOWN) && IsActiveOsAccountUnlocked()) {
108         g_hbConditionState.lockState = SOFTBUS_SCREEN_UNLOCK;
109     }
110     bool isBtOn = ((g_hbConditionState.btState != SOFTBUS_BLE_TURN_OFF) &&
111         (g_hbConditionState.btState != SOFTBUS_BT_UNKNOWN));
112     bool isScreenUnlock = g_hbConditionState.lockState == SOFTBUS_SCREEN_UNLOCK;
113     bool isLogIn = g_hbConditionState.accountState == SOFTBUS_ACCOUNT_LOG_IN;
114     bool isBackground = g_hbConditionState.backgroundState == SOFTBUS_USER_BACKGROUND;
115     bool isNightMode = g_hbConditionState.nightModeState == SOFTBUS_NIGHT_MODE_ON;
116     bool isOOBEEnd =
117         g_hbConditionState.OOBEState == SOFTBUS_OOBE_END || g_hbConditionState.OOBEState == SOFTBUS_FACK_OOBE_END;
118 
119     LNN_LOGI(LNN_HEART_BEAT,
120         "HB condition state: bt=%{public}d, screenUnlock=%{public}d, account=%{public}d, trustedRelation=%{public}d, "
121         "background=%{public}d, nightMode=%{public}d, OOBEEnd=%{public}d, heartbeatEnable=%{public}d, "
122         "request=%{public}d",
123         isBtOn, isScreenUnlock, isLogIn, g_hbConditionState.hasTrustedRelation, isBackground, isNightMode, isOOBEEnd,
124         g_hbConditionState.heartbeatEnable, g_hbConditionState.isRequestDisable);
125     return g_hbConditionState.heartbeatEnable && isBtOn && isScreenUnlock && !g_hbConditionState.isRequestDisable &&
126         (isLogIn || g_hbConditionState.hasTrustedRelation) && !isBackground && !isNightMode && isOOBEEnd;
127 }
128 
GetScreenState(void)129 SoftBusScreenState GetScreenState(void)
130 {
131     return g_hbConditionState.screenState;
132 }
133 
SetScreenState(SoftBusScreenState state)134 void SetScreenState(SoftBusScreenState state)
135 {
136     g_hbConditionState.screenState = state;
137 }
138 
HbRefreshConditionState(void)139 static void HbRefreshConditionState(void)
140 {
141     if (SoftBusGetBtState() == BLE_ENABLE) {
142         g_hbConditionState.btState = SOFTBUS_BLE_TURN_ON;
143     }
144     LnnUpdateOhosAccount(false);
145     if (!LnnIsDefaultOhosAccount()) {
146         g_hbConditionState.accountState = SOFTBUS_ACCOUNT_LOG_IN;
147     }
148     if (IsActiveOsAccountUnlocked()) {
149         g_hbConditionState.lockState = SOFTBUS_SCREEN_UNLOCK;
150     }
151     TrustedReturnType ret = AuthHasTrustedRelation();
152     if (ret == TRUSTED_RELATION_YES) {
153         g_hbConditionState.hasTrustedRelation = true;
154     } else if (ret == TRUSTED_RELATION_NO) {
155         g_hbConditionState.hasTrustedRelation = false;
156     }
157     if (g_hbConditionState.lockState == SOFTBUS_SCREEN_UNLOCK &&
158         (g_hbConditionState.accountState == SOFTBUS_ACCOUNT_LOG_IN || g_hbConditionState.hasTrustedRelation)) {
159         g_hbConditionState.heartbeatEnable = IsEnableSoftBusHeartbeat();
160     }
161 }
162 
HbIpAddrChangeEventHandler(const LnnEventBasicInfo * info)163 static void HbIpAddrChangeEventHandler(const LnnEventBasicInfo *info)
164 {
165     char localIp[IP_LEN] = { 0 };
166 
167     if (info == NULL || info->event != LNN_EVENT_IP_ADDR_CHANGED) {
168         LNN_LOGE(LNN_HEART_BEAT, "ip addr change evt handler get invalid param");
169         return;
170     }
171     if (LnnGetLocalStrInfo(STRING_KEY_WLAN_IP, localIp, IP_LEN) != SOFTBUS_OK) {
172         LNN_LOGE(LNN_HEART_BEAT, "get local ip err");
173         return;
174     }
175     if (strcmp(localIp, HB_LOOPBACK_IP) == 0 &&
176         LnnEnableHeartbeatByType(HEARTBEAT_TYPE_TCP_FLUSH, false) != SOFTBUS_OK) {
177         LNN_LOGE(LNN_HEART_BEAT, "ctrl disable tcp flush fail");
178         return;
179     }
180     if (LnnEnableHeartbeatByType(HEARTBEAT_TYPE_TCP_FLUSH, true) != SOFTBUS_OK) {
181         LNN_LOGE(LNN_HEART_BEAT, "ctrl enable tcp flush fail");
182         return;
183     }
184 }
185 
HbSendCheckOffLineMessage(LnnHeartbeatType hbType)186 static void HbSendCheckOffLineMessage(LnnHeartbeatType hbType)
187 {
188     int32_t i, infoNum;
189     NodeBasicInfo *info = NULL;
190     if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
191         LNN_LOGE(LNN_HEART_BEAT, "check dev status get online node info failed");
192         return;
193     }
194     if (info == NULL || infoNum == 0) {
195         LNN_LOGE(LNN_HEART_BEAT, "check dev status get online node is 0");
196         return;
197     }
198     for (i = 0; i < infoNum; ++i) {
199         if (LnnIsLSANode(&info[i])) {
200             continue;
201         }
202         (void)LnnStopScreenChangeOfflineTiming(info[i].networkId, LnnConvertHbTypeToConnAddrType(hbType));
203         if (LnnStartScreenChangeOfflineTiming(info[i].networkId, LnnConvertHbTypeToConnAddrType(hbType)) !=
204             SOFTBUS_OK) {
205             LNN_LOGE(LNN_HEART_BEAT, "send check offline target msg failed");
206         }
207     }
208     SoftBusFree(info);
209 }
210 
HbConditionChanged(bool isOnlySetState)211 static void HbConditionChanged(bool isOnlySetState)
212 {
213     HbRefreshConditionState();
214     bool isEnable = IsHeartbeatEnable();
215     if (g_enableState == isEnable) {
216         LNN_LOGI(LNN_HEART_BEAT, "ctrl ignore same enable request, isEnable=%{public}d", isEnable);
217         return;
218     }
219     LnnNotifyNetworkStateChanged(isEnable ? SOFTBUS_BLE_NETWORKD_ENABLE : SOFTBUS_BLE_NETWORKD_DISABLE);
220     if (LnnEnableHeartbeatByType(HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V1 | HEARTBEAT_TYPE_BLE_V3, isEnable) !=
221         SOFTBUS_OK) {
222         LNN_LOGE(LNN_HEART_BEAT, "ctrl enable ble heartbeat fail");
223         return;
224     }
225     if (isOnlySetState) {
226         LNN_LOGD(LNN_HEART_BEAT, "condition changed only set state");
227         g_enableState = isEnable;
228         return;
229     }
230     if (isEnable) {
231         LNN_LOGD(LNN_HEART_BEAT, "condition changed to enabled");
232         if (LnnStartHbByTypeAndStrategy(
233             HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false) != SOFTBUS_OK) {
234             LNN_LOGE(LNN_HEART_BEAT, "start ble heartbeat fail");
235         }
236         g_enableState = true;
237         LnnStartHeartbeat(0);
238     } else {
239         LNN_LOGD(LNN_HEART_BEAT, "condition changed to disabled");
240         if (LnnStopHeartbeatByType(HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V1 | HEARTBEAT_TYPE_BLE_V3) !=
241             SOFTBUS_OK) {
242             LNN_LOGE(LNN_HEART_BEAT, "stop ble heartbeat fail");
243         }
244         g_enableState = false;
245     }
246 }
247 
GetDisEnableBleDiscoveryTime(uint64_t modeDuration)248 static uint64_t GetDisEnableBleDiscoveryTime(uint64_t modeDuration)
249 {
250     uint64_t timeout = 0ULL;
251     if (modeDuration < MIN_DISABLE_BLE_DISCOVERY_TIME) {
252         timeout = MIN_DISABLE_BLE_DISCOVERY_TIME;
253     } else {
254         timeout = (modeDuration > MAX_DISABLE_BLE_DISCOVERY_TIME) ? MAX_DISABLE_BLE_DISCOVERY_TIME : modeDuration;
255     }
256     return timeout;
257 }
258 
RequestEnableDiscovery(void * para)259 static void RequestEnableDiscovery(void *para)
260 {
261     (void)para;
262     if (!g_hbConditionState.isRequestDisable) {
263         LNN_LOGI(LNN_HEART_BEAT, "ble has been enabled, don't need  restore enabled");
264         return;
265     }
266     g_hbConditionState.isRequestDisable = false;
267     LNN_LOGI(LNN_HEART_BEAT, "ble has been requestEnable");
268     HbConditionChanged(false);
269 }
270 
LnnRequestBleDiscoveryProcess(int32_t strategy,int64_t timeout)271 void LnnRequestBleDiscoveryProcess(int32_t strategy, int64_t timeout)
272 {
273     LNN_LOGI(LNN_HEART_BEAT, "LnnRequestBleDiscoveryProcess enter");
274     if (strategy == REQUEST_DISABLE_BLE_DISCOVERY) {
275         if (g_hbConditionState.isRequestDisable) {
276             LNN_LOGI(LNN_HEART_BEAT, "ble has been requestDisabled, need wait timeout or enabled");
277             return;
278         }
279         uint64_t time = GetDisEnableBleDiscoveryTime((uint64_t)timeout);
280         if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), RequestEnableDiscovery, NULL, time) !=
281             SOFTBUS_OK) {
282             LNN_LOGI(LNN_HEART_BEAT, "ble has been requestDisabled fail, due to async callback fail");
283             return;
284         }
285         g_hbConditionState.isRequestDisable = true;
286         LNN_LOGI(LNN_HEART_BEAT, "ble has been requestDisabled");
287         HbConditionChanged(false);
288     } else if (strategy == REQUEST_ENABLE_BLE_DISCOVERY) {
289         RequestEnableDiscovery(NULL);
290     } else {
291         LNN_LOGE(LNN_HEART_BEAT, "error strategy, not need to deal. strategy=%{public}d", strategy);
292     }
293 }
294 
HbHandleLeaveLnn(void)295 static int32_t HbHandleLeaveLnn(void)
296 {
297     int32_t i;
298     int32_t infoNum;
299     NodeBasicInfo *info = NULL;
300     if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
301         LNN_LOGE(LNN_HEART_BEAT, "get online node info failed");
302         return SOFTBUS_ERR;
303     }
304     if (info == NULL || infoNum == 0) {
305         LNN_LOGE(LNN_HEART_BEAT, "get online node is 0");
306         return SOFTBUS_ERR;
307     }
308     int32_t ret;
309     NodeInfo nodeInfo;
310     (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
311     for (i = 0; i < infoNum; ++i) {
312         ret = LnnGetRemoteNodeInfoById(info[i].networkId, CATEGORY_NETWORK_ID, &nodeInfo);
313         if (ret != SOFTBUS_OK) {
314             continue;
315         }
316         if ((nodeInfo.feature & (1 << BIT_SUPPORT_THREE_STATE)) == 0 && SoftBusGetBrState() == BR_DISABLE) {
317             LNN_LOGI(LNN_HEART_BEAT, "peer don't support three state and local br off");
318             LnnRequestLeaveSpecific(info[i].networkId, CONNECTION_ADDR_BLE);
319         }
320     }
321     SoftBusFree(info);
322     return SOFTBUS_OK;
323 }
324 
HbDelaySetNormalScanParam(void * para)325 static void HbDelaySetNormalScanParam(void *para)
326 {
327     (void)para;
328     LnnHeartbeatMediumParam param;
329     (void)memset_s(&param, sizeof(LnnHeartbeatMediumParam), 0, sizeof(LnnHeartbeatMediumParam));
330     if (g_hbConditionState.screenState == SOFTBUS_SCREEN_OFF && !LnnIsLocalSupportBurstFeature()) {
331         param.type = HEARTBEAT_TYPE_BLE_V1;
332         param.info.ble.scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P2;
333         param.info.ble.scanWindow = SOFTBUS_BC_SCAN_WINDOW_P2;
334     } else {
335         param.type = HEARTBEAT_TYPE_BLE_V1;
336         param.info.ble.scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P10;
337         param.info.ble.scanWindow = SOFTBUS_BC_SCAN_WINDOW_P10;
338     }
339     LNN_LOGI(LNN_HEART_BEAT, "scanInterval=%{public}d, scanWindow=%{public}d", param.info.ble.scanInterval,
340         param.info.ble.scanWindow);
341     if (LnnSetMediumParamBySpecificType(&param) != SOFTBUS_OK) {
342         LNN_LOGE(LNN_HEART_BEAT, "ctrl reset ble scan medium param fail");
343     }
344 }
345 
HbDelaySetHighScanParam(void * para)346 static void HbDelaySetHighScanParam(void *para)
347 {
348     (void)para;
349 
350     if (g_hbConditionState.screenState == SOFTBUS_SCREEN_OFF) {
351         LNN_LOGD(LNN_HEART_BEAT, "screen off, no need handle");
352         return;
353     }
354     LnnHeartbeatMediumParam param = {
355         .type = HEARTBEAT_TYPE_BLE_V1,
356         .info.ble.scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P25,
357         .info.ble.scanWindow = SOFTBUS_BC_SCAN_WINDOW_P25,
358     };
359     LNN_LOGI(LNN_HEART_BEAT, "scanInterval=%{public}d, scanWindow=%{public}d", param.info.ble.scanInterval,
360         param.info.ble.scanWindow);
361     if (LnnSetMediumParamBySpecificType(&param) != SOFTBUS_OK) {
362         LNN_LOGE(LNN_HEART_BEAT, "ctrl reset ble scan medium param fail");
363     }
364 }
365 
HbHandleBleStateChange(SoftBusBtState btState)366 static void HbHandleBleStateChange(SoftBusBtState btState)
367 {
368     g_enableState = false;
369     LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_BLE_TURN_ON, state=%{public}d", btState);
370     LnnUpdateHeartbeatInfo(UPDATE_BT_STATE_OPEN_INFO);
371     ClearAuthLimitMap();
372     ClearLnnBleReportExtraMap();
373     HbConditionChanged(false);
374     if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelaySetHighScanParam, NULL, 0) != SOFTBUS_OK) {
375         LNN_LOGE(LNN_HEART_BEAT, "HB async set high param fail");
376     }
377     if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelaySetNormalScanParam, NULL,
378         HB_START_DELAY_LEN + HB_SEND_RELAY_LEN_ONCE) != SOFTBUS_OK) {
379         LNN_LOGE(LNN_HEART_BEAT, "HB async set normal param fail");
380     }
381     if (LnnStartHbByTypeAndStrategy(HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3,
382         STRATEGY_HB_SEND_ADJUSTABLE_PERIOD, false) != SOFTBUS_OK) {
383         LNN_LOGE(LNN_HEART_BEAT, "start ble heartbeat fail");
384     }
385     if (btState == SOFTBUS_BR_TURN_ON) {
386         LnnUpdateHeartbeatInfo(UPDATE_BR_TURN_ON_INFO);
387     }
388 }
389 
HbBtStateChangeEventHandler(const LnnEventBasicInfo * info)390 static void HbBtStateChangeEventHandler(const LnnEventBasicInfo *info)
391 {
392     if (info == NULL || info->event != LNN_EVENT_BT_STATE_CHANGED) {
393         LNN_LOGE(LNN_HEART_BEAT, "bt state change evt handler get invalid param");
394         return;
395     }
396     const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
397     SoftBusBtState btState = (SoftBusBtState)event->status;
398     g_hbConditionState.btState = btState;
399     switch (btState) {
400         case SOFTBUS_BLE_TURN_ON:
401         case SOFTBUS_BR_TURN_ON:
402             HbHandleBleStateChange(btState);
403             break;
404         case SOFTBUS_BR_TURN_OFF:
405             if (SoftBusGetBtState() == BLE_DISABLE) {
406                 LNN_LOGE(LNN_HEART_BEAT, "ble is off");
407                 return;
408             }
409             g_enableState = false;
410             LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_BR_TURN_OFF, state=%{public}d", btState);
411             (void)HbHandleLeaveLnn();
412             HbConditionChanged(false);
413             if (LnnStartHbByTypeAndStrategy(HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3,
414                 STRATEGY_HB_SEND_ADJUSTABLE_PERIOD, false) != SOFTBUS_OK) {
415                 LNN_LOGE(LNN_HEART_BEAT, "start ble heartbeat fail");
416             }
417             break;
418         case SOFTBUS_BLE_TURN_OFF:
419             LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_BLE_TURN_OFF");
420             HbConditionChanged(false);
421             ClearAuthLimitMap();
422             ClearLnnBleReportExtraMap();
423             break;
424         default:
425             return;
426     }
427 }
428 
HbLaneVapChangeEventHandler(const LnnEventBasicInfo * info)429 static void HbLaneVapChangeEventHandler(const LnnEventBasicInfo *info)
430 {
431     if (info == NULL || info->event != LNN_EVENT_LANE_VAP_CHANGE) {
432         LNN_LOGE(LNN_HEART_BEAT, "invalid param");
433         return;
434     }
435     LnnLaneVapChangeEvent *vap = (LnnLaneVapChangeEvent *)info;
436     if (SoftBusGetBtState() == BLE_DISABLE) {
437         LNN_LOGE(LNN_HEART_BEAT, "ble is off");
438         return;
439     }
440     LNN_LOGI(LNN_HEART_BEAT, "HB handle vapChange, channel=%{public}d", vap->vapPreferChannel);
441     if (LnnStartHbByTypeAndStrategy(
442         HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false) != SOFTBUS_OK) {
443         LNN_LOGE(LNN_HEART_BEAT, "start ble heartbeat fail");
444     }
445 }
446 
HbMasterNodeChangeEventHandler(const LnnEventBasicInfo * info)447 static void HbMasterNodeChangeEventHandler(const LnnEventBasicInfo *info)
448 {
449     if (info == NULL || info->event != LNN_EVENT_NODE_MASTER_STATE_CHANGED) {
450         LNN_LOGE(LNN_HEART_BEAT, "master node change evt handler get invalid param");
451         return;
452     }
453 
454     const LnnMasterNodeChangedEvent *event = (LnnMasterNodeChangedEvent *)info;
455     if (LnnSetHbAsMasterNodeState(event->isMasterNode) != SOFTBUS_OK) {
456         LNN_LOGE(LNN_HEART_BEAT, "ctrl change master node state fail");
457     }
458 }
459 
HbRemoveCheckOffLineMessage(LnnHeartbeatType hbType)460 static void HbRemoveCheckOffLineMessage(LnnHeartbeatType hbType)
461 {
462     if (hbType <= HEARTBEAT_TYPE_MIN || hbType >= HEARTBEAT_TYPE_MAX) {
463         LNN_LOGE(LNN_HEART_BEAT, "get invalid hbType param");
464         return;
465     }
466     int32_t i, infoNum;
467     NodeBasicInfo *info = NULL;
468     if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
469         LNN_LOGE(LNN_HEART_BEAT, "check dev status get online node info failed");
470         return;
471     }
472     if (info == NULL || infoNum == 0) {
473         LNN_LOGE(LNN_HEART_BEAT, "check dev status get online node is 0");
474         return;
475     }
476     for (i = 0; i < infoNum; ++i) {
477         if (LnnIsLSANode(&info[i])) {
478             continue;
479         }
480         if (LnnStopScreenChangeOfflineTiming(info[i].networkId, LnnConvertHbTypeToConnAddrType(hbType)) != SOFTBUS_OK) {
481             char *anonyNetworkId = NULL;
482             Anonymize(info[i].networkId, &anonyNetworkId);
483             LNN_LOGE(LNN_HEART_BEAT, "stop check offline target msg failed, networkId=%{public}s", anonyNetworkId);
484             AnonymizeFree(anonyNetworkId);
485         }
486     }
487     SoftBusFree(info);
488 }
489 
HbChangeMediumParamByState(SoftBusScreenState state)490 static void HbChangeMediumParamByState(SoftBusScreenState state)
491 {
492     LnnHeartbeatMediumParam param = {
493         .type = HEARTBEAT_TYPE_BLE_V1,
494     };
495     switch (state) {
496         case SOFTBUS_SCREEN_ON:
497             param.info.ble.scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P10;
498             param.info.ble.scanWindow = SOFTBUS_BC_SCAN_WINDOW_P10;
499             break;
500         case SOFTBUS_SCREEN_OFF:
501             param.info.ble.scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P2;
502             param.info.ble.scanWindow = SOFTBUS_BC_SCAN_WINDOW_P2;
503             break;
504         default:
505             LNN_LOGD(LNN_HEART_BEAT, "ctrl reset ble scan medium param get invalid state");
506             return;
507     }
508     if (!LnnIsLocalSupportBurstFeature() && (LnnSetMediumParamBySpecificType(&param) != SOFTBUS_OK)) {
509         LNN_LOGE(LNN_HEART_BEAT, "ctrl reset ble scan medium param fail");
510         return;
511     }
512     LnnUpdateHeartbeatInfo(UPDATE_SCREEN_STATE_INFO);
513 }
514 
HbDelayConditionChanged(void * para)515 static void HbDelayConditionChanged(void *para)
516 {
517     (void)para;
518 
519     LNN_LOGI(LNN_HEART_BEAT, "HB handle delay condition changed");
520     LnnUpdateOhosAccount(true);
521     LnnUpdateSendInfoStrategy(UPDATE_HB_ACCOUNT_INFO);
522     LnnHbOnTrustedRelationIncreased(AUTH_IDENTICAL_ACCOUNT_GROUP);
523     g_hbConditionState.heartbeatEnable = IsEnableSoftBusHeartbeat();
524     HbConditionChanged(false);
525 }
526 
HbTryCloudSync(void)527 static int32_t HbTryCloudSync(void)
528 {
529     NodeInfo info;
530 
531     if (LnnIsDefaultOhosAccount()) {
532         LNN_LOGW(LNN_HEART_BEAT, "HB accountId is null, no need sync");
533         return SOFTBUS_NOT_LOGIN;
534     }
535     (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
536     if (LnnGetLocalNodeInfoSafe(&info) != SOFTBUS_OK) {
537         LNN_LOGE(LNN_HEART_BEAT, "HB save local device info fail");
538         return SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR;
539     }
540     int32_t ret = LnnLedgerAllDataSyncToDB(&info);
541     if (ret == SOFTBUS_OK) {
542         LNN_LOGI(LNN_HEART_BEAT, "HB sync to cloud end");
543     } else {
544         LNN_LOGE(LNN_HEART_BEAT, "HB sync to cloud fail");
545     }
546     return ret;
547 }
548 
HbScreenOnOnceTryCloudSync(void)549 static void HbScreenOnOnceTryCloudSync(void)
550 {
551     HbRefreshConditionState();
552     if (g_hbConditionState.screenState == SOFTBUS_SCREEN_ON && !g_isScreenOnOnce &&
553         g_hbConditionState.accountState == SOFTBUS_ACCOUNT_LOG_IN &&
554         g_hbConditionState.lockState == SOFTBUS_SCREEN_UNLOCK) {
555         LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelayConditionChanged, NULL,
556             HbTryCloudSync() == SOFTBUS_OK ? HB_CLOUD_SYNC_DELAY_LEN : 0);
557     }
558 }
559 
HbScreenOnChangeEventHandler(int64_t nowTime)560 static void HbScreenOnChangeEventHandler(int64_t nowTime)
561 {
562     LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_SCREEN_ON");
563     g_lastScreenOnTime = nowTime;
564     g_isScreenOnOnce = true;
565     HbRemoveCheckOffLineMessage(HEARTBEAT_TYPE_BLE_V1);
566     HbChangeMediumParamByState(g_hbConditionState.screenState);
567     if (g_lastScreenOnTime - g_lastScreenOffTime >= HB_SCREEN_ON_COAP_TIME) {
568         LNN_LOGD(LNN_HEART_BEAT, "screen on start coap discovery");
569         RestartCoapDiscovery();
570     }
571     int32_t ret = LnnStartHbByTypeAndStrategy(
572         HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false);
573     if (ret != SOFTBUS_OK) {
574         LNN_LOGE(LNN_HEART_BEAT, "start ble heartbeat failed, ret=%{public}d", ret);
575     }
576 }
577 
HbScreenStateChangeEventHandler(const LnnEventBasicInfo * info)578 static void HbScreenStateChangeEventHandler(const LnnEventBasicInfo *info)
579 {
580     int64_t nowTime;
581     SoftBusSysTime time = { 0 };
582     if (info == NULL || info->event != LNN_EVENT_SCREEN_STATE_CHANGED) {
583         LNN_LOGE(LNN_HEART_BEAT, "screen state evt handler get invalid param");
584         return;
585     }
586     const LnnMonitorHbStateChangedEvent *event = (LnnMonitorHbStateChangedEvent *)info;
587     if ((SoftBusScreenState)event->status == SOFTBUS_SCREEN_UNKNOWN) {
588         LNN_LOGE(LNN_HEART_BEAT, "get invalid screen state");
589         return;
590     }
591     SoftBusScreenState oldstate = g_hbConditionState.screenState;
592     g_hbConditionState.screenState = (SoftBusScreenState)event->status;
593     SoftBusGetRealTime(&time);
594     nowTime = time.sec * HB_TIME_FACTOR + time.usec / HB_TIME_FACTOR;
595     HbScreenOnOnceTryCloudSync();
596     if (g_hbConditionState.screenState == SOFTBUS_SCREEN_ON && oldstate != SOFTBUS_SCREEN_ON) {
597         (void)LnnUpdateLocalScreenStatus(true);
598         HbScreenOnChangeEventHandler(nowTime);
599         return;
600     }
601     if (g_hbConditionState.screenState == SOFTBUS_SCREEN_OFF && oldstate != SOFTBUS_SCREEN_OFF) {
602         LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_SCREEN_OFF");
603         g_lastScreenOffTime = nowTime;
604         (void)LnnUpdateLocalScreenStatus(false);
605         if (!LnnIsLocalSupportBurstFeature()) {
606             if (LnnStartHbByTypeAndStrategy(HEARTBEAT_TYPE_BLE_V0, STRATEGY_HB_SEND_SINGLE, false) != SOFTBUS_OK) {
607                 LNN_LOGE(LNN_HEART_BEAT, "start ble heartbeat failed");
608                 return;
609             }
610         }
611         if (LnnStopHeartBeatAdvByTypeNow(HEARTBEAT_TYPE_BLE_V1) != SOFTBUS_OK) {
612             LNN_LOGE(LNN_HEART_BEAT, "ctrl disable ble heartbeat failed");
613             return;
614         }
615         HbChangeMediumParamByState(g_hbConditionState.screenState);
616         HbSendCheckOffLineMessage(HEARTBEAT_TYPE_BLE_V1);
617     }
618 }
619 
HbScreenLockChangeEventHandler(const LnnEventBasicInfo * info)620 static void HbScreenLockChangeEventHandler(const LnnEventBasicInfo *info)
621 {
622     if (info == NULL || info->event != LNN_EVENT_SCREEN_LOCK_CHANGED) {
623         LNN_LOGE(LNN_HEART_BEAT, "lock state change evt handler get invalid param");
624         return;
625     }
626     const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
627     SoftBusScreenLockState lockState = (SoftBusScreenLockState)event->status;
628     if (lockState == SOFTBUS_USER_UNLOCK) {
629         LNN_LOGI(LNN_HEART_BEAT, "user unlocked");
630         (void)LnnGenerateCeParams();
631         AuthLoadDeviceKey();
632         LnnUpdateOhosAccount(true);
633         if (!LnnIsDefaultOhosAccount()) {
634             LnnNotifyAccountStateChangeEvent(SOFTBUS_ACCOUNT_LOG_IN);
635         }
636     }
637     lockState = lockState == SOFTBUS_USER_UNLOCK ? SOFTBUS_SCREEN_UNLOCK : lockState;
638     if (g_hbConditionState.lockState == SOFTBUS_SCREEN_UNLOCK) {
639         LNN_LOGI(LNN_HEART_BEAT, "screen unlocked once already, ignoring this event");
640         return;
641     }
642     g_hbConditionState.lockState = lockState;
643     LNN_LOGI(LNN_HEART_BEAT, "ScreenLock state: heartbeat=%{public}d", g_hbConditionState.heartbeatEnable);
644     switch (lockState) {
645         case SOFTBUS_SCREEN_UNLOCK:
646             LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_SCREEN_UNLOCK");
647             HbRefreshConditionState();
648             if (g_hbConditionState.screenState == SOFTBUS_SCREEN_ON &&
649                 g_hbConditionState.accountState == SOFTBUS_ACCOUNT_LOG_IN) {
650                 LnnAsyncCallbackDelayHelper(
651                     GetLooper(LOOP_TYPE_DEFAULT), HbDelaySetHighScanParam, NULL, HB_CLOUD_SYNC_DELAY_LEN);
652                 LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelaySetNormalScanParam, NULL,
653                     HB_CLOUD_SYNC_DELAY_LEN + HB_START_DELAY_LEN + HB_SEND_RELAY_LEN_ONCE);
654                 LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelayConditionChanged, NULL,
655                     HbTryCloudSync() == SOFTBUS_OK ? HB_CLOUD_SYNC_DELAY_LEN : 0);
656             }
657             if (g_hbConditionState.screenState == SOFTBUS_SCREEN_ON &&
658                 g_hbConditionState.accountState != SOFTBUS_ACCOUNT_LOG_IN) {
659                 HbConditionChanged(false);
660             }
661             break;
662         case SOFTBUS_SCREEN_LOCK:
663             LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_SCREEN_LOCK");
664             break;
665         default:
666             return;
667     }
668 }
669 
HbAccountStateChangeEventHandler(const LnnEventBasicInfo * info)670 static void HbAccountStateChangeEventHandler(const LnnEventBasicInfo *info)
671 {
672     if (info == NULL || info->event != LNN_EVENT_ACCOUNT_CHANGED) {
673         LNN_LOGE(LNN_HEART_BEAT, "account state change evt handler get invalid param");
674         return;
675     }
676     const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
677     SoftBusAccountState accountState = (SoftBusAccountState)event->status;
678     g_hbConditionState.accountState = accountState;
679     switch (accountState) {
680         case SOFTBUS_ACCOUNT_LOG_IN:
681             LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_ACCOUNT_LOG_IN");
682             LnnAsyncCallbackDelayHelper(
683                 GetLooper(LOOP_TYPE_DEFAULT), HbDelaySetHighScanParam, NULL, HB_CLOUD_SYNC_DELAY_LEN);
684             LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelaySetNormalScanParam, NULL,
685                 HB_CLOUD_SYNC_DELAY_LEN + HB_START_DELAY_LEN + HB_SEND_RELAY_LEN_ONCE);
686             LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelayConditionChanged, NULL,
687                 HbTryCloudSync() == SOFTBUS_OK ? HB_CLOUD_SYNC_DELAY_LEN : 0);
688             break;
689         case SOFTBUS_ACCOUNT_LOG_OUT:
690             LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_ACCOUNT_LOG_OUT");
691             LnnSetCloudAbility(false);
692             if (LnnDeleteSyncToDB() != SOFTBUS_OK) {
693                 LNN_LOGE(LNN_LEDGER, "HB clear local cache fail");
694             }
695             LnnOnOhosAccountLogout();
696             HbConditionChanged(false);
697             break;
698         default:
699             return;
700     }
701 }
702 
HbHomeGroupStateChangeEventHandler(const LnnEventBasicInfo * info)703 static void HbHomeGroupStateChangeEventHandler(const LnnEventBasicInfo *info)
704 {
705     const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
706     SoftBusHomeGroupState homeGroupState = (SoftBusHomeGroupState)event->status;
707     LnnUpdateHeartbeatInfo(UPDATE_HB_NETWORK_INFO);
708     switch (homeGroupState) {
709         case SOFTBUS_HOME_GROUP_CHANGE:
710             LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_HOME_GROUP_CHANGE");
711             HbConditionChanged(false);
712             break;
713         case SOFTBUS_HOME_GROUP_LEAVE:
714             LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_HOME_GROUP_LEAVE");
715             break;
716         default:
717             return;
718     }
719 }
720 
HbDifferentAccountEventHandler(const LnnEventBasicInfo * info)721 static void HbDifferentAccountEventHandler(const LnnEventBasicInfo *info)
722 {
723     if (info == NULL || info->event != LNN_EVENT_DIF_ACCOUNT_DEV_CHANGED) {
724         LNN_LOGE(LNN_HEART_BEAT, "account state change evt handler get invalid param");
725         return;
726     }
727     const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
728     SoftBusDifferentAccountState difAccountState = (SoftBusDifferentAccountState)event->status;
729     if ((LnnEventType)difAccountState == LNN_EVENT_DIF_ACCOUNT_DEV_CHANGED) {
730         HbConditionChanged(false);
731     }
732 }
733 
HbUserBackgroundEventHandler(const LnnEventBasicInfo * info)734 static void HbUserBackgroundEventHandler(const LnnEventBasicInfo *info)
735 {
736     if (info == NULL || info->event != LNN_EVENT_USER_STATE_CHANGED) {
737         LNN_LOGE(LNN_HEART_BEAT, "user background state change evt handler get invalid param");
738         return;
739     }
740     const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
741     SoftBusUserState userState = (SoftBusUserState)event->status;
742     switch (userState) {
743         case SOFTBUS_USER_FOREGROUND:
744             g_hbConditionState.backgroundState = userState;
745             LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_USER_FOREGROUND");
746             HbConditionChanged(false);
747             break;
748         case SOFTBUS_USER_BACKGROUND:
749             g_hbConditionState.backgroundState = userState;
750             LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_USER_BACKGROUND");
751             HbConditionChanged(false);
752             break;
753         default:
754             return;
755     }
756 }
757 
HbNightModeStateEventHandler(const LnnEventBasicInfo * info)758 static void HbNightModeStateEventHandler(const LnnEventBasicInfo *info)
759 {
760     if (info == NULL || info->event != LNN_EVENT_NIGHT_MODE_CHANGED) {
761         LNN_LOGE(LNN_HEART_BEAT, "user background state change evt handler get invalid param");
762         return;
763     }
764     const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
765     SoftBusNightModeState nightModeState = (SoftBusNightModeState)event->status;
766     g_hbConditionState.nightModeState = nightModeState;
767     switch (nightModeState) {
768         case SOFTBUS_NIGHT_MODE_ON:
769             LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_NIGHT_MODE_ON");
770             HbConditionChanged(false);
771             break;
772         case SOFTBUS_NIGHT_MODE_OFF:
773             LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_NIGHT_MODE_OFF");
774             HbConditionChanged(false);
775             break;
776         default:
777             return;
778     }
779 }
780 
HbOOBEStateEventHandler(const LnnEventBasicInfo * info)781 static void HbOOBEStateEventHandler(const LnnEventBasicInfo *info)
782 {
783     if (info == NULL || info->event != LNN_EVENT_OOBE_STATE_CHANGED) {
784         LNN_LOGE(LNN_HEART_BEAT, "OOBE state change evt handler get invalid param");
785         return;
786     }
787     const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
788     SoftBusOOBEState state = (SoftBusOOBEState)event->status;
789     LNN_LOGI(
790         LNN_HEART_BEAT, "HB handle oobe state=%{public}d, g_state=%{public}d", state, g_hbConditionState.OOBEState);
791     switch (state) {
792         case SOFTBUS_OOBE_RUNNING:
793             if (g_hbConditionState.OOBEState != SOFTBUS_FACK_OOBE_END) {
794                 g_hbConditionState.OOBEState = state;
795                 HbConditionChanged(false);
796             }
797             break;
798         case SOFTBUS_FACK_OOBE_END:
799             if (g_hbConditionState.OOBEState != SOFTBUS_OOBE_END &&
800                 g_hbConditionState.OOBEState != SOFTBUS_FACK_OOBE_END) {
801                 g_hbConditionState.OOBEState = state;
802                 HbConditionChanged(false);
803             }
804             break;
805         case SOFTBUS_OOBE_END:
806             if (g_hbConditionState.OOBEState != SOFTBUS_OOBE_END) {
807                 g_hbConditionState.OOBEState = state;
808                 HbConditionChanged(false);
809             }
810             break;
811         default:
812             return;
813     }
814 }
815 
HbUserSwitchedHandler(const LnnEventBasicInfo * info)816 static void HbUserSwitchedHandler(const LnnEventBasicInfo *info)
817 {
818     if (info == NULL || info->event != LNN_EVENT_USER_SWITCHED) {
819         LNN_LOGW(LNN_HEART_BEAT, "invalid param");
820         return;
821     }
822     const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
823     SoftBusUserSwitchState userSwitchState = (SoftBusUserSwitchState)event->status;
824     switch (userSwitchState) {
825         case SOFTBUS_USER_SWITCHED:
826             LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_USER_SWITCHED");
827             LnnUpdateOhosAccount(true);
828             HbConditionChanged(false);
829             LnnTrySyncDeviceName();
830             if (IsHeartbeatEnable()) {
831                 if (LnnStartHbByTypeAndStrategy(
832                     HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false) != SOFTBUS_OK) {
833                     LNN_LOGE(LNN_HEART_BEAT, "start ble heartbeat fail");
834                 }
835             }
836             RestartCoapDiscovery();
837             break;
838         default:
839             return;
840     }
841 }
842 
HbLpEventHandler(const LnnEventBasicInfo * info)843 static void HbLpEventHandler(const LnnEventBasicInfo *info)
844 {
845     if (info == NULL || info->event != LNN_EVENT_LP_EVENT_REPORT) {
846         LNN_LOGE(LNN_HEART_BEAT, "lp report evt handler get invalid param");
847         return;
848     }
849     int32_t ret;
850     const LnnLpReportEvent *event = (const LnnLpReportEvent *)info;
851     SoftBusLpEventType type = (SoftBusLpEventType)event->type;
852     switch (type) {
853         case SOFTBUS_MSDP_MOVEMENT_AND_STATIONARY:
854             LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_MSDP_MOVEMENT_AND_STATIONARY");
855             ret = LnnStartHbByTypeAndStrategy(
856                 HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false);
857             if (ret != SOFTBUS_OK) {
858                 LNN_LOGE(LNN_HEART_BEAT, "start ble heartbeat failed, ret=%{public}d", ret);
859                 return;
860             }
861             break;
862         default:
863             LNN_LOGE(LNN_HEART_BEAT, "lp evt handler get invalid type=%{public}d", type);
864             return;
865     }
866 }
867 
HbTryRecoveryNetwork(void)868 static void HbTryRecoveryNetwork(void)
869 {
870     HbConditionChanged(true);
871 }
872 
PeriodDumpLocalInfo(void * para)873 static void PeriodDumpLocalInfo(void *para)
874 {
875     (void)para;
876 
877     LnnDumpLocalBasicInfo();
878     (void)IsHeartbeatEnable();
879     LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), PeriodDumpLocalInfo, NULL, HB_PERIOD_DUMP_LOCAL_INFO_LEN);
880 }
881 
LnnStartHeartbeatFrameDelay(void)882 int32_t LnnStartHeartbeatFrameDelay(void)
883 {
884     LNN_LOGI(LNN_HEART_BEAT, "heartbeat(HB) FSM start");
885     LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), PeriodDumpLocalInfo, NULL, HB_PERIOD_DUMP_LOCAL_INFO_LEN);
886     if (LnnHbMediumMgrInit() != SOFTBUS_OK) {
887         LNN_LOGE(LNN_HEART_BEAT, "medium manager init fail");
888         return SOFTBUS_ERR;
889     }
890     HbTryRecoveryNetwork();
891     if (LnnStartNewHbStrategyFsm() != SOFTBUS_OK) {
892         LNN_LOGE(LNN_HEART_BEAT, "ctrl start strategy fsm fail");
893         return SOFTBUS_ERR;
894     }
895     bool hasTrustedRelation = (AuthHasTrustedRelation() == TRUSTED_RELATION_YES) ? true : false;
896     if (LnnIsDefaultOhosAccount() && !hasTrustedRelation) {
897         LNN_LOGD(LNN_HEART_BEAT, "no trusted relation, heartbeat(HB) process start later");
898         return SOFTBUS_OK;
899     }
900     return LnnStartHeartbeat(0);
901 }
902 
LnnSetHeartbeatMediumParam(const LnnHeartbeatMediumParam * param)903 int32_t LnnSetHeartbeatMediumParam(const LnnHeartbeatMediumParam *param)
904 {
905     return LnnSetMediumParamBySpecificType(param);
906 }
907 
LnnOfflineTimingByHeartbeat(const char * networkId,ConnectionAddrType addrType)908 int32_t LnnOfflineTimingByHeartbeat(const char *networkId, ConnectionAddrType addrType)
909 {
910     if (networkId == NULL) {
911         LNN_LOGE(LNN_HEART_BEAT, "offline timing get invalid param");
912         return SOFTBUS_INVALID_PARAM;
913     }
914     /* only support ble medium type yet. */
915     if (addrType != CONNECTION_ADDR_BLE) {
916         LNN_LOGD(LNN_HEART_BEAT, "offline timing not support addrType now. addrType=%{public}d", addrType);
917         return SOFTBUS_INVALID_PARAM;
918     }
919     SoftBusSysTime time = { 0 };
920     (void)SoftBusGetTime(&time);
921     uint64_t timeStamp = (uint64_t)time.sec * HB_TIME_FACTOR + (uint64_t)time.usec / HB_TIME_FACTOR;
922     LnnSetDLHeartbeatTimestamp(networkId, timeStamp);
923     (void)LnnStopOfflineTimingStrategy(networkId, addrType);
924     if (LnnStartOfflineTimingStrategy(networkId, addrType) != SOFTBUS_OK) {
925         LNN_LOGE(LNN_HEART_BEAT, "ctrl start offline timing strategy fail");
926         return SOFTBUS_ERR;
927     }
928     char *anonyNetworkId = NULL;
929     Anonymize(networkId, &anonyNetworkId);
930     LNN_LOGI(LNN_HEART_BEAT, "heartbeat(HB) start offline countdown, networkId=%{public}s, timeStamp=%{public}" PRIu64,
931         anonyNetworkId, timeStamp);
932     AnonymizeFree(anonyNetworkId);
933     if (SoftBusGetBtState() == BLE_ENABLE) {
934         g_hbConditionState.btState = SOFTBUS_BLE_TURN_ON;
935     }
936     return SOFTBUS_OK;
937 }
938 
LnnStopOfflineTimingByHeartbeat(const char * networkId,ConnectionAddrType addrType)939 void LnnStopOfflineTimingByHeartbeat(const char *networkId, ConnectionAddrType addrType)
940 {
941     if (networkId == NULL) {
942         LNN_LOGE(LNN_HEART_BEAT, "HB stop offline timing get invalid param");
943         return;
944     }
945     /* only support ble medium type yet. */
946     if (addrType != CONNECTION_ADDR_BLE) {
947         LNN_LOGE(LNN_HEART_BEAT, "HB stop offline timing not support addrType:%{public}d now", addrType);
948         return;
949     }
950     char *anonyNetworkId = NULL;
951     Anonymize(networkId, &anonyNetworkId);
952     LNN_LOGD(LNN_HEART_BEAT, "heartbeat(HB) stop offline timing, networkId:%{public}s", anonyNetworkId);
953     AnonymizeFree(anonyNetworkId);
954     (void)LnnStopScreenChangeOfflineTiming(networkId, addrType);
955     (void)LnnStopOfflineTimingStrategy(networkId, addrType);
956 }
957 
ReportBusinessDiscoveryResultEvt(const char * pkgName,int32_t discCnt)958 static void ReportBusinessDiscoveryResultEvt(const char *pkgName, int32_t discCnt)
959 {
960     LNN_LOGI(LNN_HEART_BEAT, "report business discovery result evt enter");
961     AppDiscNode appInfo;
962     (void)memset_s(&appInfo, sizeof(AppDiscNode), 0, sizeof(AppDiscNode));
963     appInfo.appDiscCnt = discCnt;
964     if (memcpy_s(appInfo.appName, SOFTBUS_HISYSEVT_NAME_LEN, pkgName, SOFTBUS_HISYSEVT_NAME_LEN) != EOK) {
965         LNN_LOGE(LNN_HEART_BEAT, "copy app name fail");
966         return;
967     }
968     if (SoftBusRecordDiscoveryResult(BUSINESS_DISCOVERY, &appInfo) != SOFTBUS_OK) {
969         LNN_LOGE(LNN_HEART_BEAT, "report business discovery result fail");
970     }
971 }
972 
LnnShiftLNNGear(const char * pkgName,const char * callerId,const char * targetNetworkId,const GearMode * mode)973 int32_t LnnShiftLNNGear(const char *pkgName, const char *callerId, const char *targetNetworkId, const GearMode *mode)
974 {
975     char *anonyNetworkId = NULL;
976     if (pkgName == NULL || mode == NULL || callerId == NULL) {
977         LNN_LOGE(LNN_HEART_BEAT, "shift lnn gear get invalid param");
978         return SOFTBUS_INVALID_PARAM;
979     }
980     Anonymize(targetNetworkId, &anonyNetworkId);
981     if (targetNetworkId != NULL && !LnnGetOnlineStateById(targetNetworkId, CATEGORY_NETWORK_ID)) {
982         LNN_LOGD(LNN_HEART_BEAT, "target is offline, networkId=%{public}s", anonyNetworkId);
983     }
984     LNN_LOGI(LNN_HEART_BEAT,
985         "shift lnn gear mode, callerId=%{public}s, networkId=%{public}s, cycle=%{public}d, "
986         "duration=%{public}d, wakeupFlag=%{public}d, action=%{public}d",
987         callerId, targetNetworkId != NULL ? anonyNetworkId : "", mode->cycle, mode->duration, mode->wakeupFlag,
988         mode->action);
989     AnonymizeFree(anonyNetworkId);
990     char uuid[UUID_BUF_LEN] = { 0 };
991     if (targetNetworkId != NULL) {
992         int32_t ret = LnnConvertDlId(targetNetworkId, CATEGORY_NETWORK_ID, CATEGORY_UUID, uuid, UUID_BUF_LEN);
993         if (ret != SOFTBUS_OK) {
994             LNN_LOGE(LNN_HEART_BEAT, "targetNetworkId convert uuid fail");
995             return ret;
996         }
997     }
998     if (mode->action == CHANGE_TCP_KEEPALIVE) {
999         if (AuthSendKeepaliveOption(uuid, mode->cycle) != SOFTBUS_OK) {
1000             LNN_LOGE(LNN_HEART_BEAT, "auth send keepalive option fail");
1001             return SOFTBUS_ERR;
1002         }
1003         return SOFTBUS_OK;
1004     }
1005     if (LnnSetGearModeBySpecificType(callerId, mode, HEARTBEAT_TYPE_BLE_V0) != SOFTBUS_OK) {
1006         LNN_LOGE(LNN_HEART_BEAT, "ctrl reset medium mode fail");
1007         return SOFTBUS_ERR;
1008     }
1009     if (LnnStartHbByTypeAndStrategy(
1010         HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_ADJUSTABLE_PERIOD, false) != SOFTBUS_OK) {
1011         LNN_LOGE(LNN_HEART_BEAT, "ctrl start adjustable ble heatbeat fail");
1012         return SOFTBUS_ERR;
1013     }
1014     int32_t ret = AuthFlushDevice(uuid);
1015     if (ret != SOFTBUS_OK && ret != SOFTBUS_INVALID_PARAM) {
1016         LNN_LOGI(LNN_HEART_BEAT, "tcp flush failed, wifi will offline");
1017         return LnnRequestLeaveSpecific(targetNetworkId, CONNECTION_ADDR_WLAN);
1018     }
1019     return SOFTBUS_OK;
1020 }
1021 
LnnShiftLNNGearWithoutPkgName(const char * callerId,const GearMode * mode,LnnHeartbeatStrategyType strategyType)1022 int32_t LnnShiftLNNGearWithoutPkgName(const char *callerId, const GearMode *mode, LnnHeartbeatStrategyType strategyType)
1023 {
1024     if (mode == NULL || callerId == NULL) {
1025         LNN_LOGE(LNN_HEART_BEAT, "shift lnn gear get invalid param");
1026         return SOFTBUS_INVALID_PARAM;
1027     }
1028     ReportBusinessDiscoveryResultEvt(callerId, 1);
1029     LNN_LOGD(LNN_HEART_BEAT,
1030         "shift lnn gear mode, callerId=%{public}s, cycle=%{public}d, duration=%{public}d, wakeupFlag=%{public}d",
1031         callerId, mode->cycle, mode->duration, mode->wakeupFlag);
1032     if (LnnSetGearModeBySpecificType(callerId, mode, HEARTBEAT_TYPE_BLE_V0) != SOFTBUS_OK) {
1033         LNN_LOGE(LNN_HEART_BEAT, "ctrl reset medium mode fail");
1034         return SOFTBUS_ERR;
1035     }
1036     if (LnnStartHbByTypeAndStrategy(
1037         HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, strategyType, false) != SOFTBUS_OK) {
1038         LNN_LOGE(LNN_HEART_BEAT, "ctrl start adjustable ble heatbeat fail");
1039         return SOFTBUS_ERR;
1040     }
1041     int32_t i, infoNum;
1042     char uuid[UUID_BUF_LEN] = { 0 };
1043     NodeBasicInfo *info = NULL;
1044     if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
1045         LNN_LOGE(LNN_HEART_BEAT, "get online node info failed");
1046         return SOFTBUS_ERR;
1047     }
1048     if (info == NULL || infoNum == 0) {
1049         LNN_LOGE(LNN_HEART_BEAT, "get online node is 0");
1050         return SOFTBUS_ERR;
1051     }
1052     int32_t ret;
1053     NodeInfo nodeInfo;
1054     (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1055     for (i = 0; i < infoNum; ++i) {
1056         ret = LnnGetRemoteNodeInfoById(info[i].networkId, CATEGORY_NETWORK_ID, &nodeInfo);
1057         if (ret != SOFTBUS_OK || !LnnHasDiscoveryType(&nodeInfo, DISCOVERY_TYPE_WIFI)) {
1058             continue;
1059         }
1060         (void)LnnConvertDlId(info[i].networkId, CATEGORY_NETWORK_ID, CATEGORY_UUID, uuid, UUID_BUF_LEN);
1061         if (AuthFlushDevice(uuid) != SOFTBUS_OK) {
1062             char *anonyUuid = NULL;
1063             Anonymize(uuid, &anonyUuid);
1064             LNN_LOGE(LNN_HEART_BEAT, "tcp flush failed, wifi will offline, uuid=%{public}s", anonyUuid);
1065             AnonymizeFree(anonyUuid);
1066             LnnRequestLeaveSpecific(info[i].networkId, CONNECTION_ADDR_WLAN);
1067         }
1068     }
1069     SoftBusFree(info);
1070     return SOFTBUS_OK;
1071 }
1072 
LnnUpdateHeartbeatInfo(LnnHeartbeatUpdateInfoType type)1073 void LnnUpdateHeartbeatInfo(LnnHeartbeatUpdateInfoType type)
1074 {
1075     LNN_LOGI(LNN_HEART_BEAT, "update heartbeat infoType=%{public}d", type);
1076     if (type == UPDATE_HB_ACCOUNT_INFO && !LnnIsDefaultOhosAccount()) {
1077         g_hbConditionState.accountState = SOFTBUS_ACCOUNT_LOG_IN;
1078         LNN_LOGI(LNN_HEART_BEAT, "account is login");
1079         HbConditionChanged(true);
1080     }
1081     LnnUpdateSendInfoStrategy(type);
1082 }
1083 
HbDelayCheckTrustedRelation(void * para)1084 static void HbDelayCheckTrustedRelation(void *para)
1085 {
1086     (void)para;
1087     TrustedReturnType ret = AuthHasTrustedRelation();
1088     if (ret == TRUSTED_RELATION_YES) {
1089         g_hbConditionState.heartbeatEnable = IsEnableSoftBusHeartbeat();
1090         g_hbConditionState.hasTrustedRelation = true;
1091     } else if (ret == TRUSTED_RELATION_NO) {
1092         g_hbConditionState.hasTrustedRelation = false;
1093     }
1094     LNN_LOGI(LNN_HEART_BEAT, "delay check trust relation=%{public}d", g_hbConditionState.hasTrustedRelation);
1095     HbConditionChanged(false);
1096     if (LnnIsDefaultOhosAccount() && !g_hbConditionState.hasTrustedRelation) {
1097         LNN_LOGW(LNN_HEART_BEAT, "no trusted relation, heartbeat(HB) process stop");
1098         LnnStopHeartbeatByType(
1099             HEARTBEAT_TYPE_UDP | HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V1 | HEARTBEAT_TYPE_TCP_FLUSH);
1100     }
1101 }
1102 
LnnHbOnTrustedRelationIncreased(int32_t groupType)1103 void LnnHbOnTrustedRelationIncreased(int32_t groupType)
1104 {
1105     /* If it is a peer-to-peer group, delay initialization to give BR networking priority. */
1106     int32_t ret = LnnStartHeartbeat(0);
1107     if (ret != SOFTBUS_OK) {
1108         LNN_LOGE(LNN_HEART_BEAT, "account group created start heartbeat fail, ret=%{public}d", ret);
1109         return;
1110     }
1111     if (groupType == AUTH_PEER_TO_PEER_GROUP &&
1112         LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelayCheckTrustedRelation, NULL,
1113             CHECK_TRUSTED_RELATION_TIME) != SOFTBUS_OK) {
1114         LNN_LOGE(LNN_HEART_BEAT, "async check trusted relaion fail");
1115     }
1116 }
1117 
LnnHbOnTrustedRelationReduced(void)1118 void LnnHbOnTrustedRelationReduced(void)
1119 {
1120     if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelayCheckTrustedRelation, NULL,
1121         CHECK_TRUSTED_RELATION_TIME) != SOFTBUS_OK) {
1122         LNN_LOGE(LNN_HEART_BEAT, "async check trusted relaion fail");
1123     }
1124 }
1125 
LnnRegisterCommonEvent(void)1126 static int32_t LnnRegisterCommonEvent(void)
1127 {
1128     int32_t ret;
1129     ret = LnnRegisterEventHandler(LNN_EVENT_SCREEN_STATE_CHANGED, HbScreenStateChangeEventHandler);
1130     LNN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, LNN_INIT, "regist screen state change evt handler fail");
1131     ret = LnnRegisterEventHandler(LNN_EVENT_SCREEN_LOCK_CHANGED, HbScreenLockChangeEventHandler);
1132     LNN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, LNN_INIT, "regist screen lock state change evt handler fai");
1133     ret = LnnRegisterEventHandler(LNN_EVENT_NIGHT_MODE_CHANGED, HbNightModeStateEventHandler);
1134     LNN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, LNN_INIT, "regist night mode state evt handler fail");
1135     ret = LnnRegisterEventHandler(LNN_EVENT_OOBE_STATE_CHANGED, HbOOBEStateEventHandler);
1136     LNN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, LNN_INIT, "regist OOBE state evt handler fail");
1137     ret = LnnRegisterEventHandler(LNN_EVENT_USER_SWITCHED, HbUserSwitchedHandler);
1138     LNN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, LNN_INIT, "regist user switch evt handler fail");
1139     return SOFTBUS_OK;
1140 }
1141 
LnnRegisterNetworkEvent(void)1142 static int32_t LnnRegisterNetworkEvent(void)
1143 {
1144     if (LnnRegisterEventHandler(LNN_EVENT_IP_ADDR_CHANGED, HbIpAddrChangeEventHandler) != SOFTBUS_OK) {
1145         LNN_LOGE(LNN_INIT, "regist ip addr change evt handler fail");
1146         return SOFTBUS_ERR;
1147     }
1148     if (LnnRegisterEventHandler(LNN_EVENT_BT_STATE_CHANGED, HbBtStateChangeEventHandler) != SOFTBUS_OK) {
1149         LNN_LOGE(LNN_INIT, "regist bt state change evt handler fail");
1150         return SOFTBUS_ERR;
1151     }
1152     if (LnnRegisterEventHandler(LNN_EVENT_LANE_VAP_CHANGE, HbLaneVapChangeEventHandler) != SOFTBUS_OK) {
1153         LNN_LOGE(LNN_INIT, "regist vap state change evt handler fail");
1154         return SOFTBUS_ERR;
1155     }
1156     return SOFTBUS_OK;
1157 }
1158 
LnnRegisterHeartbeatEvent(void)1159 static int32_t LnnRegisterHeartbeatEvent(void)
1160 {
1161     if (LnnRegisterEventHandler(LNN_EVENT_NODE_MASTER_STATE_CHANGED, HbMasterNodeChangeEventHandler) != SOFTBUS_OK) {
1162         LNN_LOGE(LNN_INIT, "regist node state change evt handler fail");
1163         return SOFTBUS_ERR;
1164     }
1165     if (LnnRegisterEventHandler(LNN_EVENT_HOME_GROUP_CHANGED, HbHomeGroupStateChangeEventHandler) != SOFTBUS_OK) {
1166         LNN_LOGE(LNN_INIT, "regist homeGroup state change evt handler fail");
1167         return SOFTBUS_ERR;
1168     }
1169     if (LnnRegisterEventHandler(LNN_EVENT_ACCOUNT_CHANGED, HbAccountStateChangeEventHandler) != SOFTBUS_OK) {
1170         LNN_LOGE(LNN_INIT, "regist account change evt handler fail");
1171         return SOFTBUS_ERR;
1172     }
1173     if (LnnRegisterEventHandler(LNN_EVENT_DIF_ACCOUNT_DEV_CHANGED, HbDifferentAccountEventHandler) != SOFTBUS_OK) {
1174         LNN_LOGE(LNN_INIT, "regist different account evt handler fail");
1175         return SOFTBUS_ERR;
1176     }
1177     if (LnnRegisterEventHandler(LNN_EVENT_USER_STATE_CHANGED, HbUserBackgroundEventHandler) != SOFTBUS_OK) {
1178         LNN_LOGE(LNN_INIT, "regist user background evt handler fail");
1179         return SOFTBUS_ERR;
1180     }
1181     if (LnnRegisterEventHandler(LNN_EVENT_LP_EVENT_REPORT, HbLpEventHandler) != SOFTBUS_OK) {
1182         LNN_LOGE(LNN_INIT, "regist lp report evt handler fail");
1183         return SOFTBUS_ERR;
1184     }
1185     return SOFTBUS_OK;
1186 }
1187 
LnnInitHeartbeat(void)1188 int32_t LnnInitHeartbeat(void)
1189 {
1190     if (LnnHbStrategyInit() != SOFTBUS_OK) {
1191         LNN_LOGE(LNN_INIT, "strategy module init fail");
1192         return SOFTBUS_ERR;
1193     }
1194     if (LnnRegisterCommonEvent() != SOFTBUS_OK) {
1195         LNN_LOGE(LNN_INIT, "regist common event handler fail");
1196         return SOFTBUS_ERR;
1197     }
1198     if (LnnRegisterNetworkEvent() != SOFTBUS_OK) {
1199         LNN_LOGE(LNN_INIT, "regist network event handler fail");
1200         return SOFTBUS_ERR;
1201     }
1202     if (LnnRegisterHeartbeatEvent() != SOFTBUS_OK) {
1203         LNN_LOGE(LNN_INIT, "regist heartbeat event handler fail");
1204         return SOFTBUS_ERR;
1205     }
1206     InitHbConditionState();
1207     InitHbSpecificConditionState();
1208     LNN_LOGI(LNN_INIT, "heartbeat(HB) init success");
1209     return SOFTBUS_OK;
1210 }
1211 
LnnDeinitHeartbeat(void)1212 void LnnDeinitHeartbeat(void)
1213 {
1214     LnnHbStrategyDeinit();
1215     LnnHbMediumMgrDeinit();
1216     LnnUnregisterEventHandler(LNN_EVENT_IP_ADDR_CHANGED, HbIpAddrChangeEventHandler);
1217     LnnUnregisterEventHandler(LNN_EVENT_BT_STATE_CHANGED, HbBtStateChangeEventHandler);
1218     LnnUnregisterEventHandler(LNN_EVENT_LANE_VAP_CHANGE, HbLaneVapChangeEventHandler);
1219     LnnUnregisterEventHandler(LNN_EVENT_NODE_MASTER_STATE_CHANGED, HbMasterNodeChangeEventHandler);
1220     LnnUnregisterEventHandler(LNN_EVENT_SCREEN_STATE_CHANGED, HbScreenStateChangeEventHandler);
1221     LnnUnregisterEventHandler(LNN_EVENT_HOME_GROUP_CHANGED, HbHomeGroupStateChangeEventHandler);
1222     LnnUnregisterEventHandler(LNN_EVENT_SCREEN_LOCK_CHANGED, HbScreenLockChangeEventHandler);
1223     LnnUnregisterEventHandler(LNN_EVENT_ACCOUNT_CHANGED, HbAccountStateChangeEventHandler);
1224     LnnUnregisterEventHandler(LNN_EVENT_DIF_ACCOUNT_DEV_CHANGED, HbDifferentAccountEventHandler);
1225     LnnUnregisterEventHandler(LNN_EVENT_USER_STATE_CHANGED, HbUserBackgroundEventHandler);
1226     LnnUnregisterEventHandler(LNN_EVENT_NIGHT_MODE_CHANGED, HbNightModeStateEventHandler);
1227     LnnUnregisterEventHandler(LNN_EVENT_OOBE_STATE_CHANGED, HbOOBEStateEventHandler);
1228     LnnUnregisterEventHandler(LNN_EVENT_LP_EVENT_REPORT, HbLpEventHandler);
1229 }
1230 
LnnTriggerDataLevelHeartbeat(void)1231 int32_t LnnTriggerDataLevelHeartbeat(void)
1232 {
1233     LNN_LOGD(LNN_HEART_BEAT, "LnnTriggerDataLevelHeartbeat");
1234     if (LnnStartHbByTypeAndStrategy(
1235         HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false) != SOFTBUS_OK) {
1236         LNN_LOGE(LNN_HEART_BEAT, "ctrl start single ble heartbeat fail");
1237         return SOFTBUS_ERR;
1238     }
1239     return SOFTBUS_OK;
1240 }
1241 
LnnTriggerCloudSyncHeartbeat(void)1242 int32_t LnnTriggerCloudSyncHeartbeat(void)
1243 {
1244     LNN_LOGD(LNN_HEART_BEAT, "LnnTriggerCloudSyncHeartbeat");
1245     if (LnnStartHbByTypeAndStrategy(
1246         HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false) != SOFTBUS_OK) {
1247         LNN_LOGE(LNN_HEART_BEAT, "ctrl start single ble heartbeat fail");
1248         return SOFTBUS_ERR;
1249     }
1250     return SOFTBUS_OK;
1251 }
1252 
LnnRegDataLevelChangeCb(const IDataLevelChangeCallback * callback)1253 void LnnRegDataLevelChangeCb(const IDataLevelChangeCallback *callback)
1254 {
1255     LnnBleHbRegDataLevelChangeCb(callback);
1256 }
1257 
LnnUnregDataLevelChangeCb(void)1258 void LnnUnregDataLevelChangeCb(void)
1259 {
1260     LnnBleHbUnregDataLevelChangeCb();
1261 }