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
24 #include "auth_interface.h"
25 #include "auth_manager.h"
26 #include "bus_center_manager.h"
27 #include "g_enhance_adapter_func_pack.h"
28 #include "g_enhance_lnn_func.h"
29 #include "g_enhance_lnn_func_pack.h"
30 #include "lnn_async_callback_utils.h"
31 #include "lnn_common_utils.h"
32 #include "lnn_connection_fsm.h"
33 #include "lnn_data_cloud_sync.h"
34 #include "lnn_decision_db.h"
35 #include "lnn_deviceinfo_to_profile.h"
36 #include "lnn_devicename_info.h"
37 #include "lnn_distributed_net_ledger.h"
38 #include "lnn_feature_capability.h"
39 #include "lnn_heartbeat_fsm.h"
40 #include "lnn_heartbeat_strategy.h"
41 #include "lnn_heartbeat_utils.h"
42 #include "lnn_kv_adapter_wrapper.h"
43 #include "lnn_local_net_ledger.h"
44 #include "lnn_log.h"
45 #include "lnn_meta_node_ledger.h"
46 #include "lnn_net_builder.h"
47 #include "lnn_network_info.h"
48 #include "lnn_network_manager.h"
49 #include "lnn_ohos_account.h"
50 #include "lnn_settingdata_event_monitor.h"
51 #include "lnn_init_monitor.h"
52 #include "softbus_adapter_bt_common.h"
53 #include "softbus_adapter_mem.h"
54 #include "softbus_adapter_range.h"
55 #include "softbus_broadcast_type.h"
56 #include "softbus_def.h"
57 #include "softbus_error_code.h"
58 #include "legacy/softbus_hisysevt_bus_center.h"
59 #include "softbus_utils.h"
60 #include "softbus_init_common.h"
61
62 #define HB_LOOPBACK_IP "127.0.0.1"
63 #define INVALID_DELAY_TIME (-1)
64
65 typedef struct {
66 SoftBusBtState btState;
67 SoftBusScreenLockState lockState;
68 SoftBusScreenState screenState;
69 SoftBusAccountState accountState;
70 SoftBusUserState backgroundState;
71 SoftBusNightModeState nightModeState;
72 SoftBusOOBEState OOBEState;
73 SoftBusDeviceRootState deviceRootState;
74 bool hasTrustedRelation;
75 bool heartbeatEnable;
76 bool isRequestDisable;
77 bool isSleEnable;
78 } HbConditionState;
79
80 static HbConditionState g_hbConditionState;
81 static int64_t g_lastScreenOnTime = 0;
82 static int64_t g_lastScreenOffTime = 0;
83 static atomic_bool g_enableState = false;
84 static bool g_isScreenOnOnce = false;
85 static atomic_bool g_isCloudSyncEnd = false;
86
87 static IBleRangeInnerCallback g_bleRangeCallback = {
88 .onRangeResult = NULL,
89 .onRangeStateChange = NULL,
90 };
91
InitHbConditionState(void)92 static void InitHbConditionState(void)
93 {
94 g_hbConditionState.btState = SOFTBUS_BT_UNKNOWN;
95 g_hbConditionState.screenState = SOFTBUS_SCREEN_UNKNOWN;
96 g_hbConditionState.lockState = SOFTBUS_SCREEN_LOCK_UNKNOWN;
97 // need suit for same account
98 g_hbConditionState.accountState = SOFTBUS_ACCOUNT_UNKNOWN;
99 g_hbConditionState.backgroundState = SOFTBUS_USER_FOREGROUND;
100 g_hbConditionState.nightModeState = SOFTBUS_NIGHT_MODE_UNKNOWN;
101 g_hbConditionState.hasTrustedRelation = false;
102 g_hbConditionState.isRequestDisable = false;
103 g_hbConditionState.heartbeatEnable = false;
104 g_hbConditionState.OOBEState = SOFTBUS_OOBE_UNKNOWN;
105 g_hbConditionState.deviceRootState = SOFTBUS_DEVICE_ROOT_UNKNOWN;
106 LNN_LOGI(LNN_INIT, "condition state:heartbeat=%{public}d", g_hbConditionState.heartbeatEnable);
107 }
108
InitHbSpecificConditionState(void)109 static void InitHbSpecificConditionState(void)
110 {
111 int32_t localDevTypeId = 0;
112 if (LnnGetLocalNumInfo(NUM_KEY_DEV_TYPE_ID, &localDevTypeId) != SOFTBUS_OK) {
113 return;
114 }
115 if (localDevTypeId == TYPE_WATCH_ID || localDevTypeId == TYPE_GLASS_ID) {
116 LNN_LOGD(LNN_INIT, "localDevTypeId=%{public}d", localDevTypeId);
117 g_hbConditionState.isRequestDisable = true;
118 }
119 }
120
IsHeartbeatEnable(void)121 bool IsHeartbeatEnable(void)
122 {
123 if ((g_hbConditionState.lockState == SOFTBUS_SCREEN_LOCK_UNKNOWN) && IsActiveOsAccountUnlocked()) {
124 g_hbConditionState.lockState = SOFTBUS_SCREEN_UNLOCK;
125 }
126 bool isBtOn = ((g_hbConditionState.btState != SOFTBUS_BLE_TURN_OFF) &&
127 (g_hbConditionState.btState != SOFTBUS_BT_UNKNOWN));
128 bool isScreenUnlock = g_hbConditionState.lockState == SOFTBUS_SCREEN_UNLOCK;
129 bool isLogIn = g_hbConditionState.accountState == SOFTBUS_ACCOUNT_LOG_IN;
130 bool isBackground = g_hbConditionState.backgroundState == SOFTBUS_USER_BACKGROUND;
131 bool isNightMode = g_hbConditionState.nightModeState == SOFTBUS_NIGHT_MODE_ON;
132 bool isOOBEEnd =
133 g_hbConditionState.OOBEState == SOFTBUS_OOBE_END || g_hbConditionState.OOBEState == SOFTBUS_FACK_OOBE_END;
134 bool isInitCheckSuc = IsLnnInitCheckSucceed(MONITOR_BLE_NET);
135 bool isDeviceRoot = g_hbConditionState.deviceRootState == SOFTBUS_DEVICE_IS_ROOT;
136
137 LNN_LOGI(LNN_HEART_BEAT,
138 "HB condition state: bt=%{public}d, screenUnlock=%{public}d, account=%{public}d, trustedRelation=%{public}d, "
139 "background=%{public}d, nightMode=%{public}d, OOBEEnd=%{public}d, heartbeatEnable=%{public}d, "
140 "request=%{public}d, init check=%{public}d, deviceRoot=%{public}d",
141 isBtOn, isScreenUnlock, isLogIn, g_hbConditionState.hasTrustedRelation, isBackground, isNightMode, isOOBEEnd,
142 g_hbConditionState.heartbeatEnable, g_hbConditionState.isRequestDisable, isInitCheckSuc, isDeviceRoot);
143 return g_hbConditionState.heartbeatEnable && isBtOn && isScreenUnlock && !g_hbConditionState.isRequestDisable &&
144 (isLogIn || g_hbConditionState.hasTrustedRelation) && !isBackground && !isNightMode && isOOBEEnd &&
145 isInitCheckSuc && !isDeviceRoot;
146 }
147
GetScreenState(void)148 SoftBusScreenState GetScreenState(void)
149 {
150 return g_hbConditionState.screenState;
151 }
152
GetScreenLockState(void)153 SoftBusScreenLockState GetScreenLockState(void)
154 {
155 return g_hbConditionState.lockState;
156 }
157
LnnIsCloudSyncEnd(void)158 bool LnnIsCloudSyncEnd(void)
159 {
160 return g_isCloudSyncEnd;
161 }
162
LnnIsNeedInterceptBroadcast(bool disableGlass)163 bool LnnIsNeedInterceptBroadcast(bool disableGlass)
164 {
165 int32_t localDevTypeId = TYPE_UNKNOW_ID;
166 if (LnnGetLocalNumInfo(NUM_KEY_DEV_TYPE_ID, &localDevTypeId) == SOFTBUS_OK &&
167 (localDevTypeId == TYPE_WATCH_ID || (localDevTypeId == TYPE_GLASS_ID && disableGlass)) &&
168 g_hbConditionState.isRequestDisable) {
169 LNN_LOGI(LNN_HEART_BEAT, "local heartbeat disable");
170 return true;
171 }
172 return false;
173 }
174
SetScreenState(SoftBusScreenState state)175 void SetScreenState(SoftBusScreenState state)
176 {
177 g_hbConditionState.screenState = state;
178 }
179
HbRefreshConditionState(void)180 static void HbRefreshConditionState(void)
181 {
182 if (SoftBusGetBtState() == BLE_ENABLE) {
183 g_hbConditionState.btState = SOFTBUS_BLE_TURN_ON;
184 }
185 LnnUpdateOhosAccount(UPDATE_ACCOUNT_ONLY);
186 if (!LnnIsDefaultOhosAccount()) {
187 g_hbConditionState.accountState = SOFTBUS_ACCOUNT_LOG_IN;
188 }
189 if (IsActiveOsAccountUnlocked()) {
190 g_hbConditionState.lockState = SOFTBUS_SCREEN_UNLOCK;
191 }
192 TrustedReturnType ret = AuthHasTrustedRelation();
193 if (ret == TRUSTED_RELATION_YES) {
194 g_hbConditionState.hasTrustedRelation = true;
195 } else if (ret == TRUSTED_RELATION_NO) {
196 g_hbConditionState.hasTrustedRelation = false;
197 }
198 if (g_hbConditionState.lockState == SOFTBUS_SCREEN_UNLOCK &&
199 (g_hbConditionState.accountState == SOFTBUS_ACCOUNT_LOG_IN || g_hbConditionState.hasTrustedRelation)) {
200 g_hbConditionState.heartbeatEnable = IsEnableSoftBusHeartbeat();
201 }
202 }
203
HbIpAddrChangeEventHandler(const LnnEventBasicInfo * info)204 static void HbIpAddrChangeEventHandler(const LnnEventBasicInfo *info)
205 {
206 char localIp[IP_LEN] = { 0 };
207
208 if (info == NULL || info->event != LNN_EVENT_IP_ADDR_CHANGED) {
209 LNN_LOGE(LNN_HEART_BEAT, "ip addr change evt handler get invalid param");
210 return;
211 }
212 if (LnnGetLocalStrInfoByIfnameIdx(STRING_KEY_IP, localIp, IP_LEN, WLAN_IF) != SOFTBUS_OK) {
213 LNN_LOGE(LNN_HEART_BEAT, "get local ip err");
214 return;
215 }
216 if (strcmp(localIp, HB_LOOPBACK_IP) == 0 &&
217 LnnEnableHeartbeatByType(HEARTBEAT_TYPE_TCP_FLUSH, false) != SOFTBUS_OK) {
218 LNN_LOGE(LNN_HEART_BEAT, "ctrl disable tcp flush fail");
219 return;
220 }
221 if (LnnEnableHeartbeatByType(HEARTBEAT_TYPE_TCP_FLUSH, true) != SOFTBUS_OK) {
222 LNN_LOGE(LNN_HEART_BEAT, "ctrl enable tcp flush fail");
223 return;
224 }
225 }
226
HbSendCheckOffLineMessage(LnnHeartbeatType hbType)227 static void HbSendCheckOffLineMessage(LnnHeartbeatType hbType)
228 {
229 int32_t i, infoNum;
230 NodeBasicInfo *info = NULL;
231 if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
232 LNN_LOGE(LNN_HEART_BEAT, "check dev status get online node info failed");
233 return;
234 }
235 if (info == NULL || infoNum == 0) {
236 LNN_LOGE(LNN_HEART_BEAT, "check dev status get online node is 0");
237 return;
238 }
239 for (i = 0; i < infoNum; ++i) {
240 if (LnnIsLSANode(&info[i])) {
241 continue;
242 }
243 (void)LnnStopScreenChangeOfflineTiming(info[i].networkId, LnnConvertHbTypeToConnAddrType(hbType));
244 if (LnnStartScreenChangeOfflineTiming(info[i].networkId, LnnConvertHbTypeToConnAddrType(hbType)) !=
245 SOFTBUS_OK) {
246 LNN_LOGE(LNN_HEART_BEAT, "send check offline target msg failed");
247 }
248 }
249 SoftBusFree(info);
250 }
251
HbSleStateEventHandler(const LnnEventBasicInfo * info)252 static void HbSleStateEventHandler(const LnnEventBasicInfo *info)
253 {
254 if (info == NULL || info->event != LNN_EVENT_SLE_STATE_CHANGED) {
255 LNN_LOGE(LNN_HEART_BEAT, "sle state change evt handler get invalid event");
256 return;
257 }
258
259 const LnnMonitorSleStateChangedEvent *event = (const LnnMonitorSleStateChangedEvent *)info;
260 SoftBusSleState sleState = (SoftBusSleState)event->status;
261 LNN_LOGI(LNN_HEART_BEAT, "hb sle state change, sleState=%{public}d", sleState);
262 if (sleState == SOFTBUS_SLE_TURN_ON) {
263 if (LnnEnableHeartbeatByType(HEARTBEAT_TYPE_SLE, true) != SOFTBUS_OK) {
264 LNN_LOGE(LNN_HEART_BEAT, "ctrl enable sle heartbeat fail");
265 }
266 } else if (sleState == SOFTBUS_SLE_TURN_OFF) {
267 if (LnnEnableHeartbeatByType(HEARTBEAT_TYPE_SLE, false) != SOFTBUS_OK) {
268 LNN_LOGE(LNN_HEART_BEAT, "ctrl disable sle heartbeat fail");
269 }
270 }
271 }
272
HbConditionChanged(bool isOnlySetState)273 static void HbConditionChanged(bool isOnlySetState)
274 {
275 HbRefreshConditionState();
276 bool isEnable = IsHeartbeatEnable();
277 if (g_enableState == isEnable) {
278 LNN_LOGI(LNN_HEART_BEAT, "ctrl ignore same enable request, isEnable=%{public}d", isEnable);
279 return;
280 }
281 LnnNotifyNetworkStateChanged(isEnable ? SOFTBUS_BLE_NETWORKD_ENABLE : SOFTBUS_BLE_NETWORKD_DISABLE);
282 if (LnnEnableHeartbeatByType(HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V1 | HEARTBEAT_TYPE_BLE_V3, isEnable) !=
283 SOFTBUS_OK) {
284 LNN_LOGE(LNN_HEART_BEAT, "ctrl enable ble heartbeat fail");
285 return;
286 }
287 if (isOnlySetState) {
288 LNN_LOGD(LNN_HEART_BEAT, "condition changed only set state");
289 g_enableState = isEnable;
290 return;
291 }
292 if (isEnable) {
293 LNN_LOGD(LNN_HEART_BEAT, "condition changed to enabled");
294 if (LnnStartHbByTypeAndStrategy(
295 HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false) != SOFTBUS_OK) {
296 LNN_LOGE(LNN_HEART_BEAT, "start ble heartbeat fail");
297 }
298 g_enableState = true;
299 LnnStartHeartbeat(0);
300 } else {
301 LNN_LOGD(LNN_HEART_BEAT, "condition changed to disabled");
302 if (LnnStopHeartbeatByType(HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V1 | HEARTBEAT_TYPE_BLE_V3) !=
303 SOFTBUS_OK) {
304 LNN_LOGE(LNN_HEART_BEAT, "stop ble heartbeat fail");
305 }
306 g_enableState = false;
307 }
308 }
309
GetDisEnableBleDiscoveryTime(uint64_t modeDuration)310 static uint64_t GetDisEnableBleDiscoveryTime(uint64_t modeDuration)
311 {
312 uint64_t timeout = 0ULL;
313 if (modeDuration < MIN_DISABLE_BLE_DISCOVERY_TIME) {
314 timeout = MIN_DISABLE_BLE_DISCOVERY_TIME;
315 } else {
316 timeout = (modeDuration > MAX_DISABLE_BLE_DISCOVERY_TIME) ? MAX_DISABLE_BLE_DISCOVERY_TIME : modeDuration;
317 }
318 return timeout;
319 }
320
HbEnableDiscovery(void)321 void HbEnableDiscovery(void)
322 {
323 LNN_LOGI(LNN_HEART_BEAT, "Enable ble discovery.");
324 HbConditionChanged(false);
325 }
326
RequestEnableDiscovery(void * para)327 static void RequestEnableDiscovery(void *para)
328 {
329 (void)para;
330 if (!g_hbConditionState.isRequestDisable) {
331 LNN_LOGI(LNN_HEART_BEAT, "ble has been enabled, don't need restore enabled");
332 return;
333 }
334 g_hbConditionState.isRequestDisable = false;
335 LNN_LOGI(LNN_HEART_BEAT, "ble has been requestEnable");
336 HbConditionChanged(false);
337 }
338
RequestDisableDiscovery(int64_t timeout)339 static void RequestDisableDiscovery(int64_t timeout)
340 {
341 if (g_hbConditionState.isRequestDisable) {
342 LNN_LOGI(LNN_HEART_BEAT, "ble has been requestDisabled, need wait timeout or enabled");
343 return;
344 }
345 if (timeout != INVALID_DELAY_TIME) {
346 uint64_t time = GetDisEnableBleDiscoveryTime((uint64_t)timeout);
347 if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), RequestEnableDiscovery, NULL, time) !=
348 SOFTBUS_OK) {
349 LNN_LOGI(LNN_HEART_BEAT, "ble has been requestDisabled fail, due to async callback fail");
350 return;
351 }
352 }
353 g_hbConditionState.isRequestDisable = true;
354 LNN_LOGI(LNN_HEART_BEAT, "ble has been requestDisabled");
355 HbConditionChanged(false);
356 }
357
SameAccountDevDisableDiscoveryProcess(void)358 static int32_t SameAccountDevDisableDiscoveryProcess(void)
359 {
360 bool addrType[CONNECTION_ADDR_MAX] = {false};
361 addrType[CONNECTION_ADDR_BLE] = true;
362 if (LnnRequestLeaveByAddrType(addrType, CONNECTION_ADDR_MAX) != SOFTBUS_OK) {
363 LNN_LOGE(LNN_HEART_BEAT, "leave ble network fail");
364 }
365 return LnnSyncBleOfflineMsgPacked();
366 }
367
LnnRequestBleDiscoveryProcess(int32_t strategy,int64_t timeout)368 void LnnRequestBleDiscoveryProcess(int32_t strategy, int64_t timeout)
369 {
370 LNN_LOGI(LNN_HEART_BEAT, "LnnRequestBleDiscoveryProcess enter");
371 switch (strategy) {
372 case REQUEST_DISABLE_BLE_DISCOVERY:
373 RequestDisableDiscovery(timeout);
374 break;
375 case REQUEST_ENABLE_BLE_DISCOVERY:
376 RequestEnableDiscovery(NULL);
377 break;
378 case SAME_ACCOUNT_REQUEST_DISABLE_BLE_DISCOVERY:
379 RequestDisableDiscovery(INVALID_DELAY_TIME);
380 SameAccountDevDisableDiscoveryProcess();
381 break;
382 case SAME_ACCOUNT_REQUEST_ENABLE_BLE_DISCOVERY:
383 RequestEnableDiscovery(NULL);
384 break;
385 default:
386 LNN_LOGE(LNN_HEART_BEAT, "error strategy, not need to deal. strategy=%{public}d", strategy);
387 }
388 }
389
HbRootDeviceLeaveLnn(void)390 static int32_t HbRootDeviceLeaveLnn(void)
391 {
392 LNN_LOGI(LNN_HEART_BEAT, "enter HbRootDeviceLeaveLnn");
393 int32_t i = 0;
394 int32_t infoNum = 0;
395 NodeBasicInfo *info = NULL;
396 if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
397 LNN_LOGE(LNN_HEART_BEAT, "get online node info failed");
398 return SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR;
399 }
400 if (info == NULL || infoNum == 0) {
401 LNN_LOGE(LNN_HEART_BEAT, "get online node is 0");
402 return SOFTBUS_NO_ONLINE_DEVICE;
403 }
404 int32_t ret;
405 NodeInfo nodeInfo;
406 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
407 for (i = 0; i < infoNum; ++i) {
408 ret = LnnGetRemoteNodeInfoById(info[i].networkId, CATEGORY_NETWORK_ID, &nodeInfo);
409 if (ret != SOFTBUS_OK) {
410 continue;
411 }
412 LNN_LOGI(LNN_HEART_BEAT, "device is root, need to offline");
413 LnnRequestLeaveSpecific(info[i].networkId, CONNECTION_ADDR_MAX);
414 AuthRemoveDeviceKeyByUdidPacked(nodeInfo.deviceInfo.deviceUdid);
415 }
416 SoftBusFree(info);
417 return SOFTBUS_OK;
418 }
419
HbHandleLeaveLnn(void)420 static int32_t HbHandleLeaveLnn(void)
421 {
422 int32_t i;
423 int32_t infoNum;
424 NodeBasicInfo *info = NULL;
425 if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
426 LNN_LOGE(LNN_HEART_BEAT, "get online node info failed");
427 return SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR;
428 }
429 if (info == NULL || infoNum == 0) {
430 LNN_LOGE(LNN_HEART_BEAT, "get online node is 0");
431 return SOFTBUS_NO_ONLINE_DEVICE;
432 }
433 int32_t ret;
434 NodeInfo nodeInfo;
435 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
436 for (i = 0; i < infoNum; ++i) {
437 ret = LnnGetRemoteNodeInfoById(info[i].networkId, CATEGORY_NETWORK_ID, &nodeInfo);
438 if (ret != SOFTBUS_OK) {
439 continue;
440 }
441 if ((nodeInfo.feature & (1 << BIT_SUPPORT_THREE_STATE)) == 0 && SoftBusGetBrState() == BR_DISABLE) {
442 LNN_LOGI(LNN_HEART_BEAT, "peer don't support three state and local br off");
443 LnnRequestLeaveSpecific(info[i].networkId, CONNECTION_ADDR_BLE);
444 }
445 }
446 SoftBusFree(info);
447 return SOFTBUS_OK;
448 }
449
HbDelaySetNormalScanParam(void * para)450 static void HbDelaySetNormalScanParam(void *para)
451 {
452 (void)para;
453 LnnHeartbeatMediumParam param;
454 (void)memset_s(¶m, sizeof(LnnHeartbeatMediumParam), 0, sizeof(LnnHeartbeatMediumParam));
455 if (g_hbConditionState.screenState == SOFTBUS_SCREEN_OFF && !LnnIsLocalSupportBurstFeature()) {
456 param.type = HEARTBEAT_TYPE_BLE_V1;
457 param.info.ble.scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P2;
458 param.info.ble.scanWindow = SOFTBUS_BC_SCAN_WINDOW_P2;
459 } else {
460 param.type = HEARTBEAT_TYPE_BLE_V1;
461 param.info.ble.scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P10;
462 param.info.ble.scanWindow = SOFTBUS_BC_SCAN_WINDOW_P10;
463 }
464 LNN_LOGI(LNN_HEART_BEAT, "scanInterval=%{public}hu, scanWindow=%{public}hu", param.info.ble.scanInterval,
465 param.info.ble.scanWindow);
466 if (LnnSetMediumParamBySpecificType(¶m) != SOFTBUS_OK) {
467 LNN_LOGE(LNN_HEART_BEAT, "ctrl reset ble scan medium param fail");
468 }
469 }
470
HbDelaySetHighScanParam(void * para)471 static void HbDelaySetHighScanParam(void *para)
472 {
473 (void)para;
474
475 if (g_hbConditionState.screenState == SOFTBUS_SCREEN_OFF) {
476 LNN_LOGD(LNN_HEART_BEAT, "screen off, no need handle");
477 return;
478 }
479 LnnHeartbeatMediumParam param = {
480 .type = HEARTBEAT_TYPE_BLE_V1,
481 .info.ble.scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P25,
482 .info.ble.scanWindow = SOFTBUS_BC_SCAN_WINDOW_P25,
483 };
484 LNN_LOGI(LNN_HEART_BEAT, "scanInterval=%{public}hu, scanWindow=%{public}hu", param.info.ble.scanInterval,
485 param.info.ble.scanWindow);
486 if (LnnSetMediumParamBySpecificType(¶m) != SOFTBUS_OK) {
487 LNN_LOGE(LNN_HEART_BEAT, "ctrl reset ble scan medium param fail");
488 }
489 }
490
DfxRecordBleTriggerTimestamp(LnnTriggerReason reason)491 static void DfxRecordBleTriggerTimestamp(LnnTriggerReason reason)
492 {
493 DfxRecordTriggerTime(reason, EVENT_STAGE_LNN_BLE_TRIGGER);
494 }
495
HbHandleBleStateChange(SoftBusBtState btState)496 static void HbHandleBleStateChange(SoftBusBtState btState)
497 {
498 g_enableState = false;
499 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_BLE_TURN_ON, state=%{public}d", btState);
500 LnnUpdateHeartbeatInfo(UPDATE_BT_STATE_OPEN_INFO);
501 ClearAuthLimitMap();
502 ClearLnnBleReportExtraMap();
503 HbConditionChanged(false);
504 if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelaySetHighScanParam, NULL, 0) != SOFTBUS_OK) {
505 LNN_LOGE(LNN_HEART_BEAT, "HB async set high param fail");
506 }
507 if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelaySetNormalScanParam, NULL,
508 HB_START_DELAY_LEN + HB_SEND_RELAY_LEN_ONCE) != SOFTBUS_OK) {
509 LNN_LOGE(LNN_HEART_BEAT, "HB async set normal param fail");
510 }
511 if (LnnStartHbByTypeAndStrategy(HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3,
512 STRATEGY_HB_SEND_ADJUSTABLE_PERIOD, false) != SOFTBUS_OK) {
513 LNN_LOGE(LNN_HEART_BEAT, "start ble heartbeat fail");
514 }
515 if (btState == SOFTBUS_BR_TURN_ON) {
516 LnnUpdateHeartbeatInfo(UPDATE_BR_TURN_ON_INFO);
517 }
518 DfxRecordBleTriggerTimestamp(BLE_TURN_ON);
519 }
520
HbBtStateChangeEventHandler(const LnnEventBasicInfo * info)521 static void HbBtStateChangeEventHandler(const LnnEventBasicInfo *info)
522 {
523 if (info == NULL || info->event != LNN_EVENT_BT_STATE_CHANGED) {
524 LNN_LOGE(LNN_HEART_BEAT, "bt state change evt handler get invalid param");
525 return;
526 }
527 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
528 SoftBusBtState btState = (SoftBusBtState)event->status;
529 g_hbConditionState.btState = btState;
530 switch (btState) {
531 case SOFTBUS_BLE_TURN_ON:
532 case SOFTBUS_BR_TURN_ON:
533 HbHandleBleStateChange(btState);
534 break;
535 case SOFTBUS_BR_TURN_OFF:
536 if (SoftBusGetBtState() == BLE_DISABLE) {
537 LNN_LOGE(LNN_HEART_BEAT, "ble is off");
538 return;
539 }
540 g_enableState = false;
541 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_BR_TURN_OFF, state=%{public}d", btState);
542 (void)HbHandleLeaveLnn();
543 HbConditionChanged(false);
544 if (LnnStartHbByTypeAndStrategy(HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3,
545 STRATEGY_HB_SEND_ADJUSTABLE_PERIOD, false) != SOFTBUS_OK) {
546 LNN_LOGE(LNN_HEART_BEAT, "start ble heartbeat fail");
547 }
548 DfxRecordBleTriggerTimestamp(BLE_TURN_OFF);
549 break;
550 case SOFTBUS_BLE_TURN_OFF:
551 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_BLE_TURN_OFF");
552 HbConditionChanged(false);
553 DfxRecordBleTriggerTimestamp(BLE_TURN_OFF);
554 ClearAuthLimitMap();
555 ClearLnnBleReportExtraMap();
556 break;
557 default:
558 return;
559 }
560 }
561
HbLaneVapChangeEventHandler(const LnnEventBasicInfo * info)562 static void HbLaneVapChangeEventHandler(const LnnEventBasicInfo *info)
563 {
564 if (info == NULL || info->event != LNN_EVENT_LANE_VAP_CHANGE) {
565 LNN_LOGE(LNN_HEART_BEAT, "invalid param");
566 return;
567 }
568 LnnLaneVapChangeEvent *vap = (LnnLaneVapChangeEvent *)info;
569 if (SoftBusGetBtState() == BLE_DISABLE) {
570 LNN_LOGE(LNN_HEART_BEAT, "ble is off");
571 return;
572 }
573 LNN_LOGI(LNN_HEART_BEAT, "HB handle vapChange, channel=%{public}d", vap->vapPreferChannel);
574 if (LnnStartHbByTypeAndStrategy(
575 HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false) != SOFTBUS_OK) {
576 LNN_LOGE(LNN_HEART_BEAT, "start ble heartbeat fail");
577 }
578 DfxRecordBleTriggerTimestamp(BLE_LANE_VAP_CHANGED);
579 }
580
HbMasterNodeChangeEventHandler(const LnnEventBasicInfo * info)581 static void HbMasterNodeChangeEventHandler(const LnnEventBasicInfo *info)
582 {
583 if (info == NULL || info->event != LNN_EVENT_NODE_MASTER_STATE_CHANGED) {
584 LNN_LOGE(LNN_HEART_BEAT, "master node change evt handler get invalid param");
585 return;
586 }
587
588 const LnnMasterNodeChangedEvent *event = (LnnMasterNodeChangedEvent *)info;
589 if (LnnSetHbAsMasterNodeState(event->isMasterNode) != SOFTBUS_OK) {
590 LNN_LOGE(LNN_HEART_BEAT, "ctrl change master node state fail");
591 }
592 }
593
HbRemoveCheckOffLineMessage(LnnHeartbeatType hbType)594 static void HbRemoveCheckOffLineMessage(LnnHeartbeatType hbType)
595 {
596 if (hbType <= HEARTBEAT_TYPE_MIN || hbType >= HEARTBEAT_TYPE_MAX) {
597 LNN_LOGE(LNN_HEART_BEAT, "get invalid hbType param");
598 return;
599 }
600 int32_t i, infoNum;
601 NodeBasicInfo *info = NULL;
602 if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
603 LNN_LOGE(LNN_HEART_BEAT, "check dev status get online node info failed");
604 return;
605 }
606 if (info == NULL || infoNum == 0) {
607 LNN_LOGE(LNN_HEART_BEAT, "check dev status get online node is 0");
608 return;
609 }
610 for (i = 0; i < infoNum; ++i) {
611 if (LnnIsLSANode(&info[i])) {
612 continue;
613 }
614 if (LnnStopScreenChangeOfflineTiming(info[i].networkId, LnnConvertHbTypeToConnAddrType(hbType)) != SOFTBUS_OK) {
615 char *anonyNetworkId = NULL;
616 Anonymize(info[i].networkId, &anonyNetworkId);
617 LNN_LOGE(LNN_HEART_BEAT, "stop check offline target msg failed, networkId=%{public}s",
618 AnonymizeWrapper(anonyNetworkId));
619 AnonymizeFree(anonyNetworkId);
620 }
621 }
622 SoftBusFree(info);
623 }
624
HbChangeMediumParamByState(SoftBusScreenState state)625 static void HbChangeMediumParamByState(SoftBusScreenState state)
626 {
627 LnnHeartbeatMediumParam param = {
628 .type = HEARTBEAT_TYPE_BLE_V1,
629 };
630 switch (state) {
631 case SOFTBUS_SCREEN_ON:
632 param.info.ble.scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P10;
633 param.info.ble.scanWindow = SOFTBUS_BC_SCAN_WINDOW_P10;
634 break;
635 case SOFTBUS_SCREEN_OFF:
636 param.info.ble.scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P2;
637 param.info.ble.scanWindow = SOFTBUS_BC_SCAN_WINDOW_P2;
638 break;
639 default:
640 LNN_LOGD(LNN_HEART_BEAT, "ctrl reset ble scan medium param get invalid state");
641 return;
642 }
643 if (!LnnIsLocalSupportBurstFeature() && (LnnSetMediumParamBySpecificType(¶m) != SOFTBUS_OK)) {
644 LNN_LOGE(LNN_HEART_BEAT, "ctrl reset ble scan medium param fail");
645 return;
646 }
647 LnnUpdateHeartbeatInfo(UPDATE_SCREEN_STATE_INFO);
648 }
649
HbDelayConditionChanged(void * para)650 static void HbDelayConditionChanged(void *para)
651 {
652 (void)para;
653
654 g_isCloudSyncEnd = true;
655 LNN_LOGI(LNN_HEART_BEAT, "HB handle delay condition changed");
656 LnnUpdateOhosAccount(UPDATE_HEARTBEAT);
657 LnnUpdateSendInfoStrategy(UPDATE_HB_ACCOUNT_INFO);
658 LnnHbOnTrustedRelationIncreased(AUTH_IDENTICAL_ACCOUNT_GROUP);
659 g_hbConditionState.heartbeatEnable = IsEnableSoftBusHeartbeat();
660 HbConditionChanged(false);
661 }
662
HbTryCloudSync(void)663 static int32_t HbTryCloudSync(void)
664 {
665 NodeInfo info;
666
667 if (LnnIsDefaultOhosAccount()) {
668 LNN_LOGW(LNN_HEART_BEAT, "HB accountId is null, no need sync");
669 return SOFTBUS_NOT_LOGIN;
670 }
671 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
672 if (LnnGetLocalNodeInfoSafe(&info) != SOFTBUS_OK) {
673 LNN_LOGE(LNN_HEART_BEAT, "HB save local device info fail");
674 return SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR;
675 }
676 int32_t ret = LnnLedgerAllDataSyncToDB(&info, false, NULL);
677 if (ret == SOFTBUS_OK) {
678 LNN_LOGI(LNN_HEART_BEAT, "HB sync to cloud end");
679 } else {
680 LNN_LOGE(LNN_HEART_BEAT, "HB sync to cloud fail");
681 }
682 return ret;
683 }
684
HbScreenOnOnceTryCloudSync(void)685 static void HbScreenOnOnceTryCloudSync(void)
686 {
687 HbRefreshConditionState();
688 if (g_hbConditionState.screenState == SOFTBUS_SCREEN_ON && !g_isScreenOnOnce &&
689 g_hbConditionState.accountState == SOFTBUS_ACCOUNT_LOG_IN &&
690 g_hbConditionState.lockState == SOFTBUS_SCREEN_UNLOCK) {
691 LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelayConditionChanged, NULL,
692 HbTryCloudSync() == SOFTBUS_OK ? HB_CLOUD_SYNC_DELAY_LEN : 0);
693 }
694 }
695
DfxRecordScreenChangeTimestamp(LnnTriggerReason reason)696 static void DfxRecordScreenChangeTimestamp(LnnTriggerReason reason)
697 {
698 DfxRecordTriggerTime(reason, EVENT_STAGE_LNN_SCREEN_STATE_CHANGED);
699 }
700
HbDeviceRootStateEventHandler(const LnnEventBasicInfo * info)701 static void HbDeviceRootStateEventHandler(const LnnEventBasicInfo *info)
702 {
703 if (info == NULL || info->event != LNN_EVENT_DEVICE_ROOT_STATE_CHANGED) {
704 LNN_LOGE(LNN_HEART_BEAT, "device root state change evt handler get invalid param");
705 return;
706 }
707 const LnnDeviceRootStateChangeEvent *event = (const LnnDeviceRootStateChangeEvent *)info;
708 SoftBusDeviceRootState deviceRootState = (SoftBusDeviceRootState)event->status;
709 LNN_LOGI(LNN_HEART_BEAT, "HB handle deviceRootState=%{public}d", deviceRootState);
710 switch (deviceRootState) {
711 case SOFTBUS_DEVICE_IS_ROOT:
712 if (g_hbConditionState.deviceRootState != SOFTBUS_DEVICE_IS_ROOT) {
713 g_hbConditionState.deviceRootState = deviceRootState;
714 }
715 HbConditionChanged(false);
716 HbRootDeviceLeaveLnn();
717 break;
718 case SOFTBUS_DEVICE_NOT_ROOT:
719 if (g_hbConditionState.deviceRootState != SOFTBUS_DEVICE_NOT_ROOT) {
720 g_hbConditionState.deviceRootState = deviceRootState;
721 }
722 break;
723 default:
724 LNN_LOGE(LNN_HEART_BEAT, "error deviceRootState");
725 break;
726 }
727 }
728
HbScreenOnChangeEventHandler(int64_t nowTime)729 static void HbScreenOnChangeEventHandler(int64_t nowTime)
730 {
731 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_SCREEN_ON");
732 g_lastScreenOnTime = nowTime;
733 g_isScreenOnOnce = true;
734 if (LnnIsLocalSupportBurstFeature()) {
735 LnnRemoveV0BroadcastAndCheckDev();
736 }
737 HbRemoveCheckOffLineMessage(HEARTBEAT_TYPE_BLE_V1);
738 HbChangeMediumParamByState(g_hbConditionState.screenState);
739 if (g_lastScreenOnTime - g_lastScreenOffTime >= HB_SCREEN_ON_COAP_TIME) {
740 LNN_LOGD(LNN_HEART_BEAT, "screen on start coap discovery");
741 RestartCoapDiscovery();
742 }
743 int32_t ret = LnnStartHbByTypeAndStrategy(
744 HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false);
745 if (ret != SOFTBUS_OK) {
746 LNN_LOGE(LNN_HEART_BEAT, "start ble heartbeat failed, ret=%{public}d", ret);
747 }
748 DfxRecordScreenChangeTimestamp(SCREEN_ON);
749 }
750
HbScreenStateChangeEventHandler(const LnnEventBasicInfo * info)751 static void HbScreenStateChangeEventHandler(const LnnEventBasicInfo *info)
752 {
753 int64_t nowTime;
754 SoftBusSysTime time = { 0 };
755 if (info == NULL || info->event != LNN_EVENT_SCREEN_STATE_CHANGED) {
756 LNN_LOGE(LNN_HEART_BEAT, "screen state evt handler get invalid param");
757 return;
758 }
759 const LnnMonitorHbStateChangedEvent *event = (LnnMonitorHbStateChangedEvent *)info;
760 if ((SoftBusScreenState)event->status == SOFTBUS_SCREEN_UNKNOWN) {
761 LNN_LOGE(LNN_HEART_BEAT, "get invalid screen state");
762 return;
763 }
764 SoftBusScreenState oldstate = g_hbConditionState.screenState;
765 g_hbConditionState.screenState = (SoftBusScreenState)event->status;
766 SoftBusGetRealTime(&time);
767 nowTime = time.sec * HB_TIME_FACTOR + time.usec / HB_TIME_FACTOR;
768 HbScreenOnOnceTryCloudSync();
769 if (g_hbConditionState.screenState == SOFTBUS_SCREEN_ON && oldstate != SOFTBUS_SCREEN_ON) {
770 (void)LnnUpdateLocalScreenStatus(true);
771 HbScreenOnChangeEventHandler(nowTime);
772 return;
773 }
774 if (g_hbConditionState.screenState == SOFTBUS_SCREEN_OFF && oldstate != SOFTBUS_SCREEN_OFF) {
775 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_SCREEN_OFF");
776 g_lastScreenOffTime = nowTime;
777 (void)LnnUpdateLocalScreenStatus(false);
778 if (!LnnIsLocalSupportBurstFeature()) {
779 if (LnnStartHbByTypeAndStrategy(HEARTBEAT_TYPE_BLE_V0, STRATEGY_HB_SEND_SINGLE, false) != SOFTBUS_OK) {
780 LNN_LOGE(LNN_HEART_BEAT, "start ble heartbeat failed");
781 return;
782 }
783 DfxRecordScreenChangeTimestamp(SCREEN_OFF);
784 }
785 if (LnnStopHeartBeatAdvByTypeNow(HEARTBEAT_TYPE_BLE_V1) != SOFTBUS_OK) {
786 LNN_LOGE(LNN_HEART_BEAT, "ctrl disable ble heartbeat failed");
787 return;
788 }
789 HbChangeMediumParamByState(g_hbConditionState.screenState);
790 HbSendCheckOffLineMessage(HEARTBEAT_TYPE_BLE_V1);
791 }
792 }
793
HbScreenLockChangeEventHandler(const LnnEventBasicInfo * info)794 static void HbScreenLockChangeEventHandler(const LnnEventBasicInfo *info)
795 {
796 if (info == NULL || info->event != LNN_EVENT_SCREEN_LOCK_CHANGED) {
797 LNN_LOGE(LNN_HEART_BEAT, "lock state change evt handler get invalid param");
798 return;
799 }
800 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
801 SoftBusScreenLockState lockState = (SoftBusScreenLockState)event->status;
802 if (lockState == SOFTBUS_USER_UNLOCK) {
803 LNN_LOGI(LNN_HEART_BEAT, "user unlocked");
804 (void)LnnGenerateCeParams(true);
805 AuthLoadDeviceKeyPacked();
806 LnnUpdateOhosAccount(UPDATE_ACCOUNT_ONLY);
807 if (!LnnIsDefaultOhosAccount()) {
808 LnnNotifyAccountStateChangeEvent(SOFTBUS_ACCOUNT_LOG_IN);
809 }
810 }
811 lockState = lockState == SOFTBUS_USER_UNLOCK ? SOFTBUS_SCREEN_UNLOCK : lockState;
812 if (g_hbConditionState.lockState == SOFTBUS_SCREEN_UNLOCK) {
813 LNN_LOGI(LNN_HEART_BEAT, "screen unlocked once already, ignoring this event");
814 return;
815 }
816 g_hbConditionState.lockState = lockState;
817 LNN_LOGI(LNN_HEART_BEAT, "ScreenLock state: heartbeat=%{public}d", g_hbConditionState.heartbeatEnable);
818 switch (lockState) {
819 case SOFTBUS_SCREEN_UNLOCK:
820 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_SCREEN_UNLOCK");
821 HbRefreshConditionState();
822 if (g_hbConditionState.screenState == SOFTBUS_SCREEN_ON &&
823 g_hbConditionState.accountState == SOFTBUS_ACCOUNT_LOG_IN) {
824 LnnAsyncCallbackDelayHelper(
825 GetLooper(LOOP_TYPE_DEFAULT), HbDelaySetHighScanParam, NULL, HB_CLOUD_SYNC_DELAY_LEN);
826 LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelaySetNormalScanParam, NULL,
827 HB_CLOUD_SYNC_DELAY_LEN + HB_START_DELAY_LEN + HB_SEND_RELAY_LEN_ONCE);
828 LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelayConditionChanged, NULL,
829 HbTryCloudSync() == SOFTBUS_OK ? HB_CLOUD_SYNC_DELAY_LEN : 0);
830 }
831 if (g_hbConditionState.screenState == SOFTBUS_SCREEN_ON &&
832 g_hbConditionState.accountState != SOFTBUS_ACCOUNT_LOG_IN) {
833 HbConditionChanged(false);
834 }
835 break;
836 case SOFTBUS_SCREEN_LOCK:
837 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_SCREEN_LOCK");
838 break;
839 default:
840 return;
841 }
842 }
843
HbAccountStateChangeEventHandler(const LnnEventBasicInfo * info)844 static void HbAccountStateChangeEventHandler(const LnnEventBasicInfo *info)
845 {
846 if (info == NULL || info->event != LNN_EVENT_ACCOUNT_CHANGED) {
847 LNN_LOGE(LNN_HEART_BEAT, "account state change evt handler get invalid param");
848 return;
849 }
850 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
851 SoftBusAccountState accountState = (SoftBusAccountState)event->status;
852 g_hbConditionState.accountState = accountState;
853 switch (accountState) {
854 case SOFTBUS_ACCOUNT_LOG_IN:
855 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_ACCOUNT_LOG_IN");
856 LnnAsyncCallbackDelayHelper(
857 GetLooper(LOOP_TYPE_DEFAULT), HbDelaySetHighScanParam, NULL, HB_CLOUD_SYNC_DELAY_LEN);
858 LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelaySetNormalScanParam, NULL,
859 HB_CLOUD_SYNC_DELAY_LEN + HB_START_DELAY_LEN + HB_SEND_RELAY_LEN_ONCE);
860 LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelayConditionChanged, NULL,
861 HbTryCloudSync() == SOFTBUS_OK ? HB_CLOUD_SYNC_DELAY_LEN : 0);
862 break;
863 case SOFTBUS_ACCOUNT_LOG_OUT:
864 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_ACCOUNT_LOG_OUT");
865 LnnSetCloudAbility(false);
866 if (LnnDeleteSyncToDB() != SOFTBUS_OK) {
867 LNN_LOGE(LNN_LEDGER, "HB clear local cache fail");
868 }
869 LnnOnOhosAccountLogout();
870 HbConditionChanged(false);
871 if (LnnStartHbByTypeAndStrategy(
872 HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false) != SOFTBUS_OK) {
873 LNN_LOGE(LNN_HEART_BEAT, "ctrl start single ble heartbeat fail");
874 }
875 break;
876 default:
877 return;
878 }
879 }
880
HbHomeGroupStateChangeEventHandler(const LnnEventBasicInfo * info)881 static void HbHomeGroupStateChangeEventHandler(const LnnEventBasicInfo *info)
882 {
883 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
884 SoftBusHomeGroupState homeGroupState = (SoftBusHomeGroupState)event->status;
885 LnnUpdateHeartbeatInfo(UPDATE_HB_NETWORK_INFO);
886 switch (homeGroupState) {
887 case SOFTBUS_HOME_GROUP_CHANGE:
888 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_HOME_GROUP_CHANGE");
889 HbConditionChanged(false);
890 break;
891 case SOFTBUS_HOME_GROUP_LEAVE:
892 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_HOME_GROUP_LEAVE");
893 break;
894 default:
895 return;
896 }
897 }
898
HbDifferentAccountEventHandler(const LnnEventBasicInfo * info)899 static void HbDifferentAccountEventHandler(const LnnEventBasicInfo *info)
900 {
901 if (info == NULL || info->event != LNN_EVENT_DIF_ACCOUNT_DEV_CHANGED) {
902 LNN_LOGE(LNN_HEART_BEAT, "account state change evt handler get invalid param");
903 return;
904 }
905 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
906 SoftBusDifferentAccountState difAccountState = (SoftBusDifferentAccountState)event->status;
907 if ((LnnEventType)difAccountState == LNN_EVENT_DIF_ACCOUNT_DEV_CHANGED) {
908 HbConditionChanged(false);
909 }
910 }
911
HbUserBackgroundEventHandler(const LnnEventBasicInfo * info)912 static void HbUserBackgroundEventHandler(const LnnEventBasicInfo *info)
913 {
914 if (info == NULL || info->event != LNN_EVENT_USER_STATE_CHANGED) {
915 LNN_LOGE(LNN_HEART_BEAT, "user background state change evt handler get invalid param");
916 return;
917 }
918 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
919 SoftBusUserState userState = (SoftBusUserState)event->status;
920 switch (userState) {
921 case SOFTBUS_USER_FOREGROUND:
922 g_hbConditionState.backgroundState = userState;
923 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_USER_FOREGROUND");
924 HbConditionChanged(false);
925 break;
926 case SOFTBUS_USER_BACKGROUND:
927 g_hbConditionState.backgroundState = userState;
928 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_USER_BACKGROUND");
929 HbConditionChanged(false);
930 break;
931 default:
932 return;
933 }
934 }
935
HbNightModeStateEventHandler(const LnnEventBasicInfo * info)936 static void HbNightModeStateEventHandler(const LnnEventBasicInfo *info)
937 {
938 if (info == NULL || info->event != LNN_EVENT_NIGHT_MODE_CHANGED) {
939 LNN_LOGE(LNN_HEART_BEAT, "user background state change evt handler get invalid param");
940 return;
941 }
942 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
943 SoftBusNightModeState nightModeState = (SoftBusNightModeState)event->status;
944 g_hbConditionState.nightModeState = nightModeState;
945 switch (nightModeState) {
946 case SOFTBUS_NIGHT_MODE_ON:
947 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_NIGHT_MODE_ON");
948 HbConditionChanged(false);
949 break;
950 case SOFTBUS_NIGHT_MODE_OFF:
951 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_NIGHT_MODE_OFF");
952 HbConditionChanged(false);
953 break;
954 default:
955 return;
956 }
957 }
958
HbOOBEStateEventHandler(const LnnEventBasicInfo * info)959 static void HbOOBEStateEventHandler(const LnnEventBasicInfo *info)
960 {
961 if (info == NULL || info->event != LNN_EVENT_OOBE_STATE_CHANGED) {
962 LNN_LOGE(LNN_HEART_BEAT, "OOBE state change evt handler get invalid param");
963 return;
964 }
965 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
966 SoftBusOOBEState state = (SoftBusOOBEState)event->status;
967 LNN_LOGI(
968 LNN_HEART_BEAT, "HB handle oobe state=%{public}d, g_state=%{public}d", state, g_hbConditionState.OOBEState);
969 switch (state) {
970 case SOFTBUS_OOBE_RUNNING:
971 if (g_hbConditionState.OOBEState != SOFTBUS_FACK_OOBE_END) {
972 g_hbConditionState.OOBEState = state;
973 HbConditionChanged(false);
974 }
975 break;
976 case SOFTBUS_FACK_OOBE_END:
977 if (g_hbConditionState.OOBEState != SOFTBUS_OOBE_END &&
978 g_hbConditionState.OOBEState != SOFTBUS_FACK_OOBE_END) {
979 g_hbConditionState.OOBEState = state;
980 HbConditionChanged(false);
981 }
982 break;
983 case SOFTBUS_OOBE_END:
984 if (g_hbConditionState.OOBEState != SOFTBUS_OOBE_END) {
985 g_hbConditionState.OOBEState = state;
986 HbConditionChanged(false);
987 }
988 break;
989 default:
990 return;
991 }
992 }
993
RefreshBleBroadcastByUserSwitched(void)994 static void RefreshBleBroadcastByUserSwitched(void)
995 {
996 LnnProcessSendOnceMsgPara msgPara = {
997 .hbType = HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3,
998 .strategyType = STRATEGY_HB_SEND_SINGLE,
999 .isRelay = false,
1000 .isSyncData = false,
1001 .isDirectBoardcast = false,
1002 .isMsdpRange = false,
1003 .callerId = HB_USER_SWITCH_CALLER_ID,
1004 };
1005 if (LnnStartHbByTypeAndStrategyEx(&msgPara) != SOFTBUS_OK) {
1006 LNN_LOGE(LNN_HEART_BEAT, "refresh ble broadcast fail");
1007 }
1008 }
1009
HbUserSwitchedHandler(const LnnEventBasicInfo * info)1010 static void HbUserSwitchedHandler(const LnnEventBasicInfo *info)
1011 {
1012 if (info == NULL || info->event != LNN_EVENT_USER_SWITCHED) {
1013 LNN_LOGW(LNN_HEART_BEAT, "invalid param");
1014 return;
1015 }
1016 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
1017 SoftBusUserSwitchState userSwitchState = (SoftBusUserSwitchState)event->status;
1018 switch (userSwitchState) {
1019 case SOFTBUS_USER_SWITCHED:
1020 {
1021 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_USER_SWITCHED");
1022 uint8_t userIdCheckSum[USERID_CHECKSUM_LEN];
1023 int32_t userId = GetActiveOsAccountIds();
1024 LNN_LOGI(LNN_HEART_BEAT, "userswitch userId:%{public}d", userId);
1025 int32_t ret = LnnSetLocalNumInfo(NUM_KEY_USERID, userId);
1026 if (ret != SOFTBUS_OK) {
1027 LNN_LOGW(LNN_EVENT, "set userId to local failed! userId:%{public}d", userId);
1028 }
1029 ret = HbBuildUserIdCheckSumPacked(&userId, 1, userIdCheckSum, USERID_CHECKSUM_LEN);
1030 if (ret != SOFTBUS_OK) {
1031 LNN_LOGW(LNN_EVENT, "construct useridchecksum failed! userId:%{public}d", userId);
1032 }
1033 ret = LnnSetLocalByteInfo(BYTE_KEY_USERID_CHECKSUM, userIdCheckSum, USERID_CHECKSUM_LEN);
1034 if (ret != SOFTBUS_OK) {
1035 LNN_LOGW(LNN_EVENT, "set useridchecksum to local failed! userId:%{public}d", userId);
1036 }
1037 LnnUpdateOhosAccount(UPDATE_USER_SWITCH);
1038 UpdateRecoveryDeviceInfoFromDb();
1039 LnnUpdateHeartbeatInfo(UPDATE_HB_NETWORK_INFO);
1040 HbConditionChanged(false);
1041 RefreshBleBroadcastByUserSwitched();
1042 if (IsHeartbeatEnable()) {
1043 DfxRecordTriggerTime(USER_SWITCHED, EVENT_STAGE_LNN_USER_SWITCHED);
1044 }
1045 break;
1046 }
1047 default:
1048 return;
1049 }
1050 }
1051
HbLpEventHandler(const LnnEventBasicInfo * info)1052 static void HbLpEventHandler(const LnnEventBasicInfo *info)
1053 {
1054 if (info == NULL || info->event != LNN_EVENT_LP_EVENT_REPORT) {
1055 LNN_LOGE(LNN_HEART_BEAT, "lp report evt handler get invalid param");
1056 return;
1057 }
1058 int32_t ret;
1059 const LnnLpReportEvent *event = (const LnnLpReportEvent *)info;
1060 SoftBusLpEventType type = (SoftBusLpEventType)event->type;
1061 switch (type) {
1062 case SOFTBUS_MSDP_MOVEMENT_AND_STATIONARY:
1063 LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_MSDP_MOVEMENT_AND_STATIONARY");
1064 ret = LnnStartHbByTypeAndStrategy(
1065 HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false);
1066 if (ret != SOFTBUS_OK) {
1067 LNN_LOGE(LNN_HEART_BEAT, "start ble heartbeat failed, ret=%{public}d", ret);
1068 return;
1069 }
1070 DfxRecordBleTriggerTimestamp(MSDP_MOVEMENT_AND_STATIONARY);
1071 break;
1072 default:
1073 LNN_LOGE(LNN_HEART_BEAT, "lp evt handler get invalid type=%{public}d", type);
1074 return;
1075 }
1076 }
1077
HbTryRecoveryNetwork(void)1078 static void HbTryRecoveryNetwork(void)
1079 {
1080 HbConditionChanged(true);
1081 }
1082
PeriodDumpLocalInfo(void * para)1083 static void PeriodDumpLocalInfo(void *para)
1084 {
1085 (void)para;
1086
1087 LnnDumpLocalBasicInfo();
1088 (void)IsHeartbeatEnable();
1089 LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), PeriodDumpLocalInfo, NULL, HB_PERIOD_DUMP_LOCAL_INFO_LEN);
1090 }
1091
LnnStartHeartbeatFrameDelay(void)1092 int32_t LnnStartHeartbeatFrameDelay(void)
1093 {
1094 LNN_LOGI(LNN_HEART_BEAT, "heartbeat(HB) FSM start");
1095 LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), PeriodDumpLocalInfo, NULL, HB_PERIOD_DUMP_LOCAL_INFO_LEN);
1096 if (LnnHbMediumMgrInit() != SOFTBUS_OK) {
1097 LNN_LOGE(LNN_HEART_BEAT, "medium manager init fail");
1098 return SOFTBUS_NETWORK_HB_MGR_INIT_FAIL;
1099 }
1100 HbTryRecoveryNetwork();
1101 if (LnnStartNewHbStrategyFsm() != SOFTBUS_OK) {
1102 LNN_LOGE(LNN_HEART_BEAT, "ctrl start strategy fsm fail");
1103 return SOFTBUS_NETWORK_FSM_START_FAIL;
1104 }
1105 bool hasTrustedRelation = (AuthHasTrustedRelation() == TRUSTED_RELATION_YES) ? true : false;
1106 if (LnnIsDefaultOhosAccount() && !hasTrustedRelation) {
1107 LNN_LOGD(LNN_HEART_BEAT, "no trusted relation, heartbeat(HB) process start later");
1108 return SOFTBUS_OK;
1109 }
1110 if (LnnIsNeedInterceptBroadcast(true)) {
1111 LNN_LOGI(LNN_HEART_BEAT, "local heartbeat disable");
1112 return SOFTBUS_OK;
1113 }
1114 return LnnStartHeartbeat(0);
1115 }
1116
LnnSetHeartbeatMediumParam(const LnnHeartbeatMediumParam * param)1117 int32_t LnnSetHeartbeatMediumParam(const LnnHeartbeatMediumParam *param)
1118 {
1119 return LnnSetMediumParamBySpecificType(param);
1120 }
1121
LnnOfflineTimingByHeartbeat(const char * networkId,ConnectionAddrType addrType)1122 int32_t LnnOfflineTimingByHeartbeat(const char *networkId, ConnectionAddrType addrType)
1123 {
1124 if (networkId == NULL) {
1125 LNN_LOGE(LNN_HEART_BEAT, "offline timing get invalid param");
1126 return SOFTBUS_INVALID_PARAM;
1127 }
1128 /* only support ble medium type yet. */
1129 if (addrType != CONNECTION_ADDR_BLE) {
1130 LNN_LOGD(LNN_HEART_BEAT, "offline timing not support addrType now. addrType=%{public}d", addrType);
1131 return SOFTBUS_INVALID_PARAM;
1132 }
1133 SoftBusSysTime time = { 0 };
1134 (void)SoftBusGetTime(&time);
1135 uint64_t timeStamp = (uint64_t)time.sec * HB_TIME_FACTOR + (uint64_t)time.usec / HB_TIME_FACTOR;
1136 LnnSetDLHeartbeatTimestamp(networkId, timeStamp);
1137 (void)LnnStopOfflineTimingStrategy(networkId, addrType);
1138 if (LnnStartOfflineTimingStrategy(networkId, addrType) != SOFTBUS_OK) {
1139 LNN_LOGE(LNN_HEART_BEAT, "ctrl start offline timing strategy fail");
1140 return SOFTBUS_NETWORK_HB_START_STRATEGY_FAIL;
1141 }
1142 char *anonyNetworkId = NULL;
1143 Anonymize(networkId, &anonyNetworkId);
1144 LNN_LOGI(LNN_HEART_BEAT, "heartbeat(HB) start offline countdown, networkId=%{public}s, timeStamp=%{public}" PRIu64,
1145 AnonymizeWrapper(anonyNetworkId), timeStamp);
1146 AnonymizeFree(anonyNetworkId);
1147 if (SoftBusGetBtState() == BLE_ENABLE) {
1148 g_hbConditionState.btState = SOFTBUS_BLE_TURN_ON;
1149 }
1150 return SOFTBUS_OK;
1151 }
1152
LnnStopOfflineTimingByHeartbeat(const char * networkId,ConnectionAddrType addrType)1153 void LnnStopOfflineTimingByHeartbeat(const char *networkId, ConnectionAddrType addrType)
1154 {
1155 if (networkId == NULL) {
1156 LNN_LOGE(LNN_HEART_BEAT, "HB stop offline timing get invalid param");
1157 return;
1158 }
1159 /* only support ble medium type yet. */
1160 if (addrType != CONNECTION_ADDR_BLE) {
1161 LNN_LOGE(LNN_HEART_BEAT, "HB stop offline timing not support addrType:%{public}d now", addrType);
1162 return;
1163 }
1164 char *anonyNetworkId = NULL;
1165 Anonymize(networkId, &anonyNetworkId);
1166 LNN_LOGD(LNN_HEART_BEAT, "heartbeat(HB) stop offline timing, networkId:%{public}s",
1167 AnonymizeWrapper(anonyNetworkId));
1168 AnonymizeFree(anonyNetworkId);
1169 (void)LnnStopScreenChangeOfflineTiming(networkId, addrType);
1170 (void)LnnStopOfflineTimingStrategy(networkId, addrType);
1171 }
1172
ReportBusinessDiscoveryResultEvt(const char * pkgName,int32_t discCnt)1173 static void ReportBusinessDiscoveryResultEvt(const char *pkgName, int32_t discCnt)
1174 {
1175 LNN_LOGI(LNN_HEART_BEAT, "report business discovery result evt enter");
1176 AppDiscNode appInfo;
1177 (void)memset_s(&appInfo, sizeof(AppDiscNode), 0, sizeof(AppDiscNode));
1178 appInfo.appDiscCnt = discCnt;
1179 if (memcpy_s(appInfo.appName, SOFTBUS_HISYSEVT_NAME_LEN, pkgName, SOFTBUS_HISYSEVT_NAME_LEN) != EOK) {
1180 LNN_LOGE(LNN_HEART_BEAT, "copy app name fail");
1181 return;
1182 }
1183 if (SoftBusRecordDiscoveryResult(BUSINESS_DISCOVERY, &appInfo) != SOFTBUS_OK) {
1184 LNN_LOGE(LNN_HEART_BEAT, "report business discovery result fail");
1185 }
1186 }
1187
LnnShiftLNNGear(const char * pkgName,const char * callerId,const char * targetNetworkId,const GearMode * mode)1188 int32_t LnnShiftLNNGear(const char *pkgName, const char *callerId, const char *targetNetworkId, const GearMode *mode)
1189 {
1190 char *anonyNetworkId = NULL;
1191 if (pkgName == NULL || mode == NULL || callerId == NULL) {
1192 LNN_LOGE(LNN_HEART_BEAT, "shift lnn gear get invalid param");
1193 return SOFTBUS_INVALID_PARAM;
1194 }
1195 Anonymize(targetNetworkId, &anonyNetworkId);
1196 if (targetNetworkId != NULL && !LnnGetOnlineStateById(targetNetworkId, CATEGORY_NETWORK_ID)) {
1197 LNN_LOGD(LNN_HEART_BEAT, "target is offline, networkId=%{public}s", AnonymizeWrapper(anonyNetworkId));
1198 }
1199 LNN_LOGI(LNN_HEART_BEAT,
1200 "shift lnn gear mode, callerId=%{public}s, networkId=%{public}s, cycle=%{public}d, "
1201 "duration=%{public}d, wakeupFlag=%{public}d, action=%{public}d",
1202 callerId, targetNetworkId != NULL ? AnonymizeWrapper(anonyNetworkId) : "", mode->cycle, mode->duration,
1203 mode->wakeupFlag, mode->action);
1204 AnonymizeFree(anonyNetworkId);
1205 char uuid[UUID_BUF_LEN] = { 0 };
1206 if (targetNetworkId != NULL) {
1207 int32_t ret = LnnConvertDlId(targetNetworkId, CATEGORY_NETWORK_ID, CATEGORY_UUID, uuid, UUID_BUF_LEN);
1208 if (ret != SOFTBUS_OK) {
1209 LNN_LOGE(LNN_HEART_BEAT, "targetNetworkId convert uuid fail");
1210 return ret;
1211 }
1212 }
1213 if (mode->action == CHANGE_TCP_KEEPALIVE) {
1214 if (AuthSendKeepaliveOption(uuid, mode->cycle) != SOFTBUS_OK) {
1215 LNN_LOGE(LNN_HEART_BEAT, "auth send keepalive option fail");
1216 return SOFTBUS_NETWORK_SET_KEEPALIVE_OPTION_FAIL;
1217 }
1218 return SOFTBUS_OK;
1219 }
1220 if (LnnSetGearModeBySpecificType(callerId, mode, HEARTBEAT_TYPE_BLE_V0) != SOFTBUS_OK) {
1221 LNN_LOGE(LNN_HEART_BEAT, "ctrl reset medium mode fail");
1222 return SOFTBUS_NETWORK_HB_SET_GEAR_MODE_FAIL;
1223 }
1224 if (LnnStartHbByTypeAndStrategy(
1225 HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_ADJUSTABLE_PERIOD, false) != SOFTBUS_OK) {
1226 LNN_LOGE(LNN_HEART_BEAT, "ctrl start adjustable ble heatbeat fail");
1227 return SOFTBUS_NETWORK_HB_START_STRATEGY_FAIL;
1228 }
1229 DfxRecordTriggerTime(DM_TRIGGER, EVENT_STAGE_LNN_SHIFT_GEAR);
1230 int32_t ret = AuthFlushDevice(uuid);
1231 if (ret != SOFTBUS_OK && ret != SOFTBUS_INVALID_PARAM) {
1232 LNN_LOGI(LNN_HEART_BEAT, "tcp flush failed, wifi will offline");
1233 return LnnRequestLeaveSpecific(targetNetworkId, CONNECTION_ADDR_WLAN);
1234 }
1235 return SOFTBUS_OK;
1236 }
1237
LnnShiftLNNGearWithoutPkgName(const char * callerId,const GearMode * mode,LnnHeartbeatStrategyType strategyType)1238 int32_t LnnShiftLNNGearWithoutPkgName(const char *callerId, const GearMode *mode, LnnHeartbeatStrategyType strategyType)
1239 {
1240 if (mode == NULL || callerId == NULL) {
1241 LNN_LOGE(LNN_HEART_BEAT, "shift lnn gear get invalid param");
1242 return SOFTBUS_INVALID_PARAM;
1243 }
1244 ReportBusinessDiscoveryResultEvt(callerId, 1);
1245 LNN_LOGD(LNN_HEART_BEAT,
1246 "shift lnn gear mode, callerId=%{public}s, cycle=%{public}d, duration=%{public}d, wakeupFlag=%{public}d",
1247 callerId, mode->cycle, mode->duration, mode->wakeupFlag);
1248 if (LnnSetGearModeBySpecificType(callerId, mode, HEARTBEAT_TYPE_BLE_V0) != SOFTBUS_OK) {
1249 LNN_LOGE(LNN_HEART_BEAT, "ctrl reset medium mode fail");
1250 return SOFTBUS_NETWORK_HB_SET_GEAR_MODE_FAIL;
1251 }
1252 if (LnnStartHbByTypeAndStrategy(
1253 HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, strategyType, false) != SOFTBUS_OK) {
1254 LNN_LOGE(LNN_HEART_BEAT, "ctrl start adjustable ble heatbeat fail");
1255 return SOFTBUS_NETWORK_HB_START_STRATEGY_FAIL;
1256 }
1257 int32_t i, infoNum;
1258 char uuid[UUID_BUF_LEN] = { 0 };
1259 NodeBasicInfo *info = NULL;
1260 if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
1261 LNN_LOGE(LNN_HEART_BEAT, "get online node info failed");
1262 return SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR;
1263 }
1264 if (info == NULL || infoNum == 0) {
1265 LNN_LOGE(LNN_HEART_BEAT, "get online node is 0");
1266 return SOFTBUS_NO_ONLINE_DEVICE;
1267 }
1268 int32_t ret;
1269 NodeInfo nodeInfo;
1270 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1271 for (i = 0; i < infoNum; ++i) {
1272 ret = LnnGetRemoteNodeInfoById(info[i].networkId, CATEGORY_NETWORK_ID, &nodeInfo);
1273 if (ret != SOFTBUS_OK || !LnnHasDiscoveryType(&nodeInfo, DISCOVERY_TYPE_WIFI)) {
1274 continue;
1275 }
1276 (void)LnnConvertDlId(info[i].networkId, CATEGORY_NETWORK_ID, CATEGORY_UUID, uuid, UUID_BUF_LEN);
1277 if (AuthFlushDevice(uuid) != SOFTBUS_OK) {
1278 char *anonyUuid = NULL;
1279 Anonymize(uuid, &anonyUuid);
1280 LNN_LOGE(LNN_HEART_BEAT, "tcp flush failed, wifi will offline, uuid=%{public}s",
1281 AnonymizeWrapper(anonyUuid));
1282 AnonymizeFree(anonyUuid);
1283 LnnRequestLeaveSpecific(info[i].networkId, CONNECTION_ADDR_WLAN);
1284 }
1285 }
1286 SoftBusFree(info);
1287 return SOFTBUS_OK;
1288 }
1289
LnnTriggerSleRangeForMsdp(const char * pkgName,const RangeConfig * config)1290 int32_t LnnTriggerSleRangeForMsdp(const char *pkgName, const RangeConfig *config)
1291 {
1292 (void)pkgName;
1293 (void)config;
1294 return SOFTBUS_OK;
1295 }
1296
LnnTriggerHbRangeForMsdp(const char * pkgName,const RangeConfig * config)1297 int32_t LnnTriggerHbRangeForMsdp(const char *pkgName, const RangeConfig *config)
1298 {
1299 LNN_CHECK_AND_RETURN_RET_LOGE(pkgName != NULL && config != NULL && config->medium != SLE_CONN_HADM,
1300 SOFTBUS_INVALID_PARAM, LNN_INIT, "invalid param");
1301 if (LnnIsNeedInterceptBroadcast(true)) {
1302 LNN_LOGI(LNN_HEART_BEAT, "local heartbeat disable");
1303 return SOFTBUS_FUNC_NOT_SUPPORT;
1304 }
1305 const HbMode *mode = &config->configInfo.heartbeat.mode;
1306 LNN_LOGI(LNN_HEART_BEAT, "pkgName=%{public}s, connFlag=%{public}d, duration=%{public}d, replyFlag=%{public}d",
1307 pkgName, mode->connFlag, mode->duration, mode->replyFlag);
1308 LnnProcessSendOnceMsgPara msgPara = {
1309 .hbType = HEARTBEAT_TYPE_BLE_V0,
1310 .strategyType = STRATEGY_HB_SEND_SINGLE,
1311 .isRelay = !mode->replyFlag,
1312 .isSyncData = false,
1313 .isDirectBoardcast = false,
1314 .isMsdpRange = true,
1315 .hasScanRsp = mode->connFlag,
1316 .isFast = true,
1317 .duration = mode->duration * HB_TIME_FACTOR,
1318 .networkId = { 0 },
1319 };
1320 if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelaySetHighScanParam, NULL, 0) != SOFTBUS_OK) {
1321 LNN_LOGE(LNN_HEART_BEAT, "HB async set high param fail");
1322 }
1323 if (LnnAsyncCallbackDelayHelper(
1324 GetLooper(LOOP_TYPE_DEFAULT), HbDelaySetNormalScanParam, NULL, HB_START_DELAY_LEN) != SOFTBUS_OK) {
1325 LNN_LOGE(LNN_HEART_BEAT, "HB async set normal param fail");
1326 }
1327 if (LnnStartHbByTypeAndStrategyEx(&msgPara) != SOFTBUS_OK) {
1328 LNN_LOGE(LNN_HEART_BEAT, "refresh ble broadcast fail");
1329 return SOFTBUS_NETWORK_HB_START_ADV_FAILED;
1330 }
1331 return SOFTBUS_OK;
1332 }
1333
LnnUpdateHeartbeatInfo(LnnHeartbeatUpdateInfoType type)1334 void LnnUpdateHeartbeatInfo(LnnHeartbeatUpdateInfoType type)
1335 {
1336 LNN_LOGI(LNN_HEART_BEAT, "update heartbeat infoType=%{public}d", type);
1337 if (type == UPDATE_HB_ACCOUNT_INFO && !LnnIsDefaultOhosAccount()) {
1338 g_hbConditionState.accountState = SOFTBUS_ACCOUNT_LOG_IN;
1339 LNN_LOGI(LNN_HEART_BEAT, "account is login");
1340 HbConditionChanged(false);
1341 }
1342 LnnUpdateSendInfoStrategy(type);
1343 }
1344
HbDelayCheckTrustedRelation(void * para)1345 static void HbDelayCheckTrustedRelation(void *para)
1346 {
1347 (void)para;
1348 TrustedReturnType ret = AuthHasTrustedRelation();
1349 if (ret == TRUSTED_RELATION_YES) {
1350 g_hbConditionState.heartbeatEnable = IsEnableSoftBusHeartbeat();
1351 g_hbConditionState.hasTrustedRelation = true;
1352 } else if (ret == TRUSTED_RELATION_NO) {
1353 g_hbConditionState.hasTrustedRelation = false;
1354 }
1355 LNN_LOGI(LNN_HEART_BEAT, "delay check trust relation=%{public}d", g_hbConditionState.hasTrustedRelation);
1356 HbConditionChanged(false);
1357 if (LnnIsDefaultOhosAccount() && !g_hbConditionState.hasTrustedRelation) {
1358 LNN_LOGW(LNN_HEART_BEAT, "no trusted relation, heartbeat(HB) process stop");
1359 LnnStopHeartbeatByType(
1360 HEARTBEAT_TYPE_UDP | HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V1 | HEARTBEAT_TYPE_TCP_FLUSH);
1361 }
1362 }
1363
LnnHbOnTrustedRelationIncreased(int32_t groupType)1364 void LnnHbOnTrustedRelationIncreased(int32_t groupType)
1365 {
1366 /* If it is a peer-to-peer group or share group, delay initialization to give BR networking priority. */
1367 if (groupType != AUTH_PEER_TO_PEER_GROUP || !IsHeartbeatEnable()) {
1368 int32_t ret = LnnStartHeartbeat(0);
1369 if (ret != SOFTBUS_OK) {
1370 LNN_LOGE(LNN_HEART_BEAT, "account group created start heartbeat fail, ret=%{public}d", ret);
1371 return;
1372 }
1373 }
1374 if ((groupType == AUTH_PEER_TO_PEER_GROUP || groupType == AUTH_SHARE) &&
1375 LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelayCheckTrustedRelation, NULL,
1376 CHECK_TRUSTED_RELATION_TIME) != SOFTBUS_OK) {
1377 LNN_LOGE(LNN_HEART_BEAT, "async check trusted relaion fail");
1378 }
1379 }
1380
LnnHbOnTrustedRelationReduced(void)1381 void LnnHbOnTrustedRelationReduced(void)
1382 {
1383 if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), HbDelayCheckTrustedRelation, NULL,
1384 CHECK_TRUSTED_RELATION_TIME) != SOFTBUS_OK) {
1385 LNN_LOGE(LNN_HEART_BEAT, "async check trusted relaion fail");
1386 }
1387 }
1388
LnnRegisterCommonEvent(void)1389 static int32_t LnnRegisterCommonEvent(void)
1390 {
1391 int32_t ret;
1392 ret = LnnRegisterEventHandler(LNN_EVENT_SCREEN_STATE_CHANGED, HbScreenStateChangeEventHandler);
1393 LNN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, LNN_INIT, "regist screen state change evt handler fail");
1394 ret = LnnRegisterEventHandler(LNN_EVENT_SCREEN_LOCK_CHANGED, HbScreenLockChangeEventHandler);
1395 LNN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, LNN_INIT, "regist screen lock state change evt handler fai");
1396 ret = LnnRegisterEventHandler(LNN_EVENT_NIGHT_MODE_CHANGED, HbNightModeStateEventHandler);
1397 LNN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, LNN_INIT, "regist night mode state evt handler fail");
1398 ret = LnnRegisterEventHandler(LNN_EVENT_OOBE_STATE_CHANGED, HbOOBEStateEventHandler);
1399 LNN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, LNN_INIT, "regist OOBE state evt handler fail");
1400 ret = LnnRegisterEventHandler(LNN_EVENT_USER_SWITCHED, HbUserSwitchedHandler);
1401 LNN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, LNN_INIT, "regist user switch evt handler fail");
1402 ret = LnnRegisterEventHandler(LNN_EVENT_SLE_STATE_CHANGED, HbSleStateEventHandler);
1403 LNN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, LNN_INIT, "regist sle state change evt handler fail");
1404 ret = LnnRegisterEventHandler(LNN_EVENT_DEVICE_ROOT_STATE_CHANGED, HbDeviceRootStateEventHandler);
1405 LNN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, LNN_INIT, "regist sle state change evt handler fail");
1406 return SOFTBUS_OK;
1407 }
1408
LnnRegisterNetworkEvent(void)1409 static int32_t LnnRegisterNetworkEvent(void)
1410 {
1411 if (LnnRegisterEventHandler(LNN_EVENT_IP_ADDR_CHANGED, HbIpAddrChangeEventHandler) != SOFTBUS_OK) {
1412 LNN_LOGE(LNN_INIT, "regist ip addr change evt handler fail");
1413 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
1414 }
1415 if (LnnRegisterEventHandler(LNN_EVENT_BT_STATE_CHANGED, HbBtStateChangeEventHandler) != SOFTBUS_OK) {
1416 LNN_LOGE(LNN_INIT, "regist bt state change evt handler fail");
1417 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
1418 }
1419 if (LnnRegisterEventHandler(LNN_EVENT_LANE_VAP_CHANGE, HbLaneVapChangeEventHandler) != SOFTBUS_OK) {
1420 LNN_LOGE(LNN_INIT, "regist vap state change evt handler fail");
1421 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
1422 }
1423 return SOFTBUS_OK;
1424 }
1425
LnnRegisterHeartbeatEvent(void)1426 static int32_t LnnRegisterHeartbeatEvent(void)
1427 {
1428 if (LnnRegisterEventHandler(LNN_EVENT_NODE_MASTER_STATE_CHANGED, HbMasterNodeChangeEventHandler) != SOFTBUS_OK) {
1429 LNN_LOGE(LNN_INIT, "regist node state change evt handler fail");
1430 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
1431 }
1432 if (LnnRegisterEventHandler(LNN_EVENT_HOME_GROUP_CHANGED, HbHomeGroupStateChangeEventHandler) != SOFTBUS_OK) {
1433 LNN_LOGE(LNN_INIT, "regist homeGroup state change evt handler fail");
1434 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
1435 }
1436 if (LnnRegisterEventHandler(LNN_EVENT_ACCOUNT_CHANGED, HbAccountStateChangeEventHandler) != SOFTBUS_OK) {
1437 LNN_LOGE(LNN_INIT, "regist account change evt handler fail");
1438 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
1439 }
1440 if (LnnRegisterEventHandler(LNN_EVENT_DIF_ACCOUNT_DEV_CHANGED, HbDifferentAccountEventHandler) != SOFTBUS_OK) {
1441 LNN_LOGE(LNN_INIT, "regist different account evt handler fail");
1442 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
1443 }
1444 if (LnnRegisterEventHandler(LNN_EVENT_USER_STATE_CHANGED, HbUserBackgroundEventHandler) != SOFTBUS_OK) {
1445 LNN_LOGE(LNN_INIT, "regist user background evt handler fail");
1446 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
1447 }
1448 if (LnnRegisterEventHandler(LNN_EVENT_LP_EVENT_REPORT, HbLpEventHandler) != SOFTBUS_OK) {
1449 LNN_LOGE(LNN_INIT, "regist lp report evt handler fail");
1450 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
1451 }
1452 return SOFTBUS_OK;
1453 }
1454
HbRangeCallback(SoftBusRangeHandle handle,const RangeResult * result)1455 static void HbRangeCallback(SoftBusRangeHandle handle, const RangeResult *result)
1456 {
1457 if (handle.module != MODULE_BLE_HEARTBEAT || result == NULL) {
1458 LNN_LOGE(LNN_HEART_BEAT, "invalid handle=%{public}d", handle.module);
1459 return;
1460 }
1461 char *anonyNetworkId = NULL;
1462 Anonymize(result->networkId, &anonyNetworkId);
1463 LNN_LOGI(LNN_HEART_BEAT, "module=%{public}d, networkId=%{public}s",
1464 handle.module, AnonymizeWrapper(anonyNetworkId));
1465 AnonymizeFree(anonyNetworkId);
1466
1467 RangeResultInnerInfo info = {
1468 .medium = BLE_ADV_HB,
1469 .distance = result->distance,
1470 .length = result->length,
1471 .addition = result->addition,
1472 };
1473 if (strncpy_s(info.networkId, NETWORK_ID_BUF_LEN, result->networkId, NETWORK_ID_BUF_LEN) != EOK) {
1474 LNN_LOGW(LNN_STATE, "copy networkId fail");
1475 return;
1476 }
1477 if (g_bleRangeCallback.onRangeResult != NULL) {
1478 g_bleRangeCallback.onRangeResult(&info);
1479 }
1480 }
1481
LnnInitHeartbeat(void)1482 int32_t LnnInitHeartbeat(void)
1483 {
1484 if (LnnHbStrategyInit() != SOFTBUS_OK) {
1485 LNN_LOGE(LNN_INIT, "strategy module init fail");
1486 return SOFTBUS_NETWORK_HB_INIT_STRATEGY_FAIL;
1487 }
1488 if (LnnRegisterCommonEvent() != SOFTBUS_OK) {
1489 LNN_LOGE(LNN_INIT, "regist common event handler fail");
1490 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
1491 }
1492 if (LnnRegisterNetworkEvent() != SOFTBUS_OK) {
1493 LNN_LOGE(LNN_INIT, "regist network event handler fail");
1494 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
1495 }
1496 if (LnnRegisterHeartbeatEvent() != SOFTBUS_OK) {
1497 LNN_LOGE(LNN_INIT, "regist heartbeat event handler fail");
1498 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
1499 }
1500 static SoftBusRangeCallback cb = {
1501 .onRangeResult = HbRangeCallback,
1502 };
1503 (void)SoftBusRegRangeCbPacked(MODULE_BLE_HEARTBEAT, &cb);
1504 InitHbConditionState();
1505 InitHbSpecificConditionState();
1506 LNN_LOGI(LNN_INIT, "heartbeat(HB) init success");
1507 return SOFTBUS_OK;
1508 }
1509
LnnDeinitHeartbeat(void)1510 void LnnDeinitHeartbeat(void)
1511 {
1512 LnnHbStrategyDeinit();
1513 LnnHbMediumMgrDeinit();
1514 SoftBusUnregRangeCbPacked(MODULE_BLE_HEARTBEAT);
1515 LnnUnregisterEventHandler(LNN_EVENT_IP_ADDR_CHANGED, HbIpAddrChangeEventHandler);
1516 LnnUnregisterEventHandler(LNN_EVENT_BT_STATE_CHANGED, HbBtStateChangeEventHandler);
1517 LnnUnregisterEventHandler(LNN_EVENT_LANE_VAP_CHANGE, HbLaneVapChangeEventHandler);
1518 LnnUnregisterEventHandler(LNN_EVENT_NODE_MASTER_STATE_CHANGED, HbMasterNodeChangeEventHandler);
1519 LnnUnregisterEventHandler(LNN_EVENT_SCREEN_STATE_CHANGED, HbScreenStateChangeEventHandler);
1520 LnnUnregisterEventHandler(LNN_EVENT_HOME_GROUP_CHANGED, HbHomeGroupStateChangeEventHandler);
1521 LnnUnregisterEventHandler(LNN_EVENT_SCREEN_LOCK_CHANGED, HbScreenLockChangeEventHandler);
1522 LnnUnregisterEventHandler(LNN_EVENT_ACCOUNT_CHANGED, HbAccountStateChangeEventHandler);
1523 LnnUnregisterEventHandler(LNN_EVENT_DIF_ACCOUNT_DEV_CHANGED, HbDifferentAccountEventHandler);
1524 LnnUnregisterEventHandler(LNN_EVENT_USER_STATE_CHANGED, HbUserBackgroundEventHandler);
1525 LnnUnregisterEventHandler(LNN_EVENT_NIGHT_MODE_CHANGED, HbNightModeStateEventHandler);
1526 LnnUnregisterEventHandler(LNN_EVENT_OOBE_STATE_CHANGED, HbOOBEStateEventHandler);
1527 LnnUnregisterEventHandler(LNN_EVENT_LP_EVENT_REPORT, HbLpEventHandler);
1528 LnnUnregisterEventHandler(LNN_EVENT_USER_SWITCHED, HbUserSwitchedHandler);
1529 LnnUnregisterEventHandler(LNN_EVENT_SLE_STATE_CHANGED, HbSleStateEventHandler);
1530 LnnUnregisterEventHandler(LNN_EVENT_DEVICE_ROOT_STATE_CHANGED, HbDeviceRootStateEventHandler);
1531 }
1532
LnnTriggerDataLevelHeartbeat(void)1533 int32_t LnnTriggerDataLevelHeartbeat(void)
1534 {
1535 if (LnnIsNeedInterceptBroadcast(true)) {
1536 LNN_LOGI(LNN_HEART_BEAT, "local heartbeat disable");
1537 return SOFTBUS_FUNC_NOT_SUPPORT;
1538 }
1539 LNN_LOGD(LNN_HEART_BEAT, "LnnTriggerDataLevelHeartbeat");
1540 if (LnnStartHbByTypeAndStrategy(
1541 HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false) != SOFTBUS_OK) {
1542 LNN_LOGE(LNN_HEART_BEAT, "ctrl start single ble heartbeat fail");
1543 return SOFTBUS_NETWORK_HB_START_STRATEGY_FAIL;
1544 }
1545 DfxRecordTriggerTime(DB_TRIGGER, EVENT_STAGE_LNN_DATA_LEVEL);
1546 return SOFTBUS_OK;
1547 }
1548
LnnTriggerDirectHeartbeat(const char * networkId,uint64_t timeout)1549 int32_t LnnTriggerDirectHeartbeat(const char *networkId, uint64_t timeout)
1550 {
1551 LNN_LOGD(LNN_HEART_BEAT, "LnnTriggerDirectHeartbeat");
1552 if (networkId == NULL) {
1553 LNN_LOGE(LNN_HEART_BEAT, "networkId is null");
1554 return SOFTBUS_INVALID_PARAM;
1555 }
1556 int32_t ret = LnnStartHbByTypeAndStrategyDirectly(HEARTBEAT_TYPE_BLE_V0, STRATEGY_HB_SEND_DIRECT,
1557 false, networkId, timeout);
1558 if (ret != SOFTBUS_OK) {
1559 LNN_LOGE(LNN_HEART_BEAT, "ctrl start direct ble heartbeat fail");
1560 return ret;
1561 }
1562 return SOFTBUS_OK;
1563 }
1564
LnnTriggerCloudSyncHeartbeat(void)1565 int32_t LnnTriggerCloudSyncHeartbeat(void)
1566 {
1567 LNN_LOGD(LNN_HEART_BEAT, "LnnTriggerCloudSyncHeartbeat");
1568 if (LnnStartHbByTypeAndStrategy(
1569 HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false) != SOFTBUS_OK) {
1570 LNN_LOGE(LNN_HEART_BEAT, "ctrl start single ble heartbeat fail");
1571 return SOFTBUS_NETWORK_HB_START_STRATEGY_FAIL;
1572 }
1573 DfxRecordBleTriggerTimestamp(TRIGGER_CLOUD_SYNC_HEARTBEAT);
1574 return SOFTBUS_OK;
1575 }
1576
LnnRegDataLevelChangeCb(const IDataLevelChangeCallback * callback)1577 void LnnRegDataLevelChangeCb(const IDataLevelChangeCallback *callback)
1578 {
1579 LnnBleHbRegDataLevelChangeCbPacked(callback);
1580 }
1581
LnnUnregDataLevelChangeCb(void)1582 void LnnUnregDataLevelChangeCb(void)
1583 {
1584 LnnBleHbUnregDataLevelChangeCbPacked();
1585 }
1586
LnnRegBleRangeCb(const IBleRangeInnerCallback * callback)1587 void LnnRegBleRangeCb(const IBleRangeInnerCallback *callback)
1588 {
1589 if (callback == NULL) {
1590 LNN_LOGE(LNN_HEART_BEAT, "invalid param");
1591 return;
1592 }
1593 LNN_LOGI(LNN_HEART_BEAT, "regist ble range cb");
1594 g_bleRangeCallback.onRangeResult = callback->onRangeResult;
1595 }
1596
LnnUnregBleRangeCb(void)1597 void LnnUnregBleRangeCb(void)
1598 {
1599 g_bleRangeCallback.onRangeResult = NULL;
1600 }
1601
LnnTriggerSleHeartbeat(void)1602 int32_t LnnTriggerSleHeartbeat(void)
1603 {
1604 if (!IsHeartbeatEnable()) {
1605 LNN_LOGD(LNN_HEART_BEAT, "sle no need handle");
1606 return SOFTBUS_OK;
1607 }
1608 if (g_hbConditionState.isSleEnable) {
1609 LNN_LOGD(LNN_HEART_BEAT, "sle has started");
1610 return SOFTBUS_OK;
1611 }
1612 if (LnnEnableHeartbeatByType(HEARTBEAT_TYPE_SLE, true) != SOFTBUS_OK) {
1613 LNN_LOGE(LNN_HEART_BEAT, "ctrl enable sle heartbeat fail");
1614 return SOFTBUS_NETWORK_HB_START_STRATEGY_FAIL;
1615 }
1616 if (LnnStartHbByTypeAndStrategy(HEARTBEAT_TYPE_SLE, STRATEGY_HB_SEND_FIXED_PERIOD, false) != SOFTBUS_OK) {
1617 LNN_LOGE(LNN_HEART_BEAT, "start sle spark hb fail");
1618 return SOFTBUS_NETWORK_HB_START_STRATEGY_FAIL;
1619 }
1620 g_hbConditionState.isSleEnable = true;
1621 LNN_LOGI(LNN_HEART_BEAT, "start sle spark hb success");
1622 return SOFTBUS_OK;
1623 }
1624
LnnStopSleHeartbeat(void)1625 int32_t LnnStopSleHeartbeat(void)
1626 {
1627 if (!g_hbConditionState.isSleEnable) {
1628 LNN_LOGD(LNN_HEART_BEAT, "sle has stoped");
1629 return SOFTBUS_OK;
1630 }
1631 if (LnnEnableHeartbeatByType(HEARTBEAT_TYPE_SLE, false) != SOFTBUS_OK) {
1632 LNN_LOGE(LNN_HEART_BEAT, "ctrl disable sle heartbeat fail");
1633 return SOFTBUS_NETWORK_HB_STOP_STRATEGY_FAIL;
1634 }
1635 if (LnnStopHeartbeatByType(HEARTBEAT_TYPE_SLE) != SOFTBUS_OK) {
1636 LNN_LOGE(LNN_HEART_BEAT, "stop sle spark hb fail");
1637 return SOFTBUS_NETWORK_HB_STOP_STRATEGY_FAIL;
1638 }
1639 g_hbConditionState.isSleEnable = false;
1640 LNN_LOGI(LNN_HEART_BEAT, "stop sle spark hb success");
1641 return SOFTBUS_OK;
1642 }
1643
LnnOfflineTimingBySleHb(const char * networkId,ConnectionAddrType addrType)1644 int32_t LnnOfflineTimingBySleHb(const char *networkId, ConnectionAddrType addrType)
1645 {
1646 LNN_CHECK_AND_RETURN_RET_LOGE(networkId != NULL, SOFTBUS_INVALID_PARAM, LNN_HEART_BEAT, "invalid param");
1647 LNN_CHECK_AND_RETURN_RET_LOGE(addrType == CONNECTION_ADDR_BLE, SOFTBUS_INVALID_PARAM, LNN_HEART_BEAT,
1648 "only support ble");
1649 SoftBusSysTime time = { 0 };
1650 (void)SoftBusGetTime(&time);
1651 uint64_t nowTime = (uint64_t)time.sec * HB_TIME_FACTOR + (uint64_t)time.usec / HB_TIME_FACTOR;
1652 if (LnnSetDLSleHbTimestamp(networkId, nowTime) != SOFTBUS_OK) {
1653 LNN_LOGE(LNN_HEART_BEAT, "HB set sle time stamp fail");
1654 return SOFTBUS_NETWORK_HB_STOP_STRATEGY_FAIL;
1655 }
1656 (void)LnnStopSleOfflineTimingStrategy(networkId);
1657 if (LnnStartSleOfflineTimingStrategy(networkId) != SOFTBUS_OK) {
1658 LNN_LOGE(LNN_HEART_BEAT, "ctrl start offline timing strategy fail");
1659 return SOFTBUS_NETWORK_HB_START_STRATEGY_FAIL;
1660 }
1661 char *anonyNetworkId = NULL;
1662 Anonymize(networkId, &anonyNetworkId);
1663 LNN_LOGI(LNN_HEART_BEAT, "HB start sle offline strategy, netwrokId=%{publc}s, timestamp=%{public}" PRIu64 "",
1664 AnonymizeWrapper(anonyNetworkId), nowTime);
1665 AnonymizeFree(anonyNetworkId);
1666 return SOFTBUS_OK;
1667 }
1668
LnnStopOfflineTimingBySleHb(const char * networkId,ConnectionAddrType addrType)1669 void LnnStopOfflineTimingBySleHb(const char *networkId, ConnectionAddrType addrType)
1670 {
1671 LNN_CHECK_AND_RETURN_LOGE(networkId != NULL, LNN_HEART_BEAT, "invalid param");
1672 LNN_CHECK_AND_RETURN_LOGE(addrType == CONNECTION_ADDR_BLE, LNN_HEART_BEAT, "only support ble");
1673 char *anonyNetworkId = NULL;
1674 Anonymize(networkId, &anonyNetworkId);
1675 LNN_LOGI(LNN_HEART_BEAT, "HB stop sle offline strategy, netwrokId=%{publc}s",
1676 AnonymizeWrapper(anonyNetworkId));
1677 AnonymizeFree(anonyNetworkId);
1678 LnnStopSleOfflineTimingStrategy(networkId);
1679 }