#ifdef __GBC_LOAD_APP_SWITCH_ON__ //__GBC_SPT__
#include "GBC_host.h"

#if defined(GBC_GPRS)
extern kal_uint32 gbc_GPRSAccountID;
#endif
extern U16 gCurrLangIndex;
extern sLanguageDetails gLanguageArray[MAX_LANGUAGES];
#if (GBC_VER<0x1108)
extern U8 gPLMN[];
extern pwr_context_struct g_pwr_context;
#ifdef __MMI_DUAL_SIM_MASTER__
extern U8 gPLMN_2[];
extern pwr_context_struct g_pwr_context_2;
extern MMI_BOOL IsBacklightOn(void);
extern MTPNP_BOOL MTPNP_PFAL_Send_Message_Segment(void *seg);
extern void MTPNP_OSAL_memset(void * dest, MTPNP_UINT8 value, MTPNP_UINT len);
extern MTPNP_BOOL MTPNP_PFAL_Convert_SendRsp_Msg(void *src_data, void *dst_data);
#endif
extern pBOOL mmi_idle_is_on_idle_screen(void);
extern pBOOL mmi_bootup_is_nw_registration_ok(void);
extern pBOOL mmi_bootup_is_sim2_nw_registration_ok(void);
#endif
#if (GBC_VER >= 0x1012)
extern void srv_gcall_phdlr_dial_ind(void *info, int mod_src);
extern void srv_gcall_phdlr_speech_ind(void *info, int mod_src);
extern void srv_gcall_phdlr_call_connect_ind(void *info, int mod_src);
#else
#ifdef __MMI_DUAL_SIM_MASTER__
extern void MTPNP_PFAL_CC_DIAL_IND_handler(void *MsgStruct);
extern void MTPNP_PFAL_CC_SPEECH_IND_handler(void *MsgStruct);
extern void MTPNP_PFAL_CC_CALL_CONNECT_IND_handler(void *MsgStruct);
#endif
extern void PsCbackOutgoingCallIdSync(void *MsgStruct);
extern void PsCBackSpeechIndication(void *info);
extern void OutgoingCallConnected(void *MsgStruct);
#endif
#ifdef __MMI_AUDIO_PLAYER__
extern MMI_BOOL mmi_audply_is_playing(void);
#endif
#ifdef __MMI_FM_RADIO__
extern MMI_BOOL mmi_fmrdo_is_power_on(void);
#endif
#if (GBC_VER<=0x1108)
extern void PutUARTBytes(UART_PORT port, kal_uint8 *data,kal_uint16 len);
#else
extern void U_PutUARTBytes(UART_PORT port, kal_uint8 *data,kal_uint16 len);
#endif
extern void gbc_TrimStr(char *s);
extern void gbc_ivr_exit(void);
extern void gbc_sms_reset_queue(void);
extern void gbc_sms_in_queue(U16 index);
extern  U8 gbc_ivr_connected(void* info);
extern  U8 gbc_ivr_USSDVSS_rsp(void* info);
extern U8 gbc_ivr_outgoing_call_rsp(void* info);
extern  U8 gbc_ivr_CCSpeech_ind(void* info);
extern void gbc_sms_out_queue(void);
#if defined(GBC_GPRS)
extern void gbc_gprs_init_rsp(void);
extern void gbc_http_gethostbyname_ind(kal_bool result, kal_uint8 *addr, kal_uint8 addr_len);
#endif
extern kal_bool gbc_protocol_event_handler(U16 eventID, void *MsgStruct, int mod_src, void *Message);
extern BOOL gbc_sms_mon_handle(char *pszNumber, char *pszContent, U8 dcs);
extern int gbc_sms_utf8_convert_to_ucs2(char *pContent, U8 dcs, U8 *msg, int size);
extern void DisplayPopup(U8 * string, U16 imageId, U8 imageOnBottom, U32 popupDuration, U8 toneId);
extern void mmi_frm_sms_send_message(
        module_type MOD_SRC,
        module_type MOD_DEST,
        U8 MSG_SAP,
        const U16 MSG_ID,
        void *LOCAL,
        void *PEER);
#if !defined(__COSMOS_MMI_PACKAGE__)
extern U16 mmi_ucm_app_get_marker_scrn_id(void);
#endif

char *gbc_CID={"005"};
char *gbc_MID={"002"};

char gbc_SC[20]={0};
char	gbc_IMSI[17]={0};
#if defined(GBC_GPRS)
char gbc_GPRSIcon = 1;
char gbc_APN[APN_NAME_LEN];
kal_uint8 gbc_GPRSAppId=0;
kal_int8 gbc_GPRSAccountIDIndex = -1;
#endif
static gbc_RspFunc bkfuncall = NULL;
U8 gbc_SMSReport = 0;
U8 gbc_IVRHandleRst = FALSE;
int gbc_IVRCallID = GBC_IVR_HANDLE_NULL;
GBC_IVR_STATE gbc_IVRStatus = GBC_IVR_NONE;
#if (GBC_VER >= 0x1012)//1012参数个数多了一个
static gbc_PSFunc GBC_OUTGOINGCALL_EVENT_RSP_HANDLE=NULL;
static gbc_PSFunc GBC_OUTGOINGCALL_CONNECTED_HANDLE=NULL;
static gbc_PSFunc GBC_SPEECH_IND_EVENT_HANDLE=NULL;
const U16 GBC_SRV_SMS_DELIVER_IND=MSG_ID_MMI_SMS_NEW_MSG_PDU_IND;
const U16 GBC_SMS_MSG_WAITING_IND=MSG_ID_MMI_SMS_MSG_WAITING_IND;
const U16 GBC_SMS_STARTUP_READ_IND=MSG_ID_MMI_SMS_STARTUP_READ_IND;
const U16 GBC_SMS_GET_MEM_STATUS_IND=MSG_ID_MMI_SMS_GET_MEM_STATUS_IND;
#else
static PsFuncPtr GBC_OUTGOINGCALL_EVENT_RSP_HANDLE=NULL;
static PsFuncPtr GBC_OUTGOINGCALL_CONNECTED_HANDLE=NULL;
static PsFuncPtr GBC_SPEECH_IND_EVENT_HANDLE=NULL;
#if defined(__MMI_DUAL_SIM_MASTER__)
const U16 GBC_MTPNP_PFAL_NEW_SMS_IND=MTPNP_PFAL_MSG_SMS_NEW_SMS_IND;
const U16 GBC_MTPNP_PFAL_STATUS_REPORT_IND=MTPNP_PFAL_MSG_SMS_STATUS_REPORT_IND;
const U16 GBC_MTPNP_PFAL_SMS_DEL_MSG_RSP = MTPNP_PFAL_MSG_SMS_DEL_MSG_RSP;
#else
const U16 GBC_MTPNP_PFAL_NEW_SMS_IND=0xffff;
const U16 GBC_MTPNP_PFAL_STATUS_REPORT_IND=0xffff;
const U16 GBC_MTPNP_PFAL_SMS_DEL_MSG_RSP=0xffff;
#endif
extern CALL_STATE GetCurrentState(void);
#endif
const U16 GBC_SMS_GET_PROFILE_PARAMS_RSP = MSG_ID_MMI_SMS_GET_PROFILE_PARAMS_RSP;
const U16 GBC_SMU_GET_IMSI_RSP = MSG_ID_MMI_SMU_GET_IMSI_RSP;
const U16 GBC_SMS_DEL_MSG_RSP = MSG_ID_MMI_SMS_DEL_MSG_RSP;
const U16 GBC_USSDVSS_RSP = MSG_ID_MMI_SS_PARSING_STRING_RSP;
const U16 GBC_OUTGOINGCALL_EVENT_RSP = MSG_ID_MMI_CC_DIAL_IND;
const U16 GBC_SPEECH_IND_EVENT = MSG_ID_MMI_CC_SPEECH_IND;
const U16 GBC_OUTGOINGCALL_CONNECTED = MSG_ID_MMI_CC_CALL_CONNECT_IND;
const U16 GBC_SOC_NOTIFY_IND = MSG_ID_APP_SOC_NOTIFY_IND;
const U16 GBC_SOC_GET_HOST_BY_NAME_IND=MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND;
const U16 GBC_PS_GET_GPRS_DATA_ACCOUNT_RSP=MSG_ID_MMI_PS_GET_GPRS_DATA_ACCOUNT_RSP;
const U16 GBC_PS_SET_GPRS_DATA_ACCOUNT_RSP=MSG_ID_MMI_PS_SET_GPRS_DATA_ACCOUNT_RSP;
const U16 GBC_SMS_DELIVER_MSG_IND=MSG_ID_MMI_SMS_DELIVER_MSG_IND;
const U16 GBC_SMS_STATUS_REPORT_IND=MSG_ID_MMI_SMS_STATUS_REPORT_IND;

void gbc_to_lower(char *str);
void gbc_get_imsi_req(void);
void gbc_get_sim1_profile(void);
#if defined(__MMI_DUAL_SIM_MASTER__)
void gbc_get_sim2_profile(void);
#endif
BOOL gbc_ivr_end_call(BOOL isInner);
int gbc_MultiByteToWideChar(char *pszSrc, unsigned short *pnDst, int dest_size, int nCode);

#if (GBC_VER>=0x1108)
extern MMI_BOOL mmi_idle_is_active(void);
#if (GBC_VER < 0x1352)
extern mmi_frm_event_static_info_struct g_event_table_static_info[];
extern mmi_frm_event_runtime_info_struct g_event_table_runtime_info[];
BOOL gbc_search_msg_event_tab(U16 table, U16 id)
{
	U32 idx = 0;
	S16 maxEvents = g_event_table_runtime_info[table].max_events;
	PseventInfo *eventTable = g_event_table_static_info[table].table;
	
	for (idx=0; idx<maxEvents; idx++)
	{
		if (eventTable[idx].eventID==id)
		{
			return (BOOL)eventTable[idx].flagMulti;
		}
	}
	return FALSE;
}
#endif
#endif

void gbc_ClearProtocolEventHandle(U16 eventID)
{
	ClearProtocolEventHandler(eventID);
}

void gbc_SetProtocolEventHandler(gbc_PSHandle funcPtr, U16 eventID)
{
#if(GBC_VER>=0x1108)
#if (GBC_VER>= 0x1352)
	mmi_frm_set_protocol_event_handler(eventID, (PsIntFuncPtr)funcPtr, MMI_FALSE);
#else
	MMI_BOOL MULTI_THREAD = gbc_search_msg_event_tab(EVENT_TABLE_MASTER, eventID);
	mmi_frm_set_protocol_event_handler(eventID, (PsIntFuncPtr)funcPtr, MULTI_THREAD);
#endif
#elif (GBC_VER>=0x1012)
	SetProtocolEventHandler((PsIntFuncPtr)funcPtr, eventID);
#else
	SetProtocolEventHandler((PsFuncPtr)funcPtr, eventID);
#endif
}

#ifdef __MMI_DUAL_SIM_MASTER__
void gbc_SetSlaveProtocolEventHandler(gbc_PSHandle funcPtr, U16 eventID)
{
#if(GBC_VER>=0x1108)
#if (GBC_VER>= 0x1352)
	mmi_frm_set_protocol_event_handler(eventID, (PsIntFuncPtr)funcPtr, MMI_FALSE);
#else
	MMI_BOOL MULTI_THREAD = gbc_search_msg_event_tab(EVENT_TABLE_SLAVE, eventID);
	mmi_frm_set_protocol_event_handler(eventID, (PsIntFuncPtr)funcPtr, MULTI_THREAD);
#endif
#elif(GBC_VER>=0x1012)
	SetSlaveProtocolEventHandler((PsIntFuncPtr)funcPtr, eventID);
#else
	SetSlaveProtocolEventHandler((PsFuncPtr)funcPtr, eventID);
#endif
}
#endif /* __MMI_DUAL_SIM_MASTER__ */

void gbc_msg_send_ext_queue(U16 oslSrcId, U16 oslDestId,U16 oslMsgId, U16 oslSapId, void* oslDataPtr, void* oslPeerBuffPtr)
{
	MYQUEUE Message;

	Message.oslSrcId = oslSrcId;
	Message.oslDestId = oslDestId;
	Message.oslMsgId = oslMsgId;
	Message.oslSapId = oslSapId;
	Message.oslDataPtr = (oslParaType *)oslDataPtr;
	Message.oslPeerBuffPtr =(peer_buff_struct *)oslPeerBuffPtr;     
	OslMsgSendExtQueue(&Message);
}

/* 根据客户方案修改,有些方案待机函数是重写的不是MTK的*/
static char gbc_is_in_idle_screen(void)
{
	U16 scrId = GetActiveScreenId();

	//GBC_TRACE("gbc_is_in_idle_screen, Active scrId: %d", scrId);
#if(GBC_VER >= 0x1108)
	//GBC_TRACE("mmi_idle_is_active(): %d, IDLE_SCREEN_ID: %d, GRP_ID_IDLE_MAIN: %d, IDLE_SCREEN_SCREENSAVER_ID: %d", mmi_idle_is_active(), IDLE_SCREEN_ID, GRP_ID_IDLE_MAIN, IDLE_SCREEN_SCREENSAVER_ID);
	if(mmi_idle_is_active() || scrId== IDLE_SCREEN_ID || scrId== GRP_ID_IDLE_MAIN || scrId==IDLE_SCREEN_SCREENSAVER_ID
#if(GBC_VER >= 0x1132) && defined(__COSMOS_MMI_PACKAGE__)
	||vapp_screen_lock_is_exist()
#endif
	)	
#else
	//GBC_TRACE("IDLE_SCREEN_ID: %d, IDLE_SCREEN_SCREENSAVER_ID: %d", IDLE_SCREEN_ID, IDLE_SCREEN_SCREENSAVER_ID);
	if(mmi_idle_is_on_idle_screen()||scrId== IDLE_SCREEN_ID || scrId==IDLE_SCREEN_SCREENSAVER_ID /*IDLE_SCREEN_ID_DUMMY IDLE_SCREEN_ID*/)//IDLE_SCREEN_ID_DUMMY
#endif
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

U8 gbc_get_sys_drv(void)
{
	return SRV_FMGR_SYSTEM_DRV;
}

U16 gbc_get_timerId(U16 TimerId)
{
	U16 timeId = GIS_TIMER_ID_0;
	
	switch(TimerId)
	{
	case GBC_TIMER_ID_01:
		timeId+=GBC_TIMER_ID_01;
		break;
	case GBC_TIMER_ID_02:
		timeId+=GBC_TIMER_ID_02;
		break;
	case GBC_TIMER_ID_03:
		timeId+=GBC_TIMER_ID_03;
		break;
	case GBC_TIMER_ID_04:
		timeId+=GBC_TIMER_ID_04;
		break;
	case GBC_TIMER_ID_05:
		timeId+=GBC_TIMER_ID_05;
		break;
	case GBC_TIMER_ID_06:
		timeId+=GBC_TIMER_ID_06;
		break;
	case GBC_TIMER_ID_07:
		timeId+=GBC_TIMER_ID_07;
		break;
	case GBC_TIMER_ID_08:
		timeId+=GBC_TIMER_ID_08;
		break;
	case GBC_TIMER_ID_09:
		timeId+=GBC_TIMER_ID_09;
		break;
	case GBC_TIMER_ID_10:
		timeId+=GBC_TIMER_ID_10;
		break;
	case GBC_TIMER_ID_11:
		timeId+=GBC_TIMER_ID_11;
		break;
	case GBC_TIMER_ID_12:
		timeId+=GBC_TIMER_ID_12;
		break;
	case GBC_TIMER_ID_13:
		timeId+=GBC_TIMER_ID_13;
		break;
	case GBC_TIMER_ID_14:
		timeId+=GBC_TIMER_ID_14;
		break;
	case GBC_TIMER_ID_15:
		timeId+=GBC_TIMER_ID_15;
		break;
	case GBC_TIMER_ID_16:
		timeId+=GBC_TIMER_ID_16;
		break;
	case GBC_TIMER_ID_17:
		timeId+=GBC_TIMER_ID_17;
		break;
	case GBC_TIMER_ID_18:
		timeId+=GBC_TIMER_ID_18;
		break;
	case GBC_TIMER_ID_19:
		timeId+=GBC_TIMER_ID_19;
		break;
	case GBC_TIMER_ID_20:
		timeId+=GBC_TIMER_ID_20;
		break;
	default:
		ASSERT(0);
		break;
	}
	return timeId;
}

U8 gbc_is_zhCN_set(void)
{
	extern pBOOL IsChineseSet(void);

	int i = 0;
	int result = 0;
	
#if 0
	for(i=0; i<(sizeof(gLanguageArray)/sizeof(sLanguageDetails)); i++)
	{
		GBC_TRACE("gbc_is_zhCN_set, aLangSSC: %s", gLanguageArray[i].aLangSSC);
		if (!strcmp((char *) gLanguageArray[i].aLangSSC, (char *)"*#0086#"))
		{
			result = 1;
			break;
		}
	}
#else
	result = IsChineseSet();
#endif
	GBC_TRACE("gbc_is_zhCN_set, i:%d,result:%d", i, result);
	return result;
}

U32 gbc_get_valid_sim(void)
{
	U32 activeSim = 0;
	
#if(GBC_VER>=0x1108)	   
#ifdef __MMI_DUAL_SIM_MASTER__
	if(srv_mode_switch_get_current_mode()==SRV_MODE_DUAL_SIM)
	{
		if (srv_sim_ctrl_is_available(MMI_SIM1))
		{
			activeSim = GBC_SIM_MASTER;
		}
		else if(srv_sim_ctrl_is_available(MMI_SIM2))
		{
			activeSim = GBC_SIM_SLAVE;
		}
	}
	else if(srv_mode_switch_get_current_mode() == SRV_MODE_SIM1_ONLY)
	{
		if (srv_sim_ctrl_is_available(MMI_SIM1))
		{
			activeSim = GBC_SIM_MASTER;
		}
		else
		{
			activeSim = GBC_SIM_NULL;
		}
	}
	else if(srv_mode_switch_get_current_mode() == SRV_MODE_SIM2_ONLY)
	{
		if(srv_sim_ctrl_is_available(MMI_SIM2))
		{
			activeSim = GBC_SIM_SLAVE;
		}
		else
		{
			activeSim = GBC_SIM_NULL;
		}
	}
	else
	{
		activeSim = GBC_SIM_NULL;
	}
#else /* __MMI_DUAL_SIM_MASTER__ */ 
	if (srv_sim_ctrl_is_available(MMI_SIM1))
	{
		activeSim = GBC_SIM_MASTER;
	}
#endif /* __MMI_DUAL_SIM_MASTER__ */ 
#else
#ifdef __MMI_DUAL_SIM_MASTER__
	E_MTPNP_AD_SIMCARD_USABLE_SIDE usable_sim = MTPNP_AD_Get_UsableSide();
	
	if(MTPNP_AD_DUALSIM_USABLE==usable_sim)
	{
		activeSim = GBC_SIM_DUAL;
	}
	else if( MTPNP_AD_SIMCARD1_USABLE==usable_sim)
	{
		activeSim = GBC_SIM_MASTER;
	}
	else if(MTPNP_AD_SIMCARD2_USABLE==usable_sim)
	{
		activeSim = GBC_SIM_SLAVE;
	}
	else
	{
		activeSim =  GBC_SIM_NULL;//无效SIM
	}
#else   /* __MMI_DUAL_SIM_MASTER__ */ 
	if(mmi_bootup_is_sim_valid())
	{
		activeSim = GBC_SIM_MASTER;
	}
#endif  /* __MMI_DUAL_SIM_MASTER__ */ 
#endif /* GBC_VER */
	return activeSim;
}

U32 gbc_get_active_sim(void)
{
	U32 activeSim = gbc_get_valid_sim();
#if(GBC_VER<0x1108)
#if defined( __MMI_DUAL_SIM_MASTER__)
	if(activeSim==GBC_SIM_DUAL)
	{
		if (mmi_bootup_is_nw_registration_ok() && mmi_bootup_is_sim2_nw_registration_ok())
		{
			activeSim = GBC_SIM_MASTER;
		}
		else if(mmi_bootup_is_nw_registration_ok())
		{
			activeSim = GBC_SIM_MASTER;
		}
		else if(mmi_bootup_is_sim2_nw_registration_ok())
		{
			activeSim = GBC_SIM_SLAVE;
		}
		else
		{
			activeSim = GBC_SIM_NULL;
		}
	}
	else if(activeSim==GBC_SIM_SLAVE && mmi_bootup_is_sim2_nw_registration_ok())
	{
		activeSim = GBC_SIM_SLAVE;
	}
	else 
#endif    /*__MMI_DUAL_SIM_MASTER__*/
	if(mmi_bootup_is_nw_registration_ok())
	{
		activeSim = GBC_SIM_MASTER;
	}
	else
	{
		activeSim = GBC_SIM_NULL;
	}
#endif
		GBC_TRACE("gbc_get_active_sim,activeSim:%d,Valid sim:%d", activeSim, gbc_get_valid_sim());
		return activeSim;
}

int gbc_get_network_type(int sim)
{  
	int nType = 0;
	
#if(GBC_VER<0x1108)
	if(sim == GBC_SIM_MASTER && g_pwr_context.CurrentServiceType == FULL_SERVICE)
	{
		if(!memcmp((char *)gPLMN,"46001", 5) ||!memcmp((char *)gPLMN,"46006", 5))
		{
			nType = 2;
		}
		else
		{
			nType = 1;
		}
	}
#ifdef __MMI_DUAL_SIM_MASTER__		
	else	if(sim == GBC_SIM_SLAVE && g_pwr_context_2.CurrentServiceType == FULL_SERVICE)
	{
		if(!memcmp((char *)gPLMN,"46001", 5) ||!memcmp((char *)gPLMN,"46006", 5))
		{
			nType = 2;
		}
		else
		{
			nType = 1;
		}
	}
#endif
#else
	if(sim == GBC_SIM_MASTER)
	{
		char ghnum1[MAX_PLMN_LEN + 1]={0};
		srv_sim_ctrl_get_home_plmn(MMI_SIM1, (S8 * )ghnum1, MAX_PLMN_LEN + 1);
		if(!memcmp((char *)ghnum1,"46001", 5) ||!memcmp((char *)ghnum1,"46006", 5))
		{
			nType = 2;
		}
		else
		{
			nType = 1;
		}
	}
#ifdef __MMI_DUAL_SIM_MASTER__
	else if(sim == GBC_SIM_SLAVE)
	{
		char ghnum2[MAX_PLMN_LEN + 1]={0};
		srv_sim_ctrl_get_home_plmn(MMI_SIM2, (S8 * )ghnum2, MAX_PLMN_LEN + 1);
		if(!memcmp((char *)ghnum2,"46001", 5) ||!memcmp((char *)ghnum2,"46006", 5))
		{
			nType = 2;
		}
		else
		{
			nType = 1;
		}
	}
#endif
#endif
	return nType;
}

void gbc_imsi_rsp(void* inMsg)
{
	mmi_smu_get_imsi_rsp_struct *msg = (mmi_smu_get_imsi_rsp_struct *)inMsg;
	if(msg->result)
	{
		memset(gbc_IMSI, 0x00, sizeof(gbc_IMSI));
#if WIN32
		strcpy(gbc_IMSI, GBC_WIN32_IMSI);
#else
		strcpy(gbc_IMSI, (char *)msg->imsi);
#endif
		gbc_TrimStr((char *)gbc_IMSI);
		GBC_TRACE("gbc_imsi_rsp,gbc_IMSI:%s;", gbc_IMSI);
	}
	else
	{
		GBC_TRACE("gbc_imsi_rsp, fail, retry!");
		gbc_get_imsi_req();
	}
}

void gbc_get_imsi_req(void)
{
	U8 simCard = gbc_get_active_sim();

	GBC_TRACE("gbc_get_imsi_req,simCard:%d,gbc_IMSI:%s", simCard, gbc_IMSI);
	 memset(gbc_IMSI, 0, sizeof(gbc_IMSI));	
#if(GBC_VER>=0x1132)	
	{
#if WIN32
		strcpy(gbc_IMSI, GBC_WIN32_IMSI);
#else
		srv_sim_ctrl_get_imsi(simCard, gbc_IMSI, sizeof(gbc_IMSI));
#endif
		gbc_TrimStr((char *)gbc_IMSI);
		GBC_TRACE("gbc_get_imsi_req,gbc_IMSI:%s;", gbc_IMSI);
	}
#elif (GBC_VER>= 0x1108)
#ifdef __MMI_DUAL_SIM_MASTER__
	if(GBC_SIM_SLAVE==simCard)
	{ 
		gbc_SetSlaveProtocolEventHandler((gbc_PSHandle)gbc_imsi_rsp, MSG_ID_MMI_SMU_GET_IMSI_RSP);
		srv_sms_disp_send_msg_req(MSG_ID_MMI_SMU_GET_IMSI_REQ,SRV_SMS_SIM_2, NULL);
	}
	else
#endif
	{
		gbc_SetProtocolEventHandler((gbc_PSHandle)gbc_imsi_rsp, MSG_ID_MMI_SMU_GET_IMSI_RSP);
		srv_sms_disp_send_msg_req(MSG_ID_MMI_SMU_GET_IMSI_REQ,SRV_SMS_SIM_1, NULL);
	}
#else
#if defined(__MMI_DUAL_SIM_MASTER__)
	if(GBC_SIM_SLAVE==simCard)
	{
		gbc_SetSlaveProtocolEventHandler((gbc_PSHandle)gbc_imsi_rsp, MSG_ID_MMI_SMU_GET_IMSI_RSP);    
		gbc_msg_send_ext_queue(MOD_MMI, MOD_L4C_2, PRT_GET_IMSI_REQ, 0,NULL,NULL);
	}
	else
#endif
	{
		gbc_SetProtocolEventHandler((gbc_PSHandle)gbc_imsi_rsp, MSG_ID_MMI_SMU_GET_IMSI_RSP);	
		gbc_msg_send_ext_queue(MOD_MMI, MOD_L4C, PRT_GET_IMSI_REQ, MMI_L4C_SAP,NULL,NULL);
	}
#endif
}

void gbc_delete_sms_rsp(void *dummy, module_type mod, U16 result)
{
	if (result != 0 /* MMI_FRM_SMS_OK */)
	{
		gbc_sms_out_queue();
		GBC_TRACE("gbc_delete_sms_rsp, result: %d, failed !", result);	
	}
	else
	{
		gbc_sms_reset_queue();
		GBC_TRACE("gbc_delete_sms_rsp, result: %d, success !", result);	
	}
}

void gbc_delete_sms_req(S32 index)
{
	GBC_TRACE("gbc_delete_sms_req, index: %d", index);
#if (GBC_VER<0x1012)
	if(index>=0)
	{
		if(mmi_frm_sms_get_sms_list_size(MMI_FRM_SMS_APP_INBOX) == MMI_FRM_SMS_INVALID_INDEX)
		{
			gbc_sms_in_queue(index);
		}
		else 
		{
			gbc_sms_in_queue(index);
			mmi_frm_sms_delete_sms(gbc_delete_sms_rsp, MOD_MMI, MMI_FRM_SMS_APP_AWAITS|MMI_FRM_SMS_APP_NOBOX|MMI_FRM_SMS_APP_DATA, index);
		}
	}
#else
	if(index>=0)
	{
		srv_sms_delete_msg((U16)index, NULL, (void*)NULL);
	}
#endif
}

BOOL gbc_sms_delete_handle(void *pData, void *pContent)
{
#if (GBC_VER<0x1012)
	mmi_frm_sms_deliver_msg_struct *msginfo = (mmi_frm_sms_deliver_msg_struct *)pData;
	GBC_TRACE("gbc_sms_delete_handle, index: %d", msginfo->index);
	gbc_delete_sms_req(msginfo->index);
#endif
	return TRUE;
}

BOOL gbc_sms_recv_handle(void *pData, int withobject, void *pContent)
{
	BOOL result = FALSE;
	
#if (GBC_VER>=0x1012)
	srv_sms_new_msg_struct *msginfo = (srv_sms_new_msg_struct *)pData;
	GBC_TRACE("gbc_sms_recv_handle, withobject: %d ", withobject);
	if(!withobject)
	{
		return FALSE;
	}
#else
	mmi_frm_sms_deliver_msg_struct *msginfo = (mmi_frm_sms_deliver_msg_struct*) pData;
	GBC_TRACE("gbc_sms_recv_handle, withobject: %d ", withobject);
#endif
	if(mmi_ucs2strlen((char *)pContent)>256)
	{
		return FALSE;
	}
	
#if (GBC_VER<0x1012)
	result=gbc_sms_mon_handle((char *)msginfo->addr_number.number, (char *)pContent, msginfo->dcs);
#else
	if(gbc_sms_mon_handle((char *)msginfo->number, (char *)pContent, msginfo->dcs))
	{
		gbc_delete_sms_req(msginfo->msg_id);
		result =  TRUE;
	}
#endif
	GBC_TRACE("gbc_sms_recv_handle, result: %d ", result);
	return result;
}

#if (GBC_VER<0x1012)
/* called by mmi_frm_sms_indicate_sms(), InitMessageProtocolEventHandlers() , mmi_msg_set_protocol_event_handler() */
void gbc_InitializeAll(void)
{
	mmi_frm_sms_reg_msg_check(gbc_sms_recv_handle, gbc_sms_delete_handle);
}
#endif

#if (GBC_VER<0x1012)
void gbc_send_sms_rsp(void *inMsg)
{
	U16 result = 0;
	MMI_FRM_SMS_SEND_MSG_RSP_STRUCT *msgRsp = (MMI_FRM_SMS_SEND_MSG_RSP_STRUCT*) inMsg;
	if(msgRsp->result)
	{
		result = 0;
	}
	else
	{
		result = 1;
	}
#if defined(WIN32)
	result = 0;
#endif
	GBC_TRACE("gbc_send_sms_rsp,result:%d,msgRsp->result:%d,cause:%d", result, msgRsp->result, msgRsp->cause);
	if(bkfuncall)
	{
		bkfuncall(result);
		bkfuncall =NULL;
	}
#ifndef __MMI_DUAL_SIM_MASTER__
	ClearProtocolEventHandler(PRT_MSG_ID_MMI_SMS_SEND_MSG_RSP);
	ClearProtocolEventHandler(PRT_MSG_ID_MMI_SMS_SEND_ABORT_START_IND);
#else
	switch (MTPNP_AD_Get_Channel(MTPNP_AD_SMS_CHANNEL))
	{
	case MTPNP_AD_CHANNEL_SLAVE:
	case MTPNP_AD_CHANNEL_DEFAULT_SLAVE:
		MTPNP_PFAL_Remove_Event_Handler(MTPNP_PFAL_MSG_SMS_SEND_MSG_SUCCEED);
		MTPNP_PFAL_Remove_Event_Handler(MTPNP_PFAL_MSG_SMS_SEND_MSG_FAILED);
		break;
	case MTPNP_AD_CHANNEL_MASTER:
	case MTPNP_AD_CHANNEL_DEFAULT_MASTER:
		ClearProtocolEventHandler(PRT_MSG_ID_MMI_SMS_SEND_MSG_RSP);
		ClearProtocolEventHandler(PRT_MSG_ID_MMI_SMS_SEND_ABORT_START_IND);
	default:
		break;
	}
#endif
}

#ifdef __MMI_DUAL_SIM_MASTER__
void gbc_send_sms_slave_rsp(void *inMsg)
{
	ST_MTPNP_AD_SMS_SEND_RSP *msg_rsp = (ST_MTPNP_AD_SMS_SEND_RSP *)inMsg;
	MMI_FRM_SMS_SEND_MSG_RSP_STRUCT msg_send_rsp;
	GBC_TRACE("gbc_send_sms_slave_rsp,result:%d,cause:%d", msg_rsp->result, msg_rsp->cause);
	MTPNP_OSAL_memset(&msg_send_rsp, 0, sizeof(MMI_FRM_SMS_SEND_MSG_RSP_STRUCT));
	if(msg_rsp == MTPNP_NULL)
	{
		msg_send_rsp.result = MTPNP_TRUE;
	}
	else
	{
		MTPNP_PFAL_Convert_SendRsp_Msg((void *)msg_rsp, (void *)&msg_send_rsp);
	}
	gbc_send_sms_rsp(&msg_send_rsp);
}
#endif

void gbc_send_mo_sms(char *ascii_number, char *pContent, U8 dcs, gbc_RspFunc RspCallBack)
{
	mmi_sms_send_msg_req_struct *sendSms;
	
#if defined(__MMI_DUAL_SIM_MASTER__)
	E_MTPNP_AD_CHANNELS eChannel;
	U32 activeSim = gbc_get_active_sim();
	MTPNP_AD_Free_Channel(MTPNP_AD_SMS_CHANNEL);
	if(activeSim==GBC_SIM_MASTER)
	{
		MTPNP_AD_Set_Channel(MTPNP_AD_SMS_CHANNEL, MTPNP_AD_CHANNEL_MASTER);
	}
	else if(activeSim==GBC_SIM_SLAVE)
	{
		MTPNP_AD_Set_Channel(MTPNP_AD_SMS_CHANNEL, MTPNP_AD_CHANNEL_SLAVE);
	}
	else
	{
		return;
	}
#endif
	GBC_TRACE("gbc_send_mo_sms,Num:%s,Content:%s", ascii_number, pContent);
	bkfuncall = RspCallBack;
	sendSms = (mmi_sms_send_msg_req_struct *)OslConstructDataPtr(sizeof(mmi_sms_send_msg_req_struct));
	memset(sendSms, 0, sizeof(mmi_sms_send_msg_req_struct));
	
	sendSms->ref_count = 1;
	sendSms->msg_len = sizeof(mmi_sms_send_msg_req_struct);
	sendSms->reply_index = MMI_FRM_SMS_INVALID_INDEX;
	sendSms->dest.type = CSMCC_DEFAULT_ADDR_TYPE;
	sprintf((char *)sendSms->dest.number, "%s", ascii_number);
	sendSms->dest.length=strlen((char *)sendSms->dest.number);
	sendSms->para = 0;
	sendSms->profile = 0;
	sendSms->sc_addr.length = 0xff;
	sendSms->sc_addr.type = 0xff;
	sendSms->vp = 0xff;
	sendSms->pid = 0xff;
	sendSms->udhi = 0;
	
	memset(sendSms->msg, 0, sizeof(sendSms->msg));
	if(dcs==GBC_ASCII)
	{
		sendSms->dcs = SMSAL_DEFAULT_DCS;
		memcpy(sendSms->msg, pContent, SMSAL_MAX_MSG_LEN);
		sendSms->length = strlen((const char*)sendSms->msg);
	}
	else if(dcs==GBC_UTF8)
	{
		sendSms->dcs = SMSAL_UCS2_DCS; /* SMSAL_UCS2 */
		sendSms->length= gbc_sms_utf8_convert_to_ucs2(pContent, dcs, sendSms->msg, SMSAL_MAX_MSG_LEN);
	}
	else
	{		
		sendSms->dcs = SMSAL_UCS2;
		memcpy(sendSms->msg, pContent, SMSAL_MAX_MSG_LEN);
		sendSms->length = mmi_ucs2strlen((S8 *)sendSms->msg)*2;
	}
#if defined(__MMI_DUAL_SIM_MASTER__)
	eChannel=MTPNP_AD_Get_Channel(MTPNP_AD_SMS_CHANNEL);
	if(eChannel !=MTPNP_AD_CHANNEL_MASTER)
	{
		sendSms->seq_num = 0;
		sendSms->mms_mode = 0;
	}
	switch (eChannel)
	{
	case MTPNP_AD_CHANNEL_SLAVE:
	case MTPNP_AD_CHANNEL_DEFAULT_SLAVE:
		MTPNP_PFAL_Register_Event_Handler(MTPNP_PFAL_MSG_SMS_SEND_MSG_SUCCEED, gbc_send_sms_slave_rsp);
		MTPNP_PFAL_Register_Event_Handler(MTPNP_PFAL_MSG_SMS_SEND_MSG_FAILED, gbc_send_sms_slave_rsp);
		MTPNP_PFAL_Send_Message_Segment((void *)sendSms);
		break;
	case MTPNP_AD_CHANNEL_MASTER:
	case MTPNP_AD_CHANNEL_DEFAULT_MASTER:
	default:
		gbc_SetProtocolEventHandler((gbc_PSHandle)gbc_send_sms_rsp, PRT_MSG_ID_MMI_SMS_SEND_MSG_RSP);
		mmi_frm_sms_send_message(MOD_MMI, MOD_L4C, 0, PRT_MSG_ID_MMI_SMS_SEND_MSG_REQ, (oslParaType *)sendSms, NULL);
		break;
	}
#else
	gbc_SetProtocolEventHandler((gbc_PSHandle)gbc_send_sms_rsp, PRT_MSG_ID_MMI_SMS_SEND_MSG_RSP);
	mmi_frm_sms_send_message(MOD_MMI, MOD_L4C, 0, PRT_MSG_ID_MMI_SMS_SEND_MSG_REQ, (oslParaType *)sendSms, NULL);
#endif
}
#else
static void gbc_send_sms_rsp(srv_sms_callback_struct *callback_data)
{
	U16 result = 0; /* SRV_SMS_CAUSE_NO_ERROR */
	
	GBC_TRACE("gbc_send_sms_rsp,result:%d,cause:%d", callback_data->result, callback_data->cause);
#if (GBC_VER >=0x1012)
	if(callback_data->result)
	{
		result = 0;
	}
	else
	{
		result = 1;
	}
	GBC_TRACE("gbc_send_sms_rsp,result:%d,cause:%d", result, callback_data->cause);
#else
	result = callback_data->result;
#endif
#ifdef WIN32
	result = 0;
#endif
	if(bkfuncall && callback_data)
	{
		bkfuncall(result);
		bkfuncall = NULL;
	}	
}

void gbc_send_mo_sms(char *ascii_number, char *pContent, U8 dcs, gbc_RspFunc RspCallBack)
{
	int sim_id;
	U16 content_size;
	char  ucs2_num[64];
	SMS_HANDLE sms_handle;
	char *textbufUCS2 = NULL;
	
	if(strlen(ascii_number) <=0 || strlen(pContent)<=0 )
	{
		return;
	} 
#if !defined(__MTK_TARGET__)
	if(RspCallBack)
	{
		RspCallBack(0);
	}
	return;
#endif
	textbufUCS2 = (char *)OslMalloc(420); /* SYSAPP_MAX_SMS_CMD && SMSAL_MAX_MSG_LEN*/
	if(textbufUCS2 == NULL)
	{
		return;
	}
	else
	{
		memset(textbufUCS2, 0x00, 420); /* SYSAPP_MAX_SMS_CMD && SMSAL_MAX_MSG_LEN*/
	}
	bkfuncall = RspCallBack;
	memset(ucs2_num, 0x00, sizeof(ucs2_num));
	gbc_MultiByteToWideChar(ascii_number, (WORD *)ucs2_num, sizeof(ucs2_num), GBC_UTF8);
	gbc_MultiByteToWideChar(pContent, (WORD *)textbufUCS2, 420, GBC_UTF8); /* SYSAPP_MAX_SMS_CMD && SMSAL_MAX_MSG_LEN*/
	content_size = mmi_ucs2strlen((const char *)textbufUCS2)*2;
	GBC_TRACE("gbc_send_mo_sms,Num:%s,Content:%s", ascii_number, pContent);
	sms_handle = srv_sms_get_send_handle();
	if (bkfuncall && (!sms_handle || srv_sms_is_bg_send_action_busy()))
	{
		bkfuncall(1);
		bkfuncall=NULL;
       	OslMfree(textbufUCS2);
		return;
	}	
	sim_id = gbc_get_active_sim();
	if(sim_id == GBC_SIM_SLAVE)
	{
		sim_id=SRV_SMS_SIM_2;
	}
	else
	{
		sim_id=SRV_SMS_SIM_1;
	}
	srv_sms_set_address((SMS_HANDLE)sms_handle, (char*)ucs2_num);
	srv_sms_set_sim_id((SMS_HANDLE)sms_handle, sim_id);
	srv_sms_set_status_report(sms_handle, MMI_FALSE);
	srv_sms_set_content_dcs(sms_handle, SMSAL_DEFAULT_DCS);
	srv_sms_set_content((SMS_HANDLE)sms_handle, (S8*)textbufUCS2, (U16)content_size);
#if (GBC_VER>= 0x1352)
	srv_sms_set_send_type(sms_handle, SRV_SMS_FG_SEND);
#else
	srv_sms_set_send_type(sms_handle, SRV_SMS_BG_SEND);
#endif
	srv_sms_set_no_sending_icon(sms_handle);
	srv_sms_send_msg((void*)sms_handle, (SrvSmsCallbackFunc)gbc_send_sms_rsp, NULL);
	OslMfree(textbufUCS2);
	gbc_SMSReport  =1;
} 
#endif

#if (GBC_VER>= 0x1012)
extern BOOL gbc_sms_mon_handle(char *pszNumber, char *pszContent, U8 dcs);
#if (GBC_VER>0x1012)
extern void mmi_srv_sms_send_sms_ack(MMI_BOOL result, U16 error_cause, srv_sms_sim_enum sim_id, U16 pdu_id, U8 msg_class, MMI_BOOL is_msg_wait, MMI_BOOL is_store);
void gbc_srv_sms_send_sms_ack(MMI_BOOL result, U16 error_cause, srv_sms_sim_enum sim_id, U16 pdu_id, U8 msg_class, MMI_BOOL is_msg_wait, MMI_BOOL is_store)
{
	mmi_srv_sms_send_sms_ack(result, error_cause, sim_id, pdu_id, msg_class, is_msg_wait, is_store);
}
#else
extern void mmi_srv_sms_send_sms_ack(srv_sms_sim_enum sim_id, U32 msg_id, U8 mem, MMI_BOOL result, U32 error_cause);
void gbc_srv_sms_send_sms_ack(srv_sms_sim_enum sim_id, U32 msg_id, U8 mem, MMI_BOOL result, U32 error_cause)
{
	mmi_srv_sms_send_sms_ack(sim_id, msg_id, mem, result, error_cause);
}
#endif
#endif

void gbc_get_sms_sc(void)
{
	U32 cursim = gbc_get_active_sim();
#if (GBC_VER >= 0x1108)
	const srv_sms_setting_struct *default_setting;
#endif

	GBC_TRACE("gbc_get_sms_sc,cursim:%d,gbc_SC:%s", cursim, gbc_SC);
	gbc_get_imsi_req();
	if(strlen(gbc_SC)>10)
	{
		StopTimer(gbc_get_timerId(GBC_TIMER_ID_02));
		return;
	}
	else
	{
		StartTimer(gbc_get_timerId(GBC_TIMER_ID_02), 3000, gbc_get_sms_sc);
	}
#if (GBC_VER >= 0x1108)
#ifdef __MMI_DUAL_SIM_MASTER__
	if(cursim == GBC_SIM_SLAVE)
	{
		default_setting = srv_sms_get_default_setting(SRV_SMS_SIM_2);
	}
#endif
	if(cursim == GBC_SIM_MASTER)
	{
		default_setting = srv_sms_get_default_setting(SRV_SMS_SIM_1);
	}
	
	if(default_setting)
	{
		memset(gbc_SC, 0x00, sizeof(gbc_SC));
#if defined(WIN32)
		strncpy(gbc_SC, GBC_WIN32_SC, sizeof(gbc_SC));
#else
		strncpy(gbc_SC, default_setting->sc_addr, sizeof(gbc_SC));
#endif
		gbc_TrimStr((char *)gbc_SC);
	}
#else
#ifdef __MMI_DUAL_SIM_MASTER__
	if(cursim == GBC_SIM_SLAVE)
	{
		gbc_get_sim2_profile();
	}
#endif
	if(cursim == GBC_SIM_MASTER)
	{
		gbc_get_sim1_profile();
	}
#endif
}

#if (GBC_VER < 0x1108)
#if (GBC_VER < 0x1012)
static void gbc_get_sim_profile_sim1_rsp (void* inMsg)
{
	MMI_FRM_SMS_GET_PROFILE_PARAMS_RSP_STRUCT *msgRsp = (MMI_FRM_SMS_GET_PROFILE_PARAMS_RSP_STRUCT*)inMsg;
	
	ClearProtocolEventHandler(MSG_ID_MMI_SMS_GET_PROFILE_PARAMS_RSP);
#ifdef __MMI_DUAL_SIM_MASTER__
	if (MTPNP_AD_Get_Status() == MTPNP_AD_CARD2)
	{
		return;
	}
#endif
	if(msgRsp->result)
	{
		memset(gbc_SC, 0x00, sizeof(gbc_SC));
#if WIN32
		sprintf(gbc_SC, "%s", GBC_WIN32_SC);
#else
		if(msgRsp->sc_addr.number[0] == '+')
		{
			strncpy((char *)gbc_SC, (char *)msgRsp->sc_addr.number+1, sizeof(gbc_SC));
		}
		else
		{
			strncpy((char *)gbc_SC, (char *)msgRsp->sc_addr.number, sizeof(gbc_SC));
		}
#endif
		gbc_TrimStr((char *)gbc_SC);
	}
	else
	{
		StartTimer(gbc_get_timerId(GBC_TIMER_ID_02), 3000, gbc_get_sms_sc);
	}
	GBC_TRACE("gbc_get_sim_profile_sim1_rsp,gbc_SC:%s;", gbc_SC);
}

static void gbc_get_sim_profile_sim1_req (void* inMsg)
{
	U8 index = *(U8*)inMsg;
	MMI_FRM_SMS_GET_PROFILE_PARAMS_REQ_STRUCT* msgReq;
	
	msgReq	= (MMI_FRM_SMS_GET_PROFILE_PARAMS_REQ_STRUCT *)OslConstructDataPtr(sizeof(MMI_FRM_SMS_GET_PROFILE_PARAMS_REQ_STRUCT));
	msgReq->profile_no = index;
	
	gbc_SetProtocolEventHandler((gbc_PSHandle)gbc_get_sim_profile_sim1_rsp, MSG_ID_MMI_SMS_GET_PROFILE_PARAMS_RSP);
	mmi_frm_sms_send_message(MOD_MMI, MOD_L4C, 0, PRT_MSG_ID_MMI_SMS_GET_PROFILE_PARAMS_REQ, (oslParaType *)msgReq, NULL);
}
#else  /* GBC_VER */
void gbc_get_sim_profile_sim1_rsp(srv_sms_callback_struct *callback_data)
{
	srv_sms_profile_struct *msgRsp = (srv_sms_profile_struct *)callback_data->action_data;
	
	ClearProtocolEventHandler(MSG_ID_MMI_SMS_GET_PROFILE_PARAMS_RSP);
	memset(gbc_SC, 0x00, sizeof(gbc_SC));
#if WIN32
	sprintf(gbc_SC, "%s", GBC_WIN32_SC);
#else
	mmi_ucs2_to_asc(gbc_SC,(S8*)(msgRsp->sc_addr));
#endif
	gbc_TrimStr((char *)gbc_SC);
	GBC_TRACE("gbc_get_sim_profile_sim1_rsp, gbc_SC:%s;", gbc_SC);
}
#endif /* (GBC_VER < 0x1012) */

void gbc_get_sim1_profile(void)
{
	U8 index;
	S16 error_code = 0;
	
	GBC_TRACE("gbc_get_sim1_profile");
	ReadValue(NVRAM_SMS_ACTIVE_PROFILE_INDEX, &index, DS_BYTE, &error_code);
	
#if defined( __MMI_DUAL_SIM_MASTER__)
	MTPNP_AD_Free_Channel(MTPNP_AD_SMS_CHANNEL);
	MTPNP_AD_Set_Channel(MTPNP_AD_SMS_CHANNEL, MTPNP_AD_CHANNEL_MASTER);	
#endif
	
#if (GBC_VER >= 0x1012)	
	srv_sms_get_setting_para(SRV_SMS_ACTIVE_SC_ADDR, NULL, SRV_SMS_SIM_1, (SrvSmsCallbackFunc)gbc_get_sim_profile_sim1_rsp, NULL);
#else
	gbc_get_sim_profile_sim1_req(&index);
#endif
}

#ifdef __MMI_DUAL_SIM_MASTER__
#if (GBC_VER < 0x1012)
static void gbc_get_sim_profile_sim2_rsp (void* inMsg)
{
	MMI_FRM_SMS_GET_PROFILE_PARAMS_RSP_STRUCT *msgRsp = (MMI_FRM_SMS_GET_PROFILE_PARAMS_RSP_STRUCT*)inMsg;
#if (GBC_VER >= 0x0912)
	mmi_frm_clear_slave_protocol_event_handler(MSG_ID_MMI_SMS_GET_PROFILE_PARAMS_RSP,NULL);
#else
	mmi_frm_clear_slave_protocol_event_handler(MSG_ID_MMI_SMS_GET_PROFILE_PARAMS_RSP);
#endif
	
	if (MTPNP_AD_Get_Status() == MTPNP_AD_CARD1)
	{
		return;
	}
	if(msgRsp->result)
	{
		memset(gbc_SC, 0x00, sizeof(gbc_SC));
		if(msgRsp->sc_addr.number[0] == '+')
		{
			strcpy((char *)gbc_SC,(char*)msgRsp->sc_addr.number+1);
		}
		else
		{
			strcpy((char *)gbc_SC,(char*)msgRsp->sc_addr.number);
		}
		gbc_TrimStr((char *)gbc_SC);
	}
	else
	{
		StartTimer(gbc_get_timerId(GBC_TIMER_ID_02), 3000, gbc_get_sms_sc);
	}
	GBC_TRACE("gbc_get_sim_profile_sim2_rsp,gbc_SC:%s;", gbc_SC);
}

static void gbc_get_sim_profile_sim2_req (void* inMsg)
{
	U8 index = *(U8 *)inMsg;
	MMI_FRM_SMS_GET_PROFILE_PARAMS_REQ_STRUCT* msgReq;
	
	msgReq= (MMI_FRM_SMS_GET_PROFILE_PARAMS_REQ_STRUCT*)OslConstructDataPtr(sizeof(MMI_FRM_SMS_GET_PROFILE_PARAMS_REQ_STRUCT));
	msgReq->profile_no= index;

	gbc_SetSlaveProtocolEventHandler((gbc_PSHandle)gbc_get_sim_profile_sim2_rsp, MSG_ID_MMI_SMS_GET_PROFILE_PARAMS_RSP);
	mmi_frm_sms_send_message(MOD_MMI, MOD_L4C_2, 0, PRT_MSG_ID_MMI_SMS_GET_PROFILE_PARAMS_REQ, (oslParaType *)msgReq, NULL);
}
#else  /* GBC_VER */
static void gbc_get_sim_profile_sim2_rsp(srv_sms_callback_struct *callback_data)
{
	srv_sms_profile_struct *msgRsp = (srv_sms_profile_struct *)callback_data->action_data;
	
	mmi_frm_clear_slave_protocol_event_handler(MSG_ID_MMI_SMS_GET_PROFILE_PARAMS_RSP, NULL);
	memset(gbc_SC, 0x00, sizeof(gbc_SC));
#if WIN32
	sprintf(gbc_SC, "%s", GBC_WIN32_SC);
#else
	mmi_ucs2_to_asc(gbc_SC, (S8*)(msgRsp->sc_addr));
#endif
	gbc_TrimStr((char *)gbc_SC);
	GBC_TRACE("gbc_get_sim_profile_sim2_rsp,gbc_SC:%s;", gbc_SC);
}
#endif /* GBC_VER */

void gbc_get_sim2_profile(void)
{
	U8 index;
	short  error_code = 0;

	GBC_TRACE("gbc_get_sim2_profile");
	ReadValue(NVRAM_SMS_ACTIVE_PROFILE_INDEX, &index, DS_BYTE, &error_code);
	MTPNP_AD_Free_Channel(MTPNP_AD_SMS_CHANNEL);
	MTPNP_AD_Set_Channel(MTPNP_AD_SMS_CHANNEL, MTPNP_AD_CHANNEL_SLAVE); 
#if (GBC_VER >= 0x1012)
	srv_sms_get_setting_para(SRV_SMS_ACTIVE_SC_ADDR, NULL, SRV_SMS_SIM_2, (SrvSmsCallbackFunc)gbc_get_sim_profile_sim2_rsp, NULL);
#else
	gbc_get_sim_profile_sim2_req(&index);
#endif
}
#endif /* __MMI_DUAL_SIM_MASTER__ */
#endif /* (GBC_VER < 0x1108) */

#if (GBC_VER>0x0840)
void  gbc_ivr_key_start_req(char digit)
{
	MYQUEUE Message;
	mmi_cc_start_dtmf_req_struct *dtmf;
	
	GBC_TRACE("gbc_ivr_key_start_req, %c", digit);
	Message.oslSrcId = MOD_MMI;
#ifdef  __MMI_DUAL_SIM__
	if(gbc_get_active_sim() == GBC_SIM_MASTER)
	{
		Message.oslDestId = MOD_L4C; 
	}
	else
	{
		Message.oslDestId = MOD_L4C_2; 
	}
#else
	Message.oslDestId = MOD_L4C; 
#endif
	Message.oslMsgId = PRT_DTMF_START_REQ;
	dtmf = (mmi_cc_start_dtmf_req_struct*)OslConstructDataPtr(sizeof(mmi_cc_start_dtmf_req_struct));
	dtmf->digit = digit;
	Message.oslDataPtr = (oslParaType*)dtmf;
	Message.oslPeerBuffPtr = NULL;
	OslMsgSendExtQueue(&Message);
}

void  gbc_ivr_key_stop_req(void)
{
	MYQUEUE Message;
	mmi_cc_stop_dtmf_req_struct *dtmf;
	
	GBC_TRACE("gbc_ivr_key_stop_req");
	Message.oslSrcId = MOD_MMI;
#ifdef  __MMI_DUAL_SIM__
	if(gbc_get_active_sim() == GBC_SIM_MASTER)
	{
		Message.oslDestId = MOD_L4C;
	}
	else
	{
		Message.oslDestId = MOD_L4C_2;
	}
#else
	Message.oslDestId = MOD_L4C;
#endif
	Message.oslMsgId = PRT_DTMF_STOP_REQ;
	dtmf = (mmi_cc_stop_dtmf_req_struct*)OslConstructDataPtr(sizeof(mmi_cc_stop_dtmf_req_struct));
	Message.oslDataPtr = (oslParaType*)dtmf;
	Message.oslPeerBuffPtr = NULL;
	OslMsgSendExtQueue(&Message);
}
#else
void gbc_ivr_key_start_req(char digit)
{
	MYQUEUE Message;
	MMI_DTMF_DIGIT *dtmf;
	
	GBC_TRACE("gbc_ivr_key_start_req, %c", digit);
	Message.oslSrcId = MOD_MMI;
#ifdef  __MMI_DUAL_SIM__
	if(gbc_get_active_sim() == GBC_SIM_MASTER)
	{
		Message.oslDestId = MOD_L4C;
	}
	else
	{
		Message.oslDestId = MOD_L4C_2;
	}
#else
	Message.oslDestId = MOD_L4C;
#endif
	Message.oslMsgId = PRT_DTMF_START_REQ;
	dtmf = (MMI_DTMF_DIGIT*) OslConstructDataPtr(sizeof(MMI_DTMF_DIGIT));
	dtmf->digit = digit;
	Message.oslDataPtr = (oslParaType*) dtmf;
	Message.oslPeerBuffPtr = NULL;
	OslMsgSendExtQueue(&Message);	
}

void  gbc_ivr_key_stop_req(void)
{
	MYQUEUE Message;
	
	GBC_TRACE("gbc_ivr_key_stop_req");
	Message.oslSrcId = MOD_MMI;
#ifdef  __MMI_DUAL_SIM__
	if(gbc_get_active_sim() == GBC_SIM_MASTER)
	{
		Message.oslDestId = MOD_L4C;
	}
	else
	{
		Message.oslDestId = MOD_L4C_2;
	}
#else
	Message.oslDestId = MOD_L4C;
#endif
	Message.oslMsgId = PRT_DTMF_STOP_REQ;
	Message.oslDataPtr = NULL;
	Message.oslPeerBuffPtr = NULL;
	OslMsgSendExtQueue(&Message);
}
#endif

BOOL gbc_ivr_call_is_idle(void)
{
	S8 result = 0;
#if (GBC_VER>=0x1012)
	U8 index = srv_gcall_get_free_index();
	GBC_TRACE("gbc_ivr_call_is_idle,index:%d", index);
	
	if (1)//(index != SRV_GCALL_INVALID_INDEX)//如果存在空闲位置
#else
	CALL_STATE currCallState = GetCurrentState();	
	if (currCallState == CM_IDLE_STATE)
#endif
	{
#if !defined(__COSMOS_MMI_PACKAGE__)
		if (mmi_ucm_app_get_marker_scrn_id() == GetActiveScreenId())
#else
		if(srv_ucm_is_any_call())
#endif
		{
			GBC_TRACE("gbc_ivr_call_is_idle,SCR_ID_UCM_MARKER==GetActiveScreenId()");
			result = FALSE;
		}
		else
		{
			result = TRUE;
		}		
	}
	else
	{
		result = FALSE;
	}
	GBC_TRACE("gbc_ivr_call_is_idle, result: %d", result);
	return result;
}

static void gbc_ivr_save_call_handle(U8 sim)
{
	gbc_IVRHandleRst = TRUE;
#if (GBC_VER >= 0x1012)
	GBC_OUTGOINGCALL_EVENT_RSP_HANDLE=(gbc_PSFunc)srv_gcall_phdlr_dial_ind;
	GBC_SPEECH_IND_EVENT_HANDLE=(gbc_PSFunc)srv_gcall_phdlr_speech_ind;
	GBC_OUTGOINGCALL_CONNECTED_HANDLE=(gbc_PSFunc)srv_gcall_phdlr_call_connect_ind;
#else
#ifdef __MMI_DUAL_SIM_MASTER__
	if (GBC_SIM_SLAVE == sim)
	{	
		GBC_OUTGOINGCALL_EVENT_RSP_HANDLE=(PsFuncPtr)MTPNP_PFAL_CC_DIAL_IND_handler;
		GBC_SPEECH_IND_EVENT_HANDLE=(PsFuncPtr)MTPNP_PFAL_CC_SPEECH_IND_handler;
		GBC_OUTGOINGCALL_CONNECTED_HANDLE=(PsFuncPtr)MTPNP_PFAL_CC_CALL_CONNECT_IND_handler;
	}
	else
#endif
	{
		GBC_OUTGOINGCALL_EVENT_RSP_HANDLE=(PsFuncPtr)PsCbackOutgoingCallIdSync;
		GBC_SPEECH_IND_EVENT_HANDLE=(PsFuncPtr)PsCBackSpeechIndication;
		GBC_OUTGOINGCALL_CONNECTED_HANDLE=(PsFuncPtr)OutgoingCallConnected;
	}
#endif
	GBC_TRACE("gbc_ivr_save_call_handle, sim: %d", sim);
}

static void gbc_ivr_set_call_handle(void)
{
	gbc_IVRHandleRst = TRUE;
#if (GBC_VER >= 0x1032)
	srv_gcall_set_ps_event_handler(gbc_ivr_USSDVSS_rsp, PRT_USSDVSS_RSP); 
	srv_gcall_set_ps_event_handler(gbc_ivr_outgoing_call_rsp, PRT_OUTGOINGCALL_EVENT_RSP);
	srv_gcall_set_ps_event_handler(gbc_ivr_CCSpeech_ind, PRT_SPEECH_IND_EVENT);
	srv_gcall_set_ps_event_handler((gbc_PSFunc)gbc_ivr_connected, PRT_OUTGOINGCALL_CONNECTED);
#else
#ifdef __MMI_DUAL_SIM_MASTER__
	if (GBC_SIM_SLAVE==gbc_get_active_sim())
	{	
		gbc_SetSlaveProtocolEventHandler(gbc_ivr_USSDVSS_rsp, PRT_USSDVSS_RSP);
		gbc_SetSlaveProtocolEventHandler(gbc_ivr_outgoing_call_rsp, PRT_OUTGOINGCALL_EVENT_RSP);
		gbc_SetSlaveProtocolEventHandler(gbc_ivr_CCSpeech_ind, PRT_SPEECH_IND_EVENT);
		gbc_SetSlaveProtocolEventHandler(gbc_ivr_connected, PRT_OUTGOINGCALL_CONNECTED);
	}
	else
#endif
	{	
		gbc_SetProtocolEventHandler(gbc_ivr_USSDVSS_rsp, PRT_USSDVSS_RSP);	
		gbc_SetProtocolEventHandler(gbc_ivr_outgoing_call_rsp, PRT_OUTGOINGCALL_EVENT_RSP);
		gbc_SetProtocolEventHandler(gbc_ivr_CCSpeech_ind, PRT_SPEECH_IND_EVENT);
		gbc_SetProtocolEventHandler(gbc_ivr_connected, PRT_OUTGOINGCALL_CONNECTED);
	}
#endif
	GBC_TRACE("gbc_ivr_set_call_handle");
}

BOOL gbc_ivr_make_call(U8 *ascii_number,  U8 sim)
{
	U16 length;
	MYQUEUE Message;
	mmi_ss_parsing_string_req_struct *strParse;
	
	GBC_TRACE("gbc_ivr_make_call, num: %s, SIM: %d", ascii_number, sim);
#if defined( __MMI_DUAL_SIM_MASTER__)
#if (GBC_VER < 0x1108)
	if (GBC_SIM_SLAVE == sim)
	{
		MTPNP_AD_Free_Channel(MTPNP_AD_CALL_CHANNEL);
		MTPNP_AD_Set_Channel(MTPNP_AD_CALL_CHANNEL, MTPNP_AD_CHANNEL_SLAVE);
	}
	else
	{
		MTPNP_AD_Free_Channel(MTPNP_AD_CALL_CHANNEL);
		MTPNP_AD_Set_Channel(MTPNP_AD_CALL_CHANNEL, MTPNP_AD_CHANNEL_MASTER);
	}
#endif
	if (GBC_SIM_SLAVE== sim)
	{
		Message.oslDestId = MOD_L4C_2;
	}
	else
#endif /* __MMI_DUAL_SIM_MASTER__ */
	{
		Message.oslDestId = MOD_L4C;
	}
	Message.oslSrcId = MOD_MMI;
	Message.oslMsgId = PRT_USSDVSS_REQ;
	Message.oslPeerBuffPtr = NULL;
	
	length = strlen((char *)ascii_number);
	strParse = (mmi_ss_parsing_string_req_struct *)OslConstructDataPtr(sizeof(mmi_ss_parsing_string_req_struct));
	strParse->call_type=CSMCC_VOICE_CALL;
	strParse->length = (U8)length;
	memset(strParse->input, 0x00, sizeof(strParse->input));
	memcpy(strParse->input, ascii_number, strParse->length);
	strParse->dcs = 0x0f;
	Message.oslDataPtr = (oslParaType *) strParse;
	gbc_ivr_save_call_handle(sim);
	gbc_ivr_set_call_handle();
	OslMsgSendExtQueue(&Message);
	
	return TRUE;
}

void gbc_ivr_rst_call_handle(void)
{
	GBC_TRACE("gbc_ivr_rst_call_handle,gbc_IVRHandleRst:%d", gbc_IVRHandleRst);
	if(gbc_IVRHandleRst)
	{
		gbc_IVRHandleRst = FALSE;
#if (GBC_VER >= 0x1032)
		srv_gcall_set_ps_event_handler((gbc_PSFunc)GBC_OUTGOINGCALL_EVENT_RSP_HANDLE, PRT_OUTGOINGCALL_EVENT_RSP);
		srv_gcall_set_ps_event_handler((gbc_PSFunc)GBC_SPEECH_IND_EVENT_HANDLE, PRT_SPEECH_IND_EVENT);
		srv_gcall_set_ps_event_handler((gbc_PSFunc)GBC_OUTGOINGCALL_CONNECTED_HANDLE, PRT_OUTGOINGCALL_CONNECTED);
#else
#ifdef __MMI_DUAL_SIM_MASTER__
		if (GBC_SIM_SLAVE==gbc_get_active_sim())
		{	
			gbc_SetSlaveProtocolEventHandler((gbc_PSHandle)GBC_OUTGOINGCALL_EVENT_RSP_HANDLE, PRT_OUTGOINGCALL_EVENT_RSP);
			gbc_SetSlaveProtocolEventHandler((gbc_PSHandle)GBC_SPEECH_IND_EVENT_HANDLE, PRT_SPEECH_IND_EVENT);
			gbc_SetSlaveProtocolEventHandler((gbc_PSHandle)GBC_OUTGOINGCALL_CONNECTED_HANDLE, PRT_OUTGOINGCALL_CONNECTED);
		}
		else
#endif
		{
			gbc_SetProtocolEventHandler((gbc_PSHandle)GBC_OUTGOINGCALL_EVENT_RSP_HANDLE, PRT_OUTGOINGCALL_EVENT_RSP);
			gbc_SetProtocolEventHandler((gbc_PSHandle)GBC_SPEECH_IND_EVENT_HANDLE, PRT_SPEECH_IND_EVENT);
			gbc_SetProtocolEventHandler((gbc_PSHandle)GBC_OUTGOINGCALL_CONNECTED_HANDLE, PRT_OUTGOINGCALL_CONNECTED);
		}
#endif
	}
}

BOOL gbc_ivr_end_call(BOOL isInner)
{
	MYQUEUE Message;
	mmi_cc_chld_req_struct *hangupReq;
	Message.oslSrcId = MOD_MMI;
	
	GBC_TRACE("gbc_ivr_end_call,isInner:%d,gbc_IVRStatus:%d", isInner, gbc_IVRStatus);
	StopTimer((U16)gbc_get_timerId(GBC_TIMER_ID_07));
	StopTimer((U16)gbc_get_timerId(GBC_TIMER_ID_08));
	StopTimer((U16)gbc_get_timerId(GBC_TIMER_ID_09));
	
	if (GBC_IVR_NONE==gbc_IVRStatus)
	{
		return FALSE;
	}
	else
	{
		gbc_IVRStatus=GBC_IVR_NONE;
	}
#ifdef __MMI_DUAL_SIM_MASTER__
	if (GBC_SIM_SLAVE==gbc_get_active_sim())
	{   
		Message.oslDestId = MOD_L4C_2;		
	}
	else
#endif
	{
		Message.oslDestId = MOD_L4C;
	}
	hangupReq = (mmi_cc_chld_req_struct*) OslConstructDataPtr(sizeof(mmi_cc_chld_req_struct));		
	if (gbc_IVRStatus != GBC_IVR_ACTIVE)
	{
		Message.oslMsgId = PRT_CALLENDSPECIFIC_EVENT;
		hangupReq->opcode = CSMCC_REL_SPECIFIC_CALL;
		hangupReq->call_id = (U8)gbc_IVRCallID;
	}
	else
	{
		Message.oslMsgId = PRT_ENDALLCALL_EVENT;
		hangupReq->opcode =CSMCC_REL_ALL;
	}
	Message.oslDataPtr = (oslParaType*) hangupReq;
	Message.oslPeerBuffPtr = NULL;
	OslMsgSendExtQueue(&Message);
	return TRUE;
}

BOOL gbc_is_backlight_on(void)
{
	MMI_BOOL backlight_on;
#if  (GBC_VER >= 0x1108)
	backlight_on = srv_backlight_is_on(0 /* SRV_BACKLIGHT_TYPE_MAINLCD */);
#else
	backlight_on = IsBacklightOn();
#endif
	GBC_TRACE("gbc_is_backlight_on: %d", backlight_on);
	
	return backlight_on;
}

char gbc_is_all_idle(void)
{
	char ret = 0;
	if(gbc_is_in_idle_screen() 
#ifdef __MTK_TARGET__   	
		&& !gbc_is_backlight_on()
#ifdef __MMI_AUDIO_PLAYER__
		&& !mmi_audply_is_playing()
#endif
#ifdef __MMI_FM_RADIO__
		&& !mmi_fmrdo_is_power_on()
#endif  	
#endif   	
		)
	   {
		ret = 1;
	   }
	   else
	   {
		ret = 0;
	   }
	   GBC_TRACE("gbc_is_all_idle, gbc_is_in_idle_screen: %d, ret: %d", gbc_is_in_idle_screen(), ret);
	   return ret;
}

#if defined(GBC_GPRS)
#if defined(GBC_GPRS_NET)
void gbc_gethostbyname_rsp(void *inMsg)
{
	kal_uint8 addr[MAX_SOCK_ADDR_LEN];
	app_soc_get_host_by_name_ind_struct *p = (app_soc_get_host_by_name_ind_struct *)inMsg;
	
	GBC_TRACE("gbc_gethostbyname_rsp, result: %d", p->result);
	if (p && p->result) /* success */
	{
		ClearProtocolEventHandler(MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND);
		memset(addr, 0x00, sizeof(addr));
		memcpy(addr, p->addr, p->addr_len);
		gbc_http_gethostbyname_ind(p->result, p->addr, p->addr_len);
	}
	else
	{
		gbc_http_gethostbyname_ind(0, 0, 0);
	}
}

kal_int8 gbc_gethostbyname_req(kal_int32 request_id, const kal_char *domain_name, kal_uint8 *addr, kal_uint8 *addr_len, kal_uint8 access_id, kal_uint32 nwk_account_id)
{
	kal_int8 result = 0;
	
	result = soc_gethostbyname(KAL_FALSE, MOD_MMI, request_id, domain_name, addr, addr_len, access_id, nwk_account_id);
	
	return result;
}
#endif

kal_int8 gbc_soc_create(kal_uint32 nwk_account_id)
{
	U8 val = 1;
	kal_int8 result = -1;
	kal_int8 soc = -1;
	
	soc = soc_create(PF_INET, SOCK_STREAM, 0, MOD_MMI, nwk_account_id);
	if(soc>=0)
	{
		result = soc_setsockopt(soc, SOC_NBIO, &val, sizeof(val));
		val = SOC_READ|SOC_WRITE|SOC_ACCEPT|SOC_CONNECT|SOC_CLOSE;
		result = soc_setsockopt(soc, SOC_ASYNC, &val, sizeof(val));
	} 	
	return soc;
}

kal_int8 gbc_soc_connect(kal_int8 soc, sockaddr_struct *addr)
{
	return soc_connect(soc, addr);
}

kal_int32 gbc_soc_send(kal_int8 soc, void *pvBuf, U32 nLen)
{
	return soc_send(soc, pvBuf, nLen, 0);
}

kal_int32 gbc_soc_recv(kal_int8 soc, void *pvBuf, U32 nLen)
{
	return soc_recv(soc, (kal_uint8 *)pvBuf, (kal_int32)nLen, 0);
}

kal_int8 gbc_soc_close(kal_int8 soc)
{
	return  soc_close(soc);
}

void gbc_close_network_account(int account_id)
{
#ifdef __MTK_TARGET__
    ilm_struct* ilm_send = NULL;
#endif
	GBC_TRACE("gbc_close_network_account,gbc_GPRSAppId:%d,account_id:%d", gbc_GPRSAppId, account_id);
	if(gbc_GPRSAppId)
	{
#if (GBC_VER>=0x1108)
		cbm_release_bearer(gbc_GPRSAppId);
#elif (GBC_VER>0x0932)
		cbm_release_bearer(MOD_MMI, gbc_GPRSAppId);
#endif
		cbm_deregister_app_id(gbc_GPRSAppId);
		gbc_GPRSAppId=0;
	}
	
#if(GBC_VER>=0x0816 && GBC_VER<0x0828)
	soc_close_nwk_account_by_id(MOD_MMI, account_id, 0);
#elif(GBC_VER<0x0816)
	soc_close_nwk_account_by_id(MOD_MMI, account_id);
#else
	{
		extern void soc_app_deactivate_req_hdlr(module_type mod_id, kal_uint32 nw_acct_id, kal_uint8 qos_profile);
		soc_app_deactivate_req_hdlr(MOD_MMI, account_id, 0);
		//soc_app_deactivate_req_hdlr(MOD_MMI, account_id, 0, KAL_TRUE);
	}
#endif
#ifdef __MTK_TARGET__
    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);
#endif 
}

void gbc_update_gprs_status_icon(void)
{
	GBC_TRACE("gbc_update_gprs_status_icon");
#if (GBC_VER >= 0x1108)
	wgui_status_icon_bar_reset_icon_display(STATUS_ICON_GPRS_SERVICE);
#if defined(__MMI_DUAL_SIM_MASTER__)&&!defined(__MMI_NW_INFO_DN_STATUS_SLIM__)
	wgui_status_icon_bar_reset_icon_display(STATUS_ICON_SLAVE_GPRS_SERVICE);
#endif
	wgui_status_icon_bar_update();
#else
	HideStatusIcon(STATUS_ICON_GPRS_SERVICE);
#if defined(__MMI_DUAL_SIM_MASTER__)&&!defined(__MMI_NW_INFO_DN_STATUS_SLIM__)
	HideStatusIcon(STATUS_ICON_SLAVE_GPRS_SERVICE);
#endif
	UpdateStatusIcons();
#endif
}

char gbc_gprs_icon_handle(U16 icon_ID)
{
	char result=1;
	if(!gbc_GPRSIcon) /* gbc_GPRSIcon==0, 处理 */
	{
		if((icon_ID == STATUS_ICON_GPRS_ATT_NO_PDP_INDICATOR)|| (icon_ID == STATUS_ICON_GPRS_SERVICE)
#if defined(__MMI_DUAL_SIM_MASTER__)&&!defined(__MMI_NW_INFO_DN_STATUS_SLIM__)
			||(icon_ID == STATUS_ICON_SLAVE_GPRS_ATT_NO_PDP_INDICATOR)
			||(icon_ID == STATUS_ICON_SLAVE_GPRS_SERVICE)
#endif
			)	              
			result = 0;
	}
	//GBC_TRACE("gbc_gprs_icon_handle, result: %d ", result);  
	return result;
}

void gbc_gprs_account_encode_handle(kal_int8 idx)
{
	kal_int8 result=-1;
	cbm_sim_id_enum simid=CBM_SIM_ID_TOTAL;

	GBC_TRACE("gbc_gprs_account_encode_handle,idx:%d,gbc_GPRSAppId:%d;", idx, gbc_GPRSAppId);
	if (idx>=0)
	{
#if (GBC_VER>=0x1108)
		cbm_app_info_struct info;
		if(!gbc_GPRSAppId)
		{
			info.app_str_id = STR_GLOBAL_GPRS;
			info.app_icon_id = IMG_NONE;
			/* application type which will be used in data account profile, such as MMS, etc.*/
			info.app_type = DTCNT_APPTYPE_DEF;
			result = cbm_register_app_id_with_app_info(&info, &gbc_GPRSAppId);
			//result = cbm_register_app_id(&gbc_GPRSAppId);
			if(result==CBM_OK)
			{
				cbm_hold_bearer(gbc_GPRSAppId);
			}
			else
			{
				ASSERT(0);
			}
		}
		gbc_GPRSAccountIDIndex= idx;
#else
		if(!gbc_GPRSAppId)
		{
			gbc_GPRSAppId = cbm_register_app_id(STR_GLOBAL_GPRS, IMG_GLOBAL_EMPTY);
			result=cbm_hold_bearer(MOD_MMI, gbc_GPRSAppId);
			if(result!=CBM_OK)
			{
				ASSERT(0);
			}
		}
		gbc_GPRSAccountIDIndex=10+idx;
#endif
		
#ifdef __MMI_DUAL_SIM_MASTER__	
		if(gbc_get_active_sim() == GBC_SIM_SLAVE)
		{
			simid=CBM_SIM_ID_SIM2;
		}
		else
#endif
		{
			simid=CBM_SIM_ID_SIM1;
		}
		gbc_GPRSAccountID = cbm_encode_data_account_id(gbc_GPRSAccountIDIndex, simid, gbc_GPRSAppId, 0);
		GBC_TRACE("gbc_gprs_account_encode_handle,simid:%d,AccountID:%d;", simid, gbc_GPRSAccountID);
		
		gbc_gprs_init_rsp();
		gbc_GPRSAccountIDIndex = -1;
	}
	else
	{
		gbc_GPRSAccountIDIndex = -1;
		GBC_TRACE("gbc_gprs_account_encode_handle, init GPRS account fail!\r\n");  
	}
}

#if (GBC_VER>=0x1204)
//MAUI.11B.W12.24.MP.V2 使用这个文件的接口plutommi\service\dtcntsrv\DtcntSrvApi.c
//__COSMOS_MMI_PACKAGE__ 版本 DataAccountApp.c 不会被编译,
//使用venusmmi\app\cosmos\dataaccount\Vapp_dtcnt.cpp中的接口
static U8 g_mmi_dtcnt_acct_num;
U8 gbc_get_gprs_dtcnt_num(void)
{
	 U8  srv_dtcnt_num = 0;
	 srv_dtcnt_result_enum result;
	 srv_dtcnt_store_prof_qry_struct acct_id_query;   

	 acct_id_query.qry_info.filters = SRV_DTCNT_STORE_QRY_TYPE_ACC_TYPE;
	 acct_id_query.qry_info.acc_type_info = SRV_DTCNT_PROF_TYPE_USER_CONF;
	 result = srv_dtcnt_store_qry_ids(&acct_id_query);
	 srv_dtcnt_num += acct_id_query.num_ids;
	 acct_id_query.qry_info.filters = SRV_DTCNT_STORE_QRY_TYPE_ACC_TYPE;
	 acct_id_query.qry_info.acc_type_info = SRV_DTCNT_PROF_TYPE_FACTORY_CONF;
	 result = srv_dtcnt_store_qry_ids(&acct_id_query);
	 srv_dtcnt_num += acct_id_query.num_ids;
	 acct_id_query.qry_info.filters = SRV_DTCNT_STORE_QRY_TYPE_ACC_TYPE;
	 acct_id_query.qry_info.acc_type_info = SRV_DTCNT_PROF_TYPE_OTA_CONF;
	 result = srv_dtcnt_store_qry_ids(&acct_id_query);
	 srv_dtcnt_num += acct_id_query.num_ids;
	 acct_id_query.qry_info.filters = SRV_DTCNT_STORE_QRY_TYPE_ACC_TYPE;
	 acct_id_query.qry_info.acc_type_info = SRV_DTCNT_PROF_TYPE_SIM_PROF;
	 result = srv_dtcnt_store_qry_ids(&acct_id_query);
	 srv_dtcnt_num += acct_id_query.num_ids;
	 
	 return (srv_dtcnt_num);
}

void gbc_set_gprs_data_account(signed char idx)
{
	U32 acct_id;
	srv_dtcnt_result_enum ret;
	srv_dtcnt_prof_gprs_struct prof_gprs;
	srv_dtcnt_store_prof_data_struct store_prof_data;
	const WCHAR account_name[] =  L"GPRS CMWAP";
	srv_dtcnt_sim_type_enum sim_info = gbc_get_active_sim();
	cbm_account_info_struct* acct_info = NULL;
	
	memset(&prof_gprs, 0, sizeof(prof_gprs));
	prof_gprs.APN = gbc_APN;
	if(GBC_SIM_MASTER== sim_info)
	{
		prof_gprs.prof_common_header.sim_info =SRV_DTCNT_SIM_TYPE_1;
	}
	else
	{
		prof_gprs.prof_common_header.sim_info =SRV_DTCNT_SIM_TYPE_2;
	}
	prof_gprs.prof_common_header.AccountName = (const U8*)account_name;
	prof_gprs.prof_common_header.acct_type = SRV_DTCNT_PROF_TYPE_USER_CONF;
	prof_gprs.prof_common_header.px_service = SRV_DTCNT_PROF_PX_SRV_CO_WSP;
	if(!strcmp(prof_gprs.APN, "cmwap") || !strcmp(prof_gprs.APN, "uniwap"))
	{
		prof_gprs.prof_common_header.use_proxy = KAL_TRUE;
		prof_gprs.prof_common_header.px_addr[0] = 10;
		prof_gprs.prof_common_header.px_addr[1] = 0;
		prof_gprs.prof_common_header.px_addr[2] = 0;
		prof_gprs.prof_common_header.px_addr[3] = 172;
		prof_gprs.prof_common_header.px_port = 80;
	}
	else
	{
		prof_gprs.prof_common_header.use_proxy = 0;
		prof_gprs.prof_common_header.px_addr[0] = 0;
		prof_gprs.prof_common_header.px_addr[1] = 0;
		prof_gprs.prof_common_header.px_addr[2] = 0;
		prof_gprs.prof_common_header.px_addr[3] = 0;
		prof_gprs.prof_common_header.px_port = 0;
	}
	store_prof_data.prof_data = &prof_gprs;
	store_prof_data.prof_fields = SRV_DTCNT_PROF_FIELD_ALL;
	store_prof_data.prof_type = SRV_DTCNT_BEARER_GPRS;

	acct_info = OslMalloc(sizeof(cbm_account_info_struct));
	srv_dtcnt_get_auto_acc_id(idx, &acct_id);
	cbm_decode_data_account_id_ext(acct_id, acct_info);
	ret = srv_dtcnt_store_update_prof(acct_info->account[idx].account_id, &store_prof_data);
	OslMfree(acct_info);

	GBC_TRACE("gbc_set_gprs_data_account_ext,update result:%d,idx:%d,acc_prof_id:%d", ret, idx, acct_id);
	if(ret == SRV_DTCNT_RESULT_SUCCESS)
	{
		gbc_GPRSAccountIDIndex = acct_id;
	}
	else
	{
		gbc_GPRSAccountIDIndex = -1;
	}
}

void gbc_get_gprs_data_account(signed char idx)
{
	int i = 0;
	BOOL result = FALSE;
	S8 asciiAPN[APN_NAME_LEN];
	S8 UCS2APN[APN_NAME_LEN*2];
	srv_dtcnt_sim_type_enum sim_info;
	srv_dtcnt_prof_str_info_qry_struct acct_data;

	g_mmi_dtcnt_acct_num=gbc_get_gprs_dtcnt_num();
	GBC_TRACE("gbc_get_gprs_data_account,idx:%d,g_mmi_dtcnt_acct_num:%d", idx, g_mmi_dtcnt_acct_num);  

	for(i=0; i<g_mmi_dtcnt_acct_num; i++)
	{
		memset(asciiAPN, 0, APN_NAME_LEN);
		memset(UCS2APN, 0, APN_NAME_LEN*2);
		acct_data.dest = (S8*)UCS2APN;
		acct_data.dest_len = MAX_DTCNT_LIST_ADDR_LEN*ENCODING_LENGTH;
		result = srv_dtcnt_get_apn(i, &acct_data, SRV_DTCNT_ACCOUNT_PRIMARY);
		mmi_wcs_to_asc((char *)asciiAPN, (WCHAR *)UCS2APN);
		gbc_to_lower(asciiAPN);

		srv_dtcnt_get_sim_info(i, &sim_info);
		if(SRV_DTCNT_BEARER_GPRS==srv_dtcnt_get_bearer_type(i, SRV_DTCNT_ACCOUNT_PRIMARY)
			&& !strcmp((const char *)gbc_APN, (const char *)asciiAPN) && sim_info==gbc_get_active_sim())
		{
			result = TRUE;
			gbc_GPRSAccountIDIndex = i;
			break;
		}
	}
	GBC_TRACE("gbc_get_gprs_data_account,result:%d,gbc_GPRSAccountIDIndex:%d", result, gbc_GPRSAccountIDIndex);

	if(FALSE==result)
	{
		/* update or add one new account */
		 gbc_set_gprs_data_account(GBC_WAP_CONTEXT_INDEX);
	}
	gbc_gprs_account_encode_handle(gbc_GPRSAccountIDIndex);
}	
#elif(GBC_VER>=0x1108)
U8 gbc_dtcnt_find_empty_profile(void)
{
    U8 i=0;
	
    for(i=0; i<MAX_DATA_ACCOUNT_GPRS_LIMIT; i++)
    {
        if(!g_srv_dtcnt_store_ctx.acc_list[i].in_use)
        {       
            return i;
        }
    }
    return MAX_DATA_ACCOUNT_GPRS_LIMIT;
}

//void 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)
void gbc_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)
{
	if (g_mmi_dtcnt_list_item[g_mmi_dtcnt_acct_num].bearer_type != 0)
	{
		return;
	}
	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++;
}

int gbc_set_gprs_data_account_ext(signed char idx)
{
	U32 acct_id;
	srv_dtcnt_result_enum ret;
	srv_dtcnt_prof_gprs_struct prof_gprs;
	srv_dtcnt_store_prof_data_struct store_prof_data;
	const WCHAR account_name[] =  L"GPRS CMWAP";
	srv_dtcnt_sim_type_enum sim_info = gbc_get_active_sim();
	cbm_account_info_struct* acct_info = NULL;
	
	memset(&prof_gprs, 0, sizeof(prof_gprs));
	prof_gprs.APN = gbc_APN;
	if(GBC_SIM_MASTER == sim_info)
	{
		prof_gprs.prof_common_header.sim_info =SRV_DTCNT_SIM_TYPE_1;
	}
	else
	{
		prof_gprs.prof_common_header.sim_info =SRV_DTCNT_SIM_TYPE_2;
	}
	prof_gprs.prof_common_header.AccountName = (const U8*)account_name;
	prof_gprs.prof_common_header.acct_type = SRV_DTCNT_PROF_TYPE_USER_CONF;
	prof_gprs.prof_common_header.px_service = SRV_DTCNT_PROF_PX_SRV_CO_WSP;
	if(!strcmp(prof_gprs.APN, "cmwap") || !strcmp(prof_gprs.APN, "uniwap"))
	{
		prof_gprs.prof_common_header.use_proxy = KAL_TRUE;
		prof_gprs.prof_common_header.px_addr[0] = 10;
		prof_gprs.prof_common_header.px_addr[1] = 0;
		prof_gprs.prof_common_header.px_addr[2] = 0;
		prof_gprs.prof_common_header.px_addr[3] = 172;
		prof_gprs.prof_common_header.px_port = 80;
	}
	else
	{
		prof_gprs.prof_common_header.use_proxy = 0;
		prof_gprs.prof_common_header.px_addr[0] = 0;
		prof_gprs.prof_common_header.px_addr[1] = 0;
		prof_gprs.prof_common_header.px_addr[2] = 0;
		prof_gprs.prof_common_header.px_addr[3] = 0;
		prof_gprs.prof_common_header.px_port = 0;
	}
	
	store_prof_data.prof_data = &prof_gprs;
	store_prof_data.prof_fields = SRV_DTCNT_PROF_FIELD_ALL;
	store_prof_data.prof_type = SRV_DTCNT_BEARER_GPRS;

	if(idx>=1)
	{
		acct_info = OslMalloc(sizeof(cbm_account_info_struct));
		srv_dtcnt_get_auto_acc_id(idx, &acct_id);
		cbm_decode_data_account_id_ext(acct_id, acct_info);
		ret = srv_dtcnt_store_update_prof(acct_info->account[idx].account_id, &store_prof_data);
		OslMfree(acct_info);
		GBC_TRACE("gbc_set_gprs_data_account_ext,update result:%d,idx:%d,acc_prof_id:%d", ret, idx, acct_id);
		if(ret == SRV_DTCNT_RESULT_SUCCESS)
		{
			return acct_id;
		}
		else
		{
			return -1;
		}
	}
	else
	{
		ret = srv_dtcnt_store_add_prof(&store_prof_data, &acct_id);
		GBC_TRACE("gbc_set_gprs_data_account_ext, add result:%d, acc_prof_id:%d", ret, acct_id);
		if(ret == SRV_DTCNT_RESULT_SUCCESS)
		{
			gbc_dtcnt_add_disp_list(acct_id, DATA_ACCOUNT_BEARER_GPRS, prof_gprs.prof_common_header.acct_type, 1, prof_gprs.prof_common_header.sim_info, prof_gprs.prof_common_header.read_only);
			return acct_id;
		}
		else
		{
			return -1;
		}
	}
}

void gbc_get_gprs_data_account(signed char idx)
{
	int i = 0;
	int result = 0;
	S8 asciiAPN[MAX_DTCNT_LIST_ADDR_LEN];
	S8 UCS2APN[MAX_DTCNT_LIST_ADDR_LEN*2];
	U8 sim_info=gbc_get_active_sim();
	
	GBC_TRACE("gbc_get_gprs_data_account,sim_info:%d,idx:%d,g_mmi_dtcnt_acct_num:%d", sim_info, idx, g_mmi_dtcnt_acct_num);
	if (g_mmi_dtcnt_acct_num<=0 || sim_info<0)
	{
		result = 0;
		gbc_GPRSAccountIDIndex = -1;
	}
	else
	{
		memset(asciiAPN,0x00,sizeof(asciiAPN));
		memset(UCS2APN,0x00,sizeof(UCS2APN));
		for (i=0; i<g_mmi_dtcnt_acct_num; i++)
		{
			mmi_dtcnt_get_apn(g_mmi_dtcnt_list_item[i].profile_id, (PS8)UCS2APN, MAX_DTCNT_LIST_ADDR_LEN);
			mmi_wcs_to_asc((CHAR *)asciiAPN, (WCHAR *)UCS2APN);
			gbc_to_lower(asciiAPN);
			GBC_TRACE("gbc_get_gprs_data_account,asciiAPN:%s,gbc_APN:%s,sim_info:%d,active sim:%d", asciiAPN, gbc_APN,  g_mmi_dtcnt_list_item[i].sim_info, sim_info);
			if (!strcmp((const char *)gbc_APN, (const char *)asciiAPN) && g_mmi_dtcnt_list_item[i].sim_info==sim_info)
			{
				if(SRV_DTCNT_BEARER_GPRS == srv_dtcnt_get_bearer_type(g_mmi_dtcnt_list_item[i].profile_id, SRV_DTCNT_ACCOUNT_PRIMARY))
				{
					gbc_GPRSAccountIDIndex = g_mmi_dtcnt_list_item[i].profile_id;
					result = 1;
					break;
				}
			}
			else
			{
				gbc_GPRSAccountIDIndex = -1;
				result = 0;
			}
		}
	}  
	
	if (!result)
	{
		U16 ApnIdx =g_mmi_dtcnt_acct_num;
		gbc_GPRSAccountIDIndex = CUSTOM_DEFINED_MAX_CSD_PROFILE_NUM + ApnIdx;
		if(g_mmi_dtcnt_acct_num<1)
		{
			result = gbc_set_gprs_data_account_ext(g_mmi_dtcnt_acct_num);
		}
		else
		{
		result = gbc_set_gprs_data_account_ext(g_mmi_dtcnt_acct_num-1);
		}
		if(result<0)
		{
			gbc_GPRSAccountIDIndex = -1;
		}
		else
		{
			gbc_GPRSAccountIDIndex = result;
		}
	}
	GBC_TRACE("gbc_get_gprs_data_account,result:%d,sim_info:%d,index:%d,profile_id:%d", result, g_mmi_dtcnt_list_item[i].sim_info, i, g_mmi_dtcnt_list_item[i].profile_id);
	gbc_gprs_account_encode_handle(gbc_GPRSAccountIDIndex);
}
#else
void gbc_get_gprs_data_account(signed char idx);
void gbc_set_gprs_data_account(signed char idx, GPRSDataAccount *pDataAccount);
void gbc_get_gprs_account_rsp(void *info) 
{
	char apn[APN_NAME_LEN];
	GPRSDataAccount DataAccount;
	mmi_ps_get_gprs_data_account_rsp_struct *localPtr = (mmi_ps_get_gprs_data_account_rsp_struct *)info;
	
	GBC_TRACE("gbc_get_gprs_account_rsp, result: %d, apn: %s", localPtr->result,  localPtr->gprs_account.apn);
	strcpy(apn, (char*) localPtr->gprs_account.apn);
	gbc_to_lower(apn);
	if(!strcmp(gbc_APN, apn) && !localPtr->result) /* result ==0, success!  */
	{
		gbc_gprs_account_encode_handle(gbc_GPRSAccountIDIndex);
	}
	else
	{
		gbc_GPRSAccountIDIndex++;
		GBC_TRACE("gbc_get_gprs_account_rsp, APN Not found in system APN list!");
		if(gbc_GPRSAccountIDIndex >= MAX_GPRS_PROFILE_NUM)
		{ 
			gbc_GPRSAccountIDIndex = GBC_NET_CONTEXT_INDEX-1;
			memset(&DataAccount, 0, sizeof(GPRSDataAccount));
			strcpy(DataAccount.apn, gbc_APN);
			mmi_asc_to_ucs2((char *)DataAccount.name, (char *)gbc_APN);
			gbc_set_gprs_data_account(gbc_GPRSAccountIDIndex, &DataAccount);
		}
		else
		{
			gbc_get_gprs_data_account(gbc_GPRSAccountIDIndex);
		}
	}
}

void gbc_set_gprs_account_rsp(void *info) 
{
	GBC_TRACE("gbc_set_gprs_account_rsp\r\n");
}

void gbc_set_gprs_data_account(signed char idx, GPRSDataAccount *pDataAccount)
{
	U8 ref_count;
	U16 msg_len;
	MYQUEUE SendMessage;
	mmi_ps_set_gprs_data_account_req_struct *myMsgPtr;
	
	GBC_TRACE("gbc_set_gprs_data_account, idx: %d, pDataAccount: %s", idx, pDataAccount->apn);
	if (idx >= MAX_DATA_ACCOUNT_GPRS_LIMIT || pDataAccount == NULL )
	{
		gbc_GPRSAccountIDIndex = -1;
		return;
	}
	myMsgPtr = (mmi_ps_set_gprs_data_account_req_struct*) OslConstructDataPtr(sizeof(mmi_ps_set_gprs_data_account_req_struct));
	ref_count = myMsgPtr->ref_count;
	msg_len   = myMsgPtr->msg_len;
	memset(myMsgPtr, '\0', sizeof(mmi_ps_set_gprs_data_account_req_struct));
	myMsgPtr->ref_count = ref_count;
	myMsgPtr->msg_len = msg_len;
	myMsgPtr->gprs_account.context_id = idx + 1;
	myMsgPtr->gprs_account.authentication_type = pDataAccount->auth_type;
	myMsgPtr->gprs_account.name_length = mmi_ucs2strlen((PS8)pDataAccount->name)*2;
	myMsgPtr->gprs_account.name_dcs = DATA_ACCOUNT_UCS;
	myMsgPtr->gprs_account.read_only=TRUE;
	if(myMsgPtr->gprs_account.name_length>0)
	{
		int index = 0;        
		while(index<myMsgPtr->gprs_account.name_length)
		{
			myMsgPtr->gprs_account.name[index] = pDataAccount->name[index+1];
			myMsgPtr->gprs_account.name[index+1] = pDataAccount->name[index];
			index += 2;
		}
		myMsgPtr->gprs_account.name[index]=0x00;
		myMsgPtr->gprs_account.name[index+1]=0x00;
	}
	strcpy((char *) myMsgPtr->gprs_account.apn, (const char *) pDataAccount->apn);
	myMsgPtr->gprs_account.apn_length = strlen((const char *) pDataAccount->apn);
	strcpy((char *) myMsgPtr->gprs_account.user_name, pDataAccount->user_name);
	strcpy((char *) myMsgPtr->gprs_account.password, pDataAccount->password);
	memcpy((void*)myMsgPtr->gprs_account.dns, (void*)pDataAccount->dns, 4);
#if (GBC_VER>0x0912)
	myMsgPtr->gprs_account.read_only = 0;
	/* revised for GPRS profile default value */
	myMsgPtr->gprs_account.dcomp_algo = 0x02;
	myMsgPtr->gprs_account.hcomp_algo = 0x02;
	myMsgPtr->gprs_account.pdp_type = 0x21;
	myMsgPtr->gprs_account.pdp_addr_len = 0x01;    
	myMsgPtr->profile_type = DATA_ACCT_GPRS_PROF;
#endif
	SendMessage.oslSrcId = MOD_MMI;
	SendMessage.oslDestId = MOD_L4C;
	SendMessage.oslMsgId = PRT_MMI_PS_SET_GPRS_DATA_ACCOUNT_REQ;
	SendMessage.oslDataPtr = (oslParaType *) myMsgPtr;
	SendMessage.oslPeerBuffPtr = NULL;
	gbc_SetProtocolEventHandler((gbc_PSHandle)gbc_set_gprs_account_rsp, MSG_ID_MMI_PS_SET_GPRS_DATA_ACCOUNT_RSP);
	OslMsgSendExtQueue(&SendMessage);
}

void gbc_get_gprs_data_account(signed char idx)
{
	MYQUEUE SendMessage;
	mmi_ps_get_gprs_data_account_req_struct *myMsgPtr;
	
	GBC_TRACE("gbc_get_gprs_data_account,idx:%d", idx);
	if (idx >= MAX_DATA_ACCOUNT_GPRS_LIMIT)
	{
		return;
	}
	myMsgPtr = (mmi_ps_get_gprs_data_account_req_struct *)OslConstructDataPtr(sizeof(mmi_ps_get_gprs_data_account_req_struct));
	myMsgPtr->profile_id = idx + 1;
	
#if (GBC_VER >= 0x0912)
	myMsgPtr->profile_type = 1; //DATA_ACCT_GPRS_PROF;
#endif
	SendMessage.oslSrcId = MOD_MMI;
	SendMessage.oslDestId = MOD_L4C;
	SendMessage.oslMsgId = PRT_MMI_PS_GET_GPRS_DATA_ACCOUNT_REQ;
	SendMessage.oslDataPtr = (oslParaType*) myMsgPtr;
	SendMessage.oslPeerBuffPtr = NULL;
	gbc_SetProtocolEventHandler((gbc_PSHandle)gbc_get_gprs_account_rsp, MSG_ID_MMI_PS_GET_GPRS_DATA_ACCOUNT_RSP);
	OslMsgSendExtQueue(&SendMessage);
}
#endif
#else
char gbc_gprs_icon_handle(U16 icon_ID){return 1;}
#endif /* GBC_GPRS */

HFILE gbc_OpenFile(char *pszFile, U8 nMode)
{
	int attrs;
	U32 nFlag=0;
	FS_HANDLE hFile = NULL;
	char szName[GBC_FILENAME_LEN_MAX] = {0};
	WCHAR szNew[GBC_FILENAME_LEN_MAX] = {0};
	
	strcpy(szName, pszFile);
	gbc_MultiByteToWideChar(szName, szNew, sizeof(szNew), GBC_ASCII);
	
	if(nMode == FO_READ_ONLY)
	{
		nFlag = FS_READ_ONLY;
		nFlag |= FS_OPEN_SHARED;
	}
	else if(nMode == FO_READ_WRITE)
	{
		nFlag = FS_READ_WRITE;
	}
	else if(nMode == FO_CREATE)
	{
		nFlag = FS_CREATE;
	}
	
	attrs = FS_GetAttributes(szNew);
	if(attrs < FS_NO_ERROR) 
	{
		nFlag |= FS_CREATE;
	}	
	hFile = FS_Open(szNew, nFlag);
	return (HFILE)hFile;
}

BOOL gbc_CloseFile(HFILE hFile)
{
	if(hFile != NULL)
	{
		FS_Close((FS_HANDLE)hFile);
		return TRUE;
	}
	return FALSE;
}

U32 gbc_ReadFile(void *pvBuf, U32 nLen, U32 nCount, HFILE fhFile)
{
	U32 nReadNum = 0;
	if(pvBuf != NULL)
	{
		nLen *= nCount;
		FS_Read((FS_HANDLE)fhFile, pvBuf, nLen, &nReadNum);
	}
	return nReadNum;
}

BOOL gbc_WriteFile(void *pvBuf, U32 nLen, U32 nCount, HFILE fhFile)
{
	BOOL result = FALSE;
	if(pvBuf != NULL)
	{
		U32 nLenw = 0;
		nLen *= nCount;
		return (FS_Write((FS_HANDLE)fhFile, pvBuf, nLen, &nLenw) == FS_NO_ERROR);
	}
	
	return result;
}

U32 gbc_GetFileSize(HFILE hFile)
{
	U32 nSize = 0;
	if( FS_GetFileSize((FS_HANDLE)hFile, &nSize) == FS_NO_ERROR)
	{
		return nSize;
	}
	else
	{
		return 0;
	}
}

BOOL gbc_DeleteFile(char *pszName)
{
	WCHAR wszName[GBC_FILENAME_LEN_MAX] = {0};
	gbc_MultiByteToWideChar(pszName, wszName, sizeof(wszName), GBC_ASCII);
	return (FS_Delete(wszName) == FS_NO_ERROR);
}

#if 0
BOOL gbc_CreateFolder(char *pszPath)
{
	int result = 0;
	WCHAR wcDir[GBC_FILENAME_LEN_MAX] = {0};
	
	gbc_MultiByteToWideChar(pszPath, wcDir, sizeof(wcDir), GBC_ASCII);
	result = FS_CreateDir((PU16)wcDir);
	
	return result == 0;
}

BOOL gbc_DeleteFolder(char *pszPath)
{
	int result = 0;
	
	if(strlen(pszPath) > 0)
	{
		WCHAR wcDir[GBC_FILENAME_LEN_MAX] = {0};
		gbc_MultiByteToWideChar(pszPath, wcDir, sizeof(wcDir), GBC_ASCII);
		result = FS_XDelete((PU16)wcDir, FS_FILE_TYPE | FS_DIR_TYPE, NULL, 0);
	}
	return result >= 0;	
}

BOOL gbc_SeekFile(HFILE fhFile, int nOffset, FILE_SEEK_TYPE nType)
{
	int nMod[] = {FS_FILE_BEGIN, FS_FILE_CURRENT, FS_FILE_END};
	return (FS_NO_ERROR == FS_Seek((FS_HANDLE)fhFile, nOffset, nMod[nType]));
}

U32 gbc_FileSetAttributes(const char *file_name, TFileAttriEnum attributes)
{
	int result;
	U8 attri =0;
	char szName[GBC_FILENAME_LEN_MAX] = {0};
	WCHAR szNew[GBC_FILENAME_LEN_MAX] = {0};
	
	strcpy(szName, file_name);
	if(attributes & TFILE_ATTR_READ_ONLY)
	{
		attri |= FS_ATTR_READ_ONLY;
	}
	if(attributes & TFILE_ATTR_HIDDEN)
	{
		attri |= FS_ATTR_HIDDEN;
	}
	if(attributes & TFILE_ATTR_SYSTEM)
	{
		attri |= FS_ATTR_SYSTEM;
	}
	if(attributes & TFILE_ATTR_DIR)
	{
		attri |= FS_ATTR_DIR;
	}
	
	gbc_MultiByteToWideChar(szName, szNew, sizeof(szNew), GBC_ASCII);
	result = FS_SetAttributes(szNew, attri);
	return result;
}

U32 gbc_GetDiskFreeSpace(char *pszPath)
{
	U32 nRtn = 0;
	WCHAR wszDir[64] = {0};
	
	FS_DiskInfo disc_info;
	int result;
	
	gbc_MultiByteToWideChar(pszPath, wszDir, 64, GBC_ASCII);
	FS_SetCurrentDir(wszDir);
	
	result = FS_GetDiskInfo(wszDir, &disc_info, FS_DI_BASIC_INFO | FS_DI_FREE_SPACE);
	if(result > 0 && (result&(FS_DI_BASIC_INFO | FS_DI_FREE_SPACE)))
	{
		nRtn = disc_info.FreeClusters * disc_info.SectorsPerCluster * disc_info.BytesPerSector;
	}
	return nRtn;
}
#endif

void *gbc_Malloc(int nLen)
{
#if defined(__COSMOS_MMI_PACKAGE__)
    void *p = applib_asm_alloc_anonymous(nLen);
#else
    void *p = med_alloc_ext_mem(nLen);
#endif
    return p;	
}

void gbc_Free(void *pvBuf)
{
#if defined(__COSMOS_MMI_PACKAGE__)
	applib_asm_free_anonymous(pvBuf);
#else
	med_free_ext_mem(&pvBuf);
#endif
}

void gbc_get_date_time(GBC_TIME *dateTime)
{
	applib_time_struct sysTime;
	
	applib_dt_get_rtc_time(&sysTime);
	dateTime->nHour = sysTime.nHour;
	dateTime->nMin = sysTime.nMin;
	dateTime->nSec = sysTime.nSec;
	dateTime->nDay = sysTime.nDay;
	dateTime->nMonth = sysTime.nMonth;
	dateTime->nYear = sysTime.nYear;
	//GBC_TRACE("gbc_get_date_time, %d/%d/%d, %d:%d:%d", dateTime->nYear, dateTime->nMonth, dateTime->nDay, dateTime->nHour, dateTime->nMin, dateTime->nSec);
}

int gbc_MultiByteToWideChar(char *pszSrc, unsigned short *pnDst, int dest_size, int nCode)
{
	U32 nEnd = 0;
	U32 result = 0;
	
	if(nCode==GBC_ASCII)
	{
		nCode=UTF8_TO_UCS2;
	}
	else if(nCode==GBC_UTF8)
	{
		nCode=UTF8_TO_UCS2;
	}
	else if(nCode==GBC_UCS2)
	{
		nCode=UCS2_TO_UTF8;
	}
	else
	{
		nCode=GB2312_TO_UCS2;
	}
	result = EncodingDecoding(nCode, (char *)pnDst, pszSrc, dest_size, &nEnd);
	return result;
}

void gbc_to_lower(char *str)
{
    char *ptr;
    ptr = str;	
    while (*ptr != 0)
    {
        if ((*ptr >= 'A') && (*ptr <= 'Z'))
        {
            *ptr += 'a' - 'A';
        }
        ptr++;
    }
}

#if 0
int gbc_is_digit(const char *str)
{
	int  len = strlen(str);
	while(len > 0) 
	{
		if (*str < '0' || *str > '9') 
		{
			return 0 ;
		}
		str++;
		len--;
	}
	return 1; 
}

char *gbc_replace(char *str, char srch, char tgch) 
{ 
	char   *p   =   str; 
	while(*p   !=   '\0 ') 
	{ 
		if(*p   ==   srch) 
			*p   =   tgch; 
		p   ++; 
	} 
	return   str;       
}

void gbc_ShowMsgBox(char *pszMsg, int nType, int nSecnds)
{
	int nLen = strlen(pszMsg);
	WCHAR pwszMsg[256] = {0};
	nLen = nLen > 128 ? 128 : nLen;
	nType = IMG_GLOBAL_WARNING;
	memset(pwszMsg, 0, nLen * 2 + 2);
	gbc_MultiByteToWideChar(pszMsg, pwszMsg, nLen * 2 + 2, GBC_ASCII);
	DisplayPopup((U8 *)pwszMsg, NULL, 10, nSecnds * 1000, WARNING_TONE);//nType
}
#endif

#define GBC_APP_INTERFACE
#if 0
//invoke in SmsPsHandler.c void mmi_msg_handle_deliver_report_ind(void *inMsg, module_type mod, U16 result)
{
	extern kal_bool gbc_sms_report_handle();
	if(gbc_sms_report_handle()) return;
}
#endif
BOOL gbc_sms_report_handle(void)
{
	if(gbc_SMSReport)
	{
		gbc_SMSReport=0;
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

BOOL gbc_call_log_handle(void)
{
	if( gbc_IVRStatus != GBC_IVR_NONE)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

void gbc_call_end_handle(void)
{
	extern void gbc_end_call(void);
	gbc_end_call();
}

void gbc_TurnOnBacklight(void)
{
	extern void gbc_turn_on_backlight(void);
	gbc_turn_on_backlight();
}

#if 0
//invoke in MMITask.c InitializeAll() before MMI_APP_INIT(InitMessageProtocolEventHandlers());
{
	extern void gbc_InitializeAll(void);
	MMI_APP_INIT(gbc_InitializeAll());
}
#endif
void gbc_InitAllApplications(void)
{
	extern void gbc_Init(void);
	GBC_TRACE("gbc_InitAllApplications");
	gbc_Init();
}

BOOL gbc_mmi_msg_handle(ilm_struct Message)
{
	BOOL result=FALSE;

	result = gbc_protocol_event_handler((U16)Message.oslMsgId, (void *)Message.oslDataPtr, (int)Message.oslSrcId, (void *)&Message);
	if(result==FALSE)
	{
		//
	}
	return result;
}

kal_bool gbc_ProtocolEventHandler(U16 eventID, void *MsgStruct, int mod_src, void *Message)
{
	BOOL result=FALSE;

	result = gbc_protocol_event_handler(eventID, MsgStruct, mod_src, Message);
	if(result==FALSE)
	{
		//
	}
	return result;
}

#if defined(__MMI_DUAL_SIM_MASTER__)&&(GBC_VER<0x1108)
smsal_dcs_enum gbc_MTPNP_PFAL_dcs_convert(E_MTPNP_CODING_SCHEME MTPNP_DCS)
{
	smsal_dcs_enum dcs=MTPNP_CODING_SCHEME_DEFAULT;
	
	switch(MTPNP_DCS)
	{
	case MTPNP_CODING_SCHEME_DEFAULT:
		break;
	case MTPNP_CODING_SCHEME_ASCII:
		dcs = SMSAL_8BIT_DCS;
		break;
	case MTPNP_CODING_SCHEME_UCS2:
		dcs = SMSAL_UCS2_DCS;
		break;
	case MTPNP_CODING_SCHEME_GB2312:
		break;
	case MTPNP_CODING_SCHEME_BIG5:
		break;
	case MTPNP_CODING_SCHEME_STREAM:
	case MTPNP_CODING_SCHEME_UNKNOWN:
	default:
		dcs = SMSAL_DEFAULT_DCS;
		break;
	}
	return dcs;
}
#endif

char gbc_LogBuffer[GBC_LOG_BUFF_SIZE];
#if defined(GBC_DEBUG)
void gbc_Log2File(char *data, kal_uint16 length)
{
	kal_int32 drv;
	kal_uint32 fs_len;
	FS_HANDLE handle;
	kal_uint8 usc2Path[64];
	FS_DiskInfo disk_info;
	
	if(FS_NO_ERROR == FS_GetDevStatus(SRV_FMGR_CARD_DRV, FS_MOUNT_STATE_ENUM))
	{
		drv = SRV_FMGR_CARD_DRV;
	}
	else if(FS_NO_ERROR == FS_GetDevStatus(SRV_FMGR_PUBLIC_DRV, FS_MOUNT_STATE_ENUM))
	{
		drv = SRV_FMGR_PUBLIC_DRV;
	}
	else
	{
		drv = SRV_FMGR_SYSTEM_DRV;
	}
#if defined(WIN32)
	drv = SRV_FMGR_PUBLIC_DRV;
#endif
	memset(usc2Path, 0x00, sizeof(usc2Path));
	memset((void*)&disk_info, 0, sizeof(disk_info));
	
	kal_wsprintf((unsigned short *)usc2Path, "%c:\\", drv);
	handle = FS_GetDiskInfo((kal_uint16*)usc2Path, &disk_info, FS_DI_BASIC_INFO | FS_DI_FREE_SPACE);
	
	fs_len = disk_info.FreeClusters * disk_info.SectorsPerCluster * disk_info.BytesPerSector;
	if((fs_len<1024)||handle<FS_NO_ERROR)
	{
		return;
	}
	
	mmi_ucs2cat((S8 *)usc2Path, (const char *)L"tcd.txt");
	handle=FS_GetAttributes((WCHAR *)usc2Path);
	if(handle>=FS_NO_ERROR)
	{
		handle = FS_Open((WCHAR *)usc2Path, FS_READ_WRITE);
	}
	else
	{
		handle = FS_Open((WCHAR *)usc2Path, FS_READ_WRITE |FS_CREATE_ALWAYS);
	}
	
	if (handle>=FS_NO_ERROR)
	{
		FS_Seek(handle,0,FS_FILE_END);
		FS_Write(handle, data, length, &fs_len);
		FS_Commit(handle);
		FS_Close(handle);
	}
}

void gbc_Log2Path(char *path, char *data, kal_uint16 length)
{
	kal_int32 drv;
	kal_uint32 fs_len;
	FS_HANDLE handle;
	kal_uint8 usc2Path[64];
	FS_DiskInfo disk_info;
	
	if(FS_NO_ERROR == FS_GetDevStatus(SRV_FMGR_CARD_DRV, FS_MOUNT_STATE_ENUM))
	{
		drv = SRV_FMGR_CARD_DRV;
	}
	else if(FS_NO_ERROR == FS_GetDevStatus(SRV_FMGR_PUBLIC_DRV, FS_MOUNT_STATE_ENUM))
	{
		drv = SRV_FMGR_PUBLIC_DRV;
	}
	else
	{
		drv = SRV_FMGR_SYSTEM_DRV;
	}
#if defined(WIN32)
	drv = SRV_FMGR_PUBLIC_DRV;
#endif
	memset(usc2Path, 0x00, sizeof(usc2Path));
	memset((void*)&disk_info, 0, sizeof(disk_info));
	
	kal_wsprintf((unsigned short *)usc2Path, "%c:\\", drv);
	handle = FS_GetDiskInfo((kal_uint16*)usc2Path, &disk_info, FS_DI_BASIC_INFO | FS_DI_FREE_SPACE);
	fs_len = disk_info.FreeClusters * disk_info.SectorsPerCluster * disk_info.BytesPerSector;
#if defined(__MTK_TARGET__)
	{
		char *p=get_ctrl_buffer(64);
		memset(p, 0x00, 64);
		sprintf(p, "gbc_Log2Path, gbc_ drv:%c,handle:%d,free space:%d\r\n", drv, handle, fs_len);
#if (GBC_VER<=0x1108)
		PutUARTBytes(0 /* uart_port1 */, (kal_uint8 *)p, strlen(p));
#else
		U_PutUARTBytes(0 /* uart_port1 */, (kal_uint8 *)p, strlen(p));
#endif
		free_ctrl_buffer(p);
	}
#endif
	if((fs_len<1024)||handle<FS_NO_ERROR)
	{
		return;
	}
	mmi_ucs2cat((S8 *)usc2Path, (const char *)path);
	handle=FS_GetAttributes((WCHAR *)usc2Path);
	if(handle>=FS_NO_ERROR)
	{
		handle = FS_Open((WCHAR *)usc2Path, FS_READ_WRITE);
	}
	else
	{
		handle = FS_Open((WCHAR *)usc2Path, FS_READ_WRITE |FS_CREATE_ALWAYS);
	}
	
	if (handle>=FS_NO_ERROR)
	{
		FS_Seek(handle,0,FS_FILE_END);
		FS_Write(handle, data, length, &fs_len);
		FS_Commit(handle);
		FS_Close(handle);
	}
}
#else
void gbc_Log2Path(char *path, char *data, kal_uint16 length){}
#endif

void gbc_trace(const char *fmt, ...)
{
	va_list lstArg;
	kal_uint16 nLen=0;
	applib_time_struct currTime;
	char *p=gbc_LogBuffer;

	memset(p, 0x00, GBC_LOG_BUFF_SIZE);
	memset(&currTime, 0x00, sizeof(currTime));
	applib_dt_get_rtc_time(&currTime);

	sprintf(p, "[%02d/%02d,%02d:%02d.%02d]", currTime.nMonth, currTime.nDay, currTime.nHour, currTime.nMin, currTime.nSec);
	nLen=strlen(p);

	va_start(lstArg, fmt);
#if defined(__MTK_TARGET__)
	nLen = vsnprintf(p+nLen, GBC_LOG_BUFF_SIZE-2-nLen, fmt, lstArg);
#else
	nLen = vsprintf(p+nLen, fmt, lstArg);
#endif
	va_end(lstArg);
	strcat(p, "\r\n");
	nLen=strlen(p);

#if defined(WIN32)
	kal_printf("%s\n", p);
#else
#if defined(__MTK_TARGET__)
#if (GBC_VER<=0x1108)
	PutUARTBytes(0 /* uart_port1 */, (kal_uint8 *)p, nLen);
#else
	U_PutUARTBytes(0 /* uart_port1 */, (kal_uint8 *)p, nLen);
#endif
#endif
	kal_prompt_trace(MOD_TST, "%s\n", p);
#endif
#if defined(GBC_DEBUG)
	gbc_Log2File(p, nLen);
#endif
}

#if defined(GBC_DEBUG) && !defined(__MTK_TARGET__)
void GBC_TRACE(const char *fmt, ...)
{
	va_list lstArg;
	kal_uint16 nLen=0;
	char *p=gbc_LogBuffer;
	
	memset(p, 0x00, GBC_LOG_BUFF_SIZE);
	va_start(lstArg, fmt);
	nLen = vsprintf(p, fmt, lstArg);
	va_end(lstArg);
	strcat(p, "\r\n");
	nLen+=2;
	nLen = (nLen>GBC_LOG_BUFF_SIZE?GBC_LOG_BUFF_SIZE:nLen);
	kal_printf("%s", p);
	gbc_Log2File(p, nLen);
}

void dbg_print(const char *fmt, ...)
{
	va_list lstArg;
	kal_uint16 nLen=0;
	char *p=gbc_LogBuffer;
	
	memset(p, 0x00, GBC_LOG_BUFF_SIZE);	
	va_start(lstArg, fmt);
	nLen = vsprintf(p, fmt, lstArg);
	va_end(lstArg);
	kal_printf("%s", p);
}

#elif !defined(__MTK_TARGET__)
void GBC_TRACE(const char *fmt, ...){}
#else /* defined(__MTK_TARGET__) */
//Define in header file
#endif

BOOL gbc_wap_mms_support(void)
{
	BOOL result=0;
	
#if (defined(MMS_SUPPORT)) && (defined(BROWSER_SUPPORT) || defined(WAP_SUPPORT))
	result = 0;
#elif(defined(BROWSER_SUPPORT) || defined(WAP_SUPPORT))
	result = 1;
#elif(defined(MMS_SUPPORT))
	result = 2;
#else
	result = 3;
#endif
	GBC_TRACE("gbc_wap_mms_support,result:%d", result);
	return result;
}
#endif