events_md.c

java 1.1 gemini 08_16

				j2me_current_state = j2me_saved_state;
			}
		}
		free_ilm(&current_ilm);

        ext_msg_num--;

        if( ext_msg_num > 0)
        {
            if (KPeekMessage(&current_ilm, 0) != KAL_SUCCESS)
            {
                return;
            }
        }
    }
	return;
}

/*************************************************************************
* FUNCTION
*  LCDUIincomingCall
*
* DESCRIPTION
*
* PARAMETERS
*
* RETURNS
*  None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void LCDUIincomingCall()
{
	/* Very important!! This function will be invoked after pauseApp executed */
	//pause_app_executed = KAL_TRUE;
}

/*************************************************************************
* FUNCTION
*  checkEventOver
*
* DESCRIPTION
*  This function solves the event queue overflow assertion and unresponsive
*  "END" key when Java is under initializing or event schedule thread is 
*  used to deal with an infinite loop. checkEventOver will be called by 
*  reschedule() when checkEventCountTimeSlice is zero, see events.h for 
*  more information.
*
* PARAMETERS
*
* RETURNS
*  None
*
* GLOBALS AFFECTED
*
*************************************************************************/
#ifdef CLDCHI
extern void hi_suspend_tick(void);
extern void hi_resume_tick(void);
#endif /* CLDCHI */

void checkEventOver() 
{
	kal_status result = KAL_SUCCESS;
#ifdef __SUPPORT_NATIVE_INSTALLER__
	ilm_struct current_ilm;
	kal_uint16 msg_size;
#endif /* __SUPPORT_NATIVE_INSTALLER__ */

	if (pauseThread)
	{
		if (!suspend_all_executed)
		{
			//suspendAll();
			suspend_all_executed = KAL_TRUE;
		}

		if (pause_app_executed || CurrentTime_md() - pausedTime > MAX_PAUSE_EXCUTING_TIME)
		{
			kal_uint32 event_group;

			/* sometimes context switch in suspendAll, need check this flag again */
			if (pauseThread && (jvm_get_state() == JVM_LONG_EVENT_STATE || 
                                jvm_get_state() == JVM_PAUSED_STATE))
			{
#ifdef __SUPPORT_NATIVE_INSTALLER__
				/* Peek eventgroup is set or not */
				result = kal_retrieve_eg_events(J2ME_pause_event_group, 1, KAL_OR_CONSUME, &event_group, KAL_NO_SUSPEND);
				while (result != KAL_SUCCESS)
				{
					result = kal_retrieve_eg_events(J2ME_pause_event_group, 1, KAL_OR_CONSUME, &event_group, KAL_NO_SUSPEND);
					/* if not set, we still need to process external messages */				
					if (!vm_is_force_terminated && kal_deque_msg(task_info_g[INDX_J2ME].task_ext_qid, 
					    (void*)&current_ilm, &msg_size, KAL_NO_WAIT) == KAL_SUCCESS)
					{
						if (!j2me_task_general_msg_handler(&current_ilm))
						{
							kal_int32 process_res;
	
							process_res = j2me_process_ilm(&current_ilm);
	
							if (process_res < 0)
							{
								/* Receiving invalid message */
								j2me_saved_state = j2me_current_state;
								J2ME_SET_STATE(invalid);	
								process_res = j2me_process_ilm(&current_ilm);
								j2me_current_state = j2me_saved_state;
							}
						}
						free_ilm(&current_ilm);
					}

					/* if pressed END key, and select terminated */
					if (vm_is_force_terminated) {
						MidpCommandState.nextCommand = EXIT;
						break;
					}
					kal_sleep_task(10);
				}
#else
				result = kal_retrieve_eg_events(J2ME_pause_event_group, 1, KAL_OR_CONSUME, &event_group, KAL_SUSPEND);
#endif /* __SUPPORT_NATIVE_INSTALLER__ */
			}

			/* Fix to solve MMI enter idle screen, and resume MMAPI handle will be failed and infinite loop. */
			/* If "END_KEY" pressed, but not processed for a while. force to exit */
			if (vm_is_force_terminated && CurrentTime_md() - terminateTime > MAX_TERMINAT_TIME)
			{
				vm_is_force_terminated = KAL_FALSE;
				/* Flush key ring buffer */
				jvm_keypad_flush();
				jvm_tp_flush();

				MidpCommandState.nextCommand = EXIT;
				ERROR_THROW(-1); /* long jump back to VM exit point*/
			}
		}
	}
#ifdef __SUPPORT_NATIVE_INSTALLER__
	else
	{
		if (is_bg_running && !vm_is_force_terminated && kal_deque_msg(task_info_g[INDX_J2ME].task_ext_qid, 
		    (void*)&current_ilm, &msg_size, KAL_NO_WAIT) == KAL_SUCCESS)
		{
			if (!j2me_task_general_msg_handler(&current_ilm))
			{
				kal_int32 process_res;

				process_res = j2me_process_ilm(&current_ilm);

				if (process_res < 0)
				{
					/* Receiving invalid message */
					j2me_saved_state = j2me_current_state;
					J2ME_SET_STATE(invalid);	
					process_res = j2me_process_ilm(&current_ilm);
					j2me_current_state = j2me_saved_state;
				}
			}
			free_ilm(&current_ilm);
		}
	}
#endif /* __SUPPORT_NATIVE_INSTALLER__ */
	if (suspend_all_executed && !pauseThread && !vm_is_force_terminated )
	{
		//resumeAll();
		suspend_all_executed = KAL_FALSE;
	}

	/* Keep check here, because possible pause/resume so quickly, and vm didn't detect that */
	if (vm_is_force_terminated && CurrentTime_md() - terminateTime > MAX_TERMINAT_TIME)
	{
		vm_is_force_terminated = KAL_FALSE;
		/* Flush key ring buffer */
		jvm_keypad_flush();
		jvm_tp_flush();

		MidpCommandState.nextCommand = EXIT;
		ERROR_THROW(-1); /* long jump back to VM exit point*/
	}

	if (g_jvm_card_plugin_event)
	{
		/* sleep around 0.2 sec */
		kal_sleep_task(40);
		g_jvm_card_plugin_event--;
	}
}

// Add for JAL interface
void jvm_check_event_over(void)
{
	checkEventOver();
}

void jvm_init_vm_external()
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint32 event_group;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/

	shutdonw_event_sent = KAL_FALSE;
	vm_is_force_terminated = FALSE;
	jvm_file_update_diskinfo();
	pauseThread = KAL_FALSE;
	checkEventCountTimeSlice = 10;
	store_pause_or_resume_event = FALSE;
    is_bg_running = KAL_FALSE;
    suspend_all_executed = FALSE;
    notify_pause = KAL_FALSE;
    saved_vm_pause = KAL_FALSE;

    kal_set_eg_events(J2ME_pause_event_group, 1, KAL_OR);
    kal_retrieve_eg_events(J2ME_pause_event_group, 1, KAL_OR_CONSUME, &event_group, KAL_NO_SUSPEND);
}

void jvm_reset_vm_external()
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint32 event_group;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
#ifdef CLDCHI
	set_timer_tick();
#else
	checkEventCountTimeSlice = 0;
	Timeslice = 1;               
#endif /* CLDCHI */
	vm_is_force_terminated = KAL_TRUE;
    saved_vm_pause = KAL_FALSE;
    kal_set_eg_events(J2ME_pause_event_group, 1, KAL_OR);
    kal_retrieve_eg_events(J2ME_pause_event_group, 1, KAL_OR_CONSUME, &event_group, KAL_NO_SUSPEND);
}



void jvm_pause_vm_external(jvm_state_enum vm_state, kal_bool pause_midlet)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint32 event_group;
	extern volatile module_type     j2me_lcd_mutex_tid;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/

    saved_vm_pause = KAL_TRUE;
    if( ((vm_state == JVM_SHORT_EVENT_STATE && pause_midlet == KAL_TRUE) ||
         vm_state == JVM_LONG_EVENT_STATE ||
         vm_state == JVM_PAUSED_STATE) && pauseThread == KAL_FALSE)
    {
        kal_set_eg_events(J2ME_pause_event_group, 1, KAL_OR);
        kal_retrieve_eg_events(J2ME_pause_event_group, 1, KAL_OR_CONSUME, &event_group, KAL_NO_SUSPEND);

        current_pause_level = pause_midlet;
    	pause_app_executed = KAL_FALSE;
    	if (stack_int_get_active_module_id() == j2me_lcd_mutex_tid)
	{
		// This function Can't inside the j2me_lcd_mutex_lock/unlock block !!! 
		// it will cause dead lock
		ASSERT(0);
	}

#ifdef CLDCHI
	set_timer_tick();
#else
	checkEventCountTimeSlice = 0;
	Timeslice = 1;
#endif /* CLDCHI */

	pauseThread = KAL_TRUE;
	pausedTime = CurrentTime_md();
	/* suspend MIDlet suite */
    }
    else if (vm_state == JVM_BG_RUNNING_STATE && pauseThread == KAL_TRUE)
    {
        kal_bool temp_bool = notify_pause;
        is_bg_running = KAL_TRUE;
        jvm_resume_vm_external();
        notify_pause = temp_bool;
    }
}

void jvm_resume_vm_external()
{
/*	
 * Description: After reqest for install, mmi changes work path to JAVA work path,
 * we should change it back to Eureka work path before resume it.
 */
	pauseThread = KAL_FALSE;
    notify_pause = KAL_FALSE;
    saved_vm_pause = KAL_FALSE;
	vm_is_force_terminated = FALSE;
	/* repaint screen and resume MIDlet suite */
    kal_set_eg_events(J2ME_pause_event_group, 1, KAL_OR);
    jui_widget_reset_current_menu_string();
}

void jvm_stop_vm_external()
{
	terminateTime = CurrentTime_md();
	vm_is_force_terminated = KAL_TRUE;
#ifdef __SUPPORT_INFUSIO__
	ege_launch_next_ap_flag = FALSE;
#endif /* __SUPPORT_INFUSIO__ */ 
	pauseThread = KAL_FALSE;
    kal_set_eg_events(J2ME_pause_event_group, 1, KAL_OR);
}

kal_bool
jvm_vm_is_paused()
{
	return pauseThread;
}

void jvm_check_if_need_pause(void)
{
	/* Do nothing for new pause / resume scenario */
	/*j2me_lcd_mutex_lock();
	while (!jvm_is_own_screen()) {
		j2me_lcd_mutex_unlock();
		checkEventOver();
		j2me_lcd_mutex_lock();
	}	
	j2me_lcd_mutex_unlock();*/
}

void jvm_check_if_need_pause_withlock(void)
{
	/* Do nothing for new pause / resume scenario */
	/*while (!jvm_is_own_screen()) {
		j2me_lcd_mutex_unlock();
		checkEventOver();
		j2me_lcd_mutex_lock();
	}*/ 
}

#if 0 // move to gui_adaptor.c
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#endif

void jvm_post_mma_event(java_mma_type_enum evt_type, kal_int16 player_id, kal_int64 player_time)
{

	KVMEventType evt;

	kal_trace(TRACE_GROUP_4, FUNC_J2ME_JVM_POST_MMA_EVENT, (int)evt_type, (int)player_id, (int)player_time);

	switch (evt_type)
	{
	case MMA_EVENT_END_OF_MEDIA:
		evt.type = mmEOMEvent;
		break;
	case MMA_EVENT_STOPPED_AT_TIME:
		evt.type = mmSTOPOMEvent;
		break;
    case MMA_EVENT_RECORD_ERROR:
		evt.type = mmRECERREvent;
		break;  
    case MMA_EVENT_BUFFERING_STARTED:
        evt.type = mmBufferingStartedEvent;
        break;
    case MMA_EVENT_BUFFERING_STOPPED:
        evt.type = mmBufferingStoppedEvent;
        break;
    case MMA_EVENT_ERROR:
        evt.type = mmErrorEvent;
        break;
    case MMA_EVENT_RECORD_STOPPED:
		evt.type = mmRecordStoppedEvent;
		break;      
	default:
		evt.type = invalidKVMEvent;
		break;
	}
	/* use screenX to save player id */
	evt.screenX = (short)player_id;
	/* use chr to save currenttime */
	evt.chr = player_time;

	StoreMIDPEvent(&evt);
}

/*************************************************************************
* FUNCTION
*  jvm_post_repaint_event
*
* DESCRIPTION
*  This function asks VM to repaint whole screen
*
* PARAMETERS
*
* RETURNS
*  None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void jvm_post_repaint_event(void)
{
	KVMEventType evt;

	evt.type = systemKVMEvent;
	evt.chr = MIDP_REPAINT;
	StoreMIDPEvent(&evt);
}