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

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

MTK

开发平台：

C/C++

PhoneBookSearch.c：源码内容
  1.             mdi_audio_stop_string();
  2.         }
  3.     #endif /* defined(__MMI_INTELLIGENT_CALL_ALERT__) */ 
  4.     }
  5.     else if (gInsertSimAppFlag != 1
  6. #ifdef __FLIGHT_MODE_SUPPORT__
  7.              && mmi_bootup_get_active_flight_mode() != 1
  8. #endif 
  9.         )
  10.     {
  11.         SetKeyHandler(mmi_phb_list_pre_choose_number, KEY_SEND, KEY_EVENT_UP);
  12.     }
  14.     return result_count;
  16. }
  19. /*****************************************************************************
  20.  * FUNCTION
  21.  *  mmi_phb_quick_search_get_index
  22.  * DESCRIPTION
  23.  *  
  24.  * PARAMETERS
  25.  *  nIndex      [IN]        
  26.  * RETURNS
  27.  *  void
  28.  *****************************************************************************/
  29. void mmi_phb_quick_search_get_index(S32 nIndex)
  30. {
  31.     /*----------------------------------------------------------------*/
  32.     /* Local Variables                                                */
  33.     /*----------------------------------------------------------------*/
  34.     U16 i, count;
  36.     /*----------------------------------------------------------------*/
  37.     /* Code Body                                                      */
  38.     /*----------------------------------------------------------------*/
  39.     count = 0;
  40.     for (i = 0; i < PhoneBookEntryCount; i++)
  41.     {
  42.         /* if(g_phb_qsearch[i] == 1) */
  43.         if (g_phb_qsearch_bitmask[i >> BYTE_SIZE_SHIFT_ARITHMETIC] & (1 << (i % BYTE_SIZE)))
  44.         {
  45.             if (count == nIndex)
  46.             {
  47.                 break;
  48.             }
  49.             count++;
  50.         }
  51.     }
  53.     g_phb_cntx.active_index = i;
  55. #if defined(__MMI_INTELLIGENT_CALL_ALERT__)
  56.     StopTimer(PHB_LIST_SPEAK_NAME_TIMER);
  57.     if (g_phb_is_speaking_name)
  58.     {
  59.         mdi_audio_stop_string();
  60.     }
  62.     if (g_phb_cntx.speak_name)
  63.     {
  64.         StartTimer(PHB_LIST_SPEAK_NAME_TIMER, UI_POPUP_NOTIFYDURATION_TIME, mmi_phb_list_speak_name);
  65.     }
  66. #endif /* defined(__MMI_INTELLIGENT_CALL_ALERT__) */ 
  68. }
  71. /*****************************************************************************
  72.  * FUNCTION
  73.  *  mmi_phb_quick_search_list_pre_entry
  74.  * DESCRIPTION
  75.  *  
  76.  * PARAMETERS
  77.  *  void
  78.  * RETURNS
  79.  *  void
  80.  *****************************************************************************/
  81. void mmi_phb_quick_search_list_pre_entry(void)
  82. {
  83.     /*----------------------------------------------------------------*/
  84.     /* Local Variables                                                */
  85.     /*----------------------------------------------------------------*/
  87.     /*----------------------------------------------------------------*/
  88.     /* Code Body                                                      */
  89.     /*----------------------------------------------------------------*/
  90. #ifdef __SYNCML_SUPPORT__
  91.     if (mmi_syncml_is_phb_sync_now())
  92.     {
  93.         mmi_phb_entry_not_ready(STR_ID_SYNC_PLEASE_WAIT);
  94.     }
  95.     else
  96. #endif /* __SYNCML_SUPPORT__ */
  97.     if (g_phb_cntx.phb_ready && !g_phb_cntx.processing)
  98.     {
  99.         if (PhoneBookEntryCount)
  100.         {
  101.             mmi_phb_entry_quick_search_list();
  102.         }
  103.         else
  104.         {
  105.             DisplayPopup(
  106.                 (PU8) GetString(STR_NO_ENTRIES_MESSAGE),
  107.                 IMG_GLOBAL_EMPTY,
  108.                 TRUE,
  109.                 PHB_NOTIFY_TIMEOUT,
  110.                 EMPTY_LIST_TONE);
  111.         }
  112.     }
  113.     else
  114.     {
  115.         mmi_phb_entry_not_ready(STR_PROCESSING_PHONEBOOK);
  116.     }
  117. }
  120. /*****************************************************************************
  121.  * FUNCTION
  122.  *  mmi_phb_entry_quick_search_list
  123.  * DESCRIPTION
  124.  *  
  125.  * PARAMETERS
  126.  *  void
  127.  * RETURNS
  128.  *  void
  129.  *****************************************************************************/
  130. void mmi_phb_entry_quick_search_list(void)
  131. {
  132.     /*----------------------------------------------------------------*/
  133.     /* Local Variables                                                */
  134.     /*----------------------------------------------------------------*/
  135.     U8 *guiBuffer;
  136.     U16 entryCount;
  138.     /*----------------------------------------------------------------*/
  139.     /* Code Body                                                      */
  140.     /*----------------------------------------------------------------*/
  141.     EntryNewScreen(
  142.         SCR_ID_PHB_QUICK_SEARCH_LIST,
  143.         mmi_phb_exit_quick_search_list,
  144.         mmi_phb_quick_search_list_pre_entry,
  145.         NULL);
  146.     guiBuffer = GetCurrGuiBuffer(SCR_ID_PHB_QUICK_SEARCH_LIST);
  147.     RegisterHighlightHandler(mmi_phb_quick_search_get_index);
  149.     RegisterCat200SearchFunction(mmi_phb_quick_search_find_entry);
  151.     /* First Time enter or any entry has been modified.. */
  152.     if ((guiBuffer == NULL) || (g_phb_cntx.refresh_list == MMI_PHB_ENTRY_REFRESH))
  153.     {
  154.         g_phb_cntx.highlight_entry = 0;
  155.         memset(g_phb_qsearch_input, 0, ENCODING_LENGTH);
  156.         // memset(g_phb_qsearch,1,MAX_PB_ENTRIES);  /*All records are in the subset at the beginning*/
  157.         memset(g_phb_qsearch_bitmask, 0xff, (MAX_PB_ENTRIES + 7) / 8);
  159.         entryCount = PhoneBookEntryCount;
  160.         guiBuffer = NULL;
  161.         g_phb_cntx.refresh_list = MMI_PHB_ENTRY_QSEARCH;    /* '2' is used only for this screen. */
  162.     }
  163.     else
  164.     {
  165.         entryCount = (U16) mmi_phb_quick_search_find_entry(g_phb_qsearch_input);
  166.     }
  168. #ifdef __MMI_UI_HINTS_IN_MENUITEM__
  169.     set_force_icon_on_highlight_only_in_menuitem();
  170. #endif 
  171.     ShowCategory200Screen(
  172.         STR_SCR_PBOOK_VIEW_CAPTION,
  173.         IMG_SCR_PBOOK_CAPTION,
  174.         STR_GLOBAL_OPTIONS,
  175.         IMG_GLOBAL_OPTIONS,
  176.         STR_GLOBAL_BACK,
  177.         IMG_GLOBAL_BACK,
  178.         entryCount,
  179.         mmi_phb_quick_search_list_get_item,
  180.         mmi_phb_quick_search_list_get_hint,
  181.         g_phb_cntx.highlight_entry,
  182.         IMG_ID_PHB_QUICK_SEARCH_FIND,
  183.         (U8*) g_phb_qsearch_input,
  184.         MMI_PHB_QUICK_SEARCH_INPUT_LENGTH,
  185.         guiBuffer);
  187.     SetCategory200RightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  189. #if defined(__MMI_MULTITAP_FOR_STAR_AND_POUND__)
  190.     SetCategory200LeftSoftkeyFunction(mmi_phb_entry_quick_search_option, KEY_EVENT_UP);
  191.     SetLeftSoftkeyFunction(mmi_phb_entry_quick_search_option, KEY_EVENT_UP);
  192. #else /* defined(__MMI_MULTITAP_FOR_STAR_AND_POUND__) */ 
  193.     SetCategory200LeftSoftkeyFunction(mmi_phb_entry_op_option, KEY_EVENT_UP);
  194.     SetLeftSoftkeyFunction(mmi_phb_entry_op_option, KEY_EVENT_UP);
  195. #endif /* defined(__MMI_MULTITAP_FOR_STAR_AND_POUND__) */ 
  196.     if (gInsertSimAppFlag != 1 && entryCount > 0
  197. #ifdef __FLIGHT_MODE_SUPPORT__
  198.         && mmi_bootup_get_active_flight_mode() != 1
  199. #endif 
  200.         )
  201.     {
  202.         SetKeyHandler(mmi_phb_list_pre_choose_number, KEY_SEND, KEY_EVENT_UP);
  203.     }
  204.     //MTK Elvis 20040517--it is incorrect to regist RSK here
  205.     //SetRightSoftkeyFunction(GoBackHistory,KEY_EVENT_UP);
  207.     /* Make cache according to the current input method, after input method initialized in ShowCategoryScreen. */
  208.     if (guiBuffer == NULL)
  209.     {
  210.         g_phb_qsearch_is_cache = 0;
  211.         mmi_phb_quick_search_make_cache();
  212.     }
  213. }
  216. /*****************************************************************************
  217.  * FUNCTION
  218.  *  mmi_phb_exit_quick_search_list
  219.  * DESCRIPTION
  220.  *  
  221.  * PARAMETERS
  222.  *  void
  223.  * RETURNS
  224.  *  void
  225.  *****************************************************************************/
  226. void mmi_phb_exit_quick_search_list(void)
  227. {
  228. #if defined(__MMI_PHB_RSK_QUICK_SEARCH__)
  229.     /*----------------------------------------------------------------*/
  230.     /* Local Variables                                                */
  231.     /*----------------------------------------------------------------*/
  233.     /*----------------------------------------------------------------*/
  234.     /* Code Body                                                      */
  235.     /*----------------------------------------------------------------*/
  236.     if (g_idle_context.ToNameScrFromIdleApp)
  237.     {
  238.         g_phb_cntx.start_scr_id = SCR_ID_PHB_QUICK_SEARCH_LIST;
  239.     }
  240.     g_phb_cntx.end_scr_id = SCR_ID_PHB_QUICK_SEARCH_LIST;
  242.     g_idle_context.ToNameScrFromIdleApp = 0;
  243.     g_idle_context.RskPressedFromIdleApp = 0;
  245.     StopTimer(KEYPAD_LOCK_TIMER);
  247. #if defined(__MMI_VRSD_DIAL__)
  248.     StopTimer(VRSD_DIAL_PLAYBACK_TIMER);
  249. #endif 
  251. #endif /* defined(__MMI_PHB_RSK_QUICK_SEARCH__) */ 
  253. #if defined(__MMI_INTELLIGENT_CALL_ALERT__)
  254.     StopTimer(PHB_LIST_SPEAK_NAME_TIMER);
  255.     if (g_phb_is_speaking_name)
  256.     {
  257.         mdi_audio_stop_string();
  258.     }
  259. #endif /* defined(__MMI_INTELLIGENT_CALL_ALERT__) */ 
  260. }
  263. /*****************************************************************************
  264.  * FUNCTION
  265.  *  mmi_phb_quick_search_list_get_item
  266.  * DESCRIPTION
  267.  *  
  268.  * PARAMETERS
  269.  *  item_index          [IN]        
  270.  *  str_buff            [IN]        
  271.  *  img_buff_p          [?]         
  272.  *  str_img_mask        [IN]        
  273.  * RETURNS
  274.  *  
  275.  *****************************************************************************/
  276. pBOOL mmi_phb_quick_search_list_get_item(S32 item_index, UI_string_type str_buff, PU8 *img_buff_p, U8 str_img_mask)
  277. {
  278.     /*----------------------------------------------------------------*/
  279.     /* Local Variables                                                */
  280.     /*----------------------------------------------------------------*/
  281.     U16 i, count, store_index;
  283.     /*----------------------------------------------------------------*/
  284.     /* Code Body                                                      */
  285.     /*----------------------------------------------------------------*/
  286.     count = 0;
  287.     for (i = 0; i < PhoneBookEntryCount; i++)
  288.     {
  289.         /* if(g_phb_qsearch[i] == 1) */
  290.         if (g_phb_qsearch_bitmask[i >> BYTE_SIZE_SHIFT_ARITHMETIC] & (1 << (i % BYTE_SIZE)))
  291.         {
  292.             if (count == item_index)
  293.             {
  294.                 break;
  295.             }
  296.             count++;
  297.         }
  298.     }
  300.     store_index = g_phb_name_index[i];
  301.     if (pfnUnicodeStrlen((S8*) PhoneBook[store_index].alpha_id.name))
  302.     {
  303.         pfnUnicodeStrcpy((S8*) str_buff, (S8*) PhoneBook[store_index].alpha_id.name);
  304.     }
  305.     else
  306.     {
  307.         mmi_phb_convert_get_ucs2_number((S8*) str_buff, store_index);
  308.     }
  310.     if (store_index >= MAX_PB_PHONE_ENTRIES)    /* In SIM */
  311.     {
  312.         *img_buff_p = get_image(IMG_STORAGE_SIM);
  313.     }
  314.     else
  315.     {
  316.         *img_buff_p = get_image(IMG_STORAGE_HANDSET);
  317.     }
  319.     return TRUE;
  320. }
  323. /*****************************************************************************
  324.  * FUNCTION
  325.  *  mmi_phb_quick_search_list_get_hint
  326.  * DESCRIPTION
  327.  *  
  328.  * PARAMETERS
  329.  *  item_index      [IN]        
  330.  *  hint_array      [?]         
  331.  * RETURNS
  332.  *  
  333.  *****************************************************************************/
  334. S32 mmi_phb_quick_search_list_get_hint(S32 item_index, UI_string_type *hint_array)
  335. {
  336.     /*----------------------------------------------------------------*/
  337.     /* Local Variables                                                */
  338.     /*----------------------------------------------------------------*/
  339.     U16 i, count, store_index;
  340.     S8 temp_number[(MAX_PB_NUMBER_LENGTH + 1 + 1) * ENCODING_LENGTH];
  342.     /*----------------------------------------------------------------*/
  343.     /* Code Body                                                      */
  344.     /*----------------------------------------------------------------*/
  345.     count = 0;
  346.     for (i = 0; i < PhoneBookEntryCount; i++)
  347.     {
  348.         /* if(g_phb_qsearch[i] == 1) */
  349.         if (g_phb_qsearch_bitmask[i >> BYTE_SIZE_SHIFT_ARITHMETIC] & (1 << (i % BYTE_SIZE)))
  350.         {
  351.             if (count == item_index)
  352.             {
  353.                 break;
  354.             }
  355.             count++;
  356.         }
  357.     }
  359.     store_index = g_phb_name_index[i];
  360.     mmi_phb_convert_get_ucs2_number((S8*) temp_number, store_index);
  362.     if (pfnUnicodeStrlen((S8*) PhoneBook[store_index].alpha_id.name) && pfnUnicodeStrlen((S8*) temp_number))
  363.     {
  364.         pfnUnicodeStrcpy((S8*) hint_array[0], (S8*) temp_number);
  365.     }
  366.     else
  367.     {
  368.         return 0;
  369.     }
  371.     return 1;   /* One hint data only, can be more hints. */
  372. }
  375. /*****************************************************************************
  376.  * FUNCTION
  377.  *  mmi_phb_quick_search_change_input_mode
  378.  * DESCRIPTION
  379.  *  
  380.  * PARAMETERS
  381.  *  void
  382.  * RETURNS
  383.  *  void
  384.  *****************************************************************************/
  385. void mmi_phb_quick_search_change_input_mode(void)
  386. {
  387.     /*----------------------------------------------------------------*/
  388.     /* Local Variables                                                */
  389.     /*----------------------------------------------------------------*/
  391.     /*----------------------------------------------------------------*/
  392.     /* Code Body                                                      */
  393.     /*----------------------------------------------------------------*/
  394.     // memset(g_phb_qsearch,1,MAX_PB_ENTRIES);  /*All records are in the subset at the beginning*/
  395.     memset(g_phb_qsearch_bitmask, 0xff, (MAX_PB_ENTRIES + 7) / 8);
  396.     g_phb_qsearch_is_cache = 0;
  398.     /*
  399.      * Make cache according to the current input method.
  400.      * Start a timer to avoid convert cache each time when user change input method quickly.
  401.      */
  402.     StopTimer(PHB_QUICK_SEARCH_TIMER);
  403.     StartTimer(PHB_QUICK_SEARCH_TIMER, 500, mmi_phb_quick_search_make_cache);
  404. }
  406. #if defined(__MMI_MULTITAP_FOR_STAR_AND_POUND__)
  407. extern void EntryQuickSearchInputMethodScreen(void);
  410. /*****************************************************************************
  411.  * FUNCTION
  412.  *  mmi_phb_quick_search_go_back_editor
  413.  * DESCRIPTION
  414.  *  Go back screen after change input method.
  415.  * PARAMETERS
  416.  *  void
  417.  * RETURNS
  418.  *  void
  419.  *****************************************************************************/
  420. void mmi_phb_quick_search_go_back_editor(void)
  421. {
  422.     /*----------------------------------------------------------------*/
  423.     /* Local Variables                                                */
  424.     /*----------------------------------------------------------------*/
  426.     /*----------------------------------------------------------------*/
  427.     /* Code Body                                                      */
  428.     /*----------------------------------------------------------------*/
  429.     GoBackToHistory(SCR_ID_PHB_QUICK_SEARCH_LIST);
  430. }
  433. /*****************************************************************************
  434.  * FUNCTION
  435.  *  mmi_phb_highlight_quick_search_input_method
  436.  * DESCRIPTION
  437.  *  Highlight function to enter change input method
  438.  * PARAMETERS
  439.  *  void
  440.  * RETURNS
  441.  *  void
  442.  *****************************************************************************/
  443. void mmi_phb_highlight_quick_search_input_method(void)
  444. {
  445.     /*----------------------------------------------------------------*/
  446.     /* Local Variables                                                */
  447.     /*----------------------------------------------------------------*/
  449.     /*----------------------------------------------------------------*/
  450.     /* Code Body                                                      */
  451.     /*----------------------------------------------------------------*/
  452.     SetLeftSoftkeyFunction(EntryQuickSearchInputMethodScreen, KEY_EVENT_UP);
  453.     SetKeyHandler(EntryQuickSearchInputMethodScreen, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  455.     RegisterInputMethodScreenCloseFunction(mmi_phb_quick_search_go_back_editor);
  456. }
  459. /*****************************************************************************
  460.  * FUNCTION
  461.  *  mmi_phb_highlight_quick_search_op_option
  462.  * DESCRIPTION
  463.  *  Highlight function to enter entry option.
  464.  * PARAMETERS
  465.  *  void
  466.  * RETURNS
  467.  *  void
  468.  *****************************************************************************/
  469. void mmi_phb_highlight_quick_search_op_option(void)
  470. {
  471.     /*----------------------------------------------------------------*/
  472.     /* Local Variables                                                */
  473.     /*----------------------------------------------------------------*/
  475.     /*----------------------------------------------------------------*/
  476.     /* Code Body                                                      */
  477.     /*----------------------------------------------------------------*/
  478.     SetLeftSoftkeyFunction(mmi_phb_entry_op_option, KEY_EVENT_UP);
  479.     SetKeyHandler(mmi_phb_entry_op_option, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  480. }
  483. /*****************************************************************************
  484.  * FUNCTION
  485.  *  mmi_phb_entry_quick_search_option
  486.  * DESCRIPTION
  487.  *  Entry function of phonebook quick search option.
  488.  * PARAMETERS
  489.  *  void
  490.  * RETURNS
  491.  *  void
  492.  *****************************************************************************/
  493. void mmi_phb_entry_quick_search_option(void)
  494. {
  495.     /*----------------------------------------------------------------*/
  496.     /* Local Variables                                                */
  497.     /*----------------------------------------------------------------*/
  498.     U8 *guiBuffer;
  499.     U16 nStrItemList[10];   /* Need Expand when has more options. */
  500.     U16 nNumofItem;
  502.     /*----------------------------------------------------------------*/
  503.     /* Code Body                                                      */
  504.     /*----------------------------------------------------------------*/
  505.     EntryNewScreen(
  506.         SCR_ID_PHB_QUICK_SEARCH_OPTION,
  507.         mmi_phb_exit_quick_search_option,
  508.         mmi_phb_entry_quick_search_option,
  509.         NULL);
  510.     guiBuffer = GetCurrGuiBuffer(SCR_ID_PHB_QUICK_SEARCH_OPTION);
  511.     nNumofItem = GetNumOfChild(MENU_ID_PHB_QUICK_SEARCH_OPTION);
  512.     GetSequenceStringIds(MENU_ID_PHB_QUICK_SEARCH_OPTION, nStrItemList);
  513.     SetParentHandler(MENU_ID_PHB_QUICK_SEARCH_OPTION);
  514.     RegisterHighlightHandler(ExecuteCurrHiliteHandler);
  516.     ShowCategory15Screen(
  517.         STR_GLOBAL_OPTIONS,
  518.         IMG_SCR_PBOOK_CAPTION,
  519.         STR_GLOBAL_OK,
  520.         IMG_GLOBAL_OK,
  521.         STR_GLOBAL_BACK,
  522.         IMG_GLOBAL_BACK,
  523.         nNumofItem,
  524.         nStrItemList,
  525.         (U16*) gIndexIconsImageList,
  526.         LIST_MENU,
  527.         0,
  528.         guiBuffer);
  530.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  531.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  532. }
  535. /*****************************************************************************
  536.  * FUNCTION
  537.  *  mmi_phb_exit_quick_search_option
  538.  * DESCRIPTION
  539.  *  Exit function of phonebook quick search option
  540.  * PARAMETERS
  541.  *  void
  542.  * RETURNS
  543.  *  void
  544.  *****************************************************************************/
  545. void mmi_phb_exit_quick_search_option(void)
  546. {
  547.     /*----------------------------------------------------------------*/
  548.     /* Local Variables                                                */
  549.     /*----------------------------------------------------------------*/
  551.     /*----------------------------------------------------------------*/
  552.     /* Code Body                                                      */
  553.     /*----------------------------------------------------------------*/
  554.     g_phb_cntx.end_scr_id = SCR_ID_PHB_QUICK_SEARCH_OPTION;
  555. }
  556. #endif /* defined(__MMI_MULTITAP_FOR_STAR_AND_POUND__) */ 
  557. #endif /* defined(__MMI_PHB_QUICK_SEARCH__) */
  560. #define MMI_PHB_UTIL_SEARCH
  561. /*---------------------------------------------------- General Compare String Functions -------------------------------------------------*/
  562. /*****************************************************************************
  563.  * FUNCTION
  564.  *  mmi_phb_compare_chars
  565.  * PARAMETERS
  566.  *  char1       [IN]        
  567.  *  char2       [IN]        
  568.  * RETURNS
  569.  *  
  570.  *****************************************************************************/
  571. S32 mmi_phb_compare_chars(U16 char1, U16 char2)
  572. {
  573.     /*----------------------------------------------------------------*/
  574.     /* Local Variables                                                */
  575.     /*----------------------------------------------------------------*/
  577.     /*----------------------------------------------------------------*/
  578.     /* Code Body                                                      */
  579.     /*----------------------------------------------------------------*/
  580.     /* try UCS2 matching */
  581.     if (char1 == char2)
  582.     {
  583.         return 0;
  584.     }
  586.     /* if not, try ASCII case-insensitive matching */
  587.     else if ((char1 < 0x007E) && (char2 < 0x007E))
  588.     {
  589.         if ((char1 <= 0x007b) && (char1 >= 0x0061))
  590.         {
  591.             char1 -= 0x20;
  592.         }
  593.         if ((char2 <= 0x007b) && (char2 >= 0x0061))
  594.         {
  595.             char2 -= 0x20;
  596.         }
  598.         return char1 - char2;
  599.     }
  601.     /* no match */
  602.     return char1 - char2;
  603. }
  606. /*****************************************************************************
  607.  * FUNCTION
  608.  *  mmi_phb_compare_ucs2_strings
  609.  * PARAMETERS
  610.  *  string1         [?]     
  611.  *  string2         [?]     
  612.  *  same_count      [?]     
  613.  *  distance        [?]     
  614.  * RETURNS
  615.  *  void
  616.  *****************************************************************************/
  617. void mmi_phb_compare_ucs2_strings(S8 *string1, S8 *string2, U8 *same_count, S32 *distance)
  618. {
  619.     /*----------------------------------------------------------------*/
  620.     /* Local Variables                                                */
  621.     /*----------------------------------------------------------------*/
  622.     U8 len1, len2;
  623.     U8 max_len, min_len;
  624.     U8 i;
  625.     U16 code1, code2;
  627.     /*----------------------------------------------------------------*/
  628.     /* Code Body                                                      */
  629.     /*----------------------------------------------------------------*/
  630.     *same_count = 0;
  631.     *distance = 0;
  633.     len1 = (U8) pfnUnicodeStrlen(string1);
  634.     len2 = (U8) pfnUnicodeStrlen(string2);
  636.     if (len1 > len2)
  637.     {
  638.         max_len = len1;
  639.         min_len = len2;
  640.     }
  641.     else
  642.     {
  643.         max_len = len2;
  644.         min_len = len1;
  645.     }
  647.     for (i = 0; i < max_len && i < MAX_PB_EMAIL_LENGTH; i++)    /* Use Max Phonebook Strlen as upper bound */
  648.         /* for (i = 0; i < max_len; i++) */
  649.     {
  650.         /* If all characters are identical from 0 to min_len. */
  651.         if (i >= min_len)
  652.         {
  653.             /* First is greater than second */
  654.             if (len1 > len2)
  655.             {
  656.                 *distance = (U16) string1[i * ENCODING_LENGTH];
  657.             }
  658.             /* First and second is congruence */
  659.             else if (len1 == len2)
  660.             {
  661.                 *distance = 0;
  662.             }
  663.             /* len1 < len2: First is less than second */
  664.             else
  665.             {
  666.                 *distance = -(U16) string2[i * ENCODING_LENGTH];
  667.             }
  669.             //if (min_len == 0)
  670.             //     *distance = - *distance;
  672.             break;
  673.         }
  675.         /* First, compare from 0 to min_len */
  676.         else
  677.         {
  678.             memcpy(&code1, (string1 + i * ENCODING_LENGTH), 2);
  679.             memcpy(&code2, (string2 + i * ENCODING_LENGTH), 2);
  681.             if ((*distance = mmi_phb_compare_chars(code1, code2)) == 0)
  682.             {
  683.                 *same_count = *same_count + 1;
  684.             }
  685.             /* First and second is not equal, return distance */
  686.             else
  687.             {
  688.                 break;
  689.             }
  690.         }
  691.     }
  693. }
  696. /*****************************************************************************
  697.  * FUNCTION
  698.  *  mmi_phb_compare_ascii_strings
  699.  * PARAMETERS
  700.  *  string1         [?]     > string2 ; <0 if sting1 < string2
  701.  *  string2         [?]     
  702.  *  same_count      [?]     
  703.  *  distance        [?]     
  704.  *****************************************************************************/
  705. void mmi_phb_compare_ascii_strings(S8 *string1, S8 *string2, U16 *same_count, S32 *distance)
  706. {
  707.     /*----------------------------------------------------------------*/
  708.     /* Local Variables                                                */
  709.     /*----------------------------------------------------------------*/
  710.     U16 len1, len2;
  711.     U16 max_len, min_len;
  712.     U16 i;
  713.     U16 code1, code2;
  715.     /*----------------------------------------------------------------*/
  716.     /* Code Body                                                      */
  717.     /*----------------------------------------------------------------*/
  718.     *same_count = 0;
  719.     *distance = 0;
  721.     len1 = strlen(string1);
  722.     len2 = strlen(string2);
  724.     if (len1 > len2)
  725.     {
  726.         max_len = len1;
  727.         min_len = len2;
  728.     }
  729.     else
  730.     {
  731.         max_len = len2;
  732.         min_len = len1;
  733.     }
  735.     for (i = 0; i < max_len; i++)
  736.     {
  737.         if (i >= min_len)   /* If all characters are identical from 0 to min_len. */
  738.         {
  739.             if (len1 > len2)    /* First is greater than second */
  740.             {
  741.                 *distance = (U16) string1[i];
  742.             }
  743.             else if (len1 == len2)  /* First and second is congruence */
  744.             {
  745.                 *distance = 0;
  746.             }
  747.             else    /* len1 < len2: First is less than second */
  748.             {
  749.                 *distance = -(U16) string2[i];
  750.             }
  752.             if (min_len == 0)
  753.             {
  754.                 *distance = -*distance;
  755.             }
  756.             break;
  757.         }
  758.         else    /* First, compare from 0 to min_len */
  759.         {
  760.             code1 = (U16) string1[i];
  761.             code2 = (U16) string2[i];
  763.             if ((*distance = mmi_phb_compare_chars(code1, code2)) == 0)
  764.             {
  765.                 *same_count = *same_count + 1;
  766.             }
  767.             else    /* First and second is not equal, return distance */
  768.             {
  769.                 break;
  770.             }
  771.         }
  772.     }
  773. }
  775. #if defined(__MMI_PHB_PINYIN_SORT__)
  778. /*****************************************************************************
  779.  * FUNCTION
  780.  *  mmi_phb_util_make_pinyin_cache
  781.  * DESCRIPTION
  782.  *  
  783.  * PARAMETERS
  784.  *  store_index     [IN]        
  785.  * RETURNS
  786.  *  void
  787.  *****************************************************************************/
  788. void mmi_phb_util_make_pinyin_cache(U16 store_index)
  789. {
  790.     /*----------------------------------------------------------------*/
  791.     /* Local Variables                                                */
  792.     /*----------------------------------------------------------------*/
  793.     U16 count;
  795.     /*----------------------------------------------------------------*/
  796.     /* Code Body                                                      */
  797.     /*----------------------------------------------------------------*/
  798.     if ((PhoneBook[store_index].alpha_id.name_length != 0) &&
  799.         (PhoneBook[store_index].alpha_id.name_dcs != MMI_PHB_ASCII))
  800.     {
  801.         count = mmi_phb_util_convert_to_pinyin(
  802.                     PhoneBook[store_index].alpha_id.name,
  803.                     &g_phb_name_pinyin_index[store_index][0],
  804.                     MMI_PHB_SORT_LENGTH * ENCODING_LENGTH);
  805.         g_phb_name_pinyin_index[store_index][count++] = 0x00;
  806.         g_phb_name_pinyin_index[store_index][count++] = 0x00;
  807.     }
  808.     else
  809.     {
  810.         memset(&g_phb_name_pinyin_index[store_index][0], 0, 2);
  811.     }
  812. }
  815. /*****************************************************************************
  816.  * FUNCTION
  817.  *  mmi_phb_util_get_pinyin_cache
  818.  * DESCRIPTION
  819.  *  
  820.  * PARAMETERS
  821.  *  store_index     [IN]        
  822.  *  pinyin_ptr      [IN]        
  823.  * RETURNS
  824.  *  void
  825.  *****************************************************************************/
  826. void mmi_phb_util_get_pinyin_cache(U16 store_index, U8 **pinyin_ptr)
  827. {
  828.     /*----------------------------------------------------------------*/
  829.     /* Local Variables                                                */
  830.     /*----------------------------------------------------------------*/
  832.     /*----------------------------------------------------------------*/
  833.     /* Code Body                                                      */
  834.     /*----------------------------------------------------------------*/
  835.     *pinyin_ptr = &g_phb_name_pinyin_index[store_index][0];
  836. }
  839. /*****************************************************************************
  840.  * FUNCTION
  841.  *  mmi_phb_util_convert_to_pinyin
  842.  * DESCRIPTION
  843.  *  This function convert the input string into Chinese Pinyin string according to the library
  844.  *  Between each pinyin string result, it will append the original encoding to seperate two
  845.  *  Chinese pinyin result.
  846.  * PARAMETERS
  847.  *  inputString         [?]         The input string buffer in ucs2 format.
  848.  *  outputString        [?]         The output string buffer, it will be ucs2 format
  849.  *  out_length          [IN]        The output string buffer size, in bytes.
  850.  * RETURNS
  851.  *  void
  852.  *****************************************************************************/
  853. #if defined(__MMI_T9__)
  854. #if defined(__MMI_T9_V7__)
  855. U16 mmi_phb_util_convert_to_pinyin(U8 *inputString, U8 *outputString, U16 out_length)
  856. {
  857.     /*----------------------------------------------------------------*/
  858.     /* Local Variables                                                */
  859.     /*----------------------------------------------------------------*/
  860.     T9STATUS t9ReturnCodes;
  861.     U8 i, out = 0;
  863.     /*----------------------------------------------------------------*/
  864.     /* Code Body                                                      */
  865.     /*----------------------------------------------------------------*/
  866.     T9ChangeLanguageToSMChinesePinYin();
  868.     while (!((*inputString == 0) && (*(inputString + 1) == 0)) && ((out + 1) < out_length))
  869.     {
  870.         t9ReturnCodes = T9CCGetCharSpell(&FieldInfo.CCFieldInfo, (U16*) inputString, 0);
  872.         if (t9ReturnCodes == 0) /* (code >= 0x4e00) && (code <= 0x9fa5) */
  873.         {
  874.             i = 0;
  875.             while ((FieldInfo.CCFieldInfo.pbSpellBuf[i] != 0x00) && ((out + 1) < out_length))
  876.             {
  877.                 outputString[out++] = FieldInfo.CCFieldInfo.pbSpellBuf[i++];
  878.                 outputString[out++] = 0x00;
  879.             }
  880.         }
  882.         /* Add character encoding beetween pinyin strings */
  883.         if ((out + 1) < out_length)
  884.         {
  885.             outputString[out++] = inputString[0];
  886.             outputString[out++] = inputString[1];
  887.         }
  889.         inputString += 2;
  890.     }
  892.     return out;
  893. }
  894. #else /* defined(__MMI_T9_V7__) */ 
  897. /*****************************************************************************
  898.  * FUNCTION
  899.  *  mmi_phb_util_convert_to_pinyin
  900.  * DESCRIPTION
  901.  *  
  902.  * PARAMETERS
  903.  *  inputString         [?]         
  904.  *  outputString        [?]         
  905.  *  out_length          [IN]        
  906.  * RETURNS
  907.  *  
  908.  *****************************************************************************/
  909. U16 mmi_phb_util_convert_to_pinyin(U8 *inputString, U8 *outputString, U16 out_length)
  910. {
  911.     /*----------------------------------------------------------------*/
  912.     /* Local Variables                                                */
  913.     /*----------------------------------------------------------------*/
  914.     T9Event t9EventInput;
  915.     T9STATUS t9ReturnCodes;
  916.     U8 i, out = 0;
  918.     /*----------------------------------------------------------------*/
  919.     /* Code Body                                                      */
  920.     /*----------------------------------------------------------------*/
  921.     T9ChangeLanguageToSMChinesePinYin();
  923.     while (!((*inputString == 0) && (*(inputString + 1) == 0)) && ((out + 1) < out_length))
  924.     {
  925.         t9EventInput.mType = T9EVTSPELLING;
  926.         t9EventInput.data.sLDBData.psBuf = (U16*) inputString;
  927.         t9EventInput.data.sLDBData.mCtrlID = 0;
  928.         t9ReturnCodes = T9HandleEvent(&FieldInfo, &t9EventInput);
  930.         if (t9ReturnCodes == 0) /* (code >= 0x4e00) && (code <= 0x9fa5) */
  931.         {
  932.             i = 0;
  933.             while ((FieldInfo.uLangData.pAuxChinese->pbSpellBuf[i] != 0x00) && ((out + 1) < out_length))
  934.             {
  935.                 outputString[out++] = FieldInfo.uLangData.pAuxChinese->pbSpellBuf[i++];
  936.                 outputString[out++] = 0x00;
  937.             }
  938.         }
  940.         /* Add character encoding beetween pinyin strings */
  941.         if ((out + 1) < out_length)
  942.         {
  943.             outputString[out++] = inputString[0];
  944.             outputString[out++] = inputString[1];
  945.         }
  947.         inputString += 2;
  948.     }
  950.     return out;
  951. }
  952. #endif /* defined(__MMI_T9_V7__) */ 
  953. #elif defined(__MMI_ZI__)
  956. /*****************************************************************************
  957.  * FUNCTION
  958.  *  mmi_phb_util_convert_to_pinyin
  959.  * DESCRIPTION
  960.  *  
  961.  * PARAMETERS
  962.  *  inputString         [?]         
  963.  *  outputString        [?]         
  964.  *  out_length          [IN]        
  965.  * RETURNS
  966.  *  
  967.  *****************************************************************************/
  968. U16 mmi_phb_util_convert_to_pinyin(U8 *inputString, U8 *outputString, U16 out_length)
  969. {
  970.     /*----------------------------------------------------------------*/
  971.     /* Local Variables                                                */
  972.     /*----------------------------------------------------------------*/
  973.     U8 i, out = 0;
  974.     U16 code;
  975.     U16 pCharInfoBuffer[MMI_PHB_CONVERT_BUFF_ZI];
  976.     U16 PinYin_Base = ZI8_BASE_PINYIN - 0x0061;
  978.     /*----------------------------------------------------------------*/
  979.     /* Code Body                                                      */
  980.     /*----------------------------------------------------------------*/
  981.     while (!((*inputString == 0) && (*(inputString + 1) == 0)) && ((out + 1) < out_length))
  982.     {
  983.         memcpy(&code, inputString, 2);
  985.         if ((code >= 0x4e00) && (code <= 0x9fa5) &&
  986.             Zi8GetCharInfo(code, (U16*) pCharInfoBuffer, MMI_PHB_CONVERT_BUFF_ZI, ZI8_GETMODE_PINYIN))
  987.         {
  988.             i = 0;
  989.             while ((pCharInfoBuffer[i] != 0x0000) && (out < out_length) && ((pCharInfoBuffer[i] < 0xf431) || (pCharInfoBuffer[i] > 0xf435)))    /* No tone needed */
  990.             {
  991.                 outputString[out++] = (U8) (pCharInfoBuffer[i++] - PinYin_Base);
  992.                 outputString[out++] = 0x00;
  993.             }
  994.         }
  996.         /* Add character encoding beetween pinyin strings */
  997.         if ((out + 1) < out_length)
  998.         {
  999.             outputString[out++] = inputString[0];
  1000.             outputString[out++] = inputString[1];
  1001.         }
  1003.         inputString += 2;
  1004.     }
  1006.     return out;
  1007. }
  1009. //KP Jerry add on 2007-3-8 start
  1010. #elif defined(__MMI_CSTAR__)
  1011. U16 mmi_phb_util_convert_to_pinyin(U8* inputString, U8* outputString, U16 out_length)
  1012. {
  1013.     U16 out;
  1014.     int i;
  1015.     U16 code;
  1016.     U16 buf[16];
  1018.     out = 0;
  1020.     while ( !((inputString[0] == 0) && (inputString[1] == 0)) && (out + 1 < out_length) )
  1021.     {
  1022.         memcpy(&code, inputString, 2);
  1024.         if (CstarQueryCharInfo(code, buf, 16, INPUT_MODE_MMI_MULTITAP_PINYIN) > 0)
  1025.         {
  1026.             i = 0;
  1027.             while ( (buf[i] != 0) && (out < out_length) )
  1028.             {
  1029.                 outputString[out++] = (U8)(buf[i++]);
  1030.                 outputString[out++] = 0x00; 
  1031.             }
  1032.         }
  1034.         if (out + 1 < out_length)
  1035.         {
  1036.             outputString[out++] = inputString[0];
  1037.             outputString[out++] = inputString[1];
  1038.         }
  1039.             
  1040.         inputString += 2;
  1041.     }
  1043.     return out;
  1044. }
  1045. //KP Jerry add on 2007-3-8 end
  1047. #elif defined(__MMI_ITAP__)
  1048. /* under construction !*/
  1049. /* under construction !*/
  1050. /* under construction !*/
  1051. /* under construction !*/
  1052. /* under construction !*/
  1053. /* under construction !*/
  1054. /* under construction !*/
  1055. /* under construction !*/
  1056. /* under construction !*/
  1057. /* under construction !*/
  1058. /* under construction !*/
  1059. /* under construction !*/
  1060. /* under construction !*/
  1061. /* under construction !*/
  1062. /* under construction !*/
  1063. /* under construction !*/
  1064. /* under construction !*/
  1065. /* under construction !*/
  1066. /* under construction !*/
  1067. /* under construction !*/
  1068. /* under construction !*/
  1069. /* under construction !*/
  1070. /* under construction !*/
  1071. /* under construction !*/
  1072. /* under construction !*/
  1073. /* under construction !*/
  1074. /* under construction !*/
  1075. /* under construction !*/
  1076. /* under construction !*/
  1077. /* under construction !*/
  1078. /* under construction !*/
  1079. /* under construction !*/
  1080. /* under construction !*/
  1081. /* under construction !*/
  1082. /* under construction !*/
  1083. /* under construction !*/
  1084. /* under construction !*/
  1085. /* under construction !*/
  1086. /* under construction !*/
  1087. /* under construction !*/
  1088. /* under construction !*/
  1089. /* under construction !*/
  1090. /* under construction !*/
  1091. /* under construction !*/
  1092. /* under construction !*/
  1093. /* under construction !*/
  1094. /* under construction !*/
  1095. /* under construction !*/
  1096. /* under construction !*/
  1097. /* under construction !*/
  1098. /* under construction !*/
  1099. /* under construction !*/
  1100. /* under construction !*/
  1101. /* under construction !*/
  1102. /* under construction !*/
  1103. /* under construction !*/
  1104. /* under construction !*/
  1105. /* under construction !*/
  1106. /* under construction !*/
  1107. /* under construction !*/
  1108. /* under construction !*/
  1109. /* under construction !*/
  1110. /* under construction !*/
  1111. /* under construction !*/
  1112. /* under construction !*/
  1113. /* under construction !*/
  1114. /* under construction !*/
  1115. #else 
  1118. /*****************************************************************************
  1119.  * FUNCTION
  1120.  *  mmi_phb_util_convert_to_pinyin
  1121.  * DESCRIPTION
  1122.  *  
  1123.  * PARAMETERS
  1124.  *  inputString         [?]         
  1125.  *  outputString        [?]         
  1126.  *  out_length          [IN]        
  1127.  * RETURNS
  1128.  *  
  1129.  *****************************************************************************/
  1130. U16 mmi_phb_util_convert_to_pinyin(U8 *inputString, U8 *outputString, U16 out_length)
  1131. {
  1132.     /*----------------------------------------------------------------*/
  1133.     /* Local Variables                                                */
  1134.     /*----------------------------------------------------------------*/
  1136.     /*----------------------------------------------------------------*/
  1137.     /* Code Body                                                      */
  1138.     /*----------------------------------------------------------------*/
  1139.     pfnUnicodeStrncpy((S8*) outputString, (S8*) inputString, out_length);
  1140.     return out_length;
  1141. }
  1142. #endif 
  1143. #endif /* defined(__MMI_PHB_PINYIN_SORT__) */ 
  1145. #define MMI_PHB_LOOKUP_TABLE
  1148. /*****************************************************************************
  1149.  * FUNCTION
  1150.  *  mmi_phb_lookup_table_sort
  1151.  * DESCRIPTION
  1152.  *  Sorts the look-up table
  1153.  *  
  1154.  *  This is a fast Quick-Sort as suggested by
  1155.  *  Pluto. It will perform insertion sort for
  1156.  *  array chunks of size less than 4 and quick
  1157.  *  sort for size greater than 4.
  1158.  * PARAMETERS
  1159.  *  void
  1160.  * RETURNS
  1161.  *  void
  1162.  *****************************************************************************/
  1163. void mmi_phb_lookup_table_sort(void)
  1164. {
  1165.     /*----------------------------------------------------------------*/
  1166.     /* Local Variables                                                */
  1167.     /*----------------------------------------------------------------*/
  1169.     /*----------------------------------------------------------------*/
  1170.     /* Code Body                                                      */
  1171.     /*----------------------------------------------------------------*/
  1172.     if (g_phb_cntx.lookup_table_count)
  1173.     {
  1174.         /* Set to zero beore sorting, check if this flag larger than phonebook entries to see if finish sorting. */
  1175.         g_phb_cntx.populate_count = 0;
  1177.         /* Begin to sort. */
  1178.         mmi_phb_lookup_table_quicksort(0, (U16) (g_phb_cntx.lookup_table_count - 1));
  1179.         mmi_phb_lookup_table_insertionsort(0, (U16) (g_phb_cntx.lookup_table_count - 1));
  1181.         /* After sorting, set it to total phonebook entries. */
  1182.         g_phb_cntx.populate_count = 0xffff;
  1183.     }
  1184. }
  1187. /*****************************************************************************
  1188.  * FUNCTION
  1189.  *  mmi_phb_lookup_table_quicksort
  1190.  * DESCRIPTION
  1191.  *  Sorts the lookup table using quick sort algorithm
  1192.  * PARAMETERS
  1193.  *  l       [IN]        
  1194.  *  r       [IN]        
  1195.  * RETURNS
  1196.  *  void
  1197.  *****************************************************************************/
  1198. void mmi_phb_lookup_table_quicksort(U16 l, U16 r)
  1199. {
  1200.     /*----------------------------------------------------------------*/
  1201.     /* Local Variables                                                */
  1202.     /*----------------------------------------------------------------*/
  1203.     U16 i, j;
  1204.     U32 pivot;
  1206.     /*----------------------------------------------------------------*/
  1207.     /* Code Body                                                      */
  1208.     /*----------------------------------------------------------------*/
  1209.     if ((r - l) > 4)
  1210.     {
  1211.         i = (r + l) / 2;
  1212.         if (LookUpTable[l].number > LookUpTable[i].number)
  1213.         {
  1214.             mmi_phb_lookup_table_swap_node(l, i);
  1215.         }
  1216.         if (LookUpTable[l].number > LookUpTable[r].number)
  1217.         {
  1218.             mmi_phb_lookup_table_swap_node(l, r);
  1219.         }
  1220.         if (LookUpTable[i].number > LookUpTable[r].number)
  1221.         {
  1222.             mmi_phb_lookup_table_swap_node(i, r);
  1223.         }
  1225.         j = r - 1;
  1226.         mmi_phb_lookup_table_swap_node(i, j);
  1227.         i = l;
  1228.         pivot = LookUpTable[j].number;
  1230.         for (;;)
  1231.         {
  1232.             do
  1233.             {
  1234.             } while (LookUpTable[++i].number < pivot);
  1235.             do
  1236.             {
  1237.             } while (LookUpTable[--j].number > pivot);
  1239.             if (j < i)
  1240.             {
  1241.                 break;
  1242.             }
  1244.             mmi_phb_lookup_table_swap_node(i, j);
  1245.         }
  1247.         mmi_phb_lookup_table_swap_node(i, (U16) (r - 1));
  1248.         mmi_phb_lookup_table_quicksort(l, j);
  1249.         mmi_phb_lookup_table_quicksort((U16) (i + 1), r);
  1250.     }
  1251. }
  1254. /*****************************************************************************
  1255.  * FUNCTION
  1256.  *  mmi_phb_lookup_table_insertionsort
  1257.  * DESCRIPTION
  1258.  *  Sorts the lookup table using insertion sort algorithm
  1259.  * PARAMETERS
  1260.  *  lo      [IN]        
  1261.  *  hi      [IN]        
  1262.  * RETURNS
  1263.  *  void
  1264.  *****************************************************************************/
  1265. void mmi_phb_lookup_table_insertionsort(U16 lo, U16 hi)
  1266. {
  1267.     /*----------------------------------------------------------------*/
  1268.     /* Local Variables                                                */
  1269.     /*----------------------------------------------------------------*/
  1270.     U16 i, j;
  1271.     MMI_PHB_LOOKUP_NODE_STRUCT elem;
  1273.     /*----------------------------------------------------------------*/
  1274.     /* Code Body                                                      */
  1275.     /*----------------------------------------------------------------*/
  1276.     for (i = lo + 1; i <= hi; ++i)
  1277.     {
  1278.         memcpy(&elem, &LookUpTable[i], sizeof(MMI_PHB_LOOKUP_NODE_STRUCT));
  1280.         j = i;
  1281.         while (j > lo)
  1282.         {
  1283.             if (LookUpTable[j - 1].number <= elem.number)
  1284.             {
  1285.                 break;
  1286.             }
  1287.             memcpy(&LookUpTable[j], &LookUpTable[j - 1], sizeof(MMI_PHB_LOOKUP_NODE_STRUCT));
  1288.             j--;
  1289.         }
  1290.         memcpy(&LookUpTable[j], &elem, sizeof(MMI_PHB_LOOKUP_NODE_STRUCT));
  1291.     }
  1292. }
  1295. /*****************************************************************************
  1296.  * FUNCTION
  1297.  *  mmi_phb_lookup_table_swap_node
  1298.  * DESCRIPTION
  1299.  *  Swaps the look-up table nodes
  1300.  * PARAMETERS
  1301.  *  i       [IN]        
  1302.  *  j       [IN]        
  1303.  * RETURNS
  1304.  *  void
  1305.  *****************************************************************************/
  1306. void mmi_phb_lookup_table_swap_node(U16 i, U16 j)
  1307. {
  1308.     /*----------------------------------------------------------------*/
  1309.     /* Local Variables                                                */
  1310.     /*----------------------------------------------------------------*/
  1311.     MMI_PHB_LOOKUP_NODE_STRUCT temp;
  1313.     /*----------------------------------------------------------------*/
  1314.     /* Code Body                                                      */
  1315.     /*----------------------------------------------------------------*/
  1316.     memcpy(&temp, &LookUpTable[i], sizeof(MMI_PHB_LOOKUP_NODE_STRUCT));
  1317.     memcpy(&LookUpTable[i], &LookUpTable[j], sizeof(MMI_PHB_LOOKUP_NODE_STRUCT));
  1318.     memcpy(&LookUpTable[j], &temp, sizeof(MMI_PHB_LOOKUP_NODE_STRUCT));
  1319. }
  1321. /* Advance Search Phone Numbe. For Mobile Field Only!!! */
  1322. #if defined(__MMI_PHB_ADV_NUM_MATCH_MOBILE__)
  1325. /*****************************************************************************
  1326.  * FUNCTION
  1327.  *  mmi_phb_number_has_extension
  1328.  * DESCRIPTION
  1329.  *  Find out if a phone number has extension field.
  1330.  * PARAMETERS
  1331.  *  number      [?]     
  1332.  * RETURNS
  1333.  *  The position of the first extension character.
  1334.  *  Ex. *31#+81234567890p123 => 16
  1335.  *****************************************************************************/
  1336. U16 mmi_phb_number_has_extension(S8 *number)
  1337. {
  1338.     /*----------------------------------------------------------------*/
  1339.     /* Local Variables                                                */
  1340.     /*----------------------------------------------------------------*/
  1341.     U16 temp;
  1342.     U16 pos = 0;
  1344.     /*----------------------------------------------------------------*/
  1345.     /* Code Body                                                      */
  1346.     /*----------------------------------------------------------------*/
  1347.     /* Ignore *31# and #31# */
  1348.     while (((number[0] == '*') && (number[1] == '3') && (number[2] == '1') && (number[3] == '#')) ||
  1349.            ((number[0] == '#') && (number[1] == '3') && (number[2] == '1') && (number[3] == '#')))
  1350.     {
  1351.         number += 4;
  1352.         pos += 4;
  1353.     }
  1355.     /* Ignore '+' */
  1356.     if (number[0] == '+')
  1357.     {
  1358.         number++;
  1359.         pos++;
  1360.     }
  1362.     /* Find position of first extension character */
  1363.     temp = strcspn((PS8) number, "+pw*#");
  1364.     if (temp)
  1365.     {
  1366.         number = number + temp;
  1367.         pos = pos + temp;
  1368.     }
  1370.     /* Check if extension character exists. */
  1371.     if (number[0] == '+' || number[0] == 'p' || number[0] == 'w' || number[0] == '*' || number[0] == '#')
  1372.     {
  1373.         return pos;
  1374.     }
  1375.     else
  1376.     {
  1377.         return 0;
  1378.     }
  1380. }
  1383. /*****************************************************************************
  1384.  * FUNCTION
  1385.  *  mmi_phb_number_compare_extension
  1386.  * DESCRIPTION
  1387.  *  
  1388.  * PARAMETERS
  1389.  *  number1     [?]     
  1390.  *  number2     [?]     
  1391.  * RETURNS
  1392.  *  
  1393.  *****************************************************************************/
  1394. BOOL mmi_phb_number_compare_extension(S8 *number1, S8 *number2)
  1395. {
  1396.     /*----------------------------------------------------------------*/
  1397.     /* Local Variables                                                */
  1398.     /*----------------------------------------------------------------*/
  1399.     U8 temp;
  1401.     /*----------------------------------------------------------------*/
  1402.     /* Code Body                                                      */
  1403.     /*----------------------------------------------------------------*/
  1404.     /* Ignore *31# and #31# when compare. */
  1405.     while (((number1[0] == '*') && (number1[1] == '3') && (number1[2] == '1') && (number1[3] == '#')) ||
  1406.            ((number1[0] == '#') && (number1[1] == '3') && (number1[2] == '1') && (number1[3] == '#')))
  1407.     {
  1408.         number1 += 4;
  1409.     }
  1411.     while (((number2[0] == '*') && (number2[1] == '3') && (number2[2] == '1') && (number2[3] == '#')) ||
  1412.            ((number2[0] == '#') && (number2[1] == '3') && (number2[2] == '1') && (number2[3] == '#')))
  1413.     {
  1414.         number2 += 4;
  1415.     }
  1417.     /* Ignore '+' when compare. */
  1418.     if (number1[0] == '+')
  1419.     {
  1420.         number1++;
  1421.     }
  1422.     if (number2[0] == '+')
  1423.     {
  1424.         number2++;
  1425.     }
  1427.     /* Only Compare Extension part. */
  1428.     temp = strcspn((PS8) number1, "+pw*#");
  1429.     if (temp)
  1430.     {
  1431.         number1 = number1 + temp;
  1432.     }
  1434.     temp = strcspn((PS8) number2, "+pw*#");
  1435.     if (temp)
  1436.     {
  1437.         number2 = number2 + temp;
  1438.     }
  1440.     /* Compare if the number is full match. */
  1441.     if (!strcmp((PS8) number1, (PS8) number2))
  1442.     {
  1443.         return TRUE;
  1444.     }
  1445.     else
  1446.     {
  1447.         return FALSE;
  1448.     }
  1449. }
  1452. /*****************************************************************************
  1453.  * FUNCTION
  1454.  *  mmi_phb_number_compare_before_extension
  1455.  * DESCRIPTION
  1456.  *  Compare number before extension part
  1457.  *  If two numbers are less than 9 digts, do not need to
  1458.  *  do extra handling
  1459.  * PARAMETERS
  1460.  *  number1     [?]     
  1461.  *  number2     [?]     
  1462.  * RETURNS
  1463.  *  
  1464.  *****************************************************************************/
  1465. BOOL mmi_phb_number_compare_before_extension(S8 *number1, S8 *number2)
  1466. {
  1467.     /*----------------------------------------------------------------*/
  1468.     /* Local Variables                                                */
  1469.     /*----------------------------------------------------------------*/
  1470.     U16 i;
  1471.     U16 len1, len2;
  1472.     U16 ext_pos1, ext_pos2;
  1474.     /*----------------------------------------------------------------*/
  1475.     /* Code Body                                                      */
  1476.     /*----------------------------------------------------------------*/
  1478.     /* Ignore *31# and #31# */
  1479.     while (((number2[0] == '*') && (number2[1] == '3') && (number2[2] == '1') && (number2[3] == '#')) ||
  1480.             ((number2[0] == '#') && (number2[1] == '3') && (number2[2] == '1') && (number2[3] == '#')) )
  1481.     {
  1482.         number2 += 4;
  1483.     }
  1485.     /* compare length shorter than 9
  1486.       if(g_phb_compare_length <= 9)
  1487.        return TRUE;
  1488.       although already compared when enter this function, still need to confirm the number type
  1489.       and need to do more comparation */
  1490.     ext_pos1 = mmi_phb_number_has_extension(number1);
  1491.     ext_pos2 = mmi_phb_number_has_extension(number2);
  1493.     if ((ext_pos1 == 0 && ext_pos2 != 0 && (number2[ext_pos2] == '#' || number2[ext_pos2] == '*'))
  1494.         || (ext_pos2 == 0 && ext_pos1 != 0 && (number2[ext_pos1] == '#' || number2[ext_pos1] == '*')))
  1495.     {   /* only one with extension '#' or '*'. Not match! */
  1496.         return FALSE;
  1497.     }
  1498.     len1 = (ext_pos1 == 0) ? strlen(number1) : ext_pos1;
  1499.     len2 = (ext_pos2 == 0) ? strlen(number2) : ext_pos2;
  1501.     if ((len1 < g_phb_compare_length) || (len2 < g_phb_compare_length))
  1502.     {
  1503.         U16 num_len1 = (number1[0] == '+') ? (len1 - 1) : len1;
  1504.         U16 num_len2 = (number2[0] == '+') ? (len2 - 1) : len2;
  1506.         if (num_len1 != num_len2)
  1507.         {
  1508.             return FALSE;
  1509.         }
  1510.         else    /* the same length except "+" sign */
  1511.         {
  1512.             for (i = 1; i <= len1 && i <= len2; i++)
  1513.             {
  1514.                 if (number1[len1 - i] != number2[len2 - i])
  1515.                 {
  1516.                     return FALSE;
  1517.                 }
  1518.             }
  1519.         }
  1521.         return TRUE;
  1522.     }
  1524.     /* (len1 >= g_phb_compare_length) && (len2 >= g_phb_compare_length) */
  1525.     for (i = 1; i <= g_phb_compare_length; i++)
  1526.     {
  1527.         if (number1[len1 - i] != number2[len2 - i])
  1528.         {
  1529.             return FALSE;
  1530.         }
  1531.     }
  1532.     return TRUE;
  1533. }
  1536. /*****************************************************************************
  1537.  * FUNCTION
  1538.  *  mmi_phb_number_check_full_match_with_extension
  1539.  * DESCRIPTION
  1540.  *  
  1541.  * PARAMETERS
  1542.  *  lookup_index        [IN]        
  1543.  *  number_in           [?]         
  1544.  * RETURNS
  1545.  *  
  1546.  *****************************************************************************/
  1547. BOOL mmi_phb_number_check_full_match_with_extension(U16 lookup_index, S8 *number_in)
  1548. {
  1549.     /*----------------------------------------------------------------*/
  1550.     /* Local Variables                                                */
  1551.     /*----------------------------------------------------------------*/
  1552.     U8 number_buff[MAX_PB_NUMBER_LENGTH + 1 + 1];
  1553.     U16 store_index = LookUpTable[lookup_index].store_index;
  1555.     /*----------------------------------------------------------------*/
  1556.     /* Code Body                                                      */
  1557.     /*----------------------------------------------------------------*/
  1558.     /* Check if mobile field is match */
  1559.     if (PhoneBook[store_index].tel.type == MMI_CSMCC_INTERNATIONAL_ADDR)
  1560.     {
  1561.         number_buff[0] = '+';
  1562.         mmi_phb_convert_to_digit((U8*) (number_buff + 1), PhoneBook[store_index].tel.number, MAX_PB_NUMBER_LENGTH + 1);
  1563.     }
  1564.     else
  1565.     {
  1566.         mmi_phb_convert_to_digit(number_buff, PhoneBook[store_index].tel.number, MAX_PB_NUMBER_LENGTH + 1);
  1567.     }
  1569.     if (!mmi_phb_number_has_extension((S8*) number_buff) &&
  1570.         mmi_phb_number_compare_before_extension(number_in, (S8*) number_buff))
  1571.     {
  1572.         return TRUE;
  1573.     }
  1575. #ifdef __MMI_PHB_USIM_FIELD__
  1576.     /* Check number in the anr field */
  1577.     if (store_index >= MAX_PB_PHONE_ENTRIES)
  1578.     {
  1579.         if (PhoneBook[store_index].field & MMI_PHB_ENTRY_FIELD_ANRA)
  1580.         {
  1581.             if (phb_anr[store_index - MAX_PB_PHONE_ENTRIES][0].type == MMI_CSMCC_INTERNATIONAL_ADDR)
  1582.             {
  1583.                 number_buff[0] = '+';
  1584.                 mmi_phb_convert_to_digit(
  1585.                     (U8*) (number_buff + 1),
  1586.                     phb_anr[store_index - MAX_PB_PHONE_ENTRIES][0].number,
  1587.                     MAX_PB_NUMBER_LENGTH + 1);
  1588.             }
  1589.             else
  1590.             {
  1591.                 mmi_phb_convert_to_digit(
  1592.                     (U8*) number_buff,
  1593.                     phb_anr[store_index - MAX_PB_PHONE_ENTRIES][0].number,
  1594.                     MAX_PB_NUMBER_LENGTH + 1);
  1595.             }
  1597.             if (!mmi_phb_number_has_extension((S8*) number_buff) &&
  1598.                 mmi_phb_number_compare_before_extension(number_in, (S8*) number_buff))
  1599.             {
  1600.                 return TRUE;
  1601.             }
  1602.         }
  1603.         if (PhoneBook[store_index].field & MMI_PHB_ENTRY_FIELD_ANRB)
  1604.         {
  1605.             if (phb_anr[store_index - MAX_PB_PHONE_ENTRIES][1].type == MMI_CSMCC_INTERNATIONAL_ADDR)
  1606.             {
  1607.                 number_buff[0] = '+';
  1608.                 mmi_phb_convert_to_digit(
  1609.                     (U8*) (number_buff + 1),
  1610.                     phb_anr[store_index - MAX_PB_PHONE_ENTRIES][1].number,
  1611.                     MAX_PB_NUMBER_LENGTH + 1);
  1612.             }
  1613.             else
  1614.             {
  1615.                 mmi_phb_convert_to_digit(
  1616.                     (U8*) number_buff,
  1617.                     phb_anr[store_index - MAX_PB_PHONE_ENTRIES][1].number,
  1618.                     MAX_PB_NUMBER_LENGTH + 1);
  1619.             }
  1621.             if (!mmi_phb_number_has_extension((S8*) number_buff) &&
  1622.                 mmi_phb_number_compare_before_extension(number_in, (S8*) number_buff))
  1623.             {
  1624.                 return TRUE;
  1625.             }
  1626.         }
  1627.         if (PhoneBook[store_index].field & MMI_PHB_ENTRY_FIELD_ANRC)
  1628.         {
  1629.             if (phb_anr[store_index - MAX_PB_PHONE_ENTRIES][2].type == MMI_CSMCC_INTERNATIONAL_ADDR)
  1630.             {
  1631.                 number_buff[0] = '+';
  1632.                 mmi_phb_convert_to_digit(
  1633.                     (U8*) (number_buff + 1),
  1634.                     phb_anr[store_index - MAX_PB_PHONE_ENTRIES][2].number,
  1635.                     MAX_PB_NUMBER_LENGTH + 1);
  1636.             }
  1637.             else
  1638.             {
  1639.                 mmi_phb_convert_to_digit(
  1640.                     (U8*) number_buff,
  1641.                     phb_anr[store_index - MAX_PB_PHONE_ENTRIES][2].number,
  1642.                     MAX_PB_NUMBER_LENGTH + 1);
  1643.             }
  1645.             if (!mmi_phb_number_has_extension((S8*) number_buff) &&
  1646.                 mmi_phb_number_compare_before_extension(number_in, (S8*) number_buff))
  1647.             {
  1648.                 return TRUE;
  1649.             }
  1650.         }
  1651.     }
  1652. #endif /* __MMI_PHB_USIM_FIELD__ */ 
  1654. #if !defined(__MMI_PHB_NO_OPTIONAL_FIELD__)
  1655.     /* Check number in the optional field */
  1656.     if ((store_index < MAX_PB_PHONE_ENTRIES) &&
  1657.         ((PhoneBook[store_index].field & MMI_PHB_ENTRY_FIELD_HOME) ||
  1658.          (PhoneBook[store_index].field & MMI_PHB_ENTRY_FIELD_OFFICE) ||
  1659.          (PhoneBook[store_index].field & MMI_PHB_ENTRY_FIELD_FAX)))
  1660.     {
  1661.         S16 pError;
  1663.         ReadRecord(
  1664.             NVRAM_EF_PHB_FIELDS_LID,
  1665.             (U16) (store_index + 1),
  1666.             (void*)&PhoneBookOptionalFields,
  1667.             OPTIONAL_FIELDS_RECORD_SIZE,
  1668.             &pError);
  1670.         if (PhoneBook[store_index].field | MMI_PHB_ENTRY_FIELD_HOME)
  1671.         {
  1672.             if (!mmi_phb_number_has_extension((S8*) PhoneBookOptionalFields.homeNumber) &&
  1673.                 mmi_phb_number_compare_before_extension(number_in, (S8*) PhoneBookOptionalFields.homeNumber))
  1674.             {
  1675.                 g_phb_cntx.searched_number_type = MMI_PHB_ENTRY_FIELD_HOME;
  1676.                 return TRUE;
  1677.             }
  1678.         }
  1679.         if (PhoneBook[store_index].field | MMI_PHB_ENTRY_FIELD_OFFICE)
  1680.         {
  1681.             if (!mmi_phb_number_has_extension((S8*) PhoneBookOptionalFields.officeNumber) &&
  1682.                 mmi_phb_number_compare_before_extension(number_in, (S8*) PhoneBookOptionalFields.officeNumber))
  1683.             {
  1684.                 g_phb_cntx.searched_number_type = MMI_PHB_ENTRY_FIELD_OFFICE;
  1685.                 return TRUE;
  1686.             }
  1687.         }
  1688.         if (PhoneBook[store_index].field | MMI_PHB_ENTRY_FIELD_FAX)
  1689.         {
  1690.             if (!mmi_phb_number_has_extension((S8*) PhoneBookOptionalFields.faxNumber) &&
  1691.                 mmi_phb_number_compare_before_extension(number_in, (S8*) PhoneBookOptionalFields.faxNumber))
  1692.             {
  1693.                 g_phb_cntx.searched_number_type = MMI_PHB_ENTRY_FIELD_FAX;
  1694.                 return TRUE;
  1695.             }
  1696.         }
  1697.     }
  1698. #endif /* !defined(__MMI_PHB_NO_OPTIONAL_FIELD__) */ 
  1700.     return FALSE;
  1701. }
  1704. /*****************************************************************************
  1705.  * FUNCTION
  1706.  *  mmi_phb_number_find_first_without_extension
  1707.  * DESCRIPTION
  1708.  *  
  1709.  * PARAMETERS
  1710.  *  mid             [IN]        
  1711.  *  number          [IN]        
  1712.  *  number_in       [?]         
  1713.  * RETURNS
  1714.  *  
  1715.  *****************************************************************************/
  1716. S16 mmi_phb_number_find_first_without_extension(S16 mid, U32 number, S8 *number_in)
  1717. {
  1718.     /*----------------------------------------------------------------*/
  1719.     /* Local Variables                                                */
  1720.     /*----------------------------------------------------------------*/
  1721.     S16 i, new_mid, min_index;
  1722.     S16 counter = 0;
  1723.     U16 j;
  1724.     BOOL is_match = FALSE;
  1726.     /*----------------------------------------------------------------*/
  1727.     /* Code Body                                                      */
  1728.     /*----------------------------------------------------------------*/
  1729.     new_mid = mid;
  1730.     min_index = MAX_PB_ENTRIES;
  1732.     /* Compare number before mid */
  1733.     i = mid;
  1734.     while ((i >= 0) && (LookUpTable[i].number == number))
  1735.     {
  1736.         if (mmi_phb_number_check_full_match_with_extension(i, number_in))
  1737.         {
  1738.             for (j = 0; j < PhoneBookEntryCount; j++)
  1739.                 if (g_phb_name_index[j] == LookUpTable[i].store_index)
  1740.                 {
  1741.                     is_match = TRUE;
  1742.                     break;
  1743.                 }
  1745.             if (j < min_index)
  1746.             {
  1747.                 min_index = j;
  1748.                 new_mid = i;
  1749.             }
  1750.         }
  1751.         i--;
  1752.         counter++;
  1754.         if (counter >= MAX_PHB_NUMBER_COMP)
  1755.         {
  1756.             break;
  1757.         }
  1758.     }
  1760.     /* Compare number after mid */
  1761.     i = mid + 1;
  1762.     while ((i < g_phb_cntx.lookup_table_count) && (LookUpTable[i].number == number))
  1763.     {
  1764.         if (mmi_phb_number_check_full_match_with_extension(i, number_in))
  1765.         {
  1766.             for (j = 0; j < PhoneBookEntryCount; j++)
  1767.                 if (g_phb_name_index[j] == LookUpTable[i].store_index)
  1768.                 {
  1769.                     is_match = TRUE;
  1770.                     break;
  1771.                 }
  1773.             if (j < min_index)
  1774.             {
  1775.                 min_index = j;
  1776.                 new_mid = i;
  1777.             }
  1778.         }
  1779.         i++;
  1780.         counter++;
  1781.         if (counter >= MAX_PHB_NUMBER_COMP)
  1782.         {
  1783.             break;
  1784.         }
  1785.     }
  1787.     if (is_match)
  1788.     {
  1789.         return new_mid; /* Always return, even only number with extension exists. */
  1790.     }
  1791.     else
  1792.     {
  1793.         return -1;
  1794.     }
  1795.     /*
  1796.      * if(counter <= 1)  //Only one entry match.
  1797.      * return new_mid;
  1798.      * else if(min_index < MAX_PB_ENTRIES)
  1799.      * return new_mid;
  1800.      * else
  1801.      * return -1;
  1802.      */
  1803. }
  1806. /*****************************************************************************
  1807.  * FUNCTION
  1808.  *  mmi_phb_number_check_full_match_without_extension
  1809.  * DESCRIPTION
  1810.  *  
  1811.  * PARAMETERS
  1812.  *  lookup_index        [IN]        
  1813.  *  number_list         [?]         
  1814.  *  number_in           [?]         
  1815.  * RETURNS
  1816.  *  
  1817.  *****************************************************************************/
  1818. BOOL mmi_phb_number_check_full_match_without_extension(U16 lookup_index, S8 *number_list, S8 *number_in)
  1819. {
  1820.     /*----------------------------------------------------------------*/
  1821.     /* Local Variables                                                */
  1822.     /*----------------------------------------------------------------*/
  1823.     U16 store_index = LookUpTable[lookup_index].store_index;
  1825.     /*----------------------------------------------------------------*/
  1826.     /* Code Body                                                      */
  1827.     /*----------------------------------------------------------------*/
  1828.     /* Check if mobile field is match */
  1829.     if (PhoneBook[store_index].tel.type == MMI_CSMCC_INTERNATIONAL_ADDR)
  1830.     {
  1831.         number_list[0] = '+';
  1832.         mmi_phb_convert_to_digit((U8*) (number_list + 1), PhoneBook[store_index].tel.number, MAX_PB_NUMBER_LENGTH + 1);
  1833.     }
  1834.     else
  1835.     {
  1836.         mmi_phb_convert_to_digit((U8*) number_list, PhoneBook[store_index].tel.number, MAX_PB_NUMBER_LENGTH + 1);
  1837.     }
  1839.     if (mmi_phb_number_compare_before_extension(number_in, (S8*) number_list) &&
  1840.         mmi_phb_number_compare_extension(number_in, (S8*) number_list))
  1841.     {
  1842.         return TRUE;
  1843.     }
  1845. #ifdef __MMI_PHB_USIM_FIELD__
  1846.     /* Check number in the anr field */
  1847.     if (store_index >= MAX_PB_PHONE_ENTRIES)
  1848.     {
  1849.         if (PhoneBook[store_index].field & MMI_PHB_ENTRY_FIELD_ANRA)
  1850.         {
  1851.             if (phb_anr[store_index - MAX_PB_PHONE_ENTRIES][0].type == MMI_CSMCC_INTERNATIONAL_ADDR)
  1852.             {
  1853.                 number_list[0] = '+';
  1854.                 mmi_phb_convert_to_digit(
  1855.                     (U8*) (number_list + 1),
  1856.                     phb_anr[store_index - MAX_PB_PHONE_ENTRIES][0].number,
  1857.                     MAX_PB_NUMBER_LENGTH + 1);
  1858.             }
  1859.             else
  1860.             {
  1861.                 mmi_phb_convert_to_digit(
  1862.                     (U8*) number_list,
  1863.                     phb_anr[store_index - MAX_PB_PHONE_ENTRIES][0].number,
  1864.                     MAX_PB_NUMBER_LENGTH + 1);
  1865.             }
  1867.             if (mmi_phb_number_compare_before_extension(number_in, (S8*) number_list) &&
  1868.                 mmi_phb_number_compare_extension(number_in, (S8*) number_list))
  1869.             {
  1870.                 return TRUE;
  1871.             }
  1872.         }
  1873.         if (PhoneBook[store_index].field & MMI_PHB_ENTRY_FIELD_ANRB)
  1874.         {
  1875.             if (phb_anr[store_index - MAX_PB_PHONE_ENTRIES][1].type == MMI_CSMCC_INTERNATIONAL_ADDR)
  1876.             {
  1877.                 number_list[0] = '+';
  1878.                 mmi_phb_convert_to_digit(
  1879.                     (U8*) (number_list + 1),
  1880.                     phb_anr[store_index - MAX_PB_PHONE_ENTRIES][1].number,
  1881.                     MAX_PB_NUMBER_LENGTH + 1);
  1882.             }
  1883.             else
  1884.             {
  1885.                 mmi_phb_convert_to_digit(
  1886.                     (U8*) number_list,
  1887.                     phb_anr[store_index - MAX_PB_PHONE_ENTRIES][1].number,
  1888.                     MAX_PB_NUMBER_LENGTH + 1);
  1889.             }
  1891.             if (mmi_phb_number_compare_before_extension(number_in, (S8*) number_list) &&
  1892.                 mmi_phb_number_compare_extension(number_in, (S8*) number_list))
  1893.             {
  1894.                 return TRUE;
  1895.             }
  1896.         }
  1897.         if (PhoneBook[store_index].field & MMI_PHB_ENTRY_FIELD_ANRC)
  1898.         {
  1899.             if (phb_anr[store_index - MAX_PB_PHONE_ENTRIES][2].type == MMI_CSMCC_INTERNATIONAL_ADDR)
  1900.             {
  1901.                 number_list[0] = '+';
  1902.                 mmi_phb_convert_to_digit(
  1903.                     (U8*) (number_list + 1),
  1904.                     phb_anr[store_index - MAX_PB_PHONE_ENTRIES][2].number,
  1905.                     MAX_PB_NUMBER_LENGTH + 1);
  1906.             }
  1907.             else
  1908.             {
  1909.                 mmi_phb_convert_to_digit(
  1910.                     (U8*) number_list,
  1911.                     phb_anr[store_index - MAX_PB_PHONE_ENTRIES][2].number,
  1912.                     MAX_PB_NUMBER_LENGTH + 1);
  1913.             }
  1915.             if (mmi_phb_number_compare_before_extension(number_in, (S8*) number_list) &&
  1916.                 mmi_phb_number_compare_extension(number_in, (S8*) number_list))
  1917.             {
  1918.                 return TRUE;
  1919.             }
  1920.         }
  1921.     }
  1922. #endif /* __MMI_PHB_USIM_FIELD__ */ 
  1924. #if !defined(__MMI_PHB_NO_OPTIONAL_FIELD__)
  1925.     /* Check number in the optional field */
  1926.     if ((store_index < MAX_PB_PHONE_ENTRIES) &&
  1927.         ((PhoneBook[store_index].field & MMI_PHB_ENTRY_FIELD_HOME) ||
  1928.          (PhoneBook[store_index].field & MMI_PHB_ENTRY_FIELD_OFFICE) ||
  1929.          (PhoneBook[store_index].field & MMI_PHB_ENTRY_FIELD_FAX)))
  1930.     {
  1931.         S16 pError;
  1933.         ReadRecord(
  1934.             NVRAM_EF_PHB_FIELDS_LID,
  1935.             (U16) (store_index + 1),
  1936.             (void*)&PhoneBookOptionalFields,
  1937.             OPTIONAL_FIELDS_RECORD_SIZE,
  1938.             &pError);
  1940.         if (PhoneBook[store_index].field | MMI_PHB_ENTRY_FIELD_HOME)
  1941.         {
  1942.             if (mmi_phb_number_compare_before_extension(number_in, (S8*) PhoneBookOptionalFields.homeNumber) &&
  1943.                 mmi_phb_number_compare_extension(number_in, (S8*) PhoneBookOptionalFields.homeNumber))
  1944.             {
  1945.                 g_phb_cntx.searched_number_type = MMI_PHB_ENTRY_FIELD_HOME;
  1946.                 return TRUE;
  1947.             }
  1948.         }
  1949.         if (PhoneBook[store_index].field | MMI_PHB_ENTRY_FIELD_OFFICE)
  1950.         {
  1951.             if (mmi_phb_number_compare_before_extension(number_in, (S8*) PhoneBookOptionalFields.officeNumber) &&
  1952.                 mmi_phb_number_compare_extension(number_in, (S8*) PhoneBookOptionalFields.officeNumber))
  1953.             {
  1954.                 g_phb_cntx.searched_number_type = MMI_PHB_ENTRY_FIELD_OFFICE;
  1955.                 return TRUE;
  1956.             }
  1957.         }
  1958.         if (PhoneBook[store_index].field | MMI_PHB_ENTRY_FIELD_FAX)
  1959.         {
  1960.             if (mmi_phb_number_compare_before_extension(number_in, (S8*) PhoneBookOptionalFields.faxNumber) &&
  1961.                 mmi_phb_number_compare_extension(number_in, (S8*) PhoneBookOptionalFields.faxNumber))
  1962.             {
  1963.                 g_phb_cntx.searched_number_type = MMI_PHB_ENTRY_FIELD_FAX;
  1964.                 return TRUE;
  1965.             }
  1966.         }
  1967.     }
  1968. #endif /* !defined(__MMI_PHB_NO_OPTIONAL_FIELD__) */ 
  1970.     return FALSE;
  1971. }
  1974. /*****************************************************************************
  1975.  * FUNCTION
  1976.  *  mmi_phb_number_find_first_with_extension
  1977.  * DESCRIPTION
  1978.  *  
  1979.  * PARAMETERS
  1980.  *  mid             [IN]        
  1981.  *  number          [IN]        
  1982.  *  number_in       [?]         
  1983.  * RETURNS
  1984.  *  
  1985.  *****************************************************************************/
  1986. S16 mmi_phb_number_find_first_with_extension(S16 mid, U32 number, S8 *number_in)
  1987. {
  1988.     /*----------------------------------------------------------------*/
  1989.     /* Local Variables                                                */
  1990.     /*----------------------------------------------------------------*/
  1991.     S16 i, new_mid, min_index, counter;
  1992.     U8 number_list[MAX_PB_NUMBER_LENGTH + 1 + 1];
  1993.     U16 j;
  1995.     /*----------------------------------------------------------------*/
  1996.     /* Code Body                                                      */
  1997.     /*----------------------------------------------------------------*/
  1998.     new_mid = mid;
  1999.     min_index = MAX_PB_ENTRIES;
  2000.     counter = 0;
  2002.     /* Compare number before mid */
  2003.     i = mid;
  2004.     while ((i >= 0) && (LookUpTable[i].number == number))
  2005.     {
  2006.         if (mmi_phb_number_check_full_match_without_extension(i, (S8*) number_list, number_in))
  2007.         {
  2008.             for (j = 0; j < PhoneBookEntryCount; j++)
  2009.                 if (g_phb_name_index[j] == LookUpTable[i].store_index)
  2010.                 {
  2011.                     break;
  2012.                 }
  2014.             if (j < min_index)
  2015.             {
  2016.                 min_index = j;
  2017.                 new_mid = i;
  2018.             }
  2019.         }
  2020.         i--;
  2021.         counter++;
  2022.         if (counter >= MAX_PHB_NUMBER_COMP)
  2023.         {
  2024.             break;
  2025.         }
  2026.     }
  2028.     /* Compare number after mid */
  2029.     i = mid + 1;
  2030.     while ((i < g_phb_cntx.lookup_table_count) && (LookUpTable[i].number == number))
  2031.     {
  2032.         if (mmi_phb_number_check_full_match_without_extension(i, (S8*) number_list, number_in))
  2033.         {
  2034.             for (j = 0; j < PhoneBookEntryCount; j++)
  2035.                 if (g_phb_name_index[j] == LookUpTable[i].store_index)
  2036.                 {
  2037.                     break;
  2038.                 }
  2040.             if (j < min_index)
  2041.             {
  2042.                 min_index = j;
  2043.                 new_mid = i;
  2044.             }
  2045.         }
  2046.         i++;
  2047.         counter++;
  2048.         if (counter >= MAX_PHB_NUMBER_COMP)
  2049.         {
  2050.             break;
  2051.         }
  2052.     }
  2054.     if (min_index == MAX_PB_ENTRIES)
  2055.     {
  2056.         U16 ext1 = 0;
  2058.         mmi_phb_convert_to_digit(
  2059.             number_list,
  2060.             PhoneBook[LookUpTable[new_mid].store_index].tel.number,
  2061.             MAX_PB_NUMBER_LENGTH + 1);
  2063.         if ((counter <= 1) && !mmi_phb_number_has_extension((S8*) number_list) &&
  2064.             ((ext1 = mmi_phb_number_has_extension(number_in)) > 0) &&
  2065.             (number_in[ext1] != '#') && (number_in[ext1] != '*'))
  2066.         {
  2067.             return mid;
  2068.         }
  2069.         else
  2070.         {
  2071.             return -1;
  2072.         }
  2073.     }
  2074.     else
  2075.     {
  2076.         return new_mid;
  2077.     }
  2078. }
  2079. #endif /* defined(__MMI_PHB_ADV_NUM_MATCH_MOBILE__) */ 
  2082. /*****************************************************************************
  2083.  * FUNCTION
  2084.  *  mmi_phb_lookup_table_search
  2085.  * DESCRIPTION
  2086.  *  Search for the number in the lookup table
  2087.  *  and returns the index of the matched entry.
  2088.  *  
  2089.  *  Its a non-recursive binary search
  2090.  * PARAMETERS
  2091.  *  number              [IN]        
  2092.  *  low                 [IN]        
  2093.  *  high                [IN]        
  2094.  *  number_ASCII        [IN]         
  2095.  *  storage             [IN]
  2096.  * RETURNS
  2097.  *  void
  2098.  *****************************************************************************/
  2099. U16 mmi_phb_lookup_table_search(U32 number, S16 low, S16 high, S8 *number_ASCII, U8 storage)
  2100. {
  2101.     /*----------------------------------------------------------------*/
  2102.     /* Local Variables                                                */
  2103.     /*----------------------------------------------------------------*/
  2104.     S16 mid;
  2106.     /*----------------------------------------------------------------*/
  2107.     /* Code Body                                                      */
  2108.     /*----------------------------------------------------------------*/
  2109.     while (low <= high)
  2110.     {
  2111.         mid = (low + high) / 2;
  2112.         if (number == LookUpTable[mid].number)
  2113.         {
  2114.             /*
  2115.              * Advanced Compare - Compare number longer than 9 digit,
  2116.              * with extension, find out the prior one if numbers are the same, and etc.
  2117.              */
  2118.         #if defined(__MMI_PHB_ADV_NUM_MATCH_MOBILE__)
  2119.             if (!mmi_phb_number_has_extension(number_ASCII))
  2120.             {
  2121.                 mid = mmi_phb_number_find_first_without_extension(mid, number, number_ASCII);
  2122.             }
  2123.             else
  2124.             {
  2125.                 mid = mmi_phb_number_find_first_with_extension(mid, number, number_ASCII);
  2126.             }
  2128.             if (mid < 0)
  2129.             {
  2130.                 return 0xffff;  /* an invalid number */
  2131.             }
  2132.             else
  2133.         #endif /* defined(__MMI_PHB_ADV_NUM_MATCH_MOBILE__) */ 
  2134.             {
  2135.                 if (storage == MMI_STORAGE_BOTH || 
  2136.                     (storage == MMI_SIM && LookUpTable[mid].store_index >= MAX_PB_PHONE_ENTRIES) || 
  2137.                     (storage == MMI_NVRAM && LookUpTable[mid].store_index < MAX_PB_PHONE_ENTRIES))
  2138.                 {
  2139.                     return LookUpTable[mid].store_index;    /* return storage location in array, begin from 0 */
  2140.                 }
  2141.                 mid++;
  2142.                 while ((mid < (g_phb_cntx.lookup_table_count - 1)) && number == LookUpTable[mid].number)
  2143.                 {
  2144.                     if (storage == MMI_STORAGE_BOTH || 
  2145.                         (storage == MMI_SIM && LookUpTable[mid].store_index >= MAX_PB_PHONE_ENTRIES) || 
  2146.                         (storage == MMI_NVRAM && LookUpTable[mid].store_index < MAX_PB_PHONE_ENTRIES))
  2147.                     {
  2148.                         return LookUpTable[mid].store_index;    /* return storage location in array, begin from 0 */
  2149.                     }
  2150.                     mid++;
  2151.                 }
  2152.             }
  2153.         }
  2154.         else if (number < LookUpTable[mid].number)
  2155.         {
  2156.             high = mid - 1;
  2157.         }
  2158.         else
  2159.         {
  2160.             low = mid + 1;
  2161.         }
  2162.     }
  2163.     return 0xffff;
  2164. }
  2167. /*****************************************************************************
  2168.  * FUNCTION
  2169.  *  mmi_phb_util_read_compare_length
  2170.  * DESCRIPTION
  2171.  *  Read the compare length from NVRAM
  2172.  * PARAMETERS
  2173.  *  void
  2174.  * RETURNS
  2175.  *  void
  2176.  *****************************************************************************/
  2177. void mmi_phb_util_read_compare_length(void)
  2178. {
  2179.     /*----------------------------------------------------------------*/
  2180.     /* Local Variables                                                */
  2181.     /*----------------------------------------------------------------*/
  2182.     S16 pError;
  2183.     U8 comp_len;
  2185.     /*----------------------------------------------------------------*/
  2186.     /* Code Body                                                      */
  2187.     /*----------------------------------------------------------------*/
  2188.     /* Already read value */
  2189.     if (g_phb_compare_length != 0xff)
  2190.     {
  2191.         return;
  2192.     }
  2194.     ReadRecord(NVRAM_EF_PHB_COMPARE_DIGIT_LID, 1, (void*)&comp_len, 1, &pError);
  2196.     if (comp_len < 6)
  2197.     {
  2198.         g_phb_compare_length = 6;
  2199.     }
  2200.     else if (comp_len > 20)
  2201.     {
  2202.         g_phb_compare_length = 20;
  2203.     }
  2205.     else
  2206.     {
  2207.         g_phb_compare_length = comp_len;
  2208.     }
  2209. }
  2212. /*****************************************************************************
  2213.  * FUNCTION
  2214.  *  mmi_phb_util_convert_number_to_int
  2215.  * DESCRIPTION
  2216.  *  Converts the last n characters of a phone number to digits
  2217.  * PARAMETERS
  2218.  *  ascii_number        [IN]        Input ascii number
  2219.  * RETURNS
  2220.  *  interger of input number
  2221.  *****************************************************************************/
  2222. U32 mmi_phb_util_convert_number_to_int(U8 *ascii_number)
  2223. {
  2224.     /*----------------------------------------------------------------*/
  2225.     /* Local Variables                                                */
  2226.     /*----------------------------------------------------------------*/
  2227.     U16 num_len;
  2228.     U16 ext_len;
  2229.     U16 buff_len = MAX_PB_NUMBER_LENGTH + 1;
  2230.     U8 *number;
  2231.     U8 temp_number[MAX_PB_NUMBER_LENGTH + 1 + 1];
  2232.     U8 compare_length = 9;  /* Maximum convert number length is 9 digits. (4 bytes integer) */
  2234.     /*----------------------------------------------------------------*/
  2235.     /* Code Body                                                      */
  2236.     /*----------------------------------------------------------------*/
  2237.     PRINT_INFORMATION(("---[PhonebookSearch.c] mmi_phb_util_convert_number_to_int() => number: [%s] n", ascii_number));
  2239.     if (ascii_number != NULL)
  2240.     {
  2241.         strncpy((S8*) temp_number, (S8*) ascii_number, buff_len);
  2242.         memset((temp_number + buff_len), 0x00, 1);  /* Makre sure there will be terminator */
  2243.     }
  2244.     else
  2245.     {
  2246.         return INVALID_NUMBER;
  2247.     }
  2249.     number = (U8*) temp_number;
  2251.     /* Ignore  *31# and #31# case */
  2252.     while (((number[0] == '*') && (number[1] == '3') && (number[2] == '1') && (number[3] == '#')) ||
  2253.            ((number[0] == '#') && (number[1] == '3') && (number[2] == '1') && (number[3] == '#')))
  2254.     {
  2255.         number += 4;
  2256.     }
  2258.     /* Skip the first plus sign */
  2259.     if (number[0] == '+')
  2260.     {
  2261.         number++;
  2262.     }
  2264.     /* number empty */
  2265.     if (number[0] == '')
  2266.     {
  2267.         return INVALID_NUMBER;
  2268.     }
  2270.     /* Find the position of extension number and remove that part */
  2271.     ext_len = strcspn((PS8) number, "+pw*#");
  2272.     if (!ext_len)
  2273.     {
  2274.         return INVALID_NUMBER;
  2275.     }
  2276.     else
  2277.     {
  2278.         MMI_ASSERT(ext_len <= buff_len);
  2280.         number[ext_len] = '';
  2282.         /* Read compare length from NVRAM */
  2283.         mmi_phb_util_read_compare_length();
  2285.         num_len = strlen((PS8) number);
  2287.         /* May compare less number than 9 digits */
  2288.         if (g_phb_compare_length < 9)
  2289.         {
  2290.             compare_length = g_phb_compare_length;
  2291.         }
  2293.         /* Convert at most 9 digits integer */
  2294.         if (num_len > compare_length)
  2295.         {
  2296.             number += num_len - compare_length;
  2297.         }
  2299.         /* return a 32 bits integer by atol() */
  2300.         return atol((PS8) number);
  2301.     }
  2302. }
  2304. /*-----------------------------------------------END  General Compare String Functions -------------------------------------------------*/
  2307. #define MMI_PHB_SEARCH_EMAIL
  2308. #if defined(__MMI_PHB_EMAIL_SORT__)
  2309. /*****************************************************************************
  2310.  * FUNCTION
  2311.  *  mmi_phb_sort_email_insert_index
  2312.  * DESCRIPTION
  2313.  *  This function inserts email to mapping table by its index.
  2314.  * PARAMETERS
  2315.  *  store_index     [IN]        
  2316.  * RETURNS
  2317.  *  void
  2318.  *****************************************************************************/
  2319. void mmi_phb_sort_email_insert_index(U16 store_index)
  2320. {
  2321.     /*----------------------------------------------------------------*/
  2322.     /* Local Variables                                                */
  2323.     /*----------------------------------------------------------------*/
  2324.     U16 pos;
  2325.     U16 i;
  2326.     S16 pError;
  2328. #ifdef __MMI_PHB_USIM_FIELD__
  2329.     U16 g_phb_email_index[MAX_PB_ENTRIES];
  2330. #else 
  2331.     U16 g_phb_email_index[MAX_PB_PHONE_ENTRIES];
  2332. #endif 
  2334.     /*----------------------------------------------------------------*/
  2335.     /* Code Body                                                      */
  2336.     /*----------------------------------------------------------------*/
  2337. #ifdef __MMI_PHB_USIM_FIELD__
  2338.     ReadRecord(NVRAM_EF_PHB_EMAIL_SORT_LID, 1, (void*)g_phb_email_index, MAX_PB_ENTRIES * sizeof(U16), &pError);
  2340.     if (PhoneBookEntryCount == 1)
  2341.     {
  2342.         g_phb_email_index[(PhoneBookEntryCount - 1)] = store_index;
  2343.     }
  2344.     else
  2345.     {
  2346.         pos = mmi_phb_sort_email_find_insert_pos(0, (PhoneBookEntryCount - 2), store_index, g_phb_email_index);
  2348.         for (i = (PhoneBookEntryCount - 1); i > pos; i--)
  2349.         {
  2350.             g_phb_email_index[i] = g_phb_email_index[i - 1];
  2351.         }
  2352.         g_phb_email_index[pos] = store_index;
  2354.     }
  2356.     WriteRecord(NVRAM_EF_PHB_EMAIL_SORT_LID, 1, (void*)g_phb_email_index, MAX_PB_ENTRIES * sizeof(U16), &pError);
  2357. #else /* __MMI_PHB_USIM_FIELD__ */ 
  2358.     ReadRecord(NVRAM_EF_PHB_EMAIL_SORT_LID, 1, (void*)g_phb_email_index, MAX_PB_PHONE_ENTRIES * sizeof(U16), &pError);
  2360.     if (g_phb_cntx.phone_used == 1)
  2361.     {
  2362.         g_phb_email_index[(g_phb_cntx.phone_used - 1)] = store_index;
  2363.     }
  2364.     else
  2365.     {
  2366.         pos = mmi_phb_sort_email_find_insert_pos(0, (g_phb_cntx.phone_used - 2), store_index, g_phb_email_index);
  2368.         for (i = (g_phb_cntx.phone_used - 1); i > pos; i--)
  2369.         {
  2370.             g_phb_email_index[i] = g_phb_email_index[i - 1];
  2371.         }
  2372.         g_phb_email_index[pos] = store_index;
  2374.     }
  2376.     WriteRecord(NVRAM_EF_PHB_EMAIL_SORT_LID, 1, (void*)g_phb_email_index, MAX_PB_PHONE_ENTRIES * sizeof(U16), &pError);
  2377. #endif /* __MMI_PHB_USIM_FIELD__ */ 
  2378. }
  2381. /*****************************************************************************
  2382.  * FUNCTION
  2383.  *  mmi_phb_sort_email_find_insert_pos
  2384.  * DESCRIPTION
  2385.  *  This function find the insert position for a new adding email.
  2386.  * PARAMETERS
  2387.  *  low                 [IN]        
  2388.  *  high                [IN]        
  2389.  *  store_index         [IN]        
  2390.  *  mapping_table       [?]         
  2391.  * RETURNS
  2392.  *  void
  2393.  *****************************************************************************/
  2394. U16 mmi_phb_sort_email_find_insert_pos(S32 low, S32 high, U16 store_index, U16 *mapping_table)
  2395. {
  2396.     /*----------------------------------------------------------------*/
  2397.     /* Local Variables                                                */
  2398.     /*----------------------------------------------------------------*/
  2399.     S32 mid;
  2400.     S16 flag;
  2401.     U8 same_count;
  2402.     S32 distance;
  2404.     /*----------------------------------------------------------------*/
  2405.     /* Code Body                                                      */
  2406.     /*----------------------------------------------------------------*/
  2407.     while (low <= high)
  2408.     {
  2409.         mid = (low + high) / 2;
  2411.         mmi_phb_sort_email_compare_by_encoding(store_index, mapping_table[mid], &same_count, &distance);
  2413.         if (distance > 0)
  2414.         {
  2415.             low = mid + 1;
  2416.             flag = -1;
  2417.         }
  2418.         else    /* Either > 0 or < 0, not possible ==0 */
  2419.         {
  2420.             high = mid - 1;
  2421.             flag = 1;
  2422.         }
  2423.     }
  2425.     if (flag == -1)
  2426.     {
  2427.         return (U16) (mid + 1);
  2428.     }
  2429.     else
  2430.     {
  2431.         return (U16) mid;
  2432.     }
  2433. }
  2436. /*****************************************************************************
  2437.  * FUNCTION
  2438.  *  mmi_phb_sort_email_compare_by_encoding
  2439.  * DESCRIPTION
  2440.  *  This function compare email precedence by encoding.
  2441.  *  If no email presents, use name instead.
  2442.  * PARAMETERS
  2443.  *  first           [IN]        
  2444.  *  second          [IN]        
  2445.  *  same_count      [?]         
  2446.  *  distance        [?]         
  2447.  * RETURNS
  2448.  *  void
  2449.  *****************************************************************************/
  2450. void mmi_phb_sort_email_compare_by_encoding(U16 first, U16 second, U8 *same_count, S32 *distance)
  2451. {
  2452.     /*----------------------------------------------------------------*/
  2453.     /* Local Variables                                                */
  2454.     /*----------------------------------------------------------------*/
  2455.     S8 *string1, *string2;
  2456.     S8 email1[(MAX_PB_EMAIL_LENGTH + 1) * ENCODING_LENGTH];
  2457.     S8 email2[(MAX_PB_EMAIL_LENGTH + 1) * ENCODING_LENGTH];
  2458.     S16 pError;
  2460.     /*----------------------------------------------------------------*/
  2461.     /* Code Body                                                      */
  2462.     /*----------------------------------------------------------------*/
  2463.     /*
  2464.      * Prepare data for compare string 1
  2465.      */
  2466.     if (PhoneBook[first].field & MMI_PHB_ENTRY_FIELD_EMAIL)
  2467.     {
  2468.     #ifdef __MMI_PHB_USIM_FIELD__
  2469.         if (first >= MAX_PB_PHONE_ENTRIES)
  2470.         {
  2471.             AnsiiToUnicodeString((S8*) pbEmailAddress, (S8*) phb_email[first - MAX_PB_PHONE_ENTRIES].email_address);
  2472.         }
  2473.         else
  2474.     #endif /* __MMI_PHB_USIM_FIELD__ */ 
  2475.         {
  2476.             ReadRecord(
  2477.                 NVRAM_EF_PHB_FIELDS_LID,
  2478.                 (U16) (first + 1),
  2479.                 (void*)&PhoneBookOptionalFields,
  2480.                 OPTIONAL_FIELDS_RECORD_SIZE,
  2481.                 &pError);
  2482.             AnsiiToUnicodeString(email1, (S8*) PhoneBookOptionalFields.emailAddress);
  2483.         }
  2484.         string1 = email1;
  2485.     }
  2486.     else
  2487.     {
  2488.         string1 = (S8*) PhoneBook[first].alpha_id.name;
  2489.     }
  2491.     /*
  2492.      * Prepare data for compare string 2
  2493.      */
  2494.     if (PhoneBook[second].field & MMI_PHB_ENTRY_FIELD_EMAIL)
  2495.     {
  2496.     #ifdef __MMI_PHB_USIM_FIELD__
  2497.         if (second >= MAX_PB_PHONE_ENTRIES)
  2498.         {
  2499.             AnsiiToUnicodeString((S8*) pbEmailAddress, (S8*) phb_email[second - MAX_PB_PHONE_ENTRIES].email_address);
  2500.         }
  2501.         else
  2502.     #endif /* __MMI_PHB_USIM_FIELD__ */ 
  2503.         {
  2504.             ReadRecord(
  2505.                 NVRAM_EF_PHB_FIELDS_LID,
  2506.                 (U16) (second + 1),
  2507.                 (void*)&PhoneBookOptionalFields,
  2508.                 OPTIONAL_FIELDS_RECORD_SIZE,
  2509.                 &pError);
  2510.             AnsiiToUnicodeString(email2, (S8*) PhoneBookOptionalFields.emailAddress);
  2511.         }
  2512.         string2 = email2;
  2513.     }
  2514.     else
  2515.     {
  2516.         string2 = (S8*) PhoneBook[second].alpha_id.name;
  2517.     }
  2519.     /*
  2520.      * compare strings
  2521.      */
  2522.     mmi_phb_compare_ucs2_strings(string1, string2, same_count, distance);
  2524.     /*
  2525.      * If two strings are the same, put smaller store index in front.
  2526.      */
  2527.     if (*distance == 0)
  2528.     {
  2529.         if (first < second)
  2530.         {
  2531.             *distance = -1;
  2532.         }
  2533.         else if (first > second)
  2534.         {
  2535.             *distance = 1;
  2536.         }
  2537.     }
  2538. }
  2541. /*****************************************************************************
  2542.  * FUNCTION
  2543.  *  mmi_phb_sort_email_delete_index
  2544.  * DESCRIPTION
  2545.  *  This function
  2546.  * PARAMETERS
  2547.  *  store_index     [IN]        
  2548.  * RETURNS
  2549.  *  void
  2550.  *****************************************************************************/
  2551. void mmi_phb_sort_email_delete_index(U16 store_index)
  2552. {
  2553.     /*----------------------------------------------------------------*/
  2554.     /* Local Variables                                                */
  2555.     /*----------------------------------------------------------------*/
  2556.     U16 pos, i;
  2557.     S16 pError;
  2559. #ifdef __MMI_PHB_USIM_FIELD__
  2560.     U16 g_phb_email_index[MAX_PB_ENTRIES];
  2561. #else 
  2562.     U16 g_phb_email_index[MAX_PB_PHONE_ENTRIES];
  2563. #endif 
  2565.     /*----------------------------------------------------------------*/
  2566.     /* Code Body                                                      */
  2567.     /*----------------------------------------------------------------*/
  2568. #ifdef __MMI_PHB_USIM_FIELD__
  2569.     ReadRecord(NVRAM_EF_PHB_EMAIL_SORT_LID, 1, (void*)g_phb_email_index, MAX_PB_ENTRIES * sizeof(U16), &pError);
  2570.     for (pos = 0; pos < (PhoneBookEntryCount + 1); pos++)
  2571.         if (g_phb_email_index[pos] == store_index)
  2572.         {
  2573.             break;
  2574.         }
  2575.     for (i = pos; i < (PhoneBookEntryCount + 1); i++)
  2576.     {
  2577.         g_phb_email_index[i] = g_phb_email_index[i + 1];
  2578.     }
  2579.     WriteRecord(NVRAM_EF_PHB_EMAIL_SORT_LID, 1, (void*)g_phb_email_index, MAX_PB_ENTRIES * sizeof(U16), &pError);
  2580. #else /* __MMI_PHB_USIM_FIELD__ */ 
  2581.     ReadRecord(NVRAM_EF_PHB_EMAIL_SORT_LID, 1, (void*)g_phb_email_index, MAX_PB_PHONE_ENTRIES * sizeof(U16), &pError);
  2582.     for (pos = 0; pos < (g_phb_cntx.phone_used + 1); pos++)
  2583.         if (g_phb_email_index[pos] == store_index)
  2584.         {
  2585.             break;
  2586.         }
  2587.     for (i = pos; i < (g_phb_cntx.phone_used + 1); i++)
  2588.     {
  2589.         g_phb_email_index[i] = g_phb_email_index[i + 1];
  2590.     }
  2591.     WriteRecord(NVRAM_EF_PHB_EMAIL_SORT_LID, 1, (void*)g_phb_email_index, MAX_PB_PHONE_ENTRIES * sizeof(U16), &pError);
  2592. #endif /* __MMI_PHB_USIM_FIELD__ */ 
  2593. }
  2596. /*****************************************************************************
  2597.  * FUNCTION
  2598.  *  mmi_phb_sort_email_delete_all_index
  2599.  * DESCRIPTION
  2600.  *  This function
  2601.  * PARAMETERS
  2602.  *  void
  2603.  * RETURNS
  2604.  *  void
  2605.  *****************************************************************************/
  2606. void mmi_phb_sort_email_delete_all_index(void)
  2607. {
  2608.     /*----------------------------------------------------------------*/
  2609.     /* Local Variables                                                */
  2610.     /*----------------------------------------------------------------*/
  2611.     S16 pError;
  2613. #ifdef __MMI_PHB_USIM_FIELD__
  2614.     U16 g_phb_email_index[MAX_PB_ENTRIES];
  2615. #else 
  2616.     U16 g_phb_email_index[MAX_PB_PHONE_ENTRIES];
  2617. #endif 
  2619.     /*----------------------------------------------------------------*/
  2620.     /* Code Body                                                      */
  2621.     /*----------------------------------------------------------------*/
  2622. #ifdef __MMI_PHB_USIM_FIELD__
  2623.     memset(g_phb_email_index, 0xff, MAX_PB_ENTRIES * sizeof(U16));
  2624.     WriteRecord(NVRAM_EF_PHB_EMAIL_SORT_LID, 1, (void*)g_phb_email_index, MAX_PB_ENTRIES * sizeof(U16), &pError);
  2625. #else /* __MMI_PHB_USIM_FIELD__ */ 
  2626.     memset(g_phb_email_index, 0xff, MAX_PB_PHONE_ENTRIES * sizeof(U16));
  2627.     WriteRecord(NVRAM_EF_PHB_EMAIL_SORT_LID, 1, (void*)g_phb_email_index, MAX_PB_PHONE_ENTRIES * sizeof(U16), &pError);
  2628. #endif /* __MMI_PHB_USIM_FIELD__ */ 
  2629. }
  2632. /*****************************************************************************
  2633.  * FUNCTION
  2634.  *  mmi_phb_search_email_binary_search
  2635.  * DESCRIPTION
  2636.  *  This function
  2637.  * PARAMETERS
  2638.  *  low                 [IN]        
  2639.  *  high                [IN]        
  2640.  *  ucs2_pattern        [?]         
  2641.  * RETURNS
  2642.  *  void
  2643.  *****************************************************************************/
  2644. U16 mmi_phb_search_email_binary_search(S32 low, S32 high, S8 *ucs2_pattern)
  2645. {
  2646.     /*----------------------------------------------------------------*/
  2647.     /* Local Variables                                                */
  2648.     /*----------------------------------------------------------------*/
  2649.     S16 pError;
  2650.     U16 g_phb_email_index[MAX_PB_PHONE_ENTRIES];
  2651.     S32 mid;
  2652.     S16 flag;
  2653.     U8 same_count;
  2654.     S32 distance;
  2655.     U16 index;
  2656.     S8 *string;
  2658.     /*----------------------------------------------------------------*/
  2659.     /* Code Body                                                      */
  2660.     /*----------------------------------------------------------------*/
  2661.     /* Get email mapping table from NVRAM */
  2662.     ReadRecord(NVRAM_EF_PHB_EMAIL_SORT_LID, 1, (void*)g_phb_email_index, MAX_PB_PHONE_ENTRIES * sizeof(U16), &pError);
  2664.     /* Use binary search to find nearest name. */
  2665.     while (low <= high)
  2666.     {
  2667.         mid = (low + high) / 2;
  2669.         index = g_phb_email_index[mid];
  2671.         /* Use email to compare pattern, if email empty, use name instead */
  2672.         ReadRecord(
  2673.             NVRAM_EF_PHB_FIELDS_LID,
  2674.             (U16) (index + 1),
  2675.             (void*)&PhoneBookOptionalFields,
  2676.             OPTIONAL_FIELDS_RECORD_SIZE,
  2677.             &pError);
  2678.         if (PhoneBookOptionalFields.emailAddress[0] != 0x00)
  2679.         {
  2680.             AnsiiToUnicodeString(pbEmailAddress, (PS8) PhoneBookOptionalFields.emailAddress);
  2681.             string = (S8*) pbEmailAddress;
  2682.         }
  2683.         else
  2684.         {
  2685.             string = (S8*) PhoneBook[index].alpha_id.name;
  2686.         }
  2688.         mmi_phb_compare_ucs2_strings(ucs2_pattern, string, &same_count, &distance);
  2690.         if (distance > 0)
  2691.         {
  2692.             low = mid + 1;
  2693.             flag = -1;
  2694.         }
  2695.         /*
  2696.          * Distance == 0 or < 0 here
  2697.          * If there are duplicate entry, this will help to move up until first entry.
  2698.          */
  2699.         else
  2700.         {
  2701.             high = mid - 1;
  2702.             flag = 1;
  2703.         }
  2704.     }
  2706.     if (flag == -1)
  2707.     {
  2708.         return (U16) (mid + 1);
  2709.     }
  2710.     else
  2711.     {
  2712.         return (U16) mid;
  2713.     }
  2714. }
  2716. #endif /* defined(__MMI_PHB_EMAIL_SORT__) */ 
  2718. #endif /* _PHONEBOOKSEARCH_C */