keybrd.c

MTK手机平台的MMI部分的源代码

 * #define VK_LWIN           0x5B
 * #define VK_RWIN           0x5C
 * #define VK_APPS           0x5D
 * 
 * #define VK_NUMPAD0        0x60
 * #define VK_NUMPAD1        0x61
 * #define VK_NUMPAD2        0x62
 * #define VK_NUMPAD3        0x63
 * #define VK_NUMPAD4        0x64
 * #define VK_NUMPAD5        0x65
 * #define VK_NUMPAD6        0x66
 * #define VK_NUMPAD7        0x67
 * #define VK_NUMPAD8        0x68
 * #define VK_NUMPAD9        0x69
 * #define VK_MULTIPLY       0x6A
 * #define VK_ADD            0x6B
 * #define VK_SEPARATOR      0x6C
 * #define VK_SUBTRACT       0x6D
 * #define VK_DECIMAL        0x6E
 * #define VK_DIVIDE         0x6F
 * #define VK_F1             0x70
 * #define VK_F2             0x71
 * #define VK_F3             0x72
 * #define VK_F4             0x73
 * #define VK_F5             0x74
 * #define VK_F6             0x75
 * #define VK_F7             0x76
 * #define VK_F8             0x77
 * #define VK_F9             0x78
 * #define VK_F10            0x79
 * #define VK_F11            0x7A
 * #define VK_F12            0x7B
 * #define VK_F13            0x7C
 * #define VK_F14            0x7D
 * #define VK_F15            0x7E
 * #define VK_F16            0x7F
 * #define VK_F17            0x80
 * #define VK_F18            0x81
 * #define VK_F19            0x82
 * #define VK_F20            0x83
 * #define VK_F21            0x84
 * #define VK_F22            0x85
 * #define VK_F23            0x86
 * #define VK_F24            0x87
 *
 */

static const KeyPadMap nKeyPadMap[] = 
{
    {KEY_0, KEY_0, KEY_TIMER_ID0, TONE_DTMF_0, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD0 /* 0 */ },
    {KEY_1, KEY_1, KEY_TIMER_ID1, TONE_DTMF_1, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD1 /* 1 */ },
    {KEY_2, KEY_2, KEY_TIMER_ID2, TONE_DTMF_2, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD2 /* 2 */ },
    {KEY_3, KEY_3, KEY_TIMER_ID3, TONE_DTMF_3, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD3 /* 3 */ },
    {KEY_4, KEY_4, KEY_TIMER_ID4, TONE_DTMF_4, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD4 /* 4 */ },
    {KEY_5, KEY_5, KEY_TIMER_ID5, TONE_DTMF_5, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD5 /* 5 */ },
    {KEY_6, KEY_6, KEY_TIMER_ID6, TONE_DTMF_6, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD6 /* 6 */ },
    {KEY_7, KEY_7, KEY_TIMER_ID7, TONE_DTMF_7, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD7 /* 7 */ },
    {KEY_8, KEY_8, KEY_TIMER_ID8, TONE_DTMF_8, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD8 /* 8 */ },
    {KEY_9, KEY_9, KEY_TIMER_ID9, TONE_DTMF_9, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD9 /* 9 */ },
    {KEY_LSK, KEY_LSK, KEY_TIMER_ID10, TONE_KEY_STAR, DEVICE_AUDIO_PLAY_INFINITE, VK_INSERT /* Ins */ },
    {KEY_RSK, KEY_RSK, KEY_TIMER_ID11, TONE_KEY_HASH, DEVICE_AUDIO_PLAY_INFINITE, VK_PRIOR /* PgUp */ },
    {KEY_UP_ARROW, KEY_UP_ARROW, KEY_TIMER_ID12, TONE_KEY_VOL_UP, DEVICE_AUDIO_PLAY_ONCE, VK_UP /* Up */ },
    {KEY_DOWN_ARROW, KEY_DOWN_ARROW, KEY_TIMER_ID13, TONE_KEY_VOL_DOWN, DEVICE_AUDIO_PLAY_ONCE, VK_DOWN /* Down */ },
    {KEY_LEFT_ARROW, KEY_LEFT_ARROW, KEY_TIMER_ID14, TONE_KEY_LEFT, DEVICE_AUDIO_PLAY_ONCE, VK_LEFT /* Left */ },
    {KEY_RIGHT_ARROW, KEY_RIGHT_ARROW, KEY_TIMER_ID15, TONE_KEY_RIGHT, DEVICE_AUDIO_PLAY_ONCE, VK_RIGHT /* Right */ },
    {KEY_SEND, KEY_SEND, KEY_TIMER_ID16, TONE_KEY_SEND, DEVICE_AUDIO_PLAY_ONCE, VK_DELETE /* Del */ },
    {KEY_END, KEY_END, KEY_TIMER_ID17, TONE_KEY_END, DEVICE_AUDIO_PLAY_ONCE, VK_NEXT /* PgDn */ },
    {KEY_CLEAR, KEY_CLEAR, KEY_TIMER_ID25, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, VK_END /* End */ },
    {KEY_STAR, KEY_STAR, KEY_TIMER_ID19, TONE_KEY_STAR, DEVICE_AUDIO_PLAY_INFINITE, VK_DIVIDE /* / */ },
    {KEY_POUND, KEY_POUND, KEY_TIMER_ID20, TONE_KEY_HASH, DEVICE_AUDIO_PLAY_INFINITE, VK_MULTIPLY /* * */ },
    {KEY_VOL_UP, KEY_VOL_UP, KEY_TIMER_ID21, TONE_KEY_VOL_UP, DEVICE_AUDIO_PLAY_ONCE, VK_ADD /* + */ },
    {KEY_VOL_DOWN, KEY_VOL_DOWN, KEY_TIMER_ID22, TONE_KEY_VOL_DOWN, DEVICE_AUDIO_PLAY_ONCE, VK_SUBTRACT /* - */ },
    {KEY_INVALID, KEY_INVALID, KEY_TIMER_ID_NONE, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, 0 /* None */ },
    {KEY_QUICK_ACS, KEY_QUICK_ACS, KEY_TIMER_ID19, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, VK_BACK /* Backspace */ },
    {KEY_ENTER, KEY_ENTER, KEY_TIMER_ID18, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, VK_RETURN /* Enter */ },
    {KEY_EXTRA_1, KEY_EXTRA_1, KEY_TIMER_ID27, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, VK_F1 /* F1 */ },
    {KEY_EXTRA_2, KEY_EXTRA_2, KEY_TIMER_ID28, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, VK_F2 /* F2 */ },
    {KEY_PLAY_STOP, KEY_PLAY_STOP, KEY_TIMER_ID29, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, 0 /* TBD */},
    {KEY_FWD, KEY_FWD, KEY_TIMER_ID30, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, 0 /* TBD */},
    {KEY_BACK, KEY_BACK, KEY_TIMER_ID31, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, 0 /* TBD */}
};
#endif /* MMI_ON_WIN32 */ 

extern void IdleHandleKeypadLockProcess(void);

#if defined(__MMI_HUMAN_VOICE_KEYPAD_TONE__)
extern U8 CanPlayHumanVoiceKeyTone(void);
#endif 

#if defined(__MMI_CUST_KEYPAD_TONE__)
extern U8 CanPlayCustKeyTone(void);
#endif 

#if defined(MMI_ON_WIN32)
extern void MMI_system_keybord_handler(S32 key_code, S32 key_state);
#endif 

extern void ShutdownSystemOperation(void);

/*****************************************************************************
 * FUNCTION
 *  InitProcessKeyEvent
 * DESCRIPTION
 *  To init the process key handler for preprocessing and postprocessing.
 * PARAMETERS
 *  void
 *  U32(?)      [IN]        MsgType, U16 KeyMapIndex
 * RETURNS
 *  void
 *****************************************************************************/
void InitProcessKeyEvent(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U16 i = 0;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    for (i = 0; i < MAX_KEYS; i++)
    {
        nKeyPadStatus[i] = KEY_EVENT_UP;
        key_is_pressing_count = 0;
    }
}


/*****************************************************************************
 * FUNCTION
 *  KeyEventHandler
 * DESCRIPTION
 *  To handle the key event.
 * PARAMETERS
 *  eventKey        [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
static void KeyEventHandler(KEYBRD_MESSAGE *eventKey)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* Preprocess the keypad handler */
    mmi_kbd_app_key_hdlr(eventKey);

    if (g_mmi_frm_cntx.kbd_pre_func)
    {
        g_mmi_frm_cntx.kbd_pre_func(eventKey);
    }

    /* Process the register App keypad handler */
    ExecuteCurrKeyHandler((S16) eventKey->nKeyCode, (S16) eventKey->nMsgType);

    if (g_mmi_frm_cntx.kbd_post_func)
    {
        g_mmi_frm_cntx.kbd_post_func(eventKey);
    }

}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_get_2step_keys
 * DESCRIPTION
 *  To get the 2 step keys of handset.
 *  The function should be called in MMI_Init()
 * PARAMETERS
 *  void
 *  KEYBRD_MESSAGE(?)       [IN]        *eventKey
 * RETURNS
 *  void
 *****************************************************************************/
extern void kbd_find_2step(kal_uint32 *number, kal_uint8 *two_step);
void mmi_frm_get_2step_keys(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U32 i;
    U8 _2step_key[MAX_KEYS];

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    memset(_2step_key, 0, sizeof(U8) * MAX_KEYS);
    memset(g_2step_keyCode, 0, sizeof(U16) * MAX_KEYS);

#ifndef MMI_ON_WIN32
    kbd_find_2step(&g_2step_key_num, _2step_key);
#endif 
    for (i = 0; i < g_2step_key_num; i++)
    {
        g_2step_keyCode[i] = nKeyPadMap[_2step_key[i]].nMMIKeyCode;
    }
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_is_2step_keyCode
 * DESCRIPTION
 *  To get the 2 step keys of handset.
 *  The function should be called in MMI_Init()
 * PARAMETERS
 *  keyCode                 [IN]        
 *  KEYBRD_MESSAGE(?)       [IN]        *eventKey
 * RETURNS
 *  MMI_TRUE - it's 2 step key
 *  MMI_FALSE - it isn't 2 step key
 *****************************************************************************/
static MMI_BOOL mmi_frm_is_2step_keyCode(U16 keyCode)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U32 i;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    for (i = 0; i < g_2step_key_num; i++)
    {
        if (keyCode == g_2step_keyCode[i])
        {
            return MMI_TRUE;
        }
    }

    return MMI_FALSE;
}


/*****************************************************************************
 * FUNCTION
 *  ProcessKeyEvent
 * DESCRIPTION
 *  To send the key events to MMI task
 * PARAMETERS
 *  MsgType         [IN]        
 *  KeyMapIndex     [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
/* TBD */
#define DRV_WM_ENABLE_TWOKEY_DETECTION             5
#define DRV_WM_DISABLE_TWOKEY_DETECTION               6
void ProcessKeyEvent(U32 MsgType, U16 KeyMapIndex)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_ASSERT(KeyMapIndex < MAX_KEYPADMAP);
    MMI_ASSERT(nKeyPadMap[KeyMapIndex].nMMIKeyCode != KEY_INVALID);

    MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_PROC_KEYEVENT_HDLR, MsgType, nKeyPadMap[KeyMapIndex].nMMIKeyCode));

    if (MsgType == WM_KEYPRESS)
    {
        if (nKeyPadStatus[KeyMapIndex] == KEY_EVENT_UP)
        {

            KEYBRD_MESSAGE KeyBrdMsg;

            KeyBrdMsg.nKeyCode = nKeyPadMap[KeyMapIndex].nMMIKeyCode;
            if (mmi_frm_is_2step_keyCode(KeyBrdMsg.nKeyCode))
            {
                nKeyPadStatus[KeyMapIndex] = KEY_HALF_PRESS_DOWN;
                key_is_pressing_count++;
                KeyBrdMsg.nMsgType = KEY_HALF_PRESS_DOWN;
            }
            else
            {
                nKeyPadStatus[KeyMapIndex] = KEY_EVENT_DOWN;    /* same with KEY_FULL_PRESS_DOWN */
                key_is_pressing_count++;
                KeyBrdMsg.nMsgType = KEY_EVENT_DOWN;
            }
            KeyEventHandler((KEYBRD_MESSAGE*) & KeyBrdMsg);

        #ifdef MMI_ON_WIN32
            StartTimer(nKeyPadMap[KeyMapIndex].nTimerId, KEYTIMER_LONGPRESS, (FuncPtr) KeyTimerExpiryProc);
        #endif 
        }
        else
        {
            /* Ignore the event */
        }
    }

    else if (MsgType == WM_KEYRELEASE)
    {
        if ((nKeyPadStatus[KeyMapIndex] == KEY_EVENT_DOWN)
            || (nKeyPadStatus[KeyMapIndex] == KEY_LONG_PRESS)
            || (nKeyPadStatus[KeyMapIndex] == KEY_REPEAT) || (nKeyPadStatus[KeyMapIndex] == KEY_HALF_PRESS_DOWN))
        {

            KEYBRD_MESSAGE KeyBrdMsg;

        #ifdef MMI_ON_WIN32
            /* stop timer as early as possible. avoid timer expire later */
            StopTimer(nKeyPadMap[KeyMapIndex].nTimerId);
        #endif /* MMI_ON_WIN32 */ 
            nKeyPadStatus[KeyMapIndex] = KEY_EVENT_UP;
            key_is_pressing_count--;
            KeyBrdMsg.nMsgType = KEY_EVENT_UP;
            KeyBrdMsg.nKeyCode = nKeyPadMap[KeyMapIndex].nMMIKeyCode;
            KeyEventHandler((KEYBRD_MESSAGE*) & KeyBrdMsg);

        }
        else
        {
            /* Ignore the event */
        }
    }
    /* ++Robin, modified by Max Chen */
#ifndef MMI_ON_WIN32
    else if (MsgType == DRV_WM_KEYLONGPRESS)
    {
        if (nKeyPadStatus[KeyMapIndex] == KEY_EVENT_DOWN)
        {
            KEYBRD_MESSAGE KeyBrdMsg;

            nKeyPadStatus[KeyMapIndex] = KEY_LONG_PRESS;
            KeyBrdMsg.nMsgType = KEY_LONG_PRESS;
            KeyBrdMsg.nKeyCode = nKeyPadMap[KeyMapIndex].nMMIKeyCode;
            KeyEventHandler((KEYBRD_MESSAGE*) & KeyBrdMsg);
        }
        else
        {
            /* Ignore the event */
        }
    }
    else if (MsgType == DRV_WM_KEYREPEATED)
    {
        if ((nKeyPadStatus[KeyMapIndex] == KEY_LONG_PRESS) || (nKeyPadStatus[KeyMapIndex] == KEY_REPEAT))
        {
            KEYBRD_MESSAGE KeyBrdMsg;

            nKeyPadStatus[KeyMapIndex] = KEY_REPEAT;
            KeyBrdMsg.nMsgType = KEY_REPEAT;
            KeyBrdMsg.nKeyCode = nKeyPadMap[KeyMapIndex].nMMIKeyCode;
            KeyEventHandler((KEYBRD_MESSAGE*) & KeyBrdMsg);
        }
        else
        {
            /* Ignore the event */
        }
    }
    else if (MsgType == DRV_WM_KEYFULLPRESS)
    {
        /*
         * Only in two-stage key will have KEY_FULL_PRESS_DOWN, and it followed after KEY_HALF_PRESS_DOWN
         */
        if (nKeyPadStatus[KeyMapIndex] == KEY_HALF_PRESS_DOWN)