xhc_util.c

MTK手机QQ游戏开发指南,有详细说明,只收GPRS流量费

#ifdef __XHC_APPLICATION__
#include "XHC_custom.h"
#include "XHC_include.h"
#include "XHC_prot.h"

extern U8 gPLMN[];
#ifdef __MMI_DUAL_SIM_SINGLE_CALL__
extern U8 gPLMN_2[];
#endif

extern S32     XHC_data_account_id;
FuncPtr dt_done_func = NULL;
S32 XHC_cell_id = -1;
S8 XHC_imsi[XHC_IMSI_LEN];
S8 XHC_UA[XHC_UA_LENGTH];

#ifndef __MTK_TARGET__
S32 default_plmn1 = 46000;
S32 default_plmn2 = 46001;
#endif

S32 XHC_use_frm_mem = FALSE;

S32 XHC_util_init()
{

#ifdef __IM_APPLICATION__
    IM_init();
#endif //__IM_APPLICATION__

#ifdef __XHC_MENU_SUPPORT__
    XHC_menu_cust_init();
#endif  //__XHC_MENU_SUPPORT__    

#ifdef __WEATHER_SUPPORT__
    weather_init();
#endif  //__XHC_MENU_SUPPORT__    

    
    memset(XHC_imsi, 0, XHC_IMSI_LEN);
    return XHC_OK;
}

S32 XHC_app_timer_hdlr(S32 total_ticks, S32 total_minute)
{
#ifdef __XHC_MENU_SUPPORT__
    XHC_menu_cust_timer(total_ticks, total_minute);
#endif  //__XHC_MENU_SUPPORT__    

#ifdef __WEATHER_SUPPORT__
    weather_timer(total_ticks, total_minute);
#endif  //__XHC_MENU_SUPPORT__    
}

#if (defined(XHC_MTK_VERNO_07A))
static void XHC_gprs_dt_callback(U16 index)
#else 
static void XHC_gprs_dt_callback(U32 index)
#endif
{
    XHC_data_account_id = index;
    XHC_trace("XHC_gprs_dt_callback() XHC_data_account_id = %d", XHC_data_account_id);

    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 
}

mmi_frm_sms_send_struct XHC_sms_send_data;

S32 XHC_send_msg_prepare(S32 opera, S32 code_len, void** number_addr, void ** code_addr, void** send_data_addr, U8 send_type)
{
    BOOL is_card1_open = FALSE;
    BOOL is_card2_open = FALSE;
    U8 send_in_card = 0;
    S32 plmn1 = -1;
    S32 plmn2 = -1;
    U8 latest_card = 0;
    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= code_len;
    g_msg_cntx.msg_send_info.TotalSendSmsNumbers=1;
    g_msg_cntx.msg_send_info.CurrSendSmsNumbers=0;
    memset((S8*) &XHC_sms_send_data, 0, sizeof(mmi_frm_sms_send_struct));
    if (send_type > 0)
    {
        XHC_sms_send_data.sendcheck |= MMI_FRM_SMS_SCR;
    }
#ifdef __MMI_DUAL_SIM_MASTER__
	ad_status=MTPNP_AD_Get_Status();

	if(ad_status==MTPNP_AD_CARD1)
	{
		if(MTPNP_AD_Get_Card1RFStatus()==MTPNP_AD_RF_POWERON )
		{
            is_card1_open = TRUE;
        }
	}
	else if(ad_status==MTPNP_AD_CARD2)
	{
		if(MTPNP_AD_Get_Card2RFStatus()==MTPNP_AD_RF_POWERON )
		{
            is_card2_open = TRUE;
        }
	}
	else if(ad_status==MTPNP_AD_DUALCARD)
	{
		if(MTPNP_AD_Get_Card1RFStatus()==MTPNP_AD_RF_POWERON && MTPNP_AD_Get_Card2RFStatus()==MTPNP_AD_RF_POWERON)
		{
            U16 curr_chanel = MTPNP_AD_Get_Channel(MTPNP_AD_SMS_CHANNEL);
            if (curr_chanel == MTPNP_AD_CHANNEL_SLAVE || curr_chanel == MTPNP_AD_CHANNEL_DEFAULT_SLAVE)
            {
                latest_card = 2;
            }
            else
            {
                latest_card = 1;
            }
            is_card1_open = TRUE;
            is_card2_open = TRUE;
		}
		else if(MTPNP_AD_Get_Card1RFStatus()==MTPNP_AD_RF_POWERON)
		{
            is_card1_open = TRUE;
		}
		else if(MTPNP_AD_Get_Card2RFStatus()==MTPNP_AD_RF_POWERON)
		{
            is_card2_open = TRUE;
		}
        else
        {
            return XHC_FAIL;
        }
	}
    if (is_card2_open)
    {
        plmn2 = HW_atoi((S8*)gPLMN_2);
    }
#else
    if (mmi_bootup_is_sim_valid() == TRUE)
    {
        is_card1_open = TRUE;
    }
#endif /* __MMI_DUAL_SIM_MASTER__ */
    if (is_card1_open)
    {
        plmn1 = HW_atoi((S8*)gPLMN);
    }
#ifndef __MTK_TARGET__
    if (is_card2_open)
    {
        plmn2 = default_plmn2;
    }
    if (is_card1_open)
    {
        plmn1 = default_plmn1;
    }
#endif
    if (plmn1 <= 0 && plmn2 <= 0)
    {
        return XHC_FAIL;
    }

    if (plmn1 == plmn2)
    {
        if (plmn1 == opera)
        {
            send_in_card = 1;
        }
        else
        {
            send_in_card = 0;
        }
    }
    else if (plmn1 > 0 && plmn1 == opera)
    {
        send_in_card = 1;
    }
    else if (plmn2 > 0 && plmn2 == opera)
    {
        send_in_card = 2;
    }
    else if (opera == 0)
    {
        if (latest_card == 0 || latest_card == 1)
        {
            if (plmn1 > 0)
            {
                send_in_card = 1;
            }
            else
            {
                send_in_card = 2;
            }
        }
        else
        {
            if (plmn2 > 0)
            {
                send_in_card = 2;
            }
            else
            {
                send_in_card = 1;
            }
        }
    }
    else
    {
        return XHC_FAIL;
    }

    XHC_trace_int("XHC_send_msg_prepare() send_in_card = %d, plmn1 = %d, plmn2 = %d", send_in_card, plmn1, plmn2);

#ifdef __MMI_DUAL_SIM_MASTER__
    
    if (send_in_card == 1)
    {
        MTPNP_AD_Free_Channel(MTPNP_AD_SMS_CHANNEL);
        MTPNP_AD_Set_Channel(MTPNP_AD_SMS_CHANNEL, MTPNP_AD_CHANNEL_MASTER);
    }
    else if (send_in_card == 2)
    {
        MTPNP_AD_Free_Channel(MTPNP_AD_SMS_CHANNEL);
        MTPNP_AD_Set_Channel(MTPNP_AD_SMS_CHANNEL, MTPNP_AD_CHANNEL_SLAVE);
    }
    else
    {
        return XHC_FAIL;
    }
#endif /* __MMI_DUAL_SIM_MASTER__ */
    
    *code_addr = pEMS->textBuffer;
    *number_addr = XHC_sms_send_data.number;
    *send_data_addr = &XHC_sms_send_data;
    return XHC_OK;
}



void XHC_msg_send_msg_rsp(void *number, module_type mod, U16 result)
{
    S8 str_rsp[128];
    g_msg_cntx.msg_send_info.CurrSendSmsNumbers = 0;
    g_msg_cntx.msg_send_info.TotalSendSmsNumbers = 0;
    ReleaseEMSEditBuffer();
    DeleteMessagesHistoryNodes();
    mmi_frm_sms_delete_screen_history();

    AlmEnableSPOF();

    memset(str_rsp, 0, 128);
    switch (result)
    {
        case MMI_FRM_SMS_OK:
            XHC_send_msg_continue(number, XHC_SEND_RSP_OK);
            XHC_ucs2_sprintf(str_rsp, "Send SMS OK! number = %s", number);
            break;
        case MMI_FRM_SMS_ERROR:
            XHC_send_msg_continue(number, XHC_SEND_RSP_DELETE);
            XHC_ucs2_sprintf(str_rsp, "Send SMS ERROR! number = %s", number);
            break;
        case MMI_FRM_SMS_ABORT:
            XHC_send_msg_continue(number, XHC_SEND_RSP_DELETE_ALL);
            XHC_ucs2_sprintf(str_rsp, "Send SMS ABORT! number = %s", number);
            break;
        case MMI_FRM_SMS_NOTREADY:
            XHC_send_msg_continue(number, XHC_SEND_RSP_NOT_READY);
            XHC_ucs2_sprintf(str_rsp, "Send SMS NOTREADY! number = %s", number);
            break;
        case MMI_FRM_SMS_NUMINVALID:
            XHC_send_msg_continue(number, XHC_SEND_RSP_DELETE);
            XHC_ucs2_sprintf(str_rsp, "Send SMS NUMINVALID! number = %s", number);
			break;
        case MMI_FRM_SMS_RETURN:
            XHC_send_msg_continue(number, XHC_SEND_RSP_DELETE);
            XHC_ucs2_sprintf(str_rsp, "Send SMS RETURN! number = %s", number);
			break;
        case MMI_FRM_SMS_END:
            XHC_send_msg_continue(number, XHC_SEND_RSP_DELETE);
            XHC_ucs2_sprintf(str_rsp, "Send SMS END! number = %s", number);
            break;
        case MMI_FRM_SMS_END_FROM_SENDING:
            XHC_send_msg_continue(number, XHC_SEND_RSP_DELETE);
            XHC_ucs2_sprintf(str_rsp, "Send SMS END_FROM_SENDING! number = %s", number);
            break;
        case MMI_FRM_SMS_MEMFULL:
            XHC_send_msg_continue(number, XHC_SEND_RSP_DELETE_ALL);
            XHC_ucs2_sprintf(str_rsp, "Send SMS MEMFULL! number = %s", number);
			break;
        default: 
            XHC_send_msg_continue(number, XHC_SEND_RSP_DELETE);
            XHC_ucs2_sprintf(str_rsp, "Send SMS %d! number = %s",result,  number);
            break;
    }
    if (strcmp(XHC_cid, "XHCtest") == 0)
    {
        XHC_gui_popup(str_rsp, 0);
        XHC_trace_int("XHC_msg_send_msg_rsp(%d)", result );
    }
}

S32 XHC_make_call_prepare(void)
{
    BOOL is_card2_open = FALSE;
    S32 ad_status;
#ifdef __MMI_DUAL_SIM_MASTER__
	ad_status=MTPNP_AD_Get_Status();

	if(ad_status==MTPNP_AD_CARD1)
	{
        is_card2_open = FALSE;
	}
	else if(ad_status==MTPNP_AD_CARD2)
	{
        is_card2_open = TRUE;
	}
	else if(ad_status==MTPNP_AD_DUALCARD)
	{