jam_msg_handler.c

java 1.1 gemini 08_16

{
	2,
	MSG_ID_MMI_JAVA_MIDS_GETLIST_REQ,
	j2me_getlist_table,
	"GetList",
	0
};

/* MIDlet Start/Stop */
const j2me_msg_handler j2me_run_table[] = 
{
	(j2me_msg_handler) mid_start_req_handler,
	(j2me_msg_handler) mid_stop_res_handler
};

j2me_state_struct j2me_run_state = 
{
	2,
	MSG_ID_MMI_JAVA_MID_START_REQ,
	j2me_run_table,
	"Run",
	0
};

/* Remove MIDlet Suite */
const j2me_msg_handler j2me_remove_table[] = 
{
	(j2me_msg_handler) mids_remove_req_handler,
	(j2me_msg_handler) mids_remove_cnf_res_handler
};

j2me_state_struct j2me_remove_state = 
{
	2,
	MSG_ID_MMI_JAVA_MIDS_REMOVE_REQ,
	j2me_remove_table,
	"Remove",
	0
};

/* Install MIDlet Suite */
const j2me_msg_handler j2me_install_table[] = 
{
	(j2me_msg_handler) mids_wap_install_ind_handler,
	(j2me_msg_handler) mids_mmi_install_req_handler,
	(j2me_msg_handler) mids_mmi_install_res_handler,
};

j2me_state_struct j2me_install_state = 
{
	3,
	MSG_ID_JAVA_WAP_INSTALL_MIDS_IND,
	j2me_install_table,
	"Install",
	0
};

/* Abort */
const j2me_msg_handler j2me_abort_table[] = 
{
	(j2me_msg_handler) mmi_abort_req_handler,
	(j2me_msg_handler) wap_abort_cnf_handler
};

j2me_state_struct j2me_abort_state = 
{
	2,
	MSG_ID_MMI_JAVA_ABORT_REQ,
	j2me_abort_table,
	"Abort",
	0
};

/* Local install */
const j2me_msg_handler j2me_local_install_table[] = 
{
	NULL
};

j2me_state_struct j2me_local_install_state = 
{
	1,
	MSG_ID_MMI_JAVA_LOCAL_INSTALL_REQ,
	j2me_local_install_table,
	"Local install",
	0
};

/* Invalide state error handling */
const j2me_msg_handler j2me_invalid_table[] = 
{
	(j2me_msg_handler) invalid_mids_getlist_req_handler,
	(j2me_msg_handler) invalid_mid_getlist_req_handler,
	(j2me_msg_handler) invalid_mid_start_req_handler,
	(j2me_msg_handler) invalid_mid_stop_res_handler,
	(j2me_msg_handler) invalid_mids_getinfo_req_handler,
	(j2me_msg_handler) invalid_mids_get_setting_req_handler,
	(j2me_msg_handler) invalid_mids_set_setting_req_handler,
	(j2me_msg_handler) invalid_mids_update_req_handler,
	(j2me_msg_handler) invalid_mids_remove_req_handler,
	(j2me_msg_handler) invalid_mids_remove_ind_handler,
	(j2me_msg_handler) invalid_mids_wap_install_ind_handler,
	(j2me_msg_handler) invalid_mids_mmi_install_req_handler,
	(j2me_msg_handler) invalid_mids_mmi_install_res_handler,
	(j2me_msg_handler) invalid_mids_mmi_install_cnf_res_handler,
	(j2me_msg_handler) invalid_wap_getfileandsave_ind_handler,
	(j2me_msg_handler) invalid_wap_getfileandsave_cnf_handler,
	(j2me_msg_handler) invalid_mmi_getfileandsave_res_handler,
	(j2me_msg_handler) invalid_mmi_install_reset_rms_res_handler,
	(j2me_msg_handler) invalid_wap_post_data_cnf_handler,
	(j2me_msg_handler) invalid_mmi_abort_req_handler,
	(j2me_msg_handler) invalid_wap_abort_cnf_handler,
	(j2me_msg_handler) invalid_mmiapi_sms_ind_handler,
	(j2me_msg_handler) invalid_mmi_push_res_handler,
};

j2me_state_struct j2me_invalid_state = 
{
	22,
	MSG_ID_MMI_JAVA_MIDS_GETLIST_REQ,
	j2me_invalid_table,
	"Invalid",
	0
};

#ifdef OGDR_SECURITY_SETTING
kal_char *operator_domain_str_tbl[] = {"OPERATOR", NULL};
kal_char *manufacturer_domain_str_tbl[] = {"MANUFACTURER", NULL};
kal_char *thirdparty_domain_str_tbl[] = {"THIRDPARTY", "3RD-DMN", "3rdparty", NULL};
kal_char *untrusted_domain_str_tbl[] = {"UNTRUSTED", NULL};
typedef enum{
    OPERATOR_DOMAIN,
    MANUFACTURER_DOMAIN,
    THIRDPARTY_DOMAIN,
    UNTRUSTED_DOMAIN
}domain_enum;

/*****************************************************************************
 * FUNCTION
 *  domain_compare
 * DESCRIPTION
 *  Compare security domain.
 *
 * PARAMETERS
 *  kal_wchar* domain      input domain string retrieved from security policy
 *  kal_int32 domain_index one of domain_enum.
 * RETURNS
 *  kal_bool  KAL_TRUE if string matches
 *****************************************************************************/
kal_bool domain_compare(kal_wchar* domain, kal_int32 domain_index)
{
    kal_char ** str_tbl;
    kal_int32 str_index = 0;
    kal_int32 tbl_index = 0;
    switch(domain_index)
    {
        case OPERATOR_DOMAIN:
            str_tbl = operator_domain_str_tbl;
        break;
        case MANUFACTURER_DOMAIN:
            str_tbl = manufacturer_domain_str_tbl;
        break;
        case THIRDPARTY_DOMAIN:
            str_tbl = thirdparty_domain_str_tbl;
        break;
        case UNTRUSTED_DOMAIN:
            str_tbl = untrusted_domain_str_tbl;
        break;
        default:
            return KAL_FALSE;
    }
    while(str_tbl[tbl_index] != NULL)
    {
        while(domain[str_index] == str_tbl[tbl_index][str_index] ||
              domain[str_index] == str_tbl[tbl_index][str_index] + 32)
        {
            if(domain[str_index] == 0)
            {
                return KAL_TRUE;
            }
            str_index ++;
        }
        tbl_index ++;
    }
    return KAL_FALSE;
}

#endif

void jam_success_call_back(void)
{
}

#ifdef J2ME_SHARE_MED_EXT_MEM
/*****************************************************************************
 * FUNCTION
 *  jvm_is_caller_video_can_play
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
kal_bool jvm_is_caller_video_can_play(void)
{
	/*----------------------------------------------------------------*/
	/* Local Variables                                                */
	/*----------------------------------------------------------------*/

	/*----------------------------------------------------------------*/
	/* Code Body                                                      */
	/*----------------------------------------------------------------*/
    return (!jvm_alloc_med_mem);
}
#endif


/*****************************************************************************
 * FUNCTION
 *  jvm_is_busy
 * DESCRIPTION
 *  This function can be used by any task that has higher priority than Java task
 *  to test if Java is in storage recovery
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
kal_bool jvm_is_busy(void)
{
	/*----------------------------------------------------------------*/
	/* Local Variables                                                */
	/*----------------------------------------------------------------*/

	/*----------------------------------------------------------------*/
	/* Code Body                                                      */
	/*----------------------------------------------------------------*/
	return is_jvm_in_busy || jvm_is_own_screen();
}


#ifdef __SUPPORT_NATIVE_INSTALLER__
/*****************************************************************************
 * FUNCTION
 *  jvm_task_ready
 * DESCRIPTION
 *  This function is used to prevent MMI installing, updating, or any unpredictable operation 
 *   if JVM task is not ready yet ( may on cleaning Java storage )
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
kal_bool jvm_task_ready(void)
{
    return is_jvm_task_ready;
}
#endif /* __SUPPORT_NATIVE_INSTALLER__ */


/*****************************************************************************
 * FUNCTION
 *  jvm_is_timealarmpush_session
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  
 *****************************************************************************/
kal_bool jvm_is_timealarmpush_session(void)
{
	/*----------------------------------------------------------------*/
	/* Local Variables                                                */
	/*----------------------------------------------------------------*/

	/*----------------------------------------------------------------*/
	/* Code Body                                                      */
	/*----------------------------------------------------------------*/
	return is_jvm_timealarmpush_session;
}


/*****************************************************************************
 * FUNCTION
 *  jvm_is_launch_mids_session
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  
 *****************************************************************************/
kal_bool jvm_is_launch_mids_session(void)
{
	/*----------------------------------------------------------------*/
	/* Local Variables                                                */
	/*----------------------------------------------------------------*/

	/*----------------------------------------------------------------*/
	/* Code Body                                                      */
	/*----------------------------------------------------------------*/
	return is_jvm_launch_mids_session;
}


/*****************************************************************************
 * FUNCTION
 *  jvm_is_wap_install_session
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  
 *****************************************************************************/
kal_bool jvm_is_wap_install_session(void)
{
	/*----------------------------------------------------------------*/
	/* Local Variables                                                */
	/*----------------------------------------------------------------*/

	/*----------------------------------------------------------------*/
	/* Code Body                                                      */
	/*----------------------------------------------------------------*/
	return is_jvm_wap_install_session;
}


/*****************************************************************************
 * FUNCTION
 *  get_running_mid_name
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  
 *****************************************************************************/
kal_wchar *get_running_mid_name(void)
{
	/*----------------------------------------------------------------*/
	/* Local Variables                                                */
	/*----------------------------------------------------------------*/

	/*----------------------------------------------------------------*/
	/* Code Body                                                      */
	/*----------------------------------------------------------------*/
	return currently_running_mid_name;
}


/*****************************************************************************
 * FUNCTION
 *  set_running_mid_name
 * DESCRIPTION
 *  
 * PARAMETERS
 *  mid_name_str        [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void set_running_mid_name(kal_wchar *mid_name_str)
{
	/*----------------------------------------------------------------*/
	/* Local Variables                                                */
	/*----------------------------------------------------------------*/

	/*----------------------------------------------------------------*/
	/* Code Body                                                      */
	/*----------------------------------------------------------------*/
	currently_running_mid_name = (kal_wchar*) mid_name_str;
}


/*****************************************************************************
 * FUNCTION
 *  j2me_process_ilm
 * DESCRIPTION
 *  
 * PARAMETERS
 *  ilm_ptr     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
kal_int32 j2me_process_ilm(ilm_struct *ilm_ptr)
{
	/*----------------------------------------------------------------*/
	/* Local Variables                                                */
	/*----------------------------------------------------------------*/
	kal_int32 msg_indx = ilm_ptr->msg_id - j2me_current_state->msg_begin;

	/*----------------------------------------------------------------*/
	/* Code Body                                                      */
	/*----------------------------------------------------------------*/
	if ((msg_indx < 0) || (msg_indx >= (kal_int32) j2me_current_state->msgs_limit))
	{
		sprintf(
			   _kvmLogStr,
			   "J2ME WARNING: invalid message - state:%s, msg:%d",
			   j2me_current_state->state_name,
			   ilm_ptr->msg_id);
		Kputs(_kvmLogStr);
		return -1;
	}

	debug_msg_table_ptr = (j2me_msg_handler*) j2me_current_state->msg_table_ptr;
	debug_msg_indx = msg_indx;

	j2me_current_state->msg_table_ptr[msg_indx] (ilm_ptr);

	debug_msg_table_ptr = NULL;
	debug_msg_indx = -1;

	return msg_indx;
}

kal_int32 get_event_general(kal_bool wait_forever, kal_uint32 wait_in_ms)
{
	ilm_struct current_ilm;
	kal_uint32 temp_time;
	kal_int64 start_time, current_time;
	kal_get_time(&temp_time);
	start_time = temp_time;
	if (wait_forever || wait_in_ms != 0)
	{
		jvm_keypad_register_notify();
	}

	do
	{
		kal_status status = KAL_Q_EMPTY;
		kal_uint16 msg_size;

		status = kal_deque_msg(task_info_g[INDX_J2ME].task_ext_qid, (void*)&current_ilm, &msg_size, KAL_NO_WAIT);

		if (status == KAL_SUCCESS)
		{
			kal_trace(TRACE_FUNC, FUNC_J2ME_GET_NEXT_EVENT, -1, current_ilm.msg_id);

			/* we should process common event first. add by hjf, modified by Justin */
			if (j2me_task_general_msg_handler(&current_ilm) && 
				current_ilm.msg_id != MSG_ID_MMI_JAVA_ABORT_REQ)
			{
				free_ilm(&current_ilm);
				return J2ME_NO_ERROR;
			}
			/* handle abort from MMI or WAP */
			if (current_ilm.msg_id == MSG_ID_MMI_JAVA_ABORT_REQ)
			{
				mmi_java_abort_req_struct *abort_req_ptr;
				mmi_java_abort_cnf_struct *abort_cnf_ptr;
				ilm_struct *send_ilm;

				abort_req_ptr = (mmi_java_abort_req_struct*) current_ilm.local_para_ptr;

				abort_cnf_ptr = construct_local_para(sizeof(mmi_java_abort_cnf_struct), TD_CTRL);
				abort_cnf_ptr->session_id = abort_req_ptr->session_id;
				abort_cnf_ptr->error_code = J2ME_NO_ERROR;

				send_ilm = allocate_ilm(MOD_J2ME);
				send_ilm->src_mod_id = MOD_J2ME;
				send_ilm->dest_mod_id = MOD_MMI;
				send_ilm->local_para_ptr = (local_para_struct*) abort_cnf_ptr;
				send_ilm->peer_buff_ptr = NULL;
				send_ilm->msg_id = MSG_ID_MMI_JAVA_ABORT_CNF;
				send_ilm->sap_id = J2ME_MMI_SAP;

				/* ??? can check_incoming_call_and_block() be removed? */
				check_incoming_call_and_block();
				msg_send_ext_queue(send_ilm);

				/* the message should be freed here!!! */
				free_ilm(&current_ilm);
				return J2ME_USER_CANCEL;
			}
			/* unknow event */

			kal_trace(TRACE_FUNC, FUNC_J2ME_GET_NEXT_EVENT_CLEAN, current_ilm.msg_id);
			free_ilm(&current_ilm);
			return J2ME_NO_ERROR;
		} else if (status == KAL_Q_EMPTY)
		{
#ifdef __JBLENDIA__
			kal_uint32 flag=0;
#endif
			if (wait_forever)
			{
				/* Sleep for a while, and polling again. */
				kal_sleep_task(10);
				continue;
			}

			if (wait_in_ms == 0)
			{
				return -1;
			}

#ifdef __JBLENDIA__