events_md.c

java 1.1 gemini 08_16

* RETURNS
*  None
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_bool j2me_translate_tpevent(kal_uint16 x, kal_uint16 y, enum KVMEventTypes *pen_type)
{
	switch (*pen_type)
	{
	case MMI_PEN_EVENT_DOWN:
		*pen_type = penDownKVMEvent;
		break;
	case MMI_PEN_EVENT_UP:
		*pen_type = penUpKVMEvent;
		break;
	case MMI_PEN_EVENT_MOVE:
		*pen_type = penMoveKVMEvent;
		break;
	default:
		*pen_type = invalidKVMEvent;

	}
	if ((*pen_type) == invalidKVMEvent)	return KAL_FALSE;
	return KAL_TRUE;
}

kal_bool j2me_translate_keyevent(kal_uint16 keycode, kal_uint16 keytype, 
								 KVMEventType *evt)
{
	/* Key type */
	if (keytype == kbd_onekey_press) evt->type = keyDownKVMEvent;
	else if ((keytype==kbd_onekey_longpress) || (keytype==kbd_onekey_repeated))
		evt->type = keyRepeatKVMEvent;
	else if (keytype == kbd_onekey_release)	evt->type = keyUpKVMEvent;

	/* Key code */
	switch (keycode)
	{
	case KEY_0:
		evt->chr = J2ME_KEY_0;
		break;                      
	case KEY_1:
		evt->chr = J2ME_KEY_1;
		break;
	case KEY_2:
		evt->chr = J2ME_KEY_2;
		break;
	case KEY_3:
		evt->chr = J2ME_KEY_3;
		break;
	case KEY_4:
		evt->chr = J2ME_KEY_4;
		break;
	case KEY_5:
		evt->chr = J2ME_KEY_5;
		break;
	case KEY_6:
		evt->chr = J2ME_KEY_6;
		break;
	case KEY_7:
		evt->chr = J2ME_KEY_7;
		break;
	case KEY_8:
		evt->chr = J2ME_KEY_8;
		break;
	case KEY_9:
		evt->chr = J2ME_KEY_9;
		break;
	case KEY_STAR:
		evt->chr = J2ME_KEY_ASTERISK;
		break;
	case KEY_POUND:
		evt->chr = J2ME_KEY_POUND;
		break;
	case KEY_VOL_UP:
		evt->chr = J2ME_KEY_VOL_UP;
		break;
	case KEY_VOL_DOWN:
		evt->chr = J2ME_KEY_VOL_DOWN;
		break;
	case KEY_UP_ARROW:
		evt->chr = J2ME_KEY_UP;
		break;
	case KEY_DOWN_ARROW:
		evt->chr = J2ME_KEY_DOWN;
		break;
	case KEY_LEFT_ARROW:
		evt->chr = J2ME_KEY_LEFT;
		break;
	case KEY_RIGHT_ARROW:
		evt->chr = J2ME_KEY_RIGHT;
		break;
	case KEY_LSK:
		evt->chr = J2ME_KEY_SOFT1;
		break;
	case KEY_RSK:
		evt->chr = J2ME_KEY_SOFT2;
		break;
	case KEY_SEND:
	case KEY_ENTER:
		/* Use send key for select function */
		evt->chr = J2ME_KEY_SELECT;
		break;

	case KEY_END:
		evt->chr = J2ME_KEY_END;

		/* Add cancel mechanims for TCK */                      
		if (Java_mode != JAVA_NORMAL_MODE)
			j2me_quit_tck_mode = KAL_TRUE;

		break;
	case KEY_QUICK_ACS:
		evt->chr = J2ME_KEY_POWER;
		break;
	case KEY_CLEAR:
		evt->chr = J2ME_KEY_CLEAR;
		break;
	default:
		evt->chr = J2ME_KEY_INVALID;
		break;
	}

	if (evt->chr == J2ME_KEY_INVALID)
		return KAL_FALSE;
	else return KAL_TRUE;
}

kal_bool VolumeInternalEvent(int button, KVMEventType *evt)
{

	if (evt->type == keyDownKVMEvent)
	{
		if (button == J2ME_KEY_VOL_UP || button == J2ME_KEY_VOL_DOWN)
		{
			kal_uint8 volume_level = jam_get_aud_volume_level();

			if (button == J2ME_KEY_VOL_UP)
			{
				jam_set_aud_volume_level(++volume_level);
			}

			if (button == J2ME_KEY_VOL_DOWN)
			{
				jam_set_aud_volume_level(--volume_level);
			}
			return KAL_TRUE;
		}
		return KAL_FALSE;
	}
	return KAL_FALSE;
}


/*************************************************************************
 * FUNCTION:      The stub of j2me_vm_get_nextevent
 * TYPE:          event handler
 * OVERVIEW:      Wait for an external event to occur, and store
 *                the event to the KVM event queue.
 *                On a real device, the implementation of this
 *                function should try to conserve battery if 
 *                the routine is called with the 'forever'
 *                flag turned on, or with a 'waitUntil' parameter
 *                larger than zero.
 * INTERFACE
 *   parameters:  forever: a boolean flag that tells whether the
 *                KVM has anything to do or not.  When the KVM calls
 *                this routine with the forever flag turned on, the
 *                VM has no threads to run and this function can call
 *                machine-specific battery conservation/hibernation
 *                facilities.  If the forever flag is off, the function
 *                should try to return immediately, or at least after
 *                'waitUntil' milliseconds, since there are other threads
 *                that need to continue running.
 *                waitUntil: the amount of milliseconds this routine
 *                should wait in case the 'forever' flag is off.
 *   returns:     nothing directly, but the event should be stored
 *                in the event queue of the KVM (see events.c and
 *                the porting guide for details).
*************************************************************************/
void j2me_vm_get_nextevent(bool_t forever, ulong64 waitUntil, 
						   bool_t sys_event_only) 
{
	ilm_struct current_ilm;
	ulong64 tmpTime;
	KVMEventType evt;
#ifdef __J2ME_F1_3X_EXTENSION__
	int j2me_3xdevice_query_result=0;
#endif /* __J2ME_F1_3X_EXTENSION__ */
    unsigned int ext_msg_num = 0;
	kal_bool getEvent = KNI_FALSE;

	evt.chr = J2ME_KEY_INVALID;

	/* Check if need to suspend VM Thread */
	checkEventOver();

	//kal_print("j2me_vm_get_nextevent\n");
	/* Check if need to sleep, or lower priority task cannot be run */
	tmpTime = CurrentTime_md();
	if (tmpTime - previos_sleep_time > 350)
	{
		previos_sleep_time = tmpTime;
		kal_sleep_task(1);
	}

	/* Check if external message incoming and need to suspend or not */
	if (vm_is_force_terminated)
	{
		shutdonw_event_sent = KAL_TRUE;
		evt.type = systemKVMEvent;
		evt.chr = SHUTDOWN;
		StoreMIDPEvent(&evt);
	}

    if( pauseThread )
    {
        //kal_prompt_trace(MOD_J2ME, "store_pause_or_resume_event: %d\n", store_pause_or_resume_event);
    }

		if (pauseThread && !store_pause_or_resume_event && current_pause_level == KAL_TRUE)
	{
        //kal_prompt_trace(MOD_J2ME, "insert event time: %d\n", (kal_int32)(CurrentTime_md() & 0x7FFFFFFF));
		evt.type = systemKVMEvent;
		evt.chr = SUSPEND_ALL;
		store_pause_or_resume_event  = StoreMIDPEvent(&evt);
		kal_print("pauseThread && !store_pause_or_resume_event && current_pause_level == KAL_TRUE");
		return;
	}

        if(!pauseThread && store_pause_or_resume_event)
        {

            evt.type = systemKVMEvent;
			if(current_pause_level == KAL_TRUE)
			{
				evt.chr = RESUME_AND_REPAINT;
				store_pause_or_resume_event = !StoreMIDPEvent(&evt);
				kal_print("current_pause_level == KAL_TRUE");
				return;
			}
			else
			{
				evt.chr = MIDP_REPAINT;
				StoreMIDPEvent(&evt);
				kal_print("evt.chr = MIDP_REPAINT;");
				return;
			}
		}
	/* this code is for JSR-75 file APIs */
	if (disk_changed)
	{
		jvm_file_update_diskinfo();
		disk_changed = KAL_FALSE;
		evt.type = systemKVMEvent;
		evt.chr = FILE_MOUNTING;
		StoreMIDPEvent(&evt);
		return;
	}

#ifdef __J2ME_F1_3X_EXTENSION__
	j2me_3xdevice_query_result = j2me_3xdevice_query();
	if (support3XDEventTrigger && j2me_3xdevice_query_result > 0)
	{
		evt.type = systemKVMEvent;
		evt.chr  = VK_THREEAXIS;
		StoreMIDPEvent(&evt);
		return;
	}
#endif /* __J2ME_F1_3X_EXTENSION__ */



	if (sys_event_only == FALSE)
	{
		/* VM cannot retrieve key event, or application lost key */
		/* Check if key event ring buffer */
		kal_uint16 key_code, key_type, mmi_pen_type,x, y;
		enum KVMEventTypes pen_type;

		if (jvm_keypad_fetch(&key_code, &key_type) &&
			j2me_translate_keyevent(key_code, key_type, &evt))
		{
			/* Check if menu event */
			if ((evt.type == keyDownKVMEvent) ||
				(evt.type == keyRepeatKVMEvent))
			{
				jboolean    tmp;

				/* Force to handle END_KEY for consistent behavior, some app
				 blocked in check permission and pending for a while. */
				if (evt.chr == J2ME_KEY_END)
				{
					ERROR_THROW(-1);
					return;
				}

				tmp = LCDUIpopupMenuInternalEvent(evt.chr, &evt);
				if (tmp == KNI_FALSE)
				{
					tmp = LCDUImenuInternalEvent(evt.chr, &evt);
				}

				if ((evt.chr == J2ME_KEY_SOFT1) || (evt.chr == J2ME_KEY_SOFT2))
				{
					if (tmp == KNI_TRUE)
					{
						StoreMIDPEvent(&evt);
						getEvent = KNI_TRUE;
					}
				}
                else if ((tmp == KNI_FALSE) || (evt.type != invalidKVMEvent))
				{
					/* Not popup menu or menu event */
					tmp = VolumeInternalEvent(evt.chr, &evt);
					if (tmp == KAL_FALSE)
					{
						StoreMIDPEvent(&evt);
						getEvent = KNI_TRUE;
					}
					//return;
				}
			}
            else
			{
				/* General key event to dispatcher */
				StoreMIDPEvent(&evt);
				getEvent = KNI_TRUE;
				//return;
			}
		}
		else if (jvm_tp_fetch(&x, &y, &mmi_pen_type))
		{

			pen_type = (enum KVMEventTypes)mmi_pen_type;
			if (j2me_translate_tpevent(x, y, &pen_type))
			{
				evt.screenX = x;
				evt.screenY = y;
				evt.type = pen_type;
				if (LCDUIpopupMenuInternalEvent(0, &evt) != TRUE)
				{
					StoreMIDPEvent(&evt);
					getEvent = KNI_TRUE; 
				}
				//return;
			}
		}
	}

    ext_msg_num = 0;
    jvm_get_ext_queue_info((kal_uint32*)&ext_msg_num);

    if( ext_msg_num == 0 )
    {
		/* Process other general system event */
		if (forever && !getEvent)
		{
			/* Wait forever case */
			if (KGetMessage(&current_ilm) != KAL_SUCCESS)
            {
                return;
			}
            ext_msg_num = 1;
		}
        else if( waitUntil > 0 )
		{
			ulong64 now = CurrentTime_md();
			/* If wait time expired. */
			if (waitUntil < now)
            {
                return;
			}

			if (KPeekMessage(&current_ilm, (kal_uint32)(waitUntil - now))
				!= KAL_SUCCESS)
			{
                return;
			}
            ext_msg_num = 1;
		}
    }
    else
    {
        if (KPeekMessage(&current_ilm, 0) != KAL_SUCCESS)
        {
            return;
        }
    }


    while( ext_msg_num > 0 )
    {
		if (current_ilm.msg_id == MSG_ID_MMI_JAVA_ABORT_REQ)
		{
			/* we should process this message and terminate JAVA ASAP*/
			MidpCommandState.nextCommand = EXIT;
			g_jvm_allowed_sending_abort_from_idle = KAL_TRUE;
			if (MidpCommandState.initialCommand == INSTALL ||
				MidpCommandState.initialCommand == UPDATE ||
				MidpCommandState.initialCommand == INSTALL_JAR)
			{
				free_ilm(&current_ilm);
				ERROR_THROW(JAVA_EXIT_MAIN_OK);	/* long jump back to VM exit point*/
			}
            else
			{
				terminateTime = CurrentTime_md();
				vm_is_force_terminated = KAL_TRUE;
			}
		}
        else if (j2me_custom_handler(J2ME_CUSTOM_EVENT_HANDLER, &current_ilm) != 0)
		{
			/* Check if custom event */
			free_ilm(&current_ilm);
			MidpCommandState.nextCommand = EXIT;
			g_jvm_allowed_sending_abort_from_idle = KAL_TRUE;
			ERROR_THROW(JAVA_EXIT_MAIN_OK);	/* long jump back to VM exit point*/
		}

		/* Received incoming message - General message handling */
		if (!j2me_task_general_msg_handler(&current_ilm))
		{
			kal_int32 process_res;

			/*ASSERT(j2me_current_state);*/
			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);
				/*ASSERT(process_res);*/