1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "lnn_heartbeat_fsm.h"
17 
18 #include <securec.h>
19 #include <string.h>
20 
21 #include "anonymizer.h"
22 #include "bus_center_manager.h"
23 #include "lnn_connection_addr_utils.h"
24 #include "lnn_deviceinfo_to_profile.h"
25 #include "lnn_distributed_net_ledger.h"
26 #include "lnn_feature_capability.h"
27 #include "lnn_heartbeat_ctrl.h"
28 #include "lnn_heartbeat_strategy.h"
29 #include "lnn_heartbeat_utils.h"
30 #include "lnn_log.h"
31 #include "lnn_net_builder.h"
32 #include "lnn_node_info.h"
33 #include "message_handler.h"
34 
35 #include "softbus_adapter_mem.h"
36 #include "softbus_adapter_timer.h"
37 #include "softbus_def.h"
38 #include "softbus_errcode.h"
39 #include "softbus_hisysevt_bus_center.h"
40 #include "softbus_utils.h"
41 
42 #define TO_HEARTBEAT_FSM(ptr) CONTAINER_OF(ptr, LnnHeartbeatFsm, fsm)
43 
44 typedef int32_t (*LnnHeartbeatEventHandler)(FsmStateMachine *, int32_t, void *);
45 
46 typedef struct {
47     int32_t eventType;
48     LnnHeartbeatEventHandler eventHandler;
49 } LnnHeartbeatStateHandler;
50 
51 typedef struct {
52     int32_t eventNum;
53     LnnHeartbeatStateHandler *stateHandler;
54 } LnnHeartbeatFsmHandler;
55 
56 static int32_t OnCheckDevStatus(FsmStateMachine *fsm, int32_t msgType, void *para);
57 static int32_t OnTransHbFsmState(FsmStateMachine *fsm, int32_t msgType, void *para);
58 static int32_t OnStartHbProcess(FsmStateMachine *fsm, int32_t msgType, void *para);
59 static int32_t OnStopHbByType(FsmStateMachine *fsm, int32_t msgType, void *para);
60 static int32_t OnSendOneHbBegin(FsmStateMachine *fsm, int32_t msgType, void *para);
61 static int32_t OnSendOneHbEnd(FsmStateMachine *fsm, int32_t msgType, void *para);
62 static int32_t OnProcessSendOnce(FsmStateMachine *fsm, int32_t msgType, void *para);
63 static int32_t OnSetMediumParam(FsmStateMachine *fsm, int32_t msgType, void *para);
64 static int32_t OnUpdateSendInfo(FsmStateMachine *fsm, int32_t msgType, void *para);
65 static int32_t OnScreeOffCheckDevStatus(FsmStateMachine *fsm, int32_t msgType, void *para);
66 static int32_t OnReStartHbProcess(FsmStateMachine *fsm, int32_t msgType, void *para);
67 
68 static LnnHeartbeatStateHandler g_hbNoneStateHandler[] = {
69     {EVENT_HB_CHECK_DEV_STATUS, OnCheckDevStatus},
70     {EVENT_HB_START_PROCESS, OnStartHbProcess},
71     {EVENT_HB_STOP_SPECIFIC, OnStopHbByType},
72     {EVENT_HB_AS_MASTER_NODE, OnTransHbFsmState},
73     {EVENT_HB_AS_NORMAL_NODE, OnTransHbFsmState},
74     {EVENT_HB_IN_NONE_STATE, OnTransHbFsmState},
75     {EVENT_HB_SCREEN_OFF_CHECK_STATUS, OnScreeOffCheckDevStatus},
76 };
77 
78 static LnnHeartbeatStateHandler g_normalNodeHandler[] = {
79     {EVENT_HB_SEND_ONE_BEGIN, OnSendOneHbBegin},
80     {EVENT_HB_SEND_ONE_END, OnSendOneHbEnd},
81     {EVENT_HB_CHECK_DEV_STATUS, OnCheckDevStatus},
82     {EVENT_HB_PROCESS_SEND_ONCE, OnProcessSendOnce},
83     {EVENT_HB_AS_MASTER_NODE, OnTransHbFsmState},
84     {EVENT_HB_AS_NORMAL_NODE, OnTransHbFsmState},
85     {EVENT_HB_IN_NONE_STATE, OnTransHbFsmState},
86     {EVENT_HB_SET_MEDIUM_PARAM, OnSetMediumParam},
87     {EVENT_HB_UPDATE_SEND_INFO, OnUpdateSendInfo},
88     {EVENT_HB_STOP_SPECIFIC, OnStopHbByType},
89     {EVENT_HB_SCREEN_OFF_CHECK_STATUS, OnScreeOffCheckDevStatus},
90     {EVENT_HB_START_PROCESS, OnReStartHbProcess},
91 };
92 
93 static LnnHeartbeatStateHandler g_masterNodeHandler[] = {
94     {EVENT_HB_SEND_ONE_BEGIN, OnSendOneHbBegin},
95     {EVENT_HB_SEND_ONE_END, OnSendOneHbEnd},
96     {EVENT_HB_CHECK_DEV_STATUS, OnCheckDevStatus},
97     {EVENT_HB_PROCESS_SEND_ONCE, OnProcessSendOnce},
98     {EVENT_HB_AS_MASTER_NODE, OnTransHbFsmState},
99     {EVENT_HB_AS_NORMAL_NODE, OnTransHbFsmState},
100     {EVENT_HB_IN_NONE_STATE, OnTransHbFsmState},
101     {EVENT_HB_SET_MEDIUM_PARAM, OnSetMediumParam},
102     {EVENT_HB_UPDATE_SEND_INFO, OnUpdateSendInfo},
103     {EVENT_HB_STOP_SPECIFIC, OnStopHbByType},
104     {EVENT_HB_SCREEN_OFF_CHECK_STATUS, OnScreeOffCheckDevStatus},
105     {EVENT_HB_START_PROCESS, OnReStartHbProcess},
106 };
107 
108 static LnnHeartbeatFsmHandler g_hbFsmHandler[] = {
109     [STATE_HB_NONE_INDEX] = {
110         .eventNum = sizeof(g_hbNoneStateHandler) / sizeof(LnnHeartbeatStateHandler),
111         .stateHandler = g_hbNoneStateHandler,
112     },
113     [STATE_HB_NORMAL_NODE_INDEX] = {
114         .eventNum = sizeof(g_normalNodeHandler) / sizeof(LnnHeartbeatStateHandler),
115         .stateHandler = g_normalNodeHandler,
116     },
117     [STATE_HB_MASTER_NODE_INDEX] = {
118         .eventNum = sizeof(g_masterNodeHandler) / sizeof(LnnHeartbeatStateHandler),
119         .stateHandler = g_masterNodeHandler,
120     }
121 };
122 
123 static void HbNoneStateEnter(FsmStateMachine *fsm);
124 static void HbNoneStateExit(FsmStateMachine *fsm);
125 static void HbNormalNodeStateEnter(FsmStateMachine *fsm);
126 static void HbMasterNodeStateEnter(FsmStateMachine *fsm);
127 static void HbMasterNodeStateExit(FsmStateMachine *fsm);
128 static bool HbFsmStateProcessFunc(FsmStateMachine *fsm, int32_t msgType, void *para);
129 
130 static FsmState g_hbState[STATE_HB_INDEX_MAX] = {
131     [STATE_HB_NONE_INDEX] = {
132         .enter = HbNoneStateEnter,
133         .process = HbFsmStateProcessFunc,
134         .exit = HbNoneStateExit,
135     },
136     [STATE_HB_NORMAL_NODE_INDEX] = {
137         .enter = HbNormalNodeStateEnter,
138         .process = HbFsmStateProcessFunc,
139         .exit = NULL,
140     },
141     [STATE_HB_MASTER_NODE_INDEX] = {
142         .enter = HbMasterNodeStateEnter,
143         .process = HbFsmStateProcessFunc,
144         .exit = HbMasterNodeStateExit,
145     },
146 };
147 
CheckHbFsmStateMsgArgs(const FsmStateMachine * fsm)148 static bool CheckHbFsmStateMsgArgs(const FsmStateMachine *fsm)
149 {
150     if (fsm == NULL) {
151         LNN_LOGW(LNN_HEART_BEAT, "fsm is null");
152         return false;
153     }
154     LnnHeartbeatFsm * hbFsm = TO_HEARTBEAT_FSM(fsm);
155     if (hbFsm == NULL) {
156         LNN_LOGE(LNN_HEART_BEAT, "hbFsm is null");
157         return false;
158     }
159     if (hbFsm->state < STATE_HB_INDEX_MIN || hbFsm->state >= STATE_HB_INDEX_MAX) {
160         LNN_LOGE(LNN_HEART_BEAT, "fsmId is in invalid. fsmId=%{public}d, state=%{public}d", hbFsm->id, hbFsm->state);
161         return false;
162     }
163     return true;
164 }
165 
FreeUnhandledHbMessage(int32_t msgType,void * para)166 static void FreeUnhandledHbMessage(int32_t msgType, void *para)
167 {
168     LNN_LOGI(LNN_HEART_BEAT, "free unhandled msgType=%{public}d", msgType);
169     if (msgType == EVENT_HB_UPDATE_SEND_INFO) {
170         /* this event use pointer to transfer parameters */
171         return;
172     }
173     if (para != NULL) {
174         SoftBusFree(para);
175     }
176 }
177 
HbFsmStateProcessFunc(FsmStateMachine * fsm,int32_t msgType,void * para)178 static bool HbFsmStateProcessFunc(FsmStateMachine *fsm, int32_t msgType, void *para)
179 {
180     int32_t i, eventNum, ret;
181     LnnHeartbeatStateHandler *stateHandler = NULL;
182 
183     if (!CheckHbFsmStateMsgArgs(fsm) || msgType <= EVENT_HB_MIN || msgType >= EVENT_HB_MAX) {
184         FreeUnhandledHbMessage(msgType, para);
185         return false;
186     }
187     LnnHeartbeatFsm * hbFsm = TO_HEARTBEAT_FSM(fsm);
188     eventNum = g_hbFsmHandler[hbFsm->state].eventNum;
189     stateHandler = g_hbFsmHandler[hbFsm->state].stateHandler;
190 
191     for (i = 0; i < eventNum; ++i) {
192         if (stateHandler[i].eventType != msgType) {
193             continue;
194         }
195         /* in this case, free the memory of para in eventHandler FUNC */
196         ret = (stateHandler[i].eventHandler)(fsm, msgType, para);
197         if (ret != SOFTBUS_OK) {
198             LNN_LOGE(LNN_HEART_BEAT, "FSM process hb fail, hbType=%{public}d, ret=%{public}d", msgType, ret);
199             return false;
200         }
201         LNN_LOGD(LNN_HEART_BEAT, "FSM process hb succ, hbType=%{public}d, state=%{public}d", msgType, hbFsm->state);
202         return true;
203     }
204     LNN_LOGD(LNN_HEART_BEAT, "no eventHandler in. hbType=%{public}d, state=%{public}d", msgType, hbFsm->state);
205     FreeUnhandledHbMessage(msgType, para);
206     return false;
207 }
208 
CheckRemoveHbMsgParams(const SoftBusMessage * msg,void * args)209 static bool CheckRemoveHbMsgParams(const SoftBusMessage *msg, void *args)
210 {
211     if (msg == NULL || args == NULL) {
212         return false;
213     }
214     FsmCtrlMsgObj *ctrlMsgObj = (FsmCtrlMsgObj *)msg->obj;
215     if (ctrlMsgObj == NULL || ctrlMsgObj->obj == NULL) {
216         return false;
217     }
218     SoftBusMessage *delMsg = (SoftBusMessage *)args;
219     if (delMsg == NULL || delMsg->obj == NULL) {
220         return false;
221     }
222     return true;
223 }
224 
RemoveCheckDevStatusMsg(FsmCtrlMsgObj * ctrlMsgObj,SoftBusMessage * delMsg)225 static int32_t RemoveCheckDevStatusMsg(FsmCtrlMsgObj *ctrlMsgObj, SoftBusMessage *delMsg)
226 {
227     LnnCheckDevStatusMsgPara *msgPara = (LnnCheckDevStatusMsgPara *)ctrlMsgObj->obj;
228     LnnCheckDevStatusMsgPara *delMsgPara = (LnnCheckDevStatusMsgPara *)delMsg->obj;
229 
230     if (delMsgPara->hasNetworkId != msgPara->hasNetworkId) {
231         return 1;
232     }
233     if (!delMsgPara->hasNetworkId && msgPara->hbType == delMsgPara->hbType) {
234         SoftBusFree(msgPara);
235         msgPara = NULL;
236         return 0;
237     }
238     if (delMsgPara->hasNetworkId && msgPara->hbType == delMsgPara->hbType &&
239         strcmp(msgPara->networkId, delMsgPara->networkId) == 0) {
240         SoftBusFree(msgPara);
241         msgPara = NULL;
242         return 0;
243     }
244     return 1;
245 }
246 
RemoveSendOnceMsg(FsmCtrlMsgObj * ctrlMsgObj,SoftBusMessage * delMsg)247 static int32_t RemoveSendOnceMsg(FsmCtrlMsgObj *ctrlMsgObj, SoftBusMessage *delMsg)
248 {
249     LnnProcessSendOnceMsgPara *msgPara = (LnnProcessSendOnceMsgPara *)ctrlMsgObj->obj;
250     LnnProcessSendOnceMsgPara *delMsgPara = (LnnProcessSendOnceMsgPara *)delMsg->obj;
251 
252     if (((msgPara->hbType & delMsgPara->hbType) == delMsgPara->hbType) &&
253         msgPara->strategyType == delMsgPara->strategyType) {
254         SoftBusFree(msgPara);
255         msgPara = NULL;
256         return 0;
257     }
258     return 1;
259 }
260 
RemoveSendOneEndMsg(FsmCtrlMsgObj * ctrlMsgObj,SoftBusMessage * delMsg)261 static int32_t RemoveSendOneEndMsg(FsmCtrlMsgObj *ctrlMsgObj, SoftBusMessage *delMsg)
262 {
263     LnnHeartbeatSendEndData *msgPara = (LnnHeartbeatSendEndData *)ctrlMsgObj->obj;
264     LnnRemoveSendEndMsgPara *delMsgPara = (LnnRemoveSendEndMsgPara *)delMsg->obj;
265 
266     if (!msgPara->wakeupFlag && delMsgPara->wakeupFlag) {
267         *delMsgPara->isRemoved = true;
268         SoftBusFree(msgPara);
269         msgPara = NULL;
270         return SOFTBUS_OK;
271     }
272     if (msgPara->wakeupFlag && !delMsgPara->wakeupFlag) {
273         *delMsgPara->isRemoved = false;
274         return SOFTBUS_ERR;
275     }
276     if (msgPara->isRelay && (msgPara->hbType & HEARTBEAT_TYPE_BLE_V0) != 0) {
277         *delMsgPara->isRemoved = true;
278         SoftBusFree(msgPara);
279         msgPara = NULL;
280         return SOFTBUS_OK;
281     }
282     if (delMsgPara->isRelay && (delMsgPara->hbType & HEARTBEAT_TYPE_BLE_V0) != 0) {
283         *delMsgPara->isRemoved = false;
284         return SOFTBUS_ERR;
285     }
286     if ((msgPara->hbType & HEARTBEAT_TYPE_BLE_V1) != 0 && (delMsgPara->hbType & HEARTBEAT_TYPE_BLE_V0) != 0) {
287         *delMsgPara->isRemoved = true;
288         SoftBusFree(msgPara);
289         msgPara = NULL;
290         return SOFTBUS_OK;
291     }
292     if ((msgPara->hbType & HEARTBEAT_TYPE_BLE_V0) != 0 && (delMsgPara->hbType & HEARTBEAT_TYPE_BLE_V1) != 0) {
293         *delMsgPara->isRemoved = false;
294         return SOFTBUS_ERR;
295     }
296     if (msgPara->hbType == delMsgPara->hbType && (delMsgPara->hbType & HEARTBEAT_TYPE_BLE_V0) != 0) {
297         *delMsgPara->isRemoved = true;
298         SoftBusFree(msgPara);
299         msgPara = NULL;
300         return SOFTBUS_OK;
301     }
302     if (msgPara->hbType == delMsgPara->hbType && (delMsgPara->hbType & HEARTBEAT_TYPE_BLE_V1) != 0) {
303         *delMsgPara->isRemoved = false;
304         return SOFTBUS_ERR;
305     }
306     *delMsgPara->isRemoved = false;
307     return SOFTBUS_ERR;
308 }
309 
RemoveScreenOffCheckStatus(FsmCtrlMsgObj * ctrlMsgObj,SoftBusMessage * delMsg)310 static int32_t RemoveScreenOffCheckStatus(FsmCtrlMsgObj *ctrlMsgObj, SoftBusMessage *delMsg)
311 {
312     LnnCheckDevStatusMsgPara *msgPara = (LnnCheckDevStatusMsgPara *)ctrlMsgObj->obj;
313     LnnCheckDevStatusMsgPara *delMsgPara = (LnnCheckDevStatusMsgPara *)delMsg->obj;
314 
315     if (delMsgPara->hasNetworkId != msgPara->hasNetworkId) {
316         return SOFTBUS_ERR;
317     }
318     if (!delMsgPara->hasNetworkId && msgPara->hbType == delMsgPara->hbType) {
319         SoftBusFree(msgPara);
320         msgPara = NULL;
321         return SOFTBUS_OK;
322     }
323     if (delMsgPara->hasNetworkId && msgPara->hbType == delMsgPara->hbType &&
324         strcmp(msgPara->networkId, delMsgPara->networkId) == 0) {
325         SoftBusFree(msgPara);
326         msgPara = NULL;
327         return SOFTBUS_OK;
328     }
329     return SOFTBUS_ERR;
330 }
331 
CustomFuncRemoveHbMsg(const SoftBusMessage * msg,void * args)332 static int32_t CustomFuncRemoveHbMsg(const SoftBusMessage *msg, void *args)
333 {
334     if (!CheckRemoveHbMsgParams(msg, args)) {
335         return 1;
336     }
337 
338     SoftBusMessage *delMsg = (SoftBusMessage *)args;
339     if (msg->what != delMsg->what || msg->arg1 != delMsg->arg1) {
340         return 1;
341     }
342     FsmCtrlMsgObj *ctrlMsgObj = (FsmCtrlMsgObj *)msg->obj;
343     switch (delMsg->arg1) {
344         case EVENT_HB_CHECK_DEV_STATUS:
345             return RemoveCheckDevStatusMsg(ctrlMsgObj, delMsg);
346         case EVENT_HB_PROCESS_SEND_ONCE:
347             return RemoveSendOnceMsg(ctrlMsgObj, delMsg);
348         case EVENT_HB_SEND_ONE_END:
349             return RemoveSendOneEndMsg(ctrlMsgObj, delMsg);
350         case EVENT_HB_SCREEN_OFF_CHECK_STATUS:
351             return RemoveScreenOffCheckStatus(ctrlMsgObj, delMsg);
352         default:
353             break;
354     }
355     return 1;
356 }
357 
RemoveHbMsgByCustObj(LnnHeartbeatFsm * hbFsm,LnnHeartbeatEventType evtType,void * obj)358 static void RemoveHbMsgByCustObj(LnnHeartbeatFsm *hbFsm, LnnHeartbeatEventType evtType, void *obj)
359 {
360     int32_t ret;
361 
362     SoftBusMessage removeMsg = {
363         .what = FSM_CTRL_MSG_DATA,
364         .arg1 = evtType,
365         .obj = obj,
366     };
367     ret = LnnFsmRemoveMessageSpecific(&hbFsm->fsm, CustomFuncRemoveHbMsg, (void *)&removeMsg);
368     if (ret != SOFTBUS_OK) {
369         LNN_LOGE(LNN_HEART_BEAT, "remove offline fb fail. hbType=%{public}d, fsmId=%{public}d ", hbFsm->id, evtType);
370     }
371 }
372 
LnnRemoveSendEndMsg(LnnHeartbeatFsm * hbFsm,LnnHeartbeatType type,bool wakeupFlag,bool isRelay,bool * isRemoved)373 void LnnRemoveSendEndMsg(LnnHeartbeatFsm *hbFsm, LnnHeartbeatType type, bool wakeupFlag,
374     bool isRelay, bool *isRemoved)
375 {
376     if (hbFsm == NULL || isRemoved == NULL) {
377         LNN_LOGW(LNN_HEART_BEAT, "remove send end msg get invalid param");
378         return;
379     }
380 
381     *isRemoved = true;
382     LnnRemoveSendEndMsgPara msgPara = {
383         .hbType = type & (~HEARTBEAT_TYPE_BLE_V3),
384         .wakeupFlag = wakeupFlag,
385         .isRelay = isRelay,
386         .isRemoved = isRemoved,
387     };
388     RemoveHbMsgByCustObj(hbFsm, EVENT_HB_SEND_ONE_END, (void *)&msgPara);
389     msgPara.isRemoved = NULL;
390 }
391 
LnnRemoveCheckDevStatusMsg(LnnHeartbeatFsm * hbFsm,LnnCheckDevStatusMsgPara * msgPara)392 void LnnRemoveCheckDevStatusMsg(LnnHeartbeatFsm *hbFsm, LnnCheckDevStatusMsgPara *msgPara)
393 {
394     if (hbFsm == NULL || msgPara == NULL) {
395         LNN_LOGW(LNN_HEART_BEAT, "remove check msg get invalid param");
396         return;
397     }
398     RemoveHbMsgByCustObj(hbFsm, EVENT_HB_CHECK_DEV_STATUS, (void *)msgPara);
399 }
400 
LnnRemoveScreenOffCheckStatusMsg(LnnHeartbeatFsm * hbFsm,LnnCheckDevStatusMsgPara * msgPara)401 void LnnRemoveScreenOffCheckStatusMsg(LnnHeartbeatFsm *hbFsm, LnnCheckDevStatusMsgPara *msgPara)
402 {
403     if (hbFsm == NULL || msgPara == NULL) {
404         LNN_LOGW(LNN_HEART_BEAT, "remove check msg get invalid param");
405         return;
406     }
407     RemoveHbMsgByCustObj(hbFsm, EVENT_HB_SCREEN_OFF_CHECK_STATUS, (void *)msgPara);
408 }
409 
LnnRemoveProcessSendOnceMsg(LnnHeartbeatFsm * hbFsm,LnnHeartbeatType hbType,LnnHeartbeatStrategyType strategyType)410 void LnnRemoveProcessSendOnceMsg(LnnHeartbeatFsm *hbFsm, LnnHeartbeatType hbType,
411     LnnHeartbeatStrategyType strategyType)
412 {
413     if (hbFsm == NULL) {
414         LNN_LOGW(LNN_HEART_BEAT, "remove process send once msg get invalid param");
415         return;
416     }
417     LnnProcessSendOnceMsgPara msgPara = {
418         .hbType = hbType,
419         .strategyType = strategyType,
420     };
421     RemoveHbMsgByCustObj(hbFsm, EVENT_HB_PROCESS_SEND_ONCE, (void *)&msgPara);
422 }
423 
HbMasterNodeStateEnter(FsmStateMachine * fsm)424 static void HbMasterNodeStateEnter(FsmStateMachine *fsm)
425 {
426     if (!CheckHbFsmStateMsgArgs(fsm)) {
427         LNN_LOGW(LNN_HEART_BEAT, "msg args check fail");
428         return;
429     }
430     LnnHeartbeatFsm *hbFsm = TO_HEARTBEAT_FSM(fsm);
431     hbFsm->state = STATE_HB_MASTER_NODE_INDEX;
432     LnnProcessSendOnceMsgPara *msgPara = (LnnProcessSendOnceMsgPara *)SoftBusMalloc(sizeof(LnnProcessSendOnceMsgPara));
433     if (msgPara == NULL) {
434         LNN_LOGE(LNN_HEART_BEAT, "enter master node malloc err. fsmId=%{public}d", hbFsm->id);
435         return;
436     }
437     msgPara->hbType = hbFsm->hbType;
438     msgPara->strategyType = hbFsm->strategyType;
439     msgPara->isRelay = false;
440     msgPara->isSyncData = false;
441     LnnRemoveProcessSendOnceMsg(hbFsm, hbFsm->hbType, hbFsm->strategyType);
442     if (LnnFsmPostMessage(fsm, EVENT_HB_PROCESS_SEND_ONCE, (void *)msgPara) != SOFTBUS_OK) {
443         SoftBusFree(msgPara);
444         return;
445     }
446     LNN_LOGI(LNN_HEART_BEAT, "perform as master node. fsmId=%{public}d", hbFsm->id);
447 }
448 
HbMasterNodeStateExit(FsmStateMachine * fsm)449 static void HbMasterNodeStateExit(FsmStateMachine *fsm)
450 {
451     if (!CheckHbFsmStateMsgArgs(fsm)) {
452         return;
453     }
454     LnnHeartbeatFsm *hbFsm = TO_HEARTBEAT_FSM(fsm);
455     LnnRemoveProcessSendOnceMsg(hbFsm, hbFsm->hbType, STRATEGY_HB_SEND_FIXED_PERIOD);
456 }
457 
HbNormalNodeStateEnter(FsmStateMachine * fsm)458 static void HbNormalNodeStateEnter(FsmStateMachine *fsm)
459 {
460     LnnDumpHbMgrRecvList();
461     LnnDumpHbOnlineNodeList();
462     if (!CheckHbFsmStateMsgArgs(fsm)) {
463         return;
464     }
465     LnnHeartbeatFsm *hbFsm = TO_HEARTBEAT_FSM(fsm);
466     hbFsm->state = STATE_HB_NORMAL_NODE_INDEX;
467     LnnRemoveProcessSendOnceMsg(hbFsm, hbFsm->hbType, STRATEGY_HB_SEND_FIXED_PERIOD);
468     LNN_LOGI(LNN_HEART_BEAT, "perform as normal node. fsmId=%{public}d", hbFsm->id);
469 }
470 
HbNoneStateEnter(FsmStateMachine * fsm)471 static void HbNoneStateEnter(FsmStateMachine *fsm)
472 {
473     if (!CheckHbFsmStateMsgArgs(fsm)) {
474         LNN_LOGW(LNN_HEART_BEAT, "msg args check fail");
475         return;
476     }
477     LnnHeartbeatFsm *hbFsm = TO_HEARTBEAT_FSM(fsm);
478     hbFsm->state = STATE_HB_NONE_INDEX;
479     LNN_LOGI(LNN_HEART_BEAT, "perform none state. fsmId=%{public}d", hbFsm->id);
480 
481     if (LnnHbMediumMgrStop(&hbFsm->hbType) != SOFTBUS_OK) {
482         LNN_LOGE(LNN_HEART_BEAT, "stop medium manager fail");
483         return;
484     }
485     LnnFsmRemoveMessage(fsm, EVENT_HB_PROCESS_SEND_ONCE);
486 }
487 
HbNoneStateExit(FsmStateMachine * fsm)488 static void HbNoneStateExit(FsmStateMachine *fsm)
489 {
490     if (!CheckHbFsmStateMsgArgs(fsm)) {
491         return;
492     }
493     LnnFsmPostMessage(fsm, EVENT_HB_UPDATE_SEND_INFO, (void *)(uintptr_t)UPDATE_HB_ACCOUNT_INFO);
494     LnnFsmPostMessage(fsm, EVENT_HB_UPDATE_SEND_INFO, (void *)(uintptr_t)UPDATE_HB_NETWORK_INFO);
495 }
496 
OnProcessSendOnce(FsmStateMachine * fsm,int32_t msgType,void * para)497 static int32_t OnProcessSendOnce(FsmStateMachine *fsm, int32_t msgType, void *para)
498 {
499     (void)msgType;
500     int32_t ret = SOFTBUS_ERR;
501     LnnHeartbeatFsm *hbFsm = NULL;
502     LnnHeartbeatStrategyManager strategyMgr = {0};
503 
504     LnnDumpHbMgrRecvList();
505     LnnDumpHbOnlineNodeList();
506     LnnProcessSendOnceMsgPara *msgPara = (LnnProcessSendOnceMsgPara *)para;
507     if (msgPara == NULL) {
508         LNN_LOGW(LNN_HEART_BEAT, "process send once get invalid para");
509         return SOFTBUS_INVALID_PARAM;
510     }
511     do {
512         if (!CheckHbFsmStateMsgArgs(fsm)) {
513             LNN_LOGW(LNN_HEART_BEAT, "process send once get invalid fsm");
514             break;
515         }
516         hbFsm = TO_HEARTBEAT_FSM(fsm);
517         if (LnnGetHbStrategyManager(&strategyMgr, msgPara->hbType, msgPara->strategyType) != SOFTBUS_OK) {
518             LNN_LOGE(LNN_HEART_BEAT, "process send once get strategy fail");
519             break;
520         }
521         if (strategyMgr.onProcess != NULL) {
522             ret = strategyMgr.onProcess(hbFsm, para);
523         } else {
524             LNN_LOGD(LNN_HEART_BEAT, "process send once get NULL process FUNC");
525             break;
526         }
527         if (ret != SOFTBUS_OK) {
528             LNN_LOGE(LNN_HEART_BEAT, "process send once fail, hbType=%{public}d, strategyType=%{public}d, "
529                 "ret=%{public}d", msgPara->hbType, msgPara->strategyType, ret);
530             break;
531         }
532         ret = SOFTBUS_OK;
533     } while (false);
534     SoftBusFree(msgPara);
535     return ret;
536 }
537 
ReportSendBroadcastResultEvt(void)538 static void ReportSendBroadcastResultEvt(void)
539 {
540     if (SoftBusRecordDiscoveryResult(SEND_BROADCAST, NULL) != SOFTBUS_OK) {
541         LNN_LOGE(LNN_HEART_BEAT, "report send broadcast result fail");
542     }
543 }
544 
OnSendOneHbBegin(FsmStateMachine * fsm,int32_t msgType,void * para)545 static int32_t OnSendOneHbBegin(FsmStateMachine *fsm, int32_t msgType, void *para)
546 {
547     (void)fsm;
548     (void)msgType;
549     int32_t ret = SOFTBUS_ERR;
550 
551     LnnHeartbeatSendBeginData *custData = (LnnHeartbeatSendBeginData *)para;
552     if (custData == NULL) {
553         LNN_LOGW(LNN_HEART_BEAT, "send once begin get invalid param");
554         return SOFTBUS_INVALID_PARAM;
555     }
556     do {
557         if (LnnHbMediumMgrSendBegin(custData) != SOFTBUS_OK) {
558             LNN_LOGE(LNN_HEART_BEAT, "send once begin to manager fail");
559             LnnCheckDevStatusMsgPara checkMsg = {.hbType = custData->hbType, .hasNetworkId = false};
560             LnnRemoveCheckDevStatusMsg(TO_HEARTBEAT_FSM(fsm), &checkMsg);
561             break;
562         }
563         ret = SOFTBUS_OK;
564         ReportSendBroadcastResultEvt();
565     } while (false);
566     SoftBusFree(custData);
567     return ret;
568 }
569 
OnSendOneHbEnd(FsmStateMachine * fsm,int32_t msgType,void * para)570 static int32_t OnSendOneHbEnd(FsmStateMachine *fsm, int32_t msgType, void *para)
571 {
572     (void)msgType;
573     int32_t ret = SOFTBUS_ERR;
574 
575     LnnHeartbeatSendEndData *custData = (LnnHeartbeatSendEndData *)para;
576     if (custData == NULL) {
577         LNN_LOGW(LNN_HEART_BEAT, "send once end get invalid para");
578         return SOFTBUS_INVALID_PARAM;
579     }
580     do {
581         if (!CheckHbFsmStateMsgArgs(fsm)) {
582             LNN_LOGW(LNN_HEART_BEAT, "send once end get invalid fsm");
583             break;
584         }
585         if (LnnHbMediumMgrSendEnd(custData) != SOFTBUS_OK) {
586             LNN_LOGE(LNN_HEART_BEAT, "send once end to manager fail");
587             (void)LnnFsmRemoveMessage(fsm, EVENT_HB_SEND_ONE_END);
588             (void)LnnFsmRemoveMessage(fsm, EVENT_HB_CHECK_DEV_STATUS);
589             break;
590         }
591         ret = SOFTBUS_OK;
592     } while (false);
593     SoftBusFree(custData);
594     return ret;
595 }
596 
OnStartHbProcess(FsmStateMachine * fsm,int32_t msgType,void * para)597 static int32_t OnStartHbProcess(FsmStateMachine *fsm, int32_t msgType, void *para)
598 {
599     (void)msgType;
600     (void)para;
601     if (!CheckHbFsmStateMsgArgs(fsm)) {
602         LNN_LOGW(LNN_HEART_BEAT, "start process get invalid fsm");
603         return SOFTBUS_INVALID_PARAM;
604     }
605     LnnHeartbeatFsm *hbFsm = TO_HEARTBEAT_FSM(fsm);
606     LnnFsmPostMessage(&hbFsm->fsm, EVENT_HB_AS_MASTER_NODE, NULL);
607     if (LnnIsHeartbeatEnable(HEARTBEAT_TYPE_BLE_V0)) {
608         /* Send once ble v0 heartbeat to recovery ble network. */
609         LnnStartHbByTypeAndStrategy(HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false);
610     }
611     return SOFTBUS_OK;
612 }
613 
OnReStartHbProcess(FsmStateMachine * fsm,int32_t msgType,void * para)614 static int32_t OnReStartHbProcess(FsmStateMachine *fsm, int32_t msgType, void *para)
615 {
616     (void)msgType;
617     (void)para;
618 
619     if (!CheckHbFsmStateMsgArgs(fsm)) {
620         LNN_LOGW(LNN_HEART_BEAT, "start process get invalid fsm");
621         return SOFTBUS_ERR;
622     }
623     if (LnnIsHeartbeatEnable(HEARTBEAT_TYPE_BLE_V0)) {
624         LnnStartHbByTypeAndStrategy(HEARTBEAT_TYPE_BLE_V0 | HEARTBEAT_TYPE_BLE_V3, STRATEGY_HB_SEND_SINGLE, false);
625     }
626     return SOFTBUS_OK;
627 }
628 
OnStopHbByType(FsmStateMachine * fsm,int32_t msgType,void * para)629 static int32_t OnStopHbByType(FsmStateMachine *fsm, int32_t msgType, void *para)
630 {
631     (void)msgType;
632     int32_t ret = SOFTBUS_ERR;
633 
634     LnnHeartbeatType *hbType = (LnnHeartbeatType *)para;
635     if (hbType == NULL) {
636         LNN_LOGW(LNN_HEART_BEAT, "stop specific get invalid para");
637         return SOFTBUS_INVALID_PARAM;
638     }
639     do {
640         if (!CheckHbFsmStateMsgArgs(fsm)) {
641             LNN_LOGW(LNN_HEART_BEAT, "stop specific get invalid fsm");
642             break;
643         }
644         if (LnnHbMediumMgrStop(hbType) != SOFTBUS_OK) {
645             LNN_LOGE(LNN_HEART_BEAT, "stop specific manager fail");
646             break;
647         }
648         LnnHeartbeatFsm *hbFsm = TO_HEARTBEAT_FSM(fsm);
649         if ((*hbType & HEARTBEAT_TYPE_BLE_V0) != 0) {
650             LnnFsmRemoveMessage(&hbFsm->fsm, EVENT_HB_CHECK_DEV_STATUS);
651             LnnRemoveProcessSendOnceMsg(hbFsm, HEARTBEAT_TYPE_BLE_V0, STRATEGY_HB_SEND_SINGLE);
652             LnnRemoveProcessSendOnceMsg(hbFsm, HEARTBEAT_TYPE_BLE_V0, STRATEGY_HB_SEND_ADJUSTABLE_PERIOD);
653             LnnFsmRemoveMessage(&hbFsm->fsm, EVENT_HB_SEND_ONE_END);
654         }
655         ret = SOFTBUS_OK;
656     } while (false);
657     SoftBusFree(hbType);
658     return ret;
659 }
660 
OnSetMediumParam(FsmStateMachine * fsm,int32_t msgType,void * para)661 static int32_t OnSetMediumParam(FsmStateMachine *fsm, int32_t msgType, void *para)
662 {
663     (void)fsm;
664     (void)msgType;
665     int32_t ret;
666 
667     if (para == NULL) {
668         LNN_LOGE(LNN_HEART_BEAT, "set medium param get invalid param");
669         return SOFTBUS_INVALID_PARAM;
670     }
671     ret = LnnHbMediumMgrSetParam(para);
672     if (ret != SOFTBUS_OK) {
673         LNN_LOGE(LNN_HEART_BEAT, "set medium param process fail, ret=%{public}d", ret);
674     }
675     SoftBusFree(para);
676     return ret;
677 }
678 
OnUpdateSendInfo(FsmStateMachine * fsm,int32_t msgType,void * para)679 static int32_t OnUpdateSendInfo(FsmStateMachine *fsm, int32_t msgType, void *para)
680 {
681     (void)fsm;
682     (void)msgType;
683 
684     return LnnHbMediumMgrUpdateSendInfo((LnnHeartbeatUpdateInfoType)(uintptr_t)para);
685 }
686 
TryAsMasterNodeNextLoop(FsmStateMachine * fsm)687 static void TryAsMasterNodeNextLoop(FsmStateMachine *fsm)
688 {
689     uint64_t delayMillis;
690     GearMode mode;
691     (void)memset_s(&mode, sizeof(GearMode), 0, sizeof(GearMode));
692     if (LnnGetGearModeBySpecificType(&mode, NULL, HEARTBEAT_TYPE_BLE_V1) != SOFTBUS_OK) {
693         LNN_LOGE(LNN_HEART_BEAT, "try as master node get gearmode fail");
694         return;
695     }
696     delayMillis = (uint64_t)mode.cycle * HB_TIME_FACTOR + HB_NOTIFY_MASTER_NODE_DELAY_LEN;
697     if (LnnFsmPostMessageDelay(fsm, EVENT_HB_AS_MASTER_NODE, NULL, delayMillis) != SOFTBUS_OK) {
698         LNN_LOGE(LNN_HEART_BEAT, "try as master node post msg fail");
699         return;
700     }
701     LNN_LOGI(LNN_HEART_BEAT, "try as master node in delay time. delayMillis=%{public}" PRIu64 " msec", delayMillis);
702 }
703 
OnTransHbFsmState(FsmStateMachine * fsm,int32_t msgType,void * para)704 static int32_t OnTransHbFsmState(FsmStateMachine *fsm, int32_t msgType, void *para)
705 {
706     (void)para;
707     LnnHeartbeatState nextState;
708     LnnHeartbeatFsm *hbFsm = NULL;
709 
710     if (!CheckHbFsmStateMsgArgs(fsm)) {
711         LNN_LOGW(LNN_HEART_BEAT, "args check fail");
712         return SOFTBUS_INVALID_PARAM;
713     }
714     switch (msgType) {
715         case EVENT_HB_AS_MASTER_NODE:
716             nextState = STATE_HB_MASTER_NODE_INDEX;
717             LnnFsmRemoveMessage(fsm, EVENT_HB_AS_NORMAL_NODE);
718             break;
719         case EVENT_HB_AS_NORMAL_NODE:
720             nextState = STATE_HB_NORMAL_NODE_INDEX;
721             LnnFsmRemoveMessage(fsm, EVENT_HB_AS_MASTER_NODE);
722             TryAsMasterNodeNextLoop(fsm);
723             break;
724         case EVENT_HB_IN_NONE_STATE:
725             nextState = STATE_HB_NONE_INDEX;
726             break;
727         default:
728             LNN_LOGE(LNN_HEART_BEAT, "process transact state get invalid msgType");
729             return SOFTBUS_INVALID_PARAM;
730     }
731     hbFsm = TO_HEARTBEAT_FSM(fsm);
732     if (hbFsm->state == nextState) {
733         return SOFTBUS_OK;
734     }
735     if (LnnFsmTransactState(fsm, g_hbState + nextState) != SOFTBUS_OK) {
736         LNN_LOGE(LNN_HEART_BEAT, "process transact fsm state fail");
737         return SOFTBUS_ERR;
738     }
739     return SOFTBUS_OK;
740 }
741 
ProcOfflineWithoutSoftbus(const char * networkId,ConnectionAddrType addrType)742 static bool ProcOfflineWithoutSoftbus(const char *networkId, ConnectionAddrType addrType)
743 {
744     NodeInfo node;
745     (void)memset_s(&node, sizeof(NodeInfo), 0, sizeof(NodeInfo));
746     if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &node) != SOFTBUS_OK) {
747         LNN_LOGW(LNN_HEART_BEAT, "can not find node");
748         return false;
749     }
750     LNN_LOGD(LNN_HEART_BEAT, "node deviceTypeId=%{public}d", node.deviceInfo.deviceTypeId);
751     if (node.deviceInfo.deviceTypeId == TYPE_PC_ID &&
752         strcmp(node.networkId, node.deviceInfo.deviceUdid) == 0) {
753         LNN_LOGI(LNN_HEART_BEAT, "remove node because lost heartbeat");
754         DeleteFromProfile(node.deviceInfo.deviceUdid);
755         LnnRemoveNode(node.deviceInfo.deviceUdid);
756         return true;
757     }
758     return false;
759 }
760 
ProcessLostHeartbeat(const char * networkId,LnnHeartbeatType type,bool isWakeUp)761 static int32_t ProcessLostHeartbeat(const char *networkId, LnnHeartbeatType type, bool isWakeUp)
762 {
763     ConnectionAddrType addrType = LnnConvertHbTypeToConnAddrType(type);
764     char udidHash[HB_SHORT_UDID_HASH_HEX_LEN + 1] = {0};
765     char *anonyNetworkId = NULL;
766     if (networkId == NULL) {
767         LNN_LOGW(LNN_HEART_BEAT, "process dev lost networkId is null");
768         return SOFTBUS_INVALID_PARAM;
769     }
770     if (ProcOfflineWithoutSoftbus(networkId, addrType)) {
771         LNN_LOGI(LNN_HEART_BEAT, "proc offline, that device online without softbus");
772         return SOFTBUS_OK;
773     }
774     if (!LnnGetOnlineStateById(networkId, CATEGORY_NETWORK_ID)) {
775         Anonymize(networkId, &anonyNetworkId);
776         LNN_LOGI(LNN_HEART_BEAT, "process dev lost is offline, networkId=%{public}s", anonyNetworkId);
777         AnonymizeFree(anonyNetworkId);
778         return SOFTBUS_OK;
779     }
780     if (LnnHasActiveConnection(networkId, addrType)) {
781         Anonymize(networkId, &anonyNetworkId);
782         LNN_LOGD(LNN_HEART_BEAT, "process dev lost in next period, networkId=%{public}s", anonyNetworkId);
783         AnonymizeFree(anonyNetworkId);
784         if (LnnOfflineTimingByHeartbeat(networkId, addrType) != SOFTBUS_OK) {
785             LNN_LOGE(LNN_HEART_BEAT, "process dev lost start new offline timing err");
786             return SOFTBUS_ERR;
787         }
788         return SOFTBUS_OK;
789     }
790     if (LnnIsSupportBurstFeature(networkId) && !(isWakeUp || type == HEARTBEAT_TYPE_BLE_V0)) {
791         LNN_LOGI(LNN_HEART_BEAT, "is support burst and is not wakeup or V0, don't check");
792         return SOFTBUS_OK;
793     }
794     const char *udid = LnnConvertDLidToUdid(networkId, CATEGORY_NETWORK_ID);
795     (void)LnnGenerateHexStringHash((const unsigned char *)udid, udidHash, HB_SHORT_UDID_HASH_HEX_LEN);
796     char *anonyUdidHash = NULL;
797     Anonymize(udidHash, &anonyUdidHash);
798     Anonymize(networkId, &anonyNetworkId);
799     LNN_LOGI(LNN_HEART_BEAT, "process dev lost, udidHash=%{public}s, networkId=%{public}s",
800         anonyUdidHash, anonyNetworkId);
801     AnonymizeFree(anonyNetworkId);
802     AnonymizeFree(anonyUdidHash);
803     if (LnnRequestLeaveSpecific(networkId, addrType) != SOFTBUS_OK) {
804         LNN_LOGE(LNN_HEART_BEAT, "process dev lost send request to NetBuilder fail");
805         return SOFTBUS_ERR;
806     }
807     return SOFTBUS_OK;
808 }
809 
IsTimestampExceedLimit(uint64_t nowTime,uint64_t oldTimeStamp,LnnHeartbeatType hbType)810 static bool IsTimestampExceedLimit(uint64_t nowTime, uint64_t oldTimeStamp, LnnHeartbeatType hbType)
811 {
812     GearMode mode;
813     (void)memset_s(&mode, sizeof(GearMode), 0, sizeof(GearMode));
814     uint64_t offlineToleranceLen;
815 
816     switch (hbType) {
817         case HEARTBEAT_TYPE_BLE_V0:
818             if ((nowTime - oldTimeStamp) <= HB_CHECK_OFFLINE_TOLERANCE_LEN) {
819                 return false;
820             }
821             break;
822         case HEARTBEAT_TYPE_BLE_V1:
823             if (LnnGetGearModeBySpecificType(&mode, NULL, HEARTBEAT_TYPE_BLE_V1) != SOFTBUS_OK) {
824                 LNN_LOGE(LNN_HEART_BEAT, "is timestamp exceed limit get Gearmode err");
825                 return false;
826             }
827             /* BLE_V1 have priority over BLE_V0 */
828             offlineToleranceLen = (uint64_t)mode.cycle * HB_TIME_FACTOR + HB_CHECK_DELAY_LEN + HB_SEND_ONCE_LEN;
829             if (nowTime - oldTimeStamp <= offlineToleranceLen) {
830                 return false;
831             }
832             break;
833         default:
834             break;
835     }
836     return true;
837 }
838 
CheckDevStatusByNetworkId(LnnHeartbeatFsm * hbFsm,const char * networkId,LnnCheckDevStatusMsgPara * msgPara)839 static void CheckDevStatusByNetworkId(LnnHeartbeatFsm *hbFsm, const char *networkId, LnnCheckDevStatusMsgPara *msgPara)
840 {
841     uint64_t oldTimeStamp;
842     DiscoveryType discType;
843     char *anonyNetworkId = NULL;
844     LnnHeartbeatType hbType = msgPara->hbType;
845     NodeInfo nodeInfo;
846     SoftBusSysTime times = {0};
847     (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
848     if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &nodeInfo) != SOFTBUS_OK) {
849         LNN_LOGE(LNN_HEART_BEAT, "check dev status get nodeInfo fail");
850         return;
851     }
852     discType = LnnConvAddrTypeToDiscType(LnnConvertHbTypeToConnAddrType(hbType));
853     if (!LnnHasDiscoveryType(&nodeInfo, discType)) {
854         Anonymize(networkId, &anonyNetworkId);
855         LNN_LOGE(LNN_HEART_BEAT, "check dev status doesn't have discType. networkId=%{public}s, discType=%{public}d",
856             anonyNetworkId, discType);
857         AnonymizeFree(anonyNetworkId);
858         return;
859     }
860     if (LnnGetDLHeartbeatTimestamp(networkId, &oldTimeStamp) != SOFTBUS_OK) {
861         Anonymize(networkId, &anonyNetworkId);
862         LNN_LOGE(LNN_HEART_BEAT, "check dev status get timestamp err, networkId=%{public}s", anonyNetworkId);
863         AnonymizeFree(anonyNetworkId);
864         return;
865     }
866     SoftBusGetTime(&times);
867     uint64_t nowTime = (uint64_t)times.sec * HB_TIME_FACTOR + (uint64_t)times.usec / HB_TIME_FACTOR;
868     if (!IsTimestampExceedLimit(nowTime, oldTimeStamp, hbType)) {
869         Anonymize(networkId, &anonyNetworkId);
870         LNN_LOGD(LNN_HEART_BEAT, "check dev status receive heartbeat in time, networkId=%{public}s, "
871             "nowTime=%{public}" PRIu64 ", oldTimeStamp=%{public}" PRIu64, anonyNetworkId, nowTime, oldTimeStamp);
872         AnonymizeFree(anonyNetworkId);
873         return;
874     }
875     Anonymize(networkId, &anonyNetworkId);
876     LNN_LOGI(LNN_HEART_BEAT, "notify node lost heartbeat, networkId=%{public}s, oldTimeStamp=%{public}" PRIu64 ", "
877                              "nowTime=%{public}" PRIu64, anonyNetworkId, oldTimeStamp, nowTime);
878     if (LnnStopOfflineTimingStrategy(networkId, LnnConvertHbTypeToConnAddrType(hbType)) != SOFTBUS_OK) {
879         LNN_LOGE(LNN_HEART_BEAT, "check dev status stop offline timing fail");
880         AnonymizeFree(anonyNetworkId);
881         return;
882     }
883     if (ProcessLostHeartbeat(networkId, hbType, msgPara->isWakeUp) != SOFTBUS_OK) {
884         LNN_LOGE(LNN_HEART_BEAT, "process dev lost err, networkId=%{public}s", anonyNetworkId);
885         AnonymizeFree(anonyNetworkId);
886         return;
887     }
888     AnonymizeFree(anonyNetworkId);
889 }
890 
CheckDevStatusForScreenOff(LnnHeartbeatFsm * hbFsm,const char * networkId,LnnHeartbeatType hbType,uint64_t nowTime)891 static void CheckDevStatusForScreenOff(LnnHeartbeatFsm *hbFsm, const char *networkId,
892     LnnHeartbeatType hbType, uint64_t nowTime)
893 {
894     (void)hbFsm;
895     uint64_t oldTimeStamp;
896     char *anonyNetworkId = NULL;
897     if (LnnHasActiveConnection(networkId, LnnConvertHbTypeToConnAddrType(hbType))) {
898         Anonymize(networkId, &anonyNetworkId);
899         LNN_LOGD(LNN_HEART_BEAT, "process screen off dev lost in next period, networkId=%{public}s", anonyNetworkId);
900         if (LnnStartScreenChangeOfflineTiming(networkId, LnnConvertHbTypeToConnAddrType(hbType)) != SOFTBUS_OK) {
901             LNN_LOGE(LNN_HEART_BEAT, "process screen off dev lost start new offline timing err");
902         }
903         AnonymizeFree(anonyNetworkId);
904         return;
905     }
906     if (LnnGetDLHeartbeatTimestamp(networkId, &oldTimeStamp) != SOFTBUS_OK) {
907         LNN_LOGE(LNN_HEART_BEAT, "hb check dev status get timestamp err");
908         return;
909     }
910     if ((nowTime - oldTimeStamp) <= (HB_OFFLINE_PERIOD * HB_OFFLINE_TIME)) {
911         LNN_LOGI(LNN_HEART_BEAT, "hb check dev status , receive heartbeat in 2 * period time");
912         if (GetScreenState() == SOFTBUS_SCREEN_OFF && LnnStartScreenChangeOfflineTiming(networkId,
913         LnnConvertHbTypeToConnAddrType(hbType)) != SOFTBUS_OK) {
914             LNN_LOGI(LNN_HEART_BEAT, "post next period screen off offline check msg");
915         }
916         return;
917     }
918     Anonymize(networkId, &anonyNetworkId);
919     LNN_LOGW(LNN_HEART_BEAT, "the screen has been closed for more than 2 cycles, will offline, networkId=%{public}s",
920         anonyNetworkId);
921     if (!LnnGetOnlineStateById(networkId, CATEGORY_NETWORK_ID)) {
922         LNN_LOGI(LNN_HEART_BEAT, "process dev lost is offline, networkId=%{public}s", anonyNetworkId);
923         AnonymizeFree(anonyNetworkId);
924         return;
925     }
926     AnonymizeFree(anonyNetworkId);
927     if (LnnIsLocalSupportBurstFeature()) {
928         LNN_LOGI(LNN_HEART_BEAT, "local device support lp, no need offline");
929         return;
930     }
931     if (LnnRequestLeaveSpecific(networkId, LnnConvertHbTypeToConnAddrType(hbType)) != SOFTBUS_OK) {
932         LNN_LOGE(LNN_HEART_BEAT, "process dev lost send request to NetBuilder fail");
933         return;
934     }
935 }
936 
OnCheckDevStatus(FsmStateMachine * fsm,int32_t msgType,void * para)937 static int32_t OnCheckDevStatus(FsmStateMachine *fsm, int32_t msgType, void *para)
938 {
939     (void)msgType;
940     int32_t ret = SOFTBUS_ERR;
941 
942     LnnCheckDevStatusMsgPara *msgPara = (LnnCheckDevStatusMsgPara *)para;
943     if (msgPara == NULL) {
944         LNN_LOGE(LNN_HEART_BEAT, "check dev status get invalid para");
945         return SOFTBUS_INVALID_PARAM;
946     }
947     do {
948         if (GetScreenState() == SOFTBUS_SCREEN_OFF) {
949             ret = SOFTBUS_OK;
950             LNN_LOGI(LNN_HEART_BEAT, "screen if off, dont need hb check");
951             break;
952         }
953         if (!CheckHbFsmStateMsgArgs(fsm)) {
954             LNN_LOGE(LNN_HEART_BEAT, "check dev status get invalid fsm");
955             break;
956         }
957         LnnHeartbeatFsm *hbFsm = TO_HEARTBEAT_FSM(fsm);
958         if (msgPara->hasNetworkId) {
959             CheckDevStatusByNetworkId(hbFsm, msgPara->networkId, msgPara);
960             ret = SOFTBUS_OK;
961             break;
962         }
963 
964         int32_t i, infoNum;
965         NodeBasicInfo *info = NULL;
966         if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
967             break;
968         }
969         if (info == NULL || infoNum == 0) {
970             LNN_LOGI(LNN_HEART_BEAT, "check dev status get none online node");
971             ret = SOFTBUS_OK;
972             break;
973         }
974         for (i = 0; i < infoNum; ++i) {
975             if (LnnIsLSANode(&info[i])) {
976                 continue;
977             }
978             CheckDevStatusByNetworkId(hbFsm, info[i].networkId, msgPara);
979         }
980         SoftBusFree(info);
981         ret = SOFTBUS_OK;
982     } while (false);
983     SoftBusFree(msgPara);
984     return ret;
985 }
986 
OnScreeOffCheckDevStatus(FsmStateMachine * fsm,int32_t msgType,void * para)987 static int32_t OnScreeOffCheckDevStatus(FsmStateMachine *fsm, int32_t msgType, void *para)
988 {
989     (void)msgType;
990     int32_t ret = SOFTBUS_OK;
991     uint64_t nowTime;
992     SoftBusSysTime times = {0};
993     LnnCheckDevStatusMsgPara *msgPara = (LnnCheckDevStatusMsgPara *)para;
994     if (msgPara == NULL) {
995         LNN_LOGE(LNN_HEART_BEAT, "check dev status get invalid para");
996         return SOFTBUS_INVALID_PARAM;
997     }
998     do {
999         SoftBusGetTime(&times);
1000         nowTime = (uint64_t)times.sec * HB_TIME_FACTOR + (uint64_t)times.usec / HB_TIME_FACTOR;
1001         if (!CheckHbFsmStateMsgArgs(fsm)) {
1002             LNN_LOGE(LNN_HEART_BEAT, "check dev status get invalid fsm");
1003             ret = SOFTBUS_ERR;
1004             break;
1005         }
1006         LnnHeartbeatFsm *hbFsm = TO_HEARTBEAT_FSM(fsm);
1007         if (msgPara->hasNetworkId) {
1008             CheckDevStatusForScreenOff(hbFsm, msgPara->networkId, msgPara->hbType, nowTime);
1009             break;
1010         }
1011         int32_t infoNum;
1012         NodeBasicInfo *info = NULL;
1013         if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
1014             LNN_LOGE(LNN_HEART_BEAT, "check dev status get online node info fail");
1015             ret = SOFTBUS_ERR;
1016             break;
1017         }
1018         if (info == NULL || infoNum == 0) {
1019             LNN_LOGI(LNN_HEART_BEAT, "check dev status get none online node");
1020             break;
1021         }
1022         for (int32_t i = 0; i < infoNum; ++i) {
1023             if (LnnIsLSANode(&info[i])) {
1024                 continue;
1025             }
1026             CheckDevStatusForScreenOff(hbFsm, info[i].networkId, msgPara->hbType, nowTime);
1027         }
1028         SoftBusFree(info);
1029     } while (false);
1030     SoftBusFree(msgPara);
1031     return ret;
1032 }
1033 
LnnDestroyHeartbeatFsm(LnnHeartbeatFsm * hbFsm)1034 void LnnDestroyHeartbeatFsm(LnnHeartbeatFsm *hbFsm)
1035 {
1036     if (hbFsm == NULL) {
1037         return;
1038     }
1039     // Destroy by LnnDeinitLnnLooper
1040     LNN_LOGI(LNN_HEART_BEAT, "destroy heartbeat fsmId=%{public}u", hbFsm->id);
1041     SoftBusFree(hbFsm);
1042 }
1043 
DeinitHbFsmCallback(FsmStateMachine * fsm)1044 static void DeinitHbFsmCallback(FsmStateMachine *fsm)
1045 {
1046     LnnHeartbeatFsm *hbFsm = NULL;
1047 
1048     LNN_LOGI(LNN_HEART_BEAT, "fsm deinit callback enter");
1049     if (!CheckHbFsmStateMsgArgs(fsm)) {
1050         return;
1051     }
1052     hbFsm = TO_HEARTBEAT_FSM(fsm);
1053     LnnDestroyHeartbeatFsm(hbFsm);
1054 }
1055 
InitHeartbeatFsm(LnnHeartbeatFsm * hbFsm)1056 static int32_t InitHeartbeatFsm(LnnHeartbeatFsm *hbFsm)
1057 {
1058     int32_t i;
1059 
1060     if (sprintf_s(hbFsm->fsmName, HB_FSM_NAME_LEN, "LnnHbFsm-%u", hbFsm->id) == -1) {
1061         LNN_LOGE(LNN_HEART_BEAT, "format fsm name fail");
1062         return SOFTBUS_ERR;
1063     }
1064     SoftBusLooper *looper = GetLooper(LOOP_TYPE_LNN);
1065     if (looper == NULL) {
1066         LNN_LOGE(LNN_HEART_BEAT, "create looper fail");
1067         return SOFTBUS_ERR;
1068     }
1069     if (LnnFsmInit(&hbFsm->fsm, looper, hbFsm->fsmName, DeinitHbFsmCallback) != SOFTBUS_OK) {
1070         LNN_LOGE(LNN_HEART_BEAT, "init lnn fsm fail");
1071         return SOFTBUS_ERR;
1072     }
1073     for (i = 0; i < STATE_HB_INDEX_MAX; ++i) {
1074         LnnFsmAddState(&hbFsm->fsm, &g_hbState[i]);
1075     }
1076     return SOFTBUS_OK;
1077 }
1078 
LnnCreateHeartbeatFsm(void)1079 LnnHeartbeatFsm *LnnCreateHeartbeatFsm(void)
1080 {
1081     LnnHeartbeatFsm *hbFsm = NULL;
1082 
1083     hbFsm = (LnnHeartbeatFsm *)SoftBusCalloc(sizeof(LnnHeartbeatFsm));
1084     if (hbFsm == NULL) {
1085         LNN_LOGE(LNN_HEART_BEAT, "malloc fsm fail");
1086         return NULL;
1087     }
1088     ListInit(&hbFsm->node);
1089     if (InitHeartbeatFsm(hbFsm) != SOFTBUS_OK) {
1090         LNN_LOGE(LNN_HEART_BEAT, "init fsm fail");
1091         LnnDestroyHeartbeatFsm(hbFsm);
1092         return NULL;
1093     }
1094     hbFsm->state = STATE_HB_NONE_INDEX;
1095     return hbFsm;
1096 }
1097 
LnnStartHeartbeatFsm(LnnHeartbeatFsm * hbFsm)1098 int32_t LnnStartHeartbeatFsm(LnnHeartbeatFsm *hbFsm)
1099 {
1100     if (hbFsm == NULL) {
1101         LNN_LOGE(LNN_HEART_BEAT, "start fsm is null");
1102         return SOFTBUS_INVALID_PARAM;
1103     }
1104     if (LnnFsmStart(&hbFsm->fsm, g_hbState + STATE_HB_NONE_INDEX) != SOFTBUS_OK) {
1105         LNN_LOGE(LNN_HEART_BEAT, "start fsm failed. fsmId=%{public}u", hbFsm->id);
1106         return SOFTBUS_ERR;
1107     }
1108     LNN_LOGI(LNN_HEART_BEAT, "fsm is starting. fsmId=%{public}u", hbFsm->id);
1109     return SOFTBUS_OK;
1110 }
1111 
LnnStopHeartbeatFsm(LnnHeartbeatFsm * hbFsm)1112 int32_t LnnStopHeartbeatFsm(LnnHeartbeatFsm *hbFsm)
1113 {
1114     if (hbFsm == NULL) {
1115         LNN_LOGE(LNN_HEART_BEAT, "stop fsm is null");
1116         return SOFTBUS_INVALID_PARAM;
1117     }
1118     if (LnnFsmStop(&hbFsm->fsm) != SOFTBUS_OK) {
1119         LNN_LOGE(LNN_HEART_BEAT, "stop fsm failed. fsmId=%{public}u", hbFsm->id);
1120         return SOFTBUS_ERR;
1121     }
1122     return LnnFsmDeinit(&hbFsm->fsm);
1123 }
1124 
LnnPostNextSendOnceMsgToHbFsm(LnnHeartbeatFsm * hbFsm,const LnnProcessSendOnceMsgPara * para,uint64_t delayMillis)1125 int32_t LnnPostNextSendOnceMsgToHbFsm(LnnHeartbeatFsm *hbFsm, const LnnProcessSendOnceMsgPara *para,
1126     uint64_t delayMillis)
1127 {
1128     LnnProcessSendOnceMsgPara *dupPara = NULL;
1129 
1130     if (hbFsm == NULL || para == NULL) {
1131         LNN_LOGE(LNN_HEART_BEAT, "post next loop msg get invalid param");
1132         return SOFTBUS_INVALID_PARAM;
1133     }
1134     dupPara = (LnnProcessSendOnceMsgPara *)SoftBusMalloc(sizeof(LnnProcessSendOnceMsgPara));
1135     if (dupPara == NULL) {
1136         LNN_LOGE(LNN_HEART_BEAT, "post next loop msg malloc dupPara fail");
1137         return SOFTBUS_MALLOC_ERR;
1138     }
1139     *dupPara = *para;
1140     if (LnnFsmPostMessageDelay(&hbFsm->fsm, EVENT_HB_PROCESS_SEND_ONCE, (void *)dupPara, delayMillis) != SOFTBUS_OK) {
1141         LNN_LOGE(LNN_HEART_BEAT, "post next loop msg to hbFsm fail");
1142         SoftBusFree(dupPara);
1143         return SOFTBUS_ERR;
1144     }
1145     LnnNotifyHBRepeat();
1146     LNN_LOGD(LNN_HEART_BEAT, "post next loop msg, delayMillis=%{public}" PRIu64, delayMillis);
1147     return SOFTBUS_OK;
1148 }
1149 
LnnPostSendBeginMsgToHbFsm(LnnHeartbeatFsm * hbFsm,LnnHeartbeatType type,bool wakeupFlag,LnnProcessSendOnceMsgPara * msgPara,uint64_t delayMillis)1150 int32_t LnnPostSendBeginMsgToHbFsm(LnnHeartbeatFsm *hbFsm, LnnHeartbeatType type,
1151     bool wakeupFlag, LnnProcessSendOnceMsgPara *msgPara, uint64_t delayMillis)
1152 {
1153     LNN_LOGD(LNN_HEART_BEAT, "LnnPostSendBeginMsgToHbFsm enter hbType=%{public}d, isSyncData=%{public}d",
1154         type, msgPara->isSyncData);
1155     LnnHeartbeatSendBeginData *custData = NULL;
1156 
1157     if (hbFsm == NULL) {
1158         LNN_LOGE(LNN_HEART_BEAT, "post send begin msg get invalid param");
1159         return SOFTBUS_INVALID_PARAM;
1160     }
1161     custData = (LnnHeartbeatSendBeginData *)SoftBusCalloc(sizeof(LnnHeartbeatSendBeginData));
1162     if (custData == NULL) {
1163         LNN_LOGE(LNN_HEART_BEAT, "new hbType obj msg malloc err");
1164         return SOFTBUS_MALLOC_ERR;
1165     }
1166     custData->hbType = type;
1167     custData->wakeupFlag = wakeupFlag;
1168     custData->isRelay = msgPara->isRelay;
1169     custData->isSyncData = msgPara->isSyncData;
1170     custData->isNeedRestart = msgPara->isNeedRestart;
1171     custData->hasScanRsp = msgPara->hasScanRsp;
1172     custData->isFirstBegin = msgPara->isFirstBegin;
1173     custData->isFast = msgPara->isFast;
1174     if (LnnFsmPostMessageDelay(&hbFsm->fsm, EVENT_HB_SEND_ONE_BEGIN, (void *)custData, delayMillis) != SOFTBUS_OK) {
1175         LNN_LOGE(LNN_HEART_BEAT, "post send begin msg to hbFsm fail");
1176         SoftBusFree(custData);
1177         return SOFTBUS_ERR;
1178     }
1179     return SOFTBUS_OK;
1180 }
1181 
LnnPostSendEndMsgToHbFsm(LnnHeartbeatFsm * hbFsm,LnnHeartbeatSendEndData * custData,uint64_t delayMillis)1182 int32_t LnnPostSendEndMsgToHbFsm(LnnHeartbeatFsm *hbFsm, LnnHeartbeatSendEndData *custData,
1183     uint64_t delayMillis)
1184 {
1185     LnnHeartbeatSendEndData *dupData = NULL;
1186     if (hbFsm == NULL || custData == NULL) {
1187         LNN_LOGE(LNN_HEART_BEAT, "post send end msg get invalid param");
1188         return SOFTBUS_INVALID_PARAM;
1189     }
1190     LNN_LOGD(LNN_HEART_BEAT, "LnnPostSendEndMsgToHbFsm enter hbType=%{public}d", custData->hbType);
1191     dupData = (LnnHeartbeatSendEndData *)SoftBusCalloc(sizeof(LnnHeartbeatSendEndData));
1192     if (dupData == NULL) {
1193         LNN_LOGE(LNN_HEART_BEAT, "post send end msg malloc error");
1194         return SOFTBUS_MALLOC_ERR;
1195     }
1196     *dupData = *custData;
1197     if (LnnFsmPostMessageDelay(&hbFsm->fsm, EVENT_HB_SEND_ONE_END, (void *)dupData, delayMillis) != SOFTBUS_OK) {
1198         LNN_LOGE(LNN_HEART_BEAT, "post send end msg to hbFsm fail");
1199         SoftBusFree(dupData);
1200         return SOFTBUS_ERR;
1201     }
1202     return SOFTBUS_OK;
1203 }
1204 
LnnPostStartMsgToHbFsm(LnnHeartbeatFsm * hbFsm,uint64_t delayMillis)1205 int32_t LnnPostStartMsgToHbFsm(LnnHeartbeatFsm *hbFsm, uint64_t delayMillis)
1206 {
1207     if (hbFsm == NULL) {
1208         LNN_LOGE(LNN_HEART_BEAT, "post start msg get invalid param");
1209         return SOFTBUS_INVALID_PARAM;
1210     }
1211     return LnnFsmPostMessageDelay(&hbFsm->fsm, EVENT_HB_START_PROCESS, NULL, delayMillis);
1212 }
1213 
LnnPostStopMsgToHbFsm(LnnHeartbeatFsm * hbFsm,LnnHeartbeatType type)1214 int32_t LnnPostStopMsgToHbFsm(LnnHeartbeatFsm *hbFsm, LnnHeartbeatType type)
1215 {
1216     LnnHeartbeatType *newType = NULL;
1217 
1218     if (hbFsm == NULL) {
1219         LNN_LOGE(LNN_HEART_BEAT, "post stop msg get invalid param");
1220         return SOFTBUS_INVALID_PARAM;
1221     }
1222     newType = (LnnHeartbeatType *)SoftBusCalloc(sizeof(LnnHeartbeatType));
1223     if (newType == NULL) {
1224         LNN_LOGE(LNN_HEART_BEAT, "post stop msg malloc newType err");
1225         return SOFTBUS_MALLOC_ERR;
1226     }
1227     *newType = type;
1228     if (LnnFsmPostMessage(&hbFsm->fsm, EVENT_HB_STOP_SPECIFIC, (void *)newType) != SOFTBUS_OK) {
1229         LNN_LOGE(LNN_HEART_BEAT, "post stop msg to hbFsm fail");
1230         SoftBusFree(newType);
1231         return SOFTBUS_ERR;
1232     }
1233     return SOFTBUS_OK;
1234 }
1235 
LnnPostTransStateMsgToHbFsm(LnnHeartbeatFsm * hbFsm,LnnHeartbeatEventType evtType)1236 int32_t LnnPostTransStateMsgToHbFsm(LnnHeartbeatFsm *hbFsm, LnnHeartbeatEventType evtType)
1237 {
1238     if (hbFsm == NULL) {
1239         LNN_LOGE(LNN_HEART_BEAT, "post trans state msg get invalid hbFsm");
1240         return SOFTBUS_INVALID_PARAM;
1241     }
1242     if (evtType != EVENT_HB_AS_MASTER_NODE && evtType != EVENT_HB_AS_NORMAL_NODE && evtType != EVENT_HB_IN_NONE_STATE) {
1243         LNN_LOGE(LNN_HEART_BEAT, "post trans state msg get invalid evtType");
1244         return SOFTBUS_INVALID_PARAM;
1245     }
1246     return LnnFsmPostMessage(&hbFsm->fsm, evtType, NULL);
1247 }
1248 
LnnPostSetMediumParamMsgToHbFsm(LnnHeartbeatFsm * hbFsm,const LnnHeartbeatMediumParam * para)1249 int32_t LnnPostSetMediumParamMsgToHbFsm(LnnHeartbeatFsm *hbFsm, const LnnHeartbeatMediumParam *para)
1250 {
1251     LnnHeartbeatMediumParam *dupPara = NULL;
1252 
1253     if (hbFsm == NULL || para == NULL) {
1254         LNN_LOGE(LNN_HEART_BEAT, "post set medium param msg get invalid param");
1255         return SOFTBUS_INVALID_PARAM;
1256     }
1257     dupPara = (LnnHeartbeatMediumParam *)SoftBusCalloc(sizeof(LnnHeartbeatMediumParam));
1258     if (dupPara == NULL) {
1259         LNN_LOGE(LNN_HEART_BEAT, "post set medium param msg malloc msgPara fail");
1260         return SOFTBUS_MALLOC_ERR;
1261     }
1262     *dupPara = *para;
1263     if (LnnFsmPostMessage(&hbFsm->fsm, EVENT_HB_SET_MEDIUM_PARAM, (void *)dupPara) != SOFTBUS_OK) {
1264         LNN_LOGE(LNN_HEART_BEAT, "post set medium param msg to hbFsm fail");
1265         SoftBusFree(dupPara);
1266         return SOFTBUS_ERR;
1267     }
1268     return SOFTBUS_OK;
1269 }
1270 
LnnPostCheckDevStatusMsgToHbFsm(LnnHeartbeatFsm * hbFsm,const LnnCheckDevStatusMsgPara * para,uint64_t delayMillis)1271 int32_t LnnPostCheckDevStatusMsgToHbFsm(LnnHeartbeatFsm *hbFsm,
1272     const LnnCheckDevStatusMsgPara *para, uint64_t delayMillis)
1273 {
1274     LnnCheckDevStatusMsgPara *dupPara = NULL;
1275 
1276     if (hbFsm == NULL) {
1277         LNN_LOGE(LNN_HEART_BEAT, "post check dev status msg get invalid param");
1278         return SOFTBUS_INVALID_PARAM;
1279     }
1280     if (para == NULL) {
1281         return LnnFsmPostMessageDelay(&hbFsm->fsm, EVENT_HB_CHECK_DEV_STATUS, NULL, delayMillis);
1282     }
1283     dupPara = (LnnCheckDevStatusMsgPara *)SoftBusCalloc(sizeof(LnnCheckDevStatusMsgPara));
1284     if (dupPara == NULL) {
1285         LNN_LOGE(LNN_HEART_BEAT, "post check dev status msg malloc msgPara fail");
1286         return SOFTBUS_MALLOC_ERR;
1287     }
1288     if (memcpy_s(dupPara, sizeof(LnnCheckDevStatusMsgPara), para, sizeof(LnnCheckDevStatusMsgPara)) != EOK) {
1289         LNN_LOGE(LNN_HEART_BEAT, "post check dev status msg memcpy_s msgPara fail");
1290         SoftBusFree(dupPara);
1291         return SOFTBUS_MEM_ERR;
1292     }
1293     if (LnnFsmPostMessageDelay(&hbFsm->fsm, EVENT_HB_CHECK_DEV_STATUS, (void *)dupPara, delayMillis) != SOFTBUS_OK) {
1294         LNN_LOGE(LNN_HEART_BEAT, "post check dev status msg to hbFsm fail");
1295         SoftBusFree(dupPara);
1296         return SOFTBUS_ERR;
1297     }
1298     return SOFTBUS_OK;
1299 }
1300 
LnnPostScreenOffCheckDevMsgToHbFsm(LnnHeartbeatFsm * hbFsm,const LnnCheckDevStatusMsgPara * para,uint64_t delayMillis)1301 int32_t LnnPostScreenOffCheckDevMsgToHbFsm(LnnHeartbeatFsm *hbFsm,
1302     const LnnCheckDevStatusMsgPara *para, uint64_t delayMillis)
1303 {
1304     LnnCheckDevStatusMsgPara *dupPara = NULL;
1305 
1306     if (hbFsm == NULL) {
1307         LNN_LOGE(LNN_HEART_BEAT, "post check dev status msg get invalid param");
1308         return SOFTBUS_INVALID_PARAM;
1309     }
1310     if (para == NULL) {
1311         return LnnFsmPostMessageDelay(&hbFsm->fsm, EVENT_HB_SCREEN_OFF_CHECK_STATUS, NULL, delayMillis);
1312     }
1313     dupPara = (LnnCheckDevStatusMsgPara *)SoftBusCalloc(sizeof(LnnCheckDevStatusMsgPara));
1314     if (dupPara == NULL) {
1315         LNN_LOGE(LNN_HEART_BEAT, "post check dev status msg malloc msgPara fail");
1316         return SOFTBUS_MALLOC_ERR;
1317     }
1318     if (memcpy_s(dupPara, sizeof(LnnCheckDevStatusMsgPara), para, sizeof(LnnCheckDevStatusMsgPara)) != EOK) {
1319         LNN_LOGE(LNN_HEART_BEAT, "post check dev status msg memcpy_s msgPara fail");
1320         SoftBusFree(dupPara);
1321         return SOFTBUS_MEM_ERR;
1322     }
1323     if (LnnFsmPostMessageDelay(&hbFsm->fsm, EVENT_HB_SCREEN_OFF_CHECK_STATUS,
1324         (void *)dupPara, delayMillis) != SOFTBUS_OK) {
1325         LNN_LOGE(LNN_HEART_BEAT, "post check dev status msg to hbFsm fail");
1326         SoftBusFree(dupPara);
1327         return SOFTBUS_ERR;
1328     }
1329     return SOFTBUS_OK;
1330 }
1331 
LnnPostUpdateSendInfoMsgToHbFsm(LnnHeartbeatFsm * hbFsm,LnnHeartbeatUpdateInfoType type)1332 int32_t LnnPostUpdateSendInfoMsgToHbFsm(LnnHeartbeatFsm *hbFsm, LnnHeartbeatUpdateInfoType type)
1333 {
1334     if (hbFsm == NULL || type <= UPDATE_HB_INFO_MIN || type >= UPDATE_HB_MAX_INFO) {
1335         LNN_LOGE(LNN_HEART_BEAT, "post update info msg get invalid param");
1336         return SOFTBUS_INVALID_PARAM;
1337     }
1338     return LnnFsmPostMessage(&hbFsm->fsm, EVENT_HB_UPDATE_SEND_INFO, (void *)(uintptr_t)type);
1339 }
1340