MTK11B GPRS Network connection

MTK11B/11C GPRS Network connection
1: Create an AP.
2: According to AP access GPRS account ID, if not found automatically created.
3: According to the GPRS account ID to create Socket.
Examples are divided into two files: mysocket.c, mysocket.h
mysocket. c ：
#include "mysocket.h"
//Total Entrance*/
void myapp_Socket_Initial(void)
{
myapp_Socket_HTTP_Start();
if(g_myapp_socket_inital)
{
if(myapp_Socket_HTTP_Create())
{
}
}
void socket_set_protocol_event_handler(U16 eventID, PsIntFuncPtr funcPtr, MMI_BOOL isMultiHandler)
{
#if (MTK_VERSION > 0x0848)
#if (MTK_VERSION >= 0x0936)
mmi_frm_set_protocol_event_handler(eventID, (PsIntFuncPtr)funcPtr, isMultiHandler);
#else
mmi_frm_set_protocol_event_handler(eventID, (PsIntFuncPtr)funcPtr, isMultiHandler);
#endif
#else
mmi_frm_set_protocol_event_handler((PsFuncPtr)funcPtr, eventID);
#endif
}
void socket_clear_protocol_event_handler(U16 eventID, PsIntFuncPtr funcPtr)
{ if(myapp_Socket_HTTP_Connect()) { } myapp_Socket_Send_Data(); }
#if (MTK_VERSION > 0x0848)
#if (MTK_VERSION >= 0x0936)
mmi_frm_clear_protocol_event_handler(eventID, (PsIntFuncPtr)funcPtr);
#else
mmi_frm_clear_protocol_event_handler(eventID, (PsIntFuncPtr)funcPtr);
#endif
#else
mmi_frm_clear_protocol_event_handler(eventID);
#endif
}
#if 1
static void socket_mmi_dtcnt_add_disp_list(U32 acct_id, const U8 *acct_name, const U8 *addr, U8 bearer_type, U32 account_type, U8 conn_type, U8 sim_info, U8 read_only)
{
#if (MTK_VERSION >= 0x11A1112)
#elif (MTK_VERSION >= 0x10A1103)
extern void mmi_dtcnt_add_disp_list(U32 acct_id, U8 bearer_type, mmi_socket_dtcnt_acct_type_enum account_type, U8 conn_type, U8 sim_info, U8 read_only);
mmi_dtcnt_add_disp_list(acct_id, bearer_type, account_type, conn_type, sim_info, read_only);
#else
extern void mmi_dtcnt_add_disp_list(U32 acct_id, const U8 * acct_name, const U8 * addr, U8 bearer_type, mmi_socket_dtcnt_acct_type_enum account_type, U8 conn_type, U8 sim_info, U8 read_only);
mmi_dtcnt_add_disp_list(acct_id, acct_name, addr, bearer_type, account_type, conn_type, sim_info, read_only);
#endif
}
static void socket_mmi_dtcnt_update_disp_list(U32 acct_id, const U8 *acct_name, const U8 *addr, U8 bearer_type, U32 account_type, U8 conn_type, U8 sim_info, U8 read_only)
{
#if (MTK_VERSION >= 0x11A1112)
#elif (MTK_VERSION >= 0x10A1103)
extern void mmi_dtcnt_update_disp_list(U32 acct_id, U8 bearer_type, mmi_socket_dtcnt_acct_type_enum account_type, U8 conn_type, U8 sim_info, U8 read_only);
mmi_dtcnt_update_disp_list(acct_id, bearer_type, account_type, conn_type, sim_info, read_only);
#else
extern void mmi_dtcnt_update_disp_list(U32 acct_id, const U8 * acct_name, const U8 * addr, U8 bearer_type, mmi_socket_dtcnt_acct_type_enum account_type, U8 conn_type, U8 sim_info, U8 read_only);
mmi_dtcnt_update_disp_list(acct_id, acct_name, addr, bearer_type, account_type, conn_type, sim_info, read_only);
#endif
}
static BOOL socket_update_acc_prof_id(kal_uint32 acc_prof_id, const WCHAR* account_name,
myapp_apn_struct apn_param, cbm_sim_id_enum sim)
{
srv_dtcnt_result_enum ret;
srv_dtcnt_store_prof_data_struct prof_info;
srv_dtcnt_prof_gprs_struct prof_gprs;
int i;
MMI_ASSERT(apn_param.apn != NULL);
memset(&prof_gprs, 0, sizeof(prof_gprs));
prof_gprs.APN = apn_param.apn;
prof_gprs.prof_common_header.sim_info = sim + 1;
prof_gprs.prof_common_header.AccountName = (const U8*)account_name;
//if (accountInfo)
{
prof_gprs.prof_common_header.Auth_info.AuthType = apn_param.authentication_type;
strcpy((char*)prof_gprs.prof_common_header.Auth_info.UserName, apn_param.user_name);
strcpy((char*)prof_gprs.prof_common_header.Auth_info.Passwd, apn_param.password);
for(i = 0; i < 4; i++)
{
prof_gprs.prof_common_header.PrimaryAddr[i] = apn_param.dns[i];
}
}
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_HTTP;
if(app_stricmp((char*)apn_param.apn, (char*)"cmwap") == 0)
{
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;
}
strcpy(prof_gprs.prof_common_header.HomePage, "http://wap.gd.10086.cn");
prof_info.prof_data = &prof_gprs;
prof_info.prof_fields = SRV_DTCNT_PROF_FIELD_ALL;
prof_info.prof_type = SRV_DTCNT_BEARER_GPRS;
ret = srv_dtcnt_store_update_prof(acc_prof_id, &prof_info);
if(ret == SRV_DTCNT_RESULT_SUCCESS)
{
socket_mmi_dtcnt_update_disp_list(acc_prof_id, prof_gprs.prof_common_header.AccountName, prof_gprs.APN,
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 TRUE;
}
else
{
return FALSE;
}
}
static kal_uint32 socket_find_acc_prof_id(const WCHAR* account_name)
{
int i, j;
srv_dtcnt_result_enum ret;
srv_dtcnt_store_prof_qry_struct store_prof_qry;
srv_dtcnt_prof_str_info_qry_struct prof_str_info_qry;
U16 name[SRV_DTCNT_PROF_MAX_ACC_NAME_LEN + 1] = {0};
for(j = 0; j < SRV_SIM_CTRL_MAX_SIM_NUM; ++j)
{
memset(&store_prof_qry, 0, sizeof(store_prof_qry));
store_prof_qry.qry_info.filters = SRV_DTCNT_STORE_QRY_TYPE_SIM | SRV_DTCNT_STORE_QRY_TYPE_BEARER_TYPE;
store_prof_qry.qry_info.sim_qry_info = j + 1;
store_prof_qry.qry_info.bearer_qry_info = SRV_DTCNT_BEARER_GPRS;
ret = srv_dtcnt_store_qry_ids(&store_prof_qry);
if(ret == SRV_DTCNT_RESULT_SUCCESS)
{
for(i = 0; i < store_prof_qry.num_ids; ++i)
{
prof_str_info_qry.dest = (S8*)name;
prof_str_info_qry.dest_len = sizeof(name);
srv_dtcnt_get_account_name(store_prof_qry.ids[i], &prof_str_info_qry, SRV_DTCNT_ACCOUNT_PRIMARY);
if(kal_wstrcmp(account_name, name) == 0)
{
return store_prof_qry.ids[i];
}
}
}
}
return -1;
}
static kal_uint32 myapp_socket_add_acc_prof_id(const WCHAR* account_name)
{
srv_dtcnt_store_prof_data_struct store_prof_data;
srv_dtcnt_prof_gprs_struct prof_gprs;
kal_uint32 acc_prof_id;
srv_dtcnt_result_enum ret;
memset(&prof_gprs, 0, sizeof(prof_gprs));
prof_gprs.APN = "cmwap"; // This value is used when the application is modified //china comm, can modiftiy to new comm co.
prof_gprs.prof_common_header.sim_info = SRV_DTCNT_SIM_TYPE_1;
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_HTTP; 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;
strcpy(prof_gprs.prof_common_header.HomePage, "http://wap.gd.10086.cn");
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;
ret = srv_dtcnt_store_add_prof(&store_prof_data, &acc_prof_id);
if(ret == SRV_DTCNT_RESULT_SUCCESS)
{
socket_mmi_dtcnt_add_disp_list(acc_prof_id,
DATA_ACCOUNT_BEARER_GPRS,
prof_gprs.prof_common_header.acct_type, prof_gprs.prof_common_header.read_only);
}
else
{
acc_prof_id = -1;
}
return acc_prof_id;
}
static kal_uint32 socket_find_acc_prof_id_by_apn(const char* apn, cbm_sim_id_enum sim) {
extern srv_dtcnt_store_info_context g_srv_dtcnt_store_ctx;
int i;
1, prof_gprs.prof_common_header.sim_info, prof_gprs.prof_common_header.AccountName, prof_gprs.APN,
for(i = 0; i < SRV_DTCNT_PROF_MAX_ACCOUNT_NUM; ++i)
{
if(g_srv_dtcnt_store_ctx.acc_list[i].in_use &&
g_srv_dtcnt_store_ctx.acc_list[i].bearer_type == SRV_DTCNT_BEARER_GPRS &&
g_srv_dtcnt_store_ctx.acc_list[i].sim_info == (sim + 1) &&
app_stricmp((char*)g_srv_dtcnt_store_ctx.acc_list[i].dest_name, (char*)apn) == 0)
{
return g_srv_dtcnt_store_ctx.acc_list[i].acc_id;
}
}
return -1;
}
/**
* Obtain the data account assigned to the application, you can support two applications at the same time
*
* @param handle
*
* @return Account index, this value is certainly valid
*/
static kal_uint32 socket_get_acc_prof_id(myapp_apn_struct apn_param, cbm_sim_id_enum sim_id)
{
// 1. Search the data account that exists in the system
// 2. Check that the virtual machine platform account already exists
/ / 3. If there is to return to the account ID, if there is to continue
// 4. Add a virtual machine platform data account
/ / 5. If the account ID returned successfully, if the failure to return to the specified account ID
const WCHAR* names[] = { L"SOC1 GPRS", L"SOC2 GPRS" };
kal_uint32 modify_acc_prof_ids[] = { SRV_DTCNT_PROF_MAX_ACCOUNT_NUM - 1, SRV_DTCNT_PROF_MAX_ACCOUNT_NUM - 2 }; kal_uint32 acc_prof_id;
kal_uint32 id;
id = 0;
MMI_ASSERT(id >= 0 && id <= 1);
acc_prof_id = socket_find_acc_prof_id_by_apn((const char*)apn_param.apn, sim_id);
if(acc_prof_id != -1)
{
return acc_prof_id;
}
acc_prof_id = socket_find_acc_prof_id(names[id]);
if(acc_prof_id == -1)
{
acc_prof_id = myapp_socket_add_acc_prof_id(names[id]);
}
if(acc_prof_id == -1)
{
if(id == 0)
{
acc_prof_id = socket_find_acc_prof_id(names[1]);
}
else
{
acc_prof_id = socket_find_acc_prof_id(names[0]);
}
if(acc_prof_id == -1)
{
acc_prof_id = modify_acc_prof_ids[id];
}
else
{
if(acc_prof_id == SRV_DTCNT_PROF_MAX_ACCOUNT_NUM - 1)
{
acc_prof_id = acc_prof_id - 1;
}
else
{
acc_prof_id = acc_prof_id + 1;
}
}
}
if(!socket_update_acc_prof_id(acc_prof_id, names[id], apn_param, sim_id))
{
acc_prof_id = -1;
}
return acc_prof_id;
}
void socket_set_account_id(cbm_sim_id_enum sim_id)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_int32 i;
U16 vs_apn[32];
S8 temp[32];
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
//socket_set_protocol_event_handler(MSG_ID_APP_SOC_NOTIFY_IND, (PsIntFuncPtr)myapp_socket_notify, TRUE); //socket_set_protocol_event_handler(MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND,
(PsIntFuncPtr)myapp_socket_get_host_by_name_ind, TRUE);
i = socket_get_acc_prof_id(g_myapp_apn_param, sim_id);
cbm_hold_bearer(g_socket_content.cbm_app_id);
g_socket_content.nwt_account_id = cbm_encode_data_account_id(i, sim_id, g_socket_content.cbm_app_id, KAL_FALSE); }
#endif
BOOL myapp_Socket_Register_Id_Get_NetworkId(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
cbm_app_info_struct app_info;
U8 app_id = CBM_INVALID_APP_ID;
S8 ret = 0;
kal_uint8 val = 1;
//register app id
memset(&app_info, 0, sizeof(app_info));
app_info.app_icon_id = 301;
app_info.app_str_id = 111;
app_info.app_type = 0; //DTCNT_APPTYPE_NONE
ret = cbm_register_app_id_with_app_info(&app_info, &app_id);
//get network id
if(ret == CBM_OK)
{
g_socket_content.cbm_app_id = app_id;
socket_set_account_id(CBM_SIM_ID_SIM1);
return TRUE;
}
else
{
}
}
void myapp_Socket_HTTP_Close(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
g_socket_content.soc_state = SOC_HTTP_INVALID;
if(g_socket_content.soc_id >= 0)
{
soc_close(g_socket_content.soc_id);
socket_clear_protocol_event_handler(MSG_ID_APP_SOC_NOTIFY_IND, (PsIntFuncPtr)myapp_socket_notify); }
}
void myapp_socket_notify(void * inMsg)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
app_soc_notify_ind_struct *soc_notify = (app_soc_notify_ind_struct*) inMsg;
kal_int8 ret;
S16 Error;
switch(soc_notify->event_type)
{
case SOC_WRITE:
break;
case SOC_READ:
{
myapp_Socket_HTTP_Receive();
}
break;
case SOC_CONNECT:
if(soc_notify->result)
{
myapp_Socket_Send_Data();
}
else //SIM card signal is poor will come here
{
}
break;
case SOC_CLOSE:
myapp_Socket_HTTP_Close();
break;
default:
break;
}
}
MMI_BOOL myapp_socket_get_host_by_name_ind(void *inMsg)
{
/*----------------------------------------------------------------*/
/* Local Variables */ /*----------------------------------------------------------------*/
app_soc_get_host_by_name_ind_struct *dns_ind;
kal_uint8 em_app_id;
int i;
/*----------------------------------------------------------------*/
/* Code Body */ /*----------------------------------------------------------------*/
if(!inMsg)
{
}
dns_ind = (app_soc_get_host_by_name_ind_struct*) inMsg;
socket_clear_protocol_event_handler(MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND, (PsIntFuncPtr)myapp_socket_get_host_by_name_ind);
/* Check if the result is OK */
if(dns_ind->result == KAL_TRUE)
{
g_socket_content.soc_addr.addr[0] = dns_ind->addr[0];
g_socket_content.soc_addr.addr[1] = dns_ind->addr[1];
g_socket_content.soc_addr.addr[2] = dns_ind->addr[2];
g_socket_content.soc_addr.addr[3] = dns_ind->addr[3];
if(myapp_Socket_HTTP_Connect() == KAL_TRUE)
{
myapp_Socket_Send_Data();
}
}
else
}
return MMI_TRUE;
}
void myapp_socket_get_host_by_name(const kal_uint8 *hostname)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_int32 ret;
char rcvd_buffer[200] = {0};
kal_uint32 rcvd_counter = 0;
/*----------------------------------------------------------------*/
/* Code Body
/*----------------------------------------------------------------*/
ret = soc_gethostbyname(
KAL_FALSE,
MOD_MMI,
(kal_int32) 1,
(kal_char*) hostname,
(kal_uint8*) &rcvd_buffer,
(kal_uint8*) &rcvd_counter,
0,
g_socket_content.nwt_account_id);
if(ret == SOC_SUCCESS)
{
g_socket_content.soc_addr.addr[0] = rcvd_buffer[0];
g_socket_content.soc_addr.addr[1] = rcvd_buffer[1];
g_socket_content.soc_addr.addr[2] = rcvd_buffer[2];
g_socket_content.soc_addr.addr[3] = rcvd_buffer[3];
if(myapp_Socket_HTTP_Connect() == KAL_TRUE)
{
myapp_Socket_Send_Data();
}
}
else if(ret == SOC_WOULDBLOCK)
{
/* waits for APP_SOC_GET_HOST_BY_NAME_IND */
socket_set_protocol_event_handler(MSG_ID_APP_SOC_GET_HOST_BY_NAME_IND,
(PsIntFuncPtr)myapp_socket_get_host_by_name_ind, TRUE);
}
else
{
if(ret == SOC_ERROR)
{ */
http_socket_output_result(SOC_HTTP_CON_ERROR);
}
else
{
http_socket_output_result(SOC_HTTP_CON_ERROR);
}
}
}
kal_bool myapp_Socket_HTTP_Connect(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_int8 sd, ret;
kal_uint8 val;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if(g_socket_content.soc_state >= SOC_HTTP_REQ_CONNECTONED)
{
return KAL_TRUE;
}
if(g_socket_content.soc_state == SOC_HTTP_STATE_CREATED)
{
socket_set_protocol_event_handler(MSG_ID_APP_SOC_NOTIFY_IND, (PsIntFuncPtr)myapp_socket_notify, TRUE); ret = soc_connect(g_socket_content.soc_id, &g_socket_content.soc_addr);
if(ret == SOC_SUCCESS)
{
g_socket_content.soc_state = SOC_HTTP_TCP_CON_CREATED;
return KAL_TRUE;
}
else if(ret == SOC_WOULDBLOCK)
{
return KAL_FALSE;
}
else
{
http_socket_output_result(SOC_HTTP_CON_ERROR);
return KAL_FALSE;
}
}
return KAL_FALSE;
}
void myapp_Socket_Send_Data(void)
{
int ret = 0;
if(g_socket_content.soc_state == SOC_HTTP_STATE_CREATED
|| g_socket_content.soc_state == SOC_HTTP_TCP_CON_CREATED
|| g_socket_content.soc_state == SOC_HTTP_REQ_CONNECTONED
|| g_socket_content.soc_state == SOC_HTTP_REQ_RETRY
|| g_socket_content.soc_state == SOC_HTTP_REQ_SENT
|| g_socket_content.soc_state == SOC_HTTP_RSP_RCVD)
{
if(g_socket_content.soc_state != SOC_HTTP_REQ_SENDING)
{
g_socket_content.snd_counter = 0;
}
g_socket_content.soc_state = SOC_HTTP_REQ_SENDING;
ret = soc_send(g_socket_content.soc_id, (U8*)(g_socket_content.snd_buffer +
g_socket_content.snd_counter),
(g_socket_content.snd_data_len - g_socket_content.snd_counter), 0);
}
else
{
http_socket_output_result(SOC_HTTP_CON_ERROR);
return ;
}
}
void myapp_Socket_HTTP_Receive(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint32 ret = 0;
kal_uint32 len = 0;
char *pdata = NULL;
char *pend = NULL;
int start_length = 0;
kal_uint32 datalength = 0;
U8 i = 0;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
g_socket_content.soc_state = SOC_HTTP_RSP_RCVING;
memset(&g_socket_content.rcvd_buffer, 0, sizeof(g_socket_content.rcvd_buffer));
ret = soc_recv(g_socket_content.soc_id, g_socket_content.rcvd_buffer, sizeof(g_socket_content.rcvd_buffer) , 0);
}
BOOL myapp_Socket_HTTP_Create(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint8 val = 1;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if(g_socket_content.soc_state >= SOC_HTTP_STATE_CREATED)
{
return TRUE;
}
g_socket_content.soc_id = soc_create(SOC_PF_INET, SOC_SOCK_STREAM, 0, MOD_MMI, g_socket_content.nwt_account_id); if(g_socket_content.soc_id >= 0)
{
if(soc_setsockopt(g_socket_content.soc_id, SOC_NBIO, &val, sizeof(val)) < 0)
{
}
val = SOC_READ | SOC_WRITE | SOC_CLOSE | SOC_CONNECT;
if(soc_setsockopt(g_socket_content.soc_id, SOC_ASYNC, &val, sizeof(val)) < 0)
{
}
g_socket_content.soc_state = SOC_HTTP_STATE_CREATED;
return TRUE;
}
else
{
return FALSE;
}
}
static void myapp_Socket_HTTP_Start(void)
{
if(myapp_Socket_Register_Id_Get_NetworkId() == TRUE)
{
g_myapp_socket_inital = KAL_TRUE;
}
else
{
g_myapp_socket_inital = KAL_FALSE;
}
}
mysocket. h ：
#include "MMI_features.h"
#if !defined(__MTK_TARGET__) || defined(MMI_ON_WIN32)
#include <windows.h>
#endif
#include "MMI_include.h"
/* for socket */
#include "soc_api.h"
#include "app2soc_struct.h"
#include "cbm_api.h"
#include "mmi2abm_struct.h"
#include "mmi_l3_enums.h"
#include "DtcntSrvDb.h"
#include "DtcntSrvIntStruct.h"
//sim
#include "SimCtrlSrvGprot.h"
#define mmi_socket_dtcnt_acct_type_enum srv_dtcnt_prof_acc_type_enum
typedef enum
{
SOC_HTTP_INVALID,
SOC_HTTP_STATE_CREATING,
SOC_HTTP_STATE_CREATED,
SOC_HTTP_DNS_QUERY,
SOC_HTTP_TCP_CON_CREATING,
SOC_HTTP_TCP_CON_CREATED,
SOC_HTTP_REQ_CONNECTONED,
SOC_HTTP_REQ_RETRY,
SOC_HTTP_REQ_SENDING,
SOC_HTTP_REQ_SENT,
SOC_HTTP_RSP_RCVING,
SOC_HTTP_RSP_RCVD,
SOC_HTTP_SOC_CLOSING,
SOC_HTTP_SOC_CLOSED,
SOC_HTTP_SEND
} KKSAPP_SOC_STATE_ENUM;
typedef struct
{
kal_uint8 apn[30]; //APN asc code
kal_uint8 Net_ID; //0 For China Mobile
kal_uint8 ip[4]; //Decimal
kal_uint8 user_name[32];//User name (optional)
kal_uint8 password[32];//password (optional)
unsigned char
unsigned char
} myapp_apn_struct;
typedef enum
{
SOC_HTTP_CON_ERROR = - 8,
SOC_HTTP_PEER_CANNOT_CONNECT,
SOC_HTTP_PEER_CANNOT_GETHOST,
SOC_HTTP_PEER_NOT_REACHABLE,
SOC_HTTP_PEER_NO_RESPONSE,
SOC_HTTP_CNT_RESET_BY_PEER,
SOC_HTTP_NO_MEMORY,
SOC_HTTP_SUCCESS,
SOC_HTTP_FINISHED,
SOC_HTTP_CON_MAX
} mmi_soc_http_con_app_result;
/* Local global variables */
static myapp_apn_struct g_myapp_apn_param =
{
{"cmwap"},
};
static kal_bool g_myapp_socket_inital = KAL_FALSE; /* Network initialization*/ dns[4]; authentication_type;
static KKSAPP_SOC_HTTP_STRUCT g_socket_content = {0};
/* Static function declaration */
static void socket_set_protocol_event_handler(U16 eventID, PsIntFuncPtr funcPtr, MMI_BOOL isMultiHandler); static void socket_clear_protocol_event_handler(U16 eventID, PsIntFuncPtr funcPtr);
static kal_bool myapp_Socket_HTTP_Connect(void);
static void myapp_send_http_timeout(void);
static void myapp_Socket_Send_Data(void);
static void myapp_Socket_HTTP_Receive(void);
static BOOL myapp_Socket_HTTP_Create(void);
static void myapp_http_socket_get_parsed_url(const char *in_str, myapp_http_url_struct * purl_parsed_info); static void myapp_http_socket_package_get_req(myapp_http_url_struct *purl_parsed_info);
static void http_socket_output_result(mmi_soc_http_con_app_result ret);
static void myapp_reset_soc_http_content(void);
static void myapp_socket_notify(void * inMsg);
static MMI_BOOL myapp_socket_get_host_by_name_ind(void *inMsg);
static void myapp_socket_get_host_by_name(const kal_uint8 *hostname);
/*******************************************************************/