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

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

MTK

开发平台：

C/C++

mmi_imps_util.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*****************************************************************************
  37.  *
  38.  * Filename:
  39.  * ---------
  40.  * mmi_imps_util.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  * MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  * This file implements all common utilities for IMPS application.
  49.  *
  50.  * Author:
  51.  * -------
  52.  * -------
  53.  *
  54.  *============================================================================
  55.  *             HISTORY
  56.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  57.  *------------------------------------------------------------------------------
  58.  * removed!
  59.  *
  60.  * removed!
  61.  * removed!
  62.  * removed!
  63.  *
  64.  * removed!
  65.  * removed!
  66.  * removed!
  67.  *
  68.  * removed!
  69.  * removed!
  70.  * removed!
  71.  *
  72.  * removed!
  73.  * removed!
  74.  * removed!
  75.  *
  76.  * removed!
  77.  * removed!
  78.  * removed!
  79.  *
  80.  * removed!
  81.  * removed!
  82.  * removed!
  83.  *
  84.  * removed!
  85.  * removed!
  86.  * removed!
  87.  *
  88.  *------------------------------------------------------------------------------
  89.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  90.  *============================================================================
  91.  ****************************************************************************/
  92. #ifndef _MMI_IMPS_UTIL_C
  93. #define _MMI_IMPS_UTIL_C
  94. #include "MMI_features.h"
  95. #ifdef __MMI_IMPS__
  96. /*  Include: MMI header file */
  97. #include "PixtelDataTypes.h"
  98. #include "stdC.h"
  99. #include "L4Dr1.h"
  101. #include "GlobalDefs.h"
  102. #include "CommonScreens.h"
  103. #include "DebugInitDef.h"
  104. #include "GlobalConstants.h"
  106. #include "FrameworkStruct.h"
  107. #include "EventsGprot.h"
  108. #include "HistoryGprot.h"
  110. #include "wgui_categories.h"
  111. #include "wgui_categories_inputs.h"
  112. #include "wgui_inline_edit.h"
  114. #include "mmi_imps_enum.h"
  115. #include "mmi_imps_prot.h"
  117. #include "nvram_user_defs.h"
  118. #include "NVRAMProt.h"
  119. #include "Fat_fs.h"
  120. #include "FileManagerGProt.h"
  121. #include "wgui_tab_bars.h"
  122. #include "wgui_categories_IMPS.h"
  123. #include "Wgui_status_icons.h"
  124. #include "QuickAccessMenuItemProt.h"
  125. #include "ProfileGprots.h"
  126. #include "mdi_datatype.h"
  127. #include "mdi_audio.h"
  128. #include "gpioInc.h"
  129. #include "CallManagementGprot.h"
  130. #include "IdleAppDef.h"
  131. #include "app_mine.h"
  133. /*  Include: PS header file */
  134. /* ... Add More PS header */
  136. /***************************************************************************** 
  137. * Define
  138. *****************************************************************************/
  140. /***************************************************************************** 
  141. * Typedef 
  142. *****************************************************************************/
  144. /***************************************************************************** 
  145. * Local Variable
  146. *****************************************************************************/
  147. const S8 g_imps_cont_filename[] = { 'c', '', 'o', '', 'n', '', 't', '', '', '' };
  148. const S8 g_imps_group_filename[] = { 'g', '', 'r', '', 'o', '', 'u', '', 'p', '', '', '' };
  149. const S8 g_imps_three_dot[] = { '.', '', '.', '', '.', '', '', '' };
  151. #ifdef __MTK_TARGET__
  152. __align(2)
  153. #endif 
  154.      const U8 g_imps_msg_tone[] = 
  155.      {
  156.          0x4D, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06,
  157.          0x00, 0x00, 0x00, 0x01, 0x03, 0xC0, 0x4D, 0x54,
  158.          0x72, 0x6B, 0x00, 0x00, 0x00, 0xA2, 0x00, 0xFF,
  159.          0x02, 0x16, 0x43, 0x6F, 0x70, 0x79, 0x72, 0x69,
  160.          0x67, 0x68, 0x74, 0x20, 0x63, 0x20, 0x32, 0x30,
  161.          0x30, 0x35, 0x20, 0x62, 0x79, 0x20, 0x43, 0x43,
  162.          0x00, 0xFF, 0x01, 0x02, 0x43, 0x43, 0x00, 0xFF,
  163.          0x58, 0x04, 0x04, 0x02, 0x18, 0x08, 0x00, 0xFF,
  164.          0x59, 0x02, 0x00, 0x00, 0x00, 0xFF, 0x51, 0x03,
  165.          0x03, 0xD0, 0x90, 0x00, 0xC0, 0x60, 0x00, 0xB0,
  166.          0x07, 0x6E, 0x00, 0x90, 0x3E, 0x64, 0x00, 0xC1,
  167.          0x52, 0x00, 0xB1, 0x07, 0x5C, 0x00, 0x91, 0x3E,
  168.          0x64, 0x83, 0x60, 0x90, 0x43, 0x64, 0x00, 0x91,
  169.          0x43, 0x64, 0x83, 0x60, 0x90, 0x45, 0x64, 0x00,
  170.          0x91, 0x45, 0x64, 0x81, 0x70, 0x90, 0x35, 0x64,
  171.          0x00, 0x24, 0x64, 0x00, 0x91, 0x30, 0x64, 0x00,
  172.          0x2B, 0x64, 0x00, 0x26, 0x64, 0x81, 0x70, 0x35,
  173.          0x64, 0x81, 0x70, 0x26, 0x00, 0x00, 0x2B, 0x00,
  174.          0x00, 0x90, 0x24, 0x00, 0x00, 0x35, 0x00, 0x00,
  175.          0x91, 0x30, 0x00, 0x00, 0x90, 0x43, 0x00, 0x00,
  176.          0x3E, 0x00, 0x81, 0x70, 0x45, 0x00, 0x00, 0x91,
  177.          0x3E, 0x00, 0x00, 0x35, 0x00, 0x81, 0x70, 0x45,
  178.          0x00, 0x00, 0x43, 0x00, 0x00, 0xFF, 0x2F, 0x00,
  180.      };
  182.  #ifdef __MTK_TARGET__
  183. __align(2)
  184.  #endif 
  185.      const U8 g_imps_err_tone[] = 
  186.      {
  187.          0x4D, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06,
  188.          0x00, 0x00, 0x00, 0x01, 0x03, 0xC0, 0x4D, 0x54,
  189.          0x72, 0x6B, 0x00, 0x00, 0x00, 0x76, 0x00, 0xFF,
  190.          0x02, 0x16, 0x43, 0x6F, 0x70, 0x79, 0x72, 0x69,
  191.          0x67, 0x68, 0x74, 0x20, 0x63, 0x20, 0x32, 0x30,
  192.          0x30, 0x33, 0x20, 0x62, 0x79, 0x20, 0x43, 0x43,
  193.          0x00, 0xFF, 0x01, 0x02, 0x43, 0x43, 0x00, 0xFF,
  194.          0x58, 0x04, 0x04, 0x02, 0x18, 0x08, 0x00, 0xFF,
  195.          0x59, 0x02, 0x00, 0x00, 0x00, 0xFF, 0x51, 0x03,
  196.          0x09, 0x27, 0xC0, 0x00, 0x99, 0x44, 0x64, 0x00,
  197.          0x4F, 0x64, 0x00, 0x52, 0x7D, 0x05, 0x38, 0x64,
  198.          0x23, 0x4B, 0x64, 0x2A, 0x4A, 0x64, 0x05, 0x3E,
  199.          0x64, 0x35, 0x41, 0x64, 0x53, 0x4D, 0x64, 0x05,
  200.          0x42, 0x64, 0x0C, 0x52, 0x00, 0x00, 0x44, 0x00,
  201.          0x00, 0x4F, 0x00, 0x05, 0x38, 0x00, 0x23, 0x4B,
  202.          0x00, 0x2A, 0x4A, 0x00, 0x05, 0x3E, 0x00, 0x35,
  203.          0x41, 0x00, 0x53, 0x4D, 0x00, 0x05, 0x42, 0x00,
  204.          0x00, 0xFF, 0x2F, 0x00,
  205.      };
  207. /***************************************************************************** 
  208. * Local Function
  209. *****************************************************************************/
  211. /***************************************************************************** 
  212. * Global Variable
  213. *****************************************************************************/
  215. const mmi_imps_err_mapping_struct g_imps_err_tbl[] = 
  216. {
  217.     {IMPS_OK, STR_GLOBAL_OK},
  218.     {IMPS_ERROR_GENERAL, STR_ID_IMPS_ERR_UNKNOWN_ERROR},
  219.     {IMPS_ERROR_INVALID_PARAMETER, STR_ID_IMPS_ERR_INVALID_INPUT},
  220.     {IMPS_ERROR_SERVICE_NOT_AGREED, STR_ID_IMPS_ERR_UNSUPPORT_SERVICE},
  221.     {IMPS_ERROR_NOT_LOGGED_IN, STR_ID_IMPS_ERR_NOT_LOGIN},
  222.     {IMPS_ERROR_ALREADY_LOGGED_IN, STR_ID_IMPS_ERR_ALREADY_LOGIN},
  223.     {IMPS_ERROR_LOGIN_INVALID_PASSWD, STR_ID_IMPS_ERR_INVALID_PASSWD},
  224.     {IMPS_ERROR_LOGIN_INVALID_USER, STR_ID_IMPS_ERR_INVALID_USERNAME},
  225.     {IMPS_ERROR_LOGIN_INVALID_SERVER, STR_ID_IMPS_ERR_INVALID_SERVER},
  226.     {IMPS_ERROR_BAD_CLIENT_REQUEST, STR_ID_IMPS_ERR_INVALID_REQUEST},
  227.     {IMPS_ERROR_SERVER_NOT_SUPPORT, STR_ID_IMPS_ERR_SERVER_NOT_SUPPORT},
  228.     {IMPS_ERROR_SESSION_PROBLEM, STR_ID_IMPS_ERR_SESSION_PROBLEM},      /* attar: imps sesssion related problem */
  229.     {IMPS_ERROR_PRESENCE_PROBLEM, STR_ID_IMPS_ERR_PRESENCE_PROBLEM},    /* attar: imps presence related problem */
  230.     {IMPS_ERROR_GROUP_ALREADY_EXIST, STR_ID_IMPS_ERR_ROOM_EXIST},
  231.     {IMPS_ERROR_GROUP_PROBLEM, STR_ID_IMPS_ERR_GROUP_PROBLEM},  /* attar: imps group related problem */
  232.     {IMPS_ERROR_GROUP_NOT_EXIST, STR_ID_IMPS_ERR_ROOM_NOT_EXIST},
  233.     {IMPS_ERROR_CREATE_XML_FILE_FAIL, STR_ID_IMPS_ERR_SEND_REQUEST_FAIL},       /* attar : request can not be fulfilled */
  234.     {IMPS_ERROR_PARSE_XML_FILE_FAIL, STR_ID_IMPS_ERR_RECV_RESPONSE_FAIL},       /* attar : invalid content format */
  235.     {IMPS_ERROR_HIT_MAX_GROUP, STR_ID_IMPS_ERR_CHAT_ROOM_FULL},
  236.     {IMPS_ERROR_HIT_MAX_TRANSACTION, STR_ID_IMPS_ERR_NETWORK_BUSY},
  237.     {IMPS_ERROR_HIT_MAX_INVITATION, STR_ID_IMPS_ERR_NETWORK_BUSY},
  238.     {IMPS_ERROR_WRONG_TRANSACTION_ID, STR_ID_IMPS_ERR_UNKNOWN_ERROR},
  239.     {IMPS_ERROR_HTTP_FAIL, STR_ID_IMPS_ERR_CONN_FAILED},
  240.     {IMPS_ERROR_ABORT_FAIL, STR_ID_IMPS_ERR_ABORT_FAIL},
  241.     {IMPS_ERROR_WRONG_MSG_TYPE, STR_ID_IMPS_ERR_CONN_FAILED},
  242.     {IMPS_ERROR_UNAUTHORIZED, STR_ID_IMPS_ERR_AUTH_FAIL},
  243.     {IMPS_ERROR_REQUEST_TIMEOUT, STR_ID_IMPS_ERR_REQUEST_TIMEOUT},
  244.     {IMPS_ERROR_SENDER_IS_BLOCKED, STR_ID_IMPS_ERR_MSG_SEND_FAIL},
  245.     {IMPS_ERROR_TOO_BROAD_SEARCH_CRITERIA, STR_ID_IMPS_ERR_TOO_BROAD_SEARCH_CRITERIA},
  246.     {IMPS_ERROR_MESSAGE_IS_REJECTED, STR_ID_IMPS_ERR_MSG_REJECT_BY_RECIPIENT},
  247.     {IMPS_ERROR_HIT_MAX_CONTACTS, STR_ID_IMPS_ERR_CONT_FULL},
  248.     {IMPS_ERROR_HIT_MAX_CONTACT_LISTS, STR_ID_IMPS_ERR_CONT_LIST_FULL},
  249.     {IMPS_ERROR_SCREEN_NAME_IN_USE, STR_ID_IMPS_ERR_SNAME_IN_USE},
  250.     {IMPS_ERROR_GROUP_ALREADY_JOINED, STR_ID_IMPS_ERR_ROOM_ALREADY_JOINED},
  251.     {IMPS_ERROR_GROUP_NOT_JOINED, STR_ID_IMPS_ERR_ROOM_NOT_JOINED},
  252.     {IMPS_ERROR_FORCED_LEAVE_GROUP, STR_GLOBAL_ERROR},  /* not required, because it's sent with MSG_ID_MMI_IMPS_LEAVE_GROUP_IND */
  253.     {IMPS_ERROR_HIT_MAX_JOINED_USER, STR_ID_IMPS_ERR_ROOM_FULL},
  254.     {IMPS_ERROR_SEARCH_NEED_NAME_OR_TOPIC, STR_ID_IMPS_ERR_NO_SEATCH_RESULT},
  255.     {IMPS_ERROR_FILE_ACCESS_ERROR, STR_ID_IMPS_ERR_FILE_ACCESS_ERROR}
  256. };
  258. /*****************************************************************************
  259. * Global Function
  260. *****************************************************************************/
  263. /*****************************************************************************
  264.  * FUNCTION
  265.  *  mmi_imps_util_get_err_str
  266.  * DESCRIPTION
  267.  *  Get error string for a error code.
  268.  * PARAMETERS
  269.  *  err     [IN]        
  270.  * RETURNS
  271.  *  void
  272.  *****************************************************************************/
  273. U16 mmi_imps_util_get_err_str(S32 err)
  274. {
  275.     /*----------------------------------------------------------------*/
  276.     /* Local Variables                                                */
  277.     /*----------------------------------------------------------------*/
  278.     S16 i;
  279.     S16 entry;
  281.     /*----------------------------------------------------------------*/
  282.     /* Code Body                                                      */
  283.     /*----------------------------------------------------------------*/
  284.     entry = sizeof(g_imps_err_tbl) / sizeof(mmi_imps_err_mapping_struct);
  286.     for (i = 0; i < entry; i++)
  287.         if (g_imps_err_tbl[i].err_cause == err)
  288.         {
  289.             return g_imps_err_tbl[i].str_id;
  290.         }
  292.     return STR_ID_IMPS_ERR_UNKNOWN_ERROR;
  293. }
  296. /*****************************************************************************
  297.  * FUNCTION
  298.  *  mmi_imps_util_init_list
  299.  * DESCRIPTION
  300.  *  Initialize contact list and group list from file system.
  301.  * PARAMETERS
  302.  *  void
  303.  * RETURNS
  304.  *  void
  305.  *****************************************************************************/
  306. void mmi_imps_util_init_list(void)
  307. {
  308.     /*----------------------------------------------------------------*/
  309.     /* Local Variables                                                */
  310.     /*----------------------------------------------------------------*/
  312.     /*----------------------------------------------------------------*/
  313.     /* Code Body                                                      */
  314.     /*----------------------------------------------------------------*/
  315.     mmi_imps_util_read_cont();
  316.     mmi_imps_util_read_group();
  317. }
  320. /*****************************************************************************
  321.  * FUNCTION
  322.  *  mmi_imps_util_read_nvram
  323.  * DESCRIPTION
  324.  *  Read profile info from NVRAM
  325.  * PARAMETERS
  326.  *  buff        [?]     
  327.  * RETURNS
  328.  *  void
  329.  *****************************************************************************/
  330. void mmi_imps_util_read_nvram(void *buff)
  331. {
  332.     /*----------------------------------------------------------------*/
  333.     /* Local Variables                                                */
  334.     /*----------------------------------------------------------------*/
  335.     S16 error;
  337.     /*----------------------------------------------------------------*/
  338.     /* Code Body                                                      */
  339.     /*----------------------------------------------------------------*/
  340.     ReadRecord(NVRAM_EF_IMPS_LID, 1, (void*)buff, NVRAM_EF_IMPS_SIZE, &error);
  341. }
  344. /*****************************************************************************
  345.  * FUNCTION
  346.  *  mmi_imps_util_write_nvram
  347.  * DESCRIPTION
  348.  *  Write profile info to NVRAM
  349.  * PARAMETERS
  350.  *  buff        [?]     
  351.  * RETURNS
  352.  *  void
  353.  *****************************************************************************/
  354. void mmi_imps_util_write_nvram(void *buff)
  355. {
  356.     /*----------------------------------------------------------------*/
  357.     /* Local Variables                                                */
  358.     /*----------------------------------------------------------------*/
  359.     S16 error;
  361.     /*----------------------------------------------------------------*/
  362.     /* Code Body                                                      */
  363.     /*----------------------------------------------------------------*/
  364.     WriteRecord(NVRAM_EF_IMPS_LID, 1, (void*)buff, NVRAM_EF_IMPS_SIZE, &error);
  365. }
  368. /*****************************************************************************
  369.  * FUNCTION
  370.  *  mmi_imps_util_get_file_size
  371.  * DESCRIPTION
  372.  *  Get size of a file
  373.  * PARAMETERS
  374.  *  filePathPtr         [?]             
  375.  *  fileSizePtr         [?]             
  376.  *  fileSizePrt(?)      [IN/OUT]        Address to store the size of file
  377.  *  filePathPrt(?)      [IN]            File path and name
  378.  * RETURNS
  379.  *  Error cause of file open
  380.  *****************************************************************************/
  381. S32 mmi_imps_util_get_file_size(S8 *filePathPtr, S32 *fileSizePtr)
  382. {
  383.     /*----------------------------------------------------------------*/
  384.     /* Local Variables                                                */
  385.     /*----------------------------------------------------------------*/
  386.     FS_HANDLE fileHandle;
  388.     /*----------------------------------------------------------------*/
  389.     /* Code Body                                                      */
  390.     /*----------------------------------------------------------------*/
  391.     fileHandle = FS_Open((U16*) filePathPtr, FS_READ_ONLY);
  393.     if (fileHandle > 0)
  394.     {
  395.         S32 result;
  397.         result = FS_GetFileSize(fileHandle, (U32*) fileSizePtr);
  399.         FS_Close(fileHandle);
  401.         return result;
  402.     }
  404.     return fileHandle;
  405. }
  408. /*****************************************************************************
  409.  * FUNCTION
  410.  *  mmi_imps_util_check_file_exist
  411.  * DESCRIPTION
  412.  *  Check if the file already exists.
  413.  * PARAMETERS
  414.  *  filePathName        [IN]        Full file path + name
  415.  * RETURNS
  416.  *  TRUE if exists, otherwise, FALSE.
  417.  *****************************************************************************/
  418. BOOL mmi_imps_util_check_file_exist(S8 *filePathName)
  419. {
  420.     /*----------------------------------------------------------------*/
  421.     /* Local Variables                                                */
  422.     /*----------------------------------------------------------------*/
  423.     FS_HANDLE fileHandle;
  425.     /*----------------------------------------------------------------*/
  426.     /* Code Body                                                      */
  427.     /*----------------------------------------------------------------*/
  428.     fileHandle = FS_Open((U16*) filePathName, FS_READ_ONLY);
  430.     if (fileHandle > 0)
  431.     {
  432.         FS_Close(fileHandle);
  433.         return TRUE;
  434.     }
  436.     return FALSE;
  437. }
  440. /*****************************************************************************
  441.  * FUNCTION
  442.  *  mmi_imps_util_update_cont
  443.  * DESCRIPTION
  444.  *  Remove dangling file and update contact list to file
  445.  * PARAMETERS
  446.  *  void
  447.  *  filePathName(?)     [IN]        Full file path + name
  448.  * RETURNS
  449.  *  TRUE if exists, otherwise, FALSE.(?)
  450.  *****************************************************************************/
  451. void mmi_imps_util_update_cont(void)
  452. {
  453.     /*----------------------------------------------------------------*/
  454.     /* Local Variables                                                */
  455.     /*----------------------------------------------------------------*/
  456.     S32 i;
  457.     S32 count = (S32) imps_p->cont_info.no_cont;
  459.     /*----------------------------------------------------------------*/
  460.     /* Code Body                                                      */
  461.     /*----------------------------------------------------------------*/
  462.     /* remove dangling contact list */
  463.     for (i = 0; i < count; i++)
  464.     {
  465.         if ((imps_p->cont_info.cont_list[i].comm_state & IMPS_CONT_PA_READY) == 0)
  466.         {
  467.             if (i < (count - 1))
  468.             {
  469.                 memcpy(&imps_p->cont_info.cont_list[i], &imps_p->cont_info.cont_list[i + 1], (count - i - 1));
  470.                 memset(&imps_p->cont_info.cont_list[count], 0, sizeof(mmi_imps_cont_struct));
  471.             }
  472.             else
  473.             {
  474.                 memset(&imps_p->cont_info.cont_list[i], 0, sizeof(mmi_imps_cont_struct));
  475.             }
  477.             count--;
  478.         }
  479.     }
  481.     imps_p->cont_info.no_cont = (U8) count;
  483.     mmi_imps_util_write_cont();
  484. }
  487. /*****************************************************************************
  488.  * FUNCTION
  489.  *  mmi_imps_util_write_cont
  490.  * DESCRIPTION
  491.  *  Write contact list data to file
  492.  * PARAMETERS
  493.  *  void
  494.  * RETURNS
  495.  *  result of file operation
  496.  *****************************************************************************/
  497. S32 mmi_imps_util_write_cont(void)
  498. {
  499.     /*----------------------------------------------------------------*/
  500.     /* Local Variables                                                */
  501.     /*----------------------------------------------------------------*/
  502.     FS_HANDLE fileHandle;
  503.     S16 *ucs2_folder = OslMalloc((FMGR_MAX_PATH_LEN + 1) * ENCODING_LENGTH);
  505.     /*----------------------------------------------------------------*/
  506.     /* Code Body                                                      */
  507.     /*----------------------------------------------------------------*/
  508.     mmi_imps_util_get_work_path((S8*) ucs2_folder);
  509.     pfnUnicodeStrcat((S8*) ucs2_folder, (S8*) g_imps_cont_filename);
  511.     fileHandle = FS_Open((U16*) ucs2_folder, FS_CREATE_ALWAYS);
  513.     OslMfree(ucs2_folder);
  515.     if (fileHandle > 0)
  516.     {
  517.         S32 result;
  519.         U32 len;
  521.         result = FS_Write(
  522.                     fileHandle,
  523.                     (void*)&imps_p->cont_info.cont_list[0],
  524.                     sizeof(mmi_imps_cont_struct) * IMPS_MAX_NO_CONT,
  525.                     (U32*) & len);
  527.         FS_Close(fileHandle);
  529.         return result;
  530.     }
  532.     return fileHandle;
  533. }
  536. /*****************************************************************************
  537.  * FUNCTION
  538.  *  mmi_imps_util_read_cont
  539.  * DESCRIPTION
  540.  *  Read contact list data from file
  541.  * PARAMETERS
  542.  *  void
  543.  * RETURNS
  544.  *  result of file operation
  545.  *****************************************************************************/
  546. S32 mmi_imps_util_read_cont(void)
  547. {
  548.     /*----------------------------------------------------------------*/
  549.     /* Local Variables                                                */
  550.     /*----------------------------------------------------------------*/
  551.     FS_HANDLE fileHandle;
  552.     S16 *ucs2_folder = OslMalloc((FMGR_MAX_PATH_LEN + 1) * ENCODING_LENGTH);
  553.     mmi_imps_cont_struct *cont;
  555.     /*----------------------------------------------------------------*/
  556.     /* Code Body                                                      */
  557.     /*----------------------------------------------------------------*/
  558.     mmi_imps_util_get_work_path((S8*) ucs2_folder);
  559.     pfnUnicodeStrcat((S8*) ucs2_folder, (S8*) g_imps_cont_filename);
  561.     fileHandle = FS_Open((U16*) ucs2_folder, FS_READ_ONLY);
  563.     if (fileHandle > 0)
  564.     {
  565.         U32 len;
  566.         S32 i;
  568.         FS_Read(
  569.             fileHandle,
  570.             (void*)&imps_p->cont_info.cont_list[0],
  571.             sizeof(mmi_imps_cont_struct) * IMPS_MAX_NO_CONT,
  572.             (U32*) & len);
  574.         for (i = 1; i < IMPS_MAX_NO_CONT; i++)
  575.         {
  576.             cont = &imps_p->cont_info.cont_list[i];
  577.             if (strlen((S8*) cont->id))
  578.             {
  579.                 cont->comm_state = 0;
  580.                 cont->availability = IMPS_PA_USER_UNKNOWN;
  581.             }
  582.             else
  583.             {
  584.                 break;
  585.             }
  586.         }
  588.         imps_p->cont_info.no_cont = (U8) i;
  590.         FS_Close(fileHandle);
  592.         OslMfree(ucs2_folder);
  594.     }
  595. #ifdef IMPS_TEST_CODE
  596.     else
  597.     {
  598.         S32 result;
  599.         U32 len;
  600.         S32 i;
  602.         fileHandle = FS_Open((U16*) ucs2_folder, FS_CREATE_ALWAYS);
  604.         if (strlen((S8*) imps_p->act_prof.username) == 0)
  605.         {
  606.             strcpy((S8*) imps_p->cont_info.cont_list[0].id, (S8*) "Max Chen");
  607.         }
  608.         else
  609.         {
  610.             strcpy((S8*) imps_p->cont_info.cont_list[0].id, (S8*) imps_p->act_prof.username);
  611.         }
  613.         strcpy((S8*) imps_p->cont_info.cont_list[0].group_id, (S8*) "MySelf");
  614.         pfnUnicodeStrcpy((S8*) imps_p->cont_info.cont_list[0].alias, (S8*) L"MAXMAX");
  616.         for (i = 1; i < IMPS_MAX_NO_CONT; i++)
  617.         {
  618.             sprintf((S8*) imps_p->cont_info.cont_list[i].id, (S8*) "Max %ld", i);
  619.             sprintf((S8*) imps_p->cont_info.cont_list[i].group_id, "WCP_SW_PS%ld", (IMPS_MAX_NO_CONT - i));
  620.             AnsiiToUnicodeString((S8*) imps_p->cont_info.cont_list[i].alias, (S8*) "IMPS");
  621.             imps_p->cont_info.cont_list[i].availability = (U8) (i % 3);
  622.         }
  623.         result = FS_Write(
  624.                     fileHandle,
  625.                     (void*)&imps_p->cont_info.cont_list[0],
  626.                     sizeof(mmi_imps_cont_struct) * IMPS_MAX_NO_CONT,
  627.                     (U32*) & len);
  629.         FS_Close(fileHandle);
  631.         OslMfree(ucs2_folder);
  633.         return result;
  634.     }
  635. #elif defined(IMPS_PROF_TEST_CODE)
  636.     else
  637.     {
  638.         S32 result;
  639.         U32 len;
  641.         fileHandle = FS_Open((U16*) ucs2_folder, FS_CREATE_ALWAYS);
  643.         if (strlen((S8*) imps_p->act_prof.username) == 0)
  644.         {
  645.             strcpy((S8*) imps_p->cont_info.cont_list[0].id, (S8*) "wv:max");
  646.         }
  647.         else
  648.         {
  649.             strcpy((S8*) imps_p->cont_info.cont_list[0].id, (S8*) imps_p->act_prof.username);
  650.         }
  652.         strcpy((S8*) imps_p->cont_info.cont_list[0].group_id, (S8*) "MySelf");
  653.         pfnUnicodeStrcpy((S8*) imps_p->cont_info.cont_list[0].nick_name, (S8*) L"max");
  655.     #if 0
  656. /* under construction !*/
  657. /* under construction !*/
  658. /* under construction !*/
  659. /* under construction !*/
  660. /* under construction !*/
  661. /* under construction !*/
  662. /* under construction !*/
  663. /* under construction !*/
  664. /* under construction !*/
  665. /* under construction !*/
  666. /* under construction !*/
  667. /* under construction !*/
  668. /* under construction !*/
  669. /* under construction !*/
  670. /* under construction !*/
  671.     #endif /* 0 */ 
  673.         result = FS_Write(
  674.                     fileHandle,
  675.                     (void*)&imps_p->cont_info.cont_list[0],
  676.                     sizeof(mmi_imps_cont_struct) * 1,
  677.                     (U32*) & len);
  679.         FS_Close(fileHandle);
  680.         imps_p->cont_info.no_cont = (U8) 1;
  682.         OslMfree(ucs2_folder);
  684.         return result;
  685.     }
  686. #endif 
  687.     return fileHandle;
  688. }
  691. /*****************************************************************************
  692.  * FUNCTION
  693.  *  mmi_imps_util_write_group
  694.  * DESCRIPTION
  695.  *  Write group data to file
  696.  * PARAMETERS
  697.  *  void
  698.  * RETURNS
  699.  *  result of file operation
  700.  *****************************************************************************/
  701. S32 mmi_imps_util_write_group(void)
  702. {
  703.     /*----------------------------------------------------------------*/
  704.     /* Local Variables                                                */
  705.     /*----------------------------------------------------------------*/
  706.     FS_HANDLE fileHandle;
  707.     S16 *ucs2_folder = OslMalloc((FMGR_MAX_PATH_LEN + 1) * ENCODING_LENGTH);
  709.     /*----------------------------------------------------------------*/
  710.     /* Code Body                                                      */
  711.     /*----------------------------------------------------------------*/
  712.     mmi_imps_util_get_work_path((S8*) ucs2_folder);
  714.     pfnUnicodeStrcat((S8*) ucs2_folder, (S8*) g_imps_group_filename);
  716.     fileHandle = FS_Open((U16*) ucs2_folder, FS_CREATE_ALWAYS);
  718.     OslMfree(ucs2_folder);
  720.     if (fileHandle > 0)
  721.     {
  722.         S32 result;
  723.         U32 len;
  725.         result = FS_Write(
  726.                     fileHandle,
  727.                     (void*)&imps_p->group_info.group_list[0],
  728.                     sizeof(mmi_imps_group_struct) * IMPS_MAX_NO_GROUP,
  729.                     (U32*) & len);
  730.         FS_Close(fileHandle);
  732.         return result;
  733.     }
  735.     return fileHandle;
  736. }
  739. /*****************************************************************************
  740.  * FUNCTION
  741.  *  mmi_imps_util_read_group
  742.  * DESCRIPTION
  743.  *  Write group data to file
  744.  * PARAMETERS
  745.  *  void
  746.  * RETURNS
  747.  *  result of file operation
  748.  *****************************************************************************/
  749. S32 mmi_imps_util_read_group(void)
  750. {
  751.     /*----------------------------------------------------------------*/
  752.     /* Local Variables                                                */
  753.     /*----------------------------------------------------------------*/
  754.     FS_HANDLE fileHandle;
  755.     S16 *ucs2_folder = OslMalloc((FMGR_MAX_PATH_LEN + 1) * ENCODING_LENGTH);
  757.     /*----------------------------------------------------------------*/
  758.     /* Code Body                                                      */
  759.     /*----------------------------------------------------------------*/
  760.     mmi_imps_util_get_work_path((S8*) ucs2_folder);
  761.     pfnUnicodeStrcat((S8*) ucs2_folder, (S8*) g_imps_group_filename);
  763.     fileHandle = FS_Open((U16*) ucs2_folder, FS_READ_ONLY);
  765.     if (fileHandle > 0)
  766.     {
  767.         U32 len;
  768.         S32 i;
  770.         FS_Read(
  771.             fileHandle,
  772.             (void*)&imps_p->group_info.group_list[0],
  773.             sizeof(mmi_imps_group_struct) * IMPS_MAX_NO_GROUP,
  774.             (U32*) & len);
  776.         for (i = 0; i < IMPS_MAX_NO_GROUP; i++)
  777.         {
  778.             if (strlen((S8*) imps_p->group_info.group_list[i].group_id))
  779.             {
  780.                 imps_p->group_info.group_list[i].is_sync = FALSE;
  781.             }
  782.             else
  783.             {
  784.                 break;
  785.             }
  786.         }
  788.         imps_p->group_info.no_group = (U8) i;
  790.         FS_Close(fileHandle);
  791.         OslMfree(ucs2_folder);
  792.         return 0;
  793.     }
  794. #ifdef IMPS_TEST_CODE
  795.     else
  796.     {
  797.         S32 result;
  798.         U32 len;
  800.         fileHandle = FS_Open((U16*) ucs2_folder, FS_CREATE_ALWAYS);
  801.         strcpy((S8*) imps_p->group_info.group_list[0].group_id, (S8*) "WCP_SW_PS1");
  802.         AnsiiToUnicodeString((S8*) imps_p->group_info.group_list[0].group_name, (S8*) "PS1");
  803.         imps_p->group_info.group_list[0].no_users = (IMPS_MAX_NO_CONT - 1);
  804.         imps_p->group_info.group_list[0].is_sync = TRUE;
  806.         strcpy((S8*) imps_p->group_info.group_list[1].group_id, (S8*) "WCP_SW_PS2");
  807.         AnsiiToUnicodeString((S8*) imps_p->group_info.group_list[1].group_name, (S8*) "PS2");
  808.         imps_p->group_info.group_list[1].no_users = 0;
  809.         imps_p->group_info.group_list[0].is_sync = FALSE;
  810.         imps_p->group_info.no_group = 2;
  812.         result = FS_Write(
  813.                     fileHandle,
  814.                     (void*)&imps_p->group_info.group_list[0],
  815.                     sizeof(mmi_imps_group_struct) * IMPS_MAX_NO_GROUP,
  816.                     (U32*) & len);
  818.         FS_Close(fileHandle);
  819.         OslMfree(ucs2_folder);
  820.         return result;
  822.     }
  823. #endif /* IMPS_TEST_CODE */ 
  824.     OslMfree(ucs2_folder);
  825.     return fileHandle;
  826. }
  829. /*****************************************************************************
  830.  * FUNCTION
  831.  *  mmi_imps_util_reset_cont_list
  832.  * DESCRIPTION
  833.  *  Reset contact list when data account changed.
  834.  * PARAMETERS
  835.  *  void
  836.  * RETURNS
  837.  *  void
  838.  *****************************************************************************/
  839. void mmi_imps_util_reset_cont_list(void)
  840. {
  841.     /*----------------------------------------------------------------*/
  842.     /* Local Variables                                                */
  843.     /*----------------------------------------------------------------*/
  845.     /*----------------------------------------------------------------*/
  846.     /* Code Body                                                      */
  847.     /*----------------------------------------------------------------*/
  848.     /* update contact list */
  849.     memset(&imps_p->cont_info.cont_list[0], 0, IMPS_MAX_NO_CONT * sizeof(mmi_imps_cont_struct));
  850.     strcpy((S8*) imps_p->cont_info.cont_list[0].id, (S8*) imps_p->act_prof.username);
  851.     imps_p->cont_info.no_cont = 1;
  852.     mmi_imps_util_write_cont();
  854.     /* reset group list */
  855.     memset(&imps_p->group_info.group_list[0], 0, IMPS_MAX_NO_GROUP * sizeof(mmi_imps_group_struct));
  856.     mmi_imps_util_write_group();
  857.     imps_p->group_info.no_group = 0;
  858. }
  861. /*****************************************************************************
  862.  * FUNCTION
  863.  *  mmi_imps_util_reset_about_me
  864.  * DESCRIPTION
  865.  *  Reset about me data when data account changed.
  866.  * PARAMETERS
  867.  *  buff        [OUT]       Buffer which stores whole NVRAM data.
  868.  * RETURNS
  869.  *  void
  870.  *****************************************************************************/
  871. void mmi_imps_util_reset_about_me(void *buff)
  872. {
  873.     /*----------------------------------------------------------------*/
  874.     /* Local Variables                                                */
  875.     /*----------------------------------------------------------------*/
  876.     mmi_imps_nvram_struct *nvram_data = (mmi_imps_nvram_struct*) buff;
  878.     /*----------------------------------------------------------------*/
  879.     /* Code Body                                                      */
  880.     /*----------------------------------------------------------------*/
  881.     memset(&nvram_data->about_me, 0, sizeof(mmi_imps_about_me_nvram_struct));
  882. }
  885. /*****************************************************************************
  886.  * FUNCTION
  887.  *  mmi_imps_util_is_id_same
  888.  * DESCRIPTION
  889.  *  Compare if two ids are identical (without wv:)
  890.  * PARAMETERS
  891.  *  id1     [IN]        Id to be compared
  892.  *  id2     [IN]        Id to be compared
  893.  * RETURNS
  894.  *  TRUE if identical; otherwise, FALSE
  895.  *****************************************************************************/
  896. BOOL mmi_imps_util_is_id_same(S8 *id1, S8 *id2)
  897. {
  898.     /*----------------------------------------------------------------*/
  899.     /* Local Variables                                                */
  900.     /*----------------------------------------------------------------*/
  901.     S8 *str1, *str2;
  902.     S8 *comp1, *comp2;
  903.     BOOL result = FALSE;
  905.     /*----------------------------------------------------------------*/
  906.     /* Code Body                                                      */
  907.     /*----------------------------------------------------------------*/
  908.     comp1 = OslMalloc(IMPS_MAX_ID_LEN);
  909.     comp2 = OslMalloc(IMPS_MAX_ID_LEN);
  911.     /* remove wv: */
  912.     str1 = id1;
  913.     if (str1[0] == 'w' && str1[1] == 'v' && str1[2] == ':')
  914.     {
  915.         str1 += 3;
  916.     }
  918.     str2 = id2;
  919.     if (str2[0] == 'w' && str2[1] == 'v' && str2[2] == ':')
  920.     {
  921.         str2 += 3;
  922.     }
  924.     strcpy(comp1, str1);
  925.     strcpy(comp2, str2);
  927.     /* check if @ exist */
  928.     str1 = strstr(comp1, "@");
  929.     str2 = strstr(comp2, "@");
  931.     if (str1 == NULL && str2 != NULL)   /* trancated @ after str_at2 */
  932.     {
  933.         str2[0] = '';
  934.     }
  935.     else if (str1 != NULL && str2 == NULL)
  936.     {
  937.         str1[0] = '';
  938.     }
  940.     if (mmi_imps_util_stricmp(comp1, comp2) == 0)
  941.     {
  942.         result = TRUE;
  943.     }
  945.     OslMfree(comp1);
  946.     OslMfree(comp2);
  947.     return result;
  948. }
  951. /*****************************************************************************
  952.  * FUNCTION
  953.  *  mmi_imps_util_is_cont_exist
  954.  * DESCRIPTION
  955.  *  Check if the contact already exists in contact list
  956.  * PARAMETERS
  957.  *  id      [IN]        Id of the contact
  958.  * RETURNS
  959.  *  TRUE if the contact exists; otherwise, FALSE
  960.  *****************************************************************************/
  961. BOOL mmi_imps_util_is_cont_exist(S8 *id)
  962. {
  963.     /*----------------------------------------------------------------*/
  964.     /* Local Variables                                                */
  965.     /*----------------------------------------------------------------*/
  966.     S32 i;
  967.     S32 count = (S32) imps_p->cont_info.no_cont;
  969.     /*----------------------------------------------------------------*/
  970.     /* Code Body                                                      */
  971.     /*----------------------------------------------------------------*/
  972.     /* check if contact exists */
  974.     for (i = 0; i < count; i++)
  975.         if (mmi_imps_util_is_id_same(id, (S8*) imps_p->cont_info.cont_list[i].id))
  976.         {
  977.             return TRUE;
  978.         }
  980.     return FALSE;
  981. }
  984. /*****************************************************************************
  985.  * FUNCTION
  986.  *  mmi_imps_util_is_room_joined
  987.  * DESCRIPTION
  988.  *  Check if the user has already joined the chat room
  989.  * PARAMETERS
  990.  *  id      [IN]        Id of the chat room
  991.  * RETURNS
  992.  *  TRUE if the user has already joined the chat room; otherwise, FALSE
  993.  *****************************************************************************/
  994. BOOL mmi_imps_util_is_room_joined(S8 *id)
  995. {
  996.     /*----------------------------------------------------------------*/
  997.     /* Local Variables                                                */
  998.     /*----------------------------------------------------------------*/
  999.     S32 i;
  1001.     /*----------------------------------------------------------------*/
  1002.     /* Code Body                                                      */
  1003.     /*----------------------------------------------------------------*/
  1004.     /* check if the room is already joined */
  1005.     for (i = 0; i < IMPS_MAX_NO_ROOM; i++)
  1006.         if (imps_p->room_info.room_list[i].is_used)
  1007.             if (strcmp(id, (S8*) imps_p->room_info.room_list[i].room_id) == 0)
  1008.             {
  1009.                 return TRUE;
  1010.             }
  1012.     return FALSE;
  1013. }
  1016. /*****************************************************************************
  1017.  * FUNCTION
  1018.  *  mmi_imps_util_get_empty_room_slot
  1019.  * DESCRIPTION
  1020.  *  Get the index of empty slot of chat room
  1021.  * PARAMETERS
  1022.  *  void
  1023.  * RETURNS
  1024.  *  Index in the chat room array
  1025.  *****************************************************************************/
  1026. S32 mmi_imps_util_get_empty_room_slot(void)
  1027. {
  1028.     /*----------------------------------------------------------------*/
  1029.     /* Local Variables                                                */
  1030.     /*----------------------------------------------------------------*/
  1031.     S32 i;
  1033.     /*----------------------------------------------------------------*/
  1034.     /* Code Body                                                      */
  1035.     /*----------------------------------------------------------------*/
  1036.     /* check if all check rooms are occupied */
  1037.     for (i = 0; i < IMPS_MAX_NO_ROOM; i++)
  1038.     {
  1039.         if (imps_p->room_info.room_list[i].is_used == FALSE)
  1040.         {
  1041.             break;
  1042.         }
  1043.     }
  1045.     return i;
  1046. }
  1048. #define NVRAM_FILE_IMPS
  1051. /*****************************************************************************
  1052.  * FUNCTION
  1053.  *  mmi_imps_get_mine_type
  1054.  * DESCRIPTION
  1055.  *  Reset contact list when data account changed.
  1056.  * PARAMETERS
  1057.  *  file_ext        [IN]        Get the mine of a file from its file extension.
  1058.  * RETURNS
  1059.  *  mine type string.
  1060.  *****************************************************************************/
  1061. S8 *mmi_imps_get_mine_type(S8 *file_ext)
  1062. {
  1063.     /*----------------------------------------------------------------*/
  1064.     /* Local Variables                                                */
  1065.     /*----------------------------------------------------------------*/
  1066.     applib_mime_type_struct *mime = mime_type_look_up(NULL, file_ext, 0, 0);
  1068.     /*----------------------------------------------------------------*/
  1069.     /* Code Body                                                      */
  1070.     /*----------------------------------------------------------------*/
  1071.     if (mime)
  1072.     {
  1073.         return mime->mime_string;
  1074.     }
  1075.     else
  1076.     {
  1077.         return NULL;
  1078.     }
  1079. }
  1081. #ifdef IMPS_TEST_CODE
  1084. /*****************************************************************************
  1085.  * FUNCTION
  1086.  *  mmi_imps_write_watch_list
  1087.  * DESCRIPTION
  1088.  *  
  1089.  * PARAMETERS
  1090.  *  void
  1091.  * RETURNS
  1092.  *  void
  1093.  *****************************************************************************/
  1094. void mmi_imps_write_watch_list(void)
  1095. {
  1096.     /*----------------------------------------------------------------*/
  1097.     /* Local Variables                                                */
  1098.     /*----------------------------------------------------------------*/
  1099.     U32 len;
  1100.     S32 i, count = 5;
  1101.     FS_HANDLE fileHandle;
  1102.     S16 *ucs2_folder = OslMalloc((FMGR_MAX_PATH_LEN + 1) * ENCODING_LENGTH);
  1103.     imps_watcher_entity_struct *buff = OslMalloc(sizeof(imps_watcher_entity_struct));
  1105.     /*----------------------------------------------------------------*/
  1106.     /* Code Body                                                      */
  1107.     /*----------------------------------------------------------------*/
  1108.     mmi_imps_util_get_work_path((S8*) ucs2_folder);
  1110.     pfnUnicodeStrcat((S8*) ucs2_folder, (S8*) L"watch");
  1112.     fileHandle = FS_Open((U16*) ucs2_folder, FS_CREATE_ALWAYS);
  1114.     for (i = 0; i < count; i++)
  1115.     {
  1116.         sprintf((S8*) buff->watcher_user_id, "Max Chen %ld", i);
  1117.         AnsiiToUnicodeString((S8*) buff->watcher_status, "WCP_SW_PS1");
  1119.         FS_Write(fileHandle, (void*)buff, sizeof(imps_watcher_entity_struct), &len);
  1120.     }
  1122.     imps_p->search_result.count = 5;
  1124.     FS_Close(fileHandle);
  1125.     OslMfree(ucs2_folder);
  1126.     OslMfree(buff);
  1127. }
  1128. #endif /* IMPS_TEST_CODE */ 
  1131. /*****************************************************************************
  1132.  * FUNCTION
  1133.  *  mmi_imps_util_get_work_path
  1134.  * DESCRIPTION
  1135.  *  Get path of working directory
  1136.  * PARAMETERS
  1137.  *  dest        [OUT]       Buffer to store result
  1138.  * RETURNS
  1139.  *  void
  1140.  *****************************************************************************/
  1141. void mmi_imps_util_get_work_path(S8 *dest)
  1142. {
  1143.     /*----------------------------------------------------------------*/
  1144.     /* Local Variables                                                */
  1145.     /*----------------------------------------------------------------*/
  1146.     S8 *buff = OslMalloc(FMGR_MAX_PATH_LEN * ENCODING_LENGTH);
  1148.     /*----------------------------------------------------------------*/
  1149.     /* Code Body                                                      */
  1150.     /*----------------------------------------------------------------*/
  1151.     sprintf(buff, "%s\", IMPS_XML_FILE_DIRECTORY);
  1152.     AnsiiToUnicodeString(dest, buff);
  1153.     OslMfree(buff);
  1154. }
  1157. /*****************************************************************************
  1158.  * FUNCTION
  1159.  *  mmi_imps_util_get_img_path
  1160.  * DESCRIPTION
  1161.  *  Get the path to store image
  1162.  * PARAMETERS
  1163.  *  dest        [OUT]       Buffer to store result
  1164.  * RETURNS
  1165.  *  void
  1166.  *****************************************************************************/
  1167. void mmi_imps_util_get_img_path(S8 *dest)
  1168. {
  1169.     /*----------------------------------------------------------------*/
  1170.     /* Local Variables                                                */
  1171.     /*----------------------------------------------------------------*/
  1172.     S8 *buff = OslMalloc(FMGR_MAX_PATH_LEN * ENCODING_LENGTH);
  1174.     /*----------------------------------------------------------------*/
  1175.     /* Code Body                                                      */
  1176.     /*----------------------------------------------------------------*/
  1177.     sprintf(buff, "%s%s", IMPS_XML_FILE_DIRECTORY, IMPS_STATUS_CONTENT_FOLDER);
  1178.     AnsiiToUnicodeString(dest, buff);
  1179.     OslMfree(buff);
  1180. }
  1182. #define HISTORY_IMPS
  1185. /*****************************************************************************
  1186.  * FUNCTION
  1187.  *  mmi_imps_util_is_in_imps
  1188.  * DESCRIPTION
  1189.  *  Check if it's currently in IMPS application
  1190.  * PARAMETERS
  1191.  *  void
  1192.  * RETURNS
  1193.  *  TURE if it's in IMPS application; otherwise, FALSE.
  1194.  *****************************************************************************/
  1195. BOOL mmi_imps_util_is_in_imps(void)
  1196. {
  1197.     /*----------------------------------------------------------------*/
  1198.     /* Local Variables                                                */
  1199.     /*----------------------------------------------------------------*/
  1200.     U16 scr_id = GetActiveScreenId();
  1202.     /*----------------------------------------------------------------*/
  1203.     /* Code Body                                                      */
  1204.     /*----------------------------------------------------------------*/
  1205.     if (mmi_imps_util_is_imps_scr(scr_id))
  1206.     {
  1207.         return TRUE;
  1208.     }
  1209.     else
  1210.     {
  1211.         return FALSE;
  1212.     }
  1213. }
  1216. /*****************************************************************************
  1217.  * FUNCTION
  1218.  *  mmi_imps_util_is_imps_scr
  1219.  * DESCRIPTION
  1220.  *  Check if the screen in IMPS application.
  1221.  * PARAMETERS
  1222.  *  scr_id      [IN]        Screen index to be examined.
  1223.  * RETURNS
  1224.  *  TRUE if the screen is an IMPS screen; otherwise, FALSE.
  1225.  *****************************************************************************/
  1226. BOOL mmi_imps_util_is_imps_scr(U16 scr_id)
  1227. {
  1228.     /*----------------------------------------------------------------*/
  1229.     /* Local Variables                                                */
  1230.     /*----------------------------------------------------------------*/
  1232.     /*----------------------------------------------------------------*/
  1233.     /* Code Body                                                      */
  1234.     /*----------------------------------------------------------------*/
  1235.     if (scr_id > SCR_ID_IMPS_START && scr_id < SCR_ID_IMPS_END)
  1236.     {
  1237.         return TRUE;
  1238.     }
  1239.     else
  1240.     {
  1241.         return FALSE;
  1242.     }
  1243. }
  1246. /*****************************************************************************
  1247.  * FUNCTION
  1248.  *  mmi_imps_util_del_up_to_screen
  1249.  * DESCRIPTION
  1250.  *  Delete IMPS screens until scr_id
  1251.  * PARAMETERS
  1252.  *  scr_id      [IN]        Ending screen of deletion, this screen won't be deleted.
  1253.  * RETURNS
  1254.  *  void
  1255.  *****************************************************************************/
  1256. void mmi_imps_util_del_up_to_screen(U16 scr_id)
  1257. {
  1258.     /*----------------------------------------------------------------*/
  1259.     /* Local Variables                                                */
  1260.     /*----------------------------------------------------------------*/
  1261.     U16 next_scr;
  1263.     /*----------------------------------------------------------------*/
  1264.     /* Code Body                                                      */
  1265.     /*----------------------------------------------------------------*/
  1266.     while (GetNextScrnIdOf(scr_id, &next_scr))
  1267.     {
  1268.         if (mmi_imps_util_is_imps_scr(next_scr))
  1269.         {
  1270.             DeleteScreenIfPresent(next_scr);
  1271.         }
  1272.         else
  1273.         {
  1274.             return;
  1275.         }
  1276.     }
  1277. }
  1280. /*****************************************************************************
  1281.  * FUNCTION
  1282.  *  mmi_imps_util_go_back_2_hist
  1283.  * DESCRIPTION
  1284.  *  Go back to previosu 2 screen.
  1285.  * PARAMETERS
  1286.  *  void
  1287.  * RETURNS
  1288.  *  void
  1289.  *****************************************************************************/
  1290. void mmi_imps_util_go_back_2_hist(void)
  1291. {
  1292.     /*----------------------------------------------------------------*/
  1293.     /* Local Variables                                                */
  1294.     /*----------------------------------------------------------------*/
  1296.     /*----------------------------------------------------------------*/
  1297.     /* Code Body                                                      */
  1298.     /*----------------------------------------------------------------*/
  1299.     GoBacknHistory(1);
  1300. }
  1303. /*****************************************************************************
  1304.  * FUNCTION
  1305.  *  mmi_imps_util_del_scr_after_progress
  1306.  * DESCRIPTION
  1307.  *  Delete screen between progressing screen and result screen.
  1308.  *  Result screen is not included.
  1309.  * PARAMETERS
  1310.  *  result_scr      [IN]        
  1311.  * RETURNS
  1312.  *  void
  1313.  *****************************************************************************/
  1314. void mmi_imps_util_del_scr_after_progress(U16 result_scr)
  1315. {
  1316.     /*----------------------------------------------------------------*/
  1317.     /* Local Variables                                                */
  1318.     /*----------------------------------------------------------------*/
  1319.     U16 start_scr;
  1321.     /*----------------------------------------------------------------*/
  1322.     /* Code Body                                                      */
  1323.     /*----------------------------------------------------------------*/
  1324.     if(GetNextScrnIdOf(result_scr, &start_scr) == MMI_TRUE)
  1325.     {
  1326.         /* because the result screen might not be in histor, this will ensure the correctness */
  1327.         DeleteBetweenScreen(start_scr, SCR_ID_IMPS_PROGRESS);
  1328.     }
  1329.     else
  1330.     {
  1331.         DeleteScreenIfPresent(SCR_ID_IMPS_PROGRESS);
  1332.     }
  1333. }
  1335. #define BUFF_IMPS
  1338. /*****************************************************************************
  1339.  * FUNCTION
  1340.  *  mmi_imps_util_free_buff_when_logout
  1341.  * DESCRIPTION
  1342.  *  Free allocated buffers required after login
  1343.  * PARAMETERS
  1344.  *  void
  1345.  * RETURNS
  1346.  *  void
  1347.  *****************************************************************************/
  1348. void mmi_imps_util_free_buff_when_logout(void)
  1349. {
  1350.     /*----------------------------------------------------------------*/
  1351.     /* Local Variables                                                */
  1352.     /*----------------------------------------------------------------*/
  1354.     /*----------------------------------------------------------------*/
  1355.     /* Code Body                                                      */
  1356.     /*----------------------------------------------------------------*/
  1357.     /* free allocated buffer when logout automatically or manually */
  1359.     /* about me */
  1360.     mmi_imps_free_about_me_buff();
  1362.     /* search data */
  1363.     mmi_imps_free_search_mem();
  1365.     /* invitation */
  1366.     mmi_imps_invite_ind_free_mem();
  1367.     mmi_imps_free_invite_list();
  1369.     /* edit room */
  1370.     mmi_imps_free_room_mem();
  1371. }
  1374. /*****************************************************************************
  1375.  * FUNCTION
  1376.  *  mmi_imps_util_get_seq_no
  1377.  * DESCRIPTION
  1378.  *  Get sequence number of session
  1379.  * PARAMETERS
  1380.  *  void
  1381.  * RETURNS
  1382.  *  void
  1383.  *****************************************************************************/
  1384. S32 mmi_imps_util_get_seq_no(void)
  1385. {
  1386.     /*----------------------------------------------------------------*/
  1387.     /* Local Variables                                                */
  1388.     /*----------------------------------------------------------------*/
  1390.     /*----------------------------------------------------------------*/
  1391.     /* Code Body                                                      */
  1392.     /*----------------------------------------------------------------*/
  1393.     ++imps_p->gen_info.seq_no;
  1395.     if (imps_p->gen_info.seq_no > IMPS_MAX_SEQ_NUM)
  1396.     {
  1397.         imps_p->gen_info.seq_no = 1;
  1398.     }
  1400.     return imps_p->gen_info.seq_no;
  1401. }
  1403. #define STRING_IMPS
  1406. /*****************************************************************************
  1407.  * FUNCTION
  1408.  *  mmi_imps_util_copy_with_dot
  1409.  * DESCRIPTION
  1410.  *  Append three dots to the end of string
  1411.  * PARAMETERS
  1412.  *  source      [IN]            Source buffer.
  1413.  *  dest        [IN/OUT]        Destination buffer.
  1414.  *  max_len     [IN]            Max characters can be put in destination buffer , including NULL terminate
  1415.  * RETURNS
  1416.  *  void
  1417.  *****************************************************************************/
  1418. void mmi_imps_util_copy_with_dot(S8 *source, S8 *dest, S32 max_len)
  1419. {
  1420.     /*----------------------------------------------------------------*/
  1421.     /* Local Variables                                                */
  1422.     /*----------------------------------------------------------------*/
  1424.     /*----------------------------------------------------------------*/
  1425.     /* Code Body                                                      */
  1426.     /*----------------------------------------------------------------*/
  1427.     if (pfnUnicodeStrlen(source) < max_len)
  1428.     {
  1429.         pfnUnicodeStrcpy((S8*) dest, (S8*) source);
  1430.     }
  1431.     else
  1432.     {
  1433.         /* do not clear end of string because pfnUnicodeStrncpy will auto set NULL terminate */
  1434.         pfnUnicodeStrncpy((S8*) dest, (S8*) source, max_len - 4);
  1435.         pfnUnicodeStrcat((S8*) dest, (S8*) g_imps_three_dot);
  1436.     }
  1437. }
  1440. /*****************************************************************************
  1441.  * FUNCTION
  1442.  *  mmi_imps_util_ansi_2_ucs2_menu
  1443.  * DESCRIPTION
  1444.  *  Generate menu item from ASCII string
  1445.  * PARAMETERS
  1446.  *  source      [IN]            Source buffer.
  1447.  *  dest        [IN/OUT]        Destination buffer.
  1448.  *  max_len     [IN]            Max characters can be put in destination buffer
  1449.  * RETURNS
  1450.  *  void
  1451.  *****************************************************************************/
  1452. void mmi_imps_util_ansi_2_ucs2_menu(S8 *source, S8 *dest, S32 max_len)
  1453. {
  1454.     /*----------------------------------------------------------------*/
  1455.     /* Local Variables                                                */
  1456.     /*----------------------------------------------------------------*/
  1457.     S8 *tmp_buff = OslMalloc((IMPS_MAX_ID_LEN + 1) * ENCODING_LENGTH);
  1459.     /*----------------------------------------------------------------*/
  1460.     /* Code Body                                                      */
  1461.     /*----------------------------------------------------------------*/
  1462.     AnsiiToUnicodeString((S8*) tmp_buff, (S8*) source);
  1463.     mmi_imps_util_copy_with_dot((S8*) tmp_buff, (S8*) dest, max_len);
  1464.     OslMfree(tmp_buff);
  1465. }
  1468. /*****************************************************************************
  1469.  * FUNCTION
  1470.  *  mmi_imps_util_generate_name_hint
  1471.  * DESCRIPTION
  1472.  *  Generate hint value of a menu item
  1473.  * PARAMETERS
  1474.  *  source      [IN]        Source buffer.
  1475.  *  hint_id     [IN]        Index of hint
  1476.  *  max_len     [IN]        Max characters can be put in destination buffer
  1477.  * RETURNS
  1478.  *  void
  1479.  *****************************************************************************/
  1480. void mmi_imps_util_generate_name_hint(S8 *source, S32 hint_id, S32 max_len)
  1481. {
  1482.     /*----------------------------------------------------------------*/
  1483.     /* Local Variables                                                */
  1484.     /*----------------------------------------------------------------*/
  1486.     /*----------------------------------------------------------------*/
  1487.     /* Code Body                                                      */
  1488.     /*----------------------------------------------------------------*/
  1489.     if (pfnUnicodeStrlen(source))
  1490.     {
  1491.         mmi_imps_util_copy_with_dot((S8*) source, (S8*) hintData[hint_id], max_len);
  1492.         hintDataPtrs[hint_id] = hintData[hint_id];
  1493.     }
  1494.     else
  1495.     {
  1496.         hintDataPtrs[hint_id] = NULL;
  1497.     }
  1498. }
  1501. /*****************************************************************************
  1502.  * FUNCTION
  1503.  *  mmi_imps_util_is_group_name_valid
  1504.  * DESCRIPTION
  1505.  *  Check if the input user name string is allowable.
  1506.  *  A user name can only contains string between ASCII 0x20 ~ 0x7E
  1507.  *  The plus (+) character can only be placed before numeric character
  1508.  * PARAMETERS
  1509.  *  name        [IN]        String of input
  1510.  * RETURNS
  1511.  *  TRUE if the username string follows spec; otherwise, FALSE.
  1512.  *****************************************************************************/
  1513. BOOL mmi_imps_util_is_group_name_valid(S8 *name)
  1514. {
  1515.     /*----------------------------------------------------------------*/
  1516.     /* Local Variables                                                */
  1517.     /*----------------------------------------------------------------*/
  1518.     S8 *buff = OslMalloc(IMPS_MAX_ID_LEN);
  1519.     S32 i, len;
  1520.     S32 at_count = 0;   /* count of @ symbol */
  1522.     /*----------------------------------------------------------------*/
  1523.     /* Code Body                                                      */
  1524.     /*----------------------------------------------------------------*/
  1525.     UnicodeToAnsii((S8*) buff, (S8*) name);
  1527.     len = strlen(buff);
  1529.     /* scan each byte */
  1530.     for (i = 0; i < len; i++)
  1531.     {
  1532.         if (buff[i] <= 0x20 || buff[i] > 0x7E)  /* 0x20 == linear white space */
  1533.         {
  1534.             break;
  1535.         }
  1536.         else if (buff[i] == '/')    /* 0x2F */
  1537.         {
  1538.             break;
  1539.         }
  1540.         else if (buff[i] == '@')    /* can contain only 1 @ */
  1541.         {
  1542.             if (!at_count)
  1543.             {
  1544.                 at_count++;
  1545.             }
  1546.             else
  1547.             {
  1548.                 break;
  1549.             }
  1550.         }
  1551.     }
  1553.     OslMfree(buff);
  1555.     if (i == len)   /* all characters scanned */
  1556.     {
  1557.         return TRUE;
  1558.     }
  1559.     else
  1560.     {
  1561.         return FALSE;
  1562.     }
  1563. }
  1566. /*****************************************************************************
  1567.  * FUNCTION
  1568.  *  mmi_imps_util_is_username_valid
  1569.  * DESCRIPTION
  1570.  *  Check if the input user name string is allowable.
  1571.  *  A user name can only contains string between ASCII 0x20 ~ 0x7E
  1572.  *  The plus (+) character can only be placed before numeric character
  1573.  * PARAMETERS
  1574.  *  name        [IN]        String of input
  1575.  * RETURNS
  1576.  *  TRUE if the username string follows spec; otherwise, FALSE.
  1577.  *****************************************************************************/
  1578. BOOL mmi_imps_util_is_username_valid(S8 *name)
  1579. {
  1580.     /*----------------------------------------------------------------*/
  1581.     /* Local Variables                                                */
  1582.     /*----------------------------------------------------------------*/
  1583.     S8 *buff = OslMalloc(IMPS_MAX_ID_LEN);
  1584.     S32 i, len;
  1585.     S32 at_count = 0;   /* count of @ symbol */
  1586.     S32 plus_count = 0; /* if it's numeric plus */
  1587.     S32 num_count = 0;  /* count of numeric value */
  1589.     /*----------------------------------------------------------------*/
  1590.     /* Code Body                                                      */
  1591.     /*----------------------------------------------------------------*/
  1592.     UnicodeToAnsii((S8*) buff, (S8*) name);
  1594.     len = strlen(buff);
  1596.     if (len == 3 && mmi_imps_util_stricmp((S8*) "wv:", (S8*) buff) == 0)
  1597.     {
  1598.         return FALSE;
  1599.     }
  1601.     /* scan each byte */
  1602.     for (i = 0; i < len; i++)
  1603.     {
  1604.         if (buff[i] <= 0x20 || buff[i] > 0x7E)  /* 0x20 == linear white space */
  1605.         {
  1606.             break;
  1607.         }
  1608.         else if (buff[i] == '/')    /* 0x2F */
  1609.         {
  1610.             break;
  1611.         }
  1612.         else if (buff[i] == '+')
  1613.         {
  1614.             if (!plus_count)
  1615.             {
  1616.                 plus_count++;
  1617.             }
  1618.             else
  1619.             {
  1620.                 break;
  1621.             }
  1622.         }
  1623.         else if (buff[i] == '@')    /* can contain only 1 @ */
  1624.         {
  1625.             if (!at_count)
  1626.             {
  1627.                 at_count++;
  1628.             }
  1629.             else
  1630.             {
  1631.                 break;
  1632.             }
  1633.         }
  1634.         else if (buff[i] >= 0x30 && buff[i] <= 0x39)
  1635.         {
  1636.             num_count++;
  1637.         }
  1638.     }
  1640.     OslMfree(buff);
  1642.     /* check if the user name is wv:+12324454545 */
  1643.     if (plus_count)
  1644.     {
  1645.         if ((plus_count > 1) || (strncmp((S8*) buff, (S8*) "wv:+", 4) != 0))
  1646.         {
  1647.             return FALSE;
  1648.         }
  1649.         else if (num_count != (len - 4))    /* it's not a username like wv:+009099090 (all numberic characters) */
  1650.         {
  1651.             return FALSE;
  1652.         }
  1653.     }
  1655.     if (i == len)   /* all characters scanned */
  1656.     {
  1657.         return TRUE;
  1658.     }
  1659.     else
  1660.     {
  1661.         return FALSE;
  1662.     }
  1663. }
  1666. /*****************************************************************************
  1667.  * FUNCTION
  1668.  *  mmi_imps_util_append_wv
  1669.  * DESCRIPTION
  1670.  *  Check if "wv:" string contains in the string.
  1671.  *  If not, append it.
  1672.  * PARAMETERS
  1673.  *  dest        [OUT]       Buffer to be checked andappended.
  1674.  *  max_len     [IN]        Max length of buffer
  1675.  * RETURNS
  1676.  *  TRUE if the username string follows spec; otherwise, FALSE.(?)
  1677.  *****************************************************************************/
  1678. void mmi_imps_util_append_wv(S8 *dest, S32 max_len)
  1679. {
  1680.     /*----------------------------------------------------------------*/
  1681.     /* Local Variables                                                */
  1682.     /*----------------------------------------------------------------*/
  1683.     S8 *buff = OslMalloc(IMPS_MAX_ID_LEN * ENCODING_LENGTH);
  1685.     /*----------------------------------------------------------------*/
  1686.     /* Code Body                                                      */
  1687.     /*----------------------------------------------------------------*/
  1688.     if (pfnUnicodeStrlen(dest) < (max_len - 3)) /* minus length of "wv:" */
  1689.     {
  1690.         UnicodeNToAnsii(buff, (S8*) dest, 3 * ENCODING_LENGTH);
  1691.         if (mmi_imps_util_strnicmp((S8*) "wv:", buff, 3) != 0) /* no "wv:" */
  1692.         {
  1693.             pfnUnicodeStrcpy((S8*) buff, (S8*) L"wv:");
  1694.             pfnUnicodeStrcat((S8*) buff, (S8*) dest);
  1695.             pfnUnicodeStrcpy((S8*) dest, (S8*) buff);
  1696.         }
  1697.     }
  1699.     OslMfree(buff);
  1700. }
  1703. /*****************************************************************************
  1704.  * FUNCTION
  1705.  *  mmi_imps_util_tolower
  1706.  * DESCRIPTION
  1707.  *  Convert a charcater to lower case
  1708.  * PARAMETERS
  1709.  *  ch      [IN]        Charcater to be converted
  1710.  * RETURNS
  1711.  *  lower case character
  1712.  *****************************************************************************/
  1713. U8 mmi_imps_util_tolower(U8 ch)
  1714. {
  1715.     /*----------------------------------------------------------------*/
  1716.     /* Local Variables                                                */
  1717.     /*----------------------------------------------------------------*/
  1719.     /*----------------------------------------------------------------*/
  1720.     /* Code Body                                                      */
  1721.     /*----------------------------------------------------------------*/
  1722.     if (ch >= 'A' && ch <= 'Z')
  1723.     {
  1724.         return (U8) (ch + ('a' - 'A'));
  1725.     }
  1726.     return ch;
  1727. }
  1730. /*****************************************************************************
  1731.  * FUNCTION
  1732.  *  mmi_imps_util_strnicmp
  1733.  * DESCRIPTION
  1734.  *  Compare two string without case with maximum length
  1735.  * PARAMETERS
  1736.  *  src         [IN]        String pointer to be compared
  1737.  *  dest        [IN]        String pointer to be compared
  1738.  *  maxlen      [IN]        Lengh to be compared
  1739.  * RETURNS
  1740.  *  Ture if two string is identical, otherwise, false
  1741.  *****************************************************************************/
  1742. S8 mmi_imps_util_strnicmp(S8 *src, S8 *dest, S32 maxlen)
  1743. {
  1744.     /*----------------------------------------------------------------*/
  1745.     /* Local Variables                                                */
  1746.     /*----------------------------------------------------------------*/
  1747.     U8 ch1, ch2;
  1748.     S8 *s1, *s2;
  1750.     /*----------------------------------------------------------------*/
  1751.     /* Code Body                                                      */
  1752.     /*----------------------------------------------------------------*/
  1753.     s1 = src;
  1754.     s2 = dest;
  1756.     while (maxlen-- > 0)
  1757.     {
  1758.         ch1 = mmi_imps_util_tolower(*s1++);
  1759.         ch2 = mmi_imps_util_tolower(*s2++);
  1760.         if (ch1 != ch2)
  1761.         {
  1762.             return TRUE;
  1763.         }
  1764.     }
  1766.     return FALSE;
  1767. }
  1770. /*****************************************************************************
  1771.  * FUNCTION
  1772.  *  mmi_imps_util_stricmp
  1773.  * DESCRIPTION
  1774.  *  Compare two strings without case
  1775.  * PARAMETERS
  1776.  *  src         [IN]        String pointer to be compared
  1777.  *  dest        [IN]        String pointer to be compared
  1778.  * RETURNS
  1779.  *  Ture if two string is identical, otherwise, false
  1780.  *****************************************************************************/
  1781. S8 mmi_imps_util_stricmp(S8 *src, S8 *dest)
  1782. {
  1783.     /*----------------------------------------------------------------*/
  1784.     /* Local Variables                                                */
  1785.     /*----------------------------------------------------------------*/
  1786.     S32 len_src = strlen(src);
  1787.     S32 len_dest = strlen(dest);
  1789.     /*----------------------------------------------------------------*/
  1790.     /* Code Body                                                      */
  1791.     /*----------------------------------------------------------------*/
  1792.     if (len_src != len_dest)
  1793.     {
  1794.         return TRUE;
  1795.     }
  1796.     else
  1797.     {
  1798.         return mmi_imps_util_strnicmp(src, dest, len_src);
  1799.     }
  1800. }
  1802. #define UI_COMMON_IMPS
  1805. /*****************************************************************************
  1806.  * FUNCTION
  1807.  *  mmi_imps_util_blink_tab
  1808.  * DESCRIPTION
  1809.  *  Common function to blink/unblink tabs
  1810.  * PARAMETERS
  1811.  *  void
  1812.  * RETURNS
  1813.  *  void
  1814.  *****************************************************************************/
  1815. void mmi_imps_util_blink_tab(void)
  1816. {
  1817.     /*----------------------------------------------------------------*/
  1818.     /* Local Variables                                                */
  1819.     /*----------------------------------------------------------------*/
  1820.     S32 i;
  1822.     /*----------------------------------------------------------------*/
  1823.     /* Code Body                                                      */
  1824.     /*----------------------------------------------------------------*/
  1825.     for (i = 0; i < IMPS_MAX_NO_ROOM; i++)
  1826.     {
  1827.         mmi_imps_room_struct *room = &imps_p->room_info.room_list[i];
  1829.         if (room->is_used)
  1830.         {
  1831.             if (room->unread_msg)
  1832.             {
  1833.                 Category425BlinkTab(room->tab_index);
  1834.             }
  1835.             else
  1836.             {
  1837.                 Category425UnBlinkTab(room->tab_index);
  1838.             }
  1839.         }
  1840.     }
  1841. }
  1844. /*****************************************************************************
  1845.  * FUNCTION
  1846.  *  mmi_imps_util_search_cont
  1847.  * DESCRIPTION
  1848.  *  Search contact according to his id
  1849.  * PARAMETERS
  1850.  *  id      [?]     To be search
  1851.  * RETURNS
  1852.  *  buffer that store the context of the contact
  1853.  *****************************************************************************/
  1854. mmi_imps_cont_struct *mmi_imps_util_search_cont(S8 *id)
  1855. {
  1856.     /*----------------------------------------------------------------*/
  1857.     /* Local Variables                                                */
  1858.     /*----------------------------------------------------------------*/
  1859.     S32 i, count;
  1861.     /*----------------------------------------------------------------*/
  1862.     /* Code Body                                                      */
  1863.     /*----------------------------------------------------------------*/
  1864.     count = (S32) imps_p->cont_info.no_cont;
  1866.     for (i = 0; i < count; i++)
  1867.         if (mmi_imps_util_is_id_same((S8*) id, (S8*) imps_p->cont_info.cont_list[i].id))      /* contact found */
  1868.         {
  1869.             return &imps_p->cont_info.cont_list[i];
  1870.         }
  1872.     return NULL;
  1873. }
  1876. /*****************************************************************************
  1877.  * FUNCTION
  1878.  *  mmi_imps_util_update_status_icon
  1879.  * DESCRIPTION
  1880.  *  Update status icon when new message comes
  1881.  * PARAMETERS
  1882.  *  void
  1883.  * RETURNS
  1884.  *  void
  1885.  *****************************************************************************/
  1886. void mmi_imps_util_update_status_icon(void)
  1887. {
  1888.     /*----------------------------------------------------------------*/
  1889.     /* Local Variables                                                */
  1890.     /*----------------------------------------------------------------*/
  1891.     S32 i;
  1893.     /*----------------------------------------------------------------*/
  1894.     /* Code Body                                                      */
  1895.     /*----------------------------------------------------------------*/
  1896.     for (i = 0; i < IMPS_MAX_NO_ROOM; i++)
  1897.     {
  1898.         mmi_imps_room_struct *room = &imps_p->room_info.room_list[i];
  1900.         if (room->is_used)
  1901.         {
  1902.             /* still some message there */
  1903.             if (room->unread_msg)
  1904.             {
  1905.                 BlinkStatusIcon(STATUS_ICON_IMPS_MSG);
  1906.                 UpdateStatusIcons();
  1907.                 return;
  1908.             }
  1909.         }
  1910.     }
  1912.     IdleResetStatusIcon(STATUS_ICON_IMPS_MSG);  /* reset message status icon */
  1914.     if (imps_p->gen_info.is_login)
  1915.     {
  1916.         IdleSetStatusIcon(STATUS_ICON_IMPS_LOGIN);
  1917.     }
  1918. }
  1921. /*****************************************************************************
  1922.  * FUNCTION
  1923.  *  mmi_imps_util_update_login_icon
  1924.  * DESCRIPTION
  1925.  *  Update status icon when login state changed
  1926.  * PARAMETERS
  1927.  *  void
  1928.  * RETURNS
  1929.  *  void
  1930.  *****************************************************************************/
  1931. void mmi_imps_util_update_login_icon(void)
  1932. {
  1933.     /*----------------------------------------------------------------*/
  1934.     /* Local Variables                                                */
  1935.     /*----------------------------------------------------------------*/
  1937.     /*----------------------------------------------------------------*/
  1938.     /* Code Body                                                      */
  1939.     /*----------------------------------------------------------------*/
  1940.     if (imps_p->gen_info.is_login)
  1941.     {
  1942.         IdleSetStatusIcon(STATUS_ICON_IMPS_LOGIN);
  1943.     }
  1944.     else
  1945.     {
  1946.         IdleResetStatusIcon(STATUS_ICON_IMPS_MSG);  /* reset message status icon */
  1947.         IdleResetStatusIcon(STATUS_ICON_IMPS_LOGIN);
  1948.     }
  1949. }
  1952. /*****************************************************************************
  1953.  * FUNCTION
  1954.  *  mmi_imps_util_disp_popup_done
  1955.  * DESCRIPTION
  1956.  *  Common function to display "Done" in popup screen
  1957.  * PARAMETERS
  1958.  *  void
  1959.  * RETURNS
  1960.  *  void
  1961.  *****************************************************************************/
  1962. void mmi_imps_util_disp_popup_done(void)
  1963. {
  1964.     /*----------------------------------------------------------------*/
  1965.     /* Local Variables                                                */
  1966.     /*----------------------------------------------------------------*/
  1968.     /*----------------------------------------------------------------*/
  1969.     /* Code Body                                                      */
  1970.     /*----------------------------------------------------------------*/
  1971.     TurnOnBacklight(TRUE);
  1972.     DisplayPopup(
  1973.         (U8*) GetString(STR_GLOBAL_DONE),
  1974.         IMG_GLOBAL_ACTIVATED,
  1975.         1,
  1976.         UI_POPUP_NOTIFYDURATION_TIME,
  1977.         (U8) SUCCESS_TONE);
  1978. }
  1981. /*****************************************************************************
  1982.  * FUNCTION
  1983.  *  mmi_imps_util_disp_warning_popup
  1984.  * DESCRIPTION
  1985.  *  Common function to display warning popup
  1986.  * PARAMETERS
  1987.  *  str_id      [IN]        Id of string to be displayed
  1988.  * RETURNS
  1989.  *  void
  1990.  *****************************************************************************/
  1991. void mmi_imps_util_disp_warning_popup(U16 str_id)
  1992. {
  1993.     /*----------------------------------------------------------------*/
  1994.     /* Local Variables                                                */
  1995.     /*----------------------------------------------------------------*/
  1997.     /*----------------------------------------------------------------*/
  1998.     /* Code Body                                                      */
  1999.     /*----------------------------------------------------------------*/
  2000.     TurnOnBacklight(TRUE);
  2002.     DisplayPopup((U8*) GetString(str_id), IMG_GLOBAL_WARNING, 1, UI_POPUP_NOTIFYDURATION_TIME, (U8) WARNING_TONE);
  2003. }
  2006. /*****************************************************************************
  2007.  * FUNCTION
  2008.  *  mmi_imps_util_disp_err_popup
  2009.  * DESCRIPTION
  2010.  *  Common function to display error popup
  2011.  * PARAMETERS
  2012.  *  str_id      [IN]        Id of string to be displayed
  2013.  * RETURNS
  2014.  *  void
  2015.  *****************************************************************************/
  2016. void mmi_imps_util_disp_err_popup(U16 str_id)
  2017. {
  2018.     /*----------------------------------------------------------------*/
  2019.     /* Local Variables                                                */
  2020.     /*----------------------------------------------------------------*/
  2022.     /*----------------------------------------------------------------*/
  2023.     /* Code Body                                                      */
  2024.     /*----------------------------------------------------------------*/
  2025.     TurnOnBacklight(TRUE);
  2027.     DisplayPopup((U8*) GetString(str_id), IMG_GLOBAL_ERROR, 1, UI_POPUP_NOTIFYDURATION_TIME, (U8) ERROR_TONE);
  2028. }
  2031. /*****************************************************************************
  2032.  * FUNCTION
  2033.  *  mmi_imps_util_disp_empty_popup
  2034.  * DESCRIPTION
  2035.  *  Common function to display empty popup
  2036.  * PARAMETERS
  2037.  *  void
  2038.  * RETURNS
  2039.  *  void
  2040.  *****************************************************************************/
  2041. void mmi_imps_util_disp_empty_popup(void)
  2042. {
  2043.     /*----------------------------------------------------------------*/
  2044.     /* Local Variables                                                */
  2045.     /*----------------------------------------------------------------*/
  2047.     /*----------------------------------------------------------------*/
  2048.     /* Code Body                                                      */
  2049.     /*----------------------------------------------------------------*/
  2050.     TurnOnBacklight(TRUE);
  2052.     DisplayPopup((PU8) GetString(STR_GLOBAL_EMPTY_LIST), IMG_GLOBAL_EMPTY, 0, UI_POPUP_NOTIFYDURATION_TIME, ERROR_TONE);
  2053. }
  2056. /*****************************************************************************
  2057.  * FUNCTION
  2058.  *  mmi_imps_util_is_on_idle
  2059.  * DESCRIPTION
  2060.  *  Check if the user is currently on IDLE screen.
  2061.  *  Add this function is to prevent too much include files in other files of IMPS
  2062.  * PARAMETERS
  2063.  *  void
  2064.  * RETURNS
  2065.  *  IsOnIdleScreen flag in the global context of IDLE screen.
  2066.  *****************************************************************************/
  2067. U8 mmi_imps_util_is_on_idle(void)
  2068. {
  2069.     /*----------------------------------------------------------------*/
  2070.     /* Local Variables                                                */
  2071.     /*----------------------------------------------------------------*/
  2073.     /*----------------------------------------------------------------*/
  2074.     /* Code Body                                                      */
  2075.     /*----------------------------------------------------------------*/
  2076.     return g_idle_context.IsOnIdleScreen;
  2077. }
  2079. #define TAB_IMPS
  2082. /*****************************************************************************
  2083.  * FUNCTION
  2084.  *  mmi_imps_tab_init
  2085.  * DESCRIPTION
  2086.  *  Initialize tab component
  2087.  * PARAMETERS
  2088.  *  void
  2089.  * RETURNS
  2090.  *  void
  2091.  *****************************************************************************/
  2092. void mmi_imps_tab_init(void)
  2093. {
  2094.     /*----------------------------------------------------------------*/
  2095.     /* Local Variables                                                */
  2096.     /*----------------------------------------------------------------*/
  2097.     S32 i, count;
  2098.     mmi_imps_room_struct *room;
  2100.     /*----------------------------------------------------------------*/
  2101.     /* Code Body                                                      */
  2102.     /*----------------------------------------------------------------*/
  2103.     MMI_tab_bar_items[0].icon = (PU8) GetImage(IMG_ID_IMPS_CONT_LIST);
  2104.     MMI_tab_bar_items[0].text = NULL;
  2105.     MMI_tab_bar_items[0].flags = 0;
  2107.     count = (S32) imps_p->room_info.no_rooms;
  2109.     for (i = 0; i < IMPS_MAX_NO_ROOM; i++)
  2110.     {
  2111.         room = &imps_p->room_info.room_list[i];
  2112.         if (room->is_used)
  2113.         {
  2114.             S32 tab = (S32) room->tab_index;
  2116.             if (room->type == IMPS_ROOM_TYPE_SINGLE)
  2117.             {
  2118.                 MMI_tab_bar_items[tab].icon = (PU8) GetImage(IMG_ID_IMPS_TALK);
  2119.             }
  2120.             else
  2121.             {
  2122.                 MMI_tab_bar_items[tab].icon = (PU8) GetImage(IMG_ID_IMPS_CHAT_ROOM);
  2123.             }
  2125.             MMI_tab_bar_items[tab].text = NULL;
  2126.             MMI_tab_bar_items[tab].flags = 0;
  2127.         }
  2128.     }
  2129. }
  2132. /*****************************************************************************
  2133.  * FUNCTION
  2134.  *  mmi_imps_tab_jump_current
  2135.  * DESCRIPTION
  2136.  *  Jump to current tab
  2137.  * PARAMETERS
  2138.  *  void
  2139.  * RETURNS
  2140.  *  void
  2141.  *****************************************************************************/
  2142. void mmi_imps_tab_jump_current(void)
  2143. {
  2144.     /*----------------------------------------------------------------*/
  2145.     /* Local Variables                                                */
  2146.     /*----------------------------------------------------------------*/
  2147.     S32 i;
  2149.     /*----------------------------------------------------------------*/
  2150.     /* Code Body                                                      */
  2151.     /*----------------------------------------------------------------*/
  2152.     for (i = 0; i < IMPS_MAX_NO_ROOM; i++)
  2153.         if (imps_p->room_info.room_list[i].is_used)
  2154.             if (imps_p->room_info.room_list[i].tab_index == imps_p->gen_info.curr_tab)
  2155.             {
  2156.                 imps_p->chat_info.curr_room = (U8) i;
  2157.                 break;
  2158.             }
  2160.     imps_p->room_info.room_list[imps_p->chat_info.curr_room].clear_gui_buff = TRUE;
  2162.     mmi_imps_entry_chat();
  2163.     DeleteScreenIfPresent(SCR_ID_IMPS_CONT);
  2164.     DeleteScreenIfPresent(SCR_ID_IMPS_CHAT);
  2165. }
  2168. /*****************************************************************************
  2169.  * FUNCTION
  2170.  *  mmi_imps_tab_del
  2171.  * DESCRIPTION
  2172.  *  Swap to previous tab
  2173.  * PARAMETERS
  2174.  *  tab_index       [IN]        Index of tab to be removed.
  2175.  *  hilite          [IN]        Hilited tab after removed.
  2176.  * RETURNS
  2177.  *  void
  2178.  *****************************************************************************/
  2179. void mmi_imps_tab_del(U8 tab_index, U8 hilite)
  2180. {
  2181.     /*----------------------------------------------------------------*/
  2182.     /* Local Variables                                                */
  2183.     /*----------------------------------------------------------------*/
  2184.     S32 i;
  2186.     /*----------------------------------------------------------------*/
  2187.     /* Code Body                                                      */
  2188.     /*----------------------------------------------------------------*/
  2189.     for (i = 0; i < IMPS_MAX_NO_ROOM; i++)
  2190.     {
  2191.         mmi_imps_room_struct *room = &imps_p->room_info.room_list[i];
  2193.         if (room->is_used)
  2194.         {
  2195.             if (imps_p->room_info.room_list[i].tab_index > tab_index)
  2196.             {
  2197.                 /* current tab is the tab to be hilite */
  2198.                 if (imps_p->room_info.room_list[i].tab_index == hilite && hilite)
  2199.                 {
  2200.                     hilite--;
  2201.                 }
  2202.                 imps_p->room_info.room_list[i].tab_index--;
  2203.             }
  2204.         }
  2205.     }
  2206.     imps_p->gen_info.no_tab--;
  2207.     imps_p->gen_info.curr_tab = hilite;
  2208. }
  2211. /*****************************************************************************
  2212.  * FUNCTION
  2213.  *  mmi_imps_tab_prev
  2214.  * DESCRIPTION
  2215.  *  Swap to previous tab
  2216.  * PARAMETERS
  2217.  *  void
  2218.  * RETURNS
  2219.  *  void
  2220.  *****************************************************************************/
  2221. void mmi_imps_tab_prev(void)
  2222. {
  2223.     /*----------------------------------------------------------------*/
  2224.     /* Local Variables                                                */
  2225.     /*----------------------------------------------------------------*/
  2227.     /*----------------------------------------------------------------*/
  2228.     /* Code Body                                                      */
  2229.     /*----------------------------------------------------------------*/
  2230.     if (imps_p->gen_info.no_tab == 1)
  2231.     {
  2232.         return;
  2233.     }
  2235.     if (imps_p->gen_info.curr_tab == 0)
  2236.     {
  2237.         imps_p->gen_info.curr_tab = imps_p->gen_info.no_tab - 1;
  2238.     }
  2239.     else
  2240.     {
  2241.         imps_p->gen_info.curr_tab--;
  2242.     }
  2244.     if (imps_p->gen_info.curr_tab == 0)
  2245.     {
  2246.         mmi_imps_pre_entry_cont();
  2247.     }
  2248.     else
  2249.     {
  2250.         mmi_imps_tab_jump_current();
  2251.     }
  2252. }
  2255. /*****************************************************************************
  2256.  * FUNCTION
  2257.  *  mmi_imps_tab_next
  2258.  * DESCRIPTION
  2259.  *  Swap to next tab
  2260.  * PARAMETERS
  2261.  *  void
  2262.  * RETURNS
  2263.  *  void
  2264.  *****************************************************************************/
  2265. void mmi_imps_tab_next(void)
  2266. {
  2267.     /*----------------------------------------------------------------*/
  2268.     /* Local Variables                                                */
  2269.     /*----------------------------------------------------------------*/
  2271.     /*----------------------------------------------------------------*/
  2272.     /* Code Body                                                      */
  2273.     /*----------------------------------------------------------------*/
  2274.     if (imps_p->gen_info.no_tab == 1)
  2275.     {
  2276.         return;
  2277.     }
  2279.     if (imps_p->gen_info.curr_tab == (imps_p->gen_info.no_tab - 1))
  2280.     {
  2281.         imps_p->gen_info.curr_tab = 0;
  2282.     }
  2283.     else
  2284.     {
  2285.         imps_p->gen_info.curr_tab++;
  2286.     }
  2288.     if (imps_p->gen_info.curr_tab == 0)
  2289.     {
  2290.         mmi_imps_pre_entry_cont();
  2291.     }
  2292.     else
  2293.     {
  2294.         mmi_imps_tab_jump_current();
  2295.     }
  2296. }
  2299. /*****************************************************************************
  2300.  * FUNCTION
  2301.  *  mmi_imps_tab_jump
  2302.  * DESCRIPTION
  2303.  *  Jump to tab by index
  2304.  * PARAMETERS
  2305.  *  index       [IN]        
  2306.  * RETURNS
  2307.  *  void
  2308.  *****************************************************************************/
  2309. void mmi_imps_tab_jump(int index)
  2310. {
  2311.     /*----------------------------------------------------------------*/
  2312.     /* Local Variables                                                */
  2313.     /*----------------------------------------------------------------*/
  2315.     /*----------------------------------------------------------------*/
  2316.     /* Code Body                                                      */
  2317.     /*----------------------------------------------------------------*/
  2318.     if (imps_p->gen_info.no_tab == 1)
  2319.     {
  2320.         return;
  2321.     }
  2323.     if (index >= imps_p->gen_info.no_tab)
  2324.     {
  2325.         return;
  2326.     }
  2328.     imps_p->gen_info.curr_tab = index;
  2330.     if (imps_p->gen_info.curr_tab == 0)
  2331.     {
  2332.         mmi_imps_pre_entry_cont();
  2333.     }
  2334.     else
  2335.     {
  2336.         mmi_imps_tab_jump_current();
  2337.     }
  2338. }
  2341. /*****************************************************************************
  2342.  * FUNCTION
  2343.  *  mmi_imps_tab_redraw
  2344.  * DESCRIPTION
  2345.  *  Redraw tab
  2346.  * PARAMETERS
  2347.  *  scr_id      [IN]        Current index of screen
  2348.  * RETURNS
  2349.  *  void
  2350.  *****************************************************************************/
  2351. void mmi_imps_tab_redraw(U16 scr_id)
  2352. {
  2353.     /*----------------------------------------------------------------*/
  2354.     /* Local Variables                                                */
  2355.     /*----------------------------------------------------------------*/
  2357.     /*----------------------------------------------------------------*/
  2358.     /* Code Body                                                      */
  2359.     /*----------------------------------------------------------------*/
  2360.     if (scr_id == SCR_ID_IMPS_CONT)
  2361.     {
  2362.         mmi_imps_tab_init();
  2363.         UpdateCategory425TabBar(NULL, (S8) imps_p->gen_info.no_tab, (S8) imps_p->gen_info.curr_tab, MMI_tab_bar_items);
  2365.         /* reset all blinking/unblinking status */
  2366.         mmi_imps_util_blink_tab();
  2367.     }
  2368.     else if (scr_id == SCR_ID_IMPS_CHAT)
  2369.     {
  2370.         mmi_imps_tab_init();
  2371.         UpdateCategory435TabBar(NULL, (S8) imps_p->gen_info.no_tab, (S8) imps_p->gen_info.curr_tab, MMI_tab_bar_items);
  2372.         /* reset all blinking/unblinking status */
  2373.         mmi_imps_util_blink_tab();
  2374.     }
  2375. }
  2378. /*****************************************************************************
  2379.  * FUNCTION
  2380.  *  mmi_imps_tab_update_event
  2381.  * DESCRIPTION
  2382.  *  Update tab related screen when interrupt event comes
  2383.  * PARAMETERS
  2384.  *  room        [IN]        Room in which the event comes.
  2385.  *  entity      [IN]        Contact that related to the event
  2386.  * RETURNS
  2387.  *  void
  2388.  *****************************************************************************/
  2389. void mmi_imps_tab_update_event(mmi_imps_room_struct *room, imps_entity_struct *entity)
  2390. {
  2391.     /*----------------------------------------------------------------*/
  2392.     /* Local Variables                                                */
  2393.     /*----------------------------------------------------------------*/
  2394.     U16 active_scr = GetActiveScreenId();
  2396.     /*----------------------------------------------------------------*/
  2397.     /* Code Body                                                      */
  2398.     /*----------------------------------------------------------------*/
  2399.     /* in multi-tab screen */
  2400.     if (active_scr == SCR_ID_IMPS_CHAT || active_scr == SCR_ID_IMPS_CONT)
  2401.     {
  2402.         if (imps_p->gen_info.curr_tab == room->tab_index && active_scr == SCR_ID_IMPS_CHAT)
  2403.         {
  2404.             /* flush data */
  2405.             UpdateCategory435LogText((U8*) room->chat_buff, pfnUnicodeStrlen((S8*) room->chat_buff));
  2406.         }
  2407.         else
  2408.         {
  2409.             /* blink tab */
  2410.             Category425BlinkTab(room->tab_index);
  2411.             room->unread_msg = TRUE;
  2412.             mmi_imps_cont_update_when_msg_come(entity);
  2413.         }
  2414.     }
  2415.     else
  2416.     {
  2417.         /* update contact list for new message comes */
  2418.         room->unread_msg = TRUE;
  2419.         mmi_imps_cont_update_when_msg_come(entity);
  2420.     }
  2422.     mmi_imps_util_update_status_icon();
  2423. }
  2425. #define TONE_IMPS
  2428. /*****************************************************************************
  2429.  * FUNCTION
  2430.  *  mmi_imps_util_play_tone
  2431.  * DESCRIPTION
  2432.  *  General function to play tone and vibration for incoming event.
  2433.  * PARAMETERS
  2434.  *  tone_type       [IN]        Type of message
  2435.  * RETURNS
  2436.  *  void
  2437.  *****************************************************************************/
  2438. void mmi_imps_util_play_tone(U8 tone_type)
  2439. {
  2440.     /*----------------------------------------------------------------*/
  2441.     /* Local Variables                                                */
  2442.     /*----------------------------------------------------------------*/
  2443.     BOOL is_in_imps = mmi_imps_util_is_in_imps();
  2444.     BOOL is_silent = IsSilentModeActivated();
  2445.     BOOL is_meeting = IsMeetingModeActivated();
  2447.     /*----------------------------------------------------------------*/
  2448.     /* Code Body                                                      */
  2449.     /*----------------------------------------------------------------*/
  2450.     if (isInCall() == FALSE)
  2451.     {
  2452.         if (!is_silent && !is_meeting)
  2453.         {
  2454.             if (is_in_imps || g_idle_context.IsOnIdleScreen == TRUE)
  2455.             {
  2456.                 if (tone_type == IMPS_MSG_TONE)
  2457.                 {
  2458.                     mdi_audio_play_string(
  2459.                         (void*)g_imps_msg_tone,
  2460.                         sizeof(g_imps_msg_tone),
  2461.                         MDI_FORMAT_SMF,
  2462.                         DEVICE_AUDIO_PLAY_ONCE,
  2463.                         NULL,
  2464.                         NULL);
  2465.                 }
  2466.                 else
  2467.                 {
  2468.                     mdi_audio_play_string(
  2469.                         (void*)g_imps_err_tone,
  2470.                         sizeof(g_imps_err_tone),
  2471.                         MDI_FORMAT_SMF,
  2472.                         DEVICE_AUDIO_PLAY_ONCE,
  2473.                         NULL,
  2474.                         NULL);
  2475.                 }
  2476.             }
  2477.         }
  2478.         else
  2479.         {
  2480.             if (is_in_imps || g_idle_context.IsOnIdleScreen == TRUE)
  2481.             {
  2482.                 PlayVibratorOnce();
  2483.             }
  2484.         }
  2485.     }
  2486.     else
  2487.     {
  2488.         if (!is_silent && !is_meeting)
  2489.         {
  2490.             playRequestedTone(SMS_IN_CALL_TONE);
  2491.         }
  2492.     }
  2493. }
  2496. /*****************************************************************************
  2497.  * FUNCTION
  2498.  *  mmi_imps_util_find_room
  2499.  * DESCRIPTION
  2500.  *  Find out the location of chat room in the list buffer according to its room id
  2501.  * PARAMETERS
  2502.  *  room_id     [IN]        Id of the room
  2503.  * RETURNS
  2504.  *  index of chat room in the list buffer
  2505.  *****************************************************************************/
  2506. S32 mmi_imps_util_find_room(S8 *room_id)
  2507. {
  2508.     /*----------------------------------------------------------------*/
  2509.     /* Local Variables                                                */
  2510.     /*----------------------------------------------------------------*/
  2511.     S32 i;
  2513.     /*----------------------------------------------------------------*/
  2514.     /* Code Body                                                      */
  2515.     /*----------------------------------------------------------------*/
  2516.     for (i = 0; i < IMPS_MAX_NO_ROOM; i++)
  2517.         if (mmi_imps_util_stricmp((S8*) imps_p->room_info.room_list[i].room_id, room_id) == 0)
  2518.         {
  2519.             break;
  2520.         }
  2521.     return i;
  2522. }
  2525. /*****************************************************************************
  2526.  * FUNCTION
  2527.  *  mmi_imps_util_find_cont
  2528.  * DESCRIPTION
  2529.  *  Find out the location of chat room in the list buffer according to its room id
  2530.  * PARAMETERS
  2531.  *  cont_id         [?]         
  2532.  *  room_id(?)      [IN]        Id of the room
  2533.  * RETURNS
  2534.  *  index of chat room in the list buffer
  2535.  *****************************************************************************/
  2536. S32 mmi_imps_util_find_cont(S8 *cont_id)
  2537. {
  2538.     /*----------------------------------------------------------------*/
  2539.     /* Local Variables                                                */
  2540.     /*----------------------------------------------------------------*/
  2541.     S32 i;
  2543.     /*----------------------------------------------------------------*/
  2544.     /* Code Body                                                      */
  2545.     /*----------------------------------------------------------------*/
  2546.     /* find contact */
  2547.     for (i = 0; i < imps_p->cont_info.no_cont; i++)
  2548.         if (mmi_imps_util_is_id_same((S8*) imps_p->cont_info.cont_list[i].id, (S8*) cont_id))
  2549.         {
  2550.             break;
  2551.         }
  2553.     return i;
  2554. }
  2555. #endif /* __MMI_IMPS__ */ /* #ifdef __MMI_IMPS__ */
  2556. #endif /* _MMI_IMPS_UTIL_C */