jvm_event_adaptor.c

java 1.1 gemini 08_16

    kal_int32 i;
    kal_bool key_matched = KAL_FALSE, accept_two_key_only = KAL_FALSE;
#endif /* __THREE_KEY_DETECTION_SWITCHABLE__ */ 

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    GetkeyInfo(&Keycode, &Keytype);

    if (jvm_keypad_is_first_enter && Keytype != KEY_EVENT_DOWN) /* drop key */
    {
        return;
    }

    jvm_keypad_is_first_enter = KAL_FALSE;

#ifdef __THREE_KEY_DETECTION_SWITCHABLE__
    kal_trace(TRACE_GROUP_9, FUNC_JVM_KEYPAD_FETCH, 65536, Keytype);
    kal_trace(TRACE_GROUP_9, FUNC_JVM_KEYPAD_FETCH, last_down_key_num, Keycode);
    kal_trace(TRACE_GROUP_9, FUNC_JVM_KEYPAD_FETCH, last_down_code[0], last_down_code[1]);
    kal_trace(TRACE_GROUP_9, FUNC_JVM_KEYPAD_FETCH, last_down_code[2], last_down_code[3]);
    if (Keytype == KEY_EVENT_DOWN && Keycode != KEY_UP_ARROW && Keycode != KEY_DOWN_ARROW &&
        Keycode != KEY_SEND && Keycode != KEY_LEFT_ARROW && Keycode != KEY_RIGHT_ARROW &&
        Keycode != KEY_ENTER && last_down_key_num >= 2)
    {
        return;
    }

    for (i = 0; i < KEY_DOWN_NUM; i++)
    {
        kal_int16 kcode = last_down_code[i];

        if (kcode == -1)
        {
            continue;
        }
        if (kcode == Keycode)
        {
            key_matched = KAL_TRUE;
        }
        if (kcode != KEY_UP_ARROW && kcode != KEY_DOWN_ARROW && kcode != KEY_SEND
            && kcode != KEY_LEFT_ARROW && kcode != KEY_RIGHT_ARROW && kcode != KEY_ENTER)
        {
            accept_two_key_only = KAL_TRUE;
        }
    }

    if (!key_matched && last_down_key_num >= 2 && accept_two_key_only)
    {
        return;
    }

#endif /* __THREE_KEY_DETECTION_SWITCHABLE__ */ 

#if defined(J2ME_SUPPORT_PAUSE) || defined(J2ME_SUPPORT_BACKGROUND)
    if (Keycode == KEY_END && jvm_is_own_screen() && !mmi_java_tck_is_execute())
    {

        // jvm_keypad_flush();  /* clear java key buffer */
        jvm_tp_flush();
        if (Keytype == KEY_EVENT_DOWN)
        {
            if (jvm_canbe_paused() == KAL_TRUE)
            {
                mmi_java_entry_terminate_dialog();
            }
        #if defined(J2ME_SUPPORT_BACKGROUND)
            else if (jvm_canbe_minimize())
            {
                mmi_java_entry_terminate_dialog_without_pause();
            }
        #endif /* defined(J2ME_SUPPORT_BACKGROUND) */ 
            else
            {
                mmi_java_entry_force_terminate_dialog();
            }
        }
        return;
    }
#else
    if (Keycode == KEY_END && jvm_is_own_screen() && !mmi_java_tck_is_execute())
    {
        jvm_enter_terminate_mode();
        GoBackHistory();
        mmi_java_entry_terminating(MMI_FALSE);
        return;
    }
#endif /* defined(J2ME_SUPPORT_PAUSE) || defined(J2ME_SUPPORT_BACKGROUND) */ 
    jvm_keypad_insert(Keycode, Keytype);

    if (jvm_keypad_event_notifier_cb_ptr)
    {
        kal_uint16 keycode;
        kal_uint16 keytype;

        if (jvm_keypad_fetch(&keycode, &keytype))
        {
            (*jvm_keypad_event_notifier_cb_ptr) (keycode, keytype);
        }

    }

}


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

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    g_jvm_keypad_need_notify = KAL_TRUE;
}


/*****************************************************************************
 * FUNCTION
 *  jvm_register_keypad
 * DESCRIPTION
 *  this function will register keypad handler to JVM_redirect_keyevent() function.
 * CALLS
 *  
 * PARAMETERS
 *  is_resume       [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void jvm_register_keypad(kal_bool is_resume)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U16 keyCode = 0;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    endKeyPressed = KAL_FALSE;
    ClearAllKeyHandler();
    clear_left_softkey();
    clear_right_softkey();
    register_default_hide_softkeys();

    /* enable 2 or 3 key simultanenous detection */
#ifdef __TWO_KEY_DETECTION_SWITCHABLE__
    mmi_kbd_set_concurrent_mode(CONCURRENT_KEY_MODE_2_KEYS);
#elif defined(__THREE_KEY_DETECTION_SWITCHABLE__)
    mmi_kbd_set_concurrent_mode(CONCURRENT_KEY_MODE_3_KEYS);
#endif 

    if (is_resume)
    {
        jvm_keypad_is_first_resume = KAL_TRUE;
        jvm_keypad_ring_buffer_reader = 0;
        jvm_keypad_ring_buffer_writer = 0;
        jvm_keypad_ring_buffer_size = 0;
        endKeyPressed = KAL_FALSE;
        set_left_softkey_label((UI_string_type) jui_softkey_label[0]);
        set_right_softkey_label((UI_string_type) jui_softkey_label[1]);

        if (jvm_keypad_event_notifier_cb_ptr)
        {
            kal_uint16 keycode;
            kal_uint16 keytype;

            while (jvm_keypad_fetch(&keycode, &keytype))
            {
                (*jvm_keypad_event_notifier_cb_ptr)(keycode, keytype);
            }
        }

    }
    else
    {
        int i;

        jui_softkey_label[0][0] = 0;
        jui_softkey_label[0][1] = 0;
        jui_softkey_label[1][0] = 0;
        jui_softkey_label[1][1] = 0;
        set_left_softkey_label((UI_string_type) jui_softkey_label[0]);
        set_right_softkey_label((UI_string_type) jui_softkey_label[1]);
        jvm_keypad_is_first_enter = KAL_TRUE;
        last_down_key_num = 0;
        for (i = 0; i < KEY_DOWN_NUM; i++)
        {
            last_down_code[i] = -1;
        }
    }

    jvm_keypad_flush();

    for (keyCode = 0; keyCode < MAX_KEYS; keyCode++)
    {
        SetKeyHandler((FuncPtr) jvm_keypad_collector, keyCode, KEY_EVENT_UP);
        SetKeyHandler((FuncPtr) jvm_keypad_collector, keyCode, KEY_EVENT_DOWN);
        SetKeyHandler((FuncPtr) jvm_keypad_collector, keyCode, KEY_EVENT_REPEAT);
        SetKeyHandler((FuncPtr) jvm_keypad_collector, keyCode, KEY_EVENT_LONG_PRESS);
    }
}


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

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* disable 2 or 3 key simultanenous detection */
#if defined(__THREE_KEY_DETECTION_SWITCHABLE__) || defined(__TWO_KEY_DETECTION_SWITCHABLE__)
    mmi_kbd_set_concurrent_mode(CONCURRENT_KEY_MODE_1_KEY);
#endif 

    set_left_softkey_label((UI_string_type) 0);
    set_right_softkey_label((UI_string_type) 0);
    clear_left_softkey();
    clear_right_softkey();
    ClearAllKeyHandler();
}

//////////////////////////////////////////////////////////////////////////////////////////////////////
//  JAVA TouchPanel SYSTEM
//////////////////////////////////////////////////////////////////////////////////////////////////////
#define JVM_TP_RING_BUFFER_SIZE_MASK   0x3F
#define JVM_TP_RING_BUFFER_SIZE        (JVM_TP_RING_BUFFER_SIZE_MASK+1)

typedef struct
{
    kal_uint16 x;
    kal_uint16 y;
    kal_uint16 type;
} jvm_tp_ring_buffer_struct;

static jvm_tp_ring_buffer_struct jvm_tp_ring_buffer[JVM_TP_RING_BUFFER_SIZE];
static int jvm_tp_ring_buffer_reader;
static int jvm_tp_ring_buffer_writer;
static int jvm_tp_ring_buffer_size;
static kal_mutexid jvm_tp_mutex;

/*
 * this variable is used to indicate if Java touch panel is
 * * in virtual direction key mode or normal mode 
 */
static kal_bool tp_virtual_direction = KAL_FALSE;

/*
 * this is the screen slope (x/y) * 65536 ( << 16). The 
 * * value will be used to get the direction of the screen area 
 */
static kal_bool java_level_tp_virtual = KAL_TRUE;

/*
 * this is the screen slope (x/y) * 65536 ( << 16). The 
 * * value will be used to get the direction of the screen area 
 */
static int screen_diagonal_slope;

/*
 * after pressing touch panel on the virtual keypad mode, 
 * * tp moving will triger the kbd_onekey_repeated every 80 ms
 * * this variable is used to memorize the last pressed key event.
 */
static kal_uint16 tp_virtual_last_pressed_key_code = 0;

/*
 * the variable indicates the last touch panel pressed time.
 * * the time is in ticks got by kal_get_time
 */
#ifdef __MMI_TOUCH_SCREEN__
static kal_uint32 last_pressed_ticks = 0;
static kal_bool has_pressed;
#endif /* __MMI_TOUCH_SCREEN__ */ 

#define TP_DEC_POS(V)      ((V -1) &  JVM_TP_RING_BUFFER_SIZE_MASK)
#define TP_INC_POS(V)      ((V +1) &  JVM_TP_RING_BUFFER_SIZE_MASK)

#define TP_DEC_WRITER      TP_DEC_POS(jvm_tp_ring_buffer_writer)
#define TP_INC_WRITER      TP_INC_POS(jvm_tp_ring_buffer_writer)

#define TP_DEC_READER      TP_DEC_POS(jvm_tp_ring_buffer_reader)
#define TP_INC_READER      TP_INC_POS(jvm_tp_ring_buffer_reader)

#define TP_WRITER       jvm_tp_ring_buffer_writer
#define TP_READER       jvm_tp_ring_buffer_reader
#define TP_RINGSIZE     jvm_tp_ring_buffer_size

/*************************************************************************
 *  prototype
 *************************************************************************/
void jvm_tp_init(void);
void jvm_tp_flush(void);
kal_bool jvm_tp_fetch(kal_uint16 *x, kal_uint16 *y, kal_uint16 *type);
void jvm_tp_insert(kal_uint16 x, kal_uint16 y, kal_uint16 type);


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

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    jvm_tp_mutex = kal_create_mutex("jvm tp");
    g_jvm_keypad_need_notify = KAL_FALSE;
    screen_diagonal_slope = (jui_widget_get_display_width() << 16) / jui_widget_get_display_height();
}


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

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_take_mutex(jvm_tp_mutex);
    jvm_tp_ring_buffer_reader = 0;
    jvm_tp_ring_buffer_writer = 0;
    jvm_tp_ring_buffer_size = 0;
    kal_give_mutex(jvm_tp_mutex);
}


/*****************************************************************************
 * FUNCTION
 *  set_virtual_direction
 * DESCRIPTION
 *  
 * PARAMETERS
 *  is_direction        [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
/*
 * this function is used to set the touch panel mode.
 * * is_derection == KAL_TRUE, use virtual keypad.
 * * is_derection == KAL_FALSE, use normal touch panel.
 */
void set_virtual_direction(kal_bool is_direction)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

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