#include "carlink_ec.h"
#include "os_adapt.h"
#include <FreeRTOS_POSIX.h>
#include <task.h>
#include "FreeRTOS_IP.h"
#include "FreeRTOS_IP_Private.h"
#include "FreeRTOS_Sockets.h"
#include "FreeRTOS_DHCP.h"
#include "FreeRTOS_DHCP_Server.h"
#include <FreeRTOS_IP.h>
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <FreeRTOS_Sockets.h>
#include <stdbool.h>
#include <stdio.h>
#include "board.h"
#include "timer.h"
#include "iot_wifi.h"
#include "mmcsd_core.h"
#include "carlink_video.h"
#include "carlink_utils.h"
#include "console.h"
#include "fsc_bt.h"
#include "sfud.h"

//#define CARLINK_EC 1
#if CARLINK_EC
//------ ECTiny code begin ------
#define USE_ECTINY_CODE			/*测试 ECTiny 代码 */

#ifdef USE_ECTINY_CODE
#ifdef  __cplusplus
extern "C" {
#endif

#include "ECTiny.h"
#include "ECTypes.h"

#ifdef  __cplusplus
};
#endif

#define AP_NO_PASSWD    0

#define printf_func   printf

#define FLASH_PRIV_TYPE_BYTE 0x1000
#define EC_FLASH_OFFSET           0X38000


#define EC_EVENT_BT_CONNECT               	0
#define EC_EVENT_BT_DISCONNECT            1
#define EC_EVENT_BT_DATA            		2
#define EC_EVENT_CLIENT_DHCP_READY	3
#define EC_EVENT_BUILD_NET_OK			4
#define EC_EVENT_WIFI_DISCONNECT			5
#define EC_EVENT_WIFI_CONNECT			    6

struct ec_event
{
	int type;
	union {
		int len;
		void* data;
		uint8_t para[32];
	}u;
};

static TaskHandle_t       ec_network_task = NULL;
static TaskHandle_t ec_ap_task = NULL;
static TaskHandle_t ec_sta_task = NULL;
static SemaphoreHandle_t ec_sta_sem = NULL;
static bool g_wifi_sta_inited = false;
static bool mInited = false;
static bool g_bt_mac_ready = false;
static char g_bt_mac[13] = {0};
static ECConfigHandle mECTinyCfg = NULL;
static IECCallBack* mECTinyCallback = NULL;
static IECVideoPlayer* mECTinyVideoPlayer = NULL;

static const uint8_t        ucIPAddress[4] = {192, 168, 13, 1};
static const uint8_t        ucNetMask[4] = {255, 255, 255, 0};
static const uint8_t        ucGatewayAddress[4] = {0, 0, 0, 0};
static const uint8_t        ucDNSServerAddress[4] = {8, 8, 8, 8};
static const uint8_t        ucMACAddress[6] = {0x30, 0x4a, 0x26, 0x78, 0xfd, 0x12};
static uint8_t                ap_ssid[64]     = {"ap63011"};
static uint8_t                ap_passwd[16]  = {"88888888"};
//static int g_dhcp_ready = 0;
static char g_ip_str[32] = {0};
static uint8_t                gphone_type = 0;
static ring_buffer_t ble_ring_data;
static QueueHandle_t     ec_event_queue = NULL;
static IECAccessDevice bleDev;
static IECAccessFile accessFile;
ECBTNetInfo gNetDeviceInfo = {0};
static ECQRInfo qr_info;

//extern uint8_t gDayNight;
static void ec_reset_wifi_ap_info(const char *btmac);


pthread_mutex_t bufLocker =     {                                        \
        .xIsInitialized = pdFALSE,           \
        .xMutex = { { 0 } },                 \
        .xTaskOwner = NULL,                  \
        .xAttr = { .iType = 0 }              \
    };

void onECConnectStatus(ECConnectedStatus status, ECConnectedType type)
{
    printf("\r\nite onECConnectStatus:status=%d,type=%d", status, type);
    if (status == EC_CONNECT_STATUS_CONNECT_SUCCEED)
    {
        //EC_uploadNightModeStatus(gDayNight);
        EC_startMirror();

        //EC_startIperfTcpServer("192.168.43.103",11150);
    }
}

void onMirrorStatus(ECMirrorStatus status)
{
    printf("\r\nonMirrorStatus:status=%d\r\n", status);
}

void onECStatusMessage(ECStatusMessage status)
{
    printf("\r\nITE onECStatusMessage:status=%d\r\n", status);
}

void onPhoneAppHUD(const ECNavigationHudInfo *data)
{
    printf("\r\nECNavigationHudInfo\r\n");
}

void onPhoneAppMusicInfo(const ECAppMusicInfo *data)
{
    printf("\r\nonPhoneAppMusicInfo\r\n");
}

void onPhoneAppInfo(const void *data, uint32_t length)
{
    printf("\r\nonPhoneAppInfo\r\n");
}

void onCallAction(ECCallType type, const char *name, const char *number)
{
    printf("\r\nonCallAction\r\n");
}

void onBulkDataReceived(const void *data, uint32_t length)
{
    printf("onBulkDataReceived\r\n");
}

void onMirrorInfoChanged(const ECVideoInfo *info)
{
    printf("\r\nonMirrorInfoChanged\r\n");
}

void onLicenseAuthFail(int32_t errCode, const char *errMsg)
{
    printf("\r\nonLicenseAuthFail\r\n");
}

void onLicenseAuthSuccess(int32_t code, const char *msg)
{
    printf("\r\nonLicenseAuthSuccess\r\n");
}

void onCarCmdNotified(const ECCarCmd *carCmd)
{
    printf("\r\nonCarCmdNotified\r\n");
}

void onInputStart(const ECInputInfo *info)
{
    printf("\r\nonInputStart\r\n");
}

void onInputCancel()
{
    printf("\r\nonInputCancel\r\n");
}

void onInputSelection(int32_t start, int32_t stop)
{
    printf("\r\nonInputSelection\r\n");
}

void onInputText(const char *text)
{
    printf("\r\nonInputText\r\n");
}

void onVRTextReceived(const ECVRTextInfo *info)
{
    printf("\r\nonVRTextReceived\r\n");
}

void onPageListReceived(const ECPageInfo *pages, int32_t length)
{
    printf("\r\nonPageListReceived\r\n");
}

void onPageIconReceived(const ECIconInfo *icons, int32_t length)
{
    printf("\r\nonPageIconReceived\r\n");
}

void onWeatherReceived(const char *data, int32_t length)
{
    printf("\r\nonWeatherReceived\r\n");

}

void onVRTipsReceived(const char *data, int32_t length)
{
    printf("\r\nonVRTipsReceived\r\n");
}

void  start_ap_thd(void* param) {
    int channel = 36;
#ifdef AP_USE_AUTO_CHANNEL
    int autoChannel = 0;
    uint8_t channelNum = sizeof(channel_set)/sizeof(channel_set[0]);
    autoChannel = wext_get_auto_chl("wlan0",channel_set, channelNum);
    if (autoChannel >= channel_set[0] && autoChannel <= channel_set[channelNum-1])
    {
        channel = autoChannel;
    }
    printf("start_ap_thd channel:%d, autoChannel:%d\n", channel, autoChannel);
#endif
#if !AP_NO_PASSWD
    int ret = start_ap(channel, (const char *)ap_ssid, (const char *)ap_passwd, 1);
#else
    int ret = start_ap(channel, (const char *)ap_ssid, "", 0);
#endif
	printf(" start_ap_thd_ret=%d\r\n",ret);

	vTaskDelete(NULL);
}

void start_sta_thd(void* param)
{
	xSemaphoreTake(ec_sta_sem, portMAX_DELAY );
	printf("------ start_sta_thd ssid=[%s],pwd=[%s] ------\r\n",gNetDeviceInfo.ssid, gNetDeviceInfo.pwd);
	if (!g_wifi_sta_inited) {
        printf("start_sta_thd init\r\n");
		g_wifi_sta_inited = true;
		wifi_initialize(eWiFiModeStation);// load wifi driver
        xSemaphoreGive(ec_sta_sem);
	} else {
		char ssid[32] = {0};
    	char pwd[16]  = {0};
		int ret = -1;
		strcpy(ssid, gNetDeviceInfo.ssid);
		strcpy(pwd, gNetDeviceInfo.pwd);
        printf("start_sta_thd start\r\n");
        xSemaphoreGive(ec_sta_sem);
		ret = start_sta(ssid, pwd, 1);
		if (ret != 0) {
			printf("start sta failed\r\n");
			xSemaphoreTake(ec_sta_sem, portMAX_DELAY );
			memset(&gNetDeviceInfo, 0, sizeof(gNetDeviceInfo));
			xSemaphoreGive(ec_sta_sem);
		}
	}

	vTaskDelete(NULL);
}

void onRequestBuildNet(const ECBTClientInfo *clientInfo)
{
    printf("onRequestBuildNet-----------------------\r\n");
    printf("TRACE[%s][%d]:",__func__ ,__LINE__);
	ECBTRequestBuildNetRly rpy;
	memset((void *)&rpy.netDeviceInfo, 0, sizeof(rpy.netDeviceInfo));
	printf("packageName        %s\r\n", clientInfo->packageName);
	printf("phoneName           %s\r\n", clientInfo->phoneName);
	printf("phoneID               %s\r\n", clientInfo->phoneID);
	printf("phoneType            %d\r\n", clientInfo->phoneType);
	printf("version                 %d\r\n", clientInfo->version);
    printf("TRACE[%s][%d]:",__func__ ,__LINE__);
	if (clientInfo->phoneType == 0) {// android
		rpy.status = EC_BT_REQUEST_BUILD_NET_USE_PHONE_AP;
		gphone_type = 0;

        printf("TRACE[%s][%d]:",__func__ ,__LINE__);
        EC_setRequestBuildNetRly(clientInfo->phoneID, &rpy);
        printf("TRACE[%s][%d]:",__func__ ,__LINE__);

        printf("TRACE[%s][%d]:",__func__ ,__LINE__);
        xSemaphoreTake(ec_sta_sem, portMAX_DELAY );
        g_wifi_sta_inited = false;
        memset(&gNetDeviceInfo, 0, sizeof(gNetDeviceInfo));
        xSemaphoreGive(ec_sta_sem);
        xTaskCreate(start_sta_thd, "ecThread", 2048 *4, NULL, configMAX_PRIORITIES / 4, &ec_sta_task);
        printf("TRACE[%s][%d]:",__func__ ,__LINE__);

	} else if (clientInfo->phoneType == 1) {//iphone
            printf("------ onRequestBuildNet begin\r\n");
            gphone_type = 1;
            rpy.status = EC_BT_REQUEST_BUILD_NET_NEED_PHONE_BUILD;
#if !AP_NO_PASSWD
            strcpy(rpy.netDeviceInfo.ssid, (char *)ap_ssid);
            strcpy(rpy.netDeviceInfo.pwd, (char *)ap_passwd);
            strcpy(rpy.netDeviceInfo.auth, "WAP2");
#else
	     strcpy(rpy.netDeviceInfo.ssid, (char *)ap_ssid);
            //strcpy(rpy.netDeviceInfo.pwd, (char *)ap_passwd);
            //strcpy(rpy.netDeviceInfo.auth, "");
#endif

        printf("TRACE[%s][%d]:",__func__ ,__LINE__);
        EC_setRequestBuildNetRly(clientInfo->phoneID, &rpy);
        printf("TRACE[%s][%d]:",__func__ ,__LINE__);
            xTaskCreate(start_ap_thd, "ecThread", 2048 *4, NULL, configMAX_PRIORITIES / 4, &ec_ap_task);

            printf("------ onRequestBuildNet end\r\n");
	}
}


void onRequestBuildNetCancel()
{
}


void onPhoneBuildNetFinish()
{
	struct ec_event ev = {0};
	ev.type = EC_EVENT_BUILD_NET_OK;

	if (-1 != ev.type && NULL != ec_event_queue) {
		xQueueSend(ec_event_queue, &ev, 0);
	}
}

void  onPhoneAPInfo(const ECBTNetInfo* netDeviceInfo)
{
    printf("------ onPhoneAPInfo ------\r\n");
    printf("onPhoneAPInfo ssid=[%s]\r\n",netDeviceInfo->ssid);
    printf("onPhoneAPInfo pwd=[%s]\r\n",netDeviceInfo->pwd);
    printf("onPhoneAPInfo auth=[%s]\r\n",netDeviceInfo->auth);
    printf("onPhoneAPInfo mac=[%s]\r\n",netDeviceInfo->mac);
    printf("onPhoneAPInfo name=[%s]\r\n",netDeviceInfo->name);
    printf("onPhoneAPInfo action=[%u]\r\n",netDeviceInfo->action);
    printf("------ onPhoneAPInfo ------\r\n");

	xSemaphoreTake(ec_sta_sem, portMAX_DELAY );
	if (!memcmp(netDeviceInfo->ssid, gNetDeviceInfo.ssid, strlen(netDeviceInfo->ssid) + 1) && 
		!memcmp(netDeviceInfo->pwd, gNetDeviceInfo.pwd, strlen(netDeviceInfo->pwd) + 1)) {
		xSemaphoreGive(ec_sta_sem);
		printf("recv same ssid info \r\n");
		return;
	}

    memset(&gNetDeviceInfo,0,sizeof(gNetDeviceInfo));
    strcpy(gNetDeviceInfo.ssid,netDeviceInfo->ssid);
    strcpy(gNetDeviceInfo.pwd,netDeviceInfo->pwd);
	xSemaphoreGive(ec_sta_sem);

//    static bool bRunOnce = true;
//    if(bRunOnce) {
	//start_sta(gNetDeviceInfo.ssid, gNetDeviceInfo.pwd, 1);
	xTaskCreate(start_sta_thd, "ecThread", 2048 *4, NULL, configMAX_PRIORITIES / 4, NULL);
//        bRunOnce = false;
//    }
}


IECCallBack * registerECCallback()
{
	IECCallBack * callBack = (IECCallBack*)malloc(sizeof(IECCallBack));
	memset(callBack, 0, sizeof(IECCallBack));
	callBack->onECConnectStatus = onECConnectStatus;
	callBack->onMirrorStatus = onMirrorStatus;
	callBack->onECStatusMessage = onECStatusMessage;
	callBack->onPhoneAppHUD = onPhoneAppHUD;
	callBack->onPhoneAppInfo = onPhoneAppInfo;
	callBack->onPhoneAppMusicInfo = onPhoneAppMusicInfo;
	callBack->onCallAction = onCallAction;
	callBack->onBulkDataReceived = onBulkDataReceived;
	callBack->onMirrorInfoChanged = onMirrorInfoChanged;
	callBack->onLicenseAuthFail = onLicenseAuthFail;
	callBack->onLicenseAuthSuccess = onLicenseAuthSuccess;
	callBack->onCarCmdNotified = onCarCmdNotified;
	callBack->onInputStart = onInputStart;
	callBack->onInputCancel = onInputCancel;
	callBack->onInputSelection = onInputSelection;
	callBack->onInputText = onInputText;
	callBack->onVRTextReceived = onVRTextReceived;
	callBack->onPageListReceived = onPageListReceived;
	callBack->onPageIconReceived = onPageIconReceived;
	callBack->onWeatherReceived = onWeatherReceived;
	callBack->onVRTipsReceived = onVRTipsReceived;
	callBack->onRequestBuildNet = onRequestBuildNet;
	callBack->onRequestBuildNetCancel = onRequestBuildNetCancel;
	callBack->onPhoneBuildNetFinish = onPhoneBuildNetFinish;
	callBack->onPhoneAPInfo = onPhoneAPInfo;

    return callBack;
}
void unregisterECCallback(IECCallBack * callBack)
{
    if (callBack)
    {
        free(callBack);
        callBack = NULL;
    }
}

//static uint32_t gts = 0;
// video player begin
void    vp_start(int32_t width, int32_t height)
{
    printf("\r\nstart VideoPlayer,width=%d,height=%d\r\n", width, height);
    
    h264_dec_ctx_init();
    //gts = get_timer(0);
    set_carlink_display_state(1);
}

void    vp_stop()
{
    //video_frame_s* frame = NULL;
    printf("\r\nstop VideoPlayer\r\n");

    set_carlink_display_state(0);
}

void    vp_play(const void *data, uint32_t read_len)
{
    //printf("\r\nplay VideoPlayer len = %d ts:%d ms\r\n", read_len, (get_timer(0) -gts) / 1000);
    //gts = get_timer(0);
    video_frame_s* frame = NULL;

get_retry:
    frame = get_h264_frame_buf();
    if (NULL == frame) {
        //printf("h264 frame is empty\r\n");
        vTaskDelay(pdMS_TO_TICKS(10));
        goto get_retry;
        //continue;
    }

    memcpy(frame->cur, data, read_len);
    frame->len     = read_len;

    notify_h264_frame_ready(&frame);
}

IECVideoPlayer * registerVideoPlayer()
{
    IECVideoPlayer* videoPlayer = (IECVideoPlayer*)malloc(sizeof(IECVideoPlayer));
    videoPlayer->start = vp_start;
    videoPlayer->stop = vp_stop;
    videoPlayer->play = vp_play;

    return videoPlayer;
}

void unregisterVideoPlayer(IECVideoPlayer* player)
{
    if (player)
    {
        player->stop();

        free(player);
        player = NULL;
    }
}

// Ôö¼ÓÒÚÁªµÄÊý¾Ý¶Áд½Ó¿Ú
uint32_t ec_access_size(const char* name)
{
    printf_func("TRACE[%s][%d]:name=%s\r\n",__func__ ,__LINE__,name);

    int32_t ret = 0;
    char num[5] = {0};
    sfud_flash *sflash = sfud_get_device(0);
    if( SFUD_SUCCESS == sfud_read(sflash, EC_FLASH_OFFSET, 4, (uint8_t *)num) )
    {
        ret = atoi(num);
        if (ret >= FLASH_PRIV_TYPE_BYTE)
        {
          printf_func("TRACE[%s][%d]:ec_access_size sfud_read error,clear name:%s ret:%d\r\n",__func__ ,__LINE__,name,ret);
            ret = 0;
        }
    }
    else
    {
        ret = 0;
    }

    printf_func("TRACE[%s][%d]:name=[%s],ret=%d\r\n",__func__ ,__LINE__,name,ret);
	return ret;
}

static int32_t ec_access_read(const char* name,void *data, uint32_t length)
{
    printf_func("TRACE[%s][%d]1:len=%d\r\n",
           __func__ ,__LINE__,length);

    int32_t ret = 0;
    char num[5] = {0};
    uint8_t* readData = malloc(FLASH_PRIV_TYPE_BYTE);
    memset(readData,0,sizeof(FLASH_PRIV_TYPE_BYTE));
    sfud_flash *sflash = sfud_get_device(0);
    if( SFUD_SUCCESS == sfud_read(sflash, EC_FLASH_OFFSET, FLASH_PRIV_TYPE_BYTE, readData) )
    {
        memcpy(num,readData,4);
        ret = atoi(num);
        if(ret == length)
        {
            memcpy(data,readData+4,length);
        }
        else
        {
            ret = 0;
        }
    }

    printf_func("TRACE[%s][%d]2:data=[%s],ret=%d\r\n",
           __func__ ,__LINE__,(char*)data,ret);

    free(readData);

    return ret;
}

static int32_t ec_access_write(const char* name,void *data, uint32_t length)
{
    printf_func("TRACE[%s][%d]1:data=[%s],len=%d\r\n",
                __func__ ,__LINE__,(char*)data,length);

    int32_t  ret = 0;
    char* writeData = malloc(length+4);
    sprintf(writeData,"%04d%s",length, (char*)data);
    sfud_flash *sflash = sfud_get_device(0);
    sfud_erase(sflash, EC_FLASH_OFFSET, FLASH_PRIV_TYPE_BYTE);
    if( SFUD_SUCCESS == sfud_erase_write(sflash, EC_FLASH_OFFSET, length+4, (void*)writeData) )
    {
        ret = length;
    }

    free(writeData);
    printf_func("TRACE[%s][%d]2:ret=%d\r\n",
                __func__ ,__LINE__,ret);
    return ret;
}

static void ec_access_clear(const char* name)
{
    sfud_flash *sflash = sfud_get_device(0);
    sfud_erase(sflash, EC_FLASH_OFFSET, FLASH_PRIV_TYPE_BYTE);
    printf_func("TRACE[%s][%d]1:name=[%s]\r\n",
                __func__ ,__LINE__,name);
}


void ec_wifi_event_handler( WIFIEvent_t * xEvent )
{
    WIFIEventType_t xEventType = xEvent->xEventType;

    if (0) {
    } else if (eWiFiEventConnected                    == xEventType) {// meter is sta
        printf("\r\n The meter is connected to ap \r\n");
		struct ec_event ev = {0};
		ev.type = EC_EVENT_WIFI_CONNECT;

		if (-1 != ev.type && NULL != ec_event_queue) {
			xQueueSend(ec_event_queue, &ev, 0);
		}
    } else if (eWiFiEventDisconnected                == xEventType) {// meter is sta
        printf("\r\n The meter is disconnected from ap \r\n");
		struct ec_event ev = {0};
		ev.type = EC_EVENT_WIFI_DISCONNECT;

		if (-1 != ev.type && NULL != ec_event_queue) {
			xQueueSend(ec_event_queue, &ev, 0);
		}
    } else if (eWiFiEventAPStationConnected       == xEventType) {// meter is ap
        printf("\r\n The meter in AP is connected by sta %s \r\n", xEvent->xInfo.xAPStationConnected.ucMac);
    } else if (eWiFiEventAPStationDisconnected   == xEventType) {// meter is ap
        printf("\r\n The sta %s is disconnected from the meter \r\n", xEvent->xInfo.xAPStationDisconnected.ucMac);
    }
}

#if ( ipconfigUSE_DHCP_HOOK != 0 )
eDHCPCallbackAnswer_t xApplicationDHCPHook( eDHCPCallbackPhase_t eDHCPPhase,
                                            uint32_t ulIPAddress )
{
	eDHCPCallbackAnswer_t eReturn;
	struct ec_event ev = {0};

	sprintf(g_ip_str, "%d.%d.%d.%d\r\n", (ulIPAddress >> 0) & 0xFF, 
	(ulIPAddress >> 8) & 0xFF, (ulIPAddress >> 16) & 0xFF, (ulIPAddress >> 24) & 0xFF);
	printf("\r\n  eDHCPPhase:%d  ulIPAddress:%s state:%d \r\n", eDHCPPhase, g_ip_str, getDhcpClientState());
	if (getDhcpClientState() == 0)
	return eDHCPStopNoChanges;

	switch( eDHCPPhase )
	{
	case eDHCPPhaseFinished:
		//g_dhcp_ready = 1;
		ev.type = EC_EVENT_CLIENT_DHCP_READY;

		if (-1 != ev.type && NULL != ec_event_queue) {
			xQueueSend(ec_event_queue, &ev, 0);
		}
		eReturn = eDHCPContinue;
	break;
	case eDHCPPhasePreDiscover  :
		eReturn = eDHCPContinue;
	break;

	case eDHCPPhasePreRequest  :
		eReturn = eDHCPContinue;
	break;
	default :
		eReturn = eDHCPContinue;
	break;
	}

	return eReturn;
}
#endif
int32_t ec_ble_write(void * data, uint32_t len);
int32_t ec_ble_read(void * data, uint32_t len);
int32_t ec_ble_open();
void ec_ble_close();
extern char strQrText[200];
void* initECTiny(void* param)
{
    char uuid[32] = {0};
    if (mInited)
    {
        printf("\r\n------ ECTiny has inited ------\r\n");
    }
    else
    {
        printf("\r\n-------- Sample begin----------\r\n");

        printf("\r\n1.inti ECTiny config\r\n");
        mECTinyCfg = EC_createECConfig();

	 while(!g_bt_mac_ready) {
	 	vTaskDelay(pdMS_TO_TICKS(10));
	 }
	 {
	 	char ap_prefix[5] = {0};
		memcpy(ap_prefix, g_bt_mac + 8, 4);
	 	ec_reset_wifi_ap_info(ap_prefix);
		printf("ap_ssid:%s\r\n", ap_ssid);
	 }
	 sprintf(uuid, "CARBIT%s", g_bt_mac);
	 printf("carbit  uuid :%s\r\n", uuid);
        EC_setBaseConfig(mECTinyCfg, uuid, "V0.0.1", "B:/");  //"CARBIT00000001"

        printf("\r\n2.register ECTiny callback functions\r\n");
        mECTinyCallback = registerECCallback();

        printf("\r\n3.register ECTiny Video player\r\n");
        mECTinyVideoPlayer = registerVideoPlayer();

        printf("\r\n4.set Mirror config\r\n");
        ECMirrorConfig mirrorCfg;
        memset(&mirrorCfg, 0, sizeof(ECMirrorConfig));

        //mirrorCfg.width = 1280;
        //mirrorCfg.height = 480;
        mirrorCfg.width = get_carlink_video_width();
        mirrorCfg.height = get_carlink_video_height();
        mirrorCfg.height = ((mirrorCfg.height + 0xf) & (~0xf));

        mirrorCfg.touchMode = 2;
        mirrorCfg.type = EC_VIDEO_TYPE_H264;
        mirrorCfg.quality = 4 * 1024 * 1024;
        mirrorCfg.capScreenMode = 0x08;

        printf("\r\n5.init ECTiny\r\n");

	accessFile.size = ec_access_size;
	accessFile.read = ec_access_read;
	accessFile.write = ec_access_write;
	accessFile.clear = ec_access_clear;
	EC_bindAccessFile(&accessFile);

        //EC_bindAccessFile(&license2File);
        EC_initialize(mECTinyCfg, mECTinyCallback);

        printf("\r\n6.set log info\r\n");
        EC_setLogInfo(EC_LOG_LEVEL_INFO, EC_LOG_OUT_STD, NULL, EC_LOG_MODULE_SDK | EC_LOG_MODULE_APP);

        printf("\r\n7.set Mirror config\r\n");
        EC_setMirrorConfig(&mirrorCfg);
        EC_setVideoPlayer(mECTinyVideoPlayer);

        printf("\r\n8.start EC work!\r\n");
        EC_start();

        printf("\r\n9.bindBtDevice!\r\n");

        //sleep(1);
        //EC_bindWIFIDevice(EC_TRANSPORT_ANDROID_WIFI, "192.168.43.1");
        //EC_bindWIFIDevice(EC_TRANSPORT_IOS_WIFI_APP, "192.168.13.20");

//        ECQRInfo info;
//        memset(&info,0, sizeof(ECQRInfo));
//        strcpy(info.ssid,"QJ501");
//        strcpy(info.pwd,"88888888");
//        strcpy(info.auth,"WPA");
//        info.action = EC_QR_ACTION_WIFI_AP_MODE_ACCESS_INTERNET;
//
//        EC_generateQRCodeUrl(&info);

        mInited = true;

//        while (1) {
//            sleep(20);
//        }
    }
    

    printf("------ initECTiny end ------\n");
	if (1) {
		char ap_prefix[5] = {0};
		memcpy(ap_prefix, g_bt_mac + 8, 4);

		memset(&qr_info, 0, sizeof(ECQRInfo));
		qr_info.action = EC_QR_ACTION_WIFI_STATION_MODE | EC_QR_ACTION_WIFI_AP_MODE_CUSTOMIZED;
		memcpy(ap_prefix, g_bt_mac + 8, 4);
		//sprintf(qr_info.name, "ark630hv100_p2p_%s", ap_prefix);
		sprintf(qr_info.ssid, "%s", ap_ssid);
		sprintf(qr_info.pwd, (char const *)ap_passwd);
		sprintf(qr_info.auth, "WPA-PSK");
		printf("ssid:%s\r\n", qr_info.ssid);
		const char *UrlData = EC_generateQRCodeUrl(&qr_info);
		printf("++++++++++++++++++++++UrlData:%s+++++++++++++++++++++++++++\n", UrlData);
		strcpy(strQrText, UrlData);
	}
    return NULL;
}
#endif

//------ ECTiny code end ------


void* thdPingPhone(void* param)
{
    int ret = 0;
    int count = 0;
    uint32_t IPAddress = (20 << 24) | (13 << 16) | (168 << 8) | (192 << 0);
    while(true) {
        ret = FreeRTOS_SendPingRequest(IPAddress, 8, 1000);
        printf("[TRACE][%s][%d]:count=%d,ping ret=%d\n",__FUNCTION__,__LINE__,count++,ret);
        sleep(2);
    }
}

#if 0
void testThread()
{
    pthread_t tid;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    pthread_create(&tid, &attr, initECTiny, NULL);
    pthread_attr_destroy(&attr);
}
#else
int mmcsd_wait_sdio_ready(int32_t timeout);
static int carlink_ec_network_init()
{
    BaseType_t ret;
    ret = FreeRTOS_IPInit(ucIPAddress, ucNetMask, ucGatewayAddress,ucDNSServerAddress, ucMACAddress);

    return (int)ret;
}

static void ec_reset_wifi_ap_info(const char *btmac)
{
	memset(ap_ssid, 0, sizeof(ap_ssid));
    sprintf((char *)ap_ssid,   "AP630_%s", btmac);
}

static void ec_bt_callback(char * cAtStr)
{
	char* cmd_para = NULL;
	//printf("\r\nfsc_bt_callback_ec %s\r\n", cAtStr);
	static struct ec_event ev = {0};
        static char m_tmp_buf[64];
	memset((void*)&ev, 0, sizeof(ev));
	ev.type = -1;

	if (0) {
	} else if (0 == strncmp(cAtStr, "+GATTDATA=",      10)) {
        //printf("fsc_bt_callback_ec=[%s]\r\n", cAtStr);
        char ble_buf[256] = {0};

        pthread_mutex_lock(&bufLocker);
		int data_str_len = (strlen(cAtStr) - 10), data_len;

		ev.type = EC_EVENT_BT_DATA;
		cmd_para = cAtStr + 10;
		data_len = data_str_len / 2;
		while (ring_buffer_get_bytes_free(&ble_ring_data) < data_len) {
			pthread_mutex_unlock(&bufLocker);
			vTaskDelay(pdMS_TO_TICKS(10));
			pthread_mutex_lock(&bufLocker);
		}
		string2hex(cmd_para, data_str_len, ble_buf, data_len);
		ring_buffer_write(&ble_ring_data, (uint8_t *)ble_buf, data_len);
        pthread_mutex_unlock(&bufLocker);

	} else if (0 == strncmp(cAtStr, "+GATTSTAT=1",11)) {
		ev.type = EC_EVENT_BT_DISCONNECT;
        // btEvent = EC_EVENT_BT_DISCONNECT;
        printf("TRACE[%s][%d]:EC_EVENT_BT_DISCONNECT\r\n",__func__ ,__LINE__);
	} else if (0 == strncmp(cAtStr, "+GATTSTAT=3",11)) {
        printf("TRACE[%s][%d]:EC_EVENT_BT_CONNECT\r\n",__func__ ,__LINE__);
		ev.type = EC_EVENT_BT_CONNECT;
	} else if (0 == strncmp(cAtStr, "+ADDR=",       6)) {
		char cmd_str[64] = {0};
		sprintf(cmd_str, "AT+NAME=EC_%s\r\n", (cAtStr + 6));
		//ec_reset_wifi_ap_info(cAtStr + 6);
		printf("ADDR:%s\r\n", cAtStr + 6);
		console_send_atcmd(cmd_str, strlen(cmd_str));//get mac addr
		memset(cmd_str, 0, sizeof(cmd_str));
		sprintf(cmd_str, "AT+LENAME=EC_%s\r\n", (cAtStr + 6));
		console_send_atcmd(cmd_str, strlen(cmd_str));//get mac addr
		g_bt_mac_ready = true;
		memcpy(g_bt_mac, (cAtStr + 6), 12);
	} else if (0 == strncmp(cAtStr, "+VER",         4)) {
		char* cmd = "AT+ADDR\r\n";
		console_send_atcmd(cmd, strlen(cmd));//get mac addr
    } else if (0 == strncmp(cAtStr, "+NAME=", 6)) {
		char cmd_str[64] = {0};
		sprintf(cmd_str, "AT+LEADDR\r\n");
		console_send_atcmd(cmd_str, strlen(cmd_str));//get LE addr
	} else if (0 == strncmp(cAtStr, "+LEADDR=", 6)) {
      char hexMacAddr[6] = {0};
      memset(m_tmp_buf, 0, sizeof(m_tmp_buf));
      string2hex(&cAtStr[8], 12, hexMacAddr, sizeof(hexMacAddr));
      //memcpy(addr, &cAtStr[8], 12);
      sprintf(m_tmp_buf, "AT+ADVDATA=%s\r\n", hexMacAddr);
      console_send_atcmd(m_tmp_buf, 19);
   }      
	else if (0 == strncmp(cAtStr, "+GATTSENT=", 10)) {
          
        return;
    }

	if (-1 != ev.type && NULL != ec_event_queue) {
		xQueueSend(ec_event_queue, &ev, 0);
	}
}

int32_t ec_ble_read(void * data, uint32_t len)
{
    pthread_mutex_lock(&bufLocker);
	int data_len = 0;

	data_len = ring_buffer_get_bytes_used(&ble_ring_data);

	if (data_len > len) {
		data_len = len;
	}
	if (data_len > 0) {
		ring_buffer_read(&ble_ring_data, (uint8_t*)data, data_len);
        	pthread_mutex_unlock(&bufLocker);
		return data_len;
	}
    pthread_mutex_unlock(&bufLocker);
	return 0;
}

static int ble_write(unsigned char *data, int len)
{
    uint8_t *at_str = NULL, *at_str_ptr = NULL;
    uint8_t *at_prefix = "AT+GATTSEND=";
    int prefix_len = strlen((char *)at_prefix);
    int cmd_len = (len * 2 + prefix_len + 2);

    at_str = (uint8_t *)pvPortMalloc(cmd_len+1);
    memset(at_str,0,cmd_len+1);
    if (NULL == at_str)
        return -1;
    at_str_ptr = at_str;
    sprintf((char*)at_str_ptr, "%s", (char*)at_prefix);
    at_str_ptr += prefix_len;
    hex2str(data, len, (char *)at_str_ptr);
    at_str_ptr 		+= (len * 2);
    *at_str_ptr++ 	= '\r';
    *at_str_ptr++		= '\n';
    console_send_atcmd((char *)at_str, cmd_len);
    vPortFree(at_str);
    return len;
}

int32_t ec_ble_write(void *data, uint32_t len)
{
    int send = 0;
    int offset = 0;
    do
    {
        // 把data每次按10个字节发送。ble_write 中组合之后长度变成34.  10 * 2 + 12 + 2
        send = (len - offset) > 10 ? 10 : (len - offset);
        offset += ble_write((unsigned char *)data + offset, send);
        //usleep(2000*1000);
    } while (offset < len);

    return offset;
}

int32_t ec_ble_open()
{
	return 0;
}

void ec_ble_close()
{

}

static BaseType_t wifi_init()
{
	int status;
	WIFI_Context_init();
	WIFI_RegisterEvent(eWiFiEventMax, ec_wifi_event_handler);
	for (;;) {
		status = mmcsd_wait_sdio_ready((int32_t)portMAX_DELAY);
		if (status == MMCSD_HOST_PLUGED) {
			printf("detect sdio device\r\n");
			break;
		}
	}
	return 0;
}

static void setNetInterfaceInfo()
{
	struct ECNetInterfaceInfo info;
	uint32_t ulIPAddress = 0, netMask = 0;

	memset(&info, 0, sizeof(info));
	strcpy(info.name, "wlan0");
	if (gphone_type == 1)
		ulIPAddress = (ucIPAddress[0]) | (ucIPAddress[1] << 8) | (ucIPAddress[2] << 16) | (ucIPAddress[3] << 24);
	else
		ulIPAddress = FreeRTOS_GetIPAddress();
	sprintf(info.ip, "%d.%d.%d.%d", (ulIPAddress >> 0) & 0xFF,
				(ulIPAddress >> 8) & 0xFF, (ulIPAddress >> 16) & 0xFF, (ulIPAddress >> 24) & 0xFF);
	if (gphone_type == 1)
		netMask = (ucNetMask[0]) | (ucNetMask[1] << 8) | (ucNetMask[2] << 16) | (ucNetMask[3] << 24);
	else
		netMask = FreeRTOS_GetNetmask();
	sprintf(info.mask, "%d.%d.%d.%d", (netMask >> 0) & 0xFF,
				(netMask >> 8) & 0xFF, (netMask >> 16) & 0xFF, (netMask >> 24) & 0xFF);
	EC_setNetInterfaceInfo(&info, 1);
}

static void  taskECTinyWrapper(void* param)
{
    struct ec_event ev;
	int    android_ap_connect_flag = 0;

    while(1) {
        if (xQueueReceive(ec_event_queue, &ev, portMAX_DELAY) != pdPASS) {
            printf("%s xQueueReceive err!\r\n", __func__);
            continue;
        }

        //printf("TRACE[%s][%d]:ec_event_queue,get event:%d\r\n", __func__, __LINE__, ev.type);

        switch (ev.type) {
            case -1: {
                continue;
            }
            case EC_EVENT_BT_CONNECT: {
                printf("TRACE[%s][%d]:EC_bindBTDevice_1\r\n",__func__ ,__LINE__);
                bleDev.open       = ec_ble_open;
                bleDev.close      = ec_ble_close;
                bleDev.read       = ec_ble_read;
                bleDev.write      = ec_ble_write;
                EC_bindBTDevice(&bleDev);
                printf("TRACE[%s][%d]:EC_bindBTDevice_2\r\n",__func__ ,__LINE__);

                break;
            }
            case EC_EVENT_BT_DISCONNECT: {
                break;
            }
            case EC_EVENT_BT_DATA: {

                break;
            }
                // wifi is station, dhcp ready
            case EC_EVENT_CLIENT_DHCP_READY: {
                    ECNetWorkInfo netInfo = {0};
                    netInfo.state = EC_WIFI_STATE_CONNECTED;
                    EC_notifyWifiStateChanged(EC_WIFI_STATE_CHANGED_ACTION, &netInfo);
                    setNetInterfaceInfo();
                    printf("TRACE[%s][%d]:EC_EVENT_CLIENT_DHCP_READY\r\n",__func__ ,__LINE__);

                break;
            }
            case EC_EVENT_BUILD_NET_OK: {
                if (gphone_type == 1)
                {
                    ECNetWorkInfo netInfo = {0};
                    netInfo.state = EC_WIFI_STATE_CONNECTED;
                    EC_notifyWifiStateChanged(EC_WIFI_STATE_CHANGED_ACTION, &netInfo);
                }

                setNetInterfaceInfo();
                printf("TRACE[%s][%d]:EC_EVENT_BUILD_NET_OK--------------\r\n", __func__, __LINE__);
                break;
            }
            case EC_EVENT_WIFI_DISCONNECT:
            {
            	if (android_ap_connect_flag == 1) {
	                ECNetWorkInfo netInfo = {0};
	                netInfo.state = EC_WIFI_STATE_DISCONNECTED;
	                EC_notifyWifiStateChanged(EC_WIFI_STATE_CHANGED_ACTION, &netInfo);
	                printf("TRACE[%s][%d]:EC_EVENT_WIFI_DISCONNECT--------------\r\n", __func__, __LINE__);
            	}
				android_ap_connect_flag = 0;
                break;
            }
			case EC_EVENT_WIFI_CONNECT:
            {
                android_ap_connect_flag = 1;
                printf("TRACE[%s][%d]:EC_EVENT_WIFI_CONNECT--------------\r\n", __func__, __LINE__);
                break;
            }
            default:
                printf("TRACE[%s][%d]:error event:%d\r\n", __func__, __LINE__, ev.type);
        }
    }

    vTaskDelete(NULL);
}

void testThread()
{
	wifi_init();
	ring_buffer_init(&ble_ring_data, 256);
	ec_event_queue = xQueueCreate(1, sizeof(struct ec_event));
	if (ec_sta_sem == NULL)
		ec_sta_sem = xSemaphoreCreateMutex();
	carlink_ec_network_init();
	console_register_cb(NULL, ec_bt_callback);
	xTaskCreate(taskECTinyWrapper, "ecThread", 2048 *4, NULL, configMAX_PRIORITIES / 4, &ec_network_task);
	fsc_bt_main();printf("%s:%d\r\n", __func__, __LINE__);

	initECTiny(NULL);
}
#endif

static void  taskInitCarlink(void* param)
{
	testThread();
	vTaskDelete(NULL);
}

int carlink_ec_init(int argc,char ** argv)
{
	printf("------ TestECTiny begin ------\n");
	carlink_ey_video_init();
#if 0
    testThread();
#else
	/* 启动线程初始化：
	 * 1. initECTiny初始化延时过长，导致开机动画和UI显示切换之间存在黑屏时间，因此在线程中初始化
	 * 2. wifi模块未贴或异常时，wifi_init函数无法返回，导致UI无法正常显示。
	 */
	xTaskCreate(taskInitCarlink, "initThread", 2048 *4, NULL, configMAX_PRIORITIES / 4, NULL);
#endif
	printf("------ TestECTiny end ------\n");

	return 0;
}
#else
int carlink_ec_init(int argc,char ** argv)
{
    (void)argc;
    (void)argv;
    return 0;
}
#endif