VMINT vm_preload_cancel(VMINT hdl)
{
vm_preload_ctx_t * ctx_p = NULL;
VMINT bufSize = 0;
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3068 );
if (vm_res_get_data(VM_RES_TYPE_PRELOAD,
hdl, (void**)&ctx_p, &bufSize) == 0 && ctx_p != NULL)
{
vm_common_t common = {E_PRELOAD_ABORT, NULL};
common.user_data = ctx_p->user_data;
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_PRELOAD_S, 2, __LINE__);
PRELOAD_PMNG_WRAP_CALLBACK(ctx_p->p_hdl,
ctx_p->cb, ctx_p->res_id, (void*)&common);
//_vm_preload_clean(ctx_p);
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_PRELOAD_E, 2, __LINE__);
_vm_preload_free_ctx(ctx_p);
}
if (NULL == ctx_p)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3075 );
return -2;
}
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3081 );
return 0;
}
/* SPP SERVER USING START*/
VMINT vm_btspp_bind(VMINT res_hd, VMUINT16 uuid)
{
vm_btspp_context_t * ctx_p = NULL;
VMINT buf_size = 0;
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_628 );
// TODO:
/*
if (0 == uuid)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_634 );
return VM_BT_SPP_ERR_BAD_PARAM;
}
*/
if ((0 != vm_res_get_data(VM_RES_TYPE_BTSPP,
res_hd, (void**)&ctx_p, &buf_size)) || NULL == ctx_p)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_642 );
return VM_BT_SPP_ERR_BAD_PARAM;
}
srv_spp_bind((SppHandle)ctx_p->srv_hd, (U32)uuid);
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_648 );
return VM_BT_SPP_ERR_SUCCESS;
}
static void vm_preload_free_resource(VM_P_HANDLE process_handle)
{
VMINT resHandle = 0, bufSize = 0;
vm_preload_ctx_t * ctx_p = NULL;
while ((resHandle = vm_res_findfirst(process_handle, VM_RES_TYPE_PRELOAD))
!= VM_RES_NOT_FIND)
{
if (vm_res_get_data(VM_RES_TYPE_PRELOAD,
resHandle, (void**)&ctx_p, &bufSize) == 0 && ctx_p != NULL)
{
if (ctx_p)
{
//_vm_preload_clean(ctx_p);
vm_common_t common = {E_PRELOAD_ABORT, NULL};
common.user_data = ctx_p->user_data;
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_PRELOAD_S, 1, __LINE__);
PRELOAD_PMNG_WRAP_CALLBACK(ctx_p->p_hdl,
ctx_p->cb, ctx_p->res_id, (void*)&common);
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_PRELOAD_E, 1, __LINE__);
_vm_preload_free_ctx(ctx_p);
}
}
else
{
}
vm_res_release_data(VM_RES_TYPE_PRELOAD, resHandle);
vm_res_findclose(VM_RES_TYPE_PRELOAD);
}
}
VMINT vm_btspp_set_security_level(VMINT res_hd, VMINT level)
{
vm_btspp_context_t * ctx_p = NULL;
VMINT buf_size = 0;
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_571 );
// TODO:
/*
if (0 == level)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_577 );
return VM_BT_SPP_ERR_BAD_PARAM;
}
*/
if ((0 != vm_res_get_data(VM_RES_TYPE_BTSPP,
res_hd, (void**)&ctx_p, &buf_size)) || NULL == ctx_p)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_584 );
return VM_BT_SPP_ERR_BAD_PARAM;
}
srv_spp_set_security_level((SppHandle)ctx_p->srv_hd, (SppSecurityLevel)level);
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_590 );
return VM_BT_SPP_ERR_SUCCESS;
}
VMINT vm_btspp_accept(VMINT conn_id,
void * buf,
VMUINT tx_size,
VMUINT rx_size
)
{
vm_btspp_context_t * ctx_p = NULL;
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_661 );
if (NULL == buf || 0 == tx_size || 0 == rx_size)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_665 );
return VM_BT_SPP_ERR_BAD_PARAM;
}
ctx_p = vm_btspp_get_ctx(conn_id, 1);
if (NULL == ctx_p)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_672 );
return VM_BT_SPP_ERR_BAD_PARAM;
}
srv_spp_accept((S32)conn_id, buf, (U32)tx_size, (U32)rx_size);
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_678 );
return VM_BT_SPP_ERR_SUCCESS;
}
void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
{
VMUINT8 data_out[16];
STCHE *md5_ctx_p=NULL;
VMINT res_id;
md5_ctx_p=vm_get_cheinfo_from_processid(vm_pmng_get_current_handle(),&res_id);
if (md5_ctx_p)
{
if (pms && data && (nbytes>=0))
{
che_process(md5_ctx_p, CHE_MD5, CHE_MODE_NULL, CHE_HASH, (VMUINT8*)data, data_out, nbytes,KAL_FALSE);
}
else
{
MMI_TRACE(MMI_MRE_TRC_ERROR, TRC_MRE_VMMD5_247 );
}
}
else
{
MMI_TRACE(MMI_MRE_TRC_ERROR, TRC_MRE_VMMD5_250 );
}
}
VMINT vm_btspp_get_dev_addr(VMINT conn_id, vm_srv_bt_cm_bt_addr * bt_addr)
{
vm_btspp_context_t * ctx_p = NULL;
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_544 );
if (NULL == bt_addr)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_548 );
return VM_BT_SPP_ERR_BAD_PARAM;
}
ctx_p = vm_btspp_get_ctx(conn_id, 1);
if (NULL == ctx_p)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_555 );
return VM_BT_SPP_ERR_BAD_PARAM;
}
srv_spp_get_dev_addr((U32)conn_id, (srv_bt_cm_bt_addr *)bt_addr);
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_561 );
return VM_BT_SPP_ERR_SUCCESS;
}
VMINT vm_btspp_connect_ex(VMINT res_hd,
const vm_srv_bt_cm_bt_addr * bt_addr,
void * buf,
VMUINT tx_size,
VMUINT rx_size,
vm_srv_spp_connect_type conn_type,
VMUINT16 uuid)
{
vm_btspp_context_t * ctx_p = NULL;
VMINT buf_size = 0;
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_753 );
if (NULL == bt_addr ||
NULL == buf ||
(SRV_SPP_MIN_BUFF_SIZE / 2) < tx_size ||
(SRV_SPP_MIN_BUFF_SIZE / 2) < rx_size)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_760 );
return VM_BT_SPP_ERR_BAD_PARAM;
}
if ((0 != vm_res_get_data(VM_RES_TYPE_BTSPP,
res_hd, (void**)&ctx_p, &buf_size)) || NULL == ctx_p)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_767 );
return VM_BT_SPP_ERR_BAD_PARAM;
}
srv_spp_connect_ex((SppHandle)ctx_p->srv_hd, (U32)uuid, (srv_bt_cm_bt_addr *)bt_addr, buf, (U32)tx_size, (U32)rx_size, (srv_spp_connect_type)conn_type);
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_773 );
return VM_BT_SPP_ERR_SUCCESS;
}
VMINT vm_tls_shutdown(VMINT res_id)
{
kal_int32 ret;
vm_tls_context_t * ctx_p = NULL;
MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_S, 5, __LINE__);
ctx_p = vm_tls_get_ctx_by_res(res_id);
if (NULL == ctx_p)
{
MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_E1, 5, __LINE__);
return VM_TLS_RET_BASE -2;
}
ret = tls_shutdown(ctx_p->soc_id);
if (TLS_ERR_NONE != ret)
{
MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_E2, 5, ret);
return ret;
}
MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_S, 5, ret);
return ret;
}
VMINT vm_btspp_read(VMUINT conn_id, void * buf, VMUINT size)
{
vm_btspp_context_t * ctx_p = NULL;
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_520 );
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_LOG,
conn_id,
size,
4, __LINE__ );
if (NULL == buf || 0 == size)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_524 );
return VM_BT_SPP_ERR_BAD_PARAM;
}
ctx_p = vm_btspp_get_ctx(conn_id, 1);
if (NULL == ctx_p)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_531 );
return VM_BT_SPP_ERR_BAD_PARAM;
}
return (VMINT)srv_spp_read((U32)conn_id, buf, (U32)size);
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_537 );
}
VMINT vm_tls_delete_ctx(VMINT res_id)
{
kal_int32 ret;
vm_tls_context_t * ctx_p = NULL;
MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_S, 21, __LINE__);
ctx_p = vm_tls_get_ctx_by_res(res_id);
if (NULL == ctx_p)
{
MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_E1, 21, __LINE__);
return VM_TLS_RET_BASE -2;
}
ret = tls_delete_ctx(ctx_p->tls_ctx);
vm_tls_free_ctx(ctx_p);
if (0 == --g_ref_count)
{
mmi_frm_clear_protocol_event_handler(MSG_ID_APP_SOC_NOTIFY_IND, (PsIntFuncPtr)vm_tls_notify_cb);
mmi_frm_clear_protocol_event_handler(MSG_ID_APP_TLS_NOTIFY_IND, (PsIntFuncPtr)vm_tls_notify_ind);
mmi_frm_clear_protocol_event_handler(MSG_ID_APP_TLS_ALERT_IND, (PsIntFuncPtr)vm_tls_alert_ind);
mmi_frm_clear_protocol_event_handler(MSG_ID_APP_TLS_INVALID_CERT_IND, (PsIntFuncPtr)vm_tls_invalid_cert_ind);
mmi_frm_clear_protocol_event_handler(MSG_ID_APP_TLS_CLIENT_AUTH_IND, (PsIntFuncPtr)vm_tls_client_auth_ind);
MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_E2, 21, __LINE__);
}
MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_E, 21, ret);
return ret;
}
void md5_finish(md5_state_t *pms, md5_byte_t digest[16])
{
STCHE *md5_ctx_p=NULL;
VMINT res_id;
md5_ctx_p=vm_get_cheinfo_from_processid(vm_pmng_get_current_handle(),&res_id);
if (md5_ctx_p)
{
if (pms && digest )
{
che_process(md5_ctx_p, CHE_MD5, CHE_MODE_NULL, CHE_HASH, NULL, digest, 0, KAL_TRUE);
che_deinit(md5_ctx_p);
}
else
{
MMI_TRACE(MMI_MRE_TRC_ERROR, TRC_MRE_VMMD5_274 );
}
vm_free(md5_ctx_p);
md5_ctx_p=NULL;
vm_res_release_data(VM_RES_TYPE_MD5,res_id);
}
else
{
MMI_TRACE(MMI_MRE_TRC_ERROR, TRC_MRE_VMMD5_282 );
}
}
VMINT vm_common_ui_cancel(VMINT common_ui_id)
{
VMINT res_node_size = 0;
vm_common_ui_res_struct *res_p = NULL;
VM_P_HANDLE phandle = -1;
VM_P_HANDLE curr_phandle = vm_pmng_get_app_handle();
VMINT grp_id;
if ((phandle = vm_res_get_process_handle(VM_RES_TYPE_COMMON_UI, common_ui_id)) < 0)
{
MMI_TRACE(MMI_MRE_TRC_MOD_COMMONUI, TRC_MRE_COMMON_UI_CANCEL_GET_PRO_FAIL, common_ui_id);
return VM_COMMON_UI_ERROR_INVALID_ID;
}
if (curr_phandle > 0) /* app, not engine */
{
if (phandle != curr_phandle) /* application A can not cancel alarm belongs to application B */
{
MMI_TRACE(MMI_MRE_TRC_MOD_COMMONUI, TRC_MRE_COMMON_UI_CANCEL_FROM_OTHER_PROCESS, phandle, curr_phandle);
return VM_COMMON_UI_ERROR_OF_PROCESS;
}
}
if (vm_res_get_data(VM_RES_TYPE_COMMON_UI, common_ui_id, (void **)&res_p, &res_node_size) < VM_RES_OK)
{
MMI_TRACE(MMI_MRE_TRC_MOD_COMMONUI, TRC_MRE_COMMON_UI_CANCEL_GET_RES_FAIL, common_ui_id);
return VM_COMMON_UI_ERROR;
}
grp_id = res_p->grp_id;
vm_nmgr_confirm_popup_cancel(grp_id);
return VM_COMMON_UI_OK;
}
VMINT vm_btspp_set_service_name(VMINT res_hd, VMWCHAR * name)
{
vm_btspp_context_t * ctx_p = NULL;
VMINT buf_size = 0;
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_600 );
if (NULL == name)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_604 );
return VM_BT_SPP_ERR_BAD_PARAM;
}
if ((0 != vm_res_get_data(VM_RES_TYPE_BTSPP,
res_hd, (void**)&ctx_p, &buf_size)) || NULL == ctx_p)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_611 );
return VM_BT_SPP_ERR_BAD_PARAM;
}
srv_spp_set_service_name((SppHandle)ctx_p->srv_hd, (WCHAR *)name);
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_617 );
return VM_BT_SPP_ERR_SUCCESS;
}
static MMI_BOOL vm_tls_notify_cb(void *msg)
{
app_soc_notify_ind_struct* ind = (app_soc_notify_ind_struct*)msg;
vm_tls_context_t * ctx_p = NULL;
vm_tls_soc_notify_ind_struct cb_data = {0};
MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_S, 26, __LINE__);
if (NULL == ind)
{
MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_E1, 26, __LINE__);
return MMI_FALSE;
}
ctx_p = vm_tls_get_ctx_by_soc(ind->socket_id);
if (NULL == ctx_p)
{
MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_E2, 26, __LINE__);
return MMI_FALSE;
}
cb_data.msg = VM_MSG_ID_APP_SOC_NOTIFY_IND;
cb_data.res_id = ctx_p->res_id;
cb_data.soc_id = ctx_p->soc_id;
cb_data.event_type = (VMINT)ind->event_type;
cb_data.result = (VMINT)ind->result;
cb_data.error_cause = (VMINT)ind->error_cause;
cb_data.detail_cause = (VMINT)ind->detail_cause;
MMI_TRACE(TRACE_GROUP_8, TRC_MRE_DLS_LOG,
cb_data.res_id,
cb_data.soc_id,
cb_data.event_type,
cb_data.result,
cb_data.error_cause,
cb_data.detail_cause,
26, __LINE__);
PMNG_WRAP_CALLBACK(ctx_p->p_hdl,
(ctx_p->cb)((vm_tls_event_struct*)&cb_data));
switch (ind->event_type)
{
case SOC_WRITE:
{}break;
case SOC_READ:
{}break;
case SOC_CONNECT:
{
//tls_handshake(ind->socket_id);
}break;
case SOC_CLOSE:
{}break;
}
MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_E, 26, __LINE__);
return MMI_TRUE;
}
/*****************************************************************************
* FUNCTION
* srv_callset_is_available
* DESCRIPTION
* to check if sim-related call setting service is available
* PARAMETERS
* sim : [IN] target sim
* RETURNS
* MMI_TRUE if the specific sim-related call setting service is available
*****************************************************************************/
MMI_BOOL srv_callset_is_available(mmi_sim_enum sim)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
srv_mode_switch_type_enum usable_side;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (!srv_mode_switch_is_network_service_available())
{
MMI_TRACE(MMI_COMMON_TRC_G5_CALL, TRC_SRV_CALLSET_IS_AVAILABLE, sim, MMI_FALSE, 1);
return MMI_FALSE;
}
usable_side = srv_mode_switch_get_current_mode();
/* check sim mode setting */
if (!(usable_side & sim))
{
MMI_TRACE(MMI_COMMON_TRC_G5_CALL, TRC_SRV_CALLSET_IS_AVAILABLE, sim, MMI_FALSE, 3);
return MMI_FALSE;
}
/* check sim status */
if (!srv_sim_ctrl_is_available(sim))
{
MMI_TRACE(MMI_COMMON_TRC_G5_CALL, TRC_SRV_CALLSET_IS_AVAILABLE, sim, MMI_FALSE, 4);
return MMI_FALSE;
}
if (
#ifdef __MMI_CALLSET_CALLER_ID__
srv_callset_is_caller_id_supported(sim) ||
#endif /* __MMI_CALLSET_CALLER_ID__ */
srv_ss_check_capability(sim, SRV_SS_ACT_CALL_WAIT, 0, SRV_SS_ALL_CALL) ||
srv_ss_check_capability(sim, SRV_SS_ACT_CALL_FORWARD, SRV_SS_CALL_FORWARD_CFALL, SRV_SS_ALL_CALL) ||
srv_ss_check_capability(sim, SRV_SS_ACT_CALL_BAR, SRV_SS_CALL_BAR_BAC, SRV_SS_ALL_CALL) ||
srv_callset_is_line_switch_supported(sim) ||
#ifdef __MMI_CALLSET_CUG__
srv_callset_is_cug_supported(sim) ||
#endif /* __MMI_CALLSET_CUG__ */
MMI_FALSE
)
{
MMI_TRACE(MMI_COMMON_TRC_G5_CALL, TRC_SRV_CALLSET_IS_AVAILABLE, sim, MMI_TRUE, 1);
return MMI_TRUE;
}
else
{
MMI_TRACE(MMI_COMMON_TRC_G5_CALL, TRC_SRV_CALLSET_IS_AVAILABLE, sim, MMI_FALSE, 6);
return MMI_FALSE;
}
}
/*****************************************************************************
* FUNCTION
* srv_ctm_act_req
* DESCRIPTION
* CTM action request
* PARAMETERS
* opcode : [IN] request opcode
* info : [IN] parameter for request
* callback : [IN] callback function pointer
* RETURNS
* void
*****************************************************************************/
void srv_ctm_act_req(srv_ctm_act_op_enum opcode, void* info, srv_ctm_rsp_cb_func_ptr callback)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
srv_ctm_rsp_struct rsp;
MMI_BOOL result = MMI_FALSE;
srv_ctm_act_op_enum ori_act;
srv_ctm_rsp_cb_func_ptr ori_cb;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
MMI_TRACE(MMI_COMMON_TRC_G5_CALL, TRC_SRV_CTM_ACT_REQ, opcode, srv_ctm_p->curr_act);
ori_act = srv_ctm_p->curr_act;
ori_cb = srv_ctm_p->rsp_cb;
srv_ctm_p->curr_act = opcode;
srv_ctm_p->rsp_cb = callback;
if (ori_act == SRV_CTM_ACT_IDLE)
{
switch (opcode)
{
case SRV_CTM_ACT_CONNECT:
srv_ctm_act_connect();
result = MMI_TRUE;
break;
case SRV_CTM_ACT_SEND_TEXT:
result = srv_ctm_act_send_text(info);
break;
default:
break;
}
}
/* CTM service is busy, op fails, or unsupport op */
if (result != MMI_TRUE)
{
MMI_TRACE(MMI_COMMON_TRC_G5_CALL, TRC_SRV_CTM_ACT_REQ_ERR);
if (callback)
{
/* restore before callback */
srv_ctm_p->curr_act = ori_act;
srv_ctm_p->rsp_cb = ori_cb;
rsp.result = MMI_FALSE;
(*callback)(&rsp);
}
}
}
VMINT vm_tls_log_plaintext(VMINT onoff)
{
//vm_tls_context_t * ctx_p = NULL;
MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_S, 4, __LINE__);
tls_log_plaintext((kal_bool)onoff);
MMI_TRACE(TRACE_GROUP_8, TRC_MRE_SSL_E, 4, onoff);
return 0;
}
/*****************************************************************************
* FUNCTION
* ExitScrCMErrMsg
* DESCRIPTION
* Exit handler for the error pop up screen
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
void ExitScrCMErrMsg(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
MMI_TRACE(MMI_TRACE_G5_CM, MMI_CM_FUNC_ExitScrCMErrMsg);
if (GetErrorToneFlag() > 0)
{
stopRequestedTone(GetErrorToneFlag());
SetErrorToneFlag(0);
}
StopTimer(CM_NOTIFYDURATION_TIMER);
if (cm_p->redial_info.RedialState == TRUE)
{
/* in redial process */
if (cm_p->redial_info.ErrRedialScreen == TRUE)
{
/* error msg got interrupted */
history Scr1009;
S16 nHistory = 0;
MMI_TRACE(MMI_TRACE_G5_CM, MMI_CM_INFO_ExitScrCMErrMsgRedial);
Scr1009.scrnID = CM_SCR_RDL_TIME;
Scr1009.entryFuncPtr = EntryScrShowUserTimeToRedial;
mmi_ucs2cpy((S8*) Scr1009.inputBuffer, (S8*) & nHistory);
GetCategoryHistory(Scr1009.guiBuffer);
AddHistory(Scr1009);
cm_p->redial_info.ErrRedialScreen = FALSE;
return;
}
else
{
/* error msg timer expire => going to Notify Redial Screen */
return;
}
}
/* SetRedialScreen(FALSE); */
if (GetPOPUpFlag())
{
SetPOPUpFlag(FALSE);
AdjustHistoryForCM();
}
}
static void vm_btcm_notify_process_status(VM_P_HANDLE process_handle,
VMINT sys_state)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTCM, TRC_MRE_VMBTCM_106 );
switch (sys_state)
{
case VM_PMNG_UNLOAD:
vm_btcm_free_resource(process_handle);
break;
}
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTCM, TRC_MRE_VMBTCM_128 );
}
VMINT vm_btcm_set_host_name(VMUINT8 * name)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTCM, TRC_MRE_VMBTCM_498 );
if (NULL == name)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTCM, TRC_MRE_VMBTCM_501 );
return SRV_BT_CM_RESULT_FAILED;
}
return (VMINT)srv_bt_cm_set_host_dev_name((U8*)name);
//MMI_TRACE(MMI_MRE_TRC_MOD_VMBTCM, TRC_MRE_VMBTCM_507 );
}
VMINT _vm_reg_btspp_module(void)
{
int res_code = REG_MRE_MODULE_SUCCESS;
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_221 );
if ((res_code = _vm_reg_module("BTSPP MODULE", (MOD_EVT_PROCESS)vm_btspp_mod_evt_proc)) != REG_MRE_MODULE_SUCCESS)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_224 , res_code);
}
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_227 );
return res_code;
}
VMINT _vm_reg_btcm_module(void)
{
int res_code = REG_MRE_MODULE_SUCCESS;
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTCM, TRC_MRE_VMBTCM_207 );
if ((res_code = _vm_reg_module("BTCM MODULE", (MOD_EVT_PROCESS)vm_btcm_mod_evt_proc)) != REG_MRE_MODULE_SUCCESS)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTCM, TRC_MRE_VMBTCM_210 , res_code);
}
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTCM, TRC_MRE_VMBTCM_213 );
return res_code;
}
static void PRELOAD_PMNG_WRAP_CALLBACK(VM_P_HANDLE p, void (*cb)(VMINT hdl, void * para), VMINT rid, void * data)
{
if (vm_pmng_set_ctx(p) == VM_PMNG_OP_OK)
{
if (cb)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_PRELOAD_S, 3, __LINE__);
cb(rid, data);
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_PRELOAD_E, 3, __LINE__);
}
vm_pmng_reset_ctx();
}
}
static VMINT vm_nmgr_confirm_popup(vm_common_ui_info_struct *ui_info)
{
VM_P_HANDLE phandle;
vm_common_ui_res_struct * ui_res_p;
VMINT common_ui_id;
VMINT grp_id;
if ((phandle = vm_pmng_get_app_handle()) == 0)
{
MMI_TRACE(MMI_MRE_TRC_MOD_COMMONUI, TRC_MRE_COMMON_UI_CONFIRM_GET_CUR_HANDLE_FAIL);
return VM_COMMON_UI_ERROR;
}
if((ui_res_p = (vm_common_ui_res_struct *)_vm_kernel_malloc(sizeof(vm_common_ui_res_struct))) == NULL)
{
MMI_TRACE(MMI_MRE_TRC_MOD_COMMONUI, TRC_MRE_COMMON_UI_CONFIRM_GET_MEM_FAIL);
return VM_COMMON_UI_ERROR_OF_MEM;
}
ui_res_p->m_pHandle = phandle;
ui_res_p->callback_func = ui_info->confirm_popup_para.confirm_popup_proc;
ui_res_p->user_data = ui_info->confirm_popup_para.user_data;
if ((common_ui_id = vm_res_save_data(VM_RES_TYPE_COMMON_UI, (void *) ui_res_p, sizeof(vm_common_ui_res_struct),NULL, phandle)) < 0)
{
_vm_kernel_free(ui_res_p);
MMI_TRACE(MMI_MRE_TRC_MOD_COMMONUI, TRC_MRE_COMMON_UI_CONFIRM_SAVE_RES_FAIL);
return VM_COMMON_UI_ERROR_OF_RES;
}
ui_res_p->m_nResid = common_ui_id;
grp_id = vm_nmgr_confirm_popup_show(ui_info, ui_res_p);
MMI_TRACE(MMI_MRE_TRC_MOD_COMMONUI, TRC_MRE_COMMON_UI_CONFIRM_POPUP_INFO, grp_id, common_ui_id);
if (grp_id == 0)
{
_vm_kernel_free(ui_res_p);
if (vm_res_release_data(VM_RES_TYPE_COMMON_UI, common_ui_id) < VM_RES_OK)
{
MMI_TRACE(MMI_MRE_TRC_MOD_COMMONUI, TRC_MRE_COMMON_UI_CONFIRM_RESLEASE_RES_FAIL, common_ui_id);
}
return VM_COMMON_UI_ERROR;
}
else
{
ui_res_p->grp_id = grp_id;
}
return common_ui_id;
}
static VMINT vm_btspp_finialize_resource(void)
{
VMINT resHandle = 0, bufSize = 0;
vm_btspp_context_t* ctx_p = NULL;
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_168 );
vm_btspp_free_resource(-1);
vm_res_type_set_notify_callback(VM_RES_TYPE_BTSPP, NULL);
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_188 );
return 0;
}
static void vm_btspp_notify_process_status(VM_P_HANDLE process_handle,
VMINT sys_state)
{
VMINT resHandle = 0, bufSize = 0;
vm_btspp_context_t * ctx_p = NULL;
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_121 );
switch (sys_state)
{
case VM_PMNG_UNLOAD:
vm_btspp_free_resource(process_handle);
break;
}
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTSPP, TRC_MRE_VMBTSPP_143 );
}
static VMINT vm_btcm_initialize_resource(void)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTCM, TRC_MRE_VMBTCM_134 );
if (vm_res_type_set_notify_callback(VM_RES_TYPE_BTCM,
vm_btcm_notify_process_status) != 0)
{
return -1;
}
///TODO: other init.
MMI_TRACE(MMI_MRE_TRC_MOD_VMBTCM, TRC_MRE_VMBTCM_142 );
return 0;
}
/*****************************************************************************
* FUNCTION
* mdi_webcam_abort_indication_hdlr
* DESCRIPTION
* webcam abort indication from driver
* PARAMETERS
* msg_ptr [IN] Message pointer
* RETURNS
* void
*****************************************************************************/
static void mdi_webcam_abort_indication_hdlr(void *msg_ptr)
{
#ifdef MDI_WEBCAM_DRIVER_AVAIALBE
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
media_webcam_abort_ind_struct *abort_data_ptr;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
#if 0//JiaShuo Delete for webcam
MMI_TRACE(MMI_MEDIA_TRC_G4_MDI, MDI_TRC_WEBCAM_ABORT_IND_HALR);
#endif
abort_data_ptr = (media_webcam_abort_ind_struct*) msg_ptr;
if (abort_data_ptr->seq_num != g_mdi_webcam_cntx.start_seq_num)
{
/* cant match, means already stopped */
return;
}
if (mdi_webcam_event_callback_funcptr != NULL)
{
mdi_webcam_event_callback_funcptr(MDI_RES_WEBCAM_DRV_ABORT, KAL_TRUE);
}
#endif /* MDI_WEBCAM_DRIVER_AVAIALBE */
}
/*****************************************************************************
* FUNCTION
* mdi_webcam_resume
* DESCRIPTION
* Resume webcam
* PARAMETERS
* rotate [IN] Preview rotate
* RETURNS
* MDI_RES_WEBCAM_SUCCEED Success
* MDI_RES_WEBCAM_ERR_FAILED Failure
*****************************************************************************/
MDI_RESULT mdi_webcam_resume(U16 rotate)
{
#ifdef MDI_WEBCAM_DRIVER_AVAIALBE
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
media_webcam_resume_req_struct resume_data;
S32 ret;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
#if 0//JiaShuo Delete for webcam
MMI_TRACE(MMI_MEDIA_TRC_G4_MDI, MDI_TRC_WEBCAM_RESUME);
resume_data.rotate = rotate + CAM_IMAGE_NORMAL;
#endif
ret = media_webcam_resume(MOD_MMI, &resume_data);
if (ret != MED_RES_OK)
{
return MDI_RES_WEBCAM_ERR_FAILED;
}
else
{
return MDI_RES_WEBCAM_SUCCEED;
}
#endif /* MDI_WEBCAM_DRIVER_AVAIALBE */
return MDI_RES_WEBCAM_SUCCEED;
}
