xhc_util.c

MTK平台QQ移植

#ifdef __XHC_APPLICATION__
#include "XHC_include.h"
#ifdef __MMI_DUAL_SIM_MASTER__
#include "MTPNP_AD_resdef.h"
#include "MTPNP_AD_master_if.h"
#endif /* __MMI_DUAL_SIM_MASTER__ */
#include "Conversions.h"
#include "SmsPsHandler.h"
#include "SmsGuiInterfaceType.h"
#include "SmsApi.h"

extern S32     XHC_data_account_id;
FuncPtr dt_done_func = NULL;
S32 XHC_cell_id = -1;
S32 XHC_plmn_id = -1;

S32 XHC_util_init()
{
    XHC_refresh_cell_id();

    return XHC_OK;
}

#if (defined(__MMI_DUAL_SIM__) || defined(__CBM_ALWAYS_ASK_FEATURE__))
static void XHC_gprs_dt_callback(U32 index)
#else /* __MMI_DUAL_SIM__ */
static void XHC_gprs_dt_callback(U16 index)
#endif /* __MMI_DUAL_SIM__ */
{
    XHC_data_account_id = index;

    XHC_write_all();
    if (dt_done_func)
    {
        dt_done_func();
        dt_done_func = NULL;
    }
    else
    {
        GoBackHistory();
    }
}

void XHC_list_data_account(FuncPtr done_func)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
#if (defined(__MMI_DUAL_SIM__) || defined(__CBM_ALWAYS_ASK_FEATURE__))

    mmi_dtcnt_select_account_option(
        XHC_gprs_dt_callback,
        0,
        DATA_ACCOUNT_BEARER_GPRS | DATA_ACCOUNT_BEARER_WIFI,
        DTCNT_SELECT_SIM,
        DTCNT_SELECT_NO_ALWAYS_ASK);

#else /* __MMI_DUAL_SIM__ */
    
    mmi_dtcnt_select_account(
        XHC_gprs_dt_callback,
        0,
        DATA_ACCOUNT_BEARER_GPRS | DATA_ACCOUNT_BEARER_WIFI);

#endif /* __MMI_DUAL_SIM__ */
    dt_done_func = done_func;
}

void XHC_close_all_nw()
{
    XHC_trace("XHC_net_socket_close() realse all");
//    soc_close_nwk_account_by_id( MOD_MMI, XHC_data_account_id);
#ifdef __MTK_TARGET__
    {
        ilm_struct *ilm_send = NULL;

        ilm_send = allocate_ilm(XHC_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* XHC_send_msg_prepare(S32 sms_len)
{
    S32 ad_status;
    EMSData* pEMS;
    GetEMSDataForEdit (&pEMS, 0);
    g_msg_cntx.sendMessageCase=SEND_CASE_SEND_ONLY;
    pEMS->ps_dcs=8;
    pEMS->dcs=8;
    memset(pEMS->textBuffer, 0, pEMS->textBufferSize);
    pEMS->textLength= sms_len;
    g_msg_cntx.msg_send_info.TotalSendSmsNumbers=1;
    g_msg_cntx.msg_send_info.CurrSendSmsNumbers=0;
#ifdef __MMI_DUAL_SIM_MASTER__
	ad_status=MTPNP_AD_Get_Status();

	if(ad_status==MTPNP_AD_CARD1)
	{
		/* update channel status */
		MTPNP_AD_Free_Channel(MTPNP_AD_SMS_CHANNEL);
		MTPNP_AD_Set_Channel(MTPNP_AD_SMS_CHANNEL, MTPNP_AD_CHANNEL_MASTER);
		/* update channel status */
	}
	else if(ad_status==MTPNP_AD_CARD2)
	{
		/* update channel status */
		MTPNP_AD_Free_Channel(MTPNP_AD_SMS_CHANNEL);
		MTPNP_AD_Set_Channel(MTPNP_AD_SMS_CHANNEL, MTPNP_AD_CHANNEL_SLAVE);
		/* update channel status */
	}
	else if(ad_status==MTPNP_AD_DUALCARD)
	{
		if(MTPNP_AD_Get_Card1RFStatus()==MTPNP_AD_RF_POWERON && MTPNP_AD_Get_Card2RFStatus()==MTPNP_AD_RF_POWERON)
		{
			MTPNP_AD_Free_Channel(MTPNP_AD_SMS_CHANNEL);
			MTPNP_AD_Set_Channel(MTPNP_AD_SMS_CHANNEL, MTPNP_AD_CHANNEL_MASTER);
			/* update channel status */				
		}
		else if(MTPNP_AD_Get_Card1RFStatus()==MTPNP_AD_RF_POWERON)
		{
			/* update channel status */
			MTPNP_AD_Free_Channel(MTPNP_AD_SMS_CHANNEL);
			MTPNP_AD_Set_Channel(MTPNP_AD_SMS_CHANNEL, MTPNP_AD_CHANNEL_MASTER);
			/* update channel status */
		}
		else if(MTPNP_AD_Get_Card2RFStatus()==MTPNP_AD_RF_POWERON)
		{
			/* update channel status */
			MTPNP_AD_Free_Channel(MTPNP_AD_SMS_CHANNEL);
			MTPNP_AD_Set_Channel(MTPNP_AD_SMS_CHANNEL, MTPNP_AD_CHANNEL_SLAVE);
			/* update channel status */
		}
	}
#endif /* __MMI_DUAL_SIM_MASTER__ */
    
    return pEMS->textBuffer;
}


S32 XHC_refresh_cell_id()
{
#if defined(__EM_MODE__)
    MYQUEUE Message;
    mmi_em_start_req_struct *em_start_req;

    
    XHC_cell_id = -1;
    
    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;

    Message.oslDataPtr = (oslParaType*) em_start_req;
    Message.oslPeerBuffPtr = NULL;
    Message.oslSrcId = MOD_MMI;
    Message.oslDestId = MOD_L4C;
    OslMsgSendExtQueue(&Message);

    return XHC_OK;
#endif
}

S32 XHC_em_start_rsp(void* inMsg)
{
#if defined(__EM_MODE__)
    if (XHC_cell_id < 0)
    {
        return XHC_OK;
    }
#endif
    return XHC_FAIL;
}

S32 XHC_em_status_ind(void* inMsg)
{
#if defined(__EM_MODE__)
    mmi_em_status_ind_struct *msg = (mmi_em_status_ind_struct*) inMsg;
    if (msg->em_info == RR_EM_LAI_INFO && XHC_cell_id < 0)
    {
        rr_em_lai_info_struct *data_ptr;
        kal_uint16 mm_pdu_len;

        data_ptr = (rr_em_lai_info_struct*) get_pdu_ptr(msg->info, &mm_pdu_len);
        XHC_cell_id = data_ptr->cell_id;
        XHC_trace("###################XHC_cell_id = %d", XHC_cell_id);
        return XHC_OK;
    }
#endif
    return XHC_FAIL;
}

S32 XHC_util_gb2312_to_ucs2(S8* src, S8* dest, S32 dest_size)
{
	mmi_chset_convert( MMI_CHSET_GB2312, MMI_CHSET_UCS2, 
        (char*)src, (char*)dest, dest_size);
}

void XHC_SetProtocolEventHandler(PsFuncPtr funcPtr, U16 eventID)
{
    SetProtocolEventHandler(funcPtr, eventID);
}

S32 XHC_check_in_sleep()
{
#ifndef __MMI_GPIO_DISABLE_SLEEP_MODE__
    extern BOOL gIsInSleepMode;
    if (gIsInSleepMode == TRUE)
    {
        return TRUE;
    }
    else
#endif /* __MMI_GPIO_DISABLE_SLEEP_MODE__ */ 
    {
        return FALSE;
    }
}

S8 XHC_soc_connect(S16 soc_id, U32 ip,U16 port)
{
    sockaddr_struct             soc_addr;
	U8 val, tmp;

    soc_addr.port = port;//qq_net->port_list[qq_net->curr_server];
    soc_addr.addr_len = 4;
	soc_addr.sock_type = SOCK_STREAM;

	tmp = (unsigned char)ip;
	soc_addr.addr[3] =  tmp;
	ip = ip >> 8;
	tmp = (unsigned char)ip;
	soc_addr.addr[2] =  tmp;
	ip = ip >> 8;
	tmp = (unsigned char)ip;
	soc_addr.addr[1] =  tmp;
	ip = ip >> 8;
	tmp = (unsigned char)ip;
	soc_addr.addr[0] =  tmp;

    return soc_connect(soc_id, &soc_addr);

}

#endif  //__XHC_APPLICATION__