/*******************************************************************************
 * File Name         : MQTT.c
 * Description       :
 * Created on        : 2018Äê5ÔÂ22ÈÕ
 * Author            : ¶Å¼ü
 *******************************************************************************/

/*******************************************************************************
 *                              Include Files                                  *
 *******************************************************************************/
#include "EG800MQTT.h"

#include "string.h"
#include "stdlib.h"
#include "EG800Driver.h"
#include "EG800FSM.h"
#include "HIDO_FSM.h"
#include "HIDO_Timer.h"
#include "HIDO_Util.h"
#include "HIDO_VLQueue.h"
#include "HIDO_ArraryQueue.h"
#include "HIDO_ATLite.h"
#include "HIDO_Debug.h"
#include "Module.h"
#include "ATConfig.h"
#include "MQTT.h"

/*******************************************************************************
 *                                  Macro                                      *
 *******************************************************************************/

/*******************************************************************************
 *                             Type Definition                                 *
 *******************************************************************************/
typedef struct
{
    HIDO_BOOL m_bUsed;
    HIDO_UINT32 m_u32MsgID;
    HIDO_UINT32 m_u32Tick;
} ST_Inflight;

/*******************************************************************************
 *                             Local Variable                                  *
 *******************************************************************************/
HIDO_FSM_STATE_FULL_DECLARE(EG800IPReady, EG800MQTTSetup) /* MQTTÁ¬½Ó½¨Á¢*/
HIDO_FSM_STATE_FULL_DECLARE(EG800IPReady, EG800MQTTClose) /* MQTT¹Ø±Õ״̬ */
#if 0
HIDO_FSM_STATE_FULL_DECLARE(EG800IPReady, EG800MQTTConnect)
HIDO_FSM_STATE_FULL_DECLARE(EG800IPReady, EG800MQTTDisconnect)
HIDO_FSM_STATE_FULL_DECLARE(EG800IPReady, EG800MQTTSubscribe)
HIDO_FSM_STATE_FULL_DECLARE(EG800IPReady, EG800MQTTUnsubscribe)
#endif
HIDO_FSM_STATE_FULL_DECLARE(EG800IPReady, EG800MQTTPublish)
HIDO_FSM_STATE_FULL_DECLARE(EG800IPReady, EG800MQTTRecv)

#define MAX_FLIGHT 5
#define INVALID_MSG_ID 0xFFFFFFFF

static ST_Inflight l_aastInflightList[MQTT_NUM][MAX_FLIGHT];

/*******************************************************************************
 *                        Local Function Declaration                           *
 *******************************************************************************/

/*******************************************************************************
 *                             Local Function                                  *
 *******************************************************************************/
/*******************************************************************************
 * Function Name     : EG800MQTT_IsInflightFull
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 *******************************************************************************/
static HIDO_BOOL EG800MQTT_IsInflightFull(HIDO_UINT32 _u32ClientID)
{
    HIDO_UINT32 i = 0;

    for (i = 0; i < MAX_FLIGHT; i++)
    {
        if (HIDO_FALSE == l_aastInflightList[_u32ClientID][i].m_bUsed)
        {
            return HIDO_FALSE;
        }
    }

    return HIDO_TRUE;
}

/*******************************************************************************
 * Function Name     : EG800MQTT_InflightAdd
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 *******************************************************************************/
static HIDO_INT32 EG800MQTT_InflightAdd(HIDO_UINT32 _u32ClientID, HIDO_UINT32 _u32MsgID)
{
    HIDO_UINT32 i = 0;

    for (i = 0; i < MAX_FLIGHT; i++)
    {
        if (HIDO_FALSE == l_aastInflightList[_u32ClientID][i].m_bUsed)
        {
            l_aastInflightList[_u32ClientID][i].m_bUsed = HIDO_TRUE;
            l_aastInflightList[_u32ClientID][i].m_u32MsgID = _u32MsgID;
            l_aastInflightList[_u32ClientID][i].m_u32Tick = HIDO_TimerGetTick();

            return HIDO_OK;
        }
    }

    return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : EG800MQTT_InflightRemove
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 *******************************************************************************/
static HIDO_INT32 EG800MQTT_InflightRemove(HIDO_UINT32 _u32ClientID, HIDO_UINT32 _u32MsgID)
{
    HIDO_UINT32 i = 0;

    if (_u32ClientID >= MQTT_NUM)
    {
        return HIDO_ERR;
    }

    for (i = 0; i < MAX_FLIGHT; i++)
    {
        if ((HIDO_TRUE == l_aastInflightList[_u32ClientID][i].m_bUsed) && (l_aastInflightList[_u32ClientID][i].m_u32MsgID == _u32MsgID))
        {
            memset(&l_aastInflightList[_u32ClientID][i], 0, sizeof(l_aastInflightList[_u32ClientID][i]));

            MQTT_OnSend(_u32ClientID);
        }
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : EG800MQTT_InflightCleanTimeout
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 *******************************************************************************/
static HIDO_INT32 EG800MQTT_InflightCleanTimeout(HIDO_UINT32 _u32ClientID)
{
    HIDO_UINT32 i = 0;

    for (i = 0; i < MAX_FLIGHT; i++)
    {
        if (HIDO_TRUE == l_aastInflightList[_u32ClientID][i].m_bUsed)
        {
            if ((HIDO_TimerGetTick() - l_aastInflightList[_u32ClientID][i].m_u32Tick) > HIDO_TIMER_TICK_S(15))
            {
                memset(&l_aastInflightList[_u32ClientID][i], 0, sizeof(l_aastInflightList[_u32ClientID][i]));

                MQTT_OnSend(_u32ClientID);
            }
        }
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : EG800MQTT_InflightClean
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 *******************************************************************************/
static HIDO_INT32 EG800MQTT_InflightClean(HIDO_UINT32 _u32ClientID)
{
    memset(&l_aastInflightList[_u32ClientID], 0, sizeof(l_aastInflightList[_u32ClientID]));

    return HIDO_OK;
}

/*******************************************************************************
 *                             Global Function                                 *
 *******************************************************************************/

/*******************************************************************************
 * State Name        : EG800MQTTSetup
 * Parent State      : EG800
 * Description       :
 * Author            : ¶Å¼ü
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800MQTTSetup, HIDO_FSM_STATE(EG800IPReady), HIDO_NULL)
{
    typedef enum
    {
        MQTT_SETUP_STATE_INIT_VERSION,
        MQTT_SETUP_STATE_INIT_PDPCID,
        MQTT_SETUP_STATE_INIT_TIMEOUT,
        MQTT_SETUP_STATE_INIT_SESSION,
        MQTT_SETUP_STATE_INIT_KEEPALIVE,
        MQTT_SETUP_STATE_INIT_RECV_MODE,
        MQTT_SETUP_STATE_OPEN,
        MQTT_SETUP_STATE_CONN,
        MQTT_SETUP_STATE_SUBSCRIBE,
    } E_MQTTInitState;

    static HIDO_INT32 l_i32MQTTID = 0;
    static E_MQTTInitState l_eInitState;
    static HIDO_BOOL l_bATResponse = HIDO_FALSE;
    static HIDO_BOOL l_bResultResponse = HIDO_FALSE;
    static ST_SubscribeTopic *pstTopicList = HIDO_NULL;

    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EG800DriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        l_i32MQTTID = (HIDO_INT32)_pArg;

        l_eInitState = MQTT_SETUP_STATE_INIT_VERSION;
        HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QMTCFG=\"version\",%u,%u\r\n", l_i32MQTTID,
                           MQTT_GetVersion(l_i32MQTTID));
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        HIDO_ATLiteCmdSendOver(pstATDevice);
        HIDO_TimerCancel(u32FSMTimerID);
        break;
    }
    case HIDO_AT_EVENT_OK:
    {
        if (MQTT_SETUP_STATE_INIT_VERSION == l_eInitState)
        {
            l_eInitState = MQTT_SETUP_STATE_INIT_PDPCID;
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QMTCFG=\"pdpcid\",%u,%u\r\n", l_i32MQTTID,
                               MQTT_GetPdpCid(l_i32MQTTID));
        }
        else if (MQTT_SETUP_STATE_INIT_PDPCID == l_eInitState)
        {
            l_eInitState = MQTT_SETUP_STATE_INIT_TIMEOUT;
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QMTCFG=\"timeout\",%u,%u,%u,1\r\n", l_i32MQTTID,
                               MQTT_GetPktTimeout(l_i32MQTTID), MQTT_GetRetryTimes(l_i32MQTTID));
        }
        else if (MQTT_SETUP_STATE_INIT_TIMEOUT == l_eInitState)
        {
            l_eInitState = MQTT_SETUP_STATE_INIT_SESSION;
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QMTCFG=\"session\",%u,%u\r\n", l_i32MQTTID,
                               MQTT_GetCleanSession(l_i32MQTTID));
        }
        else if (MQTT_SETUP_STATE_INIT_SESSION == l_eInitState)
        {
            l_eInitState = MQTT_SETUP_STATE_INIT_KEEPALIVE;
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QMTCFG=\"keepalive\",%u,%u\r\n", l_i32MQTTID,
                               MQTT_GetKeepAlive(l_i32MQTTID));
        }
        else if (MQTT_SETUP_STATE_INIT_KEEPALIVE == l_eInitState)
        {
            l_eInitState = MQTT_SETUP_STATE_INIT_RECV_MODE;
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QMTCFG=\"recv/mode\",%u,1,1\r\n", l_i32MQTTID);
        }
        else if (MQTT_SETUP_STATE_INIT_RECV_MODE == l_eInitState)
        {
            l_bATResponse = HIDO_FALSE;
            l_bResultResponse = HIDO_FALSE;
            l_eInitState = MQTT_SETUP_STATE_OPEN;
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QMTOPEN=%u,\"%s\",%u\r\n", l_i32MQTTID,
                               MQTT_GetRemoteAddr(l_i32MQTTID), MQTT_GetRemotePort(l_i32MQTTID));
        }
        else if (MQTT_SETUP_STATE_OPEN == l_eInitState)
        {
            l_bATResponse = HIDO_TRUE;
        OPEN:
            if (l_bATResponse == HIDO_TRUE && l_bResultResponse == HIDO_TRUE)
            {
                l_bATResponse = HIDO_FALSE;
                l_bResultResponse = HIDO_FALSE;
                l_eInitState = MQTT_SETUP_STATE_CONN;
                HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QMTCONN=%u,\"%s\",\"%s\",\"%s\"\r\n", l_i32MQTTID,
                                   MQTT_GetClientID(l_i32MQTTID), MQTT_GetUsername(l_i32MQTTID), MQTT_GetmPassword(l_i32MQTTID));
            }
        }
        else if (MQTT_SETUP_STATE_CONN == l_eInitState)
        {
            l_bATResponse = HIDO_TRUE;
        CONN:
            if (l_bATResponse == HIDO_TRUE && l_bResultResponse == HIDO_TRUE)
            {
                MQTT_OnConnected(l_i32MQTTID);
                MQTT_SetMsgID(l_i32MQTTID, 0);

                pstTopicList = MQTT_GetSubscribeTopicList(l_i32MQTTID);
                if (pstTopicList != HIDO_NULL)
                {
                    l_bATResponse = HIDO_FALSE;
                    l_bResultResponse = HIDO_FALSE;
                    l_eInitState = MQTT_SETUP_STATE_SUBSCRIBE;
                    HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QMTSUB=%u,%u", l_i32MQTTID,
                                       MQTT_GetMsgID(l_i32MQTTID));
                    HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, ",\"%s\",%u",
                                       pstTopicList->m_acTopic, pstTopicList->m_u32QOS);

                    HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "\r\n");
                }
                else
                {
                    HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
                }
            }
        }
        else if (MQTT_SETUP_STATE_SUBSCRIBE == l_eInitState)
        {
            l_bATResponse = HIDO_TRUE;
        SUB:
            if (l_bATResponse == HIDO_TRUE && l_bResultResponse == HIDO_TRUE)
            {
                if (pstTopicList != HIDO_NULL)
                {
                    pstTopicList = pstTopicList->m_pstNext;
                }

                if (pstTopicList != HIDO_NULL)
                {
                    l_bATResponse = HIDO_FALSE;
                    l_bResultResponse = HIDO_FALSE;
                    l_eInitState = MQTT_SETUP_STATE_SUBSCRIBE;
                    HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QMTSUB=%u,%u", l_i32MQTTID,
                                       MQTT_GetMsgID(l_i32MQTTID));
                    HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, ",\"%s\",%u",
                                       pstTopicList->m_acTopic, pstTopicList->m_u32QOS);

                    HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "\r\n");
                }
                else
                {
                    HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
                }
            }
        }

        break;
    }
    case HIDO_AT_EVENT_ERROR:
    {
        MQTT_OnClosed(l_i32MQTTID);
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
        break;
    }
    case EG800_EVENT_QMTOPEN:
    {
        HIDO_DataStruct *pstData = (HIDO_DataStruct *)_pArg;
        HIDO_UINT32 u32Err = 0;
        HIDO_UINT32 u32ClientID = 0;

        if (HIDO_UtilParseFormat((HIDO_UINT8 *)pstData->m_pData, pstData->m_u32Len, "+QMTOPEN: %d,%d\r\n",
                                 &u32ClientID, &u32Err) != 2)
        {
            break;
        }

        if ((u32ClientID == l_i32MQTTID) && (u32Err != 0))
        {
            MQTT_OnConnectFailed(u32ClientID);
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            break;
        }

        l_bResultResponse = HIDO_TRUE;
        goto OPEN;
    }
    case EG800_EVENT_QMTCONN:
    {
        HIDO_DataStruct *pstData = (HIDO_DataStruct *)_pArg;
        HIDO_UINT32 u32Err = 0;
        HIDO_UINT32 u32ClientID = 0;
        HIDO_UINT32 u32RetCode = 0;

        if (HIDO_UtilParseFormat((HIDO_UINT8 *)pstData->m_pData, pstData->m_u32Len, "+QMTCONN: %d,%d,%d",
                                 &u32ClientID, &u32Err, &u32RetCode) != 3)
        {
            if (HIDO_UtilParseFormat((HIDO_UINT8 *)pstData->m_pData, pstData->m_u32Len, "+QMTCONN: %d,%d",
                                     &u32ClientID, &u32Err) != 2)
            {
                break;
            }
        }

        if ((u32ClientID == l_i32MQTTID) && (u32Err != 0 || u32RetCode != 0))
        {
            MQTT_OnConnectFailed(u32ClientID);
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            break;
        }

        l_bResultResponse = HIDO_TRUE;
        goto CONN;
    }
    case EG800_EVENT_QMTSUB:
    {
        HIDO_DataStruct *pstData = (HIDO_DataStruct *)_pArg;
        HIDO_UINT32 u32Err = 0;
        HIDO_UINT32 u32ClientID = 0;

        if (HIDO_UtilParseFormat((HIDO_UINT8 *)pstData->m_pData, pstData->m_u32Len, "+QMTSUB: %d,%*,%d",
                                 &u32ClientID, &u32Err) != 3)
        {
            break;
        }

        if ((u32ClientID == l_i32MQTTID) && (u32Err != 0))
        {
            MQTT_OnClosed(u32ClientID);
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            break;
        }

        l_bResultResponse = HIDO_TRUE;
        goto SUB;
    }
    case EG800_EVENT_QMTSTAT:
    {
        HIDO_DataStruct *pstData = (HIDO_DataStruct *)_pArg;
        HIDO_UINT32 u32Err = 0;
        HIDO_UINT32 u32ClientID = 0;

        if (HIDO_UtilParseFormat((HIDO_UINT8 *)pstData->m_pData, pstData->m_u32Len, "+QMTSTAT: %d,%d\r\n",
                                 &u32ClientID, &u32Err) != 2)
        {
            break;
        }

        if ((u32ClientID == l_i32MQTTID) && (u32Err != 0))
        {
            MQTT_OnClosed(u32ClientID);
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            break;
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800MQTTClose
 * Parent State      : EG800
 * Description       :
 * Author            : ¶Å¼ü
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800MQTTClose, HIDO_FSM_STATE(EG800IPReady), HIDO_NULL)
{
    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EG800DriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;

    static HIDO_INT32 l_i32MQTTID = 0;
    static HIDO_BOOL l_bATResp = HIDO_FALSE;
    static HIDO_BOOL l_bOKResp = HIDO_FALSE;

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        l_i32MQTTID = (HIDO_INT32)_pArg;
        l_bATResp = HIDO_FALSE;
        l_bOKResp = HIDO_FALSE;
        HIDO_ATLiteCmdSend(pstATDevice, HIDO_TIMER_TICK_S(15), "AT+QMTCLOSE=%d\r\n", l_i32MQTTID);
        HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(60), _pstFSM, EG800_EVENT_DELAY);
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        HIDO_ATLiteCmdSendOver(pstATDevice);
        HIDO_TimerCancel(u32FSMTimerID);
        break;
    }
    case HIDO_AT_EVENT_ERROR:
    {
        MQTT_OnClosed(l_i32MQTTID);
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
        break;
    }
    case HIDO_AT_EVENT_OK:
    {
        l_bOKResp = HIDO_TRUE;
        if (HIDO_TRUE == l_bATResp)
        {
            MQTT_OnClosed(l_i32MQTTID);
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
        }
        break;
    }
    case EG800_EVENT_QMTCLOSE:
    {
        l_bATResp = HIDO_TRUE;
        if (HIDO_TRUE == l_bOKResp)
        {
            MQTT_OnClosed(l_i32MQTTID);
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
        }
        break;
    }
    case EG800_EVENT_DELAY:
    {
        MQTT_OnClosed(l_i32MQTTID);
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

#if 0
/*******************************************************************************
 * State Name        : EG800MQTTConnect
 * Parent State      : Ready
 * Description       :
 * Author            : ¶Å¼ü
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800MQTTConnect, HIDO_FSM_STATE(EG800IPReady), HIDO_NULL)
{
    static HIDO_INT32 l_i32MQTTID = 0;
    static HIDO_BOOL l_bIsAck = HIDO_FALSE;

    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *) _pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EG800DriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;

    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
        {
            l_i32MQTTID = (HIDO_INT32) _pArg;
            l_bIsAck = HIDO_FALSE;
            l_au32MQTTUnAckTick[l_i32MQTTID] = HIDO_TimerGetTick();

            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QISEND=%d,0\r\n", l_i32MQTTID);
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            HIDO_ATLiteCmdSendOver(pstATDevice);
            HIDO_TimerCancel(u32FSMTimerID);
            break;
        }
        case HIDO_AT_EVENT_OK:
        {
            if(HIDO_TRUE == l_bIsAck)
            {
                l_abMQTTUnAck[l_i32MQTTID] = HIDO_FALSE;
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            }
            else
            {
                if((HIDO_TimerGetTick() - l_au32MQTTSendTick[l_i32MQTTID]) >= HIDO_TIMER_TICK_S(90))
                {
                    MQTT_OnClosed(l_i32MQTTID);
					l_abMQTTUnAck[l_i32MQTTID] = HIDO_FALSE;
                }

				HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            }

            break;
        }
        case HIDO_AT_EVENT_ERROR:
        {
            l_abMQTTUnAck[l_i32MQTTID] = HIDO_FALSE;
            MQTT_OnClosed(l_i32MQTTID);
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            break;
        }
        case EG800_EVENT_SEND:
        {
            HIDO_UINT32 u32Total = 0;
            HIDO_UINT32 u32Ack = 0;
            HIDO_UINT32 u32UnAck = 0;
            HIDO_DataStruct *pstData = (HIDO_DataStruct *) _pArg;

            if (HIDO_UtilParseFormat((HIDO_UINT8 *) pstData->m_pData, pstData->m_u32Len, "+QISEND: %d,%d,%d\r\n",
                    &u32Total, &u32Ack, &u32UnAck) != 3)
            {
                MQTT_OnClosed(l_i32MQTTID);
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
                break;
            }

            if(0 == u32UnAck)
            {
                l_bIsAck = HIDO_TRUE;
            }
            else
            {
                l_bIsAck = HIDO_FALSE;
            }

            break;
        }
        case EG800_EVENT_DELAY:
        {
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QISEND=%d,0\r\n", l_i32MQTTID);
            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800MQTTDisconnect
 * Parent State      : Ready
 * Description       :
 * Author            : ¶Å¼ü
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800MQTTDisconnect, HIDO_FSM_STATE(EG800IPReady), HIDO_NULL)
{
    static HIDO_INT32 l_i32MQTTID = 0;
    static HIDO_BOOL l_bIsAck = HIDO_FALSE;

    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *) _pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EG800DriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;

    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
        {
            l_i32MQTTID = (HIDO_INT32) _pArg;
            l_bIsAck = HIDO_FALSE;
            l_au32MQTTUnAckTick[l_i32MQTTID] = HIDO_TimerGetTick();

            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QISEND=%d,0\r\n", l_i32MQTTID);
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            HIDO_ATLiteCmdSendOver(pstATDevice);
            HIDO_TimerCancel(u32FSMTimerID);
            break;
        }
        case HIDO_AT_EVENT_OK:
        {
            if(HIDO_TRUE == l_bIsAck)
            {
                l_abMQTTUnAck[l_i32MQTTID] = HIDO_FALSE;
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            }
            else
            {
                if((HIDO_TimerGetTick() - l_au32MQTTSendTick[l_i32MQTTID]) >= HIDO_TIMER_TICK_S(90))
                {
                    MQTT_OnClosed(l_i32MQTTID);
					l_abMQTTUnAck[l_i32MQTTID] = HIDO_FALSE;
                }

				HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            }

            break;
        }
        case HIDO_AT_EVENT_ERROR:
        {
            l_abMQTTUnAck[l_i32MQTTID] = HIDO_FALSE;
            MQTT_OnClosed(l_i32MQTTID);
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            break;
        }
        case EG800_EVENT_SEND:
        {
            HIDO_UINT32 u32Total = 0;
            HIDO_UINT32 u32Ack = 0;
            HIDO_UINT32 u32UnAck = 0;
            HIDO_DataStruct *pstData = (HIDO_DataStruct *) _pArg;

            if (HIDO_UtilParseFormat((HIDO_UINT8 *) pstData->m_pData, pstData->m_u32Len, "+QISEND: %d,%d,%d\r\n",
                    &u32Total, &u32Ack, &u32UnAck) != 3)
            {
                MQTT_OnClosed(l_i32MQTTID);
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
                break;
            }

            if(0 == u32UnAck)
            {
                l_bIsAck = HIDO_TRUE;
            }
            else
            {
                l_bIsAck = HIDO_FALSE;
            }

            break;
        }
        case EG800_EVENT_DELAY:
        {
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QISEND=%d,0\r\n", l_i32MQTTID);
            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800MQTTSendData
 * Parent State      : Ready
 * Description       :
 * Author            : ¶Å¼ü
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800MQTTSubscribe, HIDO_FSM_STATE(EG800IPReady), HIDO_NULL)
{
    static HIDO_INT32 l_i32MQTTID = 0;
    static HIDO_BOOL l_bIsAck = HIDO_FALSE;

    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *) _pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EG800DriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;

    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
        {
            l_i32MQTTID = (HIDO_INT32) _pArg;
            l_bIsAck = HIDO_FALSE;
            l_au32MQTTUnAckTick[l_i32MQTTID] = HIDO_TimerGetTick();

            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QISEND=%d,0\r\n", l_i32MQTTID);
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            HIDO_ATLiteCmdSendOver(pstATDevice);
            HIDO_TimerCancel(u32FSMTimerID);
            break;
        }
        case HIDO_AT_EVENT_OK:
        {
            if(HIDO_TRUE == l_bIsAck)
            {
                l_abMQTTUnAck[l_i32MQTTID] = HIDO_FALSE;
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            }
            else
            {
                if((HIDO_TimerGetTick() - l_au32MQTTSendTick[l_i32MQTTID]) >= HIDO_TIMER_TICK_S(90))
                {
                    MQTT_OnClosed(l_i32MQTTID);
					l_abMQTTUnAck[l_i32MQTTID] = HIDO_FALSE;
                }

				HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            }

            break;
        }
        case HIDO_AT_EVENT_ERROR:
        {
            l_abMQTTUnAck[l_i32MQTTID] = HIDO_FALSE;
            MQTT_OnClosed(l_i32MQTTID);
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            break;
        }
        case EG800_EVENT_SEND:
        {
            HIDO_UINT32 u32Total = 0;
            HIDO_UINT32 u32Ack = 0;
            HIDO_UINT32 u32UnAck = 0;
            HIDO_DataStruct *pstData = (HIDO_DataStruct *) _pArg;

            if (HIDO_UtilParseFormat((HIDO_UINT8 *) pstData->m_pData, pstData->m_u32Len, "+QISEND: %d,%d,%d\r\n",
                    &u32Total, &u32Ack, &u32UnAck) != 3)
            {
                MQTT_OnClosed(l_i32MQTTID);
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
                break;
            }

            if(0 == u32UnAck)
            {
                l_bIsAck = HIDO_TRUE;
            }
            else
            {
                l_bIsAck = HIDO_FALSE;
            }

            break;
        }
        case EG800_EVENT_DELAY:
        {
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QISEND=%d,0\r\n", l_i32MQTTID);
            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800MQTTUnsubscribe
 * Parent State      : EG800IPReady
 * Description       :
 * Author            : ¶Å¼ü
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800MQTTUnsubscribe, HIDO_FSM_STATE(EG800IPReady), HIDO_NULL)
{
    static HIDO_INT32 l_i32MQTTID = 0;
    static HIDO_BOOL l_bIsAck = HIDO_FALSE;

    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *) _pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EG800DriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;

    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
        {
            l_i32MQTTID = (HIDO_INT32) _pArg;
            l_bIsAck = HIDO_FALSE;
            l_au32MQTTUnAckTick[l_i32MQTTID] = HIDO_TimerGetTick();

            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QISEND=%d,0\r\n", l_i32MQTTID);
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            HIDO_ATLiteCmdSendOver(pstATDevice);
            HIDO_TimerCancel(u32FSMTimerID);
            break;
        }
        case HIDO_AT_EVENT_OK:
        {
            if(HIDO_TRUE == l_bIsAck)
            {
                l_abMQTTUnAck[l_i32MQTTID] = HIDO_FALSE;
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            }
            else
            {
                if((HIDO_TimerGetTick() - l_au32MQTTSendTick[l_i32MQTTID]) >= HIDO_TIMER_TICK_S(90))
                {
                    MQTT_OnClosed(l_i32MQTTID);
					l_abMQTTUnAck[l_i32MQTTID] = HIDO_FALSE;
                }

				HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            }

            break;
        }
        case HIDO_AT_EVENT_ERROR:
        {
            l_abMQTTUnAck[l_i32MQTTID] = HIDO_FALSE;
            MQTT_OnClosed(l_i32MQTTID);
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            break;
        }
        case EG800_EVENT_SEND:
        {
            HIDO_UINT32 u32Total = 0;
            HIDO_UINT32 u32Ack = 0;
            HIDO_UINT32 u32UnAck = 0;
            HIDO_DataStruct *pstData = (HIDO_DataStruct *) _pArg;

            if (HIDO_UtilParseFormat((HIDO_UINT8 *) pstData->m_pData, pstData->m_u32Len, "+QISEND: %d,%d,%d\r\n",
                    &u32Total, &u32Ack, &u32UnAck) != 3)
            {
                MQTT_OnClosed(l_i32MQTTID);
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
                break;
            }

            if(0 == u32UnAck)
            {
                l_bIsAck = HIDO_TRUE;
            }
            else
            {
                l_bIsAck = HIDO_FALSE;
            }

            break;
        }
        case EG800_EVENT_DELAY:
        {
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QISEND=%d,0\r\n", l_i32MQTTID);
            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}
#endif

/*******************************************************************************
 * State Name        : EG800MQTTPublish
 * Parent State      : EG800IPReady
 * Description       :
 * Author            : ¶Å¼ü
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800MQTTPublish, HIDO_FSM_STATE(EG800IPReady), HIDO_NULL)
{
    static HIDO_INT32 l_i32MQTTID = 0;
    static HIDO_VLQMemberStruct *l_pstMember = HIDO_NULL;
    static ST_MQTTMessage *l_pstMessage = HIDO_NULL;
    static HIDO_VLQStruct *l_pstSendQueue = HIDO_NULL;

    HIDO_UINT32 u32MsgID = 0;
    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        l_i32MQTTID = (HIDO_INT32)_pArg;

        l_pstSendQueue = MQTT_GetSendQueue(l_i32MQTTID);
        if (HIDO_NULL == l_pstSendQueue)
        {
            break;
        }

        if (EG800MQTT_IsInflightFull(l_i32MQTTID) == HIDO_TRUE)
        {
            break;
        }

        l_pstMember = HIDO_VLQGetDequeueMember(l_pstSendQueue);
        if (HIDO_NULL == l_pstMember)
        {
            break;
        }

        l_pstMessage = (ST_MQTTMessage *)l_pstMember->m_pDataAddr;
        if (l_pstMessage->m_u32QOS != 0)
        {
            u32MsgID = MQTT_GetMsgID(l_i32MQTTID);
            EG800MQTT_InflightAdd(l_i32MQTTID, u32MsgID);
        }

        HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QMTPUBEX=%u,%u,%u,%u,\"%s\",%u\r\n",
                           l_i32MQTTID, u32MsgID, l_pstMessage->m_u32QOS, l_pstMessage->m_u32Retain, l_pstMessage->m_acTopic,
                           l_pstMessage->m_u32DataLen);
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        l_pstMember = HIDO_NULL;
        HIDO_ATLiteCmdSendOver(pstATDevice);
        break;
    }
    case HIDO_AT_EVENT_OK:
    {
        HIDO_VLQDequeue(l_pstSendQueue, l_pstMember);

        if (EG800MQTT_IsInflightFull(l_i32MQTTID) == HIDO_TRUE)
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            break;
        }

        l_pstMember = HIDO_VLQGetDequeueMember(l_pstSendQueue);
        if (HIDO_NULL == l_pstMember)
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
            break;
        }

        l_pstMessage = (ST_MQTTMessage *)l_pstMember->m_pDataAddr;
        if (l_pstMessage->m_u32QOS != 0)
        {
            u32MsgID = MQTT_GetMsgID(l_i32MQTTID);
            EG800MQTT_InflightAdd(l_i32MQTTID, u32MsgID);
        }

        HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QMTPUBEX=%u,%u,%u,%u,\"%s\",%u\r\n",
                           l_i32MQTTID, u32MsgID, l_pstMessage->m_u32QOS, l_pstMessage->m_u32Retain, l_pstMessage->m_acTopic,
                           l_pstMessage->m_u32DataLen);
        break;
    }
    case HIDO_AT_EVENT_ERROR:
    {
        MQTT_OnClosed(l_i32MQTTID);
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
        break;
    }
    case EG800_EVENT_ACK:
    {
        if (HIDO_ATLiteGetDebugFlag() == HIDO_TRUE)
        {
            if (HIDO_UtilIsAsciiString(l_pstMessage->m_au8Data, l_pstMessage->m_u32DataLen) == HIDO_TRUE)
            {
                HIDO_DebugString((HIDO_CHAR *)l_pstMessage->m_au8Data, l_pstMessage->m_u32DataLen);
            }
            else
            {
                HIDO_DebugHex(l_pstMessage->m_au8Data, l_pstMessage->m_u32DataLen);
            }
        }

        HIDO_ATLiteDataSend(pstATDevice, 20000, (HIDO_UINT8 *)l_pstMessage->m_au8Data, l_pstMessage->m_u32DataLen);
        break;
    }
    case EG800_EVENT_SEND_FAIL:
    {
        MQTT_OnClosed(l_i32MQTTID);
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800MQTTRecv
 * Parent State      : EG800IPReady
 * Description       :
 * Author            : ¶Å¼ü
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800MQTTRecv, HIDO_FSM_STATE(EG800IPReady), HIDO_NULL)
{
    static HIDO_INT32 l_i32MQTTID = 0;
    static HIDO_BOOL l_bMQTTRecv = HIDO_FALSE;

    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        l_i32MQTTID = (HIDO_INT32)_pArg;
        l_bMQTTRecv = HIDO_FALSE;

        HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QMTRECV=%u\r\n", l_i32MQTTID);
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        HIDO_ATLiteCmdSendOver(pstATDevice);
        break;
    }
    case HIDO_AT_EVENT_OK:
    case HIDO_AT_EVENT_ERROR:
    {
        if (((HIDO_AT_EVENT_OK == _u32Event) && (HIDO_FALSE == l_bMQTTRecv)) || (HIDO_AT_EVENT_ERROR == _u32Event))
        {
            MQTT_NoRecvData(l_i32MQTTID);
        }

        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
        break;
    }
    case EG800_EVENT_QMTRECV:
    {
        HIDO_UINT32 u32ClientID = 0;
        HIDO_UINT32 u32MsgID = 0;
        HIDO_UINT32 u32PayloadLen = 0;
        HIDO_DataStruct stTopic;
        HIDO_DataStruct stPayload;
        HIDO_VLQStruct *pstRecvQueue = HIDO_NULL;
        HIDO_VLQMemberStruct *pstMember = HIDO_NULL;
        ST_MQTTMessage *pcMessage = HIDO_NULL;
        HIDO_DataStruct *pstData = (HIDO_DataStruct *)_pArg;

        if (HIDO_UtilParseFormat((HIDO_UINT8 *)pstData->m_pData, pstData->m_u32Len, "+QMTRECV: %d,%d,\"%p\",%d,%p\r\n",
                                 &u32ClientID, &u32MsgID, &stTopic, &u32PayloadLen, &stPayload) != 5)
        {
            return HIDO_EVENT_NO_PROC;
        }

        l_bMQTTRecv = HIDO_TRUE;
        pstRecvQueue = MQTT_GetRecvQueue(u32ClientID);
        if (HIDO_NULL == pstRecvQueue)
        {
            break;
        }

        if (u32PayloadLen + 2 != stPayload.m_u32Len)
        {
            break;
        }

        pstMember = HIDO_VLQGetEnqueueMember(pstRecvQueue, sizeof(ST_MQTTMessage) + u32PayloadLen);
        if (pstMember != HIDO_NULL)
        {
            pcMessage = (ST_MQTTMessage *)pstMember->m_pDataAddr;
            if (stTopic.m_u32Len < sizeof(pcMessage->m_acTopic))
            {
                memcpy(pcMessage->m_acTopic, stTopic.m_pData, stTopic.m_u32Len);
                pcMessage->m_acTopic[stTopic.m_u32Len] = '\0';
            }

            pcMessage->m_u32DataLen = u32PayloadLen;
            memcpy(pcMessage->m_au8Data, ((HIDO_CHAR *)stPayload.m_pData) + 1, stPayload.m_u32Len - 2);

            HIDO_VLQEnqueue(pstRecvQueue, pstMember);
            MQTT_OnRecv(u32ClientID);
        }
        else
        {
            HIDO_Debug("MQTT[%u] Recv Buffer Full\r\n", u32ClientID);
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * Function Name     : EG800MQTT_SendAck
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 *******************************************************************************/
HIDO_INT32 EG800MQTT_SendAck(HIDO_DataStruct *_pstData)
{
    HIDO_UINT32 u32ClientID = 0;
    HIDO_UINT32 u32MsgID = 0;
    HIDO_UINT32 u32Result = 0;

    if (HIDO_UtilParseFormat((HIDO_UINT8 *)_pstData->m_pData, _pstData->m_u32Len, "+QMTPUBEX: %d,%d,%d\r\n",
                             &u32ClientID, &u32MsgID, &u32Result) != 3)
    {
        return HIDO_ERR;
    }

    EG800MQTT_InflightRemove(u32ClientID, u32MsgID);

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : EG800MQTT_Poll
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 *******************************************************************************/
HIDO_INT32 EG800MQTT_Poll(HIDO_ATLiteDeviceStruct *_pstATDevice)
{
    HIDO_INT32 i32MQTTIndex = 0;
    HIDO_VLQStruct *pstSendQueue = HIDO_NULL;
    HIDO_UINT32 u32CurTick = HIDO_TimerGetTick();

    for (i32MQTTIndex = 0; i32MQTTIndex < MQTT_NUM; i32MQTTIndex++)
    {
        if (MQTT_STATE_CONNECT == MQTT_GetMQTTState(i32MQTTIndex))
        {
            EG800MQTT_InflightClean(i32MQTTIndex);
            MQTT_SetMQTTState(i32MQTTIndex, MQTT_STATE_CLOSE_BEFORE_CONNECT);
            HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(EG800MQTTClose), (HIDO_VOID *)(HIDO_UINT32)i32MQTTIndex);
            return HIDO_OK;
        }
        else if (MQTT_STATE_CLOSE_BEFORE_CONNECT == MQTT_GetMQTTState(i32MQTTIndex))
        {
            HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(EG800MQTTSetup), (HIDO_VOID *)(HIDO_UINT32)i32MQTTIndex);
            return HIDO_OK;
        }
        else if (MQTT_STATE_CLOSE == MQTT_GetMQTTState(i32MQTTIndex))
        {
            HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(EG800MQTTClose),
                                (HIDO_VOID *)(HIDO_UINT32)i32MQTTIndex);
            return HIDO_OK;
        }

        if (HIDO_TRUE == MQTT_HasRecvData(i32MQTTIndex))
        {
            HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(EG800MQTTRecv), (HIDO_VOID *)(HIDO_UINT32)i32MQTTIndex);
            return HIDO_OK;
        }

        if (MQTT_STATE_CONNECTED == MQTT_GetMQTTState(i32MQTTIndex))
        {
            pstSendQueue = MQTT_GetSendQueue(i32MQTTIndex);
            if (pstSendQueue != HIDO_NULL)
            {
                if (EG800MQTT_IsInflightFull(i32MQTTIndex) == HIDO_FALSE)
                {
                    if (HIDO_VLQGetDequeueMember(pstSendQueue) != HIDO_NULL)
                    {
                        HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(EG800MQTTPublish), (HIDO_VOID *)(HIDO_UINT32)i32MQTTIndex);
                        return HIDO_OK;
                    }
                }
            }
        }

        EG800MQTT_InflightCleanTimeout(i32MQTTIndex);
    }

    return HIDO_ERR;
}