jvm_event_adaptor.c

java 1.1 gemini 08_16

/*************************************************************************
 * extern variable
 *************************************************************************/
extern S32 MMI_status_bar_height;

/*************************************************************************
 * Gloable variable
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////////////////////////////////
//  JAVA KEYPAD SYSTEM
//////////////////////////////////////////////////////////////////////////////////////////////////////
#define JVM_KEYPAD_RING_BUFFER_SIZE_MASK  0x0f
#define JVM_KEYPAD_RING_BUFFER_SIZE          (JVM_KEYPAD_RING_BUFFER_SIZE_MASK+1)
#define KEY_DOWN_NUM (4)

typedef struct
{
    kal_uint16 code;
    kal_uint16 type;
} jvm_keypad_ring_buffer_struct;


static jvm_keypad_ring_buffer_struct jvm_keypad_ring_buffer[JVM_KEYPAD_RING_BUFFER_SIZE];
static int jvm_keypad_ring_buffer_reader;
static int jvm_keypad_ring_buffer_writer;
static int jvm_keypad_ring_buffer_size;
static kal_mutexid jvm_keypad_mutex;
kal_bool g_jvm_keypad_need_notify;
static kal_bool jvm_keypad_is_first_enter;
static kal_bool jvm_keypad_is_first_resume;
static kal_int16 last_down_key_num = 0;
static kal_int16 last_down_code[KEY_DOWN_NUM];
keypad_cb_funcptr jvm_keypad_event_notifier_cb_ptr = NULL;

#define DEC_POS(V)      ((V -1) &  JVM_KEYPAD_RING_BUFFER_SIZE_MASK)
#define INC_POS(V)      ((V +1) &  JVM_KEYPAD_RING_BUFFER_SIZE_MASK)

#define DEC_WRITER      DEC_POS(jvm_keypad_ring_buffer_writer)
#define INC_WRITER      INC_POS(jvm_keypad_ring_buffer_writer)

#define DEC_READER      DEC_POS(jvm_keypad_ring_buffer_reader)
#define INC_READER      INC_POS(jvm_keypad_ring_buffer_reader)

#define WRITER       jvm_keypad_ring_buffer_writer
#define READER       jvm_keypad_ring_buffer_reader
#define RINGSIZE     jvm_keypad_ring_buffer_size

/*************************************************************************
 *  prototype
 *************************************************************************/
void jvm_keypad_init(void);
void jvm_keypad_flush(void);
kal_bool jvm_keypad_fetch(kal_uint16 *code, kal_uint16 *type);
void jvm_keypad_insert(kal_uint16 code, kal_uint16 type);
void jvm_keypad_collector(void);
void jvm_keypad_register_notify(void);
void jvm_register_keypad(kal_bool is_resume);
void jvm_unregister_keypad(void);


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

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    jvm_keypad_mutex = kal_create_mutex("jvm kdb");
    g_jvm_keypad_need_notify = KAL_FALSE;
    endKeyPressed = KAL_FALSE;
}

/*****************************************************************************
 * FUNCTION
 *  jvm_keypad_event_notifier_register
 * DESCRIPTION
 *  
 * PARAMETERS
 *  fp      [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void jvm_keypad_event_notifier_register(keypad_cb_funcptr fp)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    jvm_keypad_event_notifier_cb_ptr = fp;

}


/*****************************************************************************
 * FUNCTION
 *  jvm_keypad_flush
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void jvm_keypad_flush(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int32 i;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_take_mutex(jvm_keypad_mutex);
    jvm_keypad_ring_buffer_reader = 0;
    jvm_keypad_ring_buffer_writer = 0;
    jvm_keypad_ring_buffer_size = 0;
    endKeyPressed = KAL_FALSE;
    if (!jvm_keypad_is_first_resume)
    {
        for (i = 0; i < KEY_DOWN_NUM; i++)
        {
            if (last_down_code[i] != -1)
            {
                if (jvm_keypad_event_notifier_cb_ptr)
                {
                    (*jvm_keypad_event_notifier_cb_ptr) (last_down_code[i], KEY_EVENT_UP);
                }
                last_down_code[i] = -1;
            }
        }
        last_down_key_num = 0;
    }
    kal_give_mutex(jvm_keypad_mutex);
}


/*****************************************************************************
 * FUNCTION
 *  jvm_keypad_fetch
 * DESCRIPTION
 *  
 * PARAMETERS
 *  code        [?]     [?]
 *  type        [?]     [?]
 * RETURNS
 *  
 *****************************************************************************/
kal_bool jvm_keypad_fetch(kal_uint16 *code, kal_uint16 *type)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_bool result = KAL_FALSE;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_take_mutex(jvm_keypad_mutex);
    if (RINGSIZE > 0)
    {
        /*
         * We can enter critical-section only when have keyevent,
         * * worst case is to process the incoming kevent next loop but
         * * would be better for performance.
         */
        *code = jvm_keypad_ring_buffer[READER].code;
        *type = jvm_keypad_ring_buffer[READER].type;
        READER = INC_READER;
        RINGSIZE--;
        result = KAL_TRUE;
    }
    else
    {
        if (jvm_keypad_is_first_resume && last_down_key_num > 0)
        {
            int i;

            for (i = 0; i < KEY_DOWN_NUM; i++)
            {
                if (last_down_code[i] != -1)
                {
                    *code = last_down_code[i];
                    last_down_code[i] = -1;
                    break;
                }
            }

            if (i == KEY_DOWN_NUM)
            {
                ASSERT(0);
            }
            last_down_key_num--;
            *type = KEY_EVENT_UP;
            result = KAL_TRUE;
        }
    }
    kal_give_mutex(jvm_keypad_mutex);

    if (result && !jvm_keypad_is_first_resume)
    {
        int i;

        if (*type == KEY_EVENT_DOWN)
        {
            for (i = 0; i < KEY_DOWN_NUM; i++)
            {
                if (last_down_code[i] == -1)
                {
                    last_down_code[i] = *code;
                    break;
                }
            }
            last_down_key_num++;
        }
        else
        {
            /* up, long press, or repeat without a down key */
            if (last_down_key_num == 0)
            {
                result = KAL_FALSE;
            }
            else if (*type == KEY_EVENT_UP)
            {
                for (i = 0; i < KEY_DOWN_NUM; i++)
                {
                    if (last_down_code[i] == *code)
                    {
                        last_down_code[i] = -1;
                        last_down_key_num--;
                        break;
                    }
                }
            }
        }
        if (last_down_key_num >= 4 || last_down_key_num < 0)
        {
            int i;

            Kputs("KP error");
            result = KAL_FALSE;
            last_down_key_num = 0;
            for (i = 0; i < KEY_DOWN_NUM; i++)
            {
                last_down_code[i] = -1;
            }
        }
    }
    if (last_down_key_num == 0 && jvm_keypad_is_first_resume)
    {
        jvm_keypad_is_first_resume = KAL_FALSE;
    }
    if (result)
    {
        kal_trace(TRACE_GROUP_9, FUNC_JVM_KEYPAD_FETCH, 32767, last_down_key_num);
        kal_trace(TRACE_GROUP_9, FUNC_JVM_KEYPAD_FETCH, (*code), (*type));
    }
    return result;
}


/*****************************************************************************
 * FUNCTION
 *  jvm_keypad_insert
 * DESCRIPTION
 *  
 * PARAMETERS
 *  code        [IN]        
 *  type        [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void jvm_keypad_insert(kal_uint16 code, kal_uint16 type)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int32 i;
    kal_bool Is_match_UP = KAL_FALSE;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_GROUP_9, FUNC_JVM_KEYPAD_INSERT, code, type, endKeyPressed);

    if (endKeyPressed == KAL_FALSE)
    {
        /*
         *  Let LSK and RSK action like MMI 
         */

        j2me_lcd_mutex_lock();

        /* To avoid the key up on popup screnn and then mismatch on soft button status */
        if (code == KEY_LSK || code == KEY_RSK)
        {
            jui_widget_softkey_handler(code, type);
            SetKeyHandler((FuncPtr) jvm_keypad_collector, KEY_LSK, KEY_EVENT_UP);
            SetKeyHandler((FuncPtr) jvm_keypad_collector, KEY_LSK, KEY_EVENT_DOWN);
            SetKeyHandler((FuncPtr) jvm_keypad_collector, KEY_LSK, KEY_EVENT_REPEAT);
            SetKeyHandler((FuncPtr) jvm_keypad_collector, KEY_LSK, KEY_EVENT_LONG_PRESS);
            SetKeyHandler((FuncPtr) jvm_keypad_collector, KEY_RSK, KEY_EVENT_UP);
            SetKeyHandler((FuncPtr) jvm_keypad_collector, KEY_RSK, KEY_EVENT_DOWN);
            SetKeyHandler((FuncPtr) jvm_keypad_collector, KEY_RSK, KEY_EVENT_REPEAT);
            SetKeyHandler((FuncPtr) jvm_keypad_collector, KEY_RSK, KEY_EVENT_LONG_PRESS);
        }

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

            if (kcode == -1)
            {
                continue;
            }
            if (code == kcode && type == KEY_EVENT_UP)
            {
                Is_match_UP = KAL_TRUE;
                break;
            }
        }

        if (RINGSIZE + 6 < JVM_KEYPAD_RING_BUFFER_SIZE || Is_match_UP)
        {
            /* if( RINGSIZE + 6 < (JVM_KEYPAD_RING_BUFFER_SIZE) || type != KEY_EVENT_REPEAT ){ */
            /* reject the repeated key to fill in the last two spaces */
            /* still have room to put the key */
            jvm_keypad_ring_buffer[WRITER].code = code;
            jvm_keypad_ring_buffer[WRITER].type = type;
            WRITER = INC_WRITER;
            RINGSIZE++;
            /* } */
        }
        else if (RINGSIZE > 0)
        {
            int pos = DEC_WRITER;

            /* when we want drop the release key, we should drop the press key together */
            if (type == KEY_EVENT_UP)
            {
                if (jvm_keypad_ring_buffer[pos].type == KEY_EVENT_DOWN && jvm_keypad_ring_buffer[pos].code == code)
                {
                    WRITER = DEC_WRITER;
                    RINGSIZE--;
                }
            }
        }
        kal_give_mutex(jvm_keypad_mutex);
    }

    /* If JVM will sleep for message to wakeup, send that */
    if (g_jvm_keypad_need_notify)
    {
        g_jvm_keypad_need_notify = KAL_FALSE;
        jvm_send_keypad_notify_ind();
    }
}


/*****************************************************************************
 * FUNCTION
 *  jvm_keypad_collector
 * DESCRIPTION
 *  collect all key event, insert key event into pool buffer except
 *  END key
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void jvm_keypad_collector(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint16 Keycode, Keytype;

#ifdef __THREE_KEY_DETECTION_SWITCHABLE__