xhc_util.c

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

		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_CALL_CHANNEL);
            if (curr_chanel == MTPNP_AD_CHANNEL_SLAVE || curr_chanel == MTPNP_AD_CHANNEL_DEFAULT_SLAVE)
            {
                is_card2_open = TRUE;
            }
            else
            {
                is_card2_open = FALSE;
            }
		}
		else if(MTPNP_AD_Get_Card1RFStatus()==MTPNP_AD_RF_POWERON)
		{
            is_card2_open = FALSE;
		}
		else if(MTPNP_AD_Get_Card2RFStatus()==MTPNP_AD_RF_POWERON)
		{
            is_card2_open = TRUE;
		}
        else
        {
            return XHC_FAIL;
        }
	}

    if (is_card2_open)
    {
		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 /* __MMI_DUAL_SIM_MASTER__ */
    return XHC_OK;
}

S32 XHC_get_plmn(S32 opera)
{
    S32 ad_status;
    BOOL is_card1_open = FALSE;
    BOOL is_card2_open = FALSE;
    S32 plmn1 = -1;
    S32 plmn2 = -1;
    S32 latest_card = 0;

#ifdef __MMI_DUAL_SIM_MASTER__
	ad_status=MTPNP_AD_Get_Status();

	if(ad_status==MTPNP_AD_CARD1)
	{
        is_card1_open = TRUE;
        is_card2_open = FALSE;
	}
	else if(ad_status==MTPNP_AD_CARD2)
	{
        is_card1_open = FALSE;
        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;
            is_card2_open = FALSE;
		}
		else if(MTPNP_AD_Get_Card2RFStatus()==MTPNP_AD_RF_POWERON)
		{
            is_card1_open = FALSE;
            is_card2_open = TRUE;
		}
        else
        {
            return -1;
        }
	}
    if (is_card2_open)
    {
        plmn2 = HW_atoi((S8*)gPLMN_2);//mmi_netset_plmn_str_2_bcd_short(gPLMN_2);//(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);//mmi_netset_plmn_str_2_bcd_short(gPLMN);//(S8*)gPLMN;//
    }

#ifndef __MTK_TARGET__
    if (is_card2_open)
    {
        plmn2 = default_plmn2;
    }
    if (is_card1_open)
    {
        plmn1 = default_plmn1;
    }
#endif
    
    XHC_trace("XHC_get_plmn() opera = %d, latest_card = %d, plmn1 = %d, plmn2 = %d, is_card1_open = %d, is_card2_open = %d",
        opera, latest_card, plmn1, plmn2, is_card1_open, is_card2_open);

    if (plmn1 <= 0 && plmn2 <= 0)
    {
        return -1;
    }

    if (plmn1 == plmn2)
    {
        if (plmn1 == opera)
        {
            return plmn1;
        }
        else if (plmn1 != -1)
        {
            return plmn1;
        }
        else
        {
            return -1;
        }
    }
    else if (plmn1 > 0 && (plmn1 == opera))
    {
        return plmn1;
    }
    else if (plmn2 > 0 && (plmn2 == opera))
    {
        return plmn2;
    }
    else if (opera == 0)
    {
        if (latest_card == 0 || latest_card == 1)
        {
            if (plmn1 > 0)
            {
                return plmn1;
            }
            else if(plmn2 > 0)
            {
                return plmn2;
            }
        }
        else
        {
            if (plmn2 > 0)
            {
                return plmn2;
            }
            else if (plmn1 > 0)
            {
                return plmn1;
            }
        }
    }
    else
    {
/*
        if (plmn1  > 0)
        {
            return plmn1;
        }
        else if (plmn2  > 0)
        {
            return plmn2;
        }
*/
    }
    return -1;
}

S8* XHC_get_UA()
{
	memset(XHC_UA,0,sizeof(XHC_UA));
#ifndef WAP_CUSTOM_CFG_DEFAULT_UA_HEADER
	strncpy(XHC_UA,(S8*)"MAUI WAP Browser",strlen((S8*)"MAUI WAP Browser"));
#else
	strncpy(XHC_UA,(S8*)WAP_CUSTOM_CFG_DEFAULT_UA_HEADER,strlen((S8*)WAP_CUSTOM_CFG_DEFAULT_UA_HEADER));
#endif

	return XHC_UA;
}
S32 XHC_refresh_imsi()
{
	U8 imsi_data[9];
    S32 i = 0;
    
    memset(imsi_data,0,sizeof(imsi_data));
	memset(XHC_imsi,0,sizeof(XHC_imsi));
	l4csmu_get_imsi(imsi_data);
	for(i = 0; i < 8; i++)
	{
		XHC_imsi[2*i+1]=imsi_data[i]/16+'0';
		XHC_imsi[2*i]=imsi_data[i]%16+'0';
	}

}

void XHC_em_start_rsp(void* inMsg)
{
#if defined(__EM_MODE__)
#endif
}

void 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;
        free_peer_buff(msg->info);
        return ;
    }
    free_peer_buff(msg->info);
#endif
    return ;
}

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);

    SetProtocolEventHandler(XHC_em_status_ind, MSG_ID_MMI_EM_STATUS_IND);
    SetProtocolEventHandler(XHC_em_start_rsp, MSG_ID_EM_START_RSP);

    return XHC_OK;
#endif
}

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 = 0;//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);

}

S32 XHC_cbm_app_id = -1;
S16 XHC_soc_create()
{
    S32 net_id = XHC_data_account_id;

#if (defined(XHC_MTK_VERNO_08A) || defined(XHC_MTK_VERNO_07B))
    if (XHC_cbm_app_id < 0)
    {
        XHC_cbm_app_id = cbm_register_app_id(0, 0);
    }
    net_id = cbm_encode_app_id_data_account_id(XHC_data_account_id, XHC_cbm_app_id);
#endif
    XHC_trace("XHC_soc_create() net_id = %d", net_id);
    return soc_create(0, 0, 0, MOD_MMI, net_id);
}


S32 XHC_get_disk_space(U16* disk_path, U64* disk_free_space, U64* disk_total_space)
{
    FS_DiskInfo disk_info;
    S32 fs_ret;

    fs_ret = FS_GetDiskInfo((PU16) disk_path, &disk_info, FS_DI_BASIC_INFO | FS_DI_FREE_SPACE);

    if (fs_ret >= 0)
    {
        *disk_free_space = disk_info.FreeClusters * disk_info.SectorsPerCluster * disk_info.BytesPerSector;
        *disk_total_space = disk_info.TotalClusters * disk_info.SectorsPerCluster * disk_info.BytesPerSector;
        return XHC_OK;
    }
    else
    {
        *disk_free_space = 0;
        *disk_total_space = 0;
        return XHC_FAIL;
    }
}

S32 XHC_mem_app_force_exit_all()
{
#ifdef __IM_APPLICATION__
    IM_app_force_exit_all();
#endif //__IM_APPLICATION__

}

S32 XHC_mem_app_cleanup_all()
{
#ifdef __IM_APPLICATION__
    IM_app_mem_cleanup();
#endif //__IM_APPLICATION__

}

#endif  //__XHC_APPLICATION__