开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
KeyBrd.c
资源名称：mmi.rar　[点击查看]
上传用户：lqx1163
上传日期：2014-08-13
资源大小：9183k
文件大小：75k
源码类别：

MTK

开发平台：

C/C++

KeyBrd.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*****************************************************************************
  37.  *
  38.  * Filename:
  39.  * ---------
  40.  * Keybrd.C
  41.  *
  42.  * Project:
  43.  * --------
  44.  *   MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  *   This file is intends for keypad processing
  49.  *
  50.  * Author:
  51.  * -------
  52.  * -------
  53.  *
  54.  *============================================================================
  55.  *             HISTORY
  56.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  57.  *------------------------------------------------------------------------------
  58.  * removed!
  59.  *
  60.  * removed!
  61.  * removed!
  62.  * removed!
  63.  *
  64.  * removed!
  65.  * removed!
  66.  * removed!
  67.  *
  68.  * removed!
  69.  * removed!
  70.  * removed!
  71.  *
  72.  * removed!
  73.  * removed!
  74.  * removed!
  75.  *
  76.  * removed!
  77.  * removed!
  78.  * removed!
  79.  *
  80.  * removed!
  81.  * removed!
  82.  * removed!
  83.  *
  84.  * removed!
  85.  * removed!
  86.  * removed!
  87.  * removed!
  88.  *
  89.  * removed!
  90.  * removed!
  91.  * removed!
  92.  *
  93.  * removed!
  94.  * removed!
  95.  * removed!
  96.  *
  97.  * removed!
  98.  * removed!
  99.  * removed!
  100.  *
  101.  * removed!
  102.  * removed!
  103.  * removed!
  104.  *
  105.  * removed!
  106.  * removed!
  107.  * removed!
  108.  *
  109.  * removed!
  110.  * removed!
  111.  * removed!
  112.  * removed!
  113.  * removed!
  114.  *
  115.  * removed!
  116.  * removed!
  117.  * removed!
  118.  * removed!
  119.  *
  120.  * removed!
  121.  * removed!
  122.  * removed!
  123.  *
  124.  * removed!
  125.  * removed!
  126.  * removed!
  127.  *
  128.  * removed!
  129.  * removed!
  130.  * removed!
  131.  *
  132.  * removed!
  133.  * removed!
  134.  * removed!
  135.  *
  136.  * removed!
  137.  * removed!
  138.  * removed!
  139.  *
  140.  * removed!
  141.  * removed!
  142.  * removed!
  143.  *
  144.  * removed!
  145.  * removed!
  146.  * removed!
  147.  *
  148.  * removed!
  149.  * removed!
  150.  * removed!
  151.  *
  152.  * removed!
  153.  * removed!
  154.  * removed!
  155.  *
  156.  * removed!
  157.  * removed!
  158.  * removed!
  159.  *
  160.  *------------------------------------------------------------------------------
  161.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  162.  *============================================================================
  163.  ****************************************************************************/
  165. /**
  166.  * Copyright Notice
  167.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  168.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  169.  *  (It is illegal to remove this copyright notice from this software or any
  170.  *  portion of it)
  171.  */
  173. /**************************************************************
  175.    FILENAME : KeyBrd.c
  177.    PURPOSE     : Key Board Handler 
  179.    REMARKS     : nil
  181.    AUTHOR      : Neeraj Sharma
  183.    DATE     : Aug 25, 2003
  185. **************************************************************/
  186. /*  Include: MMI header file */
  187. #include "MMI_features.h"
  188. #include "stdC.h"
  189. #include "L4Dr1.h"
  190. #include "PixtelDataTypes.h"
  191. #include "KeyBrd.h"
  192. #include "TimerEvents.h"
  194. #include "AudioInc.h"
  195. #include "GlobalConstants.h"
  196. #include "ThrdOsInterface.h"
  197. #include "DebugInitDef.h"
  198. #include "FrameworkStruct.h"
  199. #include "SettingProfile.h"
  200. #include "IdleAppDef.h"
  201. #include "QueueGprot.h"
  202. #include "taskinit.h"   /* amitM */
  203. #include "MMITaskProt.h"
  204. #include "WrapperGprot.h"
  205. #include "ProfileGprots.h"
  207. #include "L4Dr.h"
  208. #include "kbd_table.h"
  209. #include "MMI_trc.h"
  210. #include "EventsGprot.h"
  211. #include "gpioInc.h"
  212. #if defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__)
  213. #include "wgui_touch_screen.h"
  214. #endif 
  215. #include "ScreenRotationGprot.h"
  216. #include "kbd_table.h"
  217. #include "ProfilingEngine.h"
  218. #include "SimDetectionGprot.h"
  220. extern U8 processUpRepeatKey;
  221. extern U8 pressKey;
  223. /***************************************************************************** 
  224. * Define
  225. *****************************************************************************/
  226. #define MAX_PRESENTALLKEYS sizeof(PresentAllKeys)/sizeof(PresentAllKeys[0])
  227. #define MAX_PRESENTDIGITSKEYS sizeof(PresentDigitsKeys)/sizeof(PresentDigitsKeys[0])
  228. #define MAX_KEYPADMAP   sizeof(nKeyPadMap)/sizeof(nKeyPadMap[0])
  230. mmi_frm_context_struct g_mmi_frm_cntx;
  231. mmi_frm_context_struct *frm_p = &g_mmi_frm_cntx;
  233. /***************************************************************************** 
  234. * Local Variable
  235. *****************************************************************************/
  236. static U16 currKeyPadTone = 0xFFFF;
  237. static mmi_key_types_enum nKeyPadStatus[MAX_KEYS];
  239. /* allow multiple keys's processing at the same time */
  240. static MMI_BOOL g_kbd_concurrent_key_mode = MMI_FALSE;
  242. /* how many key under pressing  */
  243. static U8 key_is_pressing_count = 0;
  245. static MMI_BOOL g_process_key_in_high_frequency = MMI_FALSE;
  247. /***************************************************************************** 
  248. * Global Variable
  249. *****************************************************************************/
  250. extern oslMsgqid mmi_ext_qid;
  251. extern MMI_BOOL g_keypad_flag;
  252. extern drv_get_key_func keypad_ptr;
  254. U32 g_2step_key_num = 0;
  255. U16 g_2step_keyCode[MAX_KEYS];
  257. const U16 PresentDigitsKeys[] = {KEY_0, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9};
  258. const U16 PresentAllKeys[] = 
  259. {
  260.     KEY_0,
  261.     KEY_1,
  262.     KEY_2,
  263.     KEY_3,
  264.     KEY_4,
  265.     KEY_5,
  266.     KEY_6,
  267.     KEY_7,
  268.     KEY_8,
  269.     KEY_9,
  270.     KEY_LSK,
  271.     KEY_RSK,
  272.     KEY_UP_ARROW,
  273.     KEY_DOWN_ARROW,
  274.     KEY_LEFT_ARROW,
  275.     KEY_RIGHT_ARROW,
  276.     KEY_SEND,
  277.     KEY_END,
  278.     KEY_STAR,
  279.     KEY_POUND,
  280.     KEY_VOL_UP,
  281.     KEY_VOL_DOWN,
  282.     KEY_CLEAR,
  283.     KEY_CAMERA,
  284.     KEY_WAP,
  285.     KEY_EXTRA_1,
  286.     KEY_EXTRA_2,
  287.     KEY_PLAY_STOP,
  288.     KEY_PLAY_STOP,
  289.     KEY_BACK,
  290.     KEY_POWER
  291. //KP Jerry add on 2007-4-23 start  
  292.     ,KEY_LEFT_SHORTCUT
  293.     ,KEY_RIGHT_SHORTCUT
  294. //KP Jerry add on 2007-4-23 end
  295. };
  297. #ifndef MMI_ON_WIN32
  299. static const KeyPadMap nKeyPadMap[] = 
  300. {
  301.     {DEVICE_KEY_0, KEY_0, KEY_TIMER_ID0, TONE_DTMF_0, DEVICE_AUDIO_PLAY_INFINITE},
  302.     {DEVICE_KEY_1, KEY_1, KEY_TIMER_ID1, TONE_DTMF_1, DEVICE_AUDIO_PLAY_INFINITE},
  303.     {DEVICE_KEY_2, KEY_2, KEY_TIMER_ID2, TONE_DTMF_2, DEVICE_AUDIO_PLAY_INFINITE},
  304.     {DEVICE_KEY_3, KEY_3, KEY_TIMER_ID3, TONE_DTMF_3, DEVICE_AUDIO_PLAY_INFINITE},
  305.     {DEVICE_KEY_4, KEY_4, KEY_TIMER_ID4, TONE_DTMF_4, DEVICE_AUDIO_PLAY_INFINITE},
  306.     {DEVICE_KEY_5, KEY_5, KEY_TIMER_ID5, TONE_DTMF_5, DEVICE_AUDIO_PLAY_INFINITE},
  307.     {DEVICE_KEY_6, KEY_6, KEY_TIMER_ID6, TONE_DTMF_6, DEVICE_AUDIO_PLAY_INFINITE},
  308.     {DEVICE_KEY_7, KEY_7, KEY_TIMER_ID7, TONE_DTMF_7, DEVICE_AUDIO_PLAY_INFINITE},
  309.     {DEVICE_KEY_8, KEY_8, KEY_TIMER_ID8, TONE_DTMF_8, DEVICE_AUDIO_PLAY_INFINITE},
  310.     {DEVICE_KEY_9, KEY_9, KEY_TIMER_ID9, TONE_DTMF_9, DEVICE_AUDIO_PLAY_INFINITE},
  311.     {DEVICE_KEY_STAR, KEY_STAR, KEY_TIMER_ID10, TONE_KEY_STAR, DEVICE_AUDIO_PLAY_INFINITE},
  312.     {DEVICE_KEY_HASH, KEY_POUND, KEY_TIMER_ID11, TONE_KEY_HASH, DEVICE_AUDIO_PLAY_INFINITE},
  313.     {DEVICE_KEY_VOL_UP, KEY_VOL_UP, KEY_TIMER_ID12, TONE_KEY_VOL_UP, DEVICE_AUDIO_PLAY_ONCE},
  314.     {DEVICE_KEY_VOL_DOWN, KEY_VOL_DOWN, KEY_TIMER_ID13, TONE_KEY_VOL_DOWN, DEVICE_AUDIO_PLAY_ONCE},
  315.     {DEVICE_KEY_UP, KEY_UP_ARROW, KEY_TIMER_ID14, TONE_KEY_UP, DEVICE_AUDIO_PLAY_ONCE},
  316.     {DEVICE_KEY_DOWN, KEY_DOWN_ARROW, KEY_TIMER_ID15, TONE_KEY_DOWN, DEVICE_AUDIO_PLAY_ONCE},
  317.     {DEVICE_KEY_LEFT, KEY_LEFT_ARROW, KEY_TIMER_ID16, TONE_KEY_LEFT, DEVICE_AUDIO_PLAY_ONCE},
  318.     {DEVICE_KEY_RIGHT, KEY_RIGHT_ARROW, KEY_TIMER_ID17, TONE_KEY_RIGHT, DEVICE_AUDIO_PLAY_ONCE},
  319.     {DEVICE_KEY_MENU, KEY_ENTER, KEY_TIMER_ID18, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE},
  320.     {DEVICE_KEY_FUNCTION, KEY_QUICK_ACS, KEY_TIMER_ID19, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE},
  321.     {DEVICE_KEY_SK_LEFT, KEY_LSK, KEY_TIMER_ID20, TONE_KEY_SK_LEFT, DEVICE_AUDIO_PLAY_ONCE},
  322.     {DEVICE_KEY_SK_RIGHT, KEY_RSK, KEY_TIMER_ID21, TONE_KEY_SK_RIGHT, DEVICE_AUDIO_PLAY_ONCE},
  323.     {DEVICE_KEY_SEND, KEY_SEND, KEY_TIMER_ID22, TONE_KEY_SEND, DEVICE_AUDIO_PLAY_ONCE},
  324.     {DEVICE_KEY_END, KEY_END, KEY_TIMER_ID23, TONE_KEY_END, DEVICE_AUDIO_PLAY_ONCE},
  325.     {DEVICE_KEY_POWER, KEY_POWER, KEY_TIMER_ID24, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE},        /* 24 IMPORTANT :This will be power key */
  326.     {DEVICE_KEY_CLEAR, KEY_CLEAR, KEY_TIMER_ID25, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE},
  327.     {DEVICE_KEY_EXT_FUNC1, KEY_EXTRA_1, KEY_TIMER_ID27, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE},
  328.     {DEVICE_KEY_EXT_FUNC2, KEY_EXTRA_2, KEY_TIMER_ID28, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE},
  329.     {DEVICE_KEY_MP3_PLAY_STOP, KEY_PLAY_STOP, KEY_TIMER_ID29, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE},
  330.     {DEVICE_KEY_MP3_FWD, KEY_FWD, KEY_TIMER_ID30, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE},
  331.     {DEVICE_KEY_MP3_BACK, KEY_BACK, KEY_TIMER_ID31, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE}
  332. //KP Jerry add on 2007-4-23 start  
  333.     ,{DEVICE_KEY_MP3_SHORTCUT, KEY_LEFT_SHORTCUT, KEY_TIMER_ID32, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE}
  334.     ,{DEVICE_KEY_WAP_SHORTCUT, KEY_RIGHT_SHORTCUT, KEY_TIMER_ID33, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE}
  335. //KP Jerry add on 2007-4-23 end    
  336. };
  338. #else /* MMI_ON_WIN32 */ 
  339. /* 
  340.  * virtual-Key Code is defined in "WINUSER.H", and "WINDOWS.H" includes "WINUSER.H" 
  341.  *
  342.  * Constant name           Value (hexadecimal) 
  343.  *-------------------------------------------------
  344.  * #define VK_SPACE          0x20
  345.  * #define VK_PRIOR          0x21
  346.  * #define VK_NEXT           0x22
  347.  * #define VK_END            0x23
  348.  * #define VK_HOME           0x24
  349.  * #define VK_LEFT           0x25
  350.  * #define VK_UP             0x26
  351.  * #define VK_RIGHT          0x27
  352.  * #define VK_DOWN           0x28
  353.  * #define VK_SELECT         0x29
  354.  * #define VK_PRINT          0x2A
  355.  * #define VK_EXECUTE        0x2B
  356.  * #define VK_SNAPSHOT       0x2C
  357.  * #define VK_INSERT         0x2D
  358.  * #define VK_DELETE         0x2E
  359.  * #define VK_HELP           0x2F
  360.  *
  361.  * [ VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) ]
  362.  * [ VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) ]
  363.  *
  364.  * #define VK_LWIN           0x5B
  365.  * #define VK_RWIN           0x5C
  366.  * #define VK_APPS           0x5D
  367.  * 
  368.  * #define VK_NUMPAD0        0x60
  369.  * #define VK_NUMPAD1        0x61
  370.  * #define VK_NUMPAD2        0x62
  371.  * #define VK_NUMPAD3        0x63
  372.  * #define VK_NUMPAD4        0x64
  373.  * #define VK_NUMPAD5        0x65
  374.  * #define VK_NUMPAD6        0x66
  375.  * #define VK_NUMPAD7        0x67
  376.  * #define VK_NUMPAD8        0x68
  377.  * #define VK_NUMPAD9        0x69
  378.  * #define VK_MULTIPLY       0x6A
  379.  * #define VK_ADD            0x6B
  380.  * #define VK_SEPARATOR      0x6C
  381.  * #define VK_SUBTRACT       0x6D
  382.  * #define VK_DECIMAL        0x6E
  383.  * #define VK_DIVIDE         0x6F
  384.  * #define VK_F1             0x70
  385.  * #define VK_F2             0x71
  386.  * #define VK_F3             0x72
  387.  * #define VK_F4             0x73
  388.  * #define VK_F5             0x74
  389.  * #define VK_F6             0x75
  390.  * #define VK_F7             0x76
  391.  * #define VK_F8             0x77
  392.  * #define VK_F9             0x78
  393.  * #define VK_F10            0x79
  394.  * #define VK_F11            0x7A
  395.  * #define VK_F12            0x7B
  396.  * #define VK_F13            0x7C
  397.  * #define VK_F14            0x7D
  398.  * #define VK_F15            0x7E
  399.  * #define VK_F16            0x7F
  400.  * #define VK_F17            0x80
  401.  * #define VK_F18            0x81
  402.  * #define VK_F19            0x82
  403.  * #define VK_F20            0x83
  404.  * #define VK_F21            0x84
  405.  * #define VK_F22            0x85
  406.  * #define VK_F23            0x86
  407.  * #define VK_F24            0x87
  408.  *
  409.  */
  411. static const KeyPadMap nKeyPadMap[] = 
  412. {
  413.     {KEY_0, KEY_0, KEY_TIMER_ID0, TONE_DTMF_0, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD0 /* 0 */ },
  414.     {KEY_1, KEY_1, KEY_TIMER_ID1, TONE_DTMF_1, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD1 /* 1 */ },
  415.     {KEY_2, KEY_2, KEY_TIMER_ID2, TONE_DTMF_2, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD2 /* 2 */ },
  416.     {KEY_3, KEY_3, KEY_TIMER_ID3, TONE_DTMF_3, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD3 /* 3 */ },
  417.     {KEY_4, KEY_4, KEY_TIMER_ID4, TONE_DTMF_4, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD4 /* 4 */ },
  418.     {KEY_5, KEY_5, KEY_TIMER_ID5, TONE_DTMF_5, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD5 /* 5 */ },
  419.     {KEY_6, KEY_6, KEY_TIMER_ID6, TONE_DTMF_6, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD6 /* 6 */ },
  420.     {KEY_7, KEY_7, KEY_TIMER_ID7, TONE_DTMF_7, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD7 /* 7 */ },
  421.     {KEY_8, KEY_8, KEY_TIMER_ID8, TONE_DTMF_8, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD8 /* 8 */ },
  422.     {KEY_9, KEY_9, KEY_TIMER_ID9, TONE_DTMF_9, DEVICE_AUDIO_PLAY_INFINITE, VK_NUMPAD9 /* 9 */ },
  423.     {KEY_LSK, KEY_LSK, KEY_TIMER_ID10, TONE_KEY_STAR, DEVICE_AUDIO_PLAY_INFINITE, VK_INSERT /* Ins */ },
  424.     {KEY_RSK, KEY_RSK, KEY_TIMER_ID11, TONE_KEY_HASH, DEVICE_AUDIO_PLAY_INFINITE, VK_PRIOR /* PgUp */ },
  425.     {KEY_UP_ARROW, KEY_UP_ARROW, KEY_TIMER_ID12, TONE_KEY_VOL_UP, DEVICE_AUDIO_PLAY_ONCE, VK_UP /* Up */ },
  426.     {KEY_DOWN_ARROW, KEY_DOWN_ARROW, KEY_TIMER_ID13, TONE_KEY_VOL_DOWN, DEVICE_AUDIO_PLAY_ONCE, VK_DOWN /* Down */ },
  427.     {KEY_LEFT_ARROW, KEY_LEFT_ARROW, KEY_TIMER_ID14, TONE_KEY_LEFT, DEVICE_AUDIO_PLAY_ONCE, VK_LEFT /* Left */ },
  428.     {KEY_RIGHT_ARROW, KEY_RIGHT_ARROW, KEY_TIMER_ID15, TONE_KEY_RIGHT, DEVICE_AUDIO_PLAY_ONCE, VK_RIGHT /* Right */ },
  429.     {KEY_SEND, KEY_SEND, KEY_TIMER_ID16, TONE_KEY_SEND, DEVICE_AUDIO_PLAY_ONCE, VK_DELETE /* Del */ },
  430.     {KEY_END, KEY_END, KEY_TIMER_ID17, TONE_KEY_END, DEVICE_AUDIO_PLAY_ONCE, VK_NEXT /* PgDn */ },
  431.     {KEY_CLEAR, KEY_CLEAR, KEY_TIMER_ID25, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, VK_END /* End */ },
  432.     {KEY_STAR, KEY_STAR, KEY_TIMER_ID19, TONE_KEY_STAR, DEVICE_AUDIO_PLAY_INFINITE, VK_DIVIDE /* / */ },
  433.     {KEY_POUND, KEY_POUND, KEY_TIMER_ID20, TONE_KEY_HASH, DEVICE_AUDIO_PLAY_INFINITE, VK_MULTIPLY /* * */ },
  434.     {KEY_VOL_UP, KEY_VOL_UP, KEY_TIMER_ID21, TONE_KEY_VOL_UP, DEVICE_AUDIO_PLAY_ONCE, VK_ADD /* + */ },
  435.     {KEY_VOL_DOWN, KEY_VOL_DOWN, KEY_TIMER_ID22, TONE_KEY_VOL_DOWN, DEVICE_AUDIO_PLAY_ONCE, VK_SUBTRACT /* - */ },
  436.     {KEY_INVALID, KEY_INVALID, KEY_TIMER_ID_NONE, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, 0 /* None */ },
  437.     {KEY_QUICK_ACS, KEY_QUICK_ACS, KEY_TIMER_ID19, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, VK_BACK /* Backspace */ },
  438.     {KEY_ENTER, KEY_ENTER, KEY_TIMER_ID18, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, VK_RETURN /* Enter */ },
  439.     {KEY_EXTRA_1, KEY_EXTRA_1, KEY_TIMER_ID27, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, VK_F1 /* F1 */ },
  440.     {KEY_EXTRA_2, KEY_EXTRA_2, KEY_TIMER_ID28, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, VK_F2 /* F2 */ },
  441.     {KEY_PLAY_STOP, KEY_PLAY_STOP, KEY_TIMER_ID29, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, 0 /* TBD */},
  442.     {KEY_FWD, KEY_FWD, KEY_TIMER_ID30, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, 0 /* TBD */},
  443.     {KEY_BACK, KEY_BACK, KEY_TIMER_ID31, TONE_KEY_NORMAL, DEVICE_AUDIO_PLAY_ONCE, 0 /* TBD */}
  444. };
  445. #endif /* MMI_ON_WIN32 */ 
  447. extern void IdleHandleKeypadLockProcess(void);
  449. #if defined(__MMI_HUMAN_VOICE_KEYPAD_TONE__)
  450. extern U8 CanPlayHumanVoiceKeyTone(void);
  451. #endif 
  453. #if defined(__MMI_CUST_KEYPAD_TONE__)
  454. extern U8 CanPlayCustKeyTone(void);
  455. #endif 
  457. #if defined(MMI_ON_WIN32)
  458. extern void MMI_system_keybord_handler(S32 key_code, S32 key_state);
  459. #endif 
  461. extern void ShutdownSystemOperation(void);
  463. /*****************************************************************************
  464.  * FUNCTION
  465.  *  InitProcessKeyEvent
  466.  * DESCRIPTION
  467.  *  To init the process key handler for preprocessing and postprocessing.
  468.  * PARAMETERS
  469.  *  void
  470.  *  U32(?)      [IN]        MsgType, U16 KeyMapIndex
  471.  * RETURNS
  472.  *  void
  473.  *****************************************************************************/
  474. void InitProcessKeyEvent(void)
  475. {
  476.     /*----------------------------------------------------------------*/
  477.     /* Local Variables                                                */
  478.     /*----------------------------------------------------------------*/
  479.     U16 i = 0;
  481.     /*----------------------------------------------------------------*/
  482.     /* Code Body                                                      */
  483.     /*----------------------------------------------------------------*/
  484.     for (i = 0; i < MAX_KEYS; i++)
  485.     {
  486.         nKeyPadStatus[i] = KEY_EVENT_UP;
  487.         key_is_pressing_count = 0;
  488.     }
  489. }
  492. /*****************************************************************************
  493.  * FUNCTION
  494.  *  KeyEventHandler
  495.  * DESCRIPTION
  496.  *  To handle the key event.
  497.  * PARAMETERS
  498.  *  eventKey        [IN]        
  499.  * RETURNS
  500.  *  void
  501.  *****************************************************************************/
  502. static void KeyEventHandler(KEYBRD_MESSAGE *eventKey)
  503. {
  504.     /*----------------------------------------------------------------*/
  505.     /* Local Variables                                                */
  506.     /*----------------------------------------------------------------*/
  508.     /*----------------------------------------------------------------*/
  509.     /* Code Body                                                      */
  510.     /*----------------------------------------------------------------*/
  511.     /* Preprocess the keypad handler */
  512.     mmi_kbd_app_key_hdlr(eventKey);
  514.     if (g_mmi_frm_cntx.kbd_pre_func)
  515.     {
  516.         g_mmi_frm_cntx.kbd_pre_func(eventKey);
  517.     }
  519.     /* Process the register App keypad handler */
  520.     ExecuteCurrKeyHandler((S16) eventKey->nKeyCode, (S16) eventKey->nMsgType);
  522.     if (g_mmi_frm_cntx.kbd_post_func)
  523.     {
  524.         g_mmi_frm_cntx.kbd_post_func(eventKey);
  525.     }
  527. }
  530. /*****************************************************************************
  531.  * FUNCTION
  532.  *  mmi_frm_get_2step_keys
  533.  * DESCRIPTION
  534.  *  To get the 2 step keys of handset.
  535.  *  The function should be called in MMI_Init()
  536.  * PARAMETERS
  537.  *  void
  538.  *  KEYBRD_MESSAGE(?)       [IN]        *eventKey
  539.  * RETURNS
  540.  *  void
  541.  *****************************************************************************/
  542. extern void kbd_find_2step(kal_uint32 *number, kal_uint8 *two_step);
  543. void mmi_frm_get_2step_keys(void)
  544. {
  545.     /*----------------------------------------------------------------*/
  546.     /* Local Variables                                                */
  547.     /*----------------------------------------------------------------*/
  548.     U32 i;
  549.     U8 _2step_key[MAX_KEYS];
  551.     /*----------------------------------------------------------------*/
  552.     /* Code Body                                                      */
  553.     /*----------------------------------------------------------------*/
  554.     memset(_2step_key, 0, sizeof(U8) * MAX_KEYS);
  555.     memset(g_2step_keyCode, 0, sizeof(U16) * MAX_KEYS);
  557. #ifndef MMI_ON_WIN32
  558.     kbd_find_2step(&g_2step_key_num, _2step_key);
  559. #endif 
  560.     for (i = 0; i < g_2step_key_num; i++)
  561.     {
  562.         g_2step_keyCode[i] = nKeyPadMap[_2step_key[i]].nMMIKeyCode;
  563.     }
  564. }
  567. /*****************************************************************************
  568.  * FUNCTION
  569.  *  mmi_frm_is_2step_keyCode
  570.  * DESCRIPTION
  571.  *  To get the 2 step keys of handset.
  572.  *  The function should be called in MMI_Init()
  573.  * PARAMETERS
  574.  *  keyCode                 [IN]        
  575.  *  KEYBRD_MESSAGE(?)       [IN]        *eventKey
  576.  * RETURNS
  577.  *  MMI_TRUE - it's 2 step key
  578.  *  MMI_FALSE - it isn't 2 step key
  579.  *****************************************************************************/
  580. static MMI_BOOL mmi_frm_is_2step_keyCode(U16 keyCode)
  581. {
  582.     /*----------------------------------------------------------------*/
  583.     /* Local Variables                                                */
  584.     /*----------------------------------------------------------------*/
  585.     U32 i;
  587.     /*----------------------------------------------------------------*/
  588.     /* Code Body                                                      */
  589.     /*----------------------------------------------------------------*/
  590.     for (i = 0; i < g_2step_key_num; i++)
  591.     {
  592.         if (keyCode == g_2step_keyCode[i])
  593.         {
  594.             return MMI_TRUE;
  595.         }
  596.     }
  598.     return MMI_FALSE;
  599. }
  602. /*****************************************************************************
  603.  * FUNCTION
  604.  *  ProcessKeyEvent
  605.  * DESCRIPTION
  606.  *  To send the key events to MMI task
  607.  * PARAMETERS
  608.  *  MsgType         [IN]        
  609.  *  KeyMapIndex     [IN]        
  610.  * RETURNS
  611.  *  void
  612.  *****************************************************************************/
  613. /* TBD */
  614. #define DRV_WM_ENABLE_TWOKEY_DETECTION             5
  615. #define DRV_WM_DISABLE_TWOKEY_DETECTION               6
  616. void ProcessKeyEvent(U32 MsgType, U16 KeyMapIndex)
  617. {
  618.     /*----------------------------------------------------------------*/
  619.     /* Local Variables                                                */
  620.     /*----------------------------------------------------------------*/
  622.     /*----------------------------------------------------------------*/
  623.     /* Code Body                                                      */
  624.     /*----------------------------------------------------------------*/
  625.     MMI_ASSERT(KeyMapIndex < MAX_KEYPADMAP);
  626.     MMI_ASSERT(nKeyPadMap[KeyMapIndex].nMMIKeyCode != KEY_INVALID);
  628.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_PROC_KEYEVENT_HDLR, MsgType, nKeyPadMap[KeyMapIndex].nMMIKeyCode));
  630.     if (MsgType == WM_KEYPRESS)
  631.     {
  632.         if (nKeyPadStatus[KeyMapIndex] == KEY_EVENT_UP)
  633.         {
  635.             KEYBRD_MESSAGE KeyBrdMsg;
  637.             KeyBrdMsg.nKeyCode = nKeyPadMap[KeyMapIndex].nMMIKeyCode;
  638.             if (mmi_frm_is_2step_keyCode(KeyBrdMsg.nKeyCode))
  639.             {
  640.                 nKeyPadStatus[KeyMapIndex] = KEY_HALF_PRESS_DOWN;
  641.                 key_is_pressing_count++;
  642.                 KeyBrdMsg.nMsgType = KEY_HALF_PRESS_DOWN;
  643.             }
  644.             else
  645.             {
  646.                 nKeyPadStatus[KeyMapIndex] = KEY_EVENT_DOWN;    /* same with KEY_FULL_PRESS_DOWN */
  647.                 key_is_pressing_count++;
  648.                 KeyBrdMsg.nMsgType = KEY_EVENT_DOWN;
  649.             }
  650.             KeyEventHandler((KEYBRD_MESSAGE*) & KeyBrdMsg);
  652.         #ifdef MMI_ON_WIN32
  653.             StartTimer(nKeyPadMap[KeyMapIndex].nTimerId, KEYTIMER_LONGPRESS, (FuncPtr) KeyTimerExpiryProc);
  654.         #endif 
  655.         }
  656.         else
  657.         {
  658.             /* Ignore the event */
  659.         }
  660.     }
  662.     else if (MsgType == WM_KEYRELEASE)
  663.     {
  664.         if ((nKeyPadStatus[KeyMapIndex] == KEY_EVENT_DOWN)
  665.             || (nKeyPadStatus[KeyMapIndex] == KEY_LONG_PRESS)
  666.             || (nKeyPadStatus[KeyMapIndex] == KEY_REPEAT) || (nKeyPadStatus[KeyMapIndex] == KEY_HALF_PRESS_DOWN))
  667.         {
  669.             KEYBRD_MESSAGE KeyBrdMsg;
  671.         #ifdef MMI_ON_WIN32
  672.             /* stop timer as early as possible. avoid timer expire later */
  673.             StopTimer(nKeyPadMap[KeyMapIndex].nTimerId);
  674.         #endif /* MMI_ON_WIN32 */ 
  675.             nKeyPadStatus[KeyMapIndex] = KEY_EVENT_UP;
  676.             key_is_pressing_count--;
  677.             KeyBrdMsg.nMsgType = KEY_EVENT_UP;
  678.             KeyBrdMsg.nKeyCode = nKeyPadMap[KeyMapIndex].nMMIKeyCode;
  679.             KeyEventHandler((KEYBRD_MESSAGE*) & KeyBrdMsg);
  681.         }
  682.         else
  683.         {
  684.             /* Ignore the event */
  685.         }
  686.     }
  687.     /* ++Robin, modified by Max Chen */
  688. #ifndef MMI_ON_WIN32
  689.     else if (MsgType == DRV_WM_KEYLONGPRESS)
  690.     {
  691.         if (nKeyPadStatus[KeyMapIndex] == KEY_EVENT_DOWN)
  692.         {
  693.             KEYBRD_MESSAGE KeyBrdMsg;
  695.             nKeyPadStatus[KeyMapIndex] = KEY_LONG_PRESS;
  696.             KeyBrdMsg.nMsgType = KEY_LONG_PRESS;
  697.             KeyBrdMsg.nKeyCode = nKeyPadMap[KeyMapIndex].nMMIKeyCode;
  698.             KeyEventHandler((KEYBRD_MESSAGE*) & KeyBrdMsg);
  699.         }
  700.         else
  701.         {
  702.             /* Ignore the event */
  703.         }
  704.     }
  705.     else if (MsgType == DRV_WM_KEYREPEATED)
  706.     {
  707.         if ((nKeyPadStatus[KeyMapIndex] == KEY_LONG_PRESS) || (nKeyPadStatus[KeyMapIndex] == KEY_REPEAT))
  708.         {
  709.             KEYBRD_MESSAGE KeyBrdMsg;
  711.             nKeyPadStatus[KeyMapIndex] = KEY_REPEAT;
  712.             KeyBrdMsg.nMsgType = KEY_REPEAT;
  713.             KeyBrdMsg.nKeyCode = nKeyPadMap[KeyMapIndex].nMMIKeyCode;
  714.             KeyEventHandler((KEYBRD_MESSAGE*) & KeyBrdMsg);
  715.         }
  716.         else
  717.         {
  718.             /* Ignore the event */
  719.         }
  720.     }
  721.     else if (MsgType == DRV_WM_KEYFULLPRESS)
  722.     {
  723.         /*
  724.          * Only in two-stage key will have KEY_FULL_PRESS_DOWN, and it followed after KEY_HALF_PRESS_DOWN
  725.          */
  726.         if (nKeyPadStatus[KeyMapIndex] == KEY_HALF_PRESS_DOWN)
  727.         {
  728.             KEYBRD_MESSAGE KeyBrdMsg;
  730.             nKeyPadStatus[KeyMapIndex] = KEY_EVENT_DOWN;
  731.             KeyBrdMsg.nMsgType = KEY_EVENT_DOWN;
  732.             KeyBrdMsg.nKeyCode = nKeyPadMap[KeyMapIndex].nMMIKeyCode;
  733.             KeyEventHandler((struct KEYBRD_MESSAGE*)&KeyBrdMsg);
  734.         }
  735.         else
  736.         {
  737.             /* Ignore the event */
  738.         }
  739.     }
  740.     else if (MsgType == DRV_WM_ENABLE_TWOKEY_DETECTION || MsgType == DRV_WM_DISABLE_TWOKEY_DETECTION)
  741.     {
  742.         /* Ignore the event */
  743.     }
  744. #endif /* MMI_ON_WIN32 */ 
  745.     else
  746.     {
  747.         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_PROC_KEYEVENT_HDLR));
  749.         MMI_ASSERT(0);
  750.     }
  752. }
  754. #ifdef MMI_ON_WIN32
  756. #define CHECK_SIMPLY_HANDLE_MULTIPLEKEY(type, id)                       
  757.    {                                                                    
  758.       static U16  lastId = 0xffff;                                      
  759.       if (mmi_kbd_get_concurrent_mode() == MMI_FALSE)                   
  760.       {                                                                 
  761.       if (type == WM_KEYPRESS)                                          
  762.       {                                                                 
  763.          if (lastId == 0xffff)                                          
  764.          {  /* update lastId */                                         
  765.             lastId = id;                                                
  766.          }                                                              
  767.          else if (lastId != id)                                         
  768.          {  /* previous key isn't release but another key is pressed */ 
  769.             /* release the previous key first */                         
  770.             /* then continue to press the current key */                
  771.             ProcessKeyEvent(WM_KEYRELEASE, lastId);                     
  772.             lastKeyId = i;                                              
  773.          }                                                              
  774.       }                                                                 
  775.       else  /* WM_KEYRELEASE */                                         
  776.       {  /* reset lastId */                                             
  777.          lastId = 0xffff;                                               
  778.       }                                                                 
  779.       }                                                                 
  780.    }
  783. /*****************************************************************************
  784.  * FUNCTION
  785.  *  ProcessPCKeyEvent
  786.  * DESCRIPTION
  787.  *  This function is to convert the W32 key to MMI keys.
  788.  * PARAMETERS
  789.  *  MsgType         [IN]        Type of key event
  790.  *  KeyBrdMsg       [?]         
  791.  *  KeyMsg(?)       [IN]        Key structure
  792.  * RETURNS
  793.  *  void
  794.  *****************************************************************************/
  795. U8 ProcessPCKeyEvent(U32 MsgType, KEYBRD_MESSAGE *KeyBrdMsg)
  796. {
  798.     /*----------------------------------------------------------------*/
  799.     /* Local Variables                                                */
  800.     /*----------------------------------------------------------------*/
  801.     U16 i;
  802.     static U16 lastKeyId = 0xffff;  /* initial value (magic number) */
  804.     /*----------------------------------------------------------------*/
  805.     /* Code Body                                                      */
  806.     /*----------------------------------------------------------------*/
  807.     if ((MsgType == WM_KEYBRD_PRESS) || (MsgType == WM_KEYBRD_RELEASE))
  808.     {
  809.         /* 
  810.          * handle the key event from the keyboard event
  811.          * find keyCode in nHotKey of nKeyPadMap's table
  812.          */
  813.         for (i = 0; i < MAX_KEYPADMAP; i++)
  814.         {
  815.             if (KeyBrdMsg->nKeyCode == nKeyPadMap[i].nHotKey)
  816.             {
  817.                 if (MsgType == WM_KEYBRD_PRESS)
  818.                 {
  819.                     MsgType = WM_KEYPRESS;
  820.                 }
  821.                 else
  822.                 {
  823.                     MsgType = WM_KEYRELEASE;
  824.                 }
  825.                 CHECK_SIMPLY_HANDLE_MULTIPLEKEY(MsgType, i) ProcessKeyEvent(MsgType, i);
  826.                 return MMI_TRUE;
  827.             }
  828.         }
  829.     }
  830.     else if ((MsgType == WM_KEYPRESS) || (MsgType == WM_KEYRELEASE))
  831.     {
  832.         /* 
  833.          * handle the key event from the mouse event
  834.          * find keyCode in nKeyCode of nKeyPadMap's table
  835.          */
  836.         for (i = 0; i < MAX_KEYPADMAP; i++)
  837.         {
  838.             if (KeyBrdMsg->nKeyCode == nKeyPadMap[i].nKeyCode)
  839.             {
  840.                 CHECK_SIMPLY_HANDLE_MULTIPLEKEY(MsgType, i);
  841.                 ProcessKeyEvent(MsgType, i);    /* Msg type press or release & keymap index */
  842.                 return MMI_TRUE;
  843.             }
  844.         }
  845.     }
  846.     /* Not handle this message */
  847.     return MMI_FALSE;
  848. }
  851. /*****************************************************************************
  852.  * FUNCTION
  853.  *  mmi_frm_set_key_handle_in_high_frequency
  854.  * DESCRIPTION
  855.  *  The dummy function for PC simulator
  856.  * PARAMETERS
  857.  *  is_enable       [IN]        
  858.  *  a(?)            [IN]        Is_enable
  859.  * RETURNS
  860.  *  void
  861.  *****************************************************************************/
  862. void mmi_frm_set_key_handle_in_high_frequency(MMI_BOOL is_enable)
  863. {
  864.     /*----------------------------------------------------------------*/
  865.     /* Local Variables                                                */
  866.     /*----------------------------------------------------------------*/
  868.     /*----------------------------------------------------------------*/
  869.     /* Code Body                                                      */
  870.     /*----------------------------------------------------------------*/
  871.     /* do nothing */
  872. }
  875. /*****************************************************************************
  876.  * FUNCTION
  877.  *  KeyTimerExpiryProc
  878.  * DESCRIPTION
  879.  *  Timer expiry procedure
  880.  * PARAMETERS
  881.  *  idEvent         [?]         
  882.  *  handle(?)       [IN]        To window
  883.  * RETURNS
  884.  *  void
  885.  *****************************************************************************/
  886. void KeyTimerExpiryProc(void *idEvent)
  887. {
  888.     /*----------------------------------------------------------------*/
  889.     /* Local Variables                                                */
  890.     /*----------------------------------------------------------------*/
  891.     U16 i;
  892.     MMI_BOOL bNeedToDo = MMI_FALSE;
  894.     /*----------------------------------------------------------------*/
  895.     /* Code Body                                                      */
  896.     /*----------------------------------------------------------------*/
  897.     /* Check the timer ID */
  898.     if ((KEY_TIMER_ID0 <= (U32) idEvent) && ((U32) idEvent < UI_TIMER_ID_BASE))
  899.     {
  900.         for (i = 0; i < MAX_KEYPADMAP; i++)
  901.         {
  902.             bNeedToDo = MMI_FALSE;
  903.             if (((S32) idEvent) == nKeyPadMap[i].nTimerId)
  904.             {
  905.                 /* Check the keypad status. It should not be KEY_EVENT_UP */
  906.                 if (nKeyPadStatus[i] == KEY_EVENT_DOWN)
  907.                 {
  908.                     nKeyPadStatus[i] = KEY_LONG_PRESS;
  909.                     bNeedToDo = MMI_TRUE;
  910.                 }
  911.                 else if ((nKeyPadStatus[i] == KEY_LONG_PRESS) || (nKeyPadStatus[i] == KEY_REPEAT))
  912.                 {
  913.                     nKeyPadStatus[i] = KEY_REPEAT;
  914.                     bNeedToDo = MMI_TRUE;
  915.                 }
  916.                 /* stop the timer even the keypad status is KEY_EVENT_UP */
  917.                 StopTimer(nKeyPadMap[i].nTimerId);
  919.                 /* Only the */
  920.                 if (bNeedToDo == MMI_TRUE)
  921.                 {
  922.                     KEYBRD_MESSAGE KeyBrdMsg;
  924.                     KeyBrdMsg.nMsgType = nKeyPadStatus[i];
  925.                     KeyBrdMsg.nKeyCode = nKeyPadMap[i].nMMIKeyCode;
  927.                     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_PROC_TIMER_EVENT_HDLR, KeyBrdMsg.nMsgType,
  928.                                KeyBrdMsg.nKeyCode));
  930.                     KeyEventHandler((KEYBRD_MESSAGE*) & KeyBrdMsg);
  931.                     StartTimer(nKeyPadMap[i].nTimerId, KEYTIMER_REPEAT, (FuncPtr) KeyTimerExpiryProc);
  932.                 }
  933.                 break;
  934.             }
  935.         }
  936.     }
  937.     else
  938.     {
  939.         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_KEY_TIMER_EXPIRY_HDLR, (U32) idEvent));
  940.         MMI_ASSERT(0);
  941.     }
  942. }
  945. /* MTK added, Max to solve power on race condition 0730 */
  946. #else
  949. /*****************************************************************************
  950.  * FUNCTION
  951.  *  InitKeypadBeforePWRON
  952.  * DESCRIPTION
  953.  *  Initializes keypad before power on
  954.  * PARAMETERS
  955.  *  void
  956.  * RETURNS
  957.  *  void
  958.  *****************************************************************************/
  959. void InitKeypadBeforePWRON(void)
  960. {
  961.     /*----------------------------------------------------------------*/
  962.     /* Local Variables                                                */
  963.     /*----------------------------------------------------------------*/
  965.     /*----------------------------------------------------------------*/
  966.     /* Code Body                                                      */
  967.     /*----------------------------------------------------------------*/
  968.     SetProtocolEventHandler(KeyHandleBeforePWRON, MSG_ID_MMI_EQ_KEYPAD_DETECT_IND);
  969. }
  972. /*****************************************************************************
  973.  * FUNCTION
  974.  *  KeyHandleBeforePWRON
  975.  * DESCRIPTION
  976.  *  This function detects key presses before power on
  977.  * PARAMETERS
  978.  *  paraBuff        [IN]        
  979.  * RETURNS
  980.  *  void
  981.  *****************************************************************************/
  982. void KeyHandleBeforePWRON(void *paraBuff)
  983. {
  984.     /*----------------------------------------------------------------*/
  985.     /* Local Variables                                                */
  986.     /*----------------------------------------------------------------*/
  987.     mmi_eq_keypad_detect_ind_struct *p;
  988.     kbd_data k;
  990.     /*----------------------------------------------------------------*/
  991.     /* Code Body                                                      */
  992.     /*----------------------------------------------------------------*/
  993.     p = (mmi_eq_keypad_detect_ind_struct*) paraBuff;
  995.     while ((*(p->func)) (&k) == KAL_TRUE);
  997. }
  999. /*****************************************************************************
  1000.  * FUNCTION
  1001.  *  mmi_frm_convert_process_key_event
  1002.  * DESCRIPTION
  1003.  *  convert the driver key event type to MMI key event type
  1004.  *  and process the key event
  1005.  * PARAMETERS
  1006.  *  Keyevent        [IN]        
  1007.  *  KeyMapIndex     [IN]        
  1008.  *  a(?)            [IN]        ParaBuff
  1009.  * RETURNS
  1010.  *  void
  1011.  *****************************************************************************/
  1012. #if defined(__MMI_SCREEN_ROTATE__)
  1013. static mmi_frm_screen_rotate_enum key_rotate = MMI_FRM_SCREEN_ROTATE_0;
  1014. #endif 
  1016. void mmi_frm_convert_process_key_event(U32 Keyevent, U16 KeyMapIndex)
  1017. {
  1018.     /*----------------------------------------------------------------*/
  1019.     /* Local Variables                                                */
  1020.     /*----------------------------------------------------------------*/
  1022.     /*----------------------------------------------------------------*/
  1023.     /* Code Body                                                      */
  1024.     /*----------------------------------------------------------------*/
  1025.     if (Keyevent == WM_KEYPRESS)
  1026.     {
  1027.     #ifdef __MMI_SCREEN_ROTATE__
  1028.         key_rotate = mmi_frm_get_screen_rotate();
  1029.     #endif 
  1030.     }
  1031. #ifdef __MMI_INTERACTIVE_PROFILNG__
  1032.     if (Keyevent == WM_KEYPRESS)
  1033.     {
  1034.         mmi_frm_profiling_interactive_start3();
  1035.     }
  1036.     else if (Keyevent == WM_KEYRELEASE)
  1037.     {
  1038.         mmi_frm_profiling_interactive_start2();
  1039.     }
  1040. #endif /* __MMI_INTERACTIVE_PROFILNG__ */ 
  1042. #ifdef __MMI_SCREEN_ROTATE__
  1043.     switch (key_rotate)
  1044.     {
  1045.         case MMI_FRM_SCREEN_ROTATE_270:
  1046.             switch (KeyMapIndex)
  1047.             {
  1048.                 case DEVICE_KEY_UP:
  1049.                     KeyMapIndex = DEVICE_KEY_LEFT;
  1050.                     break;
  1051.                 case DEVICE_KEY_DOWN:
  1052.                     KeyMapIndex = DEVICE_KEY_RIGHT;
  1053.                     break;
  1054.                 case DEVICE_KEY_LEFT:
  1055.                     KeyMapIndex = DEVICE_KEY_DOWN;
  1056.                     break;
  1057.                 case DEVICE_KEY_RIGHT:
  1058.                     KeyMapIndex = DEVICE_KEY_UP;
  1059.                     break;
  1060.             }
  1061.             break;
  1062.     }
  1063. #endif /* __MMI_SCREEN_ROTATE__ */ 
  1065.     ProcessKeyEvent(Keyevent, KeyMapIndex);
  1067.     if (Keyevent == WM_KEYRELEASE)
  1068.     {
  1069.     #ifdef __MMI_SCREEN_ROTATE__
  1070.         key_rotate = MMI_FRM_SCREEN_ROTATE_0;
  1071.     #endif 
  1072.     }
  1074. #ifdef __MMI_INTERACTIVE_PROFILNG__
  1075.     if (Keyevent == WM_KEYPRESS)
  1076.     {
  1077.         mmi_frm_profiling_interactive_end3();
  1078.     }
  1079.     else if (Keyevent == WM_KEYRELEASE)
  1080.     {
  1081.         mmi_frm_profiling_interactive_end2();
  1082.         mmi_frm_profiling_interactive_show((U8*) L"K", MMI_FRM_PROFILING_MASK_2 | MMI_FRM_PROFILING_MASK_3);
  1083.     }
  1084. #endif /* __MMI_INTERACTIVE_PROFILNG__ */ 
  1085. }
  1088. /*****************************************************************************
  1089.  * FUNCTION
  1090.  *  mmi_frm_set_key_handle_in_high_frequency
  1091.  * DESCRIPTION
  1092.  *  This function is to process the keypad handler in high frequency mode
  1093.  * PARAMETERS
  1094.  *  is_enable       [IN]        
  1095.  *  a(?)            [IN]        Is_enable
  1096.  * RETURNS
  1097.  *  void
  1098.  *****************************************************************************/
  1099. void mmi_frm_set_key_handle_in_high_frequency(MMI_BOOL is_enable)
  1100. {
  1101.     /*----------------------------------------------------------------*/
  1102.     /* Local Variables                                                */
  1103.     /*----------------------------------------------------------------*/
  1105.     /*----------------------------------------------------------------*/
  1106.     /* Code Body                                                      */
  1107.     /*----------------------------------------------------------------*/
  1108.     g_process_key_in_high_frequency = is_enable;
  1109. }
  1112. /*****************************************************************************
  1113.  * FUNCTION
  1114.  *  mmi_frm_key_handle
  1115.  * DESCRIPTION
  1116.  *  This function is to process the keypad handler.
  1117.  * PARAMETERS
  1118.  *  paraBuff        [?]         
  1119.  *  a(?)            [IN]        ParaBuff
  1120.  * RETURNS
  1121.  *  void
  1122.  *****************************************************************************/
  1123. void mmi_frm_key_handle(void *paraBuff)
  1124. {
  1125.     /*----------------------------------------------------------------*/
  1126.     /* Local Variables                                                */
  1127.     /*----------------------------------------------------------------*/
  1128.     kbd_data k;
  1129.     U32 msg_count;
  1130.     mmi_eq_keypad_detect_ind_struct *p;
  1132.     /*----------------------------------------------------------------*/
  1133.     /* Code Body                                                      */
  1134.     /*----------------------------------------------------------------*/
  1135.     if (paraBuff != NULL)
  1136.     {
  1137.         drv_get_key_func new_key_ptr;
  1139.         p = (mmi_eq_keypad_detect_ind_struct*) paraBuff;
  1141.         new_key_ptr = (drv_get_key_func) (p->func);
  1143.         if (new_key_ptr != keypad_ptr)
  1144.         {
  1145.             ClearKeyEvents();
  1146.         }
  1148.         keypad_ptr = new_key_ptr;
  1149.     }
  1151.     while (1)
  1152.     {
  1153.         if ((*(keypad_ptr)) (&k) == MMI_TRUE)
  1154.         {
  1155.             if (k.Keydata[0] != KEY_INVALID)
  1156.             {
  1157.                 static U8 is_allow_key_action = MMI_TRUE;
  1159.             #if defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__)
  1160.                 kal_bool is_pen_enabled, is_pen_down;
  1162.                 mmi_pen_get_state(&is_pen_enabled, &is_pen_down);
  1163.             #endif /* defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__) */ 
  1165.             #if defined(__MMI_SLEEP_OUT_BACKLIGHT_ON__)
  1166.                 if ((IsBacklightOn() == MMI_FALSE) && (k.Keyevent == WM_KEYPRESS))
  1167.                 {
  1168.                     //KP Jerry modify for LCD Backlight don't open when press any key during keypad been locked on 2007-4-4 start
  1169.                     #ifdef __MMI_LCD_OFF_WHEN_ANYKEY_PRESSED_AND_KEYPAD_LOCKED__
  1170.       if(g_keylock_context.gKeyPadLockFlag)
  1171.                     {
  1172.                         if( (k.Keydata[0] == DEVICE_KEY_SEND) || (k.Keydata[0] == DEVICE_KEY_END) || (k.Keydata[0] == DEVICE_KEY_SK_RIGHT) ) 
  1173.        TurnOnBacklight(1); /* timer backlight control */
  1174.                     }
  1175.       else
  1176.       {
  1177.           TurnOnBacklight(1); /* timer backlight control */
  1178.       }
  1179.       #else
  1180.       TurnOnBacklight(1); /* timer backlight control */     
  1181.       #endif    
  1182.       //KP Jerry modify for LCD Backlight don't open when press any key during keypad been locked on 2007-4-4 end   
  1183.                     is_allow_key_action = MMI_FALSE;
  1184.                 }
  1185.                 else
  1186.             #endif /* defined(__MMI_SLEEP_OUT_BACKLIGHT_ON__) */ 
  1187.             #if defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__)
  1188.                 if (is_pen_down && (k.Keyevent == WM_KEYPRESS))
  1189.                 {
  1190.                     is_allow_key_action = MMI_FALSE;
  1191.                 }
  1192.                 else
  1193.             #endif /* defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__) */ 
  1194.                 if ((k.Keyevent == WM_KEYRELEASE) && (is_allow_key_action == MMI_FALSE))
  1195.                 {
  1196.                     is_allow_key_action = MMI_TRUE;
  1197.                 }
  1198.                 else if (is_allow_key_action == MMI_TRUE)
  1199.                 {
  1200.                     if ((k.Keyevent == WM_KEYPRESS) && (mmi_kbd_get_key_is_pressing_count() == 0))
  1201.                     {
  1202.                     #if defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__)
  1203.                         mmi_pen_disable();
  1204.                     #endif 
  1205.                     }
  1206.                     mmi_frm_convert_process_key_event(k.Keyevent, k.Keydata[0]);
  1208.                     if ((k.Keyevent == WM_KEYRELEASE) && (mmi_kbd_get_key_is_pressing_count() == 0))
  1209.                     {
  1210.                     #if defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__)
  1211.                         mmi_pen_enable();
  1212.                     #endif 
  1213.                     }
  1214.                 }
  1215.             }
  1217.             msg_get_ext_queue_info(mmi_ext_qid, &msg_count);
  1218.             if (msg_count > 0 || OslNumOfCircularQMsgs() > 0)
  1219.             {
  1220.                 g_keypad_flag = MMI_TRUE;
  1221.                 break;
  1222.             }
  1223.         }
  1224.         else
  1225.         {
  1226.             g_keypad_flag = MMI_FALSE;
  1227.             break;
  1228.         }
  1229.     }   /* while(1) */
  1230. }
  1233. #endif /* MMI_ON_WIN32 */
  1236. /*****************************************************************************
  1237.  * FUNCTION
  1238.  *  StopCurrentKeyPadTone
  1239.  * DESCRIPTION
  1240.  *  Stops Current keypad tone
  1241.  * PARAMETERS
  1242.  *  void
  1243.  * RETURNS
  1244.  *  void
  1245.  *****************************************************************************/
  1246. void StopCurrentKeyPadTone(void)
  1247. {
  1248.     /*----------------------------------------------------------------*/
  1249.     /* Local Variables                                                */
  1250.     /*----------------------------------------------------------------*/
  1252.     /*----------------------------------------------------------------*/
  1253.     /* Code Body                                                      */
  1254.     /*----------------------------------------------------------------*/
  1255.     if (currKeyPadTone != 0xFFFF)
  1256.     {
  1257.         AudioStopReq(currKeyPadTone);
  1258.         currKeyPadTone = 0xFFFF;
  1259.     }
  1260. }
  1263. /*****************************************************************************
  1264.  * FUNCTION
  1265.  *  ClearKeyEvents
  1266.  * DESCRIPTION
  1267.  *  Clears Keyboard buffer
  1268.  * PARAMETERS
  1269.  *  void
  1270.  * RETURNS
  1271.  *  void
  1272.  *****************************************************************************/
  1273. void ClearKeyEvents(void)
  1274. {
  1275. #ifndef MMI_ON_WIN32
  1276.     /*----------------------------------------------------------------*/
  1277.     /* Local Variables                                                */
  1278.     /*----------------------------------------------------------------*/
  1279.     extern drv_get_key_func keypad_ptr;
  1280.     kbd_data k;
  1282.     /*----------------------------------------------------------------*/
  1283.     /* Code Body                                                      */
  1284.     /*----------------------------------------------------------------*/
  1285.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_CLEAR_KEY_EVENTS_HDLR));
  1287.     if (keypad_ptr != NULL)
  1288.     {
  1289.         while ((*(keypad_ptr)) (&k) == KAL_TRUE)
  1290.         {
  1291.             /* restore state of keys */
  1292.             if (k.Keydata[0] != KEY_INVALID)
  1293.             {
  1294.                 mmi_kbd_reset_key_state(k.Keyevent, k.Keydata[0]);
  1295.             }
  1296.         }
  1297.     }
  1298.     processUpRepeatKey = 0;
  1299.     pressKey = 0;   /* 0- full up, 1- half down, 2- full down */
  1300.     StopCurrentKeyPadTone();
  1302. #if defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__)
  1303.     /*
  1304.      * We disable pen on key down and enable pen on key up. 
  1305.      * * If key down and key up events are not paired, pen is not enabled again.
  1306.      */
  1307.     mmi_pen_enable();
  1308. #endif /* defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__) */ 
  1310. #endif /* MMI_ON_WIN32 */ 
  1311. }
  1313. #if defined(__MMI_HUMAN_VOICE_KEYPAD_TONE__)
  1316. /*****************************************************************************
  1317.  * FUNCTION
  1318.  *  GetHumanVoiceToneID
  1319.  * DESCRIPTION
  1320.  *  
  1321.  * PARAMETERS
  1322.  *  MMIKeyCode      [IN]        
  1323.  * RETURNS
  1324.  *  
  1325.  *****************************************************************************/
  1326. S16 GetHumanVoiceToneID(S16 MMIKeyCode)
  1327. {
  1328.     /*----------------------------------------------------------------*/
  1329.     /* Local Variables                                                */
  1330.     /*----------------------------------------------------------------*/
  1331.     S16 i;
  1332.     U8 keypad_tone_type = GetKeypadToneType();
  1334.     /*----------------------------------------------------------------*/
  1335.     /* Code Body                                                      */
  1336.     /*----------------------------------------------------------------*/
  1337.     if (keypad_tone_type >= KEYPAD_TONE_HUMAN_VOICE_1 && keypad_tone_type <= KEYPAD_TONE_HUMAN_VOICE_6)
  1338.     {
  1339.         if (!CanPlayHumanVoiceKeyTone())
  1340.         {
  1341.             return -1;
  1342.         }
  1343.         if (MMIKeyCode >= KEY_0 && MMIKeyCode <= KEY_9)
  1344.         {
  1345.             i = MMIKeyCode - KEY_0;
  1346.         }
  1347.         else if (MMIKeyCode == KEY_STAR)
  1348.         {
  1349.             i = 10;
  1350.         }
  1351.         else if (MMIKeyCode == KEY_POUND)
  1352.         {
  1353.             i = 11;
  1354.         }
  1355.         else
  1356.         {
  1357.             i = -1;
  1358.         }
  1360.         if (i >= 0)
  1361.         {
  1362.             return (S16) ((keypad_tone_type - KEYPAD_TONE_HUMAN_VOICE_1) * 13 + i + MIN_HUMAN_VOICE_ID);
  1363.         }
  1364.     }
  1365.     return -1;
  1366. }
  1367. #endif /* defined(__MMI_HUMAN_VOICE_KEYPAD_TONE__) */ 
  1369. #if defined(__MMI_CUST_KEYPAD_TONE__)
  1372. /*****************************************************************************
  1373.  * FUNCTION
  1374.  *  GetCustKeyPadToneID
  1375.  * DESCRIPTION
  1376.  *  
  1377.  * PARAMETERS
  1378.  *  MMIKeyCode      [IN]        
  1379.  * RETURNS
  1380.  *  
  1381.  *****************************************************************************/
  1382. S16 GetCustKeyPadToneID(S16 MMIKeyCode)
  1383. {
  1384.     /*----------------------------------------------------------------*/
  1385.     /* Local Variables                                                */
  1386.     /*----------------------------------------------------------------*/
  1387.     U8 keypad_tone_type = GetKeypadToneType();
  1389.     /*----------------------------------------------------------------*/
  1390.     /* Code Body                                                      */
  1391.     /*----------------------------------------------------------------*/
  1392.     if (keypad_tone_type >= KEYPAD_TONE_CUST_1 && keypad_tone_type <= KEYPAD_TONE_CUST_6)
  1393.     {
  1394.         if (!CanPlayCustKeyTone())
  1395.         {
  1396.             return -1;
  1397.         }
  1398.         return (S16) (keypad_tone_type - KEYPAD_TONE_CUST_1 + MIN_KEYPAD_TONE_ID);
  1399.     }
  1400.     return -1;
  1401. }
  1402. #endif /* defined(__MMI_CUST_KEYPAD_TONE__) */ 
  1405. /*****************************************************************************
  1406.  * FUNCTION
  1407.  *  GetKeypadTone
  1408.  * DESCRIPTION
  1409.  *  
  1410.  * PARAMETERS
  1411.  *  MMIKeyCode      [IN]        
  1412.  * RETURNS
  1413.  *  
  1414.  *****************************************************************************/
  1415. U16 GetKeypadTone(S16 MMIKeyCode)
  1416. {
  1417.     /*----------------------------------------------------------------*/
  1418.     /* Local Variables                                                */
  1419.     /*----------------------------------------------------------------*/
  1420.     U8 is_found = MMI_FALSE;
  1421.     S16 i;
  1423.     /*----------------------------------------------------------------*/
  1424.     /* Code Body                                                      */
  1425.     /*----------------------------------------------------------------*/
  1426. #if defined(__MMI_CUST_KEYPAD_TONE__)
  1427.     if ((i = GetCustKeyPadToneID(MMIKeyCode)) >= 0)
  1428.     {
  1429.         return (U16) i;
  1430.     }
  1431. #endif /* defined(__MMI_CUST_KEYPAD_TONE__) */ 
  1433. #if defined(__MMI_HUMAN_VOICE_KEYPAD_TONE__)
  1434.     /* MTK added by Tim for human voice keypad tone */
  1435.     if ((i = GetHumanVoiceToneID(MMIKeyCode)) >= 0)
  1436.     {
  1437.         return (U16) i;
  1438.     }
  1439. #endif /* defined(__MMI_HUMAN_VOICE_KEYPAD_TONE__) */ 
  1441.     for (i = 0; i < MAX_KEYPADMAP; i++)
  1442.     {
  1443.         if (MMIKeyCode == nKeyPadMap[i].nMMIKeyCode)
  1444.         {
  1445.             is_found = MMI_TRUE;
  1446.             break;
  1447.         }
  1448.     }
  1450.     MMI_ASSERT(is_found == MMI_TRUE);
  1452.     return (U16) nKeyPadMap[i].KeyPadTone;
  1453. }
  1456. /*****************************************************************************
  1457.  * FUNCTION
  1458.  *  GetCurKeypadTone
  1459.  * DESCRIPTION
  1460.  *  
  1461.  * PARAMETERS
  1462.  *  void
  1463.  * RETURNS
  1464.  *  
  1465.  *****************************************************************************/
  1466. U16 GetCurKeypadTone(void)
  1467. {
  1468.     /*----------------------------------------------------------------*/
  1469.     /* Local Variables                                                */
  1470.     /*----------------------------------------------------------------*/
  1472.     /*----------------------------------------------------------------*/
  1473.     /* Code Body                                                      */
  1474.     /*----------------------------------------------------------------*/
  1475.     return currKeyPadTone;
  1476. }
  1479. /*****************************************************************************
  1480.  * FUNCTION
  1481.  *  SetCurKeypadTone
  1482.  * DESCRIPTION
  1483.  *  
  1484.  * PARAMETERS
  1485.  *  KeyTone     [IN]        
  1486.  * RETURNS
  1487.  *  
  1488.  *****************************************************************************/
  1489. U8 SetCurKeypadTone(U16 KeyTone)
  1490. {
  1491.     /*----------------------------------------------------------------*/
  1492.     /* Local Variables                                                */
  1493.     /*----------------------------------------------------------------*/
  1495.     /*----------------------------------------------------------------*/
  1496.     /* Code Body                                                      */
  1497.     /*----------------------------------------------------------------*/
  1498.     currKeyPadTone = KeyTone;
  1499.     return MMI_TRUE;
  1500. }
  1503. /*****************************************************************************
  1504.  * FUNCTION
  1505.  *  GetKeypadDuration
  1506.  * DESCRIPTION
  1507.  *  
  1508.  * PARAMETERS
  1509.  *  MMIKeyCode      [IN]        
  1510.  * RETURNS
  1511.  *  
  1512.  *****************************************************************************/
  1513. U8 GetKeypadDuration(S16 MMIKeyCode)
  1514. {
  1515.     /*----------------------------------------------------------------*/
  1516.     /* Local Variables                                                */
  1517.     /*----------------------------------------------------------------*/
  1518.     U8 is_found = MMI_FALSE;
  1519.     U16 i;
  1521.     /*----------------------------------------------------------------*/
  1522.     /* Code Body                                                      */
  1523.     /*----------------------------------------------------------------*/
  1524. #if defined(__MMI_CUST_KEYPAD_TONE__)
  1525.     if (GetCustKeyPadToneID(MMIKeyCode) >= 0)
  1526.     {
  1527.         return DEVICE_AUDIO_PLAY_ONCE;
  1528.     }
  1529. #endif /* defined(__MMI_CUST_KEYPAD_TONE__) */ 
  1531. #if defined(__MMI_HUMAN_VOICE_KEYPAD_TONE__)
  1532.     /* MTK added by Tim for human voice keypad tone */
  1533.     if (GetHumanVoiceToneID(MMIKeyCode) >= 0)
  1534.     {
  1535.         return DEVICE_AUDIO_PLAY_ONCE;
  1536.     }
  1537. #endif /* defined(__MMI_HUMAN_VOICE_KEYPAD_TONE__) */ 
  1539.     for (i = 0; i < MAX_KEYPADMAP; i++)
  1540.     {
  1541.         if (MMIKeyCode == nKeyPadMap[i].nMMIKeyCode)
  1542.         {
  1543.             is_found = MMI_TRUE;
  1544.             break;
  1545.         }
  1546.     }
  1547.     MMI_ASSERT(is_found == MMI_TRUE);
  1549.     /* return KeyToneMap[KeyCode].KeyPadDuration; */
  1550.     return nKeyPadMap[i].KeyPadDuration;
  1551. }
  1554. /*****************************************************************************
  1555.  * FUNCTION
  1556.  *  mmi_kbd_reverse_code
  1557.  * DESCRIPTION
  1558.  *  This function reversly get the key code of L4/Driver.
  1559.  * PARAMETERS
  1560.  *  mmi_key_code        [IN]        Key code of MMI
  1561.  * RETURNS
  1562.  *  key code of L4/Driver
  1563.  *****************************************************************************/
  1564. S16 mmi_kbd_reverse_code(S16 mmi_key_code)
  1565. {
  1566.     /*----------------------------------------------------------------*/
  1567.     /* Local Variables                                                */
  1568.     /*----------------------------------------------------------------*/
  1569.     MMI_BOOL is_found = MMI_FALSE;
  1570.     U16 i;
  1572.     /*----------------------------------------------------------------*/
  1573.     /* Code Body                                                      */
  1574.     /*----------------------------------------------------------------*/
  1575.     for (i = 0; i < MAX_KEYPADMAP; i++)
  1576.     {
  1577.         if (mmi_key_code == nKeyPadMap[i].nMMIKeyCode)
  1578.         {
  1579.             is_found = MMI_TRUE;
  1580.             break;
  1581.         }
  1582.     }
  1583.     MMI_ASSERT(is_found == MMI_TRUE);
  1585.     /* in current disign, keycode is equavlent to key code */
  1586.     MMI_ASSERT(i == nKeyPadMap[i].nKeyCode);
  1588.     PRINT_INFORMATION_2((MMI_TRACE_G1_FRM, "mmi_kbd_reverse_code: return %d n", nKeyPadMap[i].nKeyCode));
  1590.     return (nKeyPadMap[i].nKeyCode);
  1591. }
  1594. /*****************************************************************************
  1595.  * FUNCTION
  1596.  *  mmi_kbd_reset_key_state
  1597.  * DESCRIPTION
  1598.  *  This function set the keypad state according corrent key event.
  1599.  *  But keypad handler is not executed.
  1600.  * PARAMETERS
  1601.  *  MsgType         [IN]        Type of key event
  1602.  *  KeyMapIndex     [IN]        Key index
  1603.  * RETURNS
  1604.  *  void
  1605.  *****************************************************************************/
  1606. void mmi_kbd_reset_key_state(U32 MsgType, U16 KeyMapIndex)
  1607. {
  1608.     /*----------------------------------------------------------------*/
  1609.     /* Local Variables                                                */
  1610.     /*----------------------------------------------------------------*/
  1612.     /*----------------------------------------------------------------*/
  1613.     /* Code Body                                                      */
  1614.     /*----------------------------------------------------------------*/
  1615.     if (MsgType == WM_KEYPRESS)
  1616.     {
  1617.         nKeyPadStatus[KeyMapIndex] = KEY_EVENT_DOWN;
  1618.         key_is_pressing_count++;
  1619.     }
  1620.     else if (MsgType == WM_KEYRELEASE)
  1621.     {
  1622.         nKeyPadStatus[KeyMapIndex] = KEY_EVENT_UP;
  1623.         key_is_pressing_count--;
  1624.     }
  1625.     /*
  1626.      * else 
  1627.      * others won't change key state.
  1628.      */
  1629. }
  1632. /*****************************************************************************
  1633.  * FUNCTION
  1634.  *  GetMaxPresentAllKeys
  1635.  * DESCRIPTION
  1636.  *  This function is to get all MMI keys.
  1637.  * PARAMETERS
  1638.  *  void
  1639.  * RETURNS
  1640.  *  void
  1641.  *****************************************************************************/
  1642. U8 GetMaxPresentAllKeys(void)
  1643. {
  1644.     /*----------------------------------------------------------------*/
  1645.     /* Local Variables                                                */
  1646.     /*----------------------------------------------------------------*/
  1648.     /*----------------------------------------------------------------*/
  1649.     /* Code Body                                                      */
  1650.     /*----------------------------------------------------------------*/
  1651.     return MAX_PRESENTALLKEYS;
  1652. }
  1655. /*****************************************************************************
  1656.  * FUNCTION
  1657.  *  GetMaxPresentDigitsKeys
  1658.  * DESCRIPTION
  1659.  *  This function is to get all MMI digits keys.
  1660.  * PARAMETERS
  1661.  *  void
  1662.  * RETURNS
  1663.  *  void
  1664.  *****************************************************************************/
  1665. U8 GetMaxPresentDigitsKeys(void)
  1666. {
  1667.     /*----------------------------------------------------------------*/
  1668.     /* Local Variables                                                */
  1669.     /*----------------------------------------------------------------*/
  1671.     /*----------------------------------------------------------------*/
  1672.     /* Code Body                                                      */
  1673.     /*----------------------------------------------------------------*/
  1674.     return MAX_PRESENTDIGITSKEYS;
  1675. }
  1678. /*****************************************************************************
  1679.  * FUNCTION
  1680.  *  mmi_frm_kbd_set_tone_state
  1681.  * DESCRIPTION
  1682.  *  This function is to chage the state of keypad tone.
  1683.  *  To prevent abnormal cases, keypad tone will be stopped before state changed.
  1684.  * PARAMETERS
  1685.  *  state       [IN]        
  1686.  * RETURNS
  1687.  *  void
  1688.  *****************************************************************************/
  1689. void mmi_frm_kbd_set_tone_state(mmi_frm_kbd_tone_state_enum state)
  1690. {
  1691.     /*----------------------------------------------------------------*/
  1692.     /* Local Variables                                                */
  1693.     /*----------------------------------------------------------------*/
  1695.     /*----------------------------------------------------------------*/
  1696.     /* Code Body                                                      */
  1697.     /*----------------------------------------------------------------*/
  1699.     /* not stop original keypage tone. next key tone is able to stop previous tone if still exist */ 
  1700.     // StopCurrentKeyPadTone();
  1702.     frm_p->key_tone_state = state;
  1703. }
  1706. /*****************************************************************************
  1707.  * FUNCTION
  1708.  *  mmi_frm_kbd_get_key_tone_state
  1709.  * DESCRIPTION
  1710.  *  Get the state to see if keypad tone is disabled
  1711.  * PARAMETERS
  1712.  *  void
  1713.  * RETURNS
  1714.  *  state of keypad tone.
  1715.  *****************************************************************************/
  1716. mmi_frm_kbd_tone_state_enum mmi_frm_kbd_get_key_tone_state(void)
  1717. {
  1718.     /*----------------------------------------------------------------*/
  1719.     /* Local Variables                                                */
  1720.     /*----------------------------------------------------------------*/
  1722.     /*----------------------------------------------------------------*/
  1723.     /* Code Body                                                      */
  1724.     /*----------------------------------------------------------------*/
  1725.     return frm_p->key_tone_state;
  1726. }
  1729. /*****************************************************************************
  1730.  * FUNCTION
  1731.  *  mmi_frm_kbd_reg_pre_key_hdlr
  1732.  * DESCRIPTION
  1733.  *  Regiester function to execute before general keypad handler.
  1734.  * PARAMETERS
  1735.  *  func        [IN]        
  1736.  * RETURNS
  1737.  *  state of keypad tone.(?)
  1738.  *****************************************************************************/
  1739. void mmi_frm_kbd_reg_pre_key_hdlr(PsKeyProcessCBPtr func)
  1740. {
  1741.     /*----------------------------------------------------------------*/
  1742.     /* Local Variables                                                */
  1743.     /*----------------------------------------------------------------*/
  1745.     /*----------------------------------------------------------------*/
  1746.     /* Code Body                                                      */
  1747.     /*----------------------------------------------------------------*/
  1748.     frm_p->kbd_pre_func = func;
  1749. }
  1752. /*****************************************************************************
  1753.  * FUNCTION
  1754.  *  mmi_frm_kbd_reg_post_key_hdlr
  1755.  * DESCRIPTION
  1756.  *  Regiester function to execute afer general keypad handler.
  1757.  * PARAMETERS
  1758.  *  func        [IN]        
  1759.  * RETURNS
  1760.  *  state of keypad tone.(?)
  1761.  *****************************************************************************/
  1762. void mmi_frm_kbd_reg_post_key_hdlr(PsKeyProcessCBPtr func)
  1763. {
  1764.     /*----------------------------------------------------------------*/
  1765.     /* Local Variables                                                */
  1766.     /*----------------------------------------------------------------*/
  1768.     /*----------------------------------------------------------------*/
  1769.     /* Code Body                                                      */
  1770.     /*----------------------------------------------------------------*/
  1771.     frm_p->kbd_post_func = func;
  1772. }
  1775. /*****************************************************************************
  1776.  * FUNCTION
  1777.  *  mmi_frm_kbd_is_tone_enabled
  1778.  * DESCRIPTION
  1779.  *  Function to check if keypad tone can be played or not
  1780.  * PARAMETERS
  1781.  *  key_code        [IN]        Key code
  1782.  *  key_type        [IN]        Key type
  1783.  * RETURNS
  1784.  *  TRUE if the keypad tone shall be played by framework; otherwise, FALSE.
  1785.  *****************************************************************************/
  1786. BOOL mmi_frm_kbd_is_tone_enabled(S16 key_code, S16 key_type)
  1787. {
  1788.     /*----------------------------------------------------------------*/
  1789.     /* Local Variables                                                */
  1790.     /*----------------------------------------------------------------*/
  1791.     U8 tone_type = GetKeypadToneType();
  1793.     /*----------------------------------------------------------------*/
  1794.     /* Code Body                                                      */
  1795.     /*----------------------------------------------------------------*/
  1796.     if (tone_type == KEYPAD_SILENT  /* silent profile */
  1797.         || frm_p->key_tone_state == MMI_KEY_TONE_DISABLED)
  1798.     {
  1799.         return FALSE;
  1800.     }
  1801.     else if (frm_p->key_tone_state == MMI_KEY_VOL_TONE_DISABLED)
  1802.     {
  1803.         /* disable volume keypad tone */
  1804.         if (key_code == KEY_VOL_UP || key_code == KEY_VOL_DOWN)
  1805.         {
  1806.             return FALSE;
  1807.         }
  1808.     }
  1809.     else if (frm_p->key_tone_state == MMI_KEY_VOL_UP_DOWN_TONE_DISABLED)
  1810.     {
  1811.         /* disable volume keypad tone */
  1812.         if (key_code == KEY_VOL_UP || key_code == KEY_VOL_DOWN || 
  1813.             key_code == KEY_UP_ARROW || key_code == KEY_DOWN_ARROW)
  1814.         {
  1815.             return FALSE;
  1816.         }
  1817.     }
  1818.     else if (frm_p->key_tone_state == MMI_KEY_RIGHT_LEFT_ARROW_TONE_DISABLED)
  1819.     {
  1820.         if (key_code == KEY_RIGHT_ARROW || key_code == KEY_LEFT_ARROW)
  1821.         {
  1822.             return FALSE;
  1823.         }
  1824.     }
  1826.     return TRUE;
  1827. }
  1830. /*****************************************************************************
  1831.  * FUNCTION
  1832.  *  mmi_frm_play_keypad_tone
  1833.  * DESCRIPTION
  1834.  *  Function to play corresponding keypad tone
  1835.  * PARAMETERS
  1836.  *  key_code        [IN]        Key code
  1837.  * RETURNS
  1838.  *  void
  1839.  *****************************************************************************/
  1840. void mmi_frm_play_keypad_tone(S16 key_code)
  1841. {
  1842.     /*----------------------------------------------------------------*/
  1843.     /* Local Variables                                                */
  1844.     /*----------------------------------------------------------------*/
  1845.     U8 tone_type = GetKeypadToneType();
  1847.     /*----------------------------------------------------------------*/
  1848.     /* Code Body                                                      */
  1849.     /*----------------------------------------------------------------*/
  1850.     if (tone_type == KEYPAD_CLICK)
  1851.     {
  1852.         AudioPlayReq(TONE_KEY_CLICK, DEVICE_AUDIO_PLAY_ONCE);
  1853.     }
  1854.     else
  1855.     {
  1856.         SetCurKeypadTone(GetKeypadTone(key_code));
  1857.         frm_p->key_tone_id = GetCurKeypadTone();
  1858.         frm_p->key_tone_duration = GetKeypadDuration(key_code);
  1859.         AudioPlayReq(frm_p->key_tone_id, frm_p->key_tone_duration);
  1860.     }
  1861. }
  1864. /*****************************************************************************
  1865.  * FUNCTION
  1866.  *  mmi_frm_stop_keypad_tone
  1867.  * DESCRIPTION
  1868.  *  Function to stop corresponding keypad tone
  1869.  * PARAMETERS
  1870.  *  key_code        [IN]        Key code
  1871.  * RETURNS
  1872.  *  void
  1873.  *****************************************************************************/
  1874. void mmi_frm_stop_keypad_tone(S16 key_code)
  1875. {
  1876.     /*----------------------------------------------------------------*/
  1877.     /* Local Variables                                                */
  1878.     /*----------------------------------------------------------------*/
  1879.     U8 tone_type = GetKeypadToneType();
  1881.     /*----------------------------------------------------------------*/
  1882.     /* Code Body                                                      */
  1883.     /*----------------------------------------------------------------*/
  1884.     if (tone_type == KEYPAD_TONE)
  1885.     {
  1886.         SetCurKeypadTone(0xFFFF);
  1887.         if (GetKeypadDuration(key_code) == DEVICE_AUDIO_PLAY_INFINITE)
  1888.         {
  1889.             AudioStopReq(GetKeypadTone(key_code));
  1890.         }
  1891.     }
  1892. #if defined(__MMI_CUST_KEYPAD_TONE__)
  1893.     else if (tone_type >= KEYPAD_TONE_CUST_1 && tone_type <= KEYPAD_TONE_CUST_6
  1894. #if defined(__MMI_HUMAN_VOICE_KEYPAD_TONE__)
  1895.              && frm_p->key_tone_id < MIN_HUMAN_VOICE_ID)    /* MIN_KEYPAD_TONE_ID > MIN_HUMAN_VOICE_ID */
  1896. #else 
  1897.              && frm_p->key_tone_id < MIN_KEYPAD_TONE_ID)
  1898. #endif 
  1899. {
  1900.     SetCurKeypadTone(0xFFFF);
  1901.     if (frm_p->key_tone_duration == DEVICE_AUDIO_PLAY_INFINITE)
  1902.     {
  1903.         AudioStopReq(frm_p->key_tone_id);
  1904.     }
  1905. }
  1906. #endif /* defined(__MMI_CUST_KEYPAD_TONE__) */ 
  1907. #if defined(__MMI_HUMAN_VOICE_KEYPAD_TONE__)
  1908.     else
  1909. if (tone_type >= KEYPAD_TONE_HUMAN_VOICE_1 && tone_type <= KEYPAD_TONE_HUMAN_VOICE_6 && frm_p->key_tone_id < MIN_HUMAN_VOICE_ID)        /* MIN_KEYPAD_TONE_ID > MIN_HUMAN_VOICE_ID */
  1910. {
  1911.     SetCurKeypadTone(0xFFFF);
  1912.     if (frm_p->key_tone_duration == DEVICE_AUDIO_PLAY_INFINITE)
  1913.     {
  1914.         AudioStopReq(frm_p->key_tone_id);
  1915.     }
  1916. }
  1917. #endif /* defined(__MMI_HUMAN_VOICE_KEYPAD_TONE__) */ 
  1918. }
  1921. /*****************************************************************************
  1922.  * FUNCTION
  1923.  *  mmi_kbn_key_tone_hdlr
  1924.  * DESCRIPTION
  1925.  *  Function to handle general keypad tones
  1926.  * PARAMETERS
  1927.  *  eventKey        [IN]        Key event
  1928.  * RETURNS
  1929.  *  TRUE if general key tone plays; otherwise, FALSE.
  1930.  *****************************************************************************/
  1931. U8 mmi_kbn_key_tone_hdlr(KEYBRD_MESSAGE *eventKey)
  1932. {
  1933.     /*----------------------------------------------------------------*/
  1934.     /* Local Variables                                                */
  1935.     /*----------------------------------------------------------------*/
  1937.     /*----------------------------------------------------------------*/
  1938.     /* Code Body                                                      */
  1939.     /*----------------------------------------------------------------*/
  1940.     /* MTK added by JL 031220 for mute microphone to avoid the conflict with speaker and cause the DTMF frequency error */
  1941.     PRINT_INFORMATION_2((MMI_TRACE_G1_FRM, "key event <<code %d, type %d>> n", eventKey->nKeyCode,
  1942.                          eventKey->nMsgType));
  1943.     if (eventKey->nKeyCode == KEY_INVALID)
  1944.     {
  1945.         return MMI_TRUE;
  1946.     }
  1948.     /* To Play Tones */
  1949.     if (eventKey->nMsgType == KEY_EVENT_DOWN)
  1950.     {
  1951.         if (mmi_frm_kbd_is_tone_enabled(eventKey->nKeyCode, eventKey->nMsgType))
  1952.         {
  1953.             mmi_frm_play_keypad_tone(eventKey->nKeyCode);
  1954.         }
  1955.     }
  1956.     else if (eventKey->nMsgType == KEY_EVENT_UP)
  1957.     {
  1958.         mmi_frm_stop_keypad_tone(eventKey->nKeyCode);
  1959.     }
  1960.     #ifdef MMI_ON_WIN32
  1961.     if (((S16) eventKey->nMsgType == WM_KEYBRD_PRESS || (S16) eventKey->nMsgType == WM_KEYBRD_RELEASE))
  1962.     {
  1963.         MMI_system_keybord_handler((S16) eventKey->nKeyCode, (S16) eventKey->nMsgType);
  1964.         return MMI_TRUE;
  1965.     }
  1966.     #endif /* MMI_ON_WIN32 */ /* 0 */
  1968.     //move to Framework ExecuteCurrKeyHandler((S16)eventKey->nKeyCode,(S16)eventKey->nMsgType);
  1969.     //To continue to handler framework process, if false.
  1970.     return MMI_FALSE;
  1971. }
  1974. /*****************************************************************************
  1975.  * FUNCTION
  1976.  *  mmi_kbd_app_key_hdlr
  1977.  * DESCRIPTION
  1978.  *  Function to handle general appplication events
  1979.  * PARAMETERS
  1980.  *  eventKey        [?]         
  1981.  *  key_code(?)     [IN]        Key code
  1982.  * RETURNS
  1983.  *  U8, if return true, Framework will not control the key, otherwse.
  1984.  *****************************************************************************/
  1985. extern void mmi_idle_key_event_backlight_check(void);
  1986. extern void mmi_idle_key_event_keypad_lock_check(KEYBRD_MESSAGE *eventKey);
  1988. U8 mmi_kbd_app_key_hdlr(KEYBRD_MESSAGE *eventKey)
  1989. {
  1990.     /*----------------------------------------------------------------*/
  1991.     /* Local Variables                                                */
  1992.     /*----------------------------------------------------------------*/
  1994.     /*----------------------------------------------------------------*/
  1995.     /* Code Body                                                      */
  1996.     /*----------------------------------------------------------------*/
  1997.     /* diamond, 2006/02/06 Move these checking codes to idleapp.c */
  1998.     mmi_idle_key_event_backlight_check();
  1999.     mmi_idle_key_event_keypad_lock_check(eventKey);
  2001.     return mmi_kbn_key_tone_hdlr(eventKey);
  2002. }
  2005. /*****************************************************************************
  2006.  * FUNCTION
  2007.  *  mmi_kbd_set_concurrent_mode
  2008.  * DESCRIPTION
  2009.  *  Function to trun on/off concurrent mode. Key concurrent mode is to allow
  2010.  *  application handling (through call-back) concurrent two-key events on keypad.
  2011.  *  For example, user presses "up arrow" key while "left arrow" is pressing.
  2012.  *  In general cases, the mode is turned off to prevent applicaiton to make mistake
  2013.  *  at processing key events.
  2014.  * PARAMETERS
  2015.  *  mode        [IN]        Concurrent mode
  2016.  * RETURNS
  2017.  *  void
  2018.  *****************************************************************************/
  2019. void mmi_kbd_set_concurrent_mode(MMI_BOOL mode)
  2020. {
  2021. #if defined(__TWO_KEY_DETECTION_SWITCHABLE__)
  2022.     /*----------------------------------------------------------------*/
  2023.     /* Local Variables                                                */
  2024.     /*----------------------------------------------------------------*/
  2026.     /*----------------------------------------------------------------*/
  2027.     /* Code Body                                                      */
  2028.     /*----------------------------------------------------------------*/
  2029. #if !defined(MMI_ON_WIN32)
  2030.     if (mode == MMI_TRUE)
  2031.     {
  2032.         /* enable 2 key simultanenous detection */
  2033.         kbd_two_key_detection_switch(KAL_TRUE);
  2034.     }
  2035.     else
  2036.     {
  2037.         /* disable 2 key simultanenous detection */
  2038.         kbd_two_key_detection_switch(KAL_FALSE);
  2039.     }
  2040. #endif /* !defined(MMI_ON_WIN32) */ 
  2041.     ClearKeyEvents();
  2042.     g_kbd_concurrent_key_mode = mode;
  2044. #endif /* defined(__TWO_KEY_DETECTION_SWITCHABLE__) */ 
  2045.     return;
  2046. }
  2049. /*****************************************************************************
  2050.  * FUNCTION
  2051.  *  mmi_kbd_get_concurrent_mode
  2052.  * DESCRIPTION
  2053.  *  Function to handle transparent mode
  2054.  * PARAMETERS
  2055.  *  void
  2056.  * RETURNS
  2057.  *  MMI_TRUE if at coucurrent mode; MMI_FALSE if not.
  2058.  *****************************************************************************/
  2059. MMI_BOOL mmi_kbd_get_concurrent_mode(void)
  2060. {
  2061.     /*----------------------------------------------------------------*/
  2062.     /* Local Variables                                                */
  2063.     /*----------------------------------------------------------------*/
  2065.     /*----------------------------------------------------------------*/
  2066.     /* Code Body                                                      */
  2067.     /*----------------------------------------------------------------*/
  2068.     return g_kbd_concurrent_key_mode;
  2069. }
  2072. /*****************************************************************************
  2073.  * FUNCTION
  2074.  *  mmi_kbd_get_key_is_pressing_count
  2075.  * DESCRIPTION
  2076.  *  Function to query count of keys are under pressing state
  2077.  * PARAMETERS
  2078.  *  void
  2079.  * RETURNS
  2080.  *  count of keys are under pressing state
  2081.  *****************************************************************************/
  2082. U8 mmi_kbd_get_key_is_pressing_count(void)
  2083. {
  2084.     /*----------------------------------------------------------------*/
  2085.     /* Local Variables                                                */
  2086.     /*----------------------------------------------------------------*/
  2088.     /*----------------------------------------------------------------*/
  2089.     /* Code Body                                                      */
  2090.     /*----------------------------------------------------------------*/
  2091.     return key_is_pressing_count;
  2092. }
  2095. /*****************************************************************************
  2096.  * FUNCTION
  2097.  mmi_frm_set_default_power_onoff_key
  2098.  * DESCRIPTION
  2099.  *  set power on/off key to default handler
  2100.  * PARAMETERS
  2101.  *  void
  2102.  * RETURNS
  2103.  *  void
  2104.  *****************************************************************************/
  2105. void mmi_frm_set_default_power_onoff_key(void)
  2106. {
  2107. #ifdef __MMI_POWER_ON_OFF_BY_POWER_KEY__
  2108.     SetKeyHandler(NULL, KEY_END, KEY_LONG_PRESS);
  2109.     SetKeyHandler(ShutdownSystemOperation, KEY_POWER, KEY_LONG_PRESS);
  2110. #else
  2111.     SetKeyHandler(ShutdownSystemOperation, KEY_END, KEY_LONG_PRESS);
  2112. #endif /* __MMI_POWER_ON_OFF_BY_POWER_KEY__ */
  2113. }