/****************************************************************************
 *
 * Copy right:   2019-, Copyrigths of EigenComm Ltd.
 * File name:    plat_config.c
 * Description:  platform configuration source file
 * History:      Rev1.0   2019-01-18
 *
 ****************************************************************************/

#include <stdio.h>
#include <stdarg.h>
#include "commonTypedef.h"
#include "lfs_port.h"
#include "dm_task.h"
#include "cucc_dm.h"
#include "osasys.h"
#include "ostask.h"
#include DEBUG_LOG_HEADER_FILE
#include "networkmgr.h"
#include "slpman.h"
#include "ps_lib_api.h"
#include "at_util.h"
#include "MQTTClient.h"
#include "ps_event_callback.h"
#include "ps_lib_api.h"
#include "mw_nvm_config.h"
#include "cucc_mqtt.h"
#include "osasys.h"
#include "ps_mm_if.h"
#include "appmgr.h"

QueueHandle_t dmMsgHandle = NULL;
UINT8 cuccDmSlpHandler = 0xff;
osThreadId_t cuccAutoRegisterTaskHandle = NULL;
osThreadId_t cuccDmAutoRegisterTaskHandle = NULL;
MQTTClient cuccMqttClient;
Network cuccMqttNetwork;
char *cuccMqttSendbuf = NULL;
char *cuccMqttReadbuf = NULL;
char *cuccIMEI = NULL;
char *cuccIMSI = NULL;
char *cuccCCID = NULL;
char *cuccSendPayload = NULL;
UINT32 cuccDmMsgI = 81192;
osTimerId_t cuccDmTimer = NULL;

extern time_t OsaSystemTimeReadSecs(void);

void cuccAutoRegTimerCallback(void)
{
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_cuccAutoRegTimerCallback, P_SIG, "cuccAutoRegTimerCallback....");

}
void cuccAutoRegCheckIfNeedExit(UINT32 needFlag)
{
    UINT8 cfun = 0xff;

    appGetCFUN(&cfun);
    if((cfun == 0)||(needFlag == 1))
    {
        if(cuccIMEI != NULL)
        {
            freeEc(cuccIMEI);
            cuccIMEI = NULL;
        }
        if(cuccIMSI != NULL)
        {
            freeEc(cuccIMSI);
            cuccIMSI = NULL;
        }
        if(cuccCCID != NULL)
        {
            freeEc(cuccCCID);
            cuccCCID = NULL;
        }
        if(cuccMqttSendbuf != NULL)
        {
            freeEc(cuccMqttSendbuf);
            cuccMqttSendbuf = NULL;
        }
        if(cuccMqttReadbuf != NULL)
        {
            freeEc(cuccMqttReadbuf);
            cuccMqttReadbuf = NULL;
        }
        if(cuccSendPayload != NULL)
        {
            freeEc(cuccSendPayload);
            cuccSendPayload = NULL;
        }

        slpManPlatVoteEnableSleep(cuccDmSlpHandler,SLP_SLP2_STATE); //open the sleep2 gate, it can go to sleep2 and hib state
        slpManGivebackPlatVoteHandle(cuccDmSlpHandler);
        osThreadExit();
    }
}

#define CUCC_DM_AUTOREG_TASK_START
void cuccAutoRegisterTask(void *argument)
{
    INT32 ret = 0xff;
    INT32 retryCount = 0xff;
    INT32 len = 0;
    MWNvmCfgDmCuccParam dmCuccParam = {0};
    MQTTPacket_connectData connectData = MQTTPacket_connectData_initializer;
    char cuccClientID[CUCC_DM_MQTT_CLIENTID_LEN] = {0};
    char cuccUsername[CUCC_DM_MQTT_USERNAME_LEN] = {0};
    char cuccPassword[CUCC_DM_MQTT_PASSWORD_LEN] = {0};
    char dmTopic[CUCC_DM_TOPIC_LEN] = {0};
    MQTTString topicName;
    char recvPayload[CUCC_DM_MQTT_RECV_DEVICE_SECRET_LEN] = {0};
    char *data_start_ptr = NULL;
    char *data_end_ptr = NULL;
    MQTTMessage message;
    float rsrq = -10.2;
    int rsrqTemp = 0;
    int csq = 30;
    int rsrp = -100;
    int cellId = 8119;
    int snr = 10;
    //UINT32 epoch_time = 30;
    int primSize;
    dmMessage dmMsg;
    int autoRegPeriod = 0;
    int autoRegPeriodFlag = 0;
    UeExtStatusInfo  statusInfo;
    UINT8 apn[CUCC_DM_APN_LEN] = {0};
    utc_timer_value_t *utcTimePtr = NULL;
    UINT8 utcTimeBuf[CUCC_DM_UTC_TIME_LEN] = {0};
    UINT8 msgId[CUCC_DM_MSG_ID_LEN] = {0};
    INT32 timeSyncFlag = 0xff;
    INT32 timeSyncRetry = 0;
    INT32 i=0;

    memset(&dmMsg, 0, sizeof(dmMsg));
    memset(&message, 0, sizeof(MQTTMessage));
    memset(&dmCuccParam, 0, sizeof(dmCuccParam));
    slpManPlatVoteDisableSleep(cuccDmSlpHandler,SLP_SLP2_STATE);  //close sleep2 gate now, it can go to active or sleep1

    mwNvmCfgGetDmCuccParam(&dmCuccParam);
    if(dmCuccParam.mProductKey[0] == 0)
    {
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_err1, P_SIG, "mProductKey is null");
        slpManPlatVoteEnableSleep(cuccDmSlpHandler,SLP_SLP2_STATE); //open the sleep2 gate, it can go to sleep2 and hib state
        slpManGivebackPlatVoteHandle(cuccDmSlpHandler);
        osThreadExit();
    }

    /* step1: init mqtt client */
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_1, P_SIG, "step1: init mqtt client....");
    NetworkInit(&cuccMqttNetwork);
    cuccMqttSendbuf = mallocEc(CUCC_MQTT_SEND_BUFF_LEN);
    cuccMqttReadbuf = mallocEc(CUCC_MQTT_RECV_BUFF_LEN);
    memset(cuccMqttSendbuf, 0, CUCC_MQTT_SEND_BUFF_LEN);
    memset(cuccMqttReadbuf, 0, CUCC_MQTT_RECV_BUFF_LEN);
    MQTTClientInit(&cuccMqttClient, &cuccMqttNetwork, 5000, (unsigned char *)cuccMqttSendbuf, CUCC_MQTT_SEND_BUFF_LEN, (unsigned char *)cuccMqttReadbuf, CUCC_MQTT_RECV_BUFF_LEN);
    cuccAutoRegCheckIfNeedExit(0);

    /* step2: connect cucc mqtt server with product key/product secret/device key */
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_2, P_SIG, "step2: connect cucc mqtt server....");
    if(dmCuccParam.mCuccToken[0] == 0)
    {
        if(dmCuccParam.mProductSecret[0] == 0)
        {
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_err2, P_SIG, "mProductSecret is null");
            freeEc(cuccMqttSendbuf);
            cuccMqttSendbuf = NULL;
            freeEc(cuccMqttReadbuf);
            cuccMqttReadbuf = NULL;
            slpManPlatVoteEnableSleep(cuccDmSlpHandler,SLP_SLP2_STATE); //open the sleep2 gate, it can go to sleep2 and hib state
            slpManGivebackPlatVoteHandle(cuccDmSlpHandler);
            osThreadExit();
        }

        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_2_1, P_SIG, "step2: connect cucc mqtt server with product key/product secret....");
        mqttCuccDynNoPreRegIdentity((const char *)dmCuccParam.mProductKey, (const char *)cuccCCID, (const char *)cuccIMEI, (const char *)dmCuccParam.mProductSecret, (char *)&cuccClientID, (char *)&cuccUsername, (char *)&cuccPassword);
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_cuccClientID, P_SIG, "cuccClientID=%s",cuccClientID);
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_cuccUsername, P_SIG, "cuccUsername=%s",cuccUsername);
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_cuccPassword, P_SIG, "cuccPassword=%s",cuccPassword);
        
        ret = MQTTCuccCreate(&cuccMqttClient, &cuccMqttNetwork, cuccClientID, cuccUsername, cuccPassword, CUCC_MQTT_SERVER_URL, CUCC_MQTT_SERVER_PORT, &connectData);
        cuccAutoRegCheckIfNeedExit(0);
        if(ret != 0)
        {
            for(retryCount=0; retryCount<3; retryCount++)
            {
                cuccAutoRegCheckIfNeedExit(0);
        
                ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_MQTTCuccCreate, P_SIG, "MQTTCuccCreate...retryCount=%d....", retryCount);
                ret = MQTTCuccCreate(&cuccMqttClient, &cuccMqttNetwork, cuccClientID, cuccUsername, cuccPassword, CUCC_MQTT_SERVER_URL, CUCC_MQTT_SERVER_PORT, &connectData);
                if(ret == 0)
                {
                    break;
                }
            }
        }
        if(ret != 0)
        {
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_exit, P_SIG, "MQTTCuccCreate....fail..exit..task........");
            freeEc(cuccMqttSendbuf);
            cuccMqttSendbuf = NULL;
            freeEc(cuccMqttReadbuf);
            cuccMqttReadbuf = NULL;
            slpManPlatVoteEnableSleep(cuccDmSlpHandler,SLP_SLP2_STATE); //open the sleep2 gate, it can go to sleep2 and hib state
            slpManGivebackPlatVoteHandle(cuccDmSlpHandler);
            osThreadExit();
        }
        /* step3: sub mqtt client topic, preRegist is $/sys/productKey/deviceKey/ext/regist, no preRegist is $/sys/productKey/deviceKey/ext/autoregist */
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_3, P_SIG, "step3: sub mqtt client topic, $/sys/productKey/deviceKey/ext/autoregist....");
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_MQTTCuccSubscribe, P_SIG, "MQTTCuccSubscribe....$sys/productKey/deviceKey/ext/autoregist........");
        memset(dmTopic, 0, CUCC_DM_TOPIC_LEN);
        snprintf(dmTopic, CUCC_DM_TOPIC_LEN, "$sys/%s/%s/ext/autoregist", dmCuccParam.mProductKey, (const char *)cuccIMEI);
        ret = MQTTCuccSubscribe(&cuccMqttClient, (const char* )dmTopic, QOS0, NULL);
        cuccAutoRegCheckIfNeedExit(0);
        if(ret != 0)
        {
            for(retryCount=0; retryCount<3; retryCount++)
            {
                cuccAutoRegCheckIfNeedExit(0);
                ret = MQTTCuccSubscribe(&cuccMqttClient, (const char* )dmTopic, QOS0, NULL);
                if(ret == 0)
                {
                    break;
                }
            }
        }
        
        /* step4: wait for cucc mqtt server send token */
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_4, P_SIG, "step4: wait for cucc mqtt server sending token....");
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_MQTTCuccWaitForRecv, P_SIG, "MQTTCuccWaitForRecv....$sys/productKey/deviceKey/ext/autoregist........");
        ret = MQTTCuccWaitForRecv(&cuccMqttClient, PUBLISH, 100000, &topicName, recvPayload);
        cuccAutoRegCheckIfNeedExit(0);
        if(ret == 0)
        {
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_recvPayload, P_SIG, "recvPayload=%s",recvPayload);
        
            data_start_ptr = strstr(recvPayload, "token");/*for no pre autoregist, server publish "token", for auroreist, server publish "deviceSecret"*/
            if(data_start_ptr == NULL)
            {
                cuccAutoRegCheckIfNeedExit(0);
                ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_4_2, P_SIG, "step4: get token fail and exit task....");
                freeEc(cuccMqttSendbuf);
                cuccMqttSendbuf = NULL;
                freeEc(cuccMqttReadbuf);
                cuccMqttReadbuf = NULL;
                slpManPlatVoteEnableSleep(cuccDmSlpHandler,SLP_SLP2_STATE); //open the sleep2 gate, it can go to sleep2 and hib state
                slpManGivebackPlatVoteHandle(cuccDmSlpHandler);
                osThreadExit();
            }
            else
            {
                data_start_ptr = data_start_ptr+8;
                data_end_ptr   = strstr(data_start_ptr, "\"");
                len = data_end_ptr-data_start_ptr;
                memset(cuccPassword, 0, CUCC_DM_MQTT_PASSWORD_LEN);
                memcpy(cuccPassword, data_start_ptr, len); /*for no pre autoregist, the token is password and deviceSecret*/
                memset(dmCuccParam.mCuccToken, 0, sizeof(dmCuccParam.mCuccToken));
                memcpy(dmCuccParam.mCuccToken, cuccPassword, len);
                mwNvmCfgSetAndSaveDmCuccParam(&dmCuccParam);
                ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_4_1, P_SIG, "step4: get token ok and save token....");
            }
        }
        
        /* step5: disconnect mqtt client */
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_5, P_SIG, "step5: disconnect mqtt client....");
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_MQTTCuccDisconnect, P_SIG, "MQTTCuccDisconnect............");
        MQTTCuccDisconnect(&cuccMqttClient);
    }

    /* step6: connect cucc mqtt server with product key/token */
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_6, P_SIG, "step6: connect cucc mqtt server with product key/token....");
    memset(cuccClientID, 0, CUCC_DM_MQTT_CLIENTID_LEN);
    memset(cuccUsername, 0, CUCC_DM_MQTT_USERNAME_LEN);
    mqttCuccNoPreIdentity((const char *)dmCuccParam.mProductKey, (const char *)cuccCCID, (const char *)cuccIMEI, (char *)cuccClientID, (char *)cuccUsername);
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_ClientID, P_SIG, "cuccClientID=%s",cuccClientID);
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_Username, P_SIG, "cuccUsername=%s",cuccUsername);
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_Password, P_SIG, "cuccPassword=%s",dmCuccParam.mCuccToken);
    NetworkInit(&cuccMqttNetwork);
    MQTTClientInit(&cuccMqttClient, &cuccMqttNetwork, 20000, (unsigned char *)cuccMqttSendbuf, CUCC_MQTT_SEND_BUFF_LEN, (unsigned char *)cuccMqttReadbuf, CUCC_MQTT_RECV_BUFF_LEN);
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_MQTTCuccConnect, P_SIG, "MQTTCuccConnect............");
    ret = MQTTCuccCreate(&cuccMqttClient, &cuccMqttNetwork, cuccClientID, cuccUsername, (char *)dmCuccParam.mCuccToken, CUCC_MQTT_SERVER_URL, CUCC_MQTT_SERVER_PORT, &connectData);
    //ret = MQTTCuccConnect(&cuccMqttClient, cuccClientID, cuccUsername, dmCuccParam.mCuccToken, &connectData);
    cuccAutoRegCheckIfNeedExit(0);
    if(ret != 0)
    {
        for(retryCount=0; retryCount<3; retryCount++)
        {
            cuccAutoRegCheckIfNeedExit(0);
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_ReMQTTCuccConnect, P_SIG, "MQTTCuccConnect...retryCount=%d....", retryCount);
            ret = MQTTCuccCreate(&cuccMqttClient, &cuccMqttNetwork, cuccClientID, cuccUsername, (char *)dmCuccParam.mCuccToken, CUCC_MQTT_SERVER_URL, CUCC_MQTT_SERVER_PORT, &connectData);
            if(ret == 0)
            {
                break;
            }
        }
    }
    if(ret != 0)
    {
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_6_1, P_SIG, "MQTTCuccCreate....fail..exit..task........");
        freeEc(cuccMqttSendbuf);
        cuccMqttSendbuf = NULL;
        freeEc(cuccMqttReadbuf);
        cuccMqttReadbuf = NULL;
        slpManPlatVoteEnableSleep(cuccDmSlpHandler,SLP_SLP2_STATE); //open the sleep2 gate, it can go to sleep2 and hib state
        slpManGivebackPlatVoteHandle(cuccDmSlpHandler);
        osThreadExit();
    }

    /* step7: subscribe cucc server topic property/batch_reply and deviceShadow/command */
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_7, P_SIG, "step7: subscribe cucc server topic property/batch_reply and deviceShadow/command....");
    memset(dmTopic, 0, CUCC_DM_TOPIC_LEN);
    snprintf(dmTopic, CUCC_DM_TOPIC_LEN, "$sys/%s/%s/property/batch_reply", dmCuccParam.mProductKey, (const char *)cuccIMEI);
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_batch_reply, P_SIG, "MQTTCuccSubscribe......$sys/productKey/deviceKey/property/batch_reply......");
    ret = MQTTCuccSubscribe(&cuccMqttClient, (const char* )dmTopic, QOS0, NULL);

    memset(dmTopic, 0, CUCC_DM_TOPIC_LEN);
    snprintf(dmTopic, CUCC_DM_TOPIC_LEN, "$sys/%s/%s/deviceShadow/command", dmCuccParam.mProductKey, (const char *)cuccIMEI);
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_deviceShadow, P_SIG, "MQTTCuccSubscribe......$sys/productKey/deviceKey/deviceShadow/command......");
    ret = MQTTCuccSubscribe(&cuccMqttClient, (const char* )dmTopic, QOS0, NULL);

    /* step8: send register param info to cucc server */
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_8, P_SIG, "step7: send register param info to cucc server....");
    cuccSendPayload = mallocEc(CUCC_MQTT_SEND_PAYLOAD_LEN);
    memset(cuccSendPayload, 0, CUCC_MQTT_SEND_PAYLOAD_LEN);

    memset(dmTopic, 0, CUCC_DM_TOPIC_LEN);
    snprintf(dmTopic, CUCC_DM_TOPIC_LEN, "$sys/%s/%s/property/batch", dmCuccParam.mProductKey, (const char *)cuccIMEI);

    ret = appGetUeExtStatusInfoSync(UE_EXT_STATUS_PHY, &statusInfo);
    if(ret == 0){
        cellId = statusInfo.rrcStatus.cellId;
        rsrp = statusInfo.phyStatus.sRsrp/100;
        rsrq = ((float)statusInfo.phyStatus.sRsrq)/100;
        snr = statusInfo.phyStatus.snr;
        csq = mmGetCsqRssiFromCesq(rsrp, rsrq, statusInfo.phyStatus.rssiAllBW);
        appGetAPNSettingSync(cellId, apn);
        if(apn[0]==0)
        {
            memcpy(apn, "3gnet", strlen("3gnet"));
        }
    }
    timeSyncFlag = appCheckSystemTimeSync();
    if(timeSyncFlag != 0)
    {
        for(timeSyncRetry=0; timeSyncRetry<4; timeSyncRetry++)
        {
            AppMgrSntpStart("cn.ntp.org.cn", 0, BROADCAST_IND_HANDLER, 1, LWIP_PS_INVALID_CID);
            for(i=0; i<10; i++)
            {
                timeSyncFlag = appCheckSystemTimeSync();
                if(timeSyncFlag == 0)
                {
                    break;
                }
                else
                {
                    osDelay(300);
                }
            }
            AppMgrSntpStop();
            if(timeSyncFlag == 0)
            {
                ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_Sntp2, P_SIG, "Sntp is ready....");
                break;
            }
        }
    }

    utcTimePtr = OsaSystemTimeReadUtc();
    int year =0;
    int month =0;
    int day =0;
    int hour =0;

    year  = utcTimePtr->UTCtimer1>>16&0xffff;
    month = (utcTimePtr->UTCtimer1>>8)&0xff;
    day   = utcTimePtr->UTCtimer1&0xff;
    hour = (utcTimePtr->UTCtimer2>>24)&0xff;
    if((hour+8) >= 24)
    {
        switch(month)
        {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
                day = day+1;
                if(day >31)
                {
                    month = month+1;
                    day = 1;
                    hour = (hour+8) -24;
                }
                break;

            case 4:
            case 6:
            case 9:
            case 11:
                day = day+1;
                if(day >30)
                {
                    month = month+1;
                    day = 1;
                    hour = (hour+8) -24;
                }
                break;

            case 2:
                day = day+1;
                if(((day >29)&&((year%4) == 0))||((day >28)&&((year%4) != 0)))
                {
                    month = month+1;
                    day = 1;
                    hour = (hour+8) -24;
                }
                break;

            case 12:
                day = day+1;
                if(day >31)
                {
                    month = month+1;
                    if(month > 12)
                    {
                        month = 1;
                        year = year+1;
                    }
                    day = 1;
                    hour = (hour+8) -24;
                }
                break;
        }
    }
    else
    {
        hour = hour+8;
    }
    sprintf((char *)utcTimeBuf, "%04d/%02d/%02d %02d:%02d:%02d.%03d", year, month, day, hour, (utcTimePtr->UTCtimer2>>16)&0xff, (utcTimePtr->UTCtimer2>>8)&0xff, (utcTimePtr->UTCms));
    atDataToDecString(msgId, CUCC_DM_MSG_ID_LEN, cuccDmMsgI);
    cuccDmMsgI++;

    if(rsrq <0.01)
    {
        rsrq = 0-rsrq;
        rsrqTemp = (int)(rsrq*100);
        sprintf( cuccSendPayload,
            "{\"messageId\":\"%s\",\"params\":{\"data\":[{\"key\":\"manufacturer\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleType\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleIMEI\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"chipManufacturer\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"chipType\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleSoftwareVersion\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleHardwareVersion\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"connectionMode\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleIMSI\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleICCID\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":""\"csq\",\"value\":%d,\"ts\":\"\"},{\"key\":\"rsrp\",\"value\":%d,\"ts\":\"\"},{\"key\":\"rsrq\",\"value\":-%d.%d,\"ts\":\"\"},{\"key\":\"signalECL\",\"value\":%d,\"ts\":\"\"},{\"key\":\"sinr\",\"value\":%d,\"ts\":\"\"},{\"key\":\"cellID\",\"value\":\"%lu\",\"ts\":\"\"},{\"key\":\"APN\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"longitude\",\"value\":%d,\"ts\":\"\"},{\"key\":\"latitude\",\"value\":%d,\"ts\":\"\"},{\"key\":\"altitude\",\"value\":%d,\"ts\":\"\"},{\"key\":\"moduleTime\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"internetTime\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"autoRegperiod\",\"value\":%d,\"ts\":\"\"},{\"key\":\"powerSavingMode\",\"value\":%d,\"ts\":\"\"}]}}",
            msgId,dmCuccParam.manufacture, dmCuccParam.moduleType,  cuccIMEI, dmCuccParam.chipManufacturer, dmCuccParam.chipType, dmCuccParam.moduleSWVer, dmCuccParam.moduleHWVer, "CAT1", cuccIMSI, cuccIMEI, csq, rsrp, rsrqTemp/100, (rsrqTemp%100)/10, 0, snr, cellId, apn, 120, 30, 108, utcTimeBuf, utcTimeBuf, dmCuccParam.autoRegPeriod, 0);
    }
    else
    {
        sprintf( cuccSendPayload,
            "{\"messageId\":\"%s\",\"params\":{\"data\":[{\"key\":\"manufacturer\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleType\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleIMEI\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"chipManufacturer\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"chipType\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleSoftwareVersion\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleHardwareVersion\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"connectionMode\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleIMSI\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleICCID\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":""\"csq\",\"value\":%d,\"ts\":\"\"},{\"key\":\"rsrp\",\"value\":%d,\"ts\":\"\"},{\"key\":\"rsrq\",\"value\":%d.%d,\"ts\":\"\"},{\"key\":\"signalECL\",\"value\":%d,\"ts\":\"\"},{\"key\":\"sinr\",\"value\":%d,\"ts\":\"\"},{\"key\":\"cellID\",\"value\":\"%lu\",\"ts\":\"\"},{\"key\":\"APN\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"longitude\",\"value\":%d,\"ts\":\"\"},{\"key\":\"latitude\",\"value\":%d,\"ts\":\"\"},{\"key\":\"altitude\",\"value\":%d,\"ts\":\"\"},{\"key\":\"moduleTime\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"internetTime\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"autoRegperiod\",\"value\":%d,\"ts\":\"\"},{\"key\":\"powerSavingMode\",\"value\":%d,\"ts\":\"\"}]}}",
            msgId,dmCuccParam.manufacture, dmCuccParam.moduleType,  cuccIMEI, dmCuccParam.chipManufacturer, dmCuccParam.chipType, dmCuccParam.moduleSWVer, dmCuccParam.moduleHWVer, "CAT1", cuccIMSI, cuccIMEI, csq, rsrp ,rsrqTemp/100, (rsrqTemp%100)/10, 0, snr, cellId, apn, 120, 30, 108, utcTimeBuf, utcTimeBuf, dmCuccParam.autoRegPeriod, 0);
    }

    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_MQTTCuccPublish, P_SIG, "MQTTCuccPublish......$sys/productKey/deviceKey/property/batch......");
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_cuccSendPayload, P_SIG, "cuccSendPayload:%s.",cuccSendPayload);

    message.payload = cuccSendPayload;
    message.payloadlen = strlen((char *)cuccSendPayload);
    ret = MQTTCuccPublish(&cuccMqttClient, (const char* )dmTopic, &message);
    cuccAutoRegCheckIfNeedExit(0);

    /* step9: wait to recv publish ack */
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_9, P_SIG, "step9: recv for publish ack....");
    ret = MQTTCuccWaitForRecv(&cuccMqttClient, PUBLISH, 100000, &topicName, recvPayload);
    cuccAutoRegCheckIfNeedExit(0);
    if(ret == 0)
    {
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_recv_Success, P_SIG, "recvPayload=%s",recvPayload);
        data_start_ptr = strstr(recvPayload, "Success");/*for no pre autoregist, server publish "token", for auroreist, server publish "deviceSecret"*/
        if(data_start_ptr == NULL)
        {
            cuccAutoRegCheckIfNeedExit(0);
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_9_2, P_SIG, "step9: recv publish ack....");
        }
        else
        {
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_9_1, P_SIG, "step9: recv publish ack Success ok....");
        }
        data_start_ptr = strstr(recvPayload, "autoRegperiod");/*for no pre autoregist, server publish "token", for auroreist, server publish "deviceSecret"*/
        if(data_start_ptr == NULL)
        {
            cuccAutoRegCheckIfNeedExit(0);
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_9_3, P_SIG, "step9: turn to recv autoRegperiod....");
        }
        else
        {
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_9_4, P_SIG, "step9: recv autoRegperiod ok....");
            data_start_ptr = data_start_ptr+15;
            data_end_ptr   = strstr(data_start_ptr, "}");
            len = data_end_ptr-data_start_ptr;
            cmsDecStrToInt((INT32 *)&autoRegPeriod, (UINT8 *)data_start_ptr, len);
            dmCuccParam.autoRegPeriod = autoRegPeriod;
            mwNvmCfgSetAndSaveDmCuccParam(&dmCuccParam);
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_9_5, P_SIG, "step9: recv autoRegperiod=%d....",autoRegPeriod);
            autoRegPeriodFlag = 1;
        }
    }

    /* step10: wait to recv autoRegperiod */
    if(autoRegPeriodFlag != 1)
    {
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_10, P_SIG, "step10: wait to recv autoRegperiod....");
        ret = MQTTCuccWaitForRecv(&cuccMqttClient, PUBLISH, 100000, &topicName, recvPayload);
        cuccAutoRegCheckIfNeedExit(0);
        if(ret == 0)
        {
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_recv_autoRegperiod, P_SIG, "recvPayload=%s",recvPayload);
            data_start_ptr = strstr(recvPayload, "autoRegperiod");/*for no pre autoregist, server publish "token", for auroreist, server publish "deviceSecret"*/
            if(data_start_ptr == NULL)
            {
                cuccAutoRegCheckIfNeedExit(0);
                ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_10_3, P_SIG, "step10: do not recv autoRegperiod....");
            }
            else
            {
                ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_10_1, P_SIG, "step10: recv autoRegperiod ok....");

                data_start_ptr = data_start_ptr+15;
                data_end_ptr   = strstr(data_start_ptr, "}");
                len = data_end_ptr-data_start_ptr;
                cmsDecStrToInt((INT32 *)&autoRegPeriod, (UINT8 *)data_start_ptr, len);
                dmCuccParam.autoRegPeriod = autoRegPeriod;
                mwNvmCfgSetAndSaveDmCuccParam(&dmCuccParam);
                ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_10_2, P_SIG, "step10: recv autoRegperiod=%d....",autoRegPeriod);
            }
        }
    }
    else
    {
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_10_0, P_SIG, "step10: have recv autoRegperiod already....");
    }

    /* step11: publish autoRegperiod to server */
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_11, P_SIG, "step11: publish autoRegperiod to server....");
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_Publish, P_SIG, "MQTTCuccPublish......$sys/productKey/deviceKey/deviceShadow/pub......");
    memset(dmTopic, 0, CUCC_DM_TOPIC_LEN);
    snprintf(dmTopic, CUCC_DM_TOPIC_LEN, "$sys/%s/%s/deviceShadow/pub", dmCuccParam.mProductKey, (const char *)cuccIMEI);
    memset(msgId, 0, CUCC_DM_MSG_ID_LEN);
    atDataToDecString(msgId, CUCC_DM_MSG_ID_LEN, cuccDmMsgI);
    cuccDmMsgI++;


    memset(cuccSendPayload, 0, CUCC_MQTT_SEND_PAYLOAD_LEN);
    sprintf( cuccSendPayload, "{\"messageId\":\"%s\",\"params\":{\"state\":{\"reported\":{\"autoRegperiod\":\"%d\"}}}}", msgId, dmCuccParam.autoRegPeriod);
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_11_1, P_SIG, "cuccSendPayload=%s....",cuccSendPayload);

    message.payload = cuccSendPayload;
    message.payloadlen = strlen((char *)cuccSendPayload);
    ret = MQTTCuccPublish(&cuccMqttClient, (const char* )dmTopic, &message);

    /* step12: disconnect mqtt client */
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_12, P_SIG, "step12: disconnect mqtt client....");
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_Disconnect, P_SIG, "MQTTDisconnect..............");
    MQTTDisconnect(&cuccMqttClient);

    /* step13: store cucc dm info to mw */
    if(cuccIMEI != NULL)
    {
        freeEc(cuccIMEI);
        cuccIMEI = NULL;
    }
    if(cuccIMSI != NULL)
    {
        freeEc(cuccIMSI);
        cuccIMSI = NULL;
    }
    if(cuccCCID != NULL)
    {
        freeEc(cuccCCID);
        cuccCCID = NULL;
    }
    if(cuccMqttSendbuf != NULL)
    {
        freeEc(cuccMqttSendbuf);
        cuccMqttSendbuf = NULL;
    }
    if(cuccMqttReadbuf != NULL)
    {
        freeEc(cuccMqttReadbuf);
        cuccMqttReadbuf = NULL;
    }
    if(cuccSendPayload != NULL)
    {
        freeEc(cuccSendPayload);
        cuccSendPayload = NULL;
    }

    dmCuccParam.hasReg = CUCC_HAS_REGISTER;
    dmMsg.ret = REG_OK;
    primSize = sizeof(dmMsg);
    applSendCmsInd(BROADCAST_IND_HANDLER, APPL_DM, APPL_DM_CUCC_OPEN_IND, primSize, (void *)&dmMsg);
    mwNvmCfgSetAndSaveDmCuccParam(&dmCuccParam);

    if(dmCuccParam.autoRegPeriod > 0)
    {
        //start a timer
        if(cuccDmTimer != NULL)
        {
            if(osTimerIsRunning(cuccDmTimer) == 0)
            {
                osTimerDelete(cuccDmTimer);
                cuccDmTimer = osTimerNew(cuccAutoRegisterInit, osTimerOnce, NULL, NULL);
                osTimerStart(cuccDmTimer, (dmCuccParam.autoRegPeriod*2000));
            }
            else
            {
                osTimerStop(cuccDmTimer);
                osTimerDelete(cuccDmTimer);
                cuccDmTimer = osTimerNew(cuccAutoRegisterInit, osTimerOnce, NULL, NULL);
                osTimerStart(cuccDmTimer, (dmCuccParam.autoRegPeriod*2000));
            }
        }
        else
        {
            cuccDmTimer = osTimerNew(cuccAutoRegisterInit, osTimerOnce, NULL, NULL);
            osTimerStart(cuccDmTimer, (dmCuccParam.autoRegPeriod*2000));
        }
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_TimerStart, P_SIG, "autoReg cuccDmTimer start, tick=%d", (dmCuccParam.autoRegPeriod*2000));
    }
    else
    {
        slpManPlatVoteEnableSleep(cuccDmSlpHandler,SLP_SLP2_STATE); //open the sleep2 gate, it can go to sleep2 and hib state
        slpManGivebackPlatVoteHandle(cuccDmSlpHandler);
    }
    ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_exitAll, P_SIG, "autoReg will exit");

    osThreadExit();
}

#define CUCC_DM_AUTOREG_TASK_END

void cuccDmAutoRegInitTask(void)
{
    osThreadAttr_t task_attr;
    memset(&task_attr, 0, sizeof(task_attr));

    task_attr.name = "cuDmTask";
    task_attr.stack_size = CUCC_AUTO_REG_TASK_STACK_SIZE;
    task_attr.priority = osPriorityBelowNormal5;
#ifdef TYPE_EC718M
    task_attr.reserved = osThreadDynamicStackAlloc;
#endif

    ECPLAT_PRINTF(UNILOG_DM, cuccDmAutoRegInitTask0, P_SIG, "autoReg..starting task ");

    cuccDmAutoRegisterTaskHandle= osThreadNew(cuccAutoRegisterTask, NULL,&task_attr);
    if(cuccDmAutoRegisterTaskHandle == NULL)
    {
        if(slpManGivebackPlatVoteHandle(cuccDmSlpHandler) != RET_TRUE)
        {
            ECPLAT_PRINTF(UNILOG_DM, cuccDmAutoRegInitTask1, P_ERROR, "CUCC_DM vote handle give back failed");
        }
        else
        {
            ECPLAT_PRINTF(UNILOG_DM, cuccDmAutoRegInitTask2, P_VALUE, "CUCC_DM vote handle give back success");
        }
    }
}

INT32 cuccDmNetWorkStatusCallback(PsEventID eventID, void *param, UINT32 paramLen)
{
    NmAtiNetInfoInd *netif = NULL;
    dmInterMsg dmMsg;
    CmiSimImsiStr *imsi = NULL;

    memset(&dmMsg, 0, sizeof(dmInterMsg));
    switch(eventID)
    {
        case PS_URC_ID_PS_NETINFO:
        {
            netif = (NmAtiNetInfoInd *)param;
            if (netif->netifInfo.netStatus == NM_NETIF_ACTIVATED)
            //if ((netif->netStatus == NM_NETIF_OOS)||(netif->netStatus == NM_NETIF_ACTIVATED))
            {
                dmMsg.cmdType = DM_MSG_NETWORK_READY;
                if(dmMsgHandle != NULL)
                {
                    xQueueSend(dmMsgHandle, &dmMsg, DM_MSG_TIMEOUT);
                    ECPLAT_PRINTF(UNILOG_DM, cuccDmNetWorkStatusCallback_1, P_INFO, "dm network is ready");
                }
                else
                {
                    ECPLAT_PRINTF(UNILOG_DM, cuccDmNetWorkStatusCallback_2, P_ERROR, "dm network dmMsgHandle is NULL");
                }
            }
            break;
        }

        case PS_URC_ID_SIM_READY:
        {
            imsi = (CmiSimImsiStr *)param;
            memcpy(dmMsg.imsi, imsi->contents, imsi->length);

            dmMsg.cmdType = DM_MSG_SIM_READY;
            if(dmMsgHandle != NULL)
            {
                xQueueSend(dmMsgHandle, &dmMsg, DM_MSG_TIMEOUT);
                ECPLAT_PRINTF(UNILOG_DM, cuccDmNetWorkStatusCallback_3, P_INFO, "dm sim is ready");
            }
            else
            {
                ECPLAT_PRINTF(UNILOG_DM, cuccDmNetWorkStatusCallback_4, P_ERROR, "dm sim dmMsgHandle is NULL");
            }
            break;
        }

        default:
            break;
    }
    return 0;
}

void cuccAutoRegPreInitTask(void *argument)
{
    UINT8 imsiReadyFlag = 0;
    UINT8 networkReadyFlag = 0;
    UINT8 cfun = 0xff;
    INT32 msgWaitCount = 60;
    UINT8 imei[IMEI_LEN+1] = {0};
    UINT8 imsi[IMSI_LEN+1] = {0};
    UINT8 flashCCID[CCID_LEN+1] = {0};
    UINT8 simCCID[CCID_LEN+1]   = {0};
    dmInterMsg dmMsg;
    MWNvmCfgDmCuccParam dmCuccParam;
    INT32 len = 0;
    INT32 timeSyncFlag = 0xff;
    INT32 timeSyncRetry = 0;
    INT32 i=0;
    NmAtiNetifInfo  netInfo;

    memset(&dmCuccParam, 0, sizeof(dmCuccParam));
    mwNvmCfgGetDmCuccParam(&dmCuccParam);
    if(dmCuccParam.autoRegPeriod == CUCC_AUTO_REG_PERIOD_DISABLE)
    {
        osThreadExit();
    }
    if((dmCuccParam.autoRegPeriod == CUCC_AUTO_REG_PERIOD_TYPE1)&&(dmCuccParam.hasReg == CUCC_HAS_REGISTER))
    {
        osThreadExit();
    }

    memset(&dmMsg, 0, sizeof(dmInterMsg));
    dmMsgHandle = xQueueCreate(DM_MSG_MAX_NUMB, sizeof(dmInterMsg));
    registerPSEventCallback(PS_GROUP_ALL_MASK, cuccDmNetWorkStatusCallback);
    NetMgrGetNetInfo(LWIP_PS_INVALID_CID,&netInfo);
    if(netInfo.netStatus == NM_NETIF_ACTIVATED)
    {
        //turn to next 
        appGetImsiNumSync((CHAR *)imsi);
        appGetIccidNumSync((CHAR *)simCCID);
        appGetImeiNumSync((CHAR *)imei);
    }
    else
    {
        while(msgWaitCount)
        {
            xQueueReceive(dmMsgHandle, &dmMsg, DM_MSG_RECV_TIMEOUT);
        
            switch(dmMsg.cmdType)
            {
                case DM_MSG_NETWORK_READY:
                    networkReadyFlag = 1;
                    appGetCFUN(&cfun);
                    ECPLAT_PRINTF(UNILOG_DM, cuccAutoRegisterTask0, P_INFO, "dm network is ready %d %d", networkReadyFlag, cfun);
                    break;
        
                case DM_MSG_SIM_READY:
                    imsiReadyFlag = 1;
                    memcpy(imsi, dmMsg.imsi, strlen((const char*)dmMsg.imsi));
                    appGetCFUN(&cfun);   //for CTCC CUCC DM, it need wait for nerwork ready
                    ECPLAT_PRINTF(UNILOG_DM, cuccAutoRegisterTask1, P_INFO, "dm sim is ready %d %d", imsiReadyFlag, cfun);
                    break;
        
                default:
                    break;
            }
            msgWaitCount--;
        
            if((networkReadyFlag == 1)&&(imsiReadyFlag == 1))
            {
                break;
            }
        
            if((networkReadyFlag != 1)||(imsiReadyFlag != 1))
            {
                appGetCFUN(&cfun);
                if(cfun == 0) //at+cfun = 0
                {
                    break;
                }
            }
        }
        
        appGetCFUN(&cfun);
        
        if((networkReadyFlag != 1)||(imsiReadyFlag != 1)||(cfun == 0))
        {
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoRegisterTask2, P_INFO, "dm network or sim is not ready %d %d", networkReadyFlag, cfun);
            if(dmMsgHandle != NULL)
            {
                deregisterPSEventCallback(cuccDmNetWorkStatusCallback);
                vQueueDelete(dmMsgHandle);
                dmMsgHandle = NULL;
            }
            osThreadExit();
        }
    }


    //AppMgrResult AppMgrSntpStart(CHAR *server, UINT16 port, UINT16 reqHandler, BOOL autoSync, UINT8 cid)
    for(timeSyncRetry=0; timeSyncRetry<4; timeSyncRetry++)
    {
        AppMgrSntpStart("cn.ntp.org.cn", 0, BROADCAST_IND_HANDLER, 1, LWIP_PS_INVALID_CID);
        for(i=0; i<10; i++)
        {
            timeSyncFlag = appCheckSystemTimeSync();
            if(timeSyncFlag == 0)
            {
                break;
            }
            else
            {
                osDelay(300);
            }
        }
        AppMgrSntpStop();
        if(timeSyncFlag == 0)
        {
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_Sntp, P_SIG, "Sntp is ready....");
            break;
        }
    }
    //if((imsi[0] == '4')&&(imsi[1] == '6')&&(imsi[2] == '0'))
	if(1)
    {
        //if(((imsi[3] == '0')&&(imsi[4] == '1')) || ((imsi[3] == '0')&&(imsi[4] == '6')))
		if(1)
        {
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk0, P_SIG, "autoReg this is CUCC SIM card");

            /* if imei is not set, use default imei, but the api will return false */
            OsaGetImeiNumSync((CHAR *)imei);
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk1, P_SIG, "autoReg get imei ok, imei is %s", (UINT8 *)imei);
            appGetIccidNumSync((CHAR *)simCCID);
            //mwGetSimCcidValue(flashCCID, CCID_LEN);

            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk2, P_SIG, "autoReg get imsi is %s", (UINT8 *)imsi);
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk3, P_SIG, "autoReg get current iccid is %s", (UINT8 *)simCCID);
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk4, P_SIG, "autoReg get previous iccid is %s", (UINT8 *)flashCCID);

            /* check ccid, and start auto register */
            if((strcmp((CHAR *)dmCuccParam.ccid, (CHAR *)simCCID) != 0)
                ||(strcmp((CHAR *)dmCuccParam.imsi, (CHAR *)imsi) != 0)
                ||(strcmp((CHAR *)dmCuccParam.imei, (CHAR *)imei) != 0))
            {
                cuccIMEI = mallocEc(IMEI_LEN);
                memset(cuccIMEI, 0, IMEI_LEN);
                cuccIMSI = mallocEc(IMSI_LEN);
                memset(cuccIMSI, 0, IMSI_LEN);
                cuccCCID = mallocEc(CCID_LEN);
                memset(cuccCCID, 0, CCID_LEN);
                len = strlen((const char *)imei);
                memcpy(cuccIMEI, imei, len);
                len = strlen((const char *)imsi);
                memcpy(cuccIMSI, imsi, len);
                len = strlen((const char *)simCCID);
                memcpy(cuccCCID, simCCID, len);

                ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk5, P_SIG, "autoReg find new sim iccid, start auto register");
                cuccDmAutoRegInitTask();
            }
            else
            {
                ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk6, P_SIG, "autoReg find same sim iccid");
                ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk7, P_SIG, "autoReg is enable, start register");
                cuccDmAutoRegInitTask();
            }
        }
        else
        {
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk8, P_SIG, "autoReg this MNC is not supported SIM card");
        }
    }
    else
    {
        ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk9, P_SIG, "autoReg the SIM card is %s, it is not '460' SIM card, exit now", (UINT8 *)imsi);
    }

    if(dmMsgHandle != NULL)
    {
        deregisterPSEventCallback(cuccDmNetWorkStatusCallback);
        vQueueDelete(dmMsgHandle);
        dmMsgHandle = NULL;
    }
    osThreadExit();
}

void cuccAutoRegisterInit(void *argument)
{
    osThreadAttr_t task_attr;
    memset(&task_attr, 0, sizeof(task_attr));

    slpManApplyPlatVoteHandle("cuccDm",&cuccDmSlpHandler);

    task_attr.name = "cuccAutoReg";
    task_attr.stack_size = CUCC_AUTO_REG_TASK_STACK_SIZE;
    task_attr.priority = osPriorityBelowNormal5;
#ifdef TYPE_EC718M
    task_attr.reserved = osThreadDynamicStackAlloc;
#endif

    ECPLAT_PRINTF(UNILOG_DM, cuccAutoRegisterInit0, P_SIG, "autoReg..starting task ");

    cuccAutoRegisterTaskHandle= osThreadNew(cuccAutoRegPreInitTask, NULL,&task_attr);
    if(cuccAutoRegisterTaskHandle == NULL)
    {
        if(slpManGivebackPlatVoteHandle(cuccDmSlpHandler) != RET_TRUE)
        {
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoRegisterInit1, P_ERROR, "CUCC_DM vote handle give back failed");
        }
        else
        {
            ECPLAT_PRINTF(UNILOG_DM, cuccAutoRegisterInit2, P_VALUE, "CUCC_DM vote handle give back success");
        }
    }
}