static void _ies_task_job_respond(srv_ies_job *pJob,
kal_uint32 seqNum,
srv_ies_result result)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
srv_ies_ilm_job_response *pResp;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
pResp = (srv_ies_ilm_job_response*)construct_local_para(sizeof(srv_ies_ilm_job_response), TD_CTRL);
ASSERT(NULL != pResp);
pResp->pJob = pJob;
pResp->seqNum = seqNum;
pResp->result = result;
msg_send5(MOD_IES, pJob->modID, MMI_MMI_SAP, MSG_ID_IES_JOB_RSP, (local_para_struct*)pResp);
}
/*****************************************************************************
* FUNCTION
* bpp_adp_progress_ind
* DESCRIPTION
* This function send progress to bpp app(mmi)
* PARAMETERS
* printer [?] [?]
* RETURNS
* void
*****************************************************************************/
static void bpp_adp_progress_ind(bt_bpp_progress_status *prog_status)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
//float precent = 0.0;
bt_bpp_progress_ind_struct *progress_ind =
(bt_bpp_progress_ind_struct*) construct_local_para(sizeof(bt_bpp_progress_ind_struct), TD_CTRL);
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
progress_ind->hprinter = g_bpp_adp_cntx.printer_handle;
progress_ind->progress_status.sent_data_len = prog_status->sent_data_len;
progress_ind->progress_status.total_data_len = prog_status->total_data_len;
bpp_adp_send_msg2app(MSG_ID_BT_BPP_PROGRESS_IND, (local_para_struct*) progress_ind);
}
/*****************************************************************************
* FUNCTION
* phb_sat_file_change_confirm
* DESCRIPTION
* This is phb_sat_file_change_confirm function of PHB module.
* PARAMETERS
* result [IN]
* src_id [IN]
* control_block [?]
* ilm_ptr(?) [IN] The primitives
* RETURNS
* void
*****************************************************************************/
void phb_sat_file_change_confirm(phb_errno_enum result, kal_uint8 src_id, control_block_type *control_block)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
local_para_struct *local_param_ptr = NULL;
sat_file_change_res_struct *sat_file_change_res;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_FUNC, FUNC_PHB_SAT_FILE_CHANGE_CNF, result, src_id);
sat_file_change_res = (sat_file_change_res_struct*) construct_local_para(
sizeof(sat_file_change_res_struct),
TD_CTRL);
sat_file_change_res->src_id = src_id;
local_param_ptr = (local_para_struct*) sat_file_change_res;
/* Reject newly received request */
if (result == PHB_ERRNO_BUSY)
{
sat_file_change_res->is_successful = KAL_FALSE;
}
else
{
sat_file_change_res->is_successful = (result == PHB_ERRNO_SUCCESS) ? KAL_TRUE : KAL_FALSE;
if (control_block)
{
phb_free_control_block(control_block);
}
}
phb_send_ilm(MOD_SIM, MSG_ID_SAT_FILE_CHANGE_RES, local_param_ptr, NULL);
} /* end of phb_sat_file_change_confirm */
/*****************************************************************************
* FUNCTION
* bpp_adp_get_attr_confirm
* DESCRIPTION
* This function send get attr confirm to bpp app (mmi)
* PARAMETERS
* printer [?] [?]
* err_code [IN]
* RETURNS
* void
*****************************************************************************/
static void bpp_adp_get_attr_confirm(BPP_ERROR_CODE err_code, bt_bpp_printer_attributes *attr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
bt_bpp_get_printer_attr_cnf_struct *get_attr_cnf = NULL;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
BT_BPP_TRACE_INFO_ARG1(BPP_ADP_GET_ATTR_CONFIRM,err_code);
get_attr_cnf =
(bt_bpp_get_printer_attr_cnf_struct*) construct_local_para(sizeof(bt_bpp_get_printer_attr_cnf_struct), TD_CTRL);
OS_MemSet((U8*)&get_attr_cnf->printer_attributes, 0, sizeof(get_attr_cnf->printer_attributes));
get_attr_cnf->hprinter = g_bpp_adp_cntx.printer_handle;
get_attr_cnf->cnf_code = err_code;
if (attr != NULL)
{
get_attr_cnf->printer_attributes.printer_state = attr->printer_state;
get_attr_cnf->printer_attributes.state_reason = attr->state_reason;
}
if (err_code == BPP_SUCCESS)
{
OS_MemCopy((U8*)&get_attr_cnf->printer_attributes.capability, (U8*)&attr->capability, sizeof(bt_bpp_printer_capability));
}
if (g_bpp_adp_cntx.cur_req == BPP_REQ_GETPRINTERATTR)
{
g_bpp_adp_cntx.cur_req = BPP_REQ_NONE;
}
bpp_adp_send_msg2app(MSG_ID_BT_BPP_GET_PRINTER_ATTR_CNF, (local_para_struct*) get_attr_cnf);
}
void tcm_send_write_statistic_to_nvram( void )
{
nvram_write_req_struct *msg_ptr = NULL;
peer_buff_struct *pPeerBuf = NULL;
#ifndef __MASE__
nvram_ef_tcm_statistics_struct *pbPdu = NULL;
#endif
kal_uint16 wPeerLen = 0;
/* Send message to nvram */
msg_ptr = (nvram_write_req_struct *)construct_local_para(sizeof(nvram_write_req_struct), TD_CTRL);
ASSERT(NULL != msg_ptr);
msg_ptr->file_idx = NVRAM_EF_TCM_STATISTICS_LID;
msg_ptr->para = (tcm_get_actual_sim_id()+1); //for SIM1, para == 1, for SIM2, para == 2, for SIM3, para == 3, for SIM4, para == 4
msg_ptr->access_id = 0xFF; /* Indicate NVRAM writing is trigerred from TCM not L4C */
pPeerBuf = construct_peer_buff(NVRAM_EF_TCM_STATISTICS_SIZE, 0, 0, TD_CTRL);
#ifndef __MASE__
pbPdu = (nvram_ef_tcm_statistics_struct *) get_peer_buff_pdu(pPeerBuf, &wPeerLen);
TCM_INTERNAL_DEBUG_ASSERT(sizeof(nvram_ef_tcm_statistics_struct) == wPeerLen && NULL != pbPdu);
pbPdu->total_rx_data = TCM_PTR(total_rx_data);
pbPdu->total_tx_data = TCM_PTR(total_tx_data);
pbPdu->last_rx_data = TCM_PTR(last_rx_data);
pbPdu->last_tx_data = TCM_PTR(last_tx_data);
#endif
#ifdef __TCM_NEW_ARCH_DEBUG__
kal_brief_trace(TCM_CONTROL_PLANE_TRACE_GROUP, TCM_TCM_OLD_CALL_HISTORY_CONTENT, TCM_PTR(total_tx_data), TCM_PTR(total_rx_data), TCM_PTR(last_tx_data), TCM_PTR(last_rx_data));
#endif // ~ #ifdef __TCM_NEW_ARCH_DEBUG__
tcm_send_msg_to_nvram(MSG_ID_NVRAM_WRITE_REQ, (local_para_struct*)msg_ptr, pPeerBuf);
/* Update the statisti flag */
tcm_change_statistic_is_writing(KAL_TRUE);
tcm_change_statistic_needs_update(KAL_FALSE);
}
static void bpp_adp_disconnect_ind(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
bt_bpp_disconnect_ind_struct *disc_ind;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
BT_BPP_TRACE_INFO(BPP_ADP_DISC_IND);
if(g_bpp_adp_cntx.cm_conn_id != BPP_INVALID_CMID)
{
BT_BPP_TRACE_INFO_ARG1(BPP_ADP_RELEASE_CM_CONNID, g_bpp_adp_cntx.cm_conn_id);
BTBMProfileReleaseConnIndex(g_bpp_adp_cntx.cm_conn_id);
g_bpp_adp_cntx.cm_conn_id = (U8)BPP_INVALID_CMID;
}
if (g_bpp_adp_cntx.cur_req == BPP_REQ_CANCEL)
{
bpp_adp_cancel_confirm(BPP_SUCCESS);
}
disc_ind =
(bt_bpp_disconnect_ind_struct*) construct_local_para(sizeof(bt_bpp_disconnect_ind_struct), TD_CTRL);
disc_ind->hprinter = g_bpp_adp_cntx.printer_handle;
//disc_ind->cm_conn_id = g_bpp_adp_cntx.cm_conn_id;
g_bpp_adp_cntx.printer_handle = BPP_INVALID_PRINTER_HANDLE;
g_bpp_adp_cntx.cur_req = BPP_REQ_NONE;
bpp_adp_send_msg2app(MSG_ID_BT_BPP_DISCONNECT_IND, (local_para_struct*) disc_ind);
}
/*****************************************************************************
* FUNCTION
* bpp_adp_status_ind
* DESCRIPTION
* This function send printer status msg to bpp app(mmi)
* PARAMETERS
* printer [?] [?]
* prt_status [?]
* status_ind [?](?)
* RETURNS
* void
*****************************************************************************/
static void bpp_adp_status_ind(bt_bpp_job_status *prt_status)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
BT_BPP_TRACE_INFO(BPP_ADP_STATUS_IND);
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (prt_status)
{
bt_bpp_job_status_ind_struct *status_ind =
(bt_bpp_job_status_ind_struct*) construct_local_para(sizeof(bt_bpp_job_status_ind_struct), TD_CTRL);
status_ind->hprinter = g_bpp_adp_cntx.printer_handle;
status_ind->job_status.printer_state = prt_status->printer_state;
status_ind->job_status.job_state = prt_status->job_state;
status_ind->job_status.state_reason = prt_status->state_reason;
bpp_adp_send_msg2app(MSG_ID_BT_BPP_JOB_STATUS_IND, (local_para_struct*) status_ind);
}
}
static void UART_HISR(void)
{
ilm_struct *UART_ilm;
uart_ready_to_write_ind_struct* _data;
if(g_msgid == MSG_ID_UART_READY_TO_WRITE_IND)
{
_data = (uart_ready_to_write_ind_struct *) construct_local_para(sizeof(uart_ready_to_write_ind_struct),TD_UL);
_data->port = g_port;
}
else
{
_data = NULL;
}
DRV_BuildPrimitive(UART_ilm,
UARTPort[g_port].UART_id,
UARTPort[g_port].ownerid,
g_msgid,
_data);
msg_send_ext_queue(UART_ilm);
}
/*****************************************************************************
* FUNCTION
* mmi_da_wps_send_cancel_req
* DESCRIPTION
* Send "cancel request" to WAP task to cancel an action.
* PARAMETERS
* request_id IN action, reference to mmi_da_oma_request_id_enum
* RETURNS
* MMI_TRUE: OK
* MMI_FALSE: false
*****************************************************************************/
static BOOL mmi_da_wps_send_cancel_req(U8 request_id)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
wps_cancel_req_struct *abort_req;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
DA_WPS_TRACE(MMI_DA_WPS_TRACE_GROUP, MMI_DA_OMA_SEND_CANCEL_REQ);
ASSERT(_da_wps_is_ready());
abort_req = (wps_cancel_req_struct *) construct_local_para(sizeof(wps_cancel_req_struct), TD_CTRL);
abort_req->request_id = request_id + MMI_DA_WPS_REQUEST_ID_BASE;
abort_req->channel_id = da_wps_context.channel_id;
mmi_da_send_ilm(abort_req, NULL, MSG_ID_WPS_CANCEL_REQ, MOD_WPS);
SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_cancel_rsp, MSG_ID_WPS_CANCEL_RSP);
return MMI_TRUE;
}
void l4ctcm_get_gprs_statistics_info_req_hdlr( ilm_struct *ilm_ptr )
{
#ifndef __MASE__
l4ctcm_get_gprs_statistics_info_req_struct * rcv_msg_ptr;
tcm_ratdm_query_ps_statistics_req_struct * sent_msg_ptr;
rcv_msg_ptr = (l4ctcm_get_gprs_statistics_info_req_struct *)ilm_ptr->local_para_ptr;
sent_msg_ptr = (tcm_ratdm_query_ps_statistics_req_struct *)construct_local_para
(sizeof(tcm_ratdm_query_ps_statistics_req_struct),
TD_RESET );
TCM_PTR(query_serial_number) = rcv_msg_ptr->query_id;
sent_msg_ptr->query_serial_number = TCM_PTR(query_serial_number);
#ifdef __UGTCM__
tcm_send_msg_to_ratdm(MSG_ID_TCM_RATDM_QUERY_PS_STATISTICS_REQ, (local_para_struct *)sent_msg_ptr, NULL);
#endif /* __UGTCM__ */
#endif /* __MASE__ */
}
/*****************************************************************************
* FUNCTION
* bpp_adp_disconnect_confirm
* DESCRIPTION
* This function is send close confirm msg to bpp app
* PARAMETERS
* printer [?] [?]
* err_code [IN]
* RETURNS
* void
*****************************************************************************/
static void bpp_adp_disconnect_confirm(BPP_ERROR_CODE err_code)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
bt_bpp_disconnect_cnf_struct *close_cnf =
(bt_bpp_disconnect_cnf_struct*) construct_local_para(sizeof(bt_bpp_disconnect_cnf_struct), TD_CTRL);
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
BT_BPP_TRACE_INFO_ARG1(BPP_ADP_DISC_CONFIRM, err_code);
if (err_code == BPP_SUCCESS)
{
if(g_bpp_adp_cntx.cm_conn_id != BPP_INVALID_CMID)
{
BT_BPP_TRACE_INFO_ARG1(BPP_ADP_RELEASE_CM_CONNID, g_bpp_adp_cntx.cm_conn_id);
BTBMProfileReleaseConnIndex(g_bpp_adp_cntx.cm_conn_id);
g_bpp_adp_cntx.cm_conn_id = (U8)BPP_INVALID_CMID;
}
}
close_cnf->hprinter = g_bpp_adp_cntx.printer_handle;
close_cnf->cnf_code = err_code;
if (err_code == BPP_SUCCESS)
{
g_bpp_adp_cntx.printer_handle = BPP_INVALID_PRINTER_HANDLE;
g_bpp_adp_cntx.cur_req = BPP_REQ_NONE;
}
bpp_adp_send_msg2app(MSG_ID_BT_BPP_DISCONNECT_CNF, (local_para_struct*) close_cnf);
}
/*****************************************************************************
* FUNCTION
* mmi_bt_avrcp_tst_only_down_cmd
* DESCRIPTION
* Test when only down cmd comes witout up cmd
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
void mmi_bt_avrcp_tst_only_down_cmd()
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
bt_avrcp_cmd_frame_ind_res_struct* msg_p = (bt_avrcp_cmd_frame_ind_res_struct*)
construct_local_para(sizeof(bt_avrcp_cmd_frame_ind_res_struct), TD_CTRL);
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
msg_p->chnl_num = BT_AVRCP_TG ;
msg_p->profile_id = 0;
msg_p->seq_id = 0;
msg_p->c_type = 0;
msg_p->data_len = 1; /*assign a value that's larger than 0*/
msg_p->subunit_id = BT_AVRCP_SUBUNIT_ID_PASS_THROUGH;
msg_p->subunit_type = BT_AVRCP_SUBUNIT_TYPE_PASS_THROUGH;
msg_p->frame_data[0] = BT_AVRCP_OP_PASS_THROUGH;
msg_p->frame_data[1] = MMI_AVRCP_POP_STOP; //MMI_AVRCP_POP_PLAY ; /*play button down*/
/*send msg*/
{
ilm_struct *ilm_ptr = allocate_ilm(MOD_MMI);
ilm_ptr->src_mod_id = MOD_MMI;
ilm_ptr->dest_mod_id = MOD_MMI;
ilm_ptr->sap_id = BT_AVRCP_SAP;
ilm_ptr->msg_id = (msg_type)MSG_ID_BT_AVRCP_CMD_FRAME_IND;
ilm_ptr->local_para_ptr = (local_para_struct*)msg_p;
ilm_ptr->peer_buff_ptr = NULL;
msg_send_ext_queue(ilm_ptr);
}
}
/*****************************************************************************
* FUNCTION
* jpim_evtdb_deleteEntry
* DESCRIPTION
* This function deletes an entry from the event database.
* PARAMETERS
* handle [IN]
* RETURNS
* jpim_error_code_enum
*****************************************************************************/
kal_int32 jpim_evtdb_deleteEntry(kal_uint16 handle, kal_uint8 db_type, kal_int32 vm_id)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint32 event_group;
mmi_evtdb_java_set_entry_req_struct *p =
(mmi_evtdb_java_set_entry_req_struct*) construct_local_para(
sizeof(mmi_evtdb_java_set_entry_req_struct),
TD_CTRL | TD_RESET);
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
JPIM_DEBUG(TRACE_GROUP_2, JPIM_EVTDB_DELETEENTRY);
p->entry_ptr = NULL;
p->index = handle;
p->sort_type = MMI_EVTDB_SORT_BY_TIME;
p->db_index = jpim_evtdb_transfer_tdl_db(db_type);
jpim_evtdb_result = MMI_EVTDB_JAVA_ERROR;
jpim_evtdb_state = JPIM_EVTDB_STATE_DELETE_ENTRY;
if (jpim_check_vm_state(1, vm_id))
{
jpim_send_ilm(p, MSG_ID_MMI_EVTDB_JAVA_SET_ENTRY_REQ);
kal_retrieve_eg_events(g_java_event_group_1, JAVA_EG_PIM_EVTDB_DELETE_ENTRY, KAL_OR_CONSUME, &event_group, KAL_SUSPEND);
}
else
{
free_local_para((local_para_struct*) p);
}
return jpim_transfer_error_code(JPIM_EVENTDB, jpim_evtdb_result);
}
/*****************************************************************************
* FUNCTION
* vis_send_seek_cnf
* DESCRIPTION
* This function is to send visual seek confirm message.
* PARAMETERS
* result [IN]
* RETURNS
* void
*****************************************************************************/
void vis_send_seek_cnf(kal_int16 result)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
media_visual_seek_cnf_struct *msg_p = NULL;
ilm_struct *ilm_ptr = NULL;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
msg_p = (media_visual_seek_cnf_struct*) construct_local_para(sizeof(media_visual_seek_cnf_struct), TD_CTRL);
ilm_ptr = allocate_ilm(MOD_MED_V);
ilm_ptr->src_mod_id = MOD_MED_V;
ilm_ptr->dest_mod_id = MOD_MED;
ilm_ptr->sap_id = MED_SAP;
ilm_ptr->msg_id = (msg_type) MSG_ID_MEDIA_VISUAL_SEEK_CNF;
ilm_ptr->local_para_ptr = (local_para_struct*) msg_p;
ilm_ptr->peer_buff_ptr = NULL;
msg_send_ext_queue(ilm_ptr);
}
/*****************************************************************************
* FUNCTION
* mmi_da_wps_send_unset_channel_req
* DESCRIPTION
* Send "Unset channel" request to wap to destory channel
* PARAMETERS
* void
* RETURNS
* MMI_TRUE: OK
* MMI_FALSE: FAIL
*****************************************************************************/
static BOOL mmi_da_wps_send_unset_channel_req(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
wps_unset_channel_req_struct *unset_channel_req = NULL;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
DA_WPS_TRACE(MMI_DA_WPS_TRACE_GROUP, MMI_DA_OMA_SEND_UNSET_CHANNEL_REQ);
if(da_wps_context.busy_flag != MMI_DA_WPS_STATE_FREE)
return MMI_FALSE;
/* only unset when no session */
ASSERT(!da_wps_context.session_num);
if (da_wps_context.channel_id != MMI_DA_WPS_INVALID_CHANNEL)
{
unset_channel_req =
(wps_unset_channel_req_struct *) construct_local_para(sizeof(wps_unset_channel_req_struct), TD_CTRL);
unset_channel_req->channel_id = da_wps_context.channel_id;
mmi_da_send_ilm(unset_channel_req, NULL, MSG_ID_WPS_UNSET_CHANNEL_REQ, MOD_WPS);
SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_unset_channel_rsp, MSG_ID_WPS_UNSET_CHANNEL_RSP);
da_wps_context.busy_flag = MMI_DA_WPS_STATE_BUSY_UNSET;
return MMI_TRUE;
}
else
{
ASSERT(0);
}
return MMI_FALSE;
}
/*****************************************************************************
* FUNCTION
* drmt_mmi_send_alert_user_ind
* DESCRIPTION
* PARAMETERS
* type [IN]
* info [IN]
* callback [IN]
* RETURNS
*****************************************************************************/
kal_bool drmt_mmi_send_alert_user_ind(kal_int8 type, const kal_wchar *info, drmt_mmi_alert_user_cb callback)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
drmt_alert_user_ind_struct *msg;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
msg = (drmt_alert_user_ind_struct*) construct_local_para(sizeof(drmt_alert_user_ind_struct), TD_RESET);
msg->type = type;
if (info)
{
app_ucs2_strncpy((kal_int8*) msg->msg, (kal_int8*) info, 31);
}
drmt_mmi_send_ilm(msg, NULL, MSG_ID_DRMT_ALERT_USER_IND);
return KAL_TRUE;
}
/*****************************************************************************
* FUNCTION
* bpp_adp_open_confirm
* DESCRIPTION
* This function is to send open confirm msg to bpp app(MMI)
* PARAMETERS
* printer [?] Address
* err_code [IN] Error code
* RETURNS
*****************************************************************************/
static void bpp_adp_connect_confirm(BPP_ERROR_CODE cnf_code)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
bt_bpp_connect_cnf_struct *open_cnf =
(bt_bpp_connect_cnf_struct*) construct_local_para(sizeof(bt_bpp_connect_cnf_struct), TD_CTRL);
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
BT_BPP_TRACE_INFO_ARG1(BPP_ADP_CONNECT_CONFIRM,cnf_code);
if (cnf_code == BPP_SUCCESS)
{
g_bpp_adp_cntx.cm_conn_id = BTBMProfileAllocateConnIndex(BT_BASIC_PRINTING, g_bpp_adp_cntx.bt_addr);
open_cnf->cm_conn_id = g_bpp_adp_cntx.cm_conn_id;
BT_BPP_TRACE_INFO_ARG1(BPP_ADP_ALLOC_CM_CONNID, g_bpp_adp_cntx.cm_conn_id);
}
open_cnf->hprinter = g_bpp_adp_cntx.printer_handle;
open_cnf->cnf_code = cnf_code;
if (cnf_code != BPP_SUCCESS)
{
g_bpp_adp_cntx.printer_handle = BPP_INVALID_PRINTER_HANDLE;
}
g_bpp_adp_cntx.cur_req = BPP_REQ_NONE;
bpp_adp_send_msg2app(MSG_ID_BT_BPP_CONNECT_CNF, (local_para_struct*) open_cnf);
}
/*****************************************************************************
* FUNCTION
* drmt_mmi_send_open_url_req
* DESCRIPTION
* PARAMETERS
* option [IN]
* url [IN]
* callback [IN]
* RETURNS
*****************************************************************************/
kal_bool drmt_mmi_send_open_url_req(kal_uint8 option, const kal_char *url, drmt_mmi_open_url_cb callback)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
drmt_open_url_req_struct *msg;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
msg = (drmt_open_url_req_struct*) construct_local_para(sizeof(drmt_open_url_req_struct), TD_RESET);
if (url)
{
app_asc_str_n_to_ucs2_str((kal_int8*) msg->url, (kal_int8*) url, 767);
}
msg->option = option;
open_url_callback = callback;
drmt_mmi_send_ilm(msg, NULL, MSG_ID_DRMT_OPEN_URL_REQ);
return KAL_TRUE;
}
/*****************************************************************************
* FUNCTION
* bpp_adp_cancel_confirm
* DESCRIPTION
* This function is send close confirm msg to bpp app
* PARAMETERS
* printer [?] [?]
* err_code [IN]
* RETURNS
* void
*****************************************************************************/
static void bpp_adp_cancel_confirm(BPP_ERROR_CODE err_code)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
bt_bpp_cancel_cnf_struct *cancel_cnf =
(bt_bpp_cancel_cnf_struct*) construct_local_para(sizeof(bt_bpp_cancel_cnf_struct), TD_CTRL);
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
BT_BPP_TRACE_INFO_ARG1(BPP_ADP_CANCEL_CONFIRM, err_code);
cancel_cnf->hprinter = g_bpp_adp_cntx.printer_handle;
cancel_cnf->cnf_code = err_code;
if (err_code == BPP_SUCCESS)
{
g_bpp_adp_cntx.cur_req = BPP_REQ_NONE;
}
bpp_adp_send_msg2app(MSG_ID_BT_BPP_CANCEL_CNF, (local_para_struct*) cancel_cnf);
}
/*****************************************************************************
* FUNCTION
* nvram_send_L1_cal
* DESCRIPTION
*
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
void nvram_send_L1_cal(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/**
* file_idx should be the first L1 element in the logical data item ID enum
* Currently, L1 calibration data element is as following:
* NVRAM_EF_L1_AGCPATHLOSS_LID, NVRAM_EF_L1_RAMPTABLE_GSM900_LID,
* NVRAM_EF_L1_RAMPTABLE_DCS1800_LID, NVRAM_EF_L1_RAMPTABLE_PCS1900_LID,
* NVRAM_EF_L1_AFCDATA_LID, VRAM_EF_L1_L1SPFC_LID,
*/
nvram_lid_enum file_idx;
ltable_entry_struct *ldi;
peer_buff_struct *peer_buf_ptr;
kal_uint8 *pdu_ptr;
kal_uint16 pdu_length;
nvram_read_req_struct *local_data;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
local_data = (nvram_read_req_struct*) construct_local_para(sizeof(nvram_read_req_struct), TD_CTRL);
for (file_idx = NVRAM_EF_L1_START; file_idx <= NVRAM_EF_L1_END; file_idx++)
{
if (!NVRAM_IS_LID_VALID(file_idx))
{
continue;
}
switch(file_idx)
{
case NVRAM_EF_L1_AGCPATHLOSS_LID:
case NVRAM_EF_L1_RAMPTABLE_GSM850_LID:
case NVRAM_EF_L1_RAMPTABLE_GSM900_LID:
case NVRAM_EF_L1_RAMPTABLE_DCS1800_LID:
case NVRAM_EF_L1_RAMPTABLE_PCS1900_LID:
#if defined(__EPSK_TX__)
case NVRAM_EF_L1_EPSK_RAMPTABLE_GSM850_LID:
case NVRAM_EF_L1_EPSK_RAMPTABLE_GSM900_LID:
case NVRAM_EF_L1_EPSK_RAMPTABLE_DCS1800_LID:
case NVRAM_EF_L1_EPSK_RAMPTABLE_PCS1900_LID:
case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_GSM850_LID:
case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_GSM900_LID:
case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_DCS1800_LID:
case NVRAM_EF_L1_EPSK_INTERSLOT_RAMP_PCS1900_LID:
#endif /* __EPSK_TX__ */
case NVRAM_EF_L1_AFCDATA_LID:
case NVRAM_EF_L1_TXIQ_LID:
case NVRAM_EF_L1_RFSPECIALCOEF_LID:
case NVRAM_EF_L1_INTERSLOT_RAMP_GSM850_LID:
case NVRAM_EF_L1_INTERSLOT_RAMP_GSM900_LID:
case NVRAM_EF_L1_INTERSLOT_RAMP_DCS1800_LID:
case NVRAM_EF_L1_INTERSLOT_RAMP_PCS1900_LID:
case NVRAM_EF_L1_CRYSTAL_AFCDATA_LID:
case NVRAM_EF_L1_CRYSTAL_CAPDATA_LID:
{
nvram_get_data_item(ldi, file_idx);
local_data->access_id = 0;
local_data->file_idx = file_idx;
local_data->para = 1;
pdu_length = ldi->size;
peer_buf_ptr = construct_peer_buff(pdu_length, 0, 0, TD_CTRL);
ASSERT(peer_buf_ptr != NULL);
pdu_ptr = get_pdu_ptr(peer_buf_ptr, &pdu_length);
ASSERT(pdu_ptr != NULL);
nvram_read_confirm
(MOD_L1, nvram_read_data_item(ldi, 1, 1, pdu_ptr, pdu_length), local_data, ldi->size, peer_buf_ptr);
break;
}
}
}
free_local_para((local_para_struct*) local_data);
} /* end of nvram_send_L1_cal function */
/*****************************************************************************
* FUNCTION
* jpim_evtdb_fetchByIndex
* DESCRIPTION
* This function retrieves an entry from the event database. The data is filled into "entry" parameter.
* PARAMETERS
* entry [OUT]
* index [IN] 0~n-1
* sort_type [IN] jpim_evtdb_sort_enum
* db_type [IN] jpim_evtdb_db_enum
* RETURNS
* jpim_error_code_enum
*****************************************************************************/
kal_int32 jpim_evtdb_fetchByIndex(mmi_evtdb_java_entry_struct *entry,
kal_uint16 index,
kal_uint8 sort_type,
kal_uint8 db_type,
kal_int32 vm_id)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint32 event_group;
mmi_evtdb_java_get_entry_req_struct *p =
(mmi_evtdb_java_get_entry_req_struct*) construct_local_para(
sizeof(mmi_evtdb_java_get_entry_req_struct),
TD_CTRL | TD_RESET);
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
p->entry_ptr = entry;
p->index = index;
p->sort_type = MMI_EVTDB_SORT_BY_TIME;
p->db_index = jpim_evtdb_transfer_tdl_db(db_type);
p->count = 1;
jpim_evtdb_result = MMI_EVTDB_JAVA_ERROR;
jpim_evtdb_state = JPIM_EVTDB_STATE_GET_ENTRY;
if (jpim_check_vm_state(0, vm_id))
{
jpim_send_ilm(p, MSG_ID_MMI_EVTDB_JAVA_GET_ENTRY_REQ);
kal_retrieve_eg_events(g_java_event_group_1, JAVA_EG_PIM_EVTDB_FETCH_INDEX, KAL_OR_CONSUME, &event_group, KAL_SUSPEND);
JPIM_DEBUG(TRACE_GROUP_2, JPIM_EVTDB_FETCHBYINDEX, entry->handle, entry->index);
}
else
{
free_local_para((local_para_struct*) p);
}
if(jpim_transfer_error_code(JPIM_EVENTDB, jpim_evtdb_result) == JPIM_SUCCESS)
{
#ifdef JSR_75_PIM_EXTRA_ALARM_TIME_USER_DEFINE
jpim_evtdb_adjustAlarmTime(entry, db_type, KAL_FALSE);
#endif
#ifndef __COSMOS_MMI_PACKAGE__
if (db_type == JPIM_EVTDB_REMINDER || db_type == JPIM_EVTDB_MEETING || db_type == JPIM_EVTDB_COURSE ||
db_type == JPIM_EVTDB_DATE || db_type == JPIM_EVTDB_CALL|| db_type == JPIM_EVTDB_ANNIVERSARY ||
db_type == JPIM_EVTDB_ALL)
#else
if (db_type == JPIM_EVTDB_PERSONAL || db_type == JPIM_EVTDB_MEETING || db_type == JPIM_EVTDB_SPECIALDAY ||
db_type == JPIM_EVTDB_BIRTHDAY || db_type == JPIM_EVTDB_OTHERS || db_type == JPIM_EVTDB_ALL)
#endif
{
if (applib_dt_compare_time(&(entry->endTime), &(entry->startTime), NULL) == DT_TIME_LESS)
{
memcpy(&(entry->endTime), &(entry->startTime), sizeof(applib_time_struct));
}
}
if (db_type == JPIM_EVTDB_TASK)
{
#ifdef JSR_75_PIM_EXTRA_TODO
if (entry->status == SRV_TDL_STATUS_UNDONE)
{
entry->complete_time.nYear = 0;
entry->complete_time.nMonth = 0;
entry->complete_time.nDay = 0;
}
#endif
}
}
return jpim_transfer_error_code(JPIM_EVENTDB, jpim_evtdb_result);
}
static BOOL mmi_da_wps_send_http_req(U8 request_id, U8 http_method,
S8 * url, S8 * post_data, PU16 file_path)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
wps_http_req_struct *http_req;
wps_http_req_var_struct http_req_var;
peer_buff_struct *peer_buff_ptr = NULL;
U16 pdu_length;
U16 len;
FS_HANDLE hd;
static S8 range_header[30];
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
DA_WPS_TRACE(MMI_DA_WPS_TRACE_GROUP, MMI_DA_OMA_SEND_HTTP_REQ, request_id);
ASSERT(_da_wps_is_ready());
ASSERT(request_id < MMI_DA_WPS_REQUEST_ID_RANGE);
http_req = (wps_http_req_struct *) construct_local_para(sizeof(wps_http_req_struct), TD_CTRL);
http_req->channel_id = da_wps_context.channel_id;
http_req->request_id = request_id + MMI_DA_WPS_REQUEST_ID_BASE;
http_req->method = http_method;
http_req->option = WPS_HTTP_OPTION_NO_CACHE;
http_req_var.request_url_len = (kal_uint32) strlen(url);
http_req_var.request_url = (kal_uint8 *) url;
http_req_var.request_header_len = 0;
http_req_var.request_header = NULL;
if (http_method == WPS_HTTP_METHOD_POST)
{
ASSERT(post_data != NULL);
http_req->reply_type = WPS_DATA_TYPE_BUFFER;
http_req->reply_segment_len = 0; /* no use here */
http_req->post_type = WPS_DATA_TYPE_BUFFER;
http_req->post_path[0] = '\0';
http_req->post_path[1] = '\0';
http_req->post_total_len = strlen(post_data);
http_req->more_post = MMI_FALSE;
http_req_var.post_segment_len = strlen(post_data);
http_req_var.post_segment = (kal_uint8 *) post_data;
http_req_var.request_header_len = strlen("Content-Type: text/plain; charset=UTF-8\r\n");
http_req_var.request_header = (kal_uint8 *)"Content-Type: text/plain; charset=UTF-8\r\n";
}
else
{
ASSERT(file_path != NULL && mmi_ucs2strlen((S8 *) file_path) < 256);
http_req->reply_type = WPS_DATA_TYPE_FILE;
mmi_ucs2cpy((S8 *) http_req->reply_path, (S8 *) file_path);
http_req->reply_segment_len = 0; /* no use here */
http_req->post_type = WPS_DATA_TYPE_BUFFER;
http_req->post_path[0] = '\0';
http_req->post_path[1] = '\0';
http_req->post_total_len = 0;
http_req->more_post = MMI_FALSE;
http_req_var.post_segment_len = 0;
http_req_var.post_segment = NULL;
// If the target file exist, it means RESUME
if ((hd = FS_Open((PU16)file_path, FS_READ_ONLY)) >= 0)
{
UINT file_size;
FS_GetFileSize(hd, &file_size);
sprintf(range_header, "Range:bytes=%d-", file_size);
FS_Close(hd);
http_req_var.request_header_len = strlen(range_header);
http_req_var.request_header = (kal_uint8 *)range_header;
}
}
pdu_length = wps_pun_var_part(WPS_PUN_SIZE, MSG_ID_WPS_HTTP_REQ, &http_req_var, NULL);
if (pdu_length > 0)
{
peer_buff_ptr = construct_peer_buff(pdu_length, 0, 0, TD_RESET);
if (wps_pun_var_part(WPS_PUN_PACK, MSG_ID_WPS_HTTP_REQ, &http_req_var, get_pdu_ptr(peer_buff_ptr, &len)) !=
pdu_length)
{
free_peer_buff(peer_buff_ptr);
peer_buff_ptr = NULL;
}
}
mmi_da_send_ilm(http_req, peer_buff_ptr, MSG_ID_WPS_HTTP_REQ, MOD_WPS);
SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_http_rsp, MSG_ID_WPS_HTTP_RSP);
SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_dl_progress_ind, MSG_ID_WPS_DL_PROGRESS_IND);
SetProtocolEventHandler((PsFuncPtr) mmi_da_wps_recv_http_auth_ind, MSG_ID_WPS_HTTP_AUTH_IND);
return MMI_TRUE;
}
/*****************************************************************************
* FUNCTION
* rmmi_general_command_parsing()
* DESCRIPTION
* This function should parse general proprietary AT command request.
* Each owner should maintain and modify the code.
* PARAMETERS
* kal_uint32 op
* kal_uint32 data_len
* kal_uint8 *data_str
* RETURNS
* KAL_TRUE or KAL_FALSE
*****************************************************************************/
kal_bool rmmi_general_command_parsing(kal_uint32 op,
kal_uint32 data_len,
kal_uint8 *data_str)
{
kal_bool ret_val = KAL_FALSE;
#ifndef L4_NOT_PRESENT
switch(op)
{
case 2: /* add by stanley 2006-07-03*/
{
#if defined(__BTMTK__)
bt_test_cmd_req_struct *param_ptr;
param_ptr = (bt_test_cmd_req_struct *)construct_local_para(
(kal_uint16)sizeof(bt_test_cmd_req_struct),
TD_CTRL);
kal_mem_cpy(param_ptr->test_cmd_content, data_str, data_len);
rmmi_send_msg_to_bt(MSG_ID_BT_TEST_CMD_REQ, param_ptr);
ret_val = KAL_TRUE;
#endif /* __BTMTK__ */
break;
}
case 6:
{
#ifdef __UMTS_RAT__
kal_char *pp, *strModuleName, *strTstInject, *tt;
kal_uint32 module_enum = 0, input_str_data_len = 0;
input_str_data_len = strlen((kal_char*)data_str);
if( input_str_data_len > 0 && input_str_data_len < 255)
{
strModuleName = (kal_char*) kal_strtok_r((kal_char*)data_str, "_", &pp);
tt = (kal_char*) kal_strtok_r(NULL, "", &pp);
if(NULL != tt)
{
strTstInject = tt;
}
else
{
strTstInject = "";
}
/* Length of module name should be less than 8 bytes and Length of TST inject string shall be less than 128 bytes */
if((CUSTOM_MAX_MOD_NAME > strlen(strModuleName)) && (128 > strlen(strTstInject)))
{
kal_uint8 idx;
static const module_name_enum_map_struct mod_map[MAX_MODULE_MAP_SIZE] =
{
{"MEME", MOD_MEME},//0
{"CSE", MOD_CSE},
{"CSCE", MOD_CSCE},
{"SIBE", MOD_SIBE},
{"USIME", MOD_USIME},
{"RRCE", MOD_RRCE},//5
{"SLCE", MOD_SLCE},
{"ADR", MOD_ADR},
{"URR", MOD_URR},
{"URLC", MOD_URLC},
{"UMAC", MOD_UMAC},//10
{"UL2", MOD_UL2},
{"MM", MOD_MM},
{"CC", MOD_CC},
{"CISS", MOD_CISS},
{"SMS", MOD_SMS},//15
{"SIM", MOD_SIM},
{"L4C", MOD_L4C},
{"TCM", MOD_TCM},
{"SMSAL", MOD_SMSAL},
{"UEM", MOD_UEM},//20
{"RAC", MOD_RAC},
{"SMU", MOD_SMU},
{"USAT", MOD_USAT},
{"CSM", MOD_CSM},
{"ENG", MOD_ENG},//25
{"PHB", MOD_PHB},
{"RRM", MOD_RRM},
{"RLC", MOD_RLC},
{"MAC", MOD_MAC},
{"LAPDM", MOD_LAPDM}, //30
{"MPAL", MOD_MPAL},
{"SNDCP", MOD_SNDCP},
{"SM", MOD_SM},
{"LLC", MOD_LLC}//34
};
for(idx = 0; idx < MAX_MODULE_MAP_SIZE; idx++)
{
if(strcmp(strModuleName, mod_map[idx].ModuleName) == 0)
{
module_enum = mod_map[idx].ModuleEnum;
break;
}
}
if(idx != MAX_MODULE_MAP_SIZE)
{
/* The target module is found, and send the TST to the module */
tst_module_string_inject_struct *tst_inject;
tst_inject = (tst_module_string_inject_struct *)
construct_local_para((kal_uint16)sizeof(tst_module_string_inject_struct), TD_RESET);
strcpy((kal_char*)tst_inject->string, strTstInject);
tst_inject->index = data_len;
{
msg_send5(MOD_L4C, (module_type)module_enum, 0, MSG_ID_TST_INJECT_STRING, (local_para_struct*)tst_inject);
}
}
}
ret_val = KAL_TRUE;
}
#endif /* __UMTS_RAT__ */
}
break;
#if defined(__AGPS_CONTROL_PLANE__)
case 14:
{
l4c_agps_reset_positioning_lind();
ret_val = KAL_TRUE;
break;
}
#endif
/************************sample code begin************************/
// case op: /*owner_date: purpose*/
// {
// /*call proprietary parsing function here and AT will give result */
// /*code OK/ERROR according to return value of parsing function*/
//
// break;
// }
/************************sample code end*************************/
#ifdef __CTP_GOODIX_GT818_TRUE_MULTIPLE__
case 15:
case 16:
case 17:
case 18:
case 19:
case 20:
case 21:
case 22:
case 23:
case 24:
{
ret_val = process_gt818_ctp_cmd( (kal_uint8)(op - 15), data_len, data_str );
break;
}
#endif
#if defined(__AGPS_SUPPORT__)
/* below codes are for auto-test */
case 25:
case 26:
{
/*agps_auto_test_ind_struct *param_ptr = construct_local_para(
(kal_uint16)sizeof(agps_auto_test_ind_struct), TD_RESET);
param_ptr->mode = (op == 25)? 1 : 0;*/
/* Send the message to the module in AP */
//ret_val = custom_send_agps_autotest_ipc(IPC_MSG_ID_AGPS_AUTO_TEST_IND, param_ptr);
agps_md_auto_test_ind data;
data.mode = (op == 25)? 1 : 0;
rmmi_lbs_send_data(AGPS_MD_TYPE_AUTO_TEST_IND, (kal_uint8*)&data, sizeof(data));
break;
}
case 27:
case 28:
case 29:
case 30:
case 31:
case 32:
{
/*agps_cp_up_status_ind_struct *param_ptr = construct_local_para(
(kal_uint16)sizeof(agps_cp_up_status_ind_struct), TD_RESET);
param_ptr->mode = (op-27);*/
/* Send the message to the module in AP */
//ret_val = custom_send_agps_autotest_ipc(IPC_MSG_ID_AGPS_CP_UP_STATUS_IND, param_ptr);
agps_md_auto_cp_up_status_ind data;
data.mode = (op-27);
rmmi_lbs_send_data(AGPS_MD_TYPE_AUTO_CP_UP_STATUS_IND, (kal_uint8*)&data, sizeof(data));
break;
}
case 33:
case 34:
{
/* Send the message to the module in AP */
//ret_val = custom_send_agps_autotest_ipc(IPC_MSG_ID_AGPS_MOLR_START_IND+(op-33), NULL);
rmmi_lbs_send_data(AGPS_MD_TYPE_AUTO_MOLR_START_IND+(op-33), NULL, 0);
break;
}
case 35:
case 36:
{
/*agps_mtlr_response_ind_struct *param_ptr = construct_local_para(
(kal_uint16)sizeof(agps_mtlr_response_ind_struct), TD_RESET);
param_ptr->response = (op-35);*/
/* Send the message to the module in AP */
//ret_val = custom_send_agps_autotest_ipc(IPC_MSG_ID_AGPS_MTLR_RESPONSE_IND, param_ptr);
agps_md_auto_mtlr_response_ind data;
data.response = (op-35);
rmmi_lbs_send_data(AGPS_MD_TYPE_AUTO_MTLR_RESPONSE_IND, (kal_uint8*)&data, sizeof(data));
break;
}
#endif
/* Sleep Mode Stress Test */
case 37:
{
ret_val = custom_send_sm_stress_inject_msg( "2GStressEnable", MOD_L1);
break;
}
#ifdef __UMTS_FDD_MODE__
case 38:
{
ret_val = custom_send_sm_stress_inject_msg( "3GStressEnable", MOD_UL1);
break;
}
#endif
case 39:
{
ret_val = custom_send_sm_stress_inject_msg( "RTOSStressEnable", MOD_L1);
break;
}
case 40:
{
ret_val = custom_send_sm_stress_inject_msg( "2GStressDisable", MOD_L1);
break;
}
#ifdef __UMTS_FDD_MODE__
case 41:
{
ret_val = custom_send_sm_stress_inject_msg( "3GStressDisable", MOD_UL1);
break;
}
#endif
case 42:
{
ret_val = custom_send_sm_stress_inject_msg( "RTOSStressDisable", MOD_L1);
break;
}
/*Re Calibration Stress */
case 43:
{
ret_val = custom_send_sm_stress_inject_msg( "ReKEnable", MOD_L1);
break;
}
case 44:
{
ret_val = custom_send_sm_stress_inject_msg( "ReKDisable", MOD_L1);
break;
}
case 48:
{
ret_val = custom_send_sm_stress_inject_msg( "2GSleepEnable", MOD_L1);
break;
}
case 49:
{
ret_val = custom_send_sm_stress_inject_msg( "2GSleepDisable", MOD_L1);
break;
}
#ifdef __UMTS_FDD_MODE__
case 50:
{
ret_val = custom_send_sm_stress_inject_msg( "3GSleepEnable", MOD_UL1);
break;
}
case 51:
{
ret_val = custom_send_sm_stress_inject_msg( "3GSleepDisable", MOD_UL1);
break;
}
#endif
case 54:
{
ret_val = custom_send_sm_stress_inject_msg( "OSTDSleepEnable", MOD_L1);
break;
}
case 55:
{
ret_val = custom_send_sm_stress_inject_msg( "OSTDSleepDisable", MOD_L1);
break;
}
default:
break;
}
#endif // L4_NOT_PRESENT
return ret_val;
}
/*****************************************************************************
* FUNCTION
* aud_send_msg_to_nvram
* DESCRIPTION
*
* PARAMETERS
* msg_name [IN]
* ef_id [IN]
* data_ptr [?]
* length [IN]
* RETURNS
* void
*****************************************************************************/
void aud_send_msg_to_nvram(msg_type msg_name, kal_uint16 ef_id, void *data_ptr, kal_uint16 length)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
peer_buff_struct *data_stream;
local_para_struct *parm_stream;
kal_uint16 pdu_len;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
switch (msg_name)
{
case MSG_ID_NVRAM_WRITE_REQ:
switch (ef_id)
{
case NVRAM_EF_CUST_ACOUSTIC_DATA_LID:
case NVRAM_EF_AUDIO_PARAM_LID:
case NVRAM_EF_AUDIO_DC_CALIBRATION_LID:
#ifdef __AMRWB_LINK_SUPPORT__
case NVRAM_EF_AUDIO_WB_SPEECH_INPUT_FIR_LID:
case NVRAM_EF_AUDIO_WB_SPEECH_OUTPUT_FIR_LID:
case NVRAM_EF_AUDIO_WB_SPEECH_MODE_PARAM_LID:
#endif /* __AMRWB_LINK_SUPPORT__ */
parm_stream = construct_local_para(sizeof(nvram_write_req_struct), TD_CTRL);
data_stream = construct_peer_buff(length, 0, 0, TD_CTRL);
((nvram_write_req_struct*) parm_stream)->file_idx = (kal_uint16) ef_id;
((nvram_write_req_struct*) parm_stream)->para = 1;
((nvram_write_req_struct*) parm_stream)->access_id = 0;
pdu_len = length;
kal_mem_cpy(get_peer_buff_pdu(data_stream, &pdu_len), data_ptr, length);
aud_send_ilm(MOD_NVRAM, MSG_ID_NVRAM_WRITE_REQ, parm_stream, data_stream);
break;
default:
/* error write */
break;
}
break;
case MSG_ID_NVRAM_READ_REQ:
switch (ef_id)
{
case NVRAM_EF_CUST_ACOUSTIC_DATA_LID:
case NVRAM_EF_AUDIO_PARAM_LID:
case NVRAM_EF_AUDIO_DC_CALIBRATION_LID:
#ifdef __GAIN_TABLE_SUPPORT__
case NVRAM_EF_AUDIO_GAIN_TABLE_LID:
#endif /* __GAIN_TABLE_SUPPORT__ */
#ifdef __SPEECH_MODE_TABLE_SUPPORT__
case NVRAM_EF_AUDIO_SPEECH_MODE_TABLE_LID:
#endif /* __SPEECH_MODE_TABLE_SUPPORT__ */
#ifdef __AMRWB_LINK_SUPPORT__
case NVRAM_EF_AUDIO_WB_SPEECH_INPUT_FIR_LID:
case NVRAM_EF_AUDIO_WB_SPEECH_OUTPUT_FIR_LID:
case NVRAM_EF_AUDIO_WB_SPEECH_MODE_PARAM_LID:
#endif /* __AMRWB_LINK_SUPPORT__ */
#ifdef __DUAL_MIC_SUPPORT__
case NVRAM_EF_AUDIO_DUAL_MIC_PARAM_LID:
#endif
parm_stream = construct_local_para(sizeof(nvram_read_req_struct), TD_CTRL);
((nvram_read_req_struct*) parm_stream)->file_idx = (kal_uint16) ef_id;
((nvram_read_req_struct*) parm_stream)->para = 1;
aud_send_ilm(MOD_NVRAM, MSG_ID_NVRAM_READ_REQ, parm_stream, NULL);
break;
default:
/* error read */
break;
}
break;
default:
break;
} /* End Switch */
return;
}
/*****************************************************************************
* FUNCTION
* phb_search_confirm
* DESCRIPTION
* This is phb_search_confirm function of PHB module.
* PARAMETERS
* result [IN]
* actual_count [IN]
* src_id [IN]
* cnf_msg_id [IN]
* control_block [?]
* ilm_ptr(?) [IN] The primitives
* RETURNS
* void
*****************************************************************************/
static void phb_search_confirm(
phb_errno_enum result,
kal_uint16 actual_count,
kal_uint8 src_id,
msg_type cnf_msg_id,
control_block_type *control_block)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
local_para_struct *local_param_ptr = NULL;
peer_buff_struct *peer_buf_ptr = NULL;
kal_uint16 msg_id = 0;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_FUNC, FUNC_PHB_SEARCH_CNF, result, actual_count, src_id, cnf_msg_id);
/* First we release local parameter. */
if ((result != PHB_ERRNO_BUSY) && (control_block->local_param_ptr != NULL))
{
free_ctrl_buffer(control_block->local_param_ptr);
}
if ((result == PHB_ERRNO_BUSY) || (control_block->cnf_msg_id == MSG_ID_L4CPHB_SEARCH_REQ))
{
l4cphb_search_cnf_struct *l4cphb_search_cnf;
l4cphb_search_cnf = (l4cphb_search_cnf_struct*) construct_local_para(
sizeof(l4cphb_search_cnf_struct),
TD_CTRL);
l4cphb_search_cnf->total = actual_count;
l4cphb_search_cnf->src_id = src_id;
l4cphb_search_cnf->result = result;
/* Field `cause' is meaningful when I/O occured by using control blocks */
l4cphb_search_cnf->cause = control_block->cause;
if (result == PHB_ERRNO_BUSY)
{
phb_send_ilm(MOD_L4C, MSG_ID_L4CPHB_SEARCH_CNF, (local_para_struct*) l4cphb_search_cnf, NULL);
return;
}
local_param_ptr = (local_para_struct*) l4cphb_search_cnf;
msg_id = MSG_ID_L4CPHB_SEARCH_CNF;
}
/**
* Under ADN mode, only when is_retrieve is true and searching into
* physical storage device is required will call search_continue(), which
* in consequence results in this search_confirm() is invoked.
*
* Since it is ADN mode, no matter the search result is,
* the approval result is ALWAYS success!!
*/
else if (control_block->cnf_msg_id == MSG_ID_L4CPHB_APPROVE_REQ)
{
l4cphb_approve_cnf_struct *l4cphb_approve_cnf;
l4cphb_approve_cnf = (l4cphb_approve_cnf_struct*) construct_local_para(
sizeof(l4cphb_approve_cnf_struct),
TD_CTRL);
l4cphb_approve_cnf->result = PHB_ERRNO_SUCCESS;
/* Field `cause' is meaningful when I/O occured by using control blocks */
l4cphb_approve_cnf->cause = control_block->cause;
l4cphb_approve_cnf->type = control_block->type;
l4cphb_approve_cnf->src_id = control_block->src_id;
local_param_ptr = (local_para_struct*) l4cphb_approve_cnf;
msg_id = MSG_ID_L4CPHB_APPROVE_CNF;
}
/* EXCEPTION cannot reach here */
if (control_block->peer_buf_ptr != NULL)
{
if (control_block->actual_count > 0)
{
peer_buf_ptr = (peer_buff_struct*) control_block->peer_buf_ptr;
control_block->peer_buf_ptr = NULL;
}
else
{
free_ctrl_buffer(control_block->peer_buf_ptr);
peer_buf_ptr = NULL;
}
control_block->need_free_peer = KAL_FALSE;
}
phb_free_control_block(control_block);
phb_send_ilm(MOD_L4C, msg_id, local_param_ptr, peer_buf_ptr);
} /* end of phb_search_confirm */
/*****************************************************************************
* FUNCTION
* SimSrvCallback
* DESCRIPTION
*
* PARAMETERS
* Server [IN]
* Parms [IN]
* RETURNS
* void
*****************************************************************************/
void SimSrvCallback(SimServer *Server, SimCallbackParms *Parms)
{
SimCardReaderStatus cardRdrStatus;
SimCardStatus statusChange = SIM_CARD_STATUS_UNKNOWN;
SimResultCode result = SIM_RESULT_NO_REASON;
BtStatus status;
U8 *ptr;
U16 len;
switch (Parms->event)
{
case SAEVENT_SERVER_OPEN_IND:
/* When receiving this event, SimServer will send CONNECT_RSP event back to client */
if ((status = SIM_ServerRespondOpenInd(Server, SIM_CONN_STATUS_OK)) != BT_STATUS_PENDING)
{
kal_trace(TRACE_GROUP_1, BT_SIMAP_CON_NOT_ACCEPTED_IN_SRVCALLBACK, status);
/* In this case means that sending of CONNECT_RSP is failed */
/* Return value from RF_CloseChannel() may be BT_STATUS_IN_PROGRRESS(presenting rfchannel state is DLC_STATE_DISC_PENDING) */
status = SimApCloseRFCommChnl(&(Server->rfChannel));
if ((status != BT_STATUS_PENDING) && (status != BT_STATUS_IN_PROGRESS) && (status != BT_STATUS_SUCCESS))
{
/* Report(("SERVER_OPEN_IND and RF_CloseChannel error, status=%d",status)); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_SHOW_ONE_BYTE, status);
Assert(0);
}
}
else
{
kal_trace(TRACE_GROUP_1, BT_SIMAP_CON_ACCEPTED_IN_SRVCALLBACK);
}
break;
case SAEVENT_SERVER_OPEN:
kal_trace(TRACE_GROUP_1, BT_SIMAP_CON_OPEN_IN_SRVCALLBACK, Parms->status);
if (Parms->status == BT_STATUS_SUCCESS)
{
#if 0 // Reserved for MAUI
bt_simap_connect_ind_struct *bt_simap_connect_ind = NULL;
#endif
SIMAPCallbackParms parms;
/* Allocated a connection id for SIM Access Profile (SC_SIM_ACCESS: 0x112D) */
SIM(connect_id)[0] = BTBMProfileAllocateConnIndex(SC_SIM_ACCESS, Parms->ptrs.remDev->bdAddr);
SIM(allocated_connect_id)[0] = KAL_TRUE;
#if 0 // Reserved for MAUI
bt_simap_connect_ind = construct_local_para(sizeof(bt_simap_connect_ind_struct), TD_UL);
/* Reset lap,uap,nap to zero */
bt_simap_connect_ind->lap = 0;
bt_simap_connect_ind->uap = 0;
bt_simap_connect_ind->nap = 0;
memcpy(&(bt_simap_connect_ind->lap), &Parms->ptrs.remDev->bdAddr.addr[0], 3);
bt_simap_connect_ind->uap = Parms->ptrs.remDev->bdAddr.addr[3];
memcpy(&(bt_simap_connect_ind->nap), (U16*) & Parms->ptrs.remDev->bdAddr.addr[4], 2);
bt_simap_connect_ind->cid = SIM(connect_id)[0];
bt_send_msg(
MSG_ID_BT_SIMAP_CONNECT_IND,
MOD_MMI,
BT_APP_SAP,
(local_para_struct*) bt_simap_connect_ind,
NULL);
#endif
parms.event = SIMAP_EVENT_CONNECT_IND;
parms.dstMod = MOD_MMI;
parms.p.simap_connect_ind.cid = SIM(connect_id)[0];
parms.p.simap_connect_ind.lap = 0;
parms.p.simap_connect_ind.uap = 0;
parms.p.simap_connect_ind.nap = 0;
btmtk_os_memcpy((U8 *)&(parms.p.simap_connect_ind.lap), &Parms->ptrs.remDev->bdAddr.addr[0], 3);
parms.p.simap_connect_ind.uap = Parms->ptrs.remDev->bdAddr.addr[3];
btmtk_os_memcpy((U8 *)&(parms.p.simap_connect_ind.nap), (U8 *) &Parms->ptrs.remDev->bdAddr.addr[4], 2);
SIMAPCB(&parms);
}
else
{
/* Handle the failed OPEN Event */
/* Return value from RF_CloseChannel() may be BT_STATUS_IN_PROGRRESS(presenting rfchannel state is DLC_STATE_DISC_PENDING) */
status = SimApCloseRFCommChnl(&(Server->rfChannel));
if ((status != BT_STATUS_PENDING) && (status != BT_STATUS_IN_PROGRESS) && (status != BT_STATUS_SUCCESS))
{
/* Report(("SERVER_OPEN and RF_CloseChannel err, status=%d",status)); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_SHOW_ONE_BYTE, status);
Assert(0);
}
}
break;
case SAEVENT_SERVER_CLOSE_IND:
kal_trace(TRACE_GROUP_1, BT_SIMAP_CON_CLOSED_IND_IN_SRVCALLBACK, Parms->status);
break;
case SAEVENT_SERVER_CLOSED:
kal_trace(TRACE_GROUP_1, BT_SIMAP_CLOSED_IN_SRVCALLBACK, Parms->status);
/* Determine that if is is necessary to notify SIM task to start recovery mechanism */
Report(("[BT SIMAP_svr]SAEVENT_SERVER_CLOSED: substate=%d", SIM(simServer)[0].substate));
//clear the RF channel
cur_rfchannel = NULL;
if (SIM(simServer)[0].substate & BT_REJECT_SECOND_CLIENT_SESSION)
{
SIM(simServer)[0].substate &= (~BT_REJECT_SECOND_CLIENT_SESSION);
/* Report(("This closed event is due to SimServer is serving one client now, so reject another seesion")); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_CLOSED_EVENT_DUE_TO_REJECT_SECOND_CLIENT);
return;
}
if ((SIM(simServer)[0].substate & BT_SIM_CONNECT_REQ_SENT) &&
(SIM(simServer)[0].substate & BT_SIM_CONNECT_CNF_RECV) && (SIM(simServer)[0].atr.dataLen == 0))
{
//Report(("CONNECT_CNF from SIM task is error, Send DISC_REQ to SIM task is not necessary when CLOSED in SimServer"));
//Report(("Case0:In SimSrvCallback():SimServer is available again!"));
kal_trace(TRACE_GROUP_1, BT_SIMAP_SRVCALLBACK_CASE0);
SIM(simServer)[0].substate = 0;
SIM(simServer)[0].available = TRUE;
}
else if (SIM(simServer)[0].substate & BT_SIM_CONNECT_REQ_SENT)
{
/* Because the SIM task may notify other modules to enter remote SIM mode, it is necessary to recovery as normal mode */
/* Through sending disconnect_req to SIM task to notify it */
/* Check if timer for DISC_Graceful is still runing */
if (SIM(simServer)[0].substate & BT_APP_DISCONNECT_REQ_RECV)
{
/* Report(("In SimSrvCallback() recv CLOSED, check timer for DISC_Graceful type")); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_SRVCALLBACK_RECV_CLOSED_CHECK_TIMER);
bt_simap_stop_timer(&SIM(simap_event_id));
}
/* Send BT_SIM_DISCONNECT_REQ message to SIM task */
SIM(simServer)[0].substate |= BT_SIM_DISCONNECT_REQ_SENT;
#if 0
#ifdef __SIMAP_TESTER_
if(SIM(simServer)[0].test_mode == 1)
bt_fakesim_disconnect_req_hdlr();
else if(SIM(simServer)[0].test_mode == 2)
bt_send_msg(MSG_ID_BT_SIM_DISCONNECT_REQ, MOD_SIM, PS_SIM_SAP, NULL, NULL);
#endif
#endif /* 0 */
if (SIM(simServer)[0].exec_mode == 0)
{
#ifdef __SIMAP_MAUI__
bt_send_msg(MSG_ID_BT_SIM_DISCONNECT_REQ, MOD_SIM, PS_SIM_SAP, NULL, NULL);
#else
SIMAPCallbackParms parms;
parms.event = SIM_EVENT_DISCONNECT_REQ;
parms.dstMod = MOD_SIM;
SIMAPCB(&parms);
#endif
}
#ifdef __SIMAP_UT_
else if (SIM(simServer)[0].exec_mode == 1)
{
bt_fakesim_disconnect_req_hdlr();
}
#endif /* __SIMAP_UT_ */
}
else
{
/* Note: substate field has two bytes, if U8 is used the substate (e.g., 0x1000) will be narrowed to 0x00 : 2006-12-28 */
U32 oldsubstate = SIM(simServer)[0].substate;
kal_trace(TRACE_GROUP_1, BT_SIMAP_SIMSERVER_AVAILABLE_IN_SRVCALLBACK, oldsubstate);
/* Report(("Case1:In SimSrvCallback():SimServer is available again, and Simserver substate=%d",oldsubstate)); */
/*
* Check if this CLOSED Event is triggered due to receive MMI's DEACTIVATE_REQ in SimServer's CONNECT_PENDING state
* If SimServer has not yet send CONNECT_REQ to SIM task, this case is matched (No necessary to notify SIM task)
* The DEACTIVATE_CNF is returned here directly
* At that time, we call RF_CloseChannel() to trigger this event
*/
if (SIM(simServer)[0].substate & BT_APP_DEACTIVATE_REQ_RECV)
{
#if 0 // Reserved for MAUI
bt_simap_deactivate_cnf_struct *bt_simap_deactivate_cnf = construct_local_para(sizeof(bt_simap_deactivate_cnf_struct), TD_UL);
#endif
SIMAPCallbackParms parms;
/* Using this func to deregister rfcomm server channel and sdp record of SIM Access Profile */
Assert(SIM_DeregisterServer(Server) == BT_STATUS_SUCCESS);
/* Report(("This case is SimServer closed then RFCOMM closed due to MMI Deactivate Req, return Deactivate_CNF with ok")); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_SIMSRV_CLOSED_RFCOMM_CLOSED_DUE_TO_DEACTIVATE_REQ);
SIM(simServer)[0].simserver_activate_status = SIM_SERVER_STATUS_DEACTIVATED;
/* This means that SIM Access Profile connection is closed, check if conneciton_id is still allocated */
if (SIM(allocated_connect_id)[0] == KAL_TRUE)
{
BTBMProfileReleaseConnIndex(SIM(connect_id)[0]);
SIM(allocated_connect_id)[0] = KAL_FALSE;
/* Report(("Release SIM Acces Profile connect_id in Case 1")); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_RELEASE_SAP_CONID_CASE1);
}
#if 0 // Reserved for MAUI
bt_simap_deactivate_cnf->result = TRUE;
bt_send_msg(
MSG_ID_BT_SIMAP_DEACTIVATE_CNF,
MOD_MMI,
BT_APP_SAP,
(local_para_struct*) bt_simap_deactivate_cnf,
NULL);
#endif
parms.event = SIMAP_EVENT_DEACTIVATE_CNF;
parms.dstMod = MOD_MMI;
parms.p.simap_deactivate_cnf.result = TRUE;
SIMAPCB(&parms);
}
/*
* [MAUI_02129303]: As the AUTH_REQ is not responded by MMI & remote device close the RFCOMM channel (timed-out),
* we have to report this event to MMI to sync the status.
*/
else if (BT_MMI_AUTH_REQ_SENT == (SIM(simServer)[0].substate & BT_MMI_AUTH_REQ_SENT))
{
SIMAPCallbackParms parms;
btbm_bd_addr_t bd_addr;
btmtk_os_memset((kal_uint8*) & bd_addr, 0, sizeof(btbm_bd_addr_t));
CONVERT_ARRAY2BDADDR(&bd_addr, Server->remDev->bdAddr.addr);
parms.event = SIMAP_EVENT_AUTH_REQ_TIMEOUT_RFCLOSED_IND;
parms.dstMod = MOD_MMI;
parms.p.simap_auth_req_timeout_rfclose_ind.lap = bd_addr.lap;
parms.p.simap_auth_req_timeout_rfclose_ind.uap = bd_addr.uap;
parms.p.simap_auth_req_timeout_rfclose_ind.nap = bd_addr.nap;
SIMAPCB(&parms);
}
SIM(simServer)[0].substate = 0;
SIM(simServer)[0].available = TRUE;
if (SIM_SERVER_STATUS_DEACTIVATING == SIM(simServer)[0].simserver_activate_status)
{
/* Deactivate now.*/
bt_simap_deactivate_req_hdlr();
}
}
break;
case SAEVENT_SERVER_STATUS_REQ:
if (Parms->status == BT_STATUS_SUCCESS)
{
if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON)
{
statusChange = SIM_CARD_STATUS_RESET;
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
statusChange = SIM_CARD_STATUS_INSERTED;
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
statusChange = SIM_CARD_STATUS_REMOVED;
}
}
else if (Parms->status == BT_STATUS_FAILED)
{
statusChange = SIM_CARD_STATUS_NOT_ACCESSIBLE;
}
if ((status = SIM_ServerSendStatus(Server, statusChange)) != BT_STATUS_PENDING)
{
kal_trace(TRACE_GROUP_1, BT_SIMAP_FAILED_SEND_STATUS_IND_IN_SRVCALLBACK, status);
}
else
{
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_STATUS_IND_IN_SRVCALLBACK);
}
break;
case SAEVENT_SERVER_ATR_REQ:
//kal_trace(TRACE_GROUP_1, BT_SIMAP_SIMCARDREADER_STATUS, SIM(simServer)[0].current_simcardreader_status);
Report(("[BT SIMAP]current_simcardreader_status=0x%x", SIM(simServer)[0].current_simcardreader_status));
if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
result = SIM_RESULT_OK;
ptr = SIM(simServer)[0].atr.data;
len = SIM(simServer)[0].atr.dataLen;
}
else if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)
{
/* Alread off : This case is POWERED_OFF but CARD_PRESENT */
result = SIM_RESULT_CARD_ALREADY_OFF;
len = 0;
ptr = NULL;
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
/* No card inserted */
/* Note: it is impossible that POWERED_ON but CARD_NOT_PRESENT; so this is CARD_NOT_PRESENT case */
result = SIM_RESULT_CARD_REMOVED;
len = 0;
ptr = NULL;
}
status = SIM_ServerAtrRsp(Server, len, ptr, result);
kal_trace(TRACE_GROUP_1, BT_SIMAP_FAILED_SEND_ATR_RSP_IN_SRVCALLBACK, result, status);
if (status != BT_STATUS_SUCCESS)
{
status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel));
Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS));
}
break;
case SAEVENT_SERVER_APDU_REQ:
if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
if (SIM(simServer)[0].exec_mode == 0)
{
#ifdef __SIMAP_MAUI__
bt_sim_apdu_req_struct *apdu_req = NULL;
#else
SIMAPCallbackParms parms;
#endif
SIM(simServer)[0].substate |= BT_SIM_APDU_REQ_SENT;
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_APDU_TO_SIM_IN_SRVCALLBACK);
#ifdef __SIMAP_MAUI__
/* Send APDU request to SIM task */
apdu_req = construct_local_para(sizeof(bt_sim_apdu_req_struct), TD_UL);
apdu_req->apdu_req_len = Parms->ptrs.msg->parm.apdu.dataLen;
OS_MemSet(apdu_req->apdu_req, 0, APDU_REQ_MAX_LEN);
OS_MemCopy(apdu_req->apdu_req, Parms->ptrs.msg->parm.apdu.data, apdu_req->apdu_req_len);
apdu_req->transport_protocol_type = SIM(simServer)[0].current_transport_protocol_type;
bt_send_msg(MSG_ID_BT_SIM_APDU_REQ, MOD_SIM, PS_SIM_SAP, (local_para_struct*) apdu_req, NULL);
#else
parms.event = SIM_EVENT_APDU_REQ;
parms.dstMod = MOD_SIM;
parms.p.sim_apdu_req.apdu_req_len = Parms->ptrs.msg->parm.apdu.dataLen;
btmtk_os_memset(parms.p.sim_apdu_req.apdu_req, 0, APDU_REQ_MAX_LEN);
btmtk_os_memcpy(parms.p.sim_apdu_req.apdu_req, Parms->ptrs.msg->parm.apdu.data, parms.p.sim_apdu_req.apdu_req_len);
parms.p.sim_apdu_req.transport_protocol_type = SIM(simServer)[0].current_transport_protocol_type;
SIMAPCB(&parms);
#endif
}
#ifdef __SIMAP_UT_
else if (SIM(simServer)[0].exec_mode == 1)
{
bt_fakesim_apdu_req_hdlr(Parms->ptrs.msg->parm.apdu.dataLen, Parms->ptrs.msg->parm.apdu.data);
}
#endif /* __SIMAP_UT_ */
}
else if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)
{
/* Alread off : This case is POWERED_OFF but CARD_PRESENT */
result = SIM_RESULT_CARD_ALREADY_OFF;
ptr = NULL;
len = 0;
status = SIM_ServerApduRsp(&SIM(simServer)[0], len, ptr, result);
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_APDU_RSP_TO_CLIENT, result, status, 1);
if (status != BT_STATUS_SUCCESS)
{
status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel));
Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS));
}
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
/* No card inserted */
/* Note: it is impossible that POWERED_ON but CARD_NOT_PRESENT; so this is CARD_NOT_PRESENT case */
result = SIM_RESULT_CARD_REMOVED;
ptr = NULL;
len = 0;
status = SIM_ServerApduRsp(&SIM(simServer)[0], len, ptr, result);
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_APDU_RSP_TO_CLIENT, result, status, 2);
if (status != BT_STATUS_SUCCESS)
{
Assert(0);
}
}
break;
case SAEVENT_SERVER_SIM_OFF_REQ:
if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
/* In this case: must SIM_CRS_CARD_POWERED_ON and SIM_CRS_CARD_PRESENT are satisfied at the same time */
/* Send POWER_OFF_REQ to SIM task */
kal_trace(TRACE_GROUP_1, BT_SIM_SEND_POWER_OFF_TO_SIM_IN_SRVCALLBACK);
SIM(simServer)[0].substate |= BT_SIM_POWER_OFF_REQ_SENT;
if (SIM(simServer)[0].exec_mode == 0)
{
#ifdef __SIMAP_MAUI__
bt_send_msg(MSG_ID_BT_SIM_POWER_OFF_REQ, MOD_SIM, PS_SIM_SAP, NULL, NULL);
#else
SIMAPCallbackParms parms;
parms.event = SIM_EVENT_POWER_OFF_REQ;
parms.dstMod = MOD_SIM;
SIMAPCB(&parms);
#endif
}
#ifdef __SIMAP_UT_
else if (SIM(simServer)[0].exec_mode == 1)
{
bt_fakesim_poweroff_req_hdlr();
}
#endif /* __SIMAP_UT_ */
return;
}
else if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)
{
/* Alread off : This case is POWERED_OFF but CARD_PRESENT */
result = SIM_RESULT_CARD_ALREADY_OFF;
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
/* No card inserted */
/* Note: it is impossible that POWERED_ON but CARD_NOT_PRESENT; so this is CARD_NOT_PRESENT case */
result = SIM_RESULT_CARD_REMOVED;
}
/* Send POWER_OFF_RSP to client */
status = SIM_ServerSimOffRsp(Server, result);
kal_trace(TRACE_GROUP_1, BT_SIMAP_POWER_OFF_RSP_TO_CLIENT, result, status);
if (status != BT_STATUS_SUCCESS)
{
status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel));
Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS));
}
break;
case SAEVENT_SERVER_SIM_ON_REQ:
/* if current information is enough to return rsp, then sends rsp in this function */
/* POWE_ON_REQ only let client to request T at 0 (T=0) */
if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
result = SIM_RESULT_CARD_ALREADY_ON;
}
else if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)
{
/*
* Because SIM card is already off, so current_transport_protocol_type is invalid
* Set T=0 directly and send BT_SIM_RESET_REQ to sim task!
*/
if (SIM(simServer)[0].supported_transport_protocol_type_capability == 2 ||
SIM(simServer)[0].supported_transport_protocol_type_capability == 0)
{
SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT_POWER_ON;
if (SIM(simServer)[0].exec_mode == 0)
{
#ifdef __SIMAP_MAUI__
bt_sim_reset_req_struct *reset_req = NULL;
reset_req = construct_local_para(sizeof(bt_sim_reset_req_struct), TD_UL);
reset_req->transport_protocol_type = 0; /* default using T=0 transport protocol type */
bt_send_msg(
MSG_ID_BT_SIM_RESET_REQ,
MOD_SIM,
PS_SIM_SAP,
(local_para_struct*) reset_req,
NULL);
#else
SIMAPCallbackParms parms;
parms.event = SIM_EVENT_RESET_REQ;
parms.dstMod = MOD_SIM;
parms.p.sim_reset_req.transport_protocol_type = 0;
SIMAPCB(&parms);
#endif
}
#ifdef __SIMAP_UT_
else if (SIM(simServer)[0].exec_mode == 1)
{
bt_fakesim_poweron_req_hdlr();
}
#endif /* __SIMAP_UT_ */
return;
}
else if (SIM(simServer)[0].supported_transport_protocol_type_capability == 1)
{
/* SIM Card only supports T=1: RESET Error! because not support T=0, RESET_REQ uses T=0! */
result = SIM_RESULT_CARD_NOT_ACCESSIBLE;
}
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
/* Note: it is impossible that POWERED_ON but CARD_NOT_PRESENT; so this is CARD_NOT_PRESENT case */
result = SIM_RESULT_CARD_REMOVED;
}
else
{
kal_trace(TRACE_GROUP_1, BT_SIMAP_NO_RULES_PROCESS_SIM_ON_REQ_IN_SRVCALLBACK);
Assert(0);
}
/* Send SIM_POWER_ON_RSP to sim client with result code */
status = SIM_ServerSimOnRsp(Server, result);
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_POWER_ON_RSP_TO_CLIENT_IN_SRVCALLBACK, result, status);
if (status != BT_STATUS_SUCCESS)
{
status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel));
Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS));
}
break;
case SAEVENT_SERVER_SET_TRANS_PROT_REQ:
#if SET_T_SUPPORTED == TRUE
/* if current information is enough to return rsp, then sends rsp in this function */
/* Set Transport Protocol Type Req will ask to reset the SIM Card */
SIM(simServer)[0].client_requested_transport_protocol_type = Parms->ptrs.msg->parm.protocolId;
/* Report(("In SimSrvCallback(): client requested T type=%d",SIM(simServer)[0].client_requested_transport_protocol_type)); */
kal_trace(
TRACE_GROUP_1,
BT_SIMAP_CLIENT_REQ_T_TYPE,
SIM(simServer)[0].client_requested_transport_protocol_type);
if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
if (SIM(simServer)[0].supported_transport_protocol_type_capability == 2)
{
/* SIM Card supports both T=0 and T=1: Send BT_SIM_RESET_REQ msg to SIM task */
if (SIM(simServer)[0].current_transport_protocol_type != Parms->ptrs.msg->parm.protocolId)
{
Assert((SIM(simServer)[0].current_transport_protocol_type == 0) ||
(SIM(simServer)[0].current_transport_protocol_type == 1));
SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT_SET_T;
if (SIM(simServer)[0].exec_mode == 0)
{
#ifdef __SIMAP_MAUI__
bt_sim_reset_req_struct *reset_req = NULL;
reset_req = construct_local_para(sizeof(bt_sim_reset_req_struct), TD_UL);
reset_req->transport_protocol_type = Parms->ptrs.msg->parm.protocolId;
bt_send_msg(
MSG_ID_BT_SIM_RESET_REQ,
MOD_SIM,
PS_SIM_SAP,
(local_para_struct*) reset_req,
NULL);
#else
SIMAPCallbackParms parms;
parms.event = SIM_EVENT_RESET_REQ;
parms.dstMod = MOD_SIM;
parms.p.sim_reset_req.transport_protocol_type = Parms->ptrs.msg->parm.protocolId;
SIMAPCB(&parms);
#endif
}
#ifdef __SIMAP_UT_
else if (SIM(simServer)[0].exec_mode == 1)
{
bt_fakesim_set_transprotocol_type_req_hdlr();
}
#endif /* __SIMAP_UT_ */
return;
}
else
{
/* Requested T type is the same as current T type, send rsp to sim client directly */
SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT_SET_T;
result = SIM_RESULT_OK;
}
}
else if (SIM(simServer)[0].supported_transport_protocol_type_capability == 1 ||
SIM(simServer)[0].supported_transport_protocol_type_capability == 0)
{
/* In this case: SIM card only supports T=0 or T=1 and current_transport_protocol_type is equal to supported_transport_protocol_type_capability */
if (SIM(simServer)[0].current_transport_protocol_type != Parms->ptrs.msg->parm.protocolId)
{
/* Send REST_RSP with error code: Can't accessible to SIM Client */
/*
* In this case: Send SET_T_RSP first
* then in Open state PACKET_HANDLED EVENT: send STATUS_IND with card not accessible
*/
/* Report(("SET T=0/T=1 but only support T=1/T=0, Send SET_T_RSP first then STATUS_IND with card not accessible later")); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_SET_T0_T1_NOT_SUPPORT_T1_T0);
SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT_SET_T;
result = SIM_RESULT_NOT_SUPPORTED;
}
else
{
/* Requested T type is the same as current T type, send rsp to sim client directly */
result = SIM_RESULT_OK;
}
}
}
else if ((!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON)) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
result = SIM_RESULT_CARD_ALREADY_OFF;
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
result = SIM_RESULT_CARD_REMOVED;
}
#else /* SET_T_SUPPORTED == TRUE */
result = SIM_RESULT_NOT_SUPPORTED;
#endif /* SET_T_SUPPORTED == TRUE */
/* Send SIM_SET_TRANSPORT_PROTOCOL_TYPE_RSP to sim client with result code */
status = SIM_ServerSetTransProtRsp(Server, result);
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_SET_T_RSP_TO_CLIENT_IN_SRVCALLBACK, result, status);
if (status != BT_STATUS_SUCCESS)
{
Assert(0);
}
break;
case SAEVENT_SERVER_RESET_SIM_REQ:
/* if current information is enough to return rsp, then sends rsp in this function */
/* RESET_REQ only let client to request T at 0 (T=0) */
if ((SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_POWERED_ON) &&
(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
/*
* The original following state is wrong!
* Because as long as one bit (SIM_CRS_CARD_POWERED_ON or SIM_CRS_CARD_PRESENT) is set in current_simcardreader_status, condition is true!
* if((SIM(simServer)[0].current_simcardreader_status & (SIM_CRS_CARD_POWERED_ON | SIM_CRS_CARD_PRESENT)))
*/
/* In this case, must POWERED_ON and CARD_PRESERT are statisfied at the same time */
if (SIM(simServer)[0].supported_transport_protocol_type_capability == 2)
{
/* SIM Card supports both T=0 and T=1: Send BT_SIM_RESET_REQ msg to SIM task */
Assert((SIM(simServer)[0].current_transport_protocol_type == 0) ||
(SIM(simServer)[0].current_transport_protocol_type == 1));
SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT;
if (SIM(simServer)[0].exec_mode == 0)
{
#ifdef __SIMAP_MAUI__
bt_sim_reset_req_struct *reset_req = NULL;
reset_req = construct_local_para(sizeof(bt_sim_reset_req_struct), TD_UL);
reset_req->transport_protocol_type = 0; /* default using T=0 transport protocol type */
bt_send_msg(
MSG_ID_BT_SIM_RESET_REQ,
MOD_SIM,
PS_SIM_SAP,
(local_para_struct*) reset_req,
NULL);
#else
SIMAPCallbackParms parms;
parms.event = SIM_EVENT_RESET_REQ;
parms.dstMod = MOD_SIM;
parms.p.sim_reset_req.transport_protocol_type = 0;
SIMAPCB(&parms);
#endif
}
#ifdef __SIMAP_UT_
else if (SIM(simServer)[0].exec_mode == 1)
{
bt_fakesim_reset_req_hdlr();
}
#endif /* __SIMAP_UT_ */
return;
}
else if (SIM(simServer)[0].supported_transport_protocol_type_capability == 1)
{
/* SIM Card only supports T=1: RESET Error! because not support T=0, RESET_REQ uses T=0! */
Assert(SIM(simServer)[0].supported_transport_protocol_type_capability == SIM(simServer)[0].current_transport_protocol_type);
/* Send REST_RSP with error code: Can't accessible to SIM Client */
result = SIM_RESULT_CARD_NOT_ACCESSIBLE;
}
else if (SIM(simServer)[0].supported_transport_protocol_type_capability == 0)
{
/* SIM Card only supports T=0: Send BT_SIM_RESET_REQ msg to SIM task */
Assert(SIM(simServer)[0].supported_transport_protocol_type_capability == SIM(simServer)[0].current_transport_protocol_type);
SIM(simServer)[0].substate |= BT_SIM_RESET_REQ_SENT;
if (SIM(simServer)[0].exec_mode == 0)
{
#ifdef __SIMAP_MAUI__
bt_sim_reset_req_struct *reset_req = NULL;
reset_req = construct_local_para(sizeof(bt_sim_reset_req_struct), TD_UL);
reset_req->transport_protocol_type = 0; /* default using T=0 transport protocol type */
bt_send_msg(
MSG_ID_BT_SIM_RESET_REQ,
MOD_SIM,
PS_SIM_SAP,
(local_para_struct*) reset_req,
NULL);
#else
SIMAPCallbackParms parms;
parms.event = SIM_EVENT_RESET_REQ;
parms.dstMod = MOD_SIM;
parms.p.sim_reset_req.transport_protocol_type = 0;
SIMAPCB(&parms);
#endif
}
#ifdef __SIMAP_UT_
else if (SIM(simServer)[0].exec_mode == 1)
{
bt_fakesim_reset_req_hdlr();
}
#endif /* __SIMAP_UT_ */
return;
}
}
else if (SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT)
{
/* This case is SIM_CRS_CARD_PRESENT(0x40) with SIM_CRS_CARD_POWERED_OFF(0x00) */
/* Send REST_RSP with error code: Card powered off to SIM Client */
result = SIM_RESULT_CARD_ALREADY_OFF;
}
else if (!(SIM(simServer)[0].current_simcardreader_status & SIM_CRS_CARD_PRESENT))
{
/* Send REST_RSP with error code: Card Removed to SIM Client */
/* Note: it is impossible that POWERED_ON but CRS_NOT_PRESENT case, so this is CARD_NOT_PRESENT case */
result = SIM_RESULT_CARD_REMOVED;
}
else
{
kal_trace(TRACE_GROUP_1, BT_SIMAP_NO_RULES_PROCESS_RESET_REQ_IN_SRVCALLBACK);
Assert(0);
}
/* Send SIM_RESET_RSP to sim client with result code */
status = SIM_ServerResetSimRsp(Server, result);
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_RESET_RSP_TO_CLIENT_IN_SRVCALLBACK, result, status);
if (status != BT_STATUS_SUCCESS)
{
status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel));
Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS));
}
break;
case SAEVENT_SERVER_CARD_READER_STATUS_REQ:
cardRdrStatus = SIM(simServer)[0].current_simcardreader_status;
status = SIM_ServerCardReaderStatusRsp(Server, cardRdrStatus, SIM_RESULT_OK);
kal_trace(TRACE_GROUP_1, BT_SIMAP_SEND_CARD_RDS_RSP_TO_CLIENT_IN_SRVCALLBACK, result, status);
if (status != BT_STATUS_SUCCESS)
{
status = SimApCloseRFCommChnl(&(SIM(simServer)[0].rfChannel));
Assert((status == BT_STATUS_PENDING) || (status == BT_STATUS_IN_PROGRESS));
}
break;
case SAEVENT_SERVER_STATUS_SENT:
kal_trace(TRACE_GROUP_1, BT_SIMAP_STATUS_IND_SENT_IN_SRVCALLBACK, Parms->status);
/* Note that the STATUS_SENT Event may be failed, handle this case here */
if (Parms->status != BT_STATUS_SUCCESS)
{
if (Server->state == SIM_SERVER_STATE_CONN_PENDING)
{
/* In CONNECT_PENDING state, this means that STATUS_IND(with reset) is sent failed */
/* Close this SIM Access Profile connection */
/* Return value from RF_CloseChannel() may be BT_STATUS_IN_PROGRRESS(presenting rfchannel state is DLC_STATE_DISC_PENDING) */
status = SimApCloseRFCommChnl(&(Server->rfChannel));
if ((status != BT_STATUS_PENDING) && (status != BT_STATUS_IN_PROGRESS) && (status != BT_STATUS_SUCCESS))
{
/* Report(("SERVER_STATUS_SENT and RF_CloseChannel err, status=%d",status)); */
kal_trace(TRACE_GROUP_1, BT_SIMAP_SHOW_ONE_BYTE, status);
Assert(0);
}
}
else if (Server->state == SIM_SERVER_STATE_OPEN)
{ /* Ignore it */
}
else
{
/* Send STATUS_IND in wrong SimServer's state and send this event fail */
Assert(0);
}
}
break;
}
}
static void mmi_widget_send_notify_content_update_response(int instance_id, void *view_handle)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
widget_notify_content_update_cnf_struct *p = (widget_notify_content_update_cnf_struct*) construct_local_para(
sizeof(widget_notify_content_update_cnf_struct),
TD_RESET);
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
p->instance_id = instance_id;
p->view_handle = view_handle;
send_message(p, NULL, MSG_ID_WIDGET_NOTIFY_CONTENT_UPDATE_CNF, MOD_GADGET);
}
/*****************************************************************************
* FUNCTION
* mmi_syncml_start_sync_req
* DESCRIPTION
* Protocol event handler
* PARAMETERS
* info [IN] message content
* RETURNS
* void
*****************************************************************************/
void mmi_syncml_start_sync_req(U8 *imei)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
MYQUEUE Message;
mmi_syncml_start_sync_req_struct *dataPtr;
syncml_profile_struct active_profile;
applib_mime_type_struct *mime;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
mmi_syncml_read_profile_from_nvram(g_syncml_context.active_profile, &active_profile);
Message.oslSrcId = MOD_MMI;
Message.oslDestId = MOD_SYNCML;
Message.oslMsgId = MSG_ID_MMI_SYNCML_START_SYNC_REQ;
dataPtr =
(mmi_syncml_start_sync_req_struct*) construct_local_para(sizeof(mmi_syncml_start_sync_req_struct), TD_CTRL|TD_RESET);
strcpy((S8*) dataPtr->server_uri, (S8*) active_profile.server_address);
strcpy((S8*) dataPtr->server_username, (S8*) active_profile.server_username);
strcpy((S8*) dataPtr->server_password, (S8*) active_profile.server_password);
if (g_syncml_context.applications_to_sync & SYNCML_DB_PHONEBOOK)
{
strcpy((S8*) dataPtr->contact_database_uri, (S8*) active_profile.contact_address);
strcpy((S8*) dataPtr->contact_database_username, (S8*) active_profile.contact_username);
strcpy((S8*) dataPtr->contact_database_password, (S8*) active_profile.contact_password);
mime = mime_type_look_up(NULL, NULL, 0, MIME_SUBTYPE_XVCARD);
strcpy((S8*) dataPtr->contact_mime_type, mime->mime_string);
dataPtr->contact_last_anchor = g_syncml_context.last_phb_anchor[g_syncml_context.active_profile - 1];
dataPtr->contact_next_anchor = g_syncml_context.next_phb_anchor;
#ifdef __MMI_SYNCML_SERVER_ALERT_SYNC_SUPPORT__
if (mmi_syncml_is_sync_started_from_server())
{
/* replace the database URI by the specified one */
strcpy((S8*) dataPtr->contact_database_uri, (S8*) g_sas_context.sas_contact_database_uri);
}
#endif /* __MMI_SYNCML_SERVER_ALERT_SYNC_SUPPORT__ */
g_syncml_context.contact_sync_state = 1; /* synchronizing */
}
dataPtr->contact_free_id = MAX_PB_PHONE_ENTRIES - mmi_phb_get_phone_index_arrary(NULL);
dataPtr->contact_free_mem = dataPtr->contact_free_id * mmi_phb_sync_get_record_size();
if (g_syncml_context.applications_to_sync & SYNCML_DB_TODOLIST)
{
strcpy((S8*) dataPtr->calendar_database_uri, (S8*) active_profile.calendar_address);
strcpy((S8*) dataPtr->calendar_database_username, (S8*) active_profile.calendar_username);
strcpy((S8*) dataPtr->calendar_database_password, (S8*) active_profile.calendar_password);
mime = mime_type_look_up(NULL, NULL, 0, MIME_SUBTYPE_XVCALENDAR);
strcpy((S8*) dataPtr->calendar_mime_type, mime->mime_string);
dataPtr->calendar_last_anchor = g_syncml_context.last_tdl_anchor[g_syncml_context.active_profile - 1];
dataPtr->calendar_next_anchor = g_syncml_context.next_tdl_anchor;
#ifdef __MMI_SYNCML_SERVER_ALERT_SYNC_SUPPORT__
if (mmi_syncml_is_sync_started_from_server())
{
/* replace the database URI by the specified one */
strcpy((S8*) dataPtr->calendar_database_uri, (S8*) g_sas_context.sas_calendar_database_uri);
}
#endif /* __MMI_SYNCML_SERVER_ALERT_SYNC_SUPPORT__ */
g_syncml_context.calendar_sync_state = 1; /* synchronizing */
AlmDisableExpiryHandler(); /* disable alarm */
}
dataPtr->calendar_free_id = NUM_OF_TDL - mmi_tdl_get_total_index(NULL);
dataPtr->calendar_free_mem = dataPtr->calendar_free_id * NVRAM_TODO_LIST_RECORD_SIZE;
memcpy(&dataPtr->imei[0], "IMEI:", 5);
memcpy(&dataPtr->imei[5], imei, 15);
dataPtr->imei[20] = 0;
#ifdef __MMI_SYNCML_REFRESH_SYNC_SUPPORT__
if (g_syncml_context.sync_type == SYNCML_TYPE_BACKUP)
{
dataPtr->sync_type = SYNCML_SYNC_CLIENT_ONE_WAY_REFRESH;
}
else if (g_syncml_context.sync_type == SYNCML_TYPE_RESTORE)
{
dataPtr->sync_type = SYNCML_SYNC_SERVER_ONE_WAY_REFRESH;
}
else if (g_syncml_context.sync_type == SYNCML_TYPE_EXPORT)
{
dataPtr->sync_type = SYNCML_SYNC_CLIENT_ONE_WAY_SYNC;
}
else if (g_syncml_context.sync_type == SYNCML_TYPE_IMPORT)
{
dataPtr->sync_type = SYNCML_SYNC_SERVER_ONE_WAY_SYNC;
}
else
{
dataPtr->sync_type = SYNCML_SYNC_TWO_WAY_SYNC;
}
#else
dataPtr->sync_type = SYNCML_SYNC_TWO_WAY_SYNC;
#endif /* __MMI_SYNCML_REFRESH_SYNC_SUPPORT__ */
if (g_syncml_context.active_profile > MAX_SYNCML_SV_PROFILES)
{
dataPtr->transport_type = SYNCML_TRANS_USB + active_profile.net_id;
}
else
{
dataPtr->transport_type = (active_profile.conn_type == SYNCML_TRANS_HTTP) ? SYNCML_TRANS_HTTP : SYNCML_TRANS_WSP;
dataPtr->net_id = active_profile.net_id;
if (active_profile.use_proxy)
{
memcpy(dataPtr->proxy_server_ip, active_profile.proxy_ip, 4);
dataPtr->proxy_server_port = (active_profile.conn_type == SYNCML_TRANS_HTTP) ? active_profile.proxy_port : 9201;
strcpy((S8*) dataPtr->proxy_username, (S8*) active_profile.proxy_username);
strcpy((S8*) dataPtr->proxy_password, (S8*) active_profile.proxy_password);
}
else
{
memset(dataPtr->proxy_server_ip, 0, 4);
dataPtr->proxy_server_port = 0;
memset(dataPtr->proxy_username, 0, MAX_SYNCML_PROXY_USERNAME);
memset(dataPtr->proxy_password, 0, MAX_SYNCML_PROXY_PASSWORD);
}
}
g_syncml_context.abort_state = 0;
Message.oslDataPtr = (oslParaType*) dataPtr;
Message.oslPeerBuffPtr = NULL;
OslMsgSendExtQueue(&Message);
}
/*****************************************************************************
* FUNCTION
* l4c_root_sim_support_mode_req
* DESCRIPTION
* link_SML
* PARAMETERS
* src_id [IN]
* mode [IN] bitmap for SIM power-on mode
* RETURNS
* void
*****************************************************************************/
kal_bool l4c_root_lock_status_ind(kal_uint8 src_id)
{
l4c_root_context_struct *l4c_root_ptr = L4C_ROOT_PTR;
kal_bool need_unlock = KAL_FALSE;
kal_uint8 i;
l4csmu_security_req_struct *param_ptr;
module_type temp_mod = l4c_current_mod_id;
smu_pending_password_id_enum pending_password = l4csmu_get_pending_password_id();
kal_uint8 need_unlock_table[L4_MAX_SIM_NUM]; //represents the actual SIM id
kal_bool notify_mmi = KAL_TRUE;
#ifdef __GEMINI_3G_SWITCH__
kal_uint8 sim_id = L4C_PTR->cur_3g_switch_map;
L4C_COMM_PTR->c3gs_ref_flag = KAL_TRUE;
#else
kal_uint8 sim_id = l4c_current_mod_id - MOD_L4C;
#endif
kal_mem_set(need_unlock_table, 0, L4_MAX_SIM_NUM);
if (src_id != L4C_SRC)
{
need_unlock = custom_l4c_root_lock_verify(sim_id,
pending_password,
l4c_root_ptr->root_pending_password,
need_unlock_table);
}
if (need_unlock == KAL_TRUE)
{
for (i=0; i<L4_MAX_SIM_NUM; i++)
{
sim_id = l4c_gemini_get_actual_sim_id(i);
pending_password = l4csmu_get_pending_password_id_ext((sim_interface_enum)i);
kal_brief_trace(TRACE_INFO, INFO_L4C_ROOT_PENDING_PASSWD, sim_id,
l4c_root_ptr->root_pending_password[sim_id], need_unlock_table[sim_id]);
if (need_unlock_table[sim_id] != 0)
{
if (i == (l4c_current_mod_id-MOD_L4C))
{
notify_mmi = KAL_FALSE;
}
layer4_module_context_selection(MOD_L4C+i);
param_ptr = (l4csmu_security_req_struct*)
construct_local_para((kal_uint16) sizeof(l4csmu_security_req_struct), TD_RESET);
if (l4csmu_get_pending_lock(pending_password, &(param_ptr->type)) == KAL_FALSE)
{
continue;
}
param_ptr->src_id = L4C_SRC;
param_ptr->op = SUPER_VERIFY;
l4c_send_msg_to_smu(MSG_ID_L4CSMU_SECURITY_REQ, param_ptr);
}
}
layer4_module_context_selection(temp_mod);
}
return notify_mmi;
}
/*****************************************************************************
* FUNCTION
* aud_media_play_by_id_req_hdlr
* DESCRIPTION
*
* PARAMETERS
* ilm_ptr [?]
* RETURNS
* void
*****************************************************************************/
void aud_media_play_by_id_req_hdlr(ilm_struct *ilm_ptr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint8 audio_id;
kal_uint8 audio_out_device;
kal_uint8 volume;
media_aud_play_by_id_req_struct *req_p = (media_aud_play_by_id_req_struct*) ilm_ptr->local_para_ptr;
media_aud_play_by_id_cnf_struct *cnf_p = NULL;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
audio_id = req_p->audio_id;
if (req_p->output_path == AUDIO_DEVICE_SPEAKER2)
{
/* Use default configuration */
aud_cfg_audio_out_device(audio_id, &audio_out_device);
}
else
{
/* Use user-specified path */
audio_out_device = req_p->output_path;
}
if (audio_id <= TONE_KEY_CLICK)
{
aud_keytone_stop();
/* Update keytone volume */
volume = aud_get_volume_gain(aud_context_p->audio_mode, AUD_VOLUME_KEY, req_p->volume);
aud_keytone_set_output_volume(volume, 0);
aud_keytone_play(audio_id, audio_out_device, req_p->play_style);
}
else if ((audio_id > TONE_KEY_CLICK) && (audio_id <= MAX_TONE_ID))
{
/* if keytone is playing, stop it */
aud_keytone_stop();
if (req_p->play_style == DEVICE_AUDIO_PLAY_INFINITE)
{
aud_context_p->tone_playing = KAL_TRUE;
}
/* Update tone volume */
volume = aud_get_volume_gain(aud_context_p->audio_mode, AUD_VOLUME_CTN, req_p->volume);
aud_tone_set_output_volume(volume, 0);
aud_tone_play(audio_id, audio_out_device);
}
cnf_p = (media_aud_play_by_id_cnf_struct*)
construct_local_para(sizeof(media_aud_play_by_id_cnf_struct), TD_CTRL);
cnf_p->result = MED_RES_OK;
aud_send_ilm(ilm_ptr->src_mod_id, MSG_ID_MEDIA_AUD_PLAY_BY_ID_CNF, cnf_p, NULL);
}
