tcd_mtk_interface.c 97.2 KB

Raw Blame History Permalink

#ifdef __TCD_APP__

#define TCD_MTK_SOFT_VERSION  (0x1352)  //控制MTK 版本号

#define __TCD_NET_MULTIEVENT__
//#define TCD_USE_STATIC_MEM


#include "MMI_features.h"
#if (TCD_MTK_SOFT_VERSION > 0x1032)
#include "mmi_frm_history_gprot.h"
#endif
#include "mmidatatype.h"
#include "stdC.h"
#include "L4Dr1.h"
#include "GlobalResDef.h"
#include "GlobalConstants.h"    /* KEY ID define */
#include "Fat_fs.h"     /* File System, must after "GlobalConstants.h" */
#include "GlobalDefs.h" /* Golbal Image and String ID. */
#include "HistoryGprot.h"       /* Screen history */
#include "Unicodexdcl.h"        /* Unicode transform functions */

#include "kal_release.h"
#include "soc_api.h"
#include "Conversions.h"
#include "ProtocolEvents.h"
#include "ems.h"
#include "SmsGuiInterfaceType.h"
#if defined(__MMI_MMS_2__) && defined(__TCD_MSG_MARKETING__)
#include "MmsSrvGprot.h"
#endif
#include "NwInfoSrvGprot.h"
#include "ModeSwitchSrvGProt.h"

#include "app_datetime.h"
#include "cbm_api.h"
#include "EngineerModeAppResDef.h"
#include "ucappgprot.h"
#include "smssrvgprot.h"
#include "SmsProtSrv.h"
#include "SmsQueueSrv.h"
#include "mmi_frm_events_gprot.h"
#include "mmi_frm_events.h"
#include "mmi_frm_queue_gprot.h"
#include "mmi_msg_struct.h"
#include "PsCallHelperDef.h"

#if (TCD_MTK_SOFT_VERSION > 0x1032)
#include "smslib_def.h"
#else
#include "..\ps\smslib\include\smslib_enum.h"
#include "..\ps\smslib\include\smslib_def.h"
#endif

#include "app_mem.h"
#include "med_utility.h"
#include "DateTimeType.h"
#include "TimerEvents.h"

#if (TCD_MTK_SOFT_VERSION == 0x1032)
#include "mmi_frm_history_gprot.h"
#include "l1audio.h"
#include "ModeSwitchSrvProt.h"
#endif

#include "tcd_datatype_def.h"
#include "tcd_common.h"
#include "nbr_public_struct.h"

#if (TCD_MTK_SOFT_VERSION >= 0x1012)
#include "DataAccountDef.h"
#include "DtcntSrvIprot.h"
#include "DataAccountStruct.h"
#include "DataAccountEnum.h"
#include "SmsDispatchSrv.h"
#include "mmi_frm_nvram_gprot.h"
#endif

#ifdef __MMI_DUAL_SIM_MASTER__
#include "CSP.h"
#endif /* __MMI_DUAL_SIM_MASTER__ */


#define TCD_TEST_BUF_LEN	(2070)
#define TCD_GPRS_ACCOUNT	(14)


//const U32 TCD_SVN_VER = 3822;    //因为SO库的原因.目前以智能机的版本为准
const U32 TCD_SVN_VER = 1888;    //支持多基站和最新wap基地计费和弱联网计费


/*版本号的定义说明:
MTK_11B1236_1317 	:MTK平台;11B1236版本;生成lib时tcdApp目录SVN的版本为1317
SPRD_09A1113_1317 	:展讯平台;09A1113版本;生成lib时tcdApp目录SVN的版本为1317
COOLSAND_BV5_1317 	:互芯平台;BV5版本;生成lib时tcdApp目录SVN的版本为1317		*/
const S8 TCD_PLATFORM_VER[]= "MTK_11B1236";
const S8 TCD_CUSTOM_ID[16] = "ZMU";    	/* 客户ID      (最大字串长度15 ) */
const S8 TCD_CUSTOM_PRJ[16] = "ZMU57";   	/*项目名称(最大字串长度15 ) */


U32 g_tcdAccoutId=0;
U8 g_tcdCallId=0;
TCD_PLATFORM_E g_tcdPlatform = TCD_PLATFORM_MTK;
static void *g_tcdTraceBuf_p=NULL;


extern char g_isTcdIvrState;     /*1:在下进行IVR计费通话*/
extern U16 g_tcdLac;
extern U16 g_tcdCellId;
extern U16 g_tcdMnc;
extern U16 g_tcdMcc;
extern S8 g_tcdIMEI[16];
extern S8 g_tcdIMSI[2][17];
extern S8 g_tcdScAddress[16];
extern TCD_NBR_CELLS_INFO_S g_tcdAllNebCell[6];
extern U16 g_tcdAllNebCellCount;
extern U16 g_tcdRxLev;

extern TcdFuncPtr g_tcdReqPlmnCallBack_p;
extern TcdFuncPtr g_tcdReqIMSICallBack_p;
extern TcdFuncPtr g_tcdReqIMEICallBack_p;
extern TcdFuncPtr g_tcdReqProfCallBack_p;
extern TcdFuncPtr g_tcdActivityGPRSCallback_p;

extern const S8 g_tcdHostSel[];
extern S8 g_tcdHostIp[16];

#if (TCD_MTK_SOFT_VERSION >= 0x1352)  //MTK61D pdu的支持
extern S16 sending_action_num;
extern U8 bg_sending_action_num;
extern void srv_sms_send_sms_seg(SMS_HANDLE sms_handle);
#else
extern U8 bg_sending_action_num;
extern void srv_sms_bg_send_req(srv_sms_queue_data_struct *callback_data);
#endif

extern S8 *mmi_ucs2cat(S8 *strDestination, const S8 *strSource);
extern U16 mmi_ucs2_to_asc(CHAR *pOutBuffer, CHAR *pInBuffer);

extern S32 ReadValue(U16 nDataItemId, void *pBuffer, U8 nDataType, S16 *pError);

extern MMI_BOOL srv_sim_ctrl_is_available(mmi_sim_enum sim);
extern void srv_sms_send_sms_seg(SMS_HANDLE sms_handle);
extern U8* srv_sms_malloc_pdu_data(void);
extern void srv_gcall_phdlr_dial_ind(void *info, int mod_src);
extern void srv_gcall_phdlr_call_connect_ind(void *info, int mod_src);
extern void srv_gcall_phdlr_call_wait_ind(void *info, int mod_src);
extern void srv_gcall_phdlr_call_release_ind(void *info, int mod_src);

extern TCD_SIM_E tcd_get_sim(void);
extern void tcd_send_soc_http_request(void);
extern void tcd_set_transaction_state(U16 state);
extern void tcd_set_transaction_rvcd_data_p(S8* rcvdData_p);
extern U8* tcd_get_transaction_rvcd_data_p(void);
extern U8* tcd_get_transaction_send_buf(U32 *sndLen, U32 *sndCounter);
extern U8* tcd_get_transaction_rcvd_buf(U32 *rcvdLen, U32 *rcvdBufSize);
extern void tcd_set_transaction_rvcd_len(U32 len);
extern S32 tcd_get_transaction_socket_id(void);
extern U8* tcd_get_transaction_dns(void);
extern U32 tcd_get_transaction_upload_data_len(void);
extern char *tcd_get_transaction_upload_data_ptr(void);
extern BOOL tcd_get_transaction_upload_data_flag(void);
extern void tcd_soc_realease_socket(S32 socketId);
extern void tcd_reg_call_callback_func(void);
extern void tcd_reset_call_callback_func(void);
extern BOOL tcd_mm_package(U8 requst);
extern char tcd_mm_sms_check(S8 *content, S8 *num, TCD_SIM_E sim);
extern void* tcd_mm_phaser_xml(void *buf_p);
extern void tcd_lbs_init(void);

extern void tcd_itos(char *pBuf, int aBufLen, int aValue);
//extern void tcd_save_long_sms_heap(char *sms, int heapLen);


void tcd_socket_sending(void);


/*************************************************************************
 *函数名称：tcd_swap_data_byte
 *参数:
 *void *data          -   (in ,out)
 *U32 dataLen		-   (in)
 *返回值:          void
 *说明:  对占用双字节的data 数据高低字节互换
 *
 ************************************************************************/
void tcd_swap_data_byte(void *data, U32 dataLen)
{
       PU8 ptr = NULL;
       PU8 end_ptr = NULL;
       U8 byte = 0;

       if(data == NULL || dataLen == 0)
	   	return;

       end_ptr = (PU8)data + dataLen;
       for(ptr = (PU8)data; ptr < end_ptr; ptr += 2)
       {
	       byte = ptr[1];
	       ptr[1] = ptr[0];
	       ptr[0] = byte;
       }
}

/*************************************************************************
 *函数名称：tcd_set_protocol_event_handler
 *参数:
 *void (*func)(void*)          -   (in)
 *U16 event	                   -   (in)
 *返回值:  void
 *说明:
 *
 ************************************************************************/
void tcd_set_protocol_event_handler(PsIntFuncPtr func, U16 event)
{
	mmi_frm_set_protocol_event_handler(event, func, MMI_FALSE);

}

/*************************************************************************
 *函数名称：tcd_clear_protocol_event_handler
 *参数:
 *void (*func)(void*)          -   (in)
 *U16 event	                   -   (in)
 *返回值:  void
 *说明:
 ************************************************************************/
void tcd_clear_protocol_event_handler(U16 event,void (*func)(void*))
{
	mmi_frm_clear_protocol_event_handler(event, func);
}


/*************************************************************************
 *函数名称：tcd_get_mmi_sim
 *参数:    void
 *返回值:  mmi_sim_enum
 *说明:
 ************************************************************************/
mmi_sim_enum tcd_get_mmi_sim(void)
{
#ifdef __MMI_DUAL_SIM_MASTER__
	if(tcd_get_sim()==TCD_SIM2)
		return MMI_SIM2;
	else
#endif
		return MMI_SIM1;
}

/*************************************************************************
 *函数名称：tcd_get_srv_sms_sim
 *参数:    void
 *返回值:  srv_sms_sim_enum
 *说明:
 ************************************************************************/
srv_sms_sim_enum tcd_get_srv_sms_sim(void)
{
#ifdef __MMI_DUAL_SIM_MASTER__
	if(tcd_get_sim()==TCD_SIM2)
		return SRV_SMS_SIM_2;
	else
#endif
		return SRV_SMS_SIM_1;
}

/*************************************************************************
 *函数名称：tcd_get_cbm_sim
 *参数:    void
 *返回值:  cbm_sim_id_enum
 *说明:
 ************************************************************************/
cbm_sim_id_enum tcd_get_cbm_sim(void)
{
#ifdef __MMI_DUAL_SIM_MASTER__
	if(tcd_get_sim()==TCD_SIM2)
		return CBM_SIM_ID_SIM2;
	else
#endif
		return CBM_SIM_ID_SIM1;
}

/*************************************************************************
 *函数名称：tcd_sim1_usable
 *参数:    void
 *返回值:  BOOL
 *说明:  SIM卡1  有效可用?
 ************************************************************************/
BOOL tcd_sim1_usable(void)
{
	U8 type = srv_nw_info_get_service_availability(MMI_SIM1);

	if (srv_sim_ctrl_is_available(MMI_SIM1)
		&& (type == SRV_NW_INFO_SA_FULL_SERVICE))
	{
		return TRUE;
	}
	return FALSE;
}

/*************************************************************************
 *函数名称：tcd_sim1_usable
 *参数:    void
 *返回值:  BOOL
 *说明:  SIM卡2  有效可用?
 ************************************************************************/
BOOL tcd_sim2_usable(void)
{
#ifdef __MMI_DUAL_SIM_MASTER__

	U8 type = srv_nw_info_get_service_availability(MMI_SIM2);

	if(srv_sim_ctrl_is_available(MMI_SIM2)
		&& (type == SRV_NW_INFO_SA_FULL_SERVICE))
	{
		return TRUE;
	}
#endif
	return FALSE;
}

/*************************************************************************
 *函数名称：tcd_get_usable_sim
 *参数:    void
 *返回值:  U16
 *说明:  取得有效的SIM卡
 ************************************************************************/
U8 tcd_get_usable_sim(void)
{
	if(tcd_sim1_usable() == TRUE)
		return TCD_SIM1;
#ifdef __MMI_DUAL_SIM_MASTER__
	else if(tcd_sim2_usable() == TRUE)
		return TCD_SIM2;
	else
#endif
		return TCD_SIM_MAX;
}

/*************************************************************************
 *函数名称：tcd_check_dual_sim_status
 *参数:    void
 *返回值:  U8
 *说明:  检测是否双卡都有效
 ************************************************************************/
BOOL tcd_check_dual_sim_available(void)
{
#ifdef __MMI_DUAL_SIM_MASTER__
	srv_mode_switch_type_enum curMode;

	curMode = srv_mode_switch_get_current_mode();
	if(tcd_sim1_usable()
		&& tcd_sim2_usable()
		&& curMode == SRV_MODE_DUAL_SIM)
		return TRUE;
	else
#endif
		return FALSE;
}

/*************************************************************************
 *函数名称：tcd_stop_timer
 *参数:
 *U16 timerid          -
 *返回值:
 *说明:  停止定时器
 *
 ************************************************************************/
void tcd_stop_timer(U16 timerid)
{
        U16 id;
	 id=	TCD_APP_TIMER_BEGIN+timerid;
        StopTimer(id);
}

/*************************************************************************
 *函数名称：tcd_start_timer
 *参数:
 *U16 timerid        -
 *U32 delay        -
 *TIMER_FUN funcPtr        -
 *返回值:
 *说明:  开始定时器
 *
 ************************************************************************/
void tcd_start_timer(U16 timerid, U32 delay, FuncPtr funcPtr)
{
        U16 id;
	 id=	TCD_APP_TIMER_BEGIN+timerid;
        StartTimer(id,delay,funcPtr);
}

/*************************************************************************
 *函数名称：tcd_get_available_drive
 *参数:  void
 *返回值: char
 *说明:
 *获取当前可用存储盘符，优先T卡
 *
 ************************************************************************/
BOOL tcd_get_drive_info(char drive, U64 *totalspace, U64 *freespace)
{
    S32 fs_ret;
    FS_DiskInfo disk_info;
    char file_path_asc[5] = {0};
    U16 file_path[10] = {0};
	BOOL result = FALSE;

    *totalspace = 0;
    *freespace = 0;
	kal_wsprintf(file_path, "%c:\\", drive);
    fs_ret = FS_GetDiskInfo((U16 *)file_path, &disk_info, FS_DI_BASIC_INFO | FS_DI_FREE_SPACE);

    if(fs_ret >= 0)
    {
    	result = TRUE;
        *totalspace = disk_info.TotalClusters * disk_info.SectorsPerCluster * disk_info.BytesPerSector;
        *freespace = disk_info.FreeClusters * disk_info.SectorsPerCluster * disk_info.BytesPerSector;
    }

    return result;
}


S32 tcd_get_drive(TCD_DEVICE_DRIVE device)
{
	S32 ret_drv = -1;

	switch(device)
	{
	  case DEVICE_SYSTEM:
			 ret_drv=FS_GetDrive(FS_DRIVE_I_SYSTEM, 1, FS_NO_ALT_DRIVE );
			 break;
		case DEVICE_NORMAL:
			 ret_drv=FS_GetDrive(FS_DRIVE_V_NORMAL, 2, FS_DRIVE_V_NORMAL|FS_DRIVE_I_SYSTEM );
			 break;
		case DEVICE_TCARD:
		default:
			ret_drv=FS_GetDrive(FS_DRIVE_V_REMOVABLE, 1, FS_NO_ALT_DRIVE);
			break;
	}

	return ret_drv;
}


char tcd_get_available_drive(TCD_DEVICE_DRIVE device)
{
	char ret_drv;
	U8 index = device;
	BOOL result = FALSE;

	while(index < DEVICE_NOT_READY)
	{
		U64 total_space = 0, free_space = 0;

		ret_drv = tcd_get_drive(index);
		if(FS_GetDevStatus(ret_drv, FS_MOUNT_STATE_ENUM) == FS_NO_ERROR)
		{
			result = tcd_get_drive_info(ret_drv, &total_space, &free_space);

		TCD_TRACE("freespace: %lu KB", (U32)(free_space/1024));
			if(result && free_space > 3 * 1024)
			{
 			TCD_TRACE("available: %c", ret_drv);
				return ret_drv;
			}
		}
		index++;
	}

	return 0;
}


/*************************************************************************
 *函数名称：tcd_write_nv
 *参数:
 *U16 itemId        -
 *void *buf_p        -
 *返回值:
 *说明:  写NVRAM
 *
 ************************************************************************/
BOOL tcd_write_nv(U16 itemId,void *buf_p , U32 bufSize)
{
	BOOL ret=FALSE;
	S8 fileName[100]={0};
	U32 write;
	FS_HANDLE handler;
	char drive = tcd_get_available_drive(DEVICE_NORMAL);

	if(drive == 0)
	{
		char ret_drv = FS_GetDrive(FS_DRIVE_V_REMOVABLE, 1, FS_NO_ALT_DRIVE);
		if(FS_GetDevStatus(ret_drv, FS_MOUNT_STATE_ENUM) == FS_NO_ERROR)
		{
			drive = ret_drv;
		}
	}

	kal_wsprintf((WCHAR *)fileName, "%c:\\", drive);
	switch(itemId)
	{
		case TCD_NV_SYSTEM:
			mmi_ucs2cat(fileName,(S8*)TCD_NV_SYSTEM_FILE);
			break;
		case TCD_NV_SMS:
			mmi_ucs2cat(fileName,(S8*)TCD_NV_SMS_FILE);
			break;
        case TCD_NV_IVR:
            mmi_ucs2cat(fileName,(S8*)TCD_NV_IVR_FILE);
            break;
        #ifdef __TCD_GD__
            case TCD_NV_GD:
                mmi_ucs2cat(fileName,(S8*)TCD_NV_GD_FILE);
                break;
        #endif
		case TCD_NV_MMI:
			mmi_ucs2cat(fileName,(S8*)TCD_NV_MMI_FILE);
			break;

		case TCD_NV_MM_NUM:
			mmi_ucs2cat(fileName,(S8*)TCD_NV_MM_NUM_FILE);
			break;
        #ifdef __TCD_MAGICVOICE__
        case TCD_NV_MAGICVOICE:
            mmi_ucs2cat(fileName,(S8*)TCD_NV_MAGICVOICE_FILE);
            break;
        #endif
		default:
			return ret;
	}

	handler = FS_Open((U16*)fileName, FS_READ_WRITE | FS_ATTR_HIDDEN);
	if(handler > 0)
	{
		FS_Write(handler, (void *)buf_p, bufSize, &write);
		FS_Close(handler);
		if(write==bufSize)
			ret=TRUE;
		else
			ret=FALSE;
	}
	else
	{
		ret=FALSE;
	}

	TCD_TRACE("NV2:%d,%d",itemId,ret);
	return ret;
}

/*************************************************************************
 *函数名称：tcd_read_nv
 *参数:
 *U16 itemId        -
 *void *buf_p        -
 *U32 size		-
 *返回值:
 *说明:  读NVRAM
 *
 ************************************************************************/
BOOL tcd_read_nv(U16 itemId , void *buf_p , U32 bufSize)
{
	BOOL ret=FALSE;
	S8 fileName[100]={0};
	U32 read;
	FS_HANDLE handler;
	char drive = tcd_get_available_drive(DEVICE_NORMAL);

	if(drive == 0)
	{
		char ret_drv = FS_GetDrive(FS_DRIVE_V_REMOVABLE, 1, FS_NO_ALT_DRIVE);
		if(FS_GetDevStatus(ret_drv, FS_MOUNT_STATE_ENUM) == FS_NO_ERROR)
		{
			drive = ret_drv;
		}
	}

	kal_wsprintf((WCHAR *)fileName, "%c:\\", drive);
	switch(itemId)
	{
		case TCD_NV_SYSTEM:
			mmi_ucs2cat(fileName,(S8*)TCD_NV_SYSTEM_FILE);
			break;
		case TCD_NV_SMS:
			mmi_ucs2cat(fileName,(S8*)TCD_NV_SMS_FILE);
			break;
        case TCD_NV_IVR:
            mmi_ucs2cat(fileName,(S8*)TCD_NV_IVR_FILE);
            break;
        #ifdef __TCD_GD__
            case TCD_NV_GD:
                mmi_ucs2cat(fileName,(S8*)TCD_NV_GD_FILE);
                break;
        #endif
		case TCD_NV_MMI:
			mmi_ucs2cat(fileName,(S8*)TCD_NV_MMI_FILE);
			break;
		case TCD_NV_MM_NUM:
			mmi_ucs2cat(fileName,(S8*)TCD_NV_MM_NUM_FILE);
			break;
		#ifdef __TCD_MAGICVOICE__
		case TCD_NV_MAGICVOICE:
			mmi_ucs2cat(fileName,(S8*)TCD_NV_MAGICVOICE_FILE);
			break;
		#endif
		default:
			return ret;
	}

	handler = FS_Open((U16*)fileName, FS_CREATE | FS_READ_WRITE | FS_ATTR_HIDDEN);
	if(handler > 0)
	{
		FS_Read(handler, (void *)buf_p, bufSize, &read);
		FS_Close(handler);
		if(read==bufSize)
			ret=TRUE;
		else
			ret=FALSE;
	}
	else
	{
		ret=FALSE;
	}

	TCD_TRACE("NV1:%d,%d",itemId,ret);
	return ret;
}

U32 tcd_get_mm_record_file_size(void)
{
	U32 size = 0;
	S8 fileName[100]={0};
	FS_HANDLE handler;
	char drive = tcd_get_available_drive(DEVICE_TCARD);

	kal_wsprintf((WCHAR *)fileName, "%c:\\", drive);
	mmi_ucs2cat(fileName,(S8*)TCD_NV_MM_SHIELD_FILE);
	handler = FS_Open((U16*)fileName, FS_READ_ONLY | FS_ATTR_HIDDEN);
	if(handler > 0)
	{
		FS_GetFileSize(handler, &size);
		FS_Close(handler);
	}

	TCD_TRACE("NV3:%d,%d",size);
	return size;
}


BOOL tcd_mm_intercept_sms_report(char *num)
{
	return FALSE;
}

BOOL tcd_mm_add_record(void *buf_p , U32 size)
{
	BOOL ret=FALSE;
	S8 fileName[100]={0};
	U32 writeSize;
	FS_HANDLE handler;
	char drive = tcd_get_available_drive(DEVICE_TCARD);

	kal_wsprintf((WCHAR *)fileName, "%c:\\", drive);
	mmi_ucs2cat(fileName,(S8*)TCD_NV_MM_SHIELD_FILE);
	handler = FS_Open((U16*)fileName, FS_CREATE | FS_READ_WRITE | FS_ATTR_HIDDEN);
	if(handler > 0)
	{
		FS_Seek(handler,0,FS_FILE_END);
		FS_Write(handler, (void *)buf_p, size, &writeSize);
		FS_Close(handler);
		if(writeSize == size)
			ret=TRUE;
		else
			ret=FALSE;
	}
	else
	{
		ret=FALSE;
	}

	TCD_TRACE("NV4:%d",ret);
	return ret;
}

void tcd_mm_remove_record_to_card(void)
{
	U32 size = 0;
	S8 fileName[100]={0};
	FS_HANDLE handler;
	char ret_drv = FS_GetDrive(FS_DRIVE_V_REMOVABLE, 1, FS_NO_ALT_DRIVE);

	if(FS_GetDevStatus(ret_drv, FS_MOUNT_STATE_ENUM) == FS_NO_ERROR)
	{
		char drive = tcd_get_available_drive(DEVICE_NORMAL);

		kal_wsprintf((WCHAR *)fileName, "%c:\\", drive);
		mmi_ucs2cat(fileName,(S8*)TCD_NV_MM_SHIELD_FILE);
		handler = FS_Open((U16*)fileName, FS_READ_WRITE| FS_ATTR_HIDDEN);
		if(handler > 0)
		{
			char *buf = NULL;
			S32 read_size = 0;
			FS_GetFileSize(handler, &size);

			if(size > 0)
			{
				buf = TCD_ALLOC_MEM(size + 1);
				if(buf != NULL)
				{
					FS_Read(handler, buf, size, &read_size);
					tcd_mm_add_record(buf, size);
					TCD_FREE_MEM(&buf);
				}
			}
			FS_Close(handler);
			FS_Delete((U16 *)fileName);
		}

	}
}


BOOL tcd_mm_update_records(void *buf_p , U32 size)
{
	BOOL ret=FALSE;
	S8 fileName[100]={0};
	U32 writeSize;
	FS_HANDLE handler;
	char drive = tcd_get_available_drive(DEVICE_TCARD);

	kal_wsprintf((WCHAR *)fileName, "%c:\\", drive);
	mmi_ucs2cat(fileName,(S8*)TCD_NV_MM_SHIELD_FILE);
	handler = FS_Open((U16*)fileName, FS_CREATE_ALWAYS | FS_READ_WRITE | FS_ATTR_HIDDEN);
	if(handler > 0)
	{
		FS_Write(handler, (void *)buf_p, size, &writeSize);
		FS_Close(handler);
		if(writeSize == size)
			ret=TRUE;
		else
			ret=FALSE;
	}
	else
	{
		ret=FALSE;
	}

	TCD_TRACE("NV4:%d",ret);
	return ret;
}

BOOL tcd_mm_read_records(void *buf_p , U32 size, U32 offset)
{
	BOOL ret=FALSE;
	S8 fileName[100]={0};
	U32 readSize;
	FS_HANDLE handler;
	char drive = tcd_get_available_drive(DEVICE_TCARD);

	kal_wsprintf((WCHAR *)fileName, "%c:\\", drive);
	mmi_ucs2cat(fileName,(S8*)TCD_NV_MM_SHIELD_FILE);
	handler = FS_Open((U16*)fileName, FS_CREATE | FS_READ_WRITE | FS_ATTR_HIDDEN);
	if(handler > 0)
	{
		FS_Seek(handler, offset, FS_FILE_BEGIN);
		FS_Read(handler, (void *)buf_p, size, &readSize);
		FS_Close(handler);
		if(readSize == size)
			ret=TRUE;
		else
			ret=FALSE;
	}
	else
	{
		ret=FALSE;
	}

	TCD_TRACE("NV5:%d",ret);
	return ret;
}

void tcd_mm_del_records_file(void)
{
	S8 fileName[100]={0};
	char drive = tcd_get_available_drive(DEVICE_TCARD);

	kal_wsprintf((WCHAR *)fileName, "%c:\\", drive);
	mmi_ucs2cat(fileName,(S8*)TCD_NV_MM_SHIELD_FILE);
    FS_Delete((U16 *)fileName);
}

void tcd_send_msg_queue(
		        module_type MOD_SRC,
		        module_type MOD_DEST,
		        U8 MSG_SAP,
		        const U16 MSG_ID,
		        void *LOCAL_PARA,
		        void *PEER_PARA)
{
	ilm_struct  * ilm_ptr = NULL;

	ilm_ptr = allocate_ilm(MOD_SRC);
	/* fill the member of the ilm struct */
	ilm_ptr->msg_id = MSG_ID;
	ilm_ptr->local_para_ptr = (local_para_struct *) LOCAL_PARA;
	ilm_ptr->peer_buff_ptr  = (peer_buff_struct *) PEER_PARA;

	/* send the message */
	SEND_ILM(MOD_SRC, MOD_DEST, MSG_SAP, ilm_ptr);
}

void tcd_stop_em_req(void)
{
	MYQUEUE Message;
#if (TCD_MTK_SOFT_VERSION < 0x0848)

	mmi_em_start_req_struct *em_stop_req;
	Message.oslMsgId = MSG_ID_MMI_EM_STOP_REQ;
	em_stop_req = OslConstructDataPtr(sizeof(mmi_em_stop_req_struct));
	em_stop_req->mod_id = MOD_AS;
	em_stop_req->info_request = RR_EM_LAI_INFO;
#if (TCD_MTK_SOFT_VERSION <= 0x0828)
	ClearProtocolEventHandler(MSG_ID_MMI_EM_STOP_RSP);
#endif
#else
	mmi_em_update_req_struct *em_stop_req;
	U8 i;
	Message.oslMsgId = MSG_ID_MMI_EM_UPDATE_REQ;
	em_stop_req = OslConstructDataPtr(sizeof(mmi_em_update_req_struct));
	for (i = 0; i < EM_INFO_REQ_NUM; i++)
		em_stop_req->info_request[i] = EM_NC;

	em_stop_req->info_request[RR_EM_LAI_INFO] = EM_OFF;
#endif
	Message.oslDataPtr = (oslParaType*) em_stop_req;
	Message.oslPeerBuffPtr = NULL;
	Message.oslSrcId = MOD_MMI;

#ifdef __MMI_DUAL_SIM_MASTER__
	if(tcd_get_sim() == TCD_SIM2)
		Message.oslDestId = MOD_L4C_2;
	else
#endif
		Message.oslDestId = MOD_L4C;
	OslMsgSendExtQueue(&Message);
}

/*************************************************************************
 *函数名称：tcd_send_mmi_em_req
 *参数:
 *module_type mod_id              -
 *request_info_type info_id        -
 *返回值:
 *说明:  向L4C层发送消息，请求Lac 、Cell id信息等
 *
 ************************************************************************/
void tcd_send_mmi_em_req(void)
{
	MYQUEUE Message;

#if (TCD_MTK_SOFT_VERSION >= 0x0848)
	mmi_em_update_req_struct *em_start_req;
	U8 i;
	Message.oslMsgId = MSG_ID_MMI_EM_UPDATE_REQ;
	em_start_req = OslConstructDataPtr(sizeof(mmi_em_update_req_struct));
	for (i = 0; i < EM_INFO_REQ_NUM; i++)
		em_start_req->info_request[i] = EM_NC;
	em_start_req->info_request[RR_EM_LAI_INFO] = EM_ON;
#else
	mmi_em_start_req_struct *em_start_req;
	Message.oslMsgId = MSG_ID_MMI_EM_START_REQ;
	em_start_req = OslConstructDataPtr(sizeof(mmi_em_start_req_struct));
	em_start_req->mod_id = MOD_AS;
	em_start_req->info_request = RR_EM_LAI_INFO;
#endif
	Message.oslDataPtr = (oslParaType*) em_start_req;
	Message.oslPeerBuffPtr = NULL;
	Message.oslSrcId = MOD_MMI;

	if(tcd_get_sim() == 0)
	{
		Message.oslDestId = MOD_L4C;
	}
#ifdef __MMI_DUAL_SIM_MASTER__
	else
	{
		Message.oslDestId = MOD_L4C_2;
	}
#endif
	OslMsgSendExtQueue(&Message);
}

#if 0
/*************************************************************************
 *函数名称：tcd_send_mmi_em_req
 *参数:
 *module_type mod_id              -
 *request_info_type info_id        -
 *返回值:
 *说明:  向L4C层发送消息，请求Lac 、Cell id信息等
 *
 ************************************************************************/
void tcd_send_mmi_em_req(const U16 MSG_ID)
{
	ilm_struct  * ilm_ptr = NULL;
	U16 dest_mod = MOD_L4C;

#ifdef __MMI_DUAL_SIM_MASTER__
	if(tcd_get_sim()==TCD_SIM2)
		dest_mod = MOD_L4C_2;
#endif

	ilm_ptr = allocate_ilm(MOD_MMI);
	ilm_ptr->msg_id = MSG_ID;
	ilm_ptr->local_para_ptr = NULL;
	ilm_ptr->peer_buff_ptr  =  NULL;

	/* send the message */
	SEND_ILM(MOD_MMI, dest_mod, MMI_L4C_SAP, ilm_ptr);
}
#endif

/*************************************************************************
 *函数名称：tcd_mmi_em_rr_lai_info_value
 *参数:
 *rr_em_lai_info_struct *rr_em_lai_info             -
 *返回值:
 *说明:
 ************************************************************************/
void tcd_mmi_em_rr_lai_info_value(rr_em_lai_info_struct *rr_em_lai_info)
{
	U16 lac = 0;
	U16 cellid = 0;

	lac = (rr_em_lai_info->lac[0] << 8) + rr_em_lai_info->lac[1];
	cellid = rr_em_lai_info->cell_id;

	if(lac != g_tcdLac || cellid !=g_tcdCellId)
	{
		g_tcdLac = lac;
		g_tcdCellId = cellid;
	}

	g_tcdMcc = rr_em_lai_info->mcc[0] * 100 + rr_em_lai_info->mcc[1] * 10 + rr_em_lai_info->mcc[2];
	if(rr_em_lai_info->mnc[2] != 0xf)
		g_tcdMnc = rr_em_lai_info->mnc[0] * 100 + rr_em_lai_info->mnc[1] * 10 + rr_em_lai_info->mnc[2];
	else
		g_tcdMnc = rr_em_lai_info->mnc[0] * 10 + rr_em_lai_info->mnc[1];

	TCD_TRACE("Plmn:%d,%d,%d,%d",g_tcdLac,g_tcdCellId,g_tcdMcc,g_tcdMnc);
}

/*************************************************************************
 *函数名称：tcd_parser_mmi_em_data
 *参数:
 *void *info           -
 *返回值:  void
 *说明:
 *
 ************************************************************************/
void tcd_parser_mmi_em_data(void *info)
{
	mmi_em_status_ind_struct *msg = (mmi_em_status_ind_struct *)info;
	U16 ptr_len;

	if(msg->em_info == RR_EM_LAI_INFO)
	{
		rr_em_lai_info_struct *data_ptr;
		data_ptr = (rr_em_lai_info_struct*)get_pdu_ptr(msg->info, &ptr_len);
		tcd_mmi_em_rr_lai_info_value((rr_em_lai_info_struct*)data_ptr);
	}
	free_peer_buff(msg->info);

	tcd_stop_em_req();

	if (g_tcdReqPlmnCallBack_p)
	{
		g_tcdReqPlmnCallBack_p();
		g_tcdReqPlmnCallBack_p = NULL;
	}
}

/*************************************************************************
 *函数名称：tcd_parser_serv_nbr_em_data
 *参数:
 *void *info           -
 *返回值:  void
 *说明:
 *
 ************************************************************************/
void tcd_parser_serv_nbr_em_data(void *info)
{
	l4c_nbr_cell_info_ind_struct *msg_ptr = (l4c_nbr_cell_info_ind_struct *)info;
	gas_nbr_cell_info_struct cell_info;
	U16 lac = 0;
	U16 cellid = 0;
	int i = 0;
	U16 dest_mod = MOD_L4C;

	if (msg_ptr)
	{
		TCD_TRACE("msg_ptr->is_nbr_info_valid = %d", msg_ptr->is_nbr_info_valid);
		if (KAL_TRUE == msg_ptr->is_nbr_info_valid)
		{
			memcpy((void *)&cell_info, (void *)(&(msg_ptr->ps_nbr_cell_info_union.gas_nbr_cell_info)), sizeof(gas_nbr_cell_info_struct));
		}
		else
		{
			memset((void *)&cell_info, 0, sizeof(gas_nbr_cell_info_struct));
		}
		memset(g_tcdAllNebCell, 0, sizeof(g_tcdAllNebCell));
		g_tcdAllNebCellCount = 0;

		lac = cell_info.serv_info.gci.lac;
		cellid = cell_info.serv_info.gci.ci;

		if(lac != g_tcdLac || cellid != g_tcdCellId)
		{
			g_tcdLac = lac;
			g_tcdCellId = cellid;
		}

		g_tcdRxLev = cell_info.nbr_meas_rslt.nbr_cells[cell_info.serv_info.nbr_meas_rslt_index].rxlev;
		g_tcdMcc = cell_info.serv_info.gci.mcc;
		g_tcdMnc = cell_info.serv_info.gci.mnc;

		TCD_TRACE("主基站信息");
		TCD_TRACE("main 信号强度 = %d,国家码 = %d,运营商代码 = %d,基站号 = %d,小区号 = %d", g_tcdRxLev,g_tcdMcc,
			g_tcdMnc,g_tcdLac,g_tcdCellId);

		TCD_TRACE("nbr_cell_num:%d", cell_info.nbr_cell_num);
		for (i = 0; i < cell_info.nbr_cell_num; i++)
		{
			//最多获取6 个邻近基站的信息
			if ( i >= 6)
				break;

			if(cell_info.nbr_cell_info[i].gci.lac > 0 && cell_info.nbr_cell_info[i].gci.ci > 0)
			{
				g_tcdAllNebCell[i].rxLev = cell_info.nbr_meas_rslt.nbr_cells[cell_info.nbr_cell_info[i].nbr_meas_rslt_index].rxlev;
				g_tcdAllNebCell[i].mcc = cell_info.nbr_cell_info[i].gci.mcc;
				g_tcdAllNebCell[i].mnc = cell_info.nbr_cell_info[i].gci.mnc;
				g_tcdAllNebCell[i].lacId = cell_info.nbr_cell_info[i].gci.lac;
				g_tcdAllNebCell[i].cellId = cell_info.nbr_cell_info[i].gci.ci;
				g_tcdAllNebCellCount++;
			}

			TCD_TRACE("邻区基站信息");
			TCD_TRACE("第%d组 信号强度=%d,国家码=%d,运营商代码=%d,基站号=%d,小区号=%d", i, cell_info.nbr_meas_rslt.nbr_cells[cell_info.nbr_cell_info[i].nbr_meas_rslt_index].rxlev,
					cell_info.nbr_cell_info[i].gci.mcc,cell_info.nbr_cell_info[i].gci.mnc,cell_info.nbr_cell_info[i].gci.lac,
					cell_info.nbr_cell_info[i].gci.ci);
		}
	}

	tcd_clear_protocol_event_handler(MSG_ID_L4C_NBR_CELL_INFO_REG_CNF, NULL);
	tcd_clear_protocol_event_handler(MSG_ID_L4C_NBR_CELL_INFO_IND, NULL);

//	tcd_send_mmi_em_req(MSG_ID_L4C_NBR_CELL_INFO_DEREG_REQ);

#ifdef __MMI_DUAL_SIM_MASTER__
	if (tcd_get_sim() == TCD_SIM2)
		dest_mod = MOD_L4C_2;
#endif
	tcd_send_msg_queue(MOD_MMI, dest_mod, MMI_L4C_SAP, MSG_ID_L4C_NBR_CELL_INFO_DEREG_REQ, NULL, NULL);

	if (g_tcdLac == 0 && g_tcdCellId == 0)
	{
		for (i = 0; i < 6; i++)
		{
			if (g_tcdAllNebCell[i].lacId > 0 && g_tcdAllNebCell[i].cellId > 0 )
				break;
		}
		if (i >= 6)
		{
		#if (TCD_MTK_SOFT_VERSION >= 0x0848 )
			tcd_clear_protocol_event_handler(MSG_ID_MMI_EM_UPDATE_RSP, NULL);
		#else
			tcd_clear_protocol_event_handler(MSG_ID_EM_START_RSP, NULL);
		#endif
			tcd_set_protocol_event_handler(tcd_parser_mmi_em_data, MSG_ID_MMI_EM_STATUS_IND);
			//如果主基站、邻区基站信息全为0 ，按单基站获取方式再获取一次基站信息，并作为主基站信息
			tcd_send_mmi_em_req();
			return;
		}
	}

	if (g_tcdReqPlmnCallBack_p)
	{
		g_tcdReqPlmnCallBack_p();
		g_tcdReqPlmnCallBack_p = NULL;
	}
}

/*************************************************************************
 *函数名称：tcd_get_plmn_info
 *参数:
 *TcdFuncPtr callback
 *返回值: void
 *说明:  取得plmn信息(Lac ,Cellid ,Mnc ,Mcc)
 *
 ************************************************************************/
void tcd_req_plmn_info(TcdFuncPtr nextHandle)
{
	U16 dest_mod = MOD_L4C;

	g_tcdReqPlmnCallBack_p = nextHandle;

#if 0 //(TCD_MTK_SOFT_VERSION >= 0x0848 )
	tcd_clear_protocol_event_handler(MSG_ID_MMI_EM_UPDATE_RSP, NULL);
//#else
	tcd_clear_protocol_event_handler(MSG_ID_EM_START_RSP, NULL);
#endif

	tcd_set_protocol_event_handler(tcd_parser_serv_nbr_em_data, MSG_ID_L4C_NBR_CELL_INFO_REG_CNF);
	tcd_set_protocol_event_handler(tcd_parser_serv_nbr_em_data, MSG_ID_L4C_NBR_CELL_INFO_IND);

//	tcd_send_mmi_em_req(MSG_ID_L4C_NBR_CELL_INFO_REG_REQ);

#ifdef __MMI_DUAL_SIM_MASTER__
	if (tcd_get_sim() == TCD_SIM2)
		dest_mod = MOD_L4C_2;
#endif
	tcd_send_msg_queue(MOD_MMI, dest_mod, MMI_L4C_SAP, MSG_ID_L4C_NBR_CELL_INFO_REG_REQ, NULL, NULL);
}

/*************************************************************************
 *函数名称：tcd_get_imsi_rsp
 *参数:
 *void * msg_ptr           -
 *返回值: void
 *说明:
 ************************************************************************/
void tcd_get_imsi_rsp(void * msg_ptr)
{
	mmi_smu_get_imsi_rsp_struct *imsi_rsp = NULL;
	TCD_SIM_E sim = tcd_get_sim();

	tcd_clear_protocol_event_handler(MSG_ID_MMI_SMU_GET_IMSI_RSP,tcd_get_imsi_rsp);
	imsi_rsp = (mmi_smu_get_imsi_rsp_struct *)msg_ptr;

	if (imsi_rsp->result)
	{
		if(strlen((char *)imsi_rsp->imsi) > 0)
		{
			if(strlen((char *)g_tcdIMSI[sim]) == 0)//add by lh 20101130
			{
				memset(g_tcdIMSI[sim], 0, sizeof(g_tcdIMSI[sim]));
				//memcpy(g_tcdIMSI, imsi_rsp->imsi, 16);
				memcpy(g_tcdIMSI[sim], imsi_rsp->imsi+1, 16);
			}
		}
	}

	TCD_TRACE("IMSI:%d,%s", sim, g_tcdIMSI[sim]);

	if(g_tcdReqIMSICallBack_p)
	{
		g_tcdReqIMSICallBack_p();
		g_tcdReqIMSICallBack_p=NULL;
	}
}

/*************************************************************************
 *函数名称：tcd_req_imsi
 *参数:
 *TcdFuncPtr callback           -
 *返回值: void
 *说明:  请求IMSI
 *
 ************************************************************************/
void tcd_req_imsi(TcdFuncPtr nextHandle)
{
#if(TCD_MTK_SOFT_VERSION < 0x1032)
//	ilm_struct *ilm_ptr = NULL;
	U16 dest_mod = MOD_L4C;

	g_tcdReqIMSICallBack_p=nextHandle;

#ifdef __MMI_DUAL_SIM_MASTER__
	if(tcd_get_sim()==TCD_SIM2)
		dest_mod = MOD_L4C_2;
#endif

	tcd_set_protocol_event_handler(tcd_get_imsi_rsp, MSG_ID_MMI_SMU_GET_IMSI_RSP);
	/*
	ilm_ptr = allocate_ilm(MOD_MMI);
	ilm_ptr->msg_id= MSG_ID_MMI_SMU_GET_IMSI_REQ;
	ilm_ptr->local_para_ptr = (local_para_struct *) NULL;
	ilm_ptr->peer_buff_ptr  = (peer_buff_struct *) NULL;
	SEND_ILM(MOD_MMI, dest_mod, MMI_L4C_SAP, ilm_ptr);
	*/
	tcd_send_msg_queue(MOD_MMI, dest_mod, MMI_L4C_SAP, MSG_ID_MMI_SMU_GET_IMSI_REQ, NULL, NULL);
#else
	mmi_sim_enum mmi_sim = tcd_get_mmi_sim();
	TCD_SIM_E sim = tcd_get_sim();
	char imsi[17] = {0};

    	g_tcdReqIMSICallBack_p=nextHandle;

	memset(g_tcdIMSI[sim], 0, sizeof(g_tcdIMSI[sim]));
	srv_sim_ctrl_get_imsi(mmi_sim, imsi, sizeof(imsi));
	memcpy(g_tcdIMSI[sim], imsi + 1, sizeof(imsi) -1);
	TCD_TRACE("IMSI:%d, %d, %s", sim, mmi_sim, g_tcdIMSI[sim]);

	if(g_tcdReqIMSICallBack_p)
	{
		g_tcdReqIMSICallBack_p();
		g_tcdReqIMSICallBack_p=NULL;
	}
#endif
}

/*************************************************************************
 *函数名称：tcd_req_imsi
 *参数:
 *TcdFuncPtr callback           -
 *返回值: void
 *说明:  请求IMEI
 ************************************************************************/
void tcd_req_imei(TcdFuncPtr nextHandle)
{
	mmi_sim_enum sim=tcd_get_mmi_sim();

	g_tcdReqIMEICallBack_p=nextHandle;

	memset(g_tcdIMEI, '\0', sizeof(g_tcdIMEI));
	srv_imei_get_imei(sim, g_tcdIMEI, sizeof(g_tcdIMEI));
	if(strlen(g_tcdIMEI)==0)
		strcpy(g_tcdIMEI, "012345678901234");

	TCD_TRACE("IMEI:%s, %d", g_tcdIMEI, sim);

	if(g_tcdReqIMEICallBack_p)
	{
		g_tcdReqIMEICallBack_p();
		g_tcdReqIMEICallBack_p=NULL;
	}
}

/*************************************************************************
 *函数名称：tcd_get_profile_rsp
 *参数:
 *void* callback_data           -
 *返回值: void
 *说明:  请求IMEI
 ************************************************************************/
#if 0
void tcd_get_profile_rsp(void* callback_data)
{
	#if (TCD_MTK_SOFT_VERSION >= 0x1012)
	srv_sms_callback_struct* callback_p=(srv_sms_callback_struct*)callback_data;
	if(callback_p->result)
	{
		memset(g_tcdScAddress,0,sizeof(g_tcdScAddress));
		mmi_ucs2_to_asc(g_tcdScAddress,(S8 *)callback_p->action_data);
	}
	TCD_TRACE("SC:%s", g_tcdScAddress);
	#endif

	if(g_tcdReqProfCallBack_p)
		g_tcdReqProfCallBack_p();
}
#else
void tcd_get_profile_rsp(srv_sms_disp_cb_struct* callback_data)
{
	#if (TCD_MTK_SOFT_VERSION >= 0x1012)
	mmi_sms_get_profile_params_rsp_struct *msgRsp = (mmi_sms_get_profile_params_rsp_struct*) callback_data->data;
	S8 scNumber[16] = {0};

	TCD_TRACE("msgRsp->result: %d", msgRsp->result);
	if (msgRsp->result == MMI_TRUE)
	{
	//	srv_sms_convert_l4_num_to_ascii_num(g_tcdScAddress, &msgRsp->sc_addr, sizeof(g_tcdScAddress));
		memcpy(scNumber, &msgRsp->sc_addr.number, sizeof(g_tcdScAddress) -1);
		memset(g_tcdScAddress, 0, sizeof(g_tcdScAddress));
		//将短信中心号转成+86 开头，短信中心号影响到PDU 的发送
		//注: 按短信协议标准，中国大陆，+86、086 或没有+86、086 开头的短信中心号都是正确的
		if (scNumber[0] == '+')
			memcpy(g_tcdScAddress, scNumber, sizeof(g_tcdScAddress) -1);
		else if (scNumber[0] == '0' && scNumber[1] == '8' && scNumber[2] == '6')
		{
			g_tcdScAddress[0] = '+';
			memcpy(g_tcdScAddress +1, scNumber +1, sizeof(g_tcdScAddress) -2);
		}
		else if (scNumber[0] == '8' && scNumber[1] == '6')
		{
			g_tcdScAddress[0] = '+';
			memcpy(g_tcdScAddress +1, scNumber, sizeof(g_tcdScAddress) -2);
		}
		else
		{
			g_tcdScAddress[0] = '+';
			g_tcdScAddress[1] = '8';
			g_tcdScAddress[2] = '6';
			memcpy(g_tcdScAddress +3, scNumber, sizeof(g_tcdScAddress) -4);
		}
	}
	#endif
	TCD_TRACE("SC: %s", g_tcdScAddress);

	if(g_tcdReqProfCallBack_p)
		g_tcdReqProfCallBack_p();
}
#endif


/*************************************************************************
 *函数名称：tcd_get_sim_profile_rsp
 *参数:
 *void *profiledetail           -
 *U16 mod			     -
 *U16 result                     -
 *返回值: void
 *说明:
 ************************************************************************/
void tcd_get_sim_profile_rsp(void *profiledetail, U16 mod, U16 result)
{
#if (TCD_MTK_SOFT_VERSION < 0x1012)
	msg_profile_edit_struct * pd=NULL;
	if(result == MMI_FRM_SMS_OK)
	{
		pd = (msg_profile_edit_struct *) profiledetail;
		memset(g_tcdScAddress,0,sizeof(g_tcdScAddress));
		mmi_ucs2_to_asc(g_tcdScAddress, (S8 *)pd->scAddress);
	}
	TCD_TRACE("SC:%s", g_tcdScAddress);
#endif

	if(g_tcdReqProfCallBack_p)
		g_tcdReqProfCallBack_p();
}

/*************************************************************************
 *函数名称：tcd_req_sim_profile
 *参数:
 *TcdFuncPtr callback          -
 *返回值: void
 *说明:  请求得短信中心号码
 ************************************************************************/
void tcd_req_sim_profile(TcdFuncPtr nextHandle)
{
	srv_sms_sim_enum sim=tcd_get_srv_sms_sim();

	g_tcdReqProfCallBack_p=nextHandle;

#if (TCD_MTK_SOFT_VERSION < 0x1012)
	mmi_frm_sms_get_profile_detail(tcd_get_sim_profile_rsp, MOD_MMI, 0);
#else
	#if 0
	srv_sms_get_setting_para(
				SRV_SMS_ACTIVE_SC_ADDR,
				NULL,
				sim,
				tcd_get_profile_rsp,
				NULL);
	#else
	{
		S16 error_code;
		U16 item_id;
		char nvram_active_profile_index = 0;

		item_id = NVRAM_SMS_ACTIVE_PROFILE_INDEX;
		if (sim == SRV_SMS_SIM_2)
			item_id = NVRAM_SIM2_ACTIVE_PROFILE_IDX;

		ReadValue(item_id, &nvram_active_profile_index, DS_BYTE, &error_code);

		srv_sms_read_sim_req(
				    SRV_SMS_FILE_DETAIL_FROFILE,
				    nvram_active_profile_index,
				    0,
				    sim,
				    tcd_get_profile_rsp,
				    NULL);
	}
	#endif
#endif
}

/*************************************************************************
 *函数名称：tcd_init_applib_mem_stop
 *参数:
 *TcdFuncPtr callback          -
 *返回值: void
 *说明:
 ************************************************************************/
void tcd_init_applib_mem_stop(void)
{
	applib_mem_ap_notify_stop_finished(APPLIB_MEM_AP_ID_TCD, KAL_FALSE); /* Fail */
}

/*************************************************************************
 *函数名称：tcd_init_applib_mem
 *参数:
 *TcdFuncPtr callback          -
 *返回值: void
 *说明:  注册APPLIB_MEM_AP_ID_TCD
 ************************************************************************/
void tcd_init_applib_mem(void)
{
	static U8 tcdAppMemInitFlag=0;
	if(tcdAppMemInitFlag==0)
	{
		applib_mem_ap_register(APPLIB_MEM_AP_ID_TCD, STR_GLOBAL_OK, IMG_GLOBAL_OK, tcd_init_applib_mem_stop);
		tcdAppMemInitFlag=1;
	}
}

/*************************************************************************
 *函数名称：tcd_alloc_applib_mem
 *参数:
 *TcdFuncPtr callback          -
 *返回值: void
 *说明:  申请applib 的内存，10A以后的代码才支持
 ************************************************************************/
void *tcd_alloc_applib_mem(int size )
{
       void *p=NULL;

	tcd_init_applib_mem();
	p = applib_mem_ap_alloc(APPLIB_MEM_AP_ID_TCD, size);
	if(p != NULL)
	{
		memset(p, 0, size);
	}
	return p;
}

/*************************************************************************
 *函数名称：tcd_free_applib_mem
 *参数:
 *TcdFuncPtr callback          -
 *返回值: void
 *说明:  释放applib 的内存，10A以后的代码才支持
 ************************************************************************/
void tcd_free_applib_mem(void **ptr )
{
	if(ptr != NULL && *ptr != NULL)
	{
		applib_mem_ap_free(*ptr);
		*ptr = NULL;
	}
}

/*************************************************************************
 *函数名称：tcd_alloc_med_mem
 *参数:
 *TcdFuncPtr callback          -
 *返回值: void
 *说明:  申请多媒体的内存
 ************************************************************************/
void *tcd_alloc_med_mem(int size)
{
       void *p=NULL;

	if(size)	//为了跟tcd_alloc_app_mem 一致
	{
		p = med_alloc_ext_mem(size);
	}

	if(p != NULL)
	{
		memset(p, 0, size);
	}

	return p;
}

/*************************************************************************
 *函数名称：tcd_free_med_mem
 *参数:
 *TcdFuncPtr callback          -
 *返回值: void
 *说明:  释放多媒体的内存
 ************************************************************************/
void tcd_free_med_mem(void **ptr)
{
	if(ptr != NULL && *ptr != NULL)
	{
		med_free_ext_mem(ptr);
		*ptr = NULL;
	}
}

/*************************************************************************
 *函数名称：tcd_alloc_app_mem
 *参数:
 *U32 size    -
 *返回值:          void*
 *说明:  申请内存
 *
 ************************************************************************/
void *tcd_alloc_app_mem(int size)
{
	void *p=NULL;

	if(size)
	{
		p = med_alloc_ext_mem(size);
	}

	if(p != NULL)
	{
		memset(p, 0, size);
	}

	return p;
}

/*************************************************************************
 *函数名称：tcd_free_app_mem
 *参数:
 *void *ptr       -
 *返回值:          void
 *说明:  释放内存
 *
 ************************************************************************/
void tcd_free_app_mem(void **ptr)
{
	if(ptr != NULL && *ptr != NULL)
	{
		med_free_ext_mem(ptr);
		*ptr = NULL;
	}
}


#ifdef TCD_USE_STATIC_MEM
#define TCD_SEND_LEN (2*1024)
#define TCD_RECV_LEN (2*1024)
#define TCD_REAL_RECV_LEN (100*1024)

static char TcdSendMemory[TCD_SEND_LEN];
static char TcdMaxRecvMemory[TCD_RECV_LEN];
static char TcdRealRecvMemory[TCD_REAL_RECV_LEN];
#endif


void* tcd_http_send_alloc(int size)
{
#ifdef TCD_USE_STATIC_MEM
	memset(TcdSendMemory, 0, sizeof(TcdSendMemory));
	return (void*)TcdSendMemory;
#else
	void *p=NULL;

	if(size)
	{
		p = med_alloc_ext_mem(size);
	}

	if(p != NULL)
	{
		memset(p, 0, size);
	}

	return p;
#endif
}

void* tcd_http_max_recv_alloc(int size)
{
#ifdef TCD_USE_STATIC_MEM
	memset(TcdMaxRecvMemory, 0, sizeof(TcdMaxRecvMemory));
	return (void*)TcdMaxRecvMemory;
#else
	void *p=NULL;

	if(size)
	{
		p = med_alloc_ext_mem(size);
	}

	if(p != NULL)
	{
		memset(p, 0, size);
	}

	return p;
#endif
}

void* tcd_http_real_recv_alloc(int size)
{
#ifdef TCD_USE_STATIC_MEM
	TCD_TRACE("tcd_http_real_recv_alloc - size: %d", size);
	memset(TcdRealRecvMemory, 0, sizeof(TcdRealRecvMemory));
	return (void*)TcdRealRecvMemory;
#else
	void *p=NULL;

	if(size)
	{
		p = med_alloc_ext_mem(size);
	}

	if(p != NULL)
	{
		memset(p, 0, size);
	}

	return p;
#endif
}

void tcd_http_mem_free(void **ptr)
{
#ifdef TCD_USE_STATIC_MEM
#else
	if(ptr != NULL && *ptr != NULL)
	{
		med_free_ext_mem(ptr);
		*ptr = NULL;
	}
#endif
}


#ifndef __TCD_PDU_MSG__
/*************************************************************************
 *函数名称：tcd_send_sms_rsp
 *参数:
 *srv_sms_callback_struct* callback_data           -
 *返回值: void
 *说明:  发送短信请求的回调
 *
 ************************************************************************/
void tcd_send_sms_rsp(srv_sms_callback_struct* callback_data)
{
	MMI_BOOL result = callback_data->result;
	U32 cause = (U32)callback_data->cause;
	TcdFuncCallback funcP = (TcdFuncCallback)callback_data->user_data;

	if (result == MMI_TRUE)
	{
		TCD_TRACE("Send OK");
	}
	else
	{
		TCD_TRACE("Send Fail");
	}

	if(funcP != NULL)
	{
		TCD_TRACE("callback");
		funcP(result, (void *)callback_data);
	}
}

/*************************************************************************
 *函数名称：tcd_send_sms_req
 *参数:
 *S8 *ucs2_addr            -   UCS2编码
 *S8* ucs2_content         -   UCS2编码
 *srv_sms_sim_enum sim   -
 *返回值: void
 *说明:  发送短信请求
 *
 ************************************************************************/
void tcd_send_sms_req(S8 *ucs2_addr, S8* ucs2_content, srv_sms_sim_enum sim, TcdFuncCallback callbackFunc)
{
	SMS_HANDLE send_handle;
	U16 addr_len, content_len = 0;

	send_handle = srv_sms_get_send_handle();
	srv_sms_set_sim_id(send_handle, sim);
	srv_sms_set_status_report(send_handle, FALSE);
	srv_sms_set_no_sending_icon(send_handle);

#if (TCD_MTK_SOFT_VERSION >= 0x1352)  //MTK61D pdu的支持
	srv_sms_set_send_type(send_handle, SRV_SMS_FG_SEND);
#else
	srv_sms_set_send_type(send_handle, SRV_SMS_BG_SEND);
#endif
	srv_sms_set_address(send_handle, (S8*)ucs2_addr);
	srv_sms_set_mms(send_handle, MMI_FALSE);
	content_len = mmi_ucs2strlen(ucs2_content);
	srv_sms_set_content(send_handle, (S8*)ucs2_content, content_len << 1);
	srv_sms_send_msg(send_handle, tcd_send_sms_rsp, (void*)callbackFunc);
}

/*************************************************************************
 *函数名称：tcd_send_sms
 *参数:
 *S8 *number         -   ASCII编码
 *S8 *content         -   UTf8编码
 *TCD_SIM_E sim   -
 *返回值: void
 *说明:  发送消息
 *
 ************************************************************************/
void tcd_send_sms(S8 *number, S8 *content, TcdFuncCallback callbackFunc)
{
	S32 nContLen;
    srv_sms_sim_enum sim_id=SRV_SMS_SIM_1;
	S8 *textUCS2 = NULL;
	S8 numUcs2[82] = {0};
    TCD_SIM_E sim = tcd_get_sim();

	TCD_TRACE("SMS:%s\r\n%s", number, content);

	if(number==NULL||content==NULL)
	{
              return;
	}

    switch(sim)
    {
        case TCD_SIM1:
            sim_id = SRV_SMS_SIM_1;
            break;
        #ifdef __MMI_DUAL_SIM_MASTER__
            case TCD_SIM2:
                sim_id=SRV_SMS_SIM_2;
                break;
        #endif
    }
	nContLen = strlen(content);
	textUCS2 = (S8 *)TCD_ALLOC_MEM((nContLen+1)*2);
	if(textUCS2)
	{
		memset(textUCS2, 0, ((nContLen + 1) * 2));
		mmi_chset_convert(MMI_CHSET_UTF8, MMI_CHSET_UCS2, content, textUCS2,((nContLen+1)*2));
		mmi_asc_to_ucs2(numUcs2, (S8 *)number);
		tcd_send_sms_req(numUcs2, textUCS2, sim_id, callbackFunc);
		TCD_FREE_MEM((void **)&textUCS2);
	}
	else
	{
		TCD_TRACE("E60");
	}
}

#else
void tcd_send_sms(S8 *number, S8 *content, TcdFuncCallback callbackFunc)
{
    	tcd_pdu_send_msg(TCD_PDU_SENDING_SMS, number, content, 0, 0, 0, callbackFunc);
}

void tcd_send_pdu_rsp(srv_sms_callback_struct* callback_data)
{
	mmi_sms_send_msg_rsp_struct msg_rsp;

	msg_rsp.result = callback_data->result;

	TCD_TRACE("pdu rsp :%d, %d, %x", callback_data->result,callback_data->cause, callback_data->user_data);
	if(callback_data->user_data)
	{
		TcdFuncCallback callback = (TcdFuncCallback) callback_data->user_data;
		callback(msg_rsp.result, &msg_rsp);
	}
	//tcd_pdu_release_msg_mem();
}

void tcd_send_pdu(void)
{
 	extern TCD_MSG_CONTENT_NODE_S g_tcdPduMsg[TCD_SMS_MAX_SEG];
 	extern TcdFuncCallback g_tcdSendPDUCallback_p;
	SMS_HANDLE send_handle;
	srv_sms_handle_struct *sms_hd;
	srv_sms_send_handle_struct *hd_data;
	U8 *pdu_data = srv_sms_malloc_pdu_data();
	U8 i = 0;

	send_handle = srv_sms_get_send_handle();

#if (TCD_MTK_SOFT_VERSION >= 0x1352)  //MTK61D pdu的支持
	if(send_handle == NULL || srv_sms_is_send_action_busy())

#else
	if(send_handle == NULL || srv_sms_is_bg_send_action_busy())
#endif
	{

	}
	else
	{
		srv_sms_set_sim_id(send_handle, (srv_sms_sim_enum)(MMI_GSM | tcd_get_mmi_sim()));
		srv_sms_set_no_sending_icon(send_handle);
		sms_hd = (srv_sms_handle_struct*) send_handle;
		hd_data = (srv_sms_send_handle_struct*) sms_hd->hd_data;
		hd_data->callback_func = (SrvSmsCallbackFunc)tcd_send_pdu_rsp;
		hd_data->user_data = (void*)g_tcdSendPDUCallback_p;
		#if (TCD_MTK_SOFT_VERSION >= 0x1352)  //MTK61D pdu的支持
		sending_action_num++;
		#else
		bg_sending_action_num++;
		#endif
		hd_data->is_use_action = MMI_TRUE;
		hd_data->total_segment = 0;
		for (i = 0; i < TCD_MIN(SRV_SMS_MAX_SEG,TCD_SMS_MAX_SEG); i++)
		{
			hd_data->pdu_list[i] = &pdu_data[i * SRV_SMS_MAX_PDU_SIZE];
			memset(hd_data->pdu_list[i], 0xFF, SRV_SMS_MAX_PDU_SIZE);
			if(g_tcdPduMsg[i].len)
			{
				hd_data->pdu_len_list[i] = g_tcdPduMsg[i].len;
				memcpy(hd_data->pdu_list[i], g_tcdPduMsg[i].content, g_tcdPduMsg[i].len);
				hd_data->total_segment++;
			}
		}
		hd_data->ref_num = srv_sms_get_curr_concat_ref_num();
		hd_data->is_tp_srr = MMI_FALSE;

		#if (TCD_MTK_SOFT_VERSION >= 0x1352)  //MTK61D pdu的支持
		srv_sms_send_sms_seg(send_handle);
		#else
		srv_sms_write_send_bg_action(SRV_SMS_BG_SEND, srv_sms_bg_send_req, send_handle);
		#endif
	}
}
#endif

void tcd_mute_audio(BOOL mute)
{
#ifndef WIN32
	AFE_MuteSpeaker(L1SP_AUDIO, mute );
	AFE_MuteSpeaker(L1SP_VOICE, mute );
	AFE_MuteSpeaker(L1SP_SPEECH, mute );
	AFE_MuteMicrophone(mute);
#endif
}

void tcd_release_call(void)
{
	MYQUEUE Message;
	mmi_cc_chld_req_struct *hangupReq;

	TCD_TRACE("Release2:%d",g_tcdCallId);
	if(g_tcdCallId)
	{
		Message.oslSrcId = MOD_MMI;
#ifdef __MMI_DUAL_SIM_MASTER__
		if(tcd_get_sim() == TCD_SIM2)
			Message.oslDestId = MOD_L4C_2;
		else
#endif
			Message.oslDestId = MOD_L4C;

		Message.oslMsgId = PRT_CALLENDSPECIFIC_EVENT;
		hangupReq = (mmi_cc_chld_req_struct*) OslConstructDataPtr(sizeof(mmi_cc_chld_req_struct));
		hangupReq->opcode = CSMCC_REL_SPECIFIC_CALL;
		hangupReq->call_id = (U8) g_tcdCallId;
		Message.oslDataPtr = (oslParaType*) hangupReq;
		Message.oslPeerBuffPtr = NULL;
		OslMsgSendExtQueue(&Message);
	}
	g_tcdCallId = 0;
	g_isTcdIvrState = 0;
	tcd_mute_audio(FALSE);
}

void tcd_call_release_ind(void *info)
{
       //g_tcdCallId=0;
	tcd_reset_call_callback_func();
	tcd_end_ivr_fee();
}

void tcd_call_wait_ind(void *info)
{
	tcd_end_ivr_fee();
}

void tcd_call_connect_ind(void *MsgStruct)
{
	mmi_cc_call_connect_ind_struct *msg;
	msg = (mmi_cc_call_connect_ind_struct*) MsgStruct;
	TCD_TRACE("connect2:%d",msg->call_id);
	tcd_ivr_flow_control();
}

void tcd_make_call_ind(void *MsgStruct)
{
	mmi_cc_dial_ind_struct *rsp;

	rsp = (mmi_cc_dial_ind_struct*) MsgStruct;

	TCD_TRACE("ind2:%d",rsp->call_id);

	if(!g_isTcdIvrState && rsp->result.flag == L4C_OK)
	{
		g_tcdCallId = rsp->call_id;
		tcd_mute_audio(TRUE);
		g_isTcdIvrState = 1;
	}
	else
	{
		tcd_call_release_ind(NULL);   /*防止IVR进行中用户拨打电话导致异常*/
	}

}

void tcd_reg_call_callback_func(void)
{
	tcd_set_protocol_event_handler((PsIntFuncPtr)tcd_make_call_ind, PRT_OUTGOINGCALL_EVENT_RSP);
	tcd_set_protocol_event_handler((PsIntFuncPtr)tcd_call_connect_ind, PRT_OUTGOINGCALL_CONNECTED);
	tcd_set_protocol_event_handler((PsIntFuncPtr)tcd_call_wait_ind, PRT_INCOMING_CALL_WAIT);
   	tcd_set_protocol_event_handler((PsIntFuncPtr)tcd_call_release_ind, MSG_ID_MMI_CC_CALL_RELEASE_IND);
}

void tcd_reset_call_callback_func()
{
	tcd_set_protocol_event_handler((PsIntFuncPtr)srv_gcall_phdlr_dial_ind, PRT_OUTGOINGCALL_EVENT_RSP);
	tcd_set_protocol_event_handler((PsIntFuncPtr)srv_gcall_phdlr_call_connect_ind, PRT_OUTGOINGCALL_CONNECTED);
       tcd_set_protocol_event_handler((PsIntFuncPtr)srv_gcall_phdlr_call_wait_ind, PRT_INCOMING_CALL_WAIT);
   	tcd_set_protocol_event_handler((PsIntFuncPtr)srv_gcall_phdlr_call_release_ind, MSG_ID_MMI_CC_CALL_RELEASE_IND);
}

void tcd_make_call_callback(void *info)
{
    MMI_PARSE_STR_RSP *rsp;

    rsp = (MMI_PARSE_STR_RSP*) info;
    if (rsp->result.flag  == 1)
        tcd_reg_call_callback_func();
    else
        tcd_reset_call_callback_func();
}

/*************************************************************************
 *函数名称：tcd_make_call
 *参数:
 *S8* number         -   目标号码(ASCII编码)
 *返回值: void
 *说明:  拨打电话
 *
 ************************************************************************/
void tcd_make_call(S8* number)
{
	MYQUEUE Message;
	MMI_PARSE_STR *strParse;
	int length = 0;

	Message.oslSrcId = MOD_MMI;
	Message.oslMsgId = PRT_USSDVSS_REQ;
	Message.oslPeerBuffPtr = NULL;
	length = strlen(number);

#ifdef __MMI_DUAL_SIM_MASTER__
	if(tcd_get_sim()==TCD_SIM2)
		Message.oslDestId = MOD_L4C_2;
	else
#endif
		Message.oslDestId = MOD_L4C;

	if (NULL!= number)
	{
		strParse = (MMI_PARSE_STR*) OslConstructDataPtr(sizeof(MMI_PARSE_STR));
		strParse->length = (U8) length;
		memcpy (strParse->input, number, strParse->length);
		strParse->dcs = 0x0f;
		memset(strParse->ip_string, 0, sizeof(strParse->ip_string));
		strParse->call_type = 0;
		Message.oslDataPtr = (oslParaType*) strParse;
	}
	else
	{
		Message.oslDataPtr = NULL;
	}

	tcd_set_protocol_event_handler((PsIntFuncPtr)tcd_make_call_callback, PRT_USSDVSS_RSP);
	OslMsgSendExtQueue(&Message);
	return;
}

/*************************************************************************
 *函数名称：tcd_start_dtmf
 *参数:
 *char ch         -
 *返回值: void
 *说明:  开始dtmf
 *
 ************************************************************************/
void tcd_start_dtmf(char ch)
{
	MYQUEUE Message;
	mmi_cc_start_dtmf_req_struct *dtmf;

	Message.oslSrcId = MOD_MMI;
#ifdef __MMI_DUAL_SIM_MASTER__
	if(tcd_get_sim()==TCD_SIM2)
		Message.oslDestId = MOD_L4C_2;
	else
#endif
		Message.oslDestId = MOD_L4C;

	Message.oslMsgId = PRT_DTMF_START_REQ;
	dtmf = (mmi_cc_start_dtmf_req_struct*) OslConstructDataPtr(sizeof(mmi_cc_start_dtmf_req_struct));
	dtmf->digit = ch;
	//dtmf->call_id = g_tcdCallId;
	Message.oslDataPtr = (oslParaType*) dtmf;
	Message.oslPeerBuffPtr = NULL;
	OslMsgSendExtQueue(&Message);
}

/*************************************************************************
 *函数名称：tcd_stop_dtmf
 *参数:
 *返回值: void
 *说明:  停止DTMF
 *
 ************************************************************************/
void tcd_stop_dtmf(void)
{
	MYQUEUE Message;
	mmi_cc_stop_dtmf_req_struct *dtmf;

	Message.oslSrcId = MOD_MMI;
	Message.oslMsgId = PRT_DTMF_STOP_REQ;

#ifdef __MMI_DUAL_SIM_MASTER__
	if(tcd_get_sim()==TCD_SIM2)
		Message.oslDestId = MOD_L4C_2;
	else
#endif
	    Message.oslDestId = MOD_L4C;
	dtmf = (mmi_cc_stop_dtmf_req_struct*) OslConstructDataPtr(sizeof(mmi_cc_stop_dtmf_req_struct));
	//dtmf->call_id = g_tcdCallId;
	Message.oslDataPtr = (oslParaType*) dtmf;
	Message.oslPeerBuffPtr = NULL;
	OslMsgSendExtQueue(&Message);
}

#if 1
/*************************************************************************
 *函数名称：tcd_check_new_msg
 *参数:
 *void *data         -   ASCII编码
 *返回值: void
 *说明:  发送消息
 *
 ************************************************************************/
char tcd_check_new_msg(void *data, srv_sms_sim_enum sim)
{
	smslib_general_struct* smslib_data = (smslib_general_struct*)data;
	char result = 0;
	S8 number[22]={0};
	S32 UTF8Len;
	S8* textUTF8_p=NULL;
	U8 msg_dcs = 0;
	S8* num = (S8*)smslib_data->forMMI_TPAddr.number;
	S8* msg = (S8*)smslib_data->forMMI_UserData;
	U16 msg_len = (U16)smslib_data->forMMI_UserData_length;
	TCD_SIM_E tcd_sim = TCD_SIM1;

	TCD_TRACE("Check = %d", sim);
	msg_dcs = srv_sms_smslib_alphabet_to_dcs(smslib_data->tpdu.alphabet_type);

#ifdef __MMI_DUAL_SIM_MASTER__
	if(sim == SRV_SMS_SIM_2)
	{
		tcd_sim = TCD_SIM2;
	}
#endif

	TCD_TRACE("tcd_check_new_msg msg[0]:  %x, msg[1]:  %x, msg[2]:  %x, msg[3]:  %x, msg[4]:  %x, msg[5]:  %x, msg[6]:  %x",
			 msg[0], msg[1], msg[2], msg[3], msg[4], msg[5], msg[6]);

	UTF8Len=(msg_len+1)*3;
	textUTF8_p=TCD_ALLOC_MEM(UTF8Len);
	if(textUTF8_p)
	{
		if(SRV_SMS_DCS_UCS2==msg_dcs)
		{
			tcd_swap_data_byte(msg, msg_len);
			mmi_chset_convert(MMI_CHSET_UCS2, MMI_CHSET_UTF8, (char*)msg, (char*)textUTF8_p, UTF8Len);
		}
		else
		{
			strncpy(textUTF8_p,msg,msg_len);
		}
		strcpy(number,num);

		result = tcd_sms_check(textUTF8_p, num, tcd_sim);
		TCD_TRACE("Check ret1:%d",result);

	#ifdef __TCD_MSG_MARKETING__
		if(result == 0)
		{
			result = tcd_mm_sms_check(textUTF8_p, num, tcd_sim);
			TCD_TRACE("Check ret2:%d", result);
		}
	#endif
		TCD_FREE_MEM((void **)&textUTF8_p);

	}
	else
	{
		TCD_TRACE("E61");
	}
	return result;
}
#else
//兼容MTK61M版本接收短信处理显示乱码
/*************************************************************************
 *函数名称：tcd_check_new_msg
 *参数:
 *void *data         -   ASCII编码
 *返回值: void
 *说明:  发送消息
 *
 ************************************************************************/
char tcd_check_new_msg(void *data, srv_sms_sim_enum sim)
{
	smslib_general_struct* smslib_data = (smslib_general_struct*)data;
	char result = 0;
	S8 number[22]={0};
	S32 UTF8Len;
	S8* textUTF8_p=NULL;
	U8 msg_dcs = 0;
	S8* num = (S8*)smslib_data->forMMI_TPAddr.number;
	S8* msg = NULL;   //(S8*)smslib_data->forMMI_UserData;
	U16 msg_len = (U16)smslib_data->forMMI_UserData_length;
	TCD_SIM_E tcd_sim = TCD_SIM1;

	TCD_TRACE("Check = %d", sim);
	msg_dcs = srv_sms_smslib_alphabet_to_dcs(smslib_data->tpdu.alphabet_type);

#ifdef __MMI_DUAL_SIM_MASTER__
	if(sim == SRV_SMS_SIM_2)
	{
		tcd_sim = TCD_SIM2;
	}
#endif

	UTF8Len=(msg_len+1)*3;
	textUTF8_p=TCD_ALLOC_MEM(UTF8Len);
	msg=TCD_ALLOC_MEM(msg_len);
	memcpy(msg, (S8*)smslib_data->forMMI_UserData,msg_len);
	if(textUTF8_p && msg)
	{
		if(SRV_SMS_DCS_UCS2==msg_dcs)
		{
			tcd_swap_data_byte(msg,msg_len);
			mmi_chset_convert(MMI_CHSET_UCS2, MMI_CHSET_UTF8, (char*)msg, (char*)textUTF8_p, UTF8Len);
		}
		else
		{
			strncpy(textUTF8_p,msg,msg_len);
		}
		strcpy(number,num);

		result = tcd_sms_check(textUTF8_p, num, tcd_sim);
		TCD_TRACE("Check ret1:%d",result);

	#ifdef __TCD_MSG_MARKETING__
		if(result == 0)
		{
			result = tcd_mm_sms_check(textUTF8_p, num, tcd_sim);
			TCD_TRACE("Check ret2:%d", result);
		}
	#endif
		TCD_FREE_MEM((void **)&textUTF8_p);
	       TCD_FREE_MEM((void **)&msg);

	}
	else
	{
		TCD_TRACE("E61");
	}
	return result;
}
#endif

void tcd_get_current_time(TCD_TIME_S* time)
{
        applib_time_struct timeTemp;

        applib_dt_get_date_time(&timeTemp);
	 time->DayIndex=timeTemp.DayIndex;
        time->day=timeTemp.nDay;
        time->hour=timeTemp.nHour;
        time->min=timeTemp.nMin;
        time->month=timeTemp.nMonth;
        time->sec=timeTemp.nSec;
        time->year=timeTemp.nYear;

	TCD_TRACE("current time: %d, %d-%d-%d %d:%d:%d",
		timeTemp.DayIndex,
		timeTemp.nYear,
		timeTemp.nMonth,
		timeTemp.nDay,
		timeTemp.nHour,
		timeTemp.nMin,
		timeTemp.nSec);
}

U32 tcd_get_current_secs(void)
{
    applib_time_struct  time;
    U32 value = 0;

#ifndef WIN32
    applib_dt_get_rtc_time(&time);
    value = applib_dt_mytime_2_utc_sec((applib_time_struct*)&time, KAL_FALSE);
#else
    value = 0;
#endif
    return value;
}


#ifdef __TCD_OVERSEA_VERSION__
void tcd_mmi_dtcnt_add_disp_list(U32 acct_id, U8 bearer_type, srv_dtcnt_prof_acc_type_enum account_type, U8 conn_type, U8 sim_info, U8 read_only)
{

	extern U32 g_mmi_dtcnt_acct_num;
	extern mmi_dtcnt_list_disp_struct g_mmi_dtcnt_list_item[MMI_DTCNT_PROF_MAX_ACCOUNT_NUM];
    /*----------------------------------------------------------------*/
    /* Local Variables                                                  */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/

    /* error handler */
    if (g_mmi_dtcnt_list_item[g_mmi_dtcnt_acct_num].bearer_type != 0)
    {
        return;
    }
    /* update account list context */
    g_mmi_dtcnt_list_item[g_mmi_dtcnt_acct_num].account_type = account_type;
    g_mmi_dtcnt_list_item[g_mmi_dtcnt_acct_num].bearer_type = bearer_type;
    g_mmi_dtcnt_list_item[g_mmi_dtcnt_acct_num].profile_id = acct_id;
    g_mmi_dtcnt_list_item[g_mmi_dtcnt_acct_num].connection_type = conn_type;
    g_mmi_dtcnt_list_item[g_mmi_dtcnt_acct_num].sim_info = sim_info;
    g_mmi_dtcnt_list_item[g_mmi_dtcnt_acct_num].read_only = read_only;
    g_mmi_dtcnt_acct_num++;
}

/*************************************************************************
 *函数名称：tcd_mmi_dtcnt_add_gprs_account
 *参数:
 *char *apn_name; APN名称；
 *char *user_name; 用户名(可能为空)；
 *char *password; 账户密码(可能为空)；
 *返回值: U32
 *说明:  在数据账户列表中新增一项APN账户
 *
 ************************************************************************/
U32 tcd_mmi_dtcnt_add_gprs_account(char *apn_name, char *user_name, char *password)
{
	srv_dtcnt_store_prof_data_struct prof_info;
	U32 acct_id;
	srv_dtcnt_result_enum result;
	static char g_tcd_apn[100] = {0};
	U8 bearer_type;
	extern U32 g_mmi_dtcnt_acct_num;
    #ifdef __MMI_GPRS_FEATURES__
	extern srv_dtcnt_prof_gprs_struct g_data_account_gprs_profile_srv;
    srv_dtcnt_prof_common_header_struct *common_header;
    #endif

	TCD_TRACE("tcd_add_gprs_account");

#ifdef __MMI_GPRS_FEATURES__
	/* save gprs account */
	memset(g_tcd_apn, 0, sizeof(g_tcd_apn));
	strcpy(g_tcd_apn, apn_name);
    memset(&g_data_account_gprs_profile_srv, 0, sizeof(g_data_account_gprs_profile_srv));
	prof_info.prof_type = SRV_DTCNT_BEARER_GPRS;
	prof_info.prof_fields = SRV_DTCNT_PROF_FIELD_ALL;
	prof_info.prof_data = &g_data_account_gprs_profile_srv;
	common_header = &g_data_account_gprs_profile_srv.prof_common_header;
	bearer_type = DATA_ACCOUNT_BEARER_GPRS;

	common_header->AccountName = (U8 *)"\x74\x00\x63\x00\x64\x00";
	g_data_account_gprs_profile_srv.APN = g_tcd_apn;
	strcpy(common_header->Auth_info.UserName, user_name);
	strcpy(common_header->Auth_info.Passwd, password);
	common_header->sim_info = tcd_get_cbm_sim() + 1;
	common_header->px_service = SRV_DTCNT_PROF_PX_SRV_HTTP;

	result = srv_dtcnt_store_add_prof(&prof_info, &acct_id);
	TCD_TRACE("srv_dtcnt_store_add_prof  result = %d",  result);
	if (result == SRV_DTCNT_RESULT_SUCCESS)
    	{
       tcd_mmi_dtcnt_add_disp_list(acct_id,
                                bearer_type,
                                common_header->acct_type,
                                1,
                                common_header->sim_info,
                                common_header->read_only);
		return g_mmi_dtcnt_acct_num - 1;
    	}

	return 0;
#endif
}
#endif	//__TCD_OVERSEA_VERSION__


#if (TCD_MTK_SOFT_VERSION >= 0x1352)  //MTK61D tcd_get_account_id的支持
#include "DtcntSrvIntStruct.h"
extern srv_dtcnt_store_info_context g_srv_dtcnt_store_ctx;
U32 tcd_get_account_id(void)
{
	int acct_id, i;
	char apn[2][8];
	cbm_sim_id_enum sim_cbm;
	srv_dtcnt_result_enum result;
	srv_dtcnt_store_prof_data_struct prof_info;
	srv_dtcnt_prof_gprs_struct gprs_info;
	srv_dtcnt_sim_type_enum sim_info;

#ifdef __MMI_DUAL_SIM_MASTER__
	if(tcd_get_sim()==TCD_SIM2)
		sim_info = SRV_DTCNT_SIM_TYPE_2;
	else
#endif
		sim_info = SRV_DTCNT_SIM_TYPE_1;

	sim_cbm = tcd_get_cbm_sim();

	memset(apn, 0, sizeof(apn));

	if (tcd_get_transaction_proxy() == TCD_NO_PROXY)
	{
		strcpy(apn[0], "cmnet");
		strcpy(apn[1], "uninet");
	}
	else
	{
		strcpy(apn[0], "cmwap");
		strcpy(apn[1], "uniwap");
	}

	for (i = 0; i < SRV_DTCNT_PROF_MAX_ACCOUNT_NUM; i++)
	{
		if (g_srv_dtcnt_store_ctx.acc_list[i].in_use &&
		    g_srv_dtcnt_store_ctx.acc_list[i].bearer_type == SRV_DTCNT_BEARER_GPRS)
		{
			TCD_TRACE("i = %d, sys_apn = %s", i, g_srv_dtcnt_store_ctx.acc_list[i].dest_name);
			if ((!strcmp((S8 *)g_srv_dtcnt_store_ctx.acc_list[i].dest_name, apn[0]))||(!strcmp((S8 *)g_srv_dtcnt_store_ctx.acc_list[i].dest_name, apn[1])))
		   	 {
		    		if(g_srv_dtcnt_store_ctx.acc_list[i].sim_info == sim_info)
		    		{
					acct_id = g_srv_dtcnt_store_ctx.acc_list[i].acc_id;
					acct_id = cbm_encode_data_account_id(acct_id, sim_cbm, 1, 0);
					return acct_id;
		    		}
		    	}
		}
	}
	acct_id = 1;
	srv_dtcnt_store_delete_prof(acct_id, MMI_TRUE, NULL, NULL);
	memset(&gprs_info, 0, sizeof(gprs_info));
	prof_info.prof_type = SRV_DTCNT_BEARER_GPRS;
	prof_info.prof_data = &gprs_info;
	prof_info.prof_fields = SRV_DTCNT_PROF_FIELD_ALL;

	gprs_info.prof_common_header.AccountName =(const U8*) L"CHINAMOBLIENET";
	gprs_info.prof_common_header.acct_type = SRV_DTCNT_PROF_TYPE_USER_CONF;
	gprs_info.prof_common_header.acc_id = 10;
	gprs_info.APN = apn[0];
	gprs_info.prof_common_header.Auth_info.AuthType = SRV_DTCNT_PROF_GPRS_AUTH_TYPE_NORMAL;
	gprs_info.prof_common_header.sim_info = sim_info;
	strcpy((PS8)gprs_info.prof_common_header.Auth_info.UserName, "");
	strcpy((PS8)gprs_info.prof_common_header.Auth_info.Passwd, "");
	result = srv_dtcnt_store_add_prof(&prof_info, &acct_id);
	TCD_TRACE("create count  result = %d",  result);
	if (SRV_DTCNT_RESULT_SUCCESS == result)
	{
		acct_id = cbm_encode_data_account_id(acct_id, sim_cbm, 1, 0);
		TCD_TRACE("acct_id :%d", acct_id);
		return acct_id;
	}
	else
	{
		acct_id = 0;
		acct_id = cbm_encode_data_account_id(acct_id, sim_cbm, 1, 0);
		TCD_TRACE("acct_id :%d", acct_id);
		return acct_id;
	}
}
#else
U32 tcd_get_account_id(void)
{
	U32 accid = TCD_GPRS_ACCOUNT;
#ifdef __TCD_OVERSEA_VERSION__
	kal_int32 i;
	U16 sys_apn[100] = {0};
	S8 sim_apn[100] = {0};
	S8 temp[100] = {0};
	S8 user_name[32] = {0};
	S8 password[32] = {0};
	TCD_SIM_E sim = tcd_get_sim();
	cbm_sim_id_enum cbm_sim = tcd_get_cbm_sim();

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	tcd_get_apn_data(g_tcdIMSI[sim], sim_apn, user_name, password);

	for (i = 0;/*MAX_DATA_ACCOUNT_GSM_LIMIT; */i < (MAX_DATA_ACCOUNT_GPRS_LIMIT + MAX_DATA_ACCOUNT_GSM_LIMIT); i++)
	{
		memset(sys_apn, 0, sizeof(sys_apn));
		memset(temp, 0, sizeof(temp));
		mmi_dtcnt_get_apn((U32)i, (S8 *)sys_apn, sizeof(sys_apn));

		mmi_wcs_to_asc(temp, sys_apn);
		TCD_TRACE("i = %d, sys_apn = %s \n", i, temp);

		if(strncmp(temp, sim_apn, strlen(sim_apn)) == 0 && strlen(sim_apn) > 0)
		{
			accid = cbm_encode_data_account_id(i, cbm_sim, 1, FALSE);
			break;
		}
	}

	if((i >= MAX_DATA_ACCOUNT_GPRS_LIMIT + MAX_DATA_ACCOUNT_GSM_LIMIT) && strlen(sim_apn) > 0)
	{
		U32 index = tcd_mmi_dtcnt_add_gprs_account(sim_apn, user_name, password);
		accid = cbm_encode_data_account_id(index, cbm_sim, 1, FALSE);
	}

	TCD_TRACE("accid :%d", accid);
	return accid;
#else  //#undef __TCD_OVERSEA_VERSION__
#if(TCD_MTK_SOFT_VERSION >= 0x0828)
	kal_int32 i = 0;
	S8 sys_apn[100] = {0};
	S8 *sim_apn[2] = {NULL};
	S8 temp[50] = {0};
	cbm_sim_id_enum cbm_sim = tcd_get_cbm_sim();

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	TCD_TRACE("tcd_get_account_id cbm_sim = %d", cbm_sim);	//CBM_SIM_ID_SIM1?

//	tcd_get_apn_data(g_tcdIMSI[sim], sim_apn, user_name, password);

	if (tcd_get_transaction_proxy() == TCD_USE_PROXY)
	{
		sim_apn[0] = "cmwap";
		sim_apn[1] = "CMWAP";
	}
	else
	{
		sim_apn[0] = "cmnet";
		sim_apn[1] = "CMNET";
	}

	for (i = 0;i < (MAX_DATA_ACCOUNT_GPRS_LIMIT + MAX_DATA_ACCOUNT_GSM_LIMIT); i++)
	{
		memset(sys_apn, 0, sizeof(sys_apn));
		memset(temp, 0, sizeof(temp));
		mmi_dtcnt_get_apn((U32)i, (S8 *)sys_apn, sizeof(sys_apn));

		mmi_wcs_to_asc(temp, (WCHAR *)sys_apn);
		TCD_TRACE("apn check1 --i = %d, sys_apn = %s \n", i, temp);

		if(strncmp(temp, sim_apn[0], strlen(sim_apn[0])) == 0  || strncmp(temp, sim_apn[1], strlen(sim_apn[1])) == 0 )
		{
			accid = cbm_encode_data_account_id(i, cbm_sim, 1, FALSE);
			break;
		}
	}

	if( i >= (MAX_DATA_ACCOUNT_GPRS_LIMIT + MAX_DATA_ACCOUNT_GSM_LIMIT) )
	{
		if (tcd_get_transaction_proxy() == TCD_USE_PROXY)
		{
			sim_apn[0] = "uniwap";
			sim_apn[1] = "UNIWAP";
		}
		else
		{
			sim_apn[0] = "uninet";
			sim_apn[1] = "UNINET";
		}

		for (i = 0;i < (MAX_DATA_ACCOUNT_GPRS_LIMIT + MAX_DATA_ACCOUNT_GSM_LIMIT); i++)
		{
			memset(sys_apn, 0, sizeof(sys_apn));
			memset(temp, 0, sizeof(temp));
			mmi_dtcnt_get_apn((U32)i, (S8 *)sys_apn, sizeof(sys_apn));

			mmi_wcs_to_asc(temp, (WCHAR *)sys_apn);
			TCD_TRACE("apn check2 -- i = %d, sys_apn = %s \n", i, temp);

			if(strncmp(temp, sim_apn[0], strlen(sim_apn[0])) == 0  || strncmp(temp, sim_apn[1], strlen(sim_apn[1])) == 0 )
			{
				accid = cbm_encode_data_account_id(i, cbm_sim, 1, FALSE);
				break;
			}
		}
	}

	if( i >= (MAX_DATA_ACCOUNT_GPRS_LIMIT + MAX_DATA_ACCOUNT_GSM_LIMIT) )
	{
		kal_uint8 app_id = 1;
		kal_uint32 account_id = 0;
	#if 1
		cbm_app_info_struct  info = {0};

		info.app_str_id = STR_GLOBAL_OK;
		info.app_icon_id = IMG_GLOBAL_OK;
		info.app_type = 0;
		cbm_register_app_id_with_app_info(&info, &app_id);
		account_id = cbm_set_app_id(account_id, app_id);
		TCD_TRACE("acaccount_id: %d", account_id);
	//	accid = cbm_encode_data_account_id(CBM_DEFAULT_ACCT_ID, cbm_sim, app_id, KAL_FALSE);
		accid = cbm_encode_data_account_id(account_id, cbm_sim, app_id, KAL_FALSE);
	#else	//如果使用#else 部份代码，请在tcd_soc_realease_socket 修改相应内容。
		cbm_register_app_id(&app_id);
		cbm_hold_bearer(app_id);
		account_id = cbm_set_app_id(0, app_id);
		cbm_release_bearer(app_id);
		cbm_deregister_app_id(app_id);	//ret CBM_OK, CBM_WOULDBLOCK ...
		TCD_TRACE("acaccount_id: %d", account_id);
		accid = cbm_encode_data_account_id(account_id, cbm_sim, app_id, KAL_FALSE);
	#endif
	}

	TCD_TRACE("accid :%d", accid);
	return accid;
#else
	TCD_TRACE("accid :%d", accid);
	return accid;
#endif
#endif  //__TCD_OVERSEA_VERSION__
}
#endif

/*************************************************************************
 *函数名称：tcd_deactive_gprs
 *参数:
 *返回值: void
 *说明:  关闭GPRS
 *
 ************************************************************************/
void tcd_deactive_gprs(void)
{
	S32 socketId=tcd_get_transaction_socket_id();

	TCD_TRACE("Deactive GPRS");
	if(socketId>=0)
		tcd_soc_realease_socket(socketId);
}

#ifdef TCD_CHECK_OTHER_SP_NETWORK
BOOL tcd_check_other_sp_network(void)
{
	BOOL flag = FALSE;
	#if defined(__ZMAEE_APP__)&&defined(__MTK_TARGET__)  //QQ是否运行
	{
		extern int ZMAEE_QQ_IsRunning(void);
		extern void ZMAEE_QQ_Exit(void);
		if(ZMAEE_QQ_IsRunning())
		{
			ZMAEE_QQ_Exit();
			flag = TRUE;
			TCD_TRACE("tcd_check_other_sp_network exit qq");
		}
	}
	#endif
	#if 0
	if(is_wchat_runing())  //微信是否运行
	{
		exit_wchat();
		flag = TRUE;
	}
	#endif
	return flag;
}


void tcd_active_gprs_now(void)
{
	g_tcdAccoutId=tcd_get_account_id();
	if(g_tcdActivityGPRSCallback_p)
		g_tcdActivityGPRSCallback_p();
}

/*************************************************************************
 *函数名称：tcd_activate_gprs
 *参数:  FuncPtr callback      -
 *返回值: BOOL
 *说明:  在这里取得连接网络的数据帐户
 *
 ************************************************************************/
BOOL tcd_activate_gprs(TcdFuncPtr callback)
{
	if(tcd_check_other_sp_network())
	{
		g_tcdActivityGPRSCallback_p=callback;
		tcd_start_timer(TCD_CHECK_OTHER_SP_NETWORK_TIMER_TIMER, TCD_1_SECOND_DELAY, tcd_active_gprs_now);
	}
	else
	{
		g_tcdAccoutId=tcd_get_account_id();
		g_tcdActivityGPRSCallback_p=callback;
		if(g_tcdActivityGPRSCallback_p)
			g_tcdActivityGPRSCallback_p();
	}

	return TRUE;
}
#else
/*************************************************************************
 *函数名称：tcd_activate_gprs
 *参数:  FuncPtr callback      -
 *返回值: BOOL
 *说明:  在这里取得连接网络的数据帐户
 *
 ************************************************************************/
 BOOL tcd_activate_gprs(TcdFuncPtr callback)
{
	g_tcdAccoutId=tcd_get_account_id();
	g_tcdActivityGPRSCallback_p=callback;
	if(g_tcdActivityGPRSCallback_p)
		g_tcdActivityGPRSCallback_p();

	return TRUE;
}
#endif


#if 0
/*************************************************************************
 *函数名称：tcd_soc_notify
 *参数:
 *void *inMsg       -
 *返回值:  void
 *说明:  socket 消息的响应
 ************************************************************************/
void tcd_soc_notify(void *inMsg)
{
	app_soc_notify_ind_struct *soc_notify = (app_soc_notify_ind_struct*) inMsg;

	tcd_stop_timer(TCD_SOC_TIMEOUT_TIMER);		//add hezhao -- 响应SOCKET，关闭超时处理，钩子函数去掉

	if(tcd_check_transaction_socket(soc_notify->socket_id))
	{
		if(soc_notify->result == KAL_FALSE)
		{
			TCD_TRACE("E62");
            		tcd_recreate_socket();
			//tcd_socket_output_result(TCD_ERROR_DEFAULT);
			return;
		}

		if(soc_notify->event_type==SOC_WRITE)
		{
			tcd_set_transaction_state(TCD_SOCKET_SENDING);	//add hezhao
			tcd_send_soc_http_request();
		}
		else if(soc_notify->event_type==SOC_READ)
		{
			tcd_set_transaction_state(TCD_SOCKET_RCVING);
			tcd_send_soc_http_request();
		}
		else if( soc_notify->event_type==SOC_CONNECT)
		{
			tcd_set_transaction_state(TCD_SOCKET_CONNECT);
			tcd_send_soc_http_request();
		}
		else if(soc_notify->event_type==SOC_CLOSE)
		{
			TCD_TRACE("SOC_CLOSE");
			tcd_socket_output_result(TCD_NO_ERROR);
		}
		else
		{
			//add hezhao
			tcd_socket_output_result(TCD_ERROR_DEFAULT);
		}
	}
}
#endif


/*************************************************************************
 *函数名称：tcd_create_socket
 *参数:
 *S32 *socketId       -  (out)
 *返回值:  void
 *说明:  创建socket
 *
 ************************************************************************/
void tcd_create_socket(S32 *socketId)
{
	unsigned char val;
	S8 socket;

	socket = soc_create(SOC_PF_INET, SOC_SOCK_STREAM, 0, MOD_MMI, g_tcdAccoutId);
	*socketId = socket;
	if(socket< 0)
	{
		TCD_TRACE("E63");
		tcd_socket_output_result(TCD_ERROR_SOCKET_CREATE);
		return;
	}

	//设置为非阻塞
	val = 1;
	if(soc_setsockopt(socket,SOC_NBIO,&val,sizeof(val)) != 0)
	{
		TCD_TRACE("E64");
		tcd_socket_output_result(TCD_ERROR_SOCKET_CREATE);
		return;
	}

	//设置需要接收哪些 消息
	val = SOC_READ | SOC_WRITE |SOC_ACCEPT| SOC_CONNECT | SOC_CLOSE;
	if(soc_setsockopt(socket, SOC_ASYNC, &val, sizeof(val)) != 0)
	{
		TCD_TRACE("E65");
		tcd_socket_output_result(TCD_ERROR_SOCKET_CREATE);
		return;
	}

//	tcd_restart_timeout_timer();
	tcd_set_transaction_state(TCD_SOCKET_CONNETING);
	tcd_send_soc_http_request();
}

/*************************************************************************
 *函数名称：tcd_socket_do_connecting
 *参数:
 *S32 socketId       -  (in)
 *sockaddr_struct *sockaddr   -  (in)
 *返回值:  void
 *说明:  创建网络连接
 *
 ************************************************************************/
void tcd_socket_do_connecting(S32 socketId, sockaddr_struct *sockaddr)
{
	S32 rv;
	TCD_SOC_CONNECTING_RESULT_E result = TCD_SOC_CONNECTING_OTHER_ERROR;

#if 0//def __TCD_NET_MULTIEVENT__
	mmi_frm_set_protocol_event_handler(MSG_ID_APP_SOC_NOTIFY_IND, tcd_soc_notify, MMI_TRUE);
//#else
	tcd_set_protocol_event_handler(tcd_soc_notify, MSG_ID_APP_SOC_NOTIFY_IND);
#endif

	rv = soc_connect(socketId, sockaddr);
	TCD_TRACE("tcd_socket_do_connecting = %d", rv);

	if(rv == SOC_SUCCESS)
		result = TCD_SOC_CONNECTING_SUCCESS;
	else if(rv == SOC_WOULDBLOCK)
		result = TCD_SOC_CONNECTING_WOULD_BLOCK_MTK;
	tcd_socket_process_connecting_result(result);

}

void tcd_socket_prepare_ip(kal_uint8 ip_addr[])
{
//  	char sd1[4] = {0}, sd2[4] = {0}, sd3[4] = {0}, sd4[4] = {0};

	memset(g_tcdHostIp, 0, sizeof(g_tcdHostIp));
//    tcd_itos(sd1, 4, ip_addr[0]);
//    tcd_itos(sd2, 4, ip_addr[1]);
//    tcd_itos(sd3, 4, ip_addr[2]);
//    tcd_itos(sd4, 4, ip_addr[3]);
//    sprintf(g_tcdHostIp, "%s.%s.%s.%s", sd1, sd2, sd3, sd4);
	sprintf(g_tcdHostIp, "%d.%d.%d.%d", ip_addr[0], ip_addr[1], ip_addr[2], ip_addr[3]);

	TCD_TRACE("tcd_socket_prepare_ip = %s", g_tcdHostIp);
}


/*************************************************************************
 *函数名称：tcd_get_host_by_name
 *参数:
 *void* inMsg       -  (in)
 *返回值:  void
 *说明:  得到域名的IP
 *
 ************************************************************************/
void tcd_get_host_by_name(void* inMsg)
{
	app_soc_get_host_by_name_ind_struct* dns_ind = (app_soc_get_host_by_name_ind_struct*)inMsg;
	kal_uint16 dns_port = (kal_uint16)tcd_get_transaction_dns_port();

//	tcd_stop_timer(TCD_SOC_TIMEOUT_TIMER);		//add hezhao -- 响应SOCKET，关闭超时处理，清掉解析域名钩子函数。

	if(tcd_check_transaction_socket(dns_ind->request_id) && dns_ind)
	{
		TCD_TRACE("tcd_get_host_by_name0 = %d, %d", dns_ind->result, dns_ind->request_id);
		if(dns_ind->result != FALSE)
		{
			sockaddr_struct sockaddr;

			memset(&sockaddr, 0, sizeof(sockaddr));
			memcpy(sockaddr.addr, dns_ind->addr, dns_ind->addr_len);
			tcd_socket_prepare_ip(sockaddr.addr);
			sockaddr.addr_len = dns_ind->addr_len;
		//	sockaddr.port = TCD_HTTP_HOST_PORT;	//这是我们服务器的端口，不适用所有服务器
			sockaddr.port = dns_port;
			sockaddr.sock_type = SOC_SOCK_STREAM;
			TCD_TRACE("tcd_get_host_by_name1 = %d, %d, %d, %d, %d, %d", sockaddr.addr_len, sockaddr.addr[0],
				sockaddr.addr[1], sockaddr.addr[2], sockaddr.addr[3], dns_port);
			tcd_socket_do_connecting(dns_ind->request_id, &sockaddr);
		}
		else
		{
			tcd_socket_output_result(TCD_ERROR_GET_HOST);
	 	}
	}
}

/*************************************************************************
 *函数名称：tcd_socket_conneting
 *参数:
 *S32 socketId       -  (in)
 *返回值:  void
 *说明:  创建网络连接
 *
 ************************************************************************/
void tcd_socket_connecting(S32 socketId)
{
	sockaddr_struct sockaddr;
	S32 rv;
	U8 proxy = tcd_get_transaction_proxy();
	kal_char *pDns = (kal_char *)tcd_get_transaction_dns();
	kal_uint16 dns_port = (kal_uint16)tcd_get_transaction_dns_port();
	TCD_SOC_CONNECTING_RESULT_E result = TCD_SOC_CONNECTING_OTHER_ERROR;

	memset(&sockaddr, 0, sizeof(sockaddr));
	if(proxy == TCD_NO_PROXY)
	{
		kal_char dns[64];
		kal_uint8 buf[4], addr_len = 0;
		kal_char* pTmp = NULL;

		memset(buf, 0, sizeof(buf));
	//	rv = soc_gethostbyname(KAL_FALSE, MOD_MMI, socketId, g_tcdHostSel, buf, &addr_len, 0, g_tcdAccoutId);
		memset(dns, 0, sizeof(dns));
		strncpy(dns, pDns, sizeof(dns));
		pTmp = strchr(dns, ':');	//hydgroups.vicp.net:8081 去掉域名端口号
		if (pTmp)
		{
			while(*pTmp)
			{
				*pTmp = 0;
				pTmp++;
			}
		}
		TCD_TRACE("soc_gethostbyname -- dns: %s", dns);
		rv = soc_gethostbyname(KAL_FALSE, MOD_MMI, socketId, dns, buf, &addr_len, 0, g_tcdAccoutId);
		TCD_TRACE("soc_gethostbyname: %d", rv);
		if(rv == SOC_WOULDBLOCK)         // wouldblock
		{
		#if 0//def __TCD_NET_MULTIEVENT__
			mmi_frm_set_protocol_event_handler(MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND, tcd_get_host_by_name, MMI_TRUE);
		//#else
			tcd_set_protocol_event_handler(tcd_get_host_by_name, MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND);
		#endif

			//tcd_restart_timeout_timer();
			return;
		}
		else if(rv == SOC_SUCCESS)             // success
		{
			sockaddr.addr[0] = buf[0];
			sockaddr.addr[1] = buf[1];
			sockaddr.addr[2] = buf[2];
			sockaddr.addr[3] = buf[3];
			tcd_socket_prepare_ip(sockaddr.addr);
			sockaddr.addr_len = addr_len;
			sockaddr.port = dns_port;
			TCD_TRACE("tcd_socket_connecting1 = %d, %d, %d, %d, %d, %d", addr_len, buf[0], buf[1], buf[2], buf[3], dns_port);
		}
		else //解析出错时用已知的IP
		{
			/*
			sockaddr.addr[0] = 220;
			sockaddr.addr[1] = 231;
			sockaddr.addr[2] = 193;
			sockaddr.addr[3] = 136;
			sockaddr.addr_len = 4;
			sockaddr.port = TCD_HTTP_HOST_PORT;
			*/
			TCD_TRACE("TCD_ERROR_GET_HOST");
			tcd_socket_output_result(TCD_ERROR_GET_HOST);
			return;
		}
	}
	else
	{
		sockaddr.addr[0] =  10;
		sockaddr.addr[1] =  0;
		sockaddr.addr[2] =  0;
		sockaddr.addr[3] =  172;
		sockaddr.addr_len = 4;
		sockaddr.port = 80;
	}
	sockaddr.sock_type = SOC_SOCK_STREAM;
	tcd_socket_do_connecting(socketId, &sockaddr);
}

/*************************************************************************
 *函数名称：tcd_socket_sending
 *参数:
 *返回值:  void
 *说明:  发送请求数据
 *
 ************************************************************************/
void tcd_socket_sending(void)
{
	static BOOL startUploadFlag = FALSE;
	static U32 totalUploadLen = 0;
	static short nCount = 0;		/*这计数器是为了不让手机在一直发送socket 数据时，引起按键操作卡顿，MTK 是任务独占系统*/
	BOOL upLoadFlag = FALSE;
	S32 socketId = -1;
	U32 sndCounter = 0;
	U32 sndLen = 0;
	U8* buf_p = NULL;
	U32 uploadLen = 0;
	U8* uploadData = NULL;

//	tcd_stop_timer(TCD_SOC_TIMEOUT_TIMER);

	socketId = tcd_get_transaction_socket_id();
	buf_p = tcd_get_transaction_send_buf(&sndLen, &sndCounter);	//这个sendBuf 只有2KB，即TCD_SEND_BUF_LENGTH
	uploadLen = tcd_get_transaction_upload_data_len();
	upLoadFlag = tcd_get_transaction_upload_data_flag();		//当有较大数据需要上传时，在package 函数里就设置此标志
	uploadData = tcd_get_transaction_upload_data_ptr();

	do
	{
		int retVal = 0;

		TCD_TRACE("tcd_socket_sending sndLen: %d, sndCounter: %d", sndLen, sndCounter);
		retVal = soc_send(socketId, (U8*)(buf_p+ sndCounter), (sndLen - sndCounter), 0);
		tcd_set_transaction_state(TCD_SOCKET_SENDING);
		TCD_TRACE("tcd_socket_sending retVal: %d, upLoadFlag: %d", retVal, upLoadFlag);
		if (retVal > 0)
		{
			sndCounter += retVal;
			tcd_set_transaction_send_counter(sndCounter);
		}
		else if (retVal == SOC_WOULDBLOCK)
		{
			nCount++;
			if (nCount > 50)	/* 这通常是终端或服务器网络差引起的*/
			{
				TCD_TRACE("SOC_WOULDBLOCK  nCount > 50 ");
				nCount = 0;
				if (upLoadFlag)
				{
					totalUploadLen = 0;
					startUploadFlag = FALSE;
				}
				tcd_socket_output_result(TCD_ERROR_SENDING);
			}
			return;
		}
		else
		{
			TCD_TRACE("E67");
			nCount = 0;
			if (upLoadFlag)
			{
				totalUploadLen = 0;
				startUploadFlag = FALSE;
				tcd_stop_timer(TCD_SOC_TIMEOUT_TIMER);		/*当开启TCD_SOC_TIMEOUT_TIMER，没到650 毫秒，响应notify，执行这代码后，此时需要关定时器*/
			}
			tcd_socket_output_result(TCD_ERROR_SENDING);
			return;
		}

		TCD_TRACE("22222 sndLen: %d, sndCounter: %d", sndLen, sndCounter);
		if (sndCounter == sndLen)
		{
			if (upLoadFlag)
			{
				tcd_set_transaction_state(TCD_SOCKET_SENDING);
				memset(buf_p, 0,TCD_SEND_BUF_LENGTH);
				TCD_TRACE("startUploadFlag: %d", startUploadFlag);
				if (startUploadFlag)
					totalUploadLen += sndCounter;
			//	uploadLen = strlen(uploadData);
				TCD_TRACE("totalUploadLen: %d, uploadLen: %d", totalUploadLen, uploadLen);
				if (totalUploadLen >= uploadLen)
				{
					nCount = 0;
					totalUploadLen = 0;
					startUploadFlag = FALSE;
					TCD_HTTP_FREE_MEM((void **)&uploadData);
					tcd_set_transaction_upload_data_len(0);
					tcd_set_transaction_upload_data_ptr(NULL);
					tcd_set_transaction_upload_data_flag(FALSE);
					tcd_set_transaction_state(TCD_SOCKET_SENT);
					tcd_stop_timer(TCD_SOC_TIMEOUT_TIMER);		/*当开启TCD_SOC_TIMEOUT_TIMER，没到650 毫秒，响应notify，接收最后部份数据，此时需要关定时器*/
					break;
				}
				sndLen = TCD_MIN(uploadLen - totalUploadLen, TCD_SEND_BUF_LENGTH - 48);
				memcpy(buf_p, uploadData + totalUploadLen, sndLen);
				tcd_set_transaction_send_lenght(sndLen);
				tcd_set_transaction_send_counter(0);
				sndCounter = 0;
				TCD_TRACE("next upload sndLen: %d, sndCounter: %d", sndLen, sndCounter);
				startUploadFlag = TRUE;
				nCount++;
				if (nCount > 3)
				{
					nCount = 0;
					tcd_start_timer(TCD_SOC_TIMEOUT_TIMER, 650, tcd_socket_sending);	/* 为了不让手机在一直发送socket 数据时，引起按键操作卡顿，MTK 是任务独占系统*/
					return;
				}
				continue;
			}
			else
			{
				nCount = 0;
				tcd_set_transaction_state(TCD_SOCKET_SENT);
				break;
			}
		}
	}while(1);

//	tcd_restart_timeout_timer();		//现在不对连网做超时处理，注释掉这个函数调用
}

/*************************************************************************
 *函数名称：tcd_soc_recv_response
 *参数:
 *返回值:  void
 *说明:  接收数据
 *
 ************************************************************************/
#ifdef TCD_TRACE_SOC_RECV_DATA
U8 g_tcdSocRecvDataLogBuf[TCD_LBS_RECVD_BUF_LENGTH];	/*打印socket 接收到的数据的BUFFER */
#endif
void tcd_soc_recv_response(void)
{
	static BOOL isNeedMoreSpace = FALSE;
	static U32 totalRcvdLen = 0;
	short nCount = 0;		/*这计数器是为了不让手机在一直接收socket 数据时，引起按键操作卡顿，MTK 是任务独占系统*/
	S32 socketId = -1;
	U32 rcvdLen = 0, rcvdBufSize = 0;
	U8 *buf_p = NULL;
	U8 *recvdData_p = NULL;

	buf_p = tcd_get_transaction_rcvd_buf(&rcvdLen, &rcvdBufSize); 	//初始rcvdLen == 0
	TCD_TRACE("111get rcvdLen: %d", rcvdLen);
	recvdData_p = tcd_get_transaction_rvcd_data_p();
	socketId = tcd_get_transaction_socket_id();
	if(tcd_check_transaction_socket(socketId))
	{
		int retVal = 0;

		tcd_set_transaction_state(TCD_SOCKET_RCVING);
		do
		{
			retVal = soc_recv(socketId, buf_p, (rcvdBufSize -48), 0);		//rcvdBufSize -- 2KB，参照互芯平台，当整个2KB的BUF接满2KB数据时，出现不可思议的错误。
	        	TCD_TRACE("tcd_soc_recv_response = %d, %d, %x", rcvdBufSize, retVal, buf_p);
			if(retVal > 0)
			{
			#ifdef TCD_TRACE_SOC_RECV_DATA
				memset(g_tcdSocRecvDataLogBuf, 0, sizeof(g_tcdSocRecvDataLogBuf));
				memcpy(g_tcdSocRecvDataLogBuf, buf_p, retVal);
				TCD_TRACE2("%s\r\n", g_tcdSocRecvDataLogBuf);
			#endif
				totalRcvdLen += retVal;
				TCD_TRACE("totalRcvdLen: %d", totalRcvdLen);
				if (tcd_is_integral_http_package(buf_p, totalRcvdLen, rcvdBufSize))		//rcvdBufSize -- 这参数没用到
				{
					buf_p = tcd_get_transaction_rcvd_buf(&rcvdLen, &rcvdBufSize);
					TCD_TRACE("isNeedMoreSpace: %d, 333get rcvdLen: %d", isNeedMoreSpace, rcvdLen);
					if (isNeedMoreSpace)	//buf_p可以一次接收完HTTP数据时，执行之
					{
						if (totalRcvdLen <= rcvdLen)		//控制当接收的总数据大于暂存的BUFFER时，不把数据拷到BUFFER里。
							memcpy(recvdData_p + (totalRcvdLen - retVal), buf_p, retVal);
						memset(buf_p, 0, rcvdBufSize);
					}
					else
					{
						if (!recvdData_p)
						{
							recvdData_p = (U8 *)TCD_RECV_REAL_ALLOC_MEM((rcvdBufSize + (rcvdBufSize/2)));	//追加rcvdBufSize/2 的空间，为了在HTTP 数据后加上同步短信，有足够空间
							tcd_set_transaction_rvcd_data_p((S8 *)recvdData_p);
						}
						if (recvdData_p)
						{
							memcpy(recvdData_p, buf_p, rcvdBufSize);
							memset(buf_p, 0, rcvdBufSize);
						}
					}
					isNeedMoreSpace = FALSE;
					totalRcvdLen = 0;	//使用static ，解决由于retVal == SOC_WOULDBLOCK 重复调用tcd_soc_recv_response 引起的问题
					tcd_stop_timer(TCD_SOC_TIMEOUT_TIMER);	//当开启TCD_SOC_TIMEOUT_TIMER，没到650 毫秒，响应notify，接收完最后部份数据，此时需要关定时器
		 			tcd_socket_output_result(TCD_NO_ERROR);
		 			return;
				}
				else
				{
					isNeedMoreSpace = TRUE;
					buf_p = tcd_get_transaction_rcvd_buf(&rcvdLen, &rcvdBufSize);	//tcd_is_integral_http_package 获得rcvdLen 值，http 头一定要有ContenLenght
					TCD_TRACE("222get rcvdLen: %d", rcvdLen);
					if (rcvdLen == 0
					#ifdef __TCD_GD__
						||rcvdLen > 100 * 1024		//在进行 WAP 视频下载视频时，视频ContenLenght 会很大，TCD_RECV_REAL_ALLOC_MEM 不能分配太大空间。
					#endif
						)
					{
						rcvdLen = 100 * 1024;	//http 头没有ContenLenght 时，使用60KB空间接收整个</html> 或</wml> 页面
						tcd_set_transaction_rvcd_len(rcvdLen);
					}
					if (!recvdData_p)
					{
						recvdData_p = (U8 *)TCD_RECV_REAL_ALLOC_MEM((rcvdLen + (rcvdBufSize/2)));	//追加rcvdBufSize/2 的空间，为了在HTTP 数据后加上同步短信，有足够空间
						tcd_set_transaction_rvcd_data_p((S8 *)recvdData_p);
					}
					if (recvdData_p)
					{
						if (totalRcvdLen <= rcvdLen)		//控制当接收的总数据大于暂存的BUFFER时，不把数据拷到BUFFER里。
							memcpy(recvdData_p + (totalRcvdLen - retVal), buf_p, retVal);
						memset(buf_p, 0, rcvdBufSize);
						if (totalRcvdLen >= rcvdLen)
						{
							isNeedMoreSpace = FALSE;
							totalRcvdLen = 0;	//使用static ，解决由于retVal == SOC_WOULDBLOCK 重复调用tcd_soc_recv_response 引起的问题
							tcd_socket_output_result(TCD_NO_ERROR);
							return;
						}
						//为了不让手机在一直接收socket 数据时，引起按键操作卡顿，MTK 是任务独占系统
						nCount++;
						TCD_TRACE("nCount: %d", nCount);
						if (nCount > 3)
						{
							tcd_start_timer(TCD_SOC_TIMEOUT_TIMER, 650, tcd_soc_recv_response);
							break;
						}
					}
					else
					{
						isNeedMoreSpace = FALSE;
						totalRcvdLen = 0;
						tcd_socket_output_result(TCD_NO_MEMERY);
						return;
					}
				}
			}
			else if(retVal == SOC_WOULDBLOCK)
			{
				return;
			}
			else
			{
				TCD_TRACE("E68");
				isNeedMoreSpace = FALSE;
				totalRcvdLen = 0;
		 		tcd_socket_output_result(TCD_ERROR_RECEIVE);
				return;
			}
		}while(1);
	}
}

/*************************************************************************
 *函数名称：tcd_soc_recv_wml_data
 *参数:
 *返回值:  void
 *说明:  接收数据
 *
 ************************************************************************/
void tcd_soc_recv_wml_data(void)
{
#ifdef __TCD_DOWNLOAD_WML__
	static U32 totalRcvdLen = 0;
	U32 rcvdLen = 0, rcvdBufSize = 0;
	S32 socketId = -1;
	U8 *buf_p = NULL;

//	tcd_stop_timer(TCD_SOC_TIMEOUT_TIMER);

	buf_p = tcd_get_transaction_rcvd_buf(&rcvdLen, &rcvdBufSize); 	//初始rcvdLen == 0
	TCD_TRACE("111get rcvdLen: %d", rcvdLen);
	socketId = tcd_get_transaction_socket_id();
	if(tcd_check_transaction_socket(socketId))
	{
		int retVal = 0;

		tcd_set_transaction_state(TCD_SOCKET_RCVING);
		while(1)
		{
			retVal = soc_recv(socketId, buf_p, (rcvdBufSize -48), 0);
	              TCD_TRACE("tcd_soc_recv_wml_data = %d, %d, %x", rcvdBufSize, retVal, buf_p);
			if(retVal > 0)
			{
				totalRcvdLen += retVal;
			//	TCD_TRACE("%s", buf_p);	//del hezhao -- 有可能trace 里的BUF不如buf_p的空间大，引起问题，在此也不需要打印接收数据的内容.
				memset(buf_p, 0, rcvdBufSize);
				TCD_TRACE("tcd_soc_recv_wml_data totalRcvdLen = %d", totalRcvdLen);
				if(totalRcvdLen > (TCD_MAX_DOWNLOAD_SIZE/10) || tcd_check_is_full_download())
				{
					tcd_save_download_size(retVal);
					totalRcvdLen = 0;
					tcd_socket_output_result(TCD_NO_ERROR);
					return;
				}
				tcd_save_download_size(retVal);
			}
			else if(retVal == SOC_WOULDBLOCK)	//add hezhao -- 使函数的结构跟tcd_soc_recv_response 一致。
			{
				return;
			}
			else
			{
				TCD_TRACE("E68");
				totalRcvdLen = 0;
		 		tcd_socket_output_result(TCD_ERROR_RECEIVE);
				return;
			}
		}
	}
#endif
}


/*************************************************************************
 *函数名称：tcd_soc_realease_socket
 *参数:
 *U16 requst       -  (in)
 *返回值:  void
 *说明:  关闭socket
 *
 ************************************************************************/
void tcd_soc_realease_socket(S32 socketId)
{
	//关掉socket 若再发MSG_ID_APP_SOC_DEACTIVATE_REQ 消息，关掉socket 后还会有一次notify 响应
#if 0
//	ilm_struct *ilm_send = NULL;

	//cbm_release_bearer(g_kkw_cbm_id);
	kal_sleep_task(200);
	/*
	ilm_send = allocate_ilm(MOD_MMI);
	ilm_send->msg_id = MSG_ID_APP_SOC_DEACTIVATE_REQ;
	ilm_send->peer_buff_ptr = NULL;
	ilm_send->local_para_ptr = NULL;
	SEND_ILM(MOD_MMI, MOD_SOC, SOC_APP_SAP, ilm_send);
	*/
	tcd_send_msg_queue(MOD_MMI, MOD_SOC, SOC_APP_SAP, MSG_ID_APP_SOC_DEACTIVATE_REQ, NULL, NULL);
#endif

#if 0//def __TCD_NET_MULTIEVENT__
	mmi_frm_clear_protocol_event_handler(MSG_ID_APP_SOC_NOTIFY_IND, (PsIntFuncPtr)tcd_soc_notify);
	mmi_frm_clear_protocol_event_handler(MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND, (PsIntFuncPtr)tcd_get_host_by_name);
//#else
	ClearProtocolEventHandler(MSG_ID_APP_SOC_NOTIFY_IND );
	ClearProtocolEventHandler(MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND);
#endif

	soc_close(socketId);
}


/*************************************************************************
 *函数名称：tcd_soc_event_notify
 *参数:
 *返回值:  MMI_BOOL
 *说明:  在event_handler.c 处移植该函数，
 *	防止与第三方SP 使用mmi_frm_set_protocol_event_handler 引起冲突
 *
 ************************************************************************/
MMI_BOOL tcd_soc_event_notify(U16 id, void* msg)
{
	if(MSG_ID_APP_SOC_NOTIFY_IND == id )
	{
		app_soc_notify_ind_struct *soc_notify = (app_soc_notify_ind_struct*) msg;

		TCD_TRACE("tcd_soc_event_notify MSG_ID_APP_SOC_NOTIFY_IND");
		TCD_TRACE("soc_notify->event_type: %d", soc_notify->event_type);
	//	tcd_stop_timer(TCD_SOC_TIMEOUT_TIMER);

		if(tcd_check_transaction_socket(soc_notify->socket_id))
		{
			if(soc_notify->result == KAL_FALSE)
			{
				TCD_TRACE("E62");
				tcd_recreate_socket();
				return FALSE;
			}

			if(soc_notify->event_type==SOC_WRITE)
			{
				tcd_set_transaction_state(TCD_SOCKET_SENDING);
				tcd_send_soc_http_request();
				return TRUE;
			}
			else if(soc_notify->event_type==SOC_READ)
			{
				tcd_set_transaction_state(TCD_SOCKET_RCVING);
				tcd_send_soc_http_request();
				return TRUE;
			}
			else if( soc_notify->event_type==SOC_CONNECT)
			{
				tcd_set_transaction_state(TCD_SOCKET_CONNECT);
				tcd_send_soc_http_request();
				return TRUE;
			}
			else if(soc_notify->event_type==SOC_CLOSE)
			{
				TCD_TRACE("SOC_CLOSE");
				tcd_socket_output_result(TCD_NO_ERROR);
				return TRUE;
			}
			else
			{
				return FALSE;
			}
		}
	}

	if(MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND == id )
	{
		app_soc_get_host_by_name_ind_struct* dns_ind = (app_soc_get_host_by_name_ind_struct*)msg;
		kal_uint16 dns_port = (kal_uint16)tcd_get_transaction_dns_port();

		TCD_TRACE("tcd_soc_event_notify MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND");
	//	tcd_stop_timer(TCD_SOC_TIMEOUT_TIMER);

		if(tcd_check_transaction_socket(dns_ind->request_id) && dns_ind)
		{
			TCD_TRACE("tcd_get_host_by_name0 = %d, %d", dns_ind->result, dns_ind->request_id);
			if(dns_ind->result != FALSE)
			{
				sockaddr_struct sockaddr;

				memset(&sockaddr, 0, sizeof(sockaddr));
				memcpy(sockaddr.addr, dns_ind->addr, dns_ind->addr_len);
				tcd_socket_prepare_ip(sockaddr.addr);
				sockaddr.addr_len = dns_ind->addr_len;
			//	sockaddr.port = TCD_HTTP_HOST_PORT;	//这是我们服务器的端口，不适用所有服务器
				sockaddr.port = dns_port;
				sockaddr.sock_type = SOC_SOCK_STREAM;
				TCD_TRACE("tcd_get_host_by_name1 = %d, %d, %d, %d, %d, %d", sockaddr.addr_len, sockaddr.addr[0],
					sockaddr.addr[1], sockaddr.addr[2], sockaddr.addr[3], dns_port);
				tcd_socket_do_connecting(dns_ind->request_id, &sockaddr);
				return TRUE;
			}
			else
			{
				tcd_socket_output_result(TCD_ERROR_GET_HOST);
		 	}
		}
	}

	return FALSE;
}


#if defined(__MMI_MMS_2__) && defined(__TCD_MSG_MARKETING__)
void tcd_delete_mms_rsp(srv_mms_result_enum result, void *rsp_data, void *user_data)
{
    TCD_TRACE("TCD_delete_mms_rsp = %d", result);
}

void tcd_delete_mms_req(U32 msg_id)
{
	U8 error = 0;

	TCD_TRACE("TCD_delete_mms_req");
#if(TCD_MTK_SOFT_VERSION > 0x0952)
#if(TCD_MTK_SOFT_VERSION == 0x1012)
    srv_mms_delete_req_struct ttreq;

	memset(&ttreq, 0, sizeof(srv_mms_delete_req_struct));
	ttreq.call_back = tcd_delete_mms_rsp;

	ttreq.no_of_msg = 1;
	ttreq.msg_id[0] = msg_id;
	ttreq.box = MMA_FOLDER_INBOX;
	ttreq.app_id = MMA_APP_ID_MMS_APP;
	srv_mms_delete(&ttreq);
#else
	srv_mms_delete_msg(msg_id, &error);
#endif
#endif
}
#endif

void tcd_sleep_task(U32 ticks)
{
	extern void kal_sleep_task(U32 time_in_ticks);
	kal_sleep_task(ticks);
}

void tcd_read_test_data(S8* data)
{
	int hFile = 0;
	U8 file_name[64];
	U32 nRead;
	U32 size;
	const char chFilename[] = "E:\\test.xml" ;

	memset(file_name , 0, sizeof(file_name));
	mmi_asc_to_ucs2((S8*)file_name,(S8*)chFilename);
	hFile = FS_Open((U16 *)file_name, FS_READ_ONLY);
	if(hFile)
	{
		FS_GetFileSize(hFile,&size);
		FS_Read(hFile, (void*)data,size, &nRead);
		FS_Close(hFile);
	}
}

void tcd_save_http_data(void *pData, int size)
{
	int hFile = 0;
	U8 file_name[64];
	U32 nWrite;
	char chFilename[32] = {0};
	char drv = FS_GetDrive(FS_DRIVE_V_REMOVABLE, 1, FS_NO_ALT_DRIVE);
	static int fileIndex = 0;

	if (fileIndex > 5)
		fileIndex = 0;
	sprintf(chFilename, "%c:\\tcd_gd_%d.wml", drv, fileIndex);
	memset(file_name , 0, sizeof(file_name));
	mmi_asc_to_ucs2((S8*)file_name,(S8*)chFilename);
	hFile = FS_Open((U16 *)file_name, FS_READ_WRITE | FS_OPEN_SHARED | FS_CREATE);
	if(hFile)
	{
		fileIndex++;
		FS_Seek(hFile, 0, FS_FILE_BEGIN);
		FS_Write(hFile, pData, size, &nWrite);
		FS_Commit(hFile);
		FS_Close(hFile);
	}
}

void tcd_debugfile(char *pData, int size)
{
	int hFile = 0;
	U8 file_name[64];
	U32 nWrite;
	char chFilename[32] = {0};
	char drv = FS_GetDrive(FS_DRIVE_V_REMOVABLE, 1, FS_NO_ALT_DRIVE);

	sprintf(chFilename, "%c:\\tcd_debug.txt", drv);
	memset(file_name , 0, sizeof(file_name));
	mmi_asc_to_ucs2((S8*)file_name,(S8*)chFilename);
	hFile = FS_Open((U16 *)file_name, FS_READ_WRITE | FS_OPEN_SHARED | FS_CREATE);
	if(hFile)
	{
		FS_Seek(hFile, 0, FS_FILE_END);
		FS_Write(hFile, (void*)pData,size, &nWrite);
		FS_Commit(hFile);
		FS_Close(hFile);
	}
}

void tcd_trace_to_file(char *fmt, ...)
{
	va_list list;
	char   *ptr = NULL;
	applib_time_struct timeTemp;
	char time[50]={0};
	int timeLen=0;

	if(!tcd_get_test_flag())
	{
		if(g_tcdTraceBuf_p)
			TCD_FREE_MEM(&g_tcdTraceBuf_p);
		return;
	}

	if(g_tcdTraceBuf_p==NULL)
	{
		g_tcdTraceBuf_p = TCD_ALLOC_MEM(TCD_TEST_BUF_LEN);
		if(g_tcdTraceBuf_p == NULL)
			return;
	}

	ptr = (char*)g_tcdTraceBuf_p;
	memset(ptr, 0, TCD_TEST_BUF_LEN);
	applib_dt_get_date_time(&timeTemp);
	sprintf(time, "[%04d-%02d-%02d:%02d:%02d:%02d] ",
			timeTemp.nYear,
			timeTemp.nMonth,
			timeTemp.nDay,
			timeTemp.nHour,
			timeTemp.nMin,
			timeTemp.nSec);
	timeLen = strlen(time);
	strcat(g_tcdTraceBuf_p, time);
	va_start(list, fmt);
	vsprintf(ptr+timeLen, fmt, list);
	va_end(list);
	strcat(g_tcdTraceBuf_p, "\r\n");
	tcd_debugfile(g_tcdTraceBuf_p, strlen(g_tcdTraceBuf_p));
}

void tcd_trace_to_file_2(char *fmt, ...)
{
	va_list list;
	char   *ptr = NULL;

	if(!tcd_get_test_flag())
	{
		if(g_tcdTraceBuf_p)
			TCD_FREE_MEM(&g_tcdTraceBuf_p);
		return;
	}

	if(g_tcdTraceBuf_p==NULL)
	{
		g_tcdTraceBuf_p = TCD_ALLOC_MEM(TCD_TEST_BUF_LEN);
		if(g_tcdTraceBuf_p == NULL)
			return;
	}

	ptr = (char*)g_tcdTraceBuf_p;
	memset(ptr, 0, TCD_TEST_BUF_LEN);

	va_start(list, fmt);
	vsprintf(ptr, fmt, list);
	va_end(list);
	tcd_debugfile(g_tcdTraceBuf_p, strlen(g_tcdTraceBuf_p));
}

void tcd_show_locus_info(void)
{
#ifndef __TCD_ONLY_FEE__

	PS8 buffer = (PS8) tcd_get_locus_buf();
//	U32 size = tcd_get_locus_buf_size();

	TCD_TRACE("tcd_show_locus_info");
//	buffer = (PS8) tcd_get_locus_buf();
	tcd_change_wgui_cat074_text((U8 *)buffer, MMI_TRUE);
//	memset(buffer, 0, size);
#endif
}

void tcd_utf8_to_ucs2_string(char *dest, int dest_size, char *src)
{
    mmi_chset_utf8_to_ucs2_string((kal_uint8 *)dest, dest_size, (kal_uint8 *)src);
}

S32 tcd_ucs2_strlen(S8 *string)
{
    return mmi_ucs2strlen(string);
}

void tcd_ucs2_to_asc(char *dest, char *src)
{
    mmi_ucs2_to_asc(dest, src);
}

/*************************************************************************
 *函数名称：tcd_app_init
 *参数:
 *返回值:  void
 *说明:  初始化TCD应用各个模块的相数据，
 *在短信准备完成的接口中调用
 *10A以后的版本是在srv_sms_startup_ready_change_hdlr中调用
 *09A之前的版本是在mmi_frm_sms_ready_ind中调用
 ************************************************************************/
void tcd_app_init(void)
{
	static BOOL initFlag=FALSE;   /*防止被重复初始化*/

	tcd_set_test_flag(FALSE);

	TCD_TRACE("TCD Init:%d",initFlag);
	if(initFlag==FALSE)
	{
		initFlag = TRUE;
		tcd_lbs_nv_init();
		//init LBS
		tcd_start_timer(TCD_LBS_TIMER_1, 30*TCD_1_SECOND_DELAY, tcd_lbs_init);

#ifdef __TCD_DOWNLOAD_WML__
		tcd_download_init();
#endif
		//init MM
	#ifdef __TCD_MSG_MARKETING__
		{
			extern void tcd_mm_init(void);
			tcd_mm_init();
		}
	#endif

	#ifdef __TCD_MAGICVOICE__
		tcd_init_magicvoice();
	#endif

	}
}

void tcd_system_call(char * num)
{
	char ucs2_num[64] = {0};
	TCD_SIM_E sim = tcd_get_sim();
	U8 type = 0;

	mmi_asc_to_ucs2(ucs2_num, num);

    if(sim == TCD_SIM1)
    {
    	type = 0x0001;
    }
#ifdef __MMI_DUAL_SIM_MASTER__
	else if(sim == TCD_SIM2)
	{
    	type = 0x0020;
	}
#endif
	mmi_ucm_app_make_call(type, ucs2_num);
}

U32 tcd_get_vbat_percentage(void)
{
	return uem_get_vbat_percentage() / 100;
}
//对外接口提供

//调用形式为tcd_get_address(tcd_get_address_callback);
/*************************************************************************
 *函数名称：tcd_foreign_latitude_callback
 *参数:
 *返回值:  void
 *说明:  对外接口回调，得到地理位置，经纬度等信息，只提供信息，具体的操作要由调用方自己完成
 结果值说明lbsData_p->result:为TCD_NO_ERROR表示获取成功
 lbsData_p->latitude:纬度
 lbsData_p->longitude:经度
 lbsData_p->str:地理位置信息，为GBK编码
 ************************************************************************/
void tcd_get_address_callback(TCD_LBS_MMI_IND_S *lbsData_p)
{
	//TCD_TRACE("tcd_get_address_callback = %d", lbsData_p->result);
	//TCD_TRACE("tcd_get_address_callback = %f", lbsData_p->latitude);
	//TCD_TRACE("tcd_get_address_callback = %f", lbsData_p->longitude);
	//TCD_TRACE("tcd_get_address_callback = %s", lbsData_p->str);
}

/*************************************************************************
 *函数名称：tcd_get_address_latitude_longitude
 *参数:
 *返回值:  void
 *说明:  对外接口，请求地理位置信息
 ************************************************************************/
void tcd_get_address(TcdLbsApiFunPtr callback)
{
	tcd_requst_location_api(callback);
}

#endif