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

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

MTK

开发平台：

C/C++

SMSUtil.c：源码内容
  1.         return TRUE;
  2.     }
  3.     while (dataindex != MMI_FRM_SMS_INVALID_NUM)
  4.     {
  5.         /* if mmi_frm_sms_content is full */
  6.         if (dataindex == MMI_FRM_SMS_MSG_CONTENT_NUM)
  7.         {
  8.             return TRUE;
  9.         }
  10.         if (mmi_frm_sms_content[dataindex].segment != (i + 1))
  11.         {
  12.             return FALSE;
  13.         }
  14.         dataindex = mmi_frm_sms_content[dataindex].nextindex;
  15.         i++;
  16.     }
  17.     if (i == total_seg)
  18.     {
  19.         return TRUE;
  20.     }
  21.     else
  22.     {
  23.         return FALSE;
  24.     }
  25. }
  28. /*****************************************************************************
  29.  * FUNCTION
  30.  *  mmi_frm_sms_check_awaited_complete_msg
  31.  * DESCRIPTION
  32.  *  Check awaited message completeness , excluding mmi_frm_sms_content full
  33.  * PARAMETERS
  34.  *  index       [IN]        Index
  35.  * RETURNS
  36.  *  void
  37.  *****************************************************************************/
  38. U8 mmi_frm_sms_check_awaited_complete_msg(U8 index)
  39. {
  40.     /*----------------------------------------------------------------*/
  41.     /* Local Variables                                                */
  42.     /*----------------------------------------------------------------*/
  43.     U8 i = 0;
  44.     mmi_frm_sms_concat_struct *concat_info = (mmi_frm_sms_concat_struct*) & (mmi_frm_sms_awaited[index].concat_info);
  45.     U8 total_seg = ((concat_info->total_seg - concat_info->seg + 1) > g_frm_sms_cntx.mmi_frm_sms_msg_seg_size) ?
  46.         g_frm_sms_cntx.mmi_frm_sms_msg_seg_size : (concat_info->total_seg - concat_info->seg + 1);
  47.     U8 dataindex = mmi_frm_sms_awaited[index].msg_data[0];
  49.     /*----------------------------------------------------------------*/
  50.     /* Code Body                                                      */
  51.     /*----------------------------------------------------------------*/
  52.     while (dataindex != MMI_FRM_SMS_INVALID_NUM)
  53.     {
  54.         if (mmi_frm_sms_content[dataindex].segment != (i + 1))
  55.         {
  56.             return FALSE;
  57.         }
  58.         dataindex = mmi_frm_sms_content[dataindex].nextindex;
  59.         i++;
  60.     }
  61.     if (i == total_seg)
  62.     {
  63.         return TRUE;
  64.     }
  65.     else
  66.     {
  67.         return FALSE;
  68.     }
  69. }
  72. /*****************************************************************************
  73.  * FUNCTION
  74.  *  mmi_frm_sms_check_awaited
  75.  * DESCRIPTION
  76.  *  Check awaited entry, see if any match
  77.  * PARAMETERS
  78.  *  void
  79.  * RETURNS
  80.  *  index
  81.  *****************************************************************************/
  82. U8 mmi_frm_sms_check_awaited(void)
  83. {
  84.     /*----------------------------------------------------------------*/
  85.     /* Local Variables                                                */
  86.     /*----------------------------------------------------------------*/
  87.     /* find the entry in the awaited list that matches the last entry in the mmi_frm_sms_awaited  */
  88.     U8 i = 0;
  89.     mmi_frm_sms_deliver_msg_struct *datainfo = &mmi_frm_sms_awaited[MMI_FRM_SMS_ACTION_SIZE];
  90.     mmi_frm_sms_concat_struct *concatinfo =
  91.         ((mmi_frm_sms_concat_struct*) & (mmi_frm_sms_awaited[MMI_FRM_SMS_ACTION_SIZE].concat_info));
  92.     U8 thisseg = mmi_frm_sms_content[MMI_FRM_SMS_MSG_CONTENT_NUM].segment;
  94.     /*----------------------------------------------------------------*/
  95.     /* Code Body                                                      */
  96.     /*----------------------------------------------------------------*/
  97.     if (((concatinfo->total_seg % g_frm_sms_cntx.mmi_frm_sms_msg_seg_size) == 1) &&
  98.         (concatinfo->total_seg == concatinfo->seg))
  99.     {
  100.         return MMI_FRM_SMS_ACTION_SIZE;
  101.     }
  103.     while (i < MMI_FRM_SMS_ACTION_SIZE)
  104.     {
  105.         mmi_frm_sms_deliver_msg_struct *data = &mmi_frm_sms_awaited[i];
  106.         mmi_frm_sms_concat_struct *concat = ((mmi_frm_sms_concat_struct*) & (mmi_frm_sms_awaited[i].concat_info));
  108.         if ((data->display_type == datainfo->display_type) && (concat->total_seg == concatinfo->total_seg) &&
  109.             (concat->seg == concatinfo->seg) && (concat->ref == concatinfo->ref) &&
  110.             ((ComparePhoneNum((PU8) data->addr_number.number, (PU8) datainfo->addr_number.number)) == TRUE))
  111.         {
  112.             U8 j = mmi_frm_sms_awaited[i].msg_data[0];
  114.             while (j != MMI_FRM_SMS_INVALID_NUM)
  115.             {
  116.                 /* find exactly the same entry in the awaited list as the last entry */
  117.                 if (mmi_frm_sms_content[j].segment == thisseg)
  118.                 {
  119.                     break;
  120.                 }
  121.                 /* thisseg is smaller than the current smallest segment number of this message */
  122.                 else if (mmi_frm_sms_content[j].segment > thisseg)
  123.                 {
  124.                 #ifdef __MMI_MESSAGES_COPY__
  125.                     if (mmi_frm_sms_awaited[i].storageType != MMI_FRM_SMS_PREFER_STORAGE)
  126.                     {
  127.                         mmi_frm_sms_awaited[i].storageType = datainfo->storageType;
  128.                     }
  129.                 #endif /* __MMI_MESSAGES_COPY__ */ 
  130.                     /* if add awaited segment fail, it will popup arbitrarily, so leave the mmi_frm_sms_indicate_sms to free memory */
  131.                     if (mmi_frm_sms_add_awaited_segment(i, datainfo->index, thisseg, datainfo) == TRUE)
  132.                     {
  133.                         mmi_frm_sms_free_new_sms();
  134.                     }
  135.                     return i;
  136.                 }
  137.                 /* thisseg is greater than the current largest segment number of this message */
  138.                 else if (mmi_frm_sms_content[j].segment < thisseg &&
  139.                          mmi_frm_sms_content[j].nextindex == MMI_FRM_SMS_INVALID_NUM)
  140.                 {
  141.                 #ifdef __MMI_MESSAGES_COPY__
  142.                     if (mmi_frm_sms_awaited[i].storageType != MMI_FRM_SMS_PREFER_STORAGE)
  143.                     {
  144.                         mmi_frm_sms_awaited[i].storageType = datainfo->storageType;
  145.                     }
  146.                 #endif /* __MMI_MESSAGES_COPY__ */ 
  147.                     /* if add awaited segment fail, it will popup arbitrarily, so leave the mmi_frm_sms_indicate_sms to free memory */
  148.                     if (mmi_frm_sms_add_awaited_segment(i, datainfo->index, thisseg, datainfo) == TRUE)
  149.                     {
  150.                         mmi_frm_sms_free_new_sms();
  151.                     }
  152.                     return i;
  153.                 }
  154.                 j = mmi_frm_sms_content[j].nextindex;
  155.             }
  156.         }
  157.         i++;
  158.     }
  159.     return MMI_FRM_SMS_INVALID_NUM;
  160. }
  163. /*****************************************************************************
  164.  * FUNCTION
  165.  *  mmi_frm_sms_check_inbox
  166.  * DESCRIPTION
  167.  *  Check inbox, see if any match
  168.  * PARAMETERS
  169.  *  entry           [?]         Message entry info
  170.  *  thissegment     [IN]        Segment
  171.  * RETURNS
  172.  *  index
  173.  *****************************************************************************/
  174. U16 mmi_frm_sms_check_inbox(mmi_frm_sms_msgbox_struct *entry, U8 thissegment)
  175. {
  176.     /*----------------------------------------------------------------*/
  177.     /* Local Variables                                                */
  178.     /*----------------------------------------------------------------*/
  179.     U16 i = 0;
  181.     /*----------------------------------------------------------------*/
  182.     /* Code Body                                                      */
  183.     /*----------------------------------------------------------------*/
  184.     while (i < g_frm_sms_cntx.mmi_frm_sms_msg_box_size)
  185.     {
  186.         if (mmi_frm_sms_compare_entry(i, entry, thissegment) == TRUE)
  187.         {
  188.             return i;
  189.         }
  190.         i++;
  191.     }
  192.     return MMI_FRM_SMS_INVALID_INDEX;
  193. }
  196. /*****************************************************************************
  197.  * FUNCTION
  198.  *  mmi_frm_sms_timeout_concatenate_sms
  199.  * DESCRIPTION
  200.  *  timeout check concatenate SMS
  201.  * PARAMETERS
  202.  *  void
  203.  * RETURNS
  204.  *  void
  205.  *****************************************************************************/
  206. void mmi_frm_sms_timeout_concatenate_sms(void)
  207. {
  208.     /*----------------------------------------------------------------*/
  209.     /* Local Variables                                                */
  210.     /*----------------------------------------------------------------*/
  211.     U8 i = 0;
  212.     U8 awaited_remain = FALSE;
  214.     /*----------------------------------------------------------------*/
  215.     /* Code Body                                                      */
  216.     /*----------------------------------------------------------------*/
  217.     while (i < MMI_FRM_SMS_ACTION_SIZE)
  218.     {
  219.         if (mmi_frm_sms_awaited_counter[i] != MMI_FRM_SMS_INVALID_NUM)
  220.         {
  221.             mmi_frm_sms_awaited_counter[i]++;
  222.             if (mmi_frm_sms_awaited_counter[i] == MMI_FRM_SMS_ACTION_SIZE)
  223.             {
  224.                 mmi_frm_sms_awaited_counter[i] = MMI_FRM_SMS_INVALID_NUM;
  225.                 mmi_frm_sms_indicate_sms(i);
  226.             }
  227.             else
  228.             {
  229.                 awaited_remain = TRUE;
  230.             }
  231.         }
  232.         i++;
  233.     }
  234.     /* timer expires but still some segments are missing in the mmi_frm_sms_awaited */
  235.     if (awaited_remain == TRUE)
  236.     {
  237.         StartTimer(MESSAGES_LMS_RECV_TIMER_ID, MMI_FRM_SMS_LMS_TIME_OUT, mmi_frm_sms_timeout_concatenate_sms);
  238.     }
  239.     else
  240.     {
  241.         mmi_frm_sms_awaited_counting = FALSE;
  242.     }
  243. }
  246. /*****************************************************************************
  247.  * FUNCTION
  248.  *  mmi_frm_sms_check_concatenate_sms
  249.  * DESCRIPTION
  250.  *  Check concatenate SMS in awaited and inbox list
  251.  * PARAMETERS
  252.  *  index       [?]     Index
  253.  * RETURNS
  254.  *  type
  255.  *****************************************************************************/
  256. U8 mmi_frm_sms_check_concatenate_sms(U16 *index)
  257. {
  258.     /*----------------------------------------------------------------*/
  259.     /* Local Variables                                                */
  260.     /*----------------------------------------------------------------*/
  261.     mmi_frm_sms_concat_struct *concatinfo =
  262.         (mmi_frm_sms_concat_struct*) & (mmi_frm_sms_awaited[MMI_FRM_SMS_ACTION_SIZE].concat_info);
  264.     /*----------------------------------------------------------------*/
  265.     /* Code Body                                                      */
  266.     /*----------------------------------------------------------------*/
  267.     if (((concatinfo->total_seg % g_frm_sms_cntx.mmi_frm_sms_msg_seg_size) == 1) &&
  268.         (concatinfo->total_seg == concatinfo->seg))
  269.     {
  270.         *index = MMI_FRM_SMS_ACTION_SIZE;
  271.         return MMI_FRM_SMS_AWAITS;
  272.     }
  273.     else
  274.     {
  275.         U8 awaited_index = mmi_frm_sms_check_awaited();
  277.         /* the last entry in the mmi_frm_sms_awaited belongs to one of the segments of the entry with index awaited_index in the awaited list */
  278.         if (awaited_index != MMI_FRM_SMS_INVALID_NUM)
  279.         {
  280.             if (mmi_frm_sms_check_awaited_complete(awaited_index) == TRUE)
  281.             {
  282.                 mmi_frm_sms_awaited_counter[awaited_index] = MMI_FRM_SMS_INVALID_NUM;
  283.                 *index = awaited_index;
  284.                 return MMI_FRM_SMS_AWAITS;
  285.             }
  286.             /* not all segments of this message are arrived, restart the counter to keep waiting for other segment's arriving */
  287.             else
  288.             {
  289.                 mmi_frm_sms_awaited_counter[awaited_index] = 0;
  290.                 *index = awaited_index;
  291.                 return MMI_FRM_SMS_NOBOX;
  292.             }
  293.         }
  294.         /* the last entry in the mmi_frm_sms_awaited matches nothing with other entries in the awaited list */
  295.         else if (mmi_frm_sms_list_done)
  296.         {
  297.             U16 inbox_index;
  298.             mmi_frm_sms_msgbox_struct *entry = OslMalloc(sizeof(mmi_frm_sms_msgbox_struct));
  299.             U8 thissegment = mmi_frm_sms_content[MMI_FRM_SMS_MSG_CONTENT_NUM].segment;
  301.             mmi_frm_sms_convert_mt_to_entry(&(mmi_frm_sms_awaited[MMI_FRM_SMS_ACTION_SIZE]), entry);
  302.             inbox_index = mmi_frm_sms_check_inbox(entry, thissegment);
  303.             OslMfree(entry);
  305.             /* the last entry in the mmi_frm_sms_awaited belongs to one of the segments of the entry with index inbox_index in the inbox list */
  306.             if (inbox_index != MMI_FRM_SMS_INVALID_INDEX)
  307.             {
  308.             #ifdef __MMI_UNIFIED_MESSAGE__
  309.                 {
  310.                     mmi_frm_sms_deliver_msg_struct *data = OslMalloc(sizeof(mmi_frm_sms_deliver_msg_struct));
  312.                     /* MMI could only allocate 2K control buffer, so limit the max allocate buffer to 1600 here */
  313.                     U16 content_len =
  314.                         ((MMI_FRM_SMS_MSG_LEN * g_frm_sms_cntx.mmi_frm_sms_msg_seg_size) < (MMI_FRM_SMS_MSG_LEN * 10)) ? 
  315.                         (MMI_FRM_SMS_MSG_LEN * g_frm_sms_cntx.mmi_frm_sms_msg_seg_size) : (MMI_FRM_SMS_MSG_LEN * 10);
  316.                     
  317.                     U8 *content = OslMalloc(content_len);
  318.                     U8 withobject;
  319.                     U8 new_segment_index = MMI_FRM_SMS_ACTION_SIZE;
  320.                     U8 *ucs2_content = NULL;
  321.                     U16 ucs2_content_len = 0;
  323.                     memset(content, 0x00, content_len);
  324.                     withobject = mmi_frm_sms_get_awaited_sms((U8) new_segment_index, data, content);
  326.                     ucs2_content_len = ((mmi_msg_get_max_content_size() + 1) * ENCODING_LENGTH);
  327.                     ucs2_content = OslMalloc(ucs2_content_len);
  328.                     memset(ucs2_content, 0, ucs2_content_len);
  329.                     
  330.                     if (data->dcs == SMSAL_UCS2_DCS)
  331.                     {
  332.                         if (pfnUnicodeStrlen((S8*) content))
  333.                         {
  334.                             pfnUnicodeStrncpy(
  335.                                 (S8*) ucs2_content,
  336.                                 (S8*) content,
  337.                                 mmi_msg_get_max_content_size());
  338.                         }                        
  339.                     }
  340.                     else
  341.                     {
  342.                         if (strlen((S8*) content))
  343.                         {
  344.                             AnsiiNToUnicodeString((S8*) ucs2_content, (S8*) content, (U32) mmi_msg_get_max_content_size());
  345.                         }
  346.                     }
  348.                     if (pfnUnicodeStrlen((S8*) ucs2_content) > 0)
  349.                     {
  350.                         if (mmi_frm_sms_index_list[mmi_frm_sms_msg_box[inbox_index].startindex].segment == thissegment - 1)
  351.                         {
  352.                             if (pfnUnicodeStrlen((S8*) mmi_frm_sms_msg_box[inbox_index].content) <
  353.                                 (mmi_msg_get_max_content_size() - 1))
  354.                             {
  355.                                 /* append content to mmi_frm_sms_msg_box[addindex].content */
  356.                                 U16 *temp_content;
  357.                                 U16 temp_content_size = (U16) (mmi_msg_get_max_content_size() + 1) * ENCODING_LENGTH;
  358.                     
  359.                                 temp_content = OslMalloc(temp_content_size);
  360.                                 memset((S8*) temp_content, 0, temp_content_size);
  361.                                 pfnUnicodeStrncpy(
  362.                                     (S8*) temp_content,
  363.                                     (S8*) mmi_frm_sms_msg_box[inbox_index].content,
  364.                                     mmi_msg_get_max_content_size());
  365.                                 
  366.                                 pfnUnicodeStrncat(
  367.                                     (S8*) temp_content,
  368.                                     (S8*) ucs2_content,
  369.                                     (mmi_msg_get_max_content_size() - pfnUnicodeStrlen((S8*) temp_content)));
  370.                     
  371.                                 mmi_frm_sms_add_content_to_entry(
  372.                                     (mmi_frm_sms_msgbox_struct*) & mmi_frm_sms_msg_box[inbox_index],
  373.                                     (U8*) temp_content);
  374.                     
  375.                                 OslMfree(temp_content);                        
  376.                             }
  377.                         }
  378.                         else if (mmi_frm_sms_index_list[mmi_frm_sms_msg_box[inbox_index].startindex].segment == thissegment + 1)
  379.                         {
  380.                             /* copy data->content to the beginning of  mmi_frm_sms_msg_box[addindex].content */
  381.                             U16 *temp_content;
  382.                             U16 temp_content_size = (U16) (mmi_msg_get_max_content_size() + 1) * ENCODING_LENGTH;
  383.                     
  384.                             temp_content = OslMalloc(temp_content_size);
  385.                             memset((S8*) temp_content, 0, temp_content_size);
  386.                             pfnUnicodeStrncpy((S8*) temp_content, (S8*) ucs2_content, mmi_msg_get_max_content_size());
  387.                     
  388.                             if (mmi_msg_get_max_content_size() > pfnUnicodeStrlen((S8*) temp_content))
  389.                             {
  390.                                 pfnUnicodeStrncat(
  391.                                     (S8*) temp_content,
  392.                                     (S8*) mmi_frm_sms_msg_box[inbox_index].content,
  393.                                     (mmi_msg_get_max_content_size() - pfnUnicodeStrlen((S8*) temp_content)));
  394.                             }
  395.                     
  396.                             mmi_frm_sms_add_content_to_entry(
  397.                                 (mmi_frm_sms_msgbox_struct*) & mmi_frm_sms_msg_box[inbox_index],
  398.                                 (U8*) temp_content);
  399.                     
  400.                             OslMfree(temp_content);
  401.                         }
  402.                         else if (mmi_frm_sms_index_list[mmi_frm_sms_msg_box[inbox_index].startindex].segment > thissegment)
  403.                         {
  404.                             mmi_frm_sms_add_content_to_entry(
  405.                                 (mmi_frm_sms_msgbox_struct*) & mmi_frm_sms_msg_box[inbox_index],
  406.                                 (U8*) ucs2_content);
  407.                         }
  408.                         else
  409.                         {
  410.                             /* thissegment > start_segment + 1 */
  411.                             /* If thissegment is the last segment of received segments, append the content */
  412.                             if (pfnUnicodeStrlen((S8*) mmi_frm_sms_msg_box[inbox_index].content) <
  413.                                 (mmi_msg_get_max_content_size() - 1))
  414.                             {
  415.                                 U16 l4_index = mmi_frm_sms_index_list[mmi_frm_sms_msg_box[inbox_index].startindex].nextindex;
  417.                                 if (l4_index == MMI_FRM_SMS_INVALID_INDEX)
  418.                                 {
  419.                                     /* Do nothing */
  420.                                     ;
  421.                                 }
  422.                                 else
  423.                                 {
  424.                                     for (;;)
  425.                                     {
  426.                                         /* Received segments are continuous */
  427.                                         if (mmi_frm_sms_index_list[l4_index].nextindex == MMI_FRM_SMS_INVALID_INDEX)
  428.                                         {
  430.                                             if ((mmi_frm_sms_index_list[l4_index].segment - 1 ) != 
  431.                                                 mmi_frm_sms_index_list[mmi_frm_sms_index_list[l4_index].previndex].segment)
  432.                                             {
  433.                                                 /* Do nothing if received segments are not continuous */
  434.                                                 break;
  435.                                             }                
  437.                                             /* thissegment is the last segment of received segments */
  438.                                             if (thissegment == (mmi_frm_sms_index_list[l4_index].segment + 1 ))
  439.                                             {
  440.                                                 /* append content to mmi_frm_sms_msg_box[addindex].content */
  441.                                                 U16 *temp_content;
  442.                                                 U16 temp_content_size = (U16) (mmi_msg_get_max_content_size() + 1) * ENCODING_LENGTH;
  443.                                     
  444.                                                 temp_content = OslMalloc(temp_content_size);
  445.                                                 memset((S8*) temp_content, 0, temp_content_size);
  446.                                                 pfnUnicodeStrncpy(
  447.                                                     (S8*) temp_content,
  448.                                                     (S8*) mmi_frm_sms_msg_box[inbox_index].content,
  449.                                                     mmi_msg_get_max_content_size());
  450.                                                 
  451.                                                 pfnUnicodeStrncat(
  452.                                                     (S8*) temp_content,
  453.                                                     (S8*) ucs2_content,
  454.                                                     (mmi_msg_get_max_content_size() - pfnUnicodeStrlen((S8*) temp_content)));
  455.                                     
  456.                                                 mmi_frm_sms_add_content_to_entry(
  457.                                                     (mmi_frm_sms_msgbox_struct*) & mmi_frm_sms_msg_box[inbox_index],
  458.                                                     (U8*) temp_content);
  459.                                     
  460.                                                 OslMfree(temp_content);      
  461.                                             }
  462.                                             break;
  463.                                         }   
  465.                                         if ((mmi_frm_sms_index_list[l4_index].segment - 1 ) != 
  466.                                             mmi_frm_sms_index_list[mmi_frm_sms_index_list[l4_index].previndex].segment)
  467.                                         {
  468.                                             /* Do nothing if received segments are not continuous */
  469.                                             break;
  470.                                         } 
  472.                                         l4_index = mmi_frm_sms_index_list[l4_index].nextindex;
  473.                                     }                
  474.                                 }
  475.                             }
  476.                         }
  477.                     }
  478.                     
  479.                     OslMfree(data);
  480.                     OslMfree(content);
  481.                     OslMfree(ucs2_content);
  482.                 }
  483.             #endif /* __MMI_UNIFIED_MESSAGE__ */ 
  485.                 mmi_frm_sms_add_sms_segment(
  486.                     inbox_index,
  487.                     mmi_frm_sms_awaited[MMI_FRM_SMS_ACTION_SIZE].index,
  488.                     thissegment);
  489.             #ifdef __MMI_MESSAGES_COPY__
  490.                 if (mmi_frm_sms_msg_box[inbox_index].storageType != MMI_FRM_SMS_PREFER_STORAGE)
  491.                 {
  492.                     mmi_frm_sms_msg_box[inbox_index].storageType =
  493.                         mmi_frm_sms_awaited[MMI_FRM_SMS_ACTION_SIZE].storageType;
  494.                 }
  495.             #endif /* __MMI_MESSAGES_COPY__ */ 
  496.                 mmi_frm_sms_free_new_sms();
  497.                 *index = inbox_index;
  498.                 return MMI_FRM_SMS_INBOX;
  499.             }
  500.         }
  501.         /* cannot find any match in awaited list and inbox list, add one entry with index awaited_index in the mmi_frm_sms_awaited */
  502.         awaited_index = mmi_frm_sms_add_awaited_entry();
  503.         /* find an empty entry in the awaited list and add successfully */
  504.         if (awaited_index != MMI_FRM_SMS_INVALID_NUM)
  505.         {
  506.             mmi_frm_sms_free_new_sms();
  507.             /* the timer is not started yet */
  508.             if (mmi_frm_sms_awaited_counting == FALSE)
  509.             {
  510.                 StartTimer(MESSAGES_LMS_RECV_TIMER_ID, MMI_FRM_SMS_LMS_TIME_OUT, mmi_frm_sms_timeout_concatenate_sms);
  511.                 mmi_frm_sms_awaited_counting = TRUE;
  512.             }
  513.             mmi_frm_sms_awaited_counter[awaited_index] = 0;
  514.             *index = MMI_FRM_SMS_INVALID_INDEX;
  515.             return MMI_FRM_SMS_NOBOX;
  516.         }
  517.         /* awaited list is full and the segment should be popup arbitrarily */
  518.         else
  519.         {
  520.             *index = MMI_FRM_SMS_ACTION_SIZE;
  521.             return MMI_FRM_SMS_AWAITS;
  522.         }
  523.     }
  524. }
  527. /*****************************************************************************
  528.  * FUNCTION
  529.  *  mmi_frm_sms_check_sms_complete
  530.  * DESCRIPTION
  531.  *  Check SMS completeness
  532.  * PARAMETERS
  533.  *  type        [IN]        Type
  534.  *  index       [IN]        Index
  535.  * RETURNS
  536.  *  TRUE: complete, FALSE: not
  537.  *****************************************************************************/
  538. U8 mmi_frm_sms_check_sms_complete(U8 type, U16 index)
  539. {
  540.     /*----------------------------------------------------------------*/
  541.     /* Local Variables                                                */
  542.     /*----------------------------------------------------------------*/
  543.     U8 i = 0;
  544.     U8 total_seg;
  545.     U16 dataindex;
  546.     U16 msgindex;
  548.     /*----------------------------------------------------------------*/
  549.     /* Code Body                                                      */
  550.     /*----------------------------------------------------------------*/
  551.     switch (type)
  552.     {
  553.         case MMI_FRM_SMS_INBOX:
  554.         case MMI_FRM_SMS_UNREAD:
  555.             msgindex = mmi_frm_sms_inbox_list[index];
  556.             break;
  557.         case MMI_FRM_SMS_OUTBOX:
  558.     #ifndef __MMI_MESSAGES_DRAFT_BOX__
  559.         case MMI_FRM_SMS_DRAFTS:
  560.     #endif 
  561.             msgindex = mmi_frm_sms_outbox_list[index];
  562.             break;
  563.     #ifdef __MMI_MESSAGES_DRAFT_BOX__
  564.         case MMI_FRM_SMS_DRAFTS:
  565.     #ifdef __MMI_UNIFIED_MESSAGE__
  566.         case MMI_FRM_SMS_UNSENT:
  567.     #endif 
  568.             msgindex = mmi_frm_sms_drafts_list[index];
  569.             break;
  570.     #endif /* __MMI_MESSAGES_DRAFT_BOX__ */ 
  571.         default:
  572.             msgindex = 0;
  573.             break;
  574.     }
  575.     total_seg =
  576.         ((mmi_frm_sms_msg_box[msgindex].totalseg - mmi_frm_sms_msg_box[msgindex].startseg + 1) >
  577.          g_frm_sms_cntx.mmi_frm_sms_msg_seg_size) ? g_frm_sms_cntx.
  578.         mmi_frm_sms_msg_seg_size : (mmi_frm_sms_msg_box[msgindex].totalseg - mmi_frm_sms_msg_box[msgindex].startseg +
  579.                                     1);
  580.     dataindex = mmi_frm_sms_msg_box[msgindex].startindex;
  581.     while (dataindex != MMI_FRM_SMS_INVALID_INDEX)
  582.     {
  583.         if (mmi_frm_sms_index_list[dataindex].segment != (i + 1))
  584.         {
  585.             return FALSE;
  586.         }
  587.         dataindex = mmi_frm_sms_index_list[dataindex].nextindex;
  588.         i++;
  589.     }
  590.     if (i == total_seg)
  591.     {
  592.         return TRUE;
  593.     }
  594.     else
  595.     {
  596.         return FALSE;
  597.     }
  598. }
  601. /*****************************************************************************
  602.  * FUNCTION
  603.  *  mmi_frm_sms_get_data_index
  604.  * DESCRIPTION
  605.  *  get data index of specific source port and module
  606.  * PARAMETERS
  607.  *  mod             [IN]        Port
  608.  *  port            [IN]        
  609.  *  startindex      [IN]        
  610.  * RETURNS
  611.  *  index
  612.  *****************************************************************************/
  613. U8 mmi_frm_sms_get_data_index(module_type mod, U16 port, U8 startindex)
  614. {
  615.     /*----------------------------------------------------------------*/
  616.     /* Local Variables                                                */
  617.     /*----------------------------------------------------------------*/
  618.     U8 i = 0;
  620.     /*----------------------------------------------------------------*/
  621.     /* Code Body                                                      */
  622.     /*----------------------------------------------------------------*/
  623.     for (i = startindex; i < MMI_FRM_SMS_ACTION_SIZE; i++)
  624.     {
  625.         if ((mmi_frm_sms_data[i].dest_mod_id == mod) && (mmi_frm_sms_data[i].dest_port == port))
  626.         {
  627.             return i;
  628.         }
  629.     }
  630.     return MMI_FRM_SMS_INVALID_NUM;
  631. }
  634. /*****************************************************************************
  635.  * FUNCTION
  636.  *  mmi_frm_sms_remove_data
  637.  * DESCRIPTION
  638.  *  Remove SMS with port, by module and port
  639.  * PARAMETERS
  640.  *  mod         [IN]        Module
  641.  *  port        [IN]        Port number
  642.  * RETURNS
  643.  *  void
  644.  *****************************************************************************/
  645. void mmi_frm_sms_remove_data(module_type mod, U16 port)
  646. {
  647.     /*----------------------------------------------------------------*/
  648.     /* Local Variables                                                */
  649.     /*----------------------------------------------------------------*/
  650.     U8 i = 0;
  652.     /*----------------------------------------------------------------*/
  653.     /* Code Body                                                      */
  654.     /*----------------------------------------------------------------*/
  655.     for (i = 0; i < MMI_FRM_SMS_ACTION_SIZE; i++)
  656.     {
  657.         if ((mmi_frm_sms_data[i].dest_mod_id == mod) && (mmi_frm_sms_data[i].dest_port == port))
  658.         {
  659.             mmi_frm_sms_free_data(i);
  660.         }
  661.     }
  662. }
  665. /*****************************************************************************
  666.  * FUNCTION
  667.  *  mmi_frm_sms_add_data_segment
  668.  * DESCRIPTION
  669.  *  add one segment to awaited entry
  670.  * PARAMETERS
  671.  *  index       [IN]        Index
  672.  *  segment     [IN]        Segment
  673.  *  entry       [?]         
  674.  *  b  addindex    addindex(?)
  675.  * RETURNS
  676.  *  void
  677.  *****************************************************************************/
  678. U8 mmi_frm_sms_add_data_segment(U8 index, U8 segment, mmi_frm_sms_deliver_data_struct *entry)
  679. {
  680.     /*----------------------------------------------------------------*/
  681.     /* Local Variables                                                */
  682.     /*----------------------------------------------------------------*/
  683.     U8 islast = TRUE;
  684.     U8 dataindex = 0;
  685.     U8 thisdataindex = mmi_frm_sms_data[index].data[0];
  686.     U8 prevdataindex = MMI_FRM_SMS_INVALID_NUM;
  688.     /*----------------------------------------------------------------*/
  689.     /* Code Body                                                      */
  690.     /*----------------------------------------------------------------*/
  691.     /* find an empty entry in mmi_frm_sms_content in order to move the last entry to that entry */
  692.     while (dataindex < MMI_FRM_SMS_MSG_CONTENT_NUM)
  693.     {
  694.         if (mmi_frm_sms_content[dataindex].msglen == 0)
  695.         {
  696.             break;  /* found empty entry */
  697.         }
  698.         dataindex++;
  699.     }
  700.     /* if mmi_frm_sms_content is full and cannot find any empty entry, don't have to move */
  701.     if (dataindex != MMI_FRM_SMS_MSG_CONTENT_NUM)
  702.     {
  703.         /* move the actual data of the last entry to the entry with the index dataindex in mmi_frm_sms_content */
  704.         if (entry->message_len)
  705.         {
  706.             mmi_frm_sms_content[dataindex].data = OslMalloc(entry->message_len);
  707.             memcpy(
  708.                 (S8*) mmi_frm_sms_content[dataindex].data,
  709.                 (S8*) mmi_frm_sms_content[MMI_FRM_SMS_MSG_CONTENT_NUM].data,
  710.                 entry->message_len);
  711.         }
  712.         mmi_frm_sms_content[dataindex].msglen = entry->message_len;
  713.         mmi_frm_sms_content[dataindex].segment = segment;
  714.     }
  715.     mmi_frm_sms_data[index].message_len += entry->message_len;
  716.     MMI_ASSERT(mmi_frm_sms_data[index].message_len <= MMI_SMS_MAX_MSG_SEG * MMI_FRM_SMS_MSG_LEN);
  718.     /* thisdataindex is the current smallest segment index of this message */
  719.     if (mmi_frm_sms_content[thisdataindex].segment > segment)
  720.     {
  721.         islast = FALSE;
  722.         /* dataindex is inserted in the head, now dataindex is the current smallest segment index of this message */
  723.         mmi_frm_sms_content[dataindex].nextindex = thisdataindex;
  724.         mmi_frm_sms_data[index].data[0] = dataindex;
  725.     }
  726.     else
  727.     {
  728.         while (mmi_frm_sms_content[thisdataindex].nextindex != MMI_FRM_SMS_INVALID_NUM)
  729.         {
  730.             prevdataindex = thisdataindex;
  731.             thisdataindex = mmi_frm_sms_content[thisdataindex].nextindex;
  732.             if (mmi_frm_sms_content[thisdataindex].segment > segment)
  733.             {
  734.                 islast = FALSE;
  735.                 break;
  736.             }
  737.         }
  738.     }
  740.     if (islast == TRUE)
  741.     {
  742.         /* dataindex is inserted in the tail, now dataindex is the current largest segment index of this message */
  743.         mmi_frm_sms_content[thisdataindex].nextindex = dataindex;
  744.         mmi_frm_sms_content[dataindex].nextindex = MMI_FRM_SMS_INVALID_NUM;
  745.     }
  746.     else
  747.     {
  748.         /* dataindex is inserted in the middle */
  749.         if (prevdataindex != MMI_FRM_SMS_INVALID_NUM)
  750.         {
  751.             mmi_frm_sms_content[prevdataindex].nextindex = dataindex;
  752.         }
  753.         mmi_frm_sms_content[dataindex].nextindex = thisdataindex;
  754.     }
  755.     /* mmi_frm_sms_content is full and cannot handle other new segment coming anymore */
  756.     if (dataindex == MMI_FRM_SMS_MSG_CONTENT_NUM)
  757.     {
  758.         return FALSE;
  759.     }
  760.     else
  761.     {
  762.         return TRUE;
  763.     }
  764. }
  767. /*****************************************************************************
  768.  * FUNCTION
  769.  *  mmi_frm_sms_add_data_entry
  770.  * DESCRIPTION
  771.  *  add sms to awaited list
  772.  * PARAMETERS
  773.  *  void
  774.  *  a  type        type(?)
  775.  *  b  index       index(?)
  776.  *  c  l4_index    l4_index(?)
  777.  * RETURNS
  778.  *  TRUE: inserted, FALSE: not inserted
  779.  *****************************************************************************/
  780. U8 mmi_frm_sms_add_data_entry(void)
  781. {
  782.     /*----------------------------------------------------------------*/
  783.     /* Local Variables                                                */
  784.     /*----------------------------------------------------------------*/
  785.     U8 i = 0;
  786.     U8 dataindex = 0;
  787.     U16 length = mmi_frm_sms_content[MMI_FRM_SMS_MSG_CONTENT_NUM].msglen;
  789.     /*----------------------------------------------------------------*/
  790.     /* Code Body                                                      */
  791.     /*----------------------------------------------------------------*/
  792.     while (dataindex < MMI_FRM_SMS_MSG_CONTENT_NUM)
  793.     {
  794.         if (mmi_frm_sms_content[dataindex].segment == MMI_FRM_SMS_INVALID_NUM)
  795.         {
  796.             break;  /* found empty entry */
  797.         }
  798.         dataindex++;
  799.     }
  800.     /* cannot find any empty entry in mmi_frm_sms_content */
  801.     if (dataindex == MMI_FRM_SMS_MSG_CONTENT_NUM)
  802.     {
  803.         return MMI_FRM_SMS_INVALID_NUM;
  804.     }
  806.     mmi_frm_sms_content[dataindex].msglen = mmi_frm_sms_content[MMI_FRM_SMS_MSG_CONTENT_NUM].msglen;
  807.     mmi_frm_sms_content[dataindex].nextindex = mmi_frm_sms_content[MMI_FRM_SMS_MSG_CONTENT_NUM].nextindex;
  808.     mmi_frm_sms_content[dataindex].segment = mmi_frm_sms_content[MMI_FRM_SMS_MSG_CONTENT_NUM].segment;
  809.     // mmi_frm_sms_content[dataindex].data=mmi_frm_sms_content[MMI_FRM_SMS_MSG_CONTENT_NUM].data;
  810.     // mmi_frm_sms_content[MMI_FRM_SMS_MSG_CONTENT_NUM].data=NULL;
  811.     if (length)
  812.     {
  813.         mmi_frm_sms_content[dataindex].data = OslMalloc(length);
  814.         memcpy(mmi_frm_sms_content[dataindex].data, mmi_frm_sms_content[MMI_FRM_SMS_MSG_CONTENT_NUM].data, length);
  815.     }
  817.     while (i < MMI_FRM_SMS_ACTION_SIZE)
  818.     {
  819.         if (mmi_frm_sms_data[i].data[0] == MMI_FRM_SMS_INVALID_NUM)
  820.         {
  821.             memcpy(
  822.                 &(mmi_frm_sms_data[i]),
  823.                 &(mmi_frm_sms_data[MMI_FRM_SMS_ACTION_SIZE]),
  824.                 sizeof(mmi_frm_sms_deliver_data_struct));
  825.             mmi_frm_sms_data[i].data[0] = dataindex;
  826.             return i;
  827.         }
  828.         i++;
  829.     }
  830.     /* cannot find any empty entry in mmi_frm_sms_data */
  831.     return MMI_FRM_SMS_INVALID_NUM;
  832. }
  835. /*****************************************************************************
  836.  * FUNCTION
  837.  *  mmi_frm_sms_get_data
  838.  * DESCRIPTION
  839.  *  Get SMS with port: get content
  840.  * PARAMETERS
  841.  *  index       [IN]        Index
  842.  *  data        [?]         Entry info
  843.  *  content     [?]         Content
  844.  * RETURNS
  845.  *  TRUE: OK, FALSE: content empty
  846.  *****************************************************************************/
  847. U8 mmi_frm_sms_get_data(U8 index, mmi_frm_sms_deliver_data_struct *data, U8 *content)
  848. {
  849.     /*----------------------------------------------------------------*/
  850.     /* Local Variables                                                */
  851.     /*----------------------------------------------------------------*/
  853.     /*----------------------------------------------------------------*/
  854.     /* Code Body                                                      */
  855.     /*----------------------------------------------------------------*/
  856.     if (mmi_frm_sms_data[index].message_len == 0)
  857.     {
  858.         return FALSE;
  859.     }
  861.     memcpy((S8*) data, (S8*) & mmi_frm_sms_data[index], sizeof(mmi_frm_sms_deliver_data_struct));
  862.     memset((S8*) content, 0, mmi_frm_sms_data[index].message_len);
  864.     if (mmi_frm_sms_data[index].dcs == SMSAL_UCS2_DCS || mmi_frm_sms_data[index].dcs == SMSAL_DEFAULT_DCS)
  865.     {
  866.         U8 i = mmi_frm_sms_data[index].data[0];
  867.         EMSData *pEMSdata = NULL;
  868.         U8 *textBuff = NULL;
  869.         U8 *textBuffShifted = NULL;
  870.         U8 *TPUD[1];
  871.         U8 TPUDLEN[1];
  872.         U8 is_obj_present = 0;
  873.         U16 buffLen = mmi_frm_sms_data[index].message_len;
  874.         U16 textLen = 0;
  875.         U8 udhi = KAL_FALSE;
  877.         if (mmi_frm_sms_data[index].dcs == SMSAL_DEFAULT_DCS)
  878.         {
  879.             buffLen *= 2;
  880.         }
  882.         if (buffLen)
  883.         {
  884.             pEMSdata = OslMalloc(sizeof(EMSData));
  885.             /* MMI could only allocate 2K control buffer, so limit the max allocate buffer to 1600 here */
  886.             buffLen = (buffLen < (MMI_FRM_SMS_MSG_LEN * 10)) ? buffLen : (MMI_FRM_SMS_MSG_LEN * 10);
  887.             textBuff = OslMalloc(buffLen);
  888.             textBuffShifted = textBuff;
  890.             pEMSdata->textBuffer = textBuff;
  891.             pEMSdata->textBufferSize = buffLen;
  892.             pEMSdata->textLength = 0;
  893.             pEMSdata->dcs = mmi_frm_sms_data[index].dcs;
  895.             while (i != MMI_FRM_SMS_INVALID_NUM)
  896.             {
  897.                 TPUDLEN[0] = (U8) mmi_frm_sms_content[i].msglen;
  898.                 TPUD[0] = (U8*) mmi_frm_sms_content[i].data;
  899.                 EMSMsgPreview(
  900.                     1,
  901.                     mmi_frm_sms_data[index].dcs,
  902.                     udhi,
  903.                     TPUD,
  904.                     TPUDLEN,
  905.                     buffLen,
  906.                     textBuffShifted,
  907.                     &is_obj_present,
  908.                     &textLen);
  910.                 pEMSdata->textLength += textLen;
  911.                 textBuffShifted += textLen;
  912.                 buffLen -= textLen;
  913.                 textLen = 0;
  915.                 i = mmi_frm_sms_content[i].nextindex;
  916.             }
  918.             EMS_ConvertGSM7BitDefaultEncodingToAsciiWithoutEMSlib(pEMSdata);
  919.             /* UnicodeNToAnsii((S8*)content, (S8*)pEMSdata->textBuffer, pEMSdata->textBufferSize); */
  920.             memcpy((S8*) content, (S8*) pEMSdata->textBuffer, pEMSdata->textLength);
  921.             data->message_len = pEMSdata->textLength;
  922.             OslMfree(textBuff);
  923.             OslMfree(pEMSdata);
  924.         }
  925.         else
  926.         {
  927.             memset((S8*) content, 0, ENCODING_LENGTH);
  928.         }
  929.         return TRUE;
  930.     }
  931.     else
  932.     {
  933.         U8 i = mmi_frm_sms_data[index].data[0];
  934.         U16 len = 0;
  936.         while (i != MMI_FRM_SMS_INVALID_NUM)
  937.         {
  938.             memcpy(((S8*) content) + len, (S8*) mmi_frm_sms_content[i].data, mmi_frm_sms_content[i].msglen);
  939.             len += mmi_frm_sms_content[i].msglen;
  940.             i = mmi_frm_sms_content[i].nextindex;
  941.         }
  942.         return TRUE;
  943.     }
  944. }
  947. /*****************************************************************************
  948.  * FUNCTION
  949.  *  mmi_frm_sms_check_data
  950.  * DESCRIPTION
  951.  *  Check SMS with port in data list
  952.  * PARAMETERS
  953.  *  void
  954.  * RETURNS
  955.  *  index
  956.  *****************************************************************************/
  957. U8 mmi_frm_sms_check_data(void)
  958. {
  959.     /*----------------------------------------------------------------*/
  960.     /* Local Variables                                                */
  961.     /*----------------------------------------------------------------*/
  962.     /* find the entry in the data list that matches the last entry in the mmi_frm_sms_data */
  963.     U8 i = 0;
  964.     mmi_frm_sms_deliver_data_struct *datainfo = &mmi_frm_sms_data[MMI_FRM_SMS_ACTION_SIZE];
  965.     mmi_frm_sms_concat_struct *concatinfo =
  966.         ((mmi_frm_sms_concat_struct*) & (mmi_frm_sms_data[MMI_FRM_SMS_ACTION_SIZE].concat_info));
  967.     U8 thisseg = mmi_frm_sms_content[MMI_FRM_SMS_MSG_CONTENT_NUM].segment;
  969.     /*----------------------------------------------------------------*/
  970.     /* Code Body                                                      */
  971.     /*----------------------------------------------------------------*/
  972.     if (((concatinfo->total_seg % g_frm_sms_cntx.mmi_frm_sms_msg_seg_size) == 1) &&
  973.         (concatinfo->total_seg == concatinfo->seg))
  974.     {
  975.         return MMI_FRM_SMS_ACTION_SIZE;
  976.     }
  978.     while (i < MMI_FRM_SMS_ACTION_SIZE)
  979.     {
  980.         mmi_frm_sms_deliver_data_struct *data = &mmi_frm_sms_data[i];
  981.         mmi_frm_sms_concat_struct *concat = ((mmi_frm_sms_concat_struct*) & (mmi_frm_sms_data[i].concat_info));
  983.         if ((concat->total_seg == concatinfo->total_seg) && (concat->seg == concatinfo->seg) &&
  984.             (concat->ref == concatinfo->ref) &&
  985.             ((ComparePhoneNum((PU8) data->oa.number, (PU8) datainfo->oa.number)) == TRUE))
  986.         {
  987.             U8 j = mmi_frm_sms_data[i].data[0];
  989.             while (j != MMI_FRM_SMS_INVALID_NUM)
  990.             {
  991.                 /* find exactly the same entry in the data list as the last entry */
  992.                 if (mmi_frm_sms_content[j].segment == thisseg)
  993.                 {
  994.                     break;
  995.                 }
  996.                 /* thisseg is smaller than the current smallest segment number of this message */
  997.                 else if (mmi_frm_sms_content[j].segment > thisseg)
  998.                 {
  999.                     /* if add data segment fail, the last entry is not duplicated, so it cannot free here */
  1000.                     if (mmi_frm_sms_add_data_segment(i, thisseg, datainfo) == TRUE)
  1001.                     {
  1002.                         mmi_frm_sms_free_new_data();
  1003.                     }
  1004.                     return i;
  1005.                 }
  1006.                 /* thisseg is greater than the current largest segment number of this message */
  1007.                 else if (mmi_frm_sms_content[j].segment < thisseg &&
  1008.                          mmi_frm_sms_content[j].nextindex == MMI_FRM_SMS_INVALID_NUM)
  1009.                 {
  1010.                     /* if add data segment fail, the last entry is not duplicated, so it cannot free here */
  1011.                     if (mmi_frm_sms_add_data_segment(i, thisseg, datainfo) == TRUE)
  1012.                     {
  1013.                         mmi_frm_sms_free_new_data();
  1014.                     }
  1015.                     return i;
  1016.                 }
  1017.                 j = mmi_frm_sms_content[j].nextindex;
  1018.             }
  1019.         }
  1020.         i++;
  1021.     }
  1022.     return MMI_FRM_SMS_INVALID_NUM;
  1023. }
  1026. /*****************************************************************************
  1027.  * FUNCTION
  1028.  *  mmi_frm_sms_timeout_concatenate_data
  1029.  * DESCRIPTION
  1030.  *  timeout check concatenate SMS
  1031.  * PARAMETERS
  1032.  *  void
  1033.  * RETURNS
  1034.  *  void
  1035.  *****************************************************************************/
  1036. void mmi_frm_sms_timeout_concatenate_data(void)
  1037. {
  1038.     /*----------------------------------------------------------------*/
  1039.     /* Local Variables                                                */
  1040.     /*----------------------------------------------------------------*/
  1041.     U8 i = 0;
  1042.     U8 awaited_remain = FALSE;
  1044.     /*----------------------------------------------------------------*/
  1045.     /* Code Body                                                      */
  1046.     /*----------------------------------------------------------------*/
  1047.     while (i < MMI_FRM_SMS_ACTION_SIZE)
  1048.     {
  1049.         if (mmi_frm_sms_data_counter[i] != MMI_FRM_SMS_INVALID_NUM)
  1050.         {
  1051.             mmi_frm_sms_data_counter[i]++;
  1053.             /* Give twice time for data to be re-assembled. */
  1054.             if (mmi_frm_sms_data_counter[i] == MMI_FRM_SMS_ACTION_SIZE * 2)
  1055.             {
  1056.                 mmi_frm_sms_data_counter[i] = MMI_FRM_SMS_INVALID_NUM;
  1057.                 mmi_frm_sms_free_data(i);
  1058.             }
  1059.             else
  1060.             {
  1061.                 awaited_remain = TRUE;
  1062.             }
  1063.         }
  1064.         i++;
  1065.     }
  1066.     /* timer expires but still some segments are missing in the mmi_frm_sms_awaited */
  1067.     if (awaited_remain == TRUE)
  1068.     {
  1069.         StartTimer(MESSAGES_LMS_RECV_TIMER_ID, MMI_FRM_SMS_LMS_TIME_OUT, mmi_frm_sms_timeout_concatenate_data);
  1070.     }
  1071.     else
  1072.     {
  1073.         mmi_frm_sms_data_counting = FALSE;
  1074.     }
  1075. }
  1078. /*****************************************************************************
  1079.  * FUNCTION
  1080.  *  mmi_frm_sms_check_concatenate_data
  1081.  * DESCRIPTION
  1082.  *  Check concatenate data
  1083.  * PARAMETERS
  1084.  *  index       [?]     Index
  1085.  * RETURNS
  1086.  *  index
  1087.  *****************************************************************************/
  1088. U8 mmi_frm_sms_check_concatenate_data(U8 *index)
  1089. {
  1090.     /*----------------------------------------------------------------*/
  1091.     /* Local Variables                                                */
  1092.     /*----------------------------------------------------------------*/
  1093.     mmi_frm_sms_concat_struct *concatinfo =
  1094.         (mmi_frm_sms_concat_struct*) & (mmi_frm_sms_data[MMI_FRM_SMS_ACTION_SIZE].concat_info);
  1096.     /*----------------------------------------------------------------*/
  1097.     /* Code Body                                                      */
  1098.     /*----------------------------------------------------------------*/
  1099.     if (((concatinfo->total_seg % g_frm_sms_cntx.mmi_frm_sms_msg_seg_size) == 1) &&
  1100.         (concatinfo->total_seg == concatinfo->seg))
  1101.     {
  1102.         *index = MMI_FRM_SMS_ACTION_SIZE;
  1103.         return MMI_FRM_SMS_DATA;
  1104.     }
  1105.     else
  1106.     {
  1107.         U8 awaited_index = mmi_frm_sms_check_data();
  1109.         /* the last entry in the mmi_frm_sms_data belongs to one of the segments of the entry with index awaited_index in the data list */
  1110.         if (awaited_index != MMI_FRM_SMS_INVALID_NUM)
  1111.         {
  1112.             if (mmi_frm_sms_check_data_complete(awaited_index) == TRUE)
  1113.             {
  1114.                 mmi_frm_sms_data_counter[awaited_index] = MMI_FRM_SMS_INVALID_NUM;
  1115.                 *index = awaited_index;
  1116.                 return MMI_FRM_SMS_DATA;
  1117.             }
  1118.             /* not all segments of this message are arrived */
  1119.             else
  1120.             {
  1121.                 U8 dataindex = 0;
  1123.                 /* check if mmi_frm_sms_content is full */
  1124.                 while (dataindex < MMI_FRM_SMS_MSG_CONTENT_NUM)
  1125.                 {
  1126.                     if (mmi_frm_sms_content[dataindex].segment == MMI_FRM_SMS_INVALID_NUM)
  1127.                     {
  1128.                         /* mmi_frm_sms_content is not full, restart the counter to keep waiting for other segment's arriving */
  1129.                         mmi_frm_sms_data_counter[awaited_index] = 0;
  1130.                         *index = awaited_index;
  1131.                         return MMI_FRM_SMS_NOBOX;
  1132.                     }
  1133.                     dataindex++;
  1134.                 }
  1135.                 /* mmi_frm_sms_content is full, reset the counter and free this message */
  1136.                 mmi_frm_sms_data_counter[awaited_index] = MMI_FRM_SMS_INVALID_NUM;
  1137.                 mmi_frm_sms_free_data(awaited_index);
  1138.                 *index = awaited_index;
  1139.                 return MMI_FRM_SMS_NOBOX;
  1140.             }
  1141.         }
  1142.         else
  1143.         {
  1144.             /* cannot find any match in data list, add one entry with index awaited_index in the mmi_frm_sms_data */
  1145.             awaited_index = mmi_frm_sms_add_data_entry();
  1146.             /* find an empty entry in the data list and add successfully */
  1147.             if (awaited_index != MMI_FRM_SMS_INVALID_NUM)
  1148.             {
  1149.                 mmi_frm_sms_free_new_data();
  1150.                 /* the timer is not started yet */
  1151.                 if (mmi_frm_sms_data_counting == FALSE)
  1152.                 {
  1153.                     StartTimer(
  1154.                         MESSAGES_LMS_RECV_TIMER_ID,
  1155.                         MMI_FRM_SMS_LMS_TIME_OUT,
  1156.                         mmi_frm_sms_timeout_concatenate_data);
  1157.                     mmi_frm_sms_data_counting = TRUE;
  1158.                 }
  1159.                 mmi_frm_sms_data_counter[awaited_index] = 0;
  1160.                 *index = MMI_FRM_SMS_INVALID_NUM;
  1161.                 return MMI_FRM_SMS_NOBOX;
  1162.             }
  1163.             /* data list or content list is full and the segment should be discarded */
  1164.             else
  1165.             {
  1166.                 mmi_frm_sms_free_new_data();
  1167.                 *index = MMI_FRM_SMS_ACTION_SIZE;
  1168.                 return MMI_FRM_SMS_NOBOX;
  1169.             }
  1170.         }
  1171.     }
  1172. }
  1175. /*****************************************************************************
  1176.  * FUNCTION
  1177.  *  mmi_frm_sms_check_data_complete
  1178.  * DESCRIPTION
  1179.  *  Check SMS with port completeness
  1180.  * PARAMETERS
  1181.  *  index       [IN]        Index
  1182.  * RETURNS
  1183.  *  TRUE: complete, FALSE: not
  1184.  *****************************************************************************/
  1185. U8 mmi_frm_sms_check_data_complete(U8 index)
  1186. {
  1187.     /*----------------------------------------------------------------*/
  1188.     /* Local Variables                                                */
  1189.     /*----------------------------------------------------------------*/
  1190.     U8 i = 0;
  1191.     mmi_frm_sms_concat_struct *concat_info = (mmi_frm_sms_concat_struct*) & (mmi_frm_sms_data[index].concat_info);
  1192.     U8 total_seg = ((concat_info->total_seg - concat_info->seg + 1) > g_frm_sms_cntx.mmi_frm_sms_msg_seg_size) ?
  1193.         g_frm_sms_cntx.mmi_frm_sms_msg_seg_size : (concat_info->total_seg - concat_info->seg + 1);
  1194.     U8 dataindex = mmi_frm_sms_data[index].data[0];
  1196.     /*----------------------------------------------------------------*/
  1197.     /* Code Body                                                      */
  1198.     /*----------------------------------------------------------------*/
  1199.     /* if the message has only one segment */
  1200.     if (index == MMI_FRM_SMS_ACTION_SIZE)
  1201.     {
  1202.         return TRUE;
  1203.     }
  1204.     while (dataindex != MMI_FRM_SMS_INVALID_NUM)
  1205.     {
  1206.         if (mmi_frm_sms_content[dataindex].segment != (i + 1))
  1207.         {
  1208.             return FALSE;
  1209.         }
  1210.         dataindex = mmi_frm_sms_content[dataindex].nextindex;
  1211.         i++;
  1212.     }
  1213.     if (i == total_seg)
  1214.     {
  1215.         return TRUE;
  1216.     }
  1217.     else
  1218.     {
  1219.         return FALSE;
  1220.     }
  1221. }
  1223. /* given msg box index, change to type */
  1226. /*****************************************************************************
  1227.  * FUNCTION
  1228.  *  mmi_frm_sms_set_sms_status
  1229.  * DESCRIPTION
  1230.  *  Set SMS status
  1231.  * PARAMETERS
  1232.  *  type        [IN]        Origin type
  1233.  *  index       [IN]        Index
  1234.  *  newtype     [IN]        Type to be set
  1235.  * RETURNS
  1236.  * TRUE
  1237.  *****************************************************************************/
  1238. U8 mmi_frm_sms_set_sms_status(U8 type, U16 index, U8 newtype)
  1239. {
  1240.     /*----------------------------------------------------------------*/
  1241.     /* Local Variables                                                */
  1242.     /*----------------------------------------------------------------*/
  1243.     U8 mti;
  1244.     U16 msgindex;
  1246.     /*----------------------------------------------------------------*/
  1247.     /* Code Body                                                      */
  1248.     /*----------------------------------------------------------------*/
  1249.     switch (type)
  1250.     {
  1251.         case MMI_FRM_SMS_NOBOX:
  1252.             msgindex = index;
  1253.             mti = (mmi_frm_sms_msg_box[msgindex].msgtype & 0xf0);
  1254.             mmi_frm_sms_msg_box[msgindex].msgtype = mti | newtype;
  1255.             break;
  1256.         case MMI_FRM_SMS_INBOX:
  1257.         case MMI_FRM_SMS_UNREAD:
  1258.             msgindex = mmi_frm_sms_inbox_list[index];
  1259.             mti = (mmi_frm_sms_msg_box[msgindex].msgtype & 0xf0);
  1260.             mmi_frm_sms_msg_box[msgindex].msgtype = mti | newtype;
  1261.             break;
  1262.         default:
  1263.             PRINT_INFORMATION_2((MMI_TRACE_G6_SMS,
  1264.                                  "*-------[SmsUtil.c] mmi_frm_sms_set_sms_status DO NOTHING -------*n"));
  1265.             break;
  1266.     }
  1267.     return TRUE;
  1268. }
  1271. /*****************************************************************************
  1272.  * FUNCTION
  1273.  *  mmi_frm_sms_get_sms_status
  1274.  * DESCRIPTION
  1275.  *  Get SMS status
  1276.  * PARAMETERS
  1277.  *  type        [IN]        Type
  1278.  *  index       [IN]        Index
  1279.  * RETURNS
  1280.  *  status
  1281.  *****************************************************************************/
  1282. U8 mmi_frm_sms_get_sms_status(U8 type, U16 index)
  1283. {
  1284.     /*----------------------------------------------------------------*/
  1285.     /* Local Variables                                                */
  1286.     /*----------------------------------------------------------------*/
  1287.     U16 entryindex = index;
  1289.     /*----------------------------------------------------------------*/
  1290.     /* Code Body                                                      */
  1291.     /*----------------------------------------------------------------*/
  1292.     switch (type)
  1293.     {
  1294.         case MMI_FRM_SMS_INBOX:
  1295.         case MMI_FRM_SMS_UNREAD:
  1296.             entryindex = mmi_frm_sms_inbox_list[index];
  1297.             break;
  1298.         case MMI_FRM_SMS_OUTBOX:
  1299.     #ifndef __MMI_MESSAGES_DRAFT_BOX__
  1300.         case MMI_FRM_SMS_DRAFTS:
  1301.     #endif 
  1302.             entryindex = mmi_frm_sms_outbox_list[index];
  1303.             break;
  1304.     #ifdef __MMI_MESSAGES_DRAFT_BOX__
  1305.         case MMI_FRM_SMS_DRAFTS:
  1306.     #ifdef __MMI_UNIFIED_MESSAGE__
  1307.         case MMI_FRM_SMS_UNSENT:
  1308.     #endif 
  1309.             entryindex = mmi_frm_sms_drafts_list[index];
  1310.             break;
  1311.     #endif /* __MMI_MESSAGES_DRAFT_BOX__ */ 
  1312.     }
  1313.     return mmi_frm_sms_msg_box[entryindex].msgtype;
  1314. }
  1317. /*****************************************************************************
  1318.  * FUNCTION
  1319.  *  mmi_frm_sms_get_sms_dcs
  1320.  * DESCRIPTION
  1321.  *  Get SMS DCS
  1322.  * PARAMETERS
  1323.  *  type        [IN]        Type
  1324.  *  index       [IN]        Index
  1325.  * RETURNS
  1326.  *  dcs
  1327.  *****************************************************************************/
  1328. U8 mmi_frm_sms_get_sms_dcs(U8 type, U16 index)
  1329. {
  1330.     /*----------------------------------------------------------------*/
  1331.     /* Local Variables                                                */
  1332.     /*----------------------------------------------------------------*/
  1334.     /*----------------------------------------------------------------*/
  1335.     /* Code Body                                                      */
  1336.     /*----------------------------------------------------------------*/
  1337.     if (type == MMI_FRM_SMS_DATA)
  1338.     {
  1339.         return mmi_frm_sms_data[index].dcs;
  1340.     }
  1341.     else
  1342.     {
  1343.         return SMSAL_8BIT_DCS;
  1344.     }
  1345. }
  1348. /*****************************************************************************
  1349.  * FUNCTION
  1350.  *  mmi_frm_sms_get_sms_address
  1351.  * DESCRIPTION
  1352.  *  Get SMS address
  1353.  * PARAMETERS
  1354.  *  type        [IN]        Type
  1355.  *  index       [IN]        Index
  1356.  * RETURNS
  1357.  *  address
  1358.  *****************************************************************************/
  1359. U8 *mmi_frm_sms_get_sms_address(U8 type, U16 index)
  1360. {
  1361.     /*----------------------------------------------------------------*/
  1362.     /* Local Variables                                                */
  1363.     /*----------------------------------------------------------------*/
  1364.     U16 entryindex = index;
  1366.     /*----------------------------------------------------------------*/
  1367.     /* Code Body                                                      */
  1368.     /*----------------------------------------------------------------*/
  1369.     switch (type)
  1370.     {
  1371.         case MMI_FRM_SMS_INBOX:
  1372.         case MMI_FRM_SMS_UNREAD:
  1373.             entryindex = mmi_frm_sms_inbox_list[index];
  1374.             break;
  1375.         case MMI_FRM_SMS_OUTBOX:
  1376.     #ifndef __MMI_MESSAGES_DRAFT_BOX__
  1377.         case MMI_FRM_SMS_DRAFTS:
  1378.     #endif 
  1379.             entryindex = mmi_frm_sms_outbox_list[index];
  1380.             break;
  1381.     #ifdef __MMI_MESSAGES_DRAFT_BOX__
  1382.         case MMI_FRM_SMS_DRAFTS:
  1383.     #ifdef __MMI_UNIFIED_MESSAGE__
  1384.         case MMI_FRM_SMS_UNSENT:
  1385.     #endif 
  1386.             entryindex = mmi_frm_sms_drafts_list[index];
  1387.             break;
  1388.     #endif /* __MMI_MESSAGES_DRAFT_BOX__ */ 
  1389.         default:
  1390.             entryindex = index;
  1391.             break;
  1392.     }
  1393.     if (type == MMI_FRM_SMS_DATA)
  1394.     {
  1395.         return (U8*) & mmi_frm_sms_data[entryindex].oa;
  1396.     }
  1397.     else
  1398.     {
  1399.         return mmi_frm_sms_msg_box[entryindex].number;
  1400.     }
  1401. }
  1404. /*****************************************************************************
  1405.  * FUNCTION
  1406.  *  mmi_frm_sms_get_sms_timestamp
  1407.  * DESCRIPTION
  1408.  *  Get SMS timestamp
  1409.  * PARAMETERS
  1410.  *  type        [IN]        Type
  1411.  *  index       [IN]        Index
  1412.  * RETURNS
  1413.  *  timestamp
  1414.  *****************************************************************************/
  1415. U8 *mmi_frm_sms_get_sms_timestamp(U8 type, U16 index)
  1416. {
  1417.     /*----------------------------------------------------------------*/
  1418.     /* Local Variables                                                */
  1419.     /*----------------------------------------------------------------*/
  1420.     U16 entryindex = index;
  1422.     /*----------------------------------------------------------------*/
  1423.     /* Code Body                                                      */
  1424.     /*----------------------------------------------------------------*/
  1425.     switch (type)
  1426.     {
  1427.         case MMI_FRM_SMS_INBOX:
  1428.         case MMI_FRM_SMS_UNREAD:
  1429.             entryindex = mmi_frm_sms_inbox_list[index];
  1430.             break;
  1431.         case MMI_FRM_SMS_OUTBOX:
  1432.     #ifndef __MMI_MESSAGES_DRAFT_BOX__
  1433.         case MMI_FRM_SMS_DRAFTS:
  1434.     #endif 
  1435.             entryindex = mmi_frm_sms_outbox_list[index];
  1436.             break;
  1437.     #ifdef __MMI_MESSAGES_DRAFT_BOX__
  1438.         case MMI_FRM_SMS_DRAFTS:
  1439.     #ifdef __MMI_UNIFIED_MESSAGE__
  1440.         case MMI_FRM_SMS_UNSENT:
  1441.     #endif 
  1442.             entryindex = mmi_frm_sms_drafts_list[index];
  1443.             break;
  1444.     #endif /* __MMI_MESSAGES_DRAFT_BOX__ */ 
  1445.     }
  1446.     if (type == MMI_FRM_SMS_DATA)
  1447.     {
  1448.         return mmi_frm_sms_data[entryindex].scts;
  1449.     }
  1450.     else
  1451.     {
  1452.         return mmi_frm_sms_msg_box[entryindex].timestamp;
  1453.     }
  1454. }
  1457. /*****************************************************************************
  1458.  * FUNCTION
  1459.  *  mmi_frm_sms_get_sms_size
  1460.  * DESCRIPTION
  1461.  *  Get SMS size
  1462.  * PARAMETERS
  1463.  *  type        [IN]        Type
  1464.  *  index       [IN]        Index
  1465.  * RETURNS
  1466.  *  size
  1467.  *****************************************************************************/
  1468. U8 mmi_frm_sms_get_sms_size(U8 type, U16 index)
  1469. {
  1470.     /*----------------------------------------------------------------*/
  1471.     /* Local Variables                                                */
  1472.     /*----------------------------------------------------------------*/
  1473.     U16 msgindex = 0;
  1474.     U8 totalseg = 0;
  1476.     /*----------------------------------------------------------------*/
  1477.     /* Code Body                                                      */
  1478.     /*----------------------------------------------------------------*/
  1479.     switch (type)
  1480.     {
  1481.         case MMI_FRM_SMS_NOBOX:
  1482.             msgindex = index;
  1483.             break;
  1485.         case MMI_FRM_SMS_INBOX:
  1486.         case MMI_FRM_SMS_UNREAD:
  1487.             msgindex = mmi_frm_sms_inbox_list[index];
  1488.             break;
  1490.         case MMI_FRM_SMS_OUTBOX:
  1491.     #ifndef __MMI_MESSAGES_DRAFT_BOX__
  1492.         case MMI_FRM_SMS_DRAFTS:
  1493.     #endif 
  1494.             msgindex = mmi_frm_sms_outbox_list[index];
  1495.             break;
  1497.     #ifdef __MMI_MESSAGES_DRAFT_BOX__
  1498.         case MMI_FRM_SMS_DRAFTS:
  1499.             msgindex = mmi_frm_sms_drafts_list[index];
  1500.             break;
  1501.     #endif /* __MMI_MESSAGES_DRAFT_BOX__ */ 
  1502.     }
  1503.     totalseg = mmi_frm_sms_msg_box[msgindex].totalseg - mmi_frm_sms_msg_box[msgindex].startseg + 1;
  1504.     return ((totalseg > g_frm_sms_cntx.mmi_frm_sms_msg_seg_size) ? g_frm_sms_cntx.mmi_frm_sms_msg_seg_size : totalseg);
  1505. }
  1508. /*****************************************************************************
  1509.  * FUNCTION
  1510.  *  mmi_frm_sms_get_sms_received_size
  1511.  * DESCRIPTION
  1512.  *  Get SMS received segment number
  1513.  * PARAMETERS
  1514.  *  type        [IN]        Type
  1515.  *  index       [IN]        Index
  1516.  * RETURNS
  1517.  *  size
  1518.  *****************************************************************************/
  1519. U8 mmi_frm_sms_get_sms_received_size(U8 type, U16 index)
  1520. {
  1521.     /*----------------------------------------------------------------*/
  1522.     /* Local Variables                                                */
  1523.     /*----------------------------------------------------------------*/
  1524.     U16 msgindex = 0;
  1525.     U8 receivedseg = 0;
  1526.     unsigned short l4index;
  1528.     /*----------------------------------------------------------------*/
  1529.     /* Code Body                                                      */
  1530.     /*----------------------------------------------------------------*/
  1531.     switch (type)
  1532.     {
  1533.         case MMI_FRM_SMS_NOBOX:
  1534.             msgindex = index;
  1535.             break;
  1537.         case MMI_FRM_SMS_INBOX:
  1538.         case MMI_FRM_SMS_UNREAD:
  1539.             msgindex = mmi_frm_sms_inbox_list[index];
  1540.             break;
  1542.         case MMI_FRM_SMS_OUTBOX:
  1543.     #ifndef __MMI_MESSAGES_DRAFT_BOX__
  1544.         case MMI_FRM_SMS_DRAFTS:
  1545.     #endif 
  1546.             msgindex = mmi_frm_sms_outbox_list[index];
  1547.             break;
  1549.     #ifdef __MMI_MESSAGES_DRAFT_BOX__
  1550.         case MMI_FRM_SMS_DRAFTS:
  1551.             msgindex = mmi_frm_sms_drafts_list[index];
  1552.             break;
  1553.     #endif /* __MMI_MESSAGES_DRAFT_BOX__ */ 
  1554.     }
  1556.     l4index = mmi_frm_sms_msg_box[msgindex].startindex;
  1557.     while (l4index != MMI_FRM_SMS_INVALID_INDEX)
  1558.     {
  1559.         receivedseg++;
  1560.         l4index = mmi_frm_sms_index_list[l4index].nextindex;
  1561.     }
  1562.     return receivedseg;
  1563. }
  1566. /*****************************************************************************
  1567.  * FUNCTION
  1568.  *  mmi_frm_sms_get_sms_list_size
  1569.  * DESCRIPTION
  1570.  *  Get SMS list size
  1571.  * PARAMETERS
  1572.  *  type        [IN]        Type
  1573.  * RETURNS
  1574.  *  size
  1575.  *****************************************************************************/
  1576. U16 mmi_frm_sms_get_sms_list_size(U8 type)
  1577. {
  1578.     /*----------------------------------------------------------------*/
  1579.     /* Local Variables                                                */
  1580.     /*----------------------------------------------------------------*/
  1582.     /*----------------------------------------------------------------*/
  1583.     /* Code Body                                                      */
  1584.     /*----------------------------------------------------------------*/
  1585.     if (mmi_frm_sms_list_done == FALSE || g_frm_sms_cntx.mmi_frm_sms_ready == FALSE)
  1586.     {
  1587.         return MMI_FRM_SMS_INVALID_INDEX;
  1588.     }
  1589.     switch (type)
  1590.     {
  1591.         case MMI_FRM_SMS_INBOX:
  1592.         case MMI_FRM_SMS_UNREAD:
  1593.             return mmi_frm_sms_inbox_size;
  1594.         case MMI_FRM_SMS_OUTBOX:
  1595.     #ifndef __MMI_MESSAGES_DRAFT_BOX__
  1596.         case MMI_FRM_SMS_DRAFTS:
  1597.     #endif 
  1598.             return mmi_frm_sms_outbox_size;
  1599.     #ifdef __MMI_MESSAGES_DRAFT_BOX__
  1600.         case MMI_FRM_SMS_DRAFTS:
  1601.     #ifdef __MMI_UNIFIED_MESSAGE__
  1602.         {
  1603.             kal_uint16 msg_num = 0;
  1605.             mmi_frm_sms_get_draft_msg_num(&msg_num);
  1607.             return msg_num;
  1608.         }
  1609.     #else /* __MMI_UNIFIED_MESSAGE__ */ 
  1610.             return mmi_frm_sms_drafts_size;
  1611.     #endif /* __MMI_UNIFIED_MESSAGE__ */ 
  1612.     #endif /* __MMI_MESSAGES_DRAFT_BOX__ */ 
  1614.     #ifdef __MMI_UNIFIED_MESSAGE__
  1615.         case MMI_FRM_SMS_UNSENT:
  1616.         {
  1617.             kal_uint16 msg_num = 0;
  1619.             mmi_frm_sms_get_unsent_msg_num(&msg_num);
  1621.             return msg_num;
  1622.         }
  1624.     #endif /* __MMI_UNIFIED_MESSAGE__ */ 
  1625.     }
  1626.     return 0;
  1627. }
  1630. /*****************************************************************************
  1631.  * FUNCTION
  1632.  *  mmi_frm_sms_get_data_check
  1633.  * DESCRIPTION
  1634.  *  See if data is checked
  1635.  * PARAMETERS
  1636.  *  index       [IN]        Index
  1637.  * RETURNS
  1638.  *  Check or not
  1639.  *****************************************************************************/
  1640. U8 mmi_frm_sms_get_data_check(U8 index)
  1641. {
  1642.     /*----------------------------------------------------------------*/
  1643.     /* Local Variables                                                */
  1644.     /*----------------------------------------------------------------*/
  1646.     /*----------------------------------------------------------------*/
  1647.     /* Code Body                                                      */
  1648.     /*----------------------------------------------------------------*/
  1649.     return (mmi_frm_sms_data_checked >> index) & 0x01;
  1650. }
  1653. /*****************************************************************************
  1654.  * FUNCTION
  1655.  *  mmi_frm_sms_set_data_check
  1656.  * DESCRIPTION
  1657.  *  Set SMS check
  1658.  * PARAMETERS
  1659.  *  index       [IN]        Index
  1660.  *  set         [IN]        1/0
  1661.  * RETURNS
  1662.  *  void
  1663.  *****************************************************************************/
  1664. void mmi_frm_sms_set_data_check(U8 index, U8 set)
  1665. {
  1666.     /*----------------------------------------------------------------*/
  1667.     /* Local Variables                                                */
  1668.     /*----------------------------------------------------------------*/
  1669.     U16 resetVector = (U16) (0xffff - (1 << index));
  1670.     U16 setVector = (U16) set;
  1672.     /*----------------------------------------------------------------*/
  1673.     /* Code Body                                                      */
  1674.     /*----------------------------------------------------------------*/
  1675.     setVector = setVector << index;
  1677.     /* Reset the check bit to zero  */
  1678.     mmi_frm_sms_data_checked &= resetVector;
  1680.     mmi_frm_sms_data_checked |= setVector;
  1681. }
  1683. #ifdef __MMI_MESSAGES_COPY__
  1686. /*****************************************************************************
  1687.  * FUNCTION
  1688.  *  mmi_frm_sms_get_sms_storage
  1689.  * DESCRIPTION
  1690.  *  get SMS storage type
  1691.  * PARAMETERS
  1692.  *  type        [IN]        mmi_frm_sms_app_msgbox_enum
  1693.  *  index       [IN]        message list index
  1694.  * RETURNS
  1695.  *  smsal_storage_enum (SMSAL_SM or SMSAL_ME)
  1696.  *****************************************************************************/
  1697. U8 mmi_frm_sms_get_sms_storage(U8 type, U16 index)
  1698. {
  1699.     /*----------------------------------------------------------------*/
  1700.     /* Local Variables                                                */
  1701.     /*----------------------------------------------------------------*/
  1702.     U16 msgindex = 0;
  1704.     /*----------------------------------------------------------------*/
  1705.     /* Code Body                                                      */
  1706.     /*----------------------------------------------------------------*/
  1707.     switch (type)
  1708.     {
  1709.         case MMI_FRM_SMS_NOBOX:
  1710.             msgindex = index;
  1711.             break;
  1713.         case MMI_FRM_SMS_INBOX:
  1714.         case MMI_FRM_SMS_UNREAD:
  1715.             msgindex = mmi_frm_sms_inbox_list[index];
  1716.             break;
  1718.         case MMI_FRM_SMS_OUTBOX:
  1719.     #ifndef __MMI_MESSAGES_DRAFT_BOX__
  1720.         case MMI_FRM_SMS_DRAFTS:
  1721.     #endif 
  1722.             msgindex = mmi_frm_sms_outbox_list[index];
  1723.             break;
  1725.     #ifdef __MMI_MESSAGES_DRAFT_BOX__
  1726.         case MMI_FRM_SMS_DRAFTS:
  1727.     #ifdef __MMI_UNIFIED_MESSAGE__
  1728.         case MMI_FRM_SMS_UNSENT:
  1729.     #endif 
  1730.             msgindex = mmi_frm_sms_drafts_list[index];
  1731.             break;
  1732.     #endif /* __MMI_MESSAGES_DRAFT_BOX__ */ 
  1733.     }
  1735.     return mmi_frm_sms_msg_box[msgindex].storageType;
  1736. }
  1739. /*****************************************************************************
  1740.  * FUNCTION
  1741.  *  mmi_frm_sms_copy_sms_abort
  1742.  * DESCRIPTION
  1743.  *  abort SMS copy action
  1744.  * PARAMETERS
  1745.  *  void
  1746.  * RETURNS
  1747.  *  void
  1748.  *****************************************************************************/
  1749. void mmi_frm_sms_copy_sms_abort()
  1750. {
  1751.     /*----------------------------------------------------------------*/
  1752.     /* Local Variables                                                */
  1753.     /*----------------------------------------------------------------*/
  1755.     /*----------------------------------------------------------------*/
  1756.     /* Code Body                                                      */
  1757.     /*----------------------------------------------------------------*/
  1758.     g_frm_sms_copy_info.is_aborted = TRUE;
  1759.     return;
  1760. }
  1761. #endif /* __MMI_MESSAGES_COPY__ */ 
  1764. /*****************************************************************************
  1765.  * FUNCTION
  1766.  *  mmi_frm_sms_swap_list_index
  1767.  * DESCRIPTION
  1768.  *  swap list index
  1769.  * PARAMETERS
  1770.  *  type        [IN]        mmi_frm_sms_app_msgbox_enum, only inbox, outbox or draft
  1771.  *  index1      [IN]        
  1772.  *  index2      [IN]        
  1773.  * RETURNS
  1774.  *  void
  1775.  *****************************************************************************/
  1776. void mmi_frm_sms_swap_list_index(U8 type, U16 index1, U16 index2)
  1777. {
  1778.     /*----------------------------------------------------------------*/
  1779.     /* Local Variables                                                */
  1780.     /*----------------------------------------------------------------*/
  1781.     U16 msgindex;
  1783.     /*----------------------------------------------------------------*/
  1784.     /* Code Body                                                      */
  1785.     /*----------------------------------------------------------------*/
  1786.     switch (type)
  1787.     {
  1788.         case MMI_FRM_SMS_INBOX:
  1789.         case MMI_FRM_SMS_UNREAD:
  1790.             msgindex = mmi_frm_sms_inbox_list[index1];
  1791.             mmi_frm_sms_inbox_list[index1] = mmi_frm_sms_inbox_list[index2];
  1792.             mmi_frm_sms_inbox_list[index2] = msgindex;
  1793.             break;
  1795.         case MMI_FRM_SMS_OUTBOX:
  1796.     #ifndef __MMI_MESSAGES_DRAFT_BOX__
  1797.         case MMI_FRM_SMS_DRAFTS:
  1798.     #endif 
  1799.             msgindex = mmi_frm_sms_outbox_list[index1];
  1800.             mmi_frm_sms_outbox_list[index1] = mmi_frm_sms_outbox_list[index2];
  1801.             mmi_frm_sms_outbox_list[index2] = msgindex;
  1802.             break;
  1804.     #ifdef __MMI_MESSAGES_DRAFT_BOX__
  1805.         case MMI_FRM_SMS_DRAFTS:
  1806.             msgindex = mmi_frm_sms_drafts_list[index1];
  1807.             mmi_frm_sms_drafts_list[index1] = mmi_frm_sms_drafts_list[index2];
  1808.             mmi_frm_sms_drafts_list[index2] = msgindex;
  1809.             break;
  1810.     #endif /* __MMI_MESSAGES_DRAFT_BOX__ */ 
  1812.         default:
  1813.             return;
  1814.     }
  1816.     return;
  1817. }
  1819. #ifdef __MMI_MESSAGES_SINGLE_DELIVERY_REPORT__
  1822. /*****************************************************************************
  1823.  * FUNCTION
  1824.  *  mmi_frm_sms_set_delivery_report_awaited_check
  1825.  * DESCRIPTION
  1826.  *  set check bit of msg box in delivery report list
  1827.  * PARAMETERS
  1828.  *  delivery_report_awaited_index       [IN]        
  1829.  *  msg_ref                             [IN]        
  1830.  *  status_type                         [IN]        
  1831.  * RETURNS
  1832.  *  void
  1833.  *****************************************************************************/
  1834. void mmi_frm_sms_set_delivery_report_awaited_check(U16 delivery_report_awaited_index, U8 msg_ref, U8 status_type)
  1835. {
  1836.     /*----------------------------------------------------------------*/
  1837.     /* Local Variables                                                */
  1838.     /*----------------------------------------------------------------*/
  1839.     U16 list_index = delivery_report_awaited_index;
  1840.     U8 mr = msg_ref;
  1841.     U8 st = status_type;
  1842.     int i = 0;
  1843.     mmi_frm_sms_delivery_report_box_struct *box = mmi_frm_sms_delivery_report_awaited[list_index].ptr;
  1845.     /*----------------------------------------------------------------*/
  1846.     /* Code Body                                                      */
  1847.     /*----------------------------------------------------------------*/
  1848.     if (st != ST_COMP_MSG_RECV_BY_SME)
  1849.     {
  1850.         mmi_frm_sms_delivery_report_awaited[list_index].result = st;
  1851.     }
  1853.     for (i = 0; i < mmi_frm_sms_delivery_report_awaited[list_index].box_number; i++)
  1854.     {
  1855.         if (box[i].mr == mr)
  1856.         {
  1857.             box[i].check_bit = 1;
  1858.             return;
  1859.         }
  1860.     }
  1861. }
  1864. /*****************************************************************************
  1865.  * FUNCTION
  1866.  *  mmi_frm_sms_set_delivery_report_awaited_mr
  1867.  * DESCRIPTION
  1868.  *  set message reference of msg box in delivery report list
  1869.  * PARAMETERS
  1870.  *  delivery_report_awaited_index       [IN]        
  1871.  *  msg_ref                             [IN]        
  1872.  *  seq_number                          [IN]        
  1873.  * RETURNS
  1874.  *  void
  1875.  *****************************************************************************/
  1876. void mmi_frm_sms_set_delivery_report_awaited_mr(U16 delivery_report_awaited_index, U8 msg_ref, U8 seq_number)
  1877. {
  1878.     /*----------------------------------------------------------------*/
  1879.     /* Local Variables                                                */
  1880.     /*----------------------------------------------------------------*/
  1881.     U8 mr = msg_ref;
  1882.     U8 seq_no = seq_number;
  1883.     U16 list_index = delivery_report_awaited_index;
  1884.     mmi_frm_sms_delivery_report_box_struct *box;
  1886.     /*----------------------------------------------------------------*/
  1887.     /* Code Body                                                      */
  1888.     /*----------------------------------------------------------------*/
  1889.     if (seq_no < mmi_frm_sms_delivery_report_awaited[list_index].box_number)
  1890.     {
  1891.         box = mmi_frm_sms_delivery_report_awaited[list_index].ptr;
  1892.         box[seq_no].mr = mr;
  1893.     }
  1895.     return;
  1896. }
  1899. /*****************************************************************************
  1900.  * FUNCTION
  1901.  *  mmi_frm_sms_check_delivery_report_awaited_complete
  1902.  * DESCRIPTION
  1903.  *  check if entry of delivery report awaited list is complete
  1904.  * PARAMETERS
  1905.  *  delivery_report_awaited_index       [IN]        
  1906.  * RETURNS
  1907.  *  
  1908.  *****************************************************************************/
  1909. BOOL mmi_frm_sms_check_delivery_report_awaited_complete(U16 delivery_report_awaited_index)
  1910. {
  1911.     /*----------------------------------------------------------------*/
  1912.     /* Local Variables                                                */
  1913.     /*----------------------------------------------------------------*/
  1914.     U16 list_index = delivery_report_awaited_index;
  1915.     int i = 0;
  1916.     mmi_frm_sms_delivery_report_box_struct *box = mmi_frm_sms_delivery_report_awaited[list_index].ptr;
  1918.     /*----------------------------------------------------------------*/
  1919.     /* Code Body                                                      */
  1920.     /*----------------------------------------------------------------*/
  1921.     for (i = 0; i < mmi_frm_sms_delivery_report_awaited[list_index].box_number; i++)
  1922.     {
  1923.         if (box[i].check_bit == 0)
  1924.         {
  1925.             return FALSE;
  1926.         }
  1927.     }
  1929.     return TRUE;
  1930. }
  1933. /*****************************************************************************
  1934.  * FUNCTION
  1935.  *  mmi_frm_sms_remove_delivery_report_awaited
  1936.  * DESCRIPTION
  1937.  *  remove delivery report list entry with the specified list index
  1938.  * PARAMETERS
  1939.  *  delivery_report_awaited_list_index      [IN]        
  1940.  * RETURNS
  1941.  *  index of delivery_report_awaited list(?)
  1942.  *  MMI_FRM_SMS_ACTION_SIZE means not found(?)
  1943.  *****************************************************************************/
  1944. void mmi_frm_sms_remove_delivery_report_awaited(U16 delivery_report_awaited_list_index)
  1945. {
  1946.     /*----------------------------------------------------------------*/
  1947.     /* Local Variables                                                */
  1948.     /*----------------------------------------------------------------*/
  1949.     U16 list_index = delivery_report_awaited_list_index;;
  1951.     /*----------------------------------------------------------------*/
  1952.     /* Code Body                                                      */
  1953.     /*----------------------------------------------------------------*/
  1954.     mmi_frm_sms_delivery_report_awaited[list_index].result = 0;
  1955.     mmi_frm_sms_delivery_report_awaited[list_index].ref = 0;
  1956.     mmi_frm_sms_delivery_report_awaited[list_index].box_number = 0;
  1957.     if (mmi_frm_sms_delivery_report_awaited[list_index].ptr != NULL)
  1958.     {
  1959.         OslMfree(mmi_frm_sms_delivery_report_awaited[list_index].ptr);
  1960.         mmi_frm_sms_delivery_report_awaited[list_index].ptr = NULL;
  1961.     }
  1962.     return;
  1963. }
  1966. /*****************************************************************************
  1967.  * FUNCTION
  1968.  *  mmi_frm_sms_get_delivery_report_index_by_mr
  1969.  * DESCRIPTION
  1970.  *  check if delivery report box with the specified message reference already in list
  1971.  * PARAMETERS
  1972.  *  mr      [IN]        
  1973.  * RETURNS
  1974.  *  index of delivery_report_awaited list
  1975.  *  MMI_FRM_SMS_ACTION_SIZE means not found
  1976.  *****************************************************************************/
  1977. U16 mmi_frm_sms_get_delivery_report_index_by_mr(U8 mr)
  1978. {
  1979.     /*----------------------------------------------------------------*/
  1980.     /* Local Variables                                                */
  1981.     /*----------------------------------------------------------------*/
  1982.     U8 msg_reference = mr;
  1983.     int list_index = 0;
  1985.     /*----------------------------------------------------------------*/
  1986.     /* Code Body                                                      */
  1987.     /*----------------------------------------------------------------*/
  1988.     for (list_index = 0; list_index < MMI_FRM_SMS_ACTION_SIZE; list_index++)
  1989.     {
  1990.         if (mmi_frm_sms_delivery_report_awaited[list_index].box_number != 0)
  1991.         {
  1992.             int box_no = mmi_frm_sms_delivery_report_awaited[list_index].box_number;
  1993.             int box_index = 0;
  1994.             mmi_frm_sms_delivery_report_box_struct *box = mmi_frm_sms_delivery_report_awaited[list_index].ptr;
  1996.             for (box_index = 0; box_index < box_no; box_index++)
  1997.             {
  1998.                 if (box[box_index].mr == msg_reference)
  1999.                 {
  2000.                     return list_index;
  2001.                 }
  2002.             }
  2003.         }
  2004.     }
  2006.     return list_index;
  2008. }
  2011. /*****************************************************************************
  2012.  * FUNCTION
  2013.  *  mmi_frm_sms_get_delivery_report_index_by_ref
  2014.  * DESCRIPTION
  2015.  *  check if delivery report entry with the specified reference number already in list
  2016.  * PARAMETERS
  2017.  *  ref     [IN]        
  2018.  * RETURNS
  2019.  *  index of delivery_report_awaited list
  2020.  *  MMI_FRM_SMS_ACTION_SIZE means not found
  2021.  *****************************************************************************/
  2022. U16 mmi_frm_sms_get_delivery_report_index_by_ref(U16 ref)
  2023. {
  2024.     /*----------------------------------------------------------------*/
  2025.     /* Local Variables                                                */
  2026.     /*----------------------------------------------------------------*/
  2027.     U16 reference_no = ref;
  2028.     int list_index = 0;
  2030.     /*----------------------------------------------------------------*/
  2031.     /* Code Body                                                      */
  2032.     /*----------------------------------------------------------------*/
  2033.     for (list_index = 0; list_index < MMI_FRM_SMS_ACTION_SIZE; list_index++)
  2034.     {
  2035.         if (mmi_frm_sms_delivery_report_awaited[list_index].box_number != 0)
  2036.         {
  2037.             if (mmi_frm_sms_delivery_report_awaited[list_index].ref == reference_no)
  2038.             {
  2039.                 return list_index;
  2040.             }
  2041.         }
  2042.     }
  2044.     return list_index;
  2045. }
  2048. /*****************************************************************************
  2049.  * FUNCTION
  2050.  *  mmi_frm_sms_add_delivery_report_awaited
  2051.  * DESCRIPTION
  2052.  *  add entry to delivery report awaited list
  2053.  * PARAMETERS
  2054.  *  reference_number        [IN]        
  2055.  *  total_segment           [IN]        
  2056.  *  index                   [IN]        
  2057.  *  mr                      [IN]        
  2058.  * RETURNS
  2059.  *  ref         : reference number(?)
  2060.  *  total_segment  : number of total segments(?)
  2061.  *  index : segment number -1(?)
  2062.  *  mr    : message reference(?)
  2063.  *****************************************************************************/
  2064. void mmi_frm_sms_add_delivery_report_awaited(U16 reference_number, U8 total_segment, U8 index, U8 mr)
  2065. {
  2066.     /*----------------------------------------------------------------*/
  2067.     /* Local Variables                                                */
  2068.     /*----------------------------------------------------------------*/
  2069.     U16 ref_no = reference_number;
  2070.     U8 total_seg = total_segment;
  2071.     U8 box_index = index;
  2072.     U8 msg_reference = mr;
  2073.     mmi_frm_sms_delivery_report_box_struct *box;
  2075.     /*----------------------------------------------------------------*/
  2076.     /* Code Body                                                      */
  2077.     /*----------------------------------------------------------------*/
  2078.     if (mmi_frm_sms_delivery_report_awaited[mmi_frm_sms_delivery_report_awaited_next_available].box_number != 0)
  2079.     {
  2080.         mmi_frm_sms_remove_delivery_report_awaited(mmi_frm_sms_delivery_report_awaited_next_available);
  2081.     }
  2083.     mmi_frm_sms_delivery_report_awaited[mmi_frm_sms_delivery_report_awaited_next_available].ref = ref_no;
  2084.     mmi_frm_sms_delivery_report_awaited[mmi_frm_sms_delivery_report_awaited_next_available].box_number = total_seg;
  2085.     mmi_frm_sms_delivery_report_awaited[mmi_frm_sms_delivery_report_awaited_next_available].result =
  2086.         ST_COMP_MSG_RECV_BY_SME;
  2087.     mmi_frm_sms_delivery_report_awaited[mmi_frm_sms_delivery_report_awaited_next_available].ptr = OslMalloc(total_seg * sizeof(mmi_frm_sms_delivery_report_box_struct));
  2088.     memset(
  2089.         (S8*) mmi_frm_sms_delivery_report_awaited[mmi_frm_sms_delivery_report_awaited_next_available].ptr,
  2090.         0,
  2091.         total_seg * sizeof(mmi_frm_sms_delivery_report_box_struct));
  2092.     box = mmi_frm_sms_delivery_report_awaited[mmi_frm_sms_delivery_report_awaited_next_available].ptr;
  2093.     box[box_index].mr = msg_reference;
  2095.     mmi_frm_sms_delivery_report_awaited_next_available++;
  2097.     if (mmi_frm_sms_delivery_report_awaited_next_available == MMI_FRM_SMS_ACTION_SIZE)
  2098.     {
  2099.         mmi_frm_sms_delivery_report_awaited_next_available = 0;
  2100.     }
  2102.     return;
  2103. }
  2106. /*****************************************************************************
  2107.  * FUNCTION
  2108.  *  mmi_frm_sms_get_delivery_report_awaited_result
  2109.  * DESCRIPTION
  2110.  *  get result of delivery report awaited list entry
  2111.  * PARAMETERS
  2112.  *  delivery_report_awaited_index       [IN]        
  2113.  * RETURNS
  2114.  *  delivery_report_awaited_index : index of delivery report list
  2115.  *****************************************************************************/
  2116. U8 mmi_frm_sms_get_delivery_report_awaited_result(U16 delivery_report_awaited_index)
  2117. {
  2118.     /*----------------------------------------------------------------*/
  2119.     /* Local Variables                                                */
  2120.     /*----------------------------------------------------------------*/
  2122.     /*----------------------------------------------------------------*/
  2123.     /* Code Body                                                      */
  2124.     /*----------------------------------------------------------------*/
  2125.     return mmi_frm_sms_delivery_report_awaited[delivery_report_awaited_index].result;
  2126. }
  2129. /*****************************************************************************
  2130.  * FUNCTION
  2131.  *  mmi_frm_sms_check_delivery_report_awaited
  2132.  * DESCRIPTION
  2133.  *  entry of check delivery report awaited list
  2134.  * PARAMETERS
  2135.  *  inMsg       [?]     
  2136.  * RETURNS
  2137.  *  void
  2138.  *****************************************************************************/
  2139. void mmi_frm_sms_check_delivery_report_awaited(MMI_FRM_SMS_SEND_MSG_RSP_STRUCT *inMsg)
  2140. {
  2141.     /*----------------------------------------------------------------*/
  2142.     /* Local Variables                                                */
  2143.     /*----------------------------------------------------------------*/
  2144.     MMI_FRM_SMS_SEND_MSG_RSP_STRUCT *msgRsp = inMsg;
  2145.     U16 delivery_report_awaited_index;
  2146.     U16 ref = msgRsp->concat_info.ref;
  2147.     U8 msg_reference = msgRsp->mr;
  2149.     /*----------------------------------------------------------------*/
  2150.     /* Code Body                                                      */
  2151.     /*----------------------------------------------------------------*/
  2152.     if (msgRsp->result == TRUE) /* success */
  2153.     {
  2155.         /* check if mr is in delivery report awaited list */
  2156.         delivery_report_awaited_index = mmi_frm_sms_get_delivery_report_index_by_mr(msg_reference);
  2158.         /* mr is in delivery report  awaited list */
  2159.         while (delivery_report_awaited_index != MMI_FRM_SMS_ACTION_SIZE)
  2160.         {
  2161.             mmi_frm_sms_remove_delivery_report_awaited(delivery_report_awaited_index);
  2163.             /* check if mr is in delivery report awaited list */
  2164.             delivery_report_awaited_index = mmi_frm_sms_get_delivery_report_index_by_mr(msg_reference);
  2165.         }
  2167.         /* Single-segment msg is always added into awaited list.  Ref of single-segment msg is always zero. */
  2168.         if (msgRsp->concat_info.total_seg == 1)
  2169.         {
  2170.             delivery_report_awaited_index = MMI_FRM_SMS_ACTION_SIZE;
  2171.         }
  2172.         else
  2173.         {
  2174.             delivery_report_awaited_index = mmi_frm_sms_get_delivery_report_index_by_ref(ref);
  2175.         }
  2177.         /* reference number not in awaited list, add an entry to delivery report awaited list */
  2178.         if (delivery_report_awaited_index == MMI_FRM_SMS_ACTION_SIZE)
  2179.         {
  2180.             U8 total_seg = msgRsp->concat_info.total_seg;
  2181.             U8 box_index = msgRsp->concat_info.seg - 1; /* start from 0 */
  2183.             /* add entry to delivery report awaited list */
  2184.             mmi_frm_sms_add_delivery_report_awaited(ref, total_seg, box_index, msg_reference);
  2185.         }
  2186.         /* reference number is in awaited list */
  2187.         else
  2188.         {
  2189.             U8 box_index = msgRsp->concat_info.seg - 1; /* start from 0 */
  2191.             /* add mr to delivery report awaited list */
  2192.             mmi_frm_sms_set_delivery_report_awaited_mr(delivery_report_awaited_index, msg_reference, box_index);
  2193.         }
  2194.     }
  2195.     /* Send_RSP fail */
  2196.     else
  2197.     {
  2198.         /* Single-segment msg should not be taken care. */
  2199.         if (msgRsp->concat_info.total_seg == 1)
  2200.         {
  2201.             delivery_report_awaited_index = MMI_FRM_SMS_ACTION_SIZE;
  2202.         }
  2203.         else
  2204.         {
  2205.             delivery_report_awaited_index = mmi_frm_sms_get_delivery_report_index_by_ref(ref);
  2206.         }
  2208.         /* reference number in awaited list */
  2209.         while (delivery_report_awaited_index != MMI_FRM_SMS_ACTION_SIZE)
  2210.         {
  2211.             mmi_frm_sms_remove_delivery_report_awaited(delivery_report_awaited_index);
  2212.             delivery_report_awaited_index = mmi_frm_sms_get_delivery_report_index_by_ref(ref);
  2213.         }
  2214.     }
  2216. }
  2217. #endif /* __MMI_MESSAGES_SINGLE_DELIVERY_REPORT__ */ 
  2220. /*****************************************************************************
  2221.  * FUNCTION
  2222.  *  mmi_frm_sms_handle_extension_char
  2223.  * DESCRIPTION
  2224.  *  added '1b' before extionsion char
  2225.  *  caller must make sure the dstBuf size is at least twice more than srcBuf size
  2226.  * PARAMETERS
  2227.  *  dstBuf      [?]         
  2228.  *  srcBuf      [?]         
  2229.  *  charNum     [IN]        number of char in srcBuffer
  2230.  * RETURNS
  2231.  *  void
  2232.  *****************************************************************************/
  2233. void mmi_frm_sms_handle_extension_char(U16 *dstBuf, U16 *srcBuf, U16 charNum)
  2234. {
  2235.     /*----------------------------------------------------------------*/
  2236.     /* Local Variables                                                */
  2237.     /*----------------------------------------------------------------*/
  2238.     U16 *dstBuffer = dstBuf;
  2239.     U16 *srcBuffer = srcBuf;
  2240.     U16 charNumber = charNum;
  2241.     U16 c;
  2242.     U16 srcCount = 0;
  2243.     U16 dstCount = 0;
  2245.     /*----------------------------------------------------------------*/
  2246.     /* Code Body                                                      */
  2247.     /*----------------------------------------------------------------*/
  2248.     while (srcCount < charNumber)
  2249.     {
  2250.         c = srcBuffer[srcCount];
  2251.         if (UI_TEST_GSM_EXTENDED(c))
  2252.         {
  2253.             dstBuffer[dstCount] = EMS_ESCAPE_CHARACTER;
  2254.             dstCount++;
  2255.         }
  2256.         dstBuffer[dstCount] = c;
  2257.         srcCount++;
  2258.         dstCount++;
  2259.     }
  2261.     dstBuffer[dstCount] = '';
  2263.     return;
  2264. }
  2267. /*****************************************************************************
  2268.  * FUNCTION
  2269.  *  mmi_frm_sms_count_extension_char
  2270.  * DESCRIPTION
  2271.  *  count the number of extension characters in buff
  2272.  * PARAMETERS
  2273.  *  buff            [?]         
  2274.  *  char_num        [IN]        
  2275.  * RETURNS
  2276.  *  number of extension characters in buff
  2277.  *****************************************************************************/
  2278. U32 mmi_frm_sms_count_extension_char(U16 *buff, U32 char_num)
  2279. {
  2280.     /*----------------------------------------------------------------*/
  2281.     /* Local Variables                                                */
  2282.     /*----------------------------------------------------------------*/
  2283.     U32 extension_char_num = 0;
  2284.     U32 count = 0;
  2285.     U16 c;
  2287.     /*----------------------------------------------------------------*/
  2288.     /* Code Body                                                      */
  2289.     /*----------------------------------------------------------------*/
  2290.     while (count < char_num)
  2291.     {
  2292.         c = buff[count];
  2293.         if (UI_TEST_GSM_EXTENDED(c))
  2294.         {
  2295.             extension_char_num++;
  2296.         }
  2297.         count++;
  2298.     }
  2300.     return extension_char_num;
  2301. }
  2304. /*****************************************************************************
  2305.  * FUNCTION
  2306.  *  mmi_frm_sms_check_UCS2
  2307.  * DESCRIPTION
  2308.  *  check if UCS2 char exists
  2309.  * PARAMETERS
  2310.  *  buf         [?]         
  2311.  *  charNum     [IN]        number of char in buffer
  2312.  * RETURNS
  2313.  *  return true if UCS2 char exists, else return false
  2314.  *****************************************************************************/
  2315. BOOL mmi_frm_sms_check_UCS2(U16 *buf, U16 charNum)
  2316. {
  2317.     /*----------------------------------------------------------------*/
  2318.     /* Local Variables                                                */
  2319.     /*----------------------------------------------------------------*/
  2320.     U16 *buffer = buf;
  2321.     U16 charNumber = charNum;
  2322.     U16 c;
  2323.     U16 count = 0;
  2325.     /*----------------------------------------------------------------*/
  2326.     /* Code Body                                                      */
  2327.     /*----------------------------------------------------------------*/
  2328.     while (count < charNumber)
  2329.     {
  2330.         c = buffer[count];
  2331.         if (UI_TEST_UCS2_CHARACTER(c))
  2332.         {
  2333.             return KAL_TRUE;
  2334.         }
  2335.         count++;
  2336.     }
  2338.     return KAL_FALSE;
  2339. }
  2342. /*****************************************************************************
  2343.  * FUNCTION
  2344.  *  mmi_frm_sms_check_dst_number
  2345.  * DESCRIPTION
  2346.  *  check if the number is valid
  2347.  * PARAMETERS
  2348.  *  num         [?]         dst number
  2349.  *  numLen      [IN]        number length
  2350.  * RETURNS
  2351.  *  return true if number is valid, else return false
  2352.  *****************************************************************************/
  2353. BOOL mmi_frm_sms_check_dst_number(U8 *num, U8 numLen)
  2354. {
  2355.     /*----------------------------------------------------------------*/
  2356.     /* Local Variables                                                */
  2357.     /*----------------------------------------------------------------*/
  2358.     U8 *number = num;
  2359.     U8 numberlen = numLen;
  2360.     U8 i = 0;
  2362.     /*----------------------------------------------------------------*/
  2363.     /* Code Body                                                      */
  2364.     /*----------------------------------------------------------------*/
  2365.     for (; i < numberlen; i++)
  2366.     {
  2367.         U8 digit = number[i];
  2369.         if (digit == 'p' || digit == 'P' || digit == 'w' || digit == 'W')
  2370.         {
  2371.             return KAL_FALSE;
  2372.         }
  2373.     }
  2375.     return KAL_TRUE;
  2376. }
  2379. /*****************************************************************************
  2380.  * FUNCTION
  2381.  *  mmi_frm_sms_is_in_sim_refresh
  2382.  * DESCRIPTION
  2383.  *  return if in sim refresh
  2384.  * PARAMETERS
  2385.  *  void
  2386.  * RETURNS
  2387.  *  return true if in sim refresh, else return false
  2388.  *****************************************************************************/
  2389. BOOL mmi_frm_sms_is_in_sim_refresh(void)
  2390. {
  2391.     /*----------------------------------------------------------------*/
  2392.     /* Local Variables                                                */
  2393.     /*----------------------------------------------------------------*/
  2395.     /*----------------------------------------------------------------*/
  2396.     /* Code Body                                                      */
  2397.     /*----------------------------------------------------------------*/
  2398.     if ((mmi_frm_sms_list_done) && (!g_frm_sms_cntx.mmi_frm_sms_ready))
  2399.     {
  2400.         return KAL_TRUE;
  2401.     }
  2403.     return KAL_FALSE;
  2404. }
  2406. #ifdef __MMI_UNIFIED_MESSAGE__
  2409. /*****************************************************************************
  2410.  * FUNCTION
  2411.  *  mmi_frm_sms_get_read_sms_content
  2412.  * DESCRIPTION
  2413.  *  Get start up sms content
  2414.  * PARAMETERS
  2415.  *  entry       [?]     Message entry info
  2416.  *  content     [?]     Message content
  2417.  * RETURNS
  2418.  *  object present
  2419.  *****************************************************************************/
  2420. U8 mmi_frm_sms_get_read_sms_content(MMI_FRM_SMS_GET_MSG_RSP_STRUCT *entry, U8 *content)
  2421. {
  2422.     /*----------------------------------------------------------------*/
  2423.     /* Local Variables                                                */
  2424.     /*----------------------------------------------------------------*/
  2425.     U8 *date_p = entry->msg_data;
  2426.     EMSData *pEMSdata = NULL;
  2427.     U8 *textBuff;
  2428.     U8 *TPUD[1];
  2429.     U8 TPUDLEN[1];
  2430.     U8 is_obj_present = 0;
  2431.     U16 buffLen = entry->no_msg_data;
  2432.     U16 textLen = 0;
  2433.     U8 totalseg = 1;    /* always extract one segment at one time */
  2435.     EMSTATUS result;
  2437.     /*----------------------------------------------------------------*/
  2438.     /* Code Body                                                      */
  2439.     /*----------------------------------------------------------------*/
  2440.     TPUDLEN[0] = (U8) buffLen;
  2441.     TPUD[0] = (U8*) date_p;
  2443.     if (entry->dcs != SMSAL_UCS2_DCS)
  2444.     {
  2445.         buffLen *= 2;
  2446.     }
  2448.     if (buffLen)
  2449.     {
  2450.         pEMSdata = OslMalloc(sizeof(EMSData));
  2451.         textBuff = OslMalloc(buffLen);
  2452.         result = EMSMsgPreview(
  2453.                     totalseg,
  2454.                     entry->dcs,
  2455.                     (U8) GetUDHIBit(entry->fo),
  2456.                     TPUD,
  2457.                     TPUDLEN,
  2458.                     buffLen,
  2459.                     textBuff,
  2460.                     &is_obj_present,
  2461.                     &textLen);
  2463.         if (result == EMS_OK)
  2464.         {
  2465.             kal_uint16 content_len = 0;
  2467.             pEMSdata->textBuffer = textBuff;
  2468.             pEMSdata->textBufferSize = entry->no_msg_data;
  2469.             pEMSdata->textLength = textLen;
  2470.             pEMSdata->dcs = entry->dcs;
  2472.             EMS_ConvertGSM7BitDefaultEncodingToAsciiWithoutEMSlib(pEMSdata);
  2474.             content_len = (pEMSdata->textLength < MMI_FRM_SMS_MSG_LEN) ? pEMSdata->textLength : MMI_FRM_SMS_MSG_LEN;
  2476.             memcpy((S8*) content, (S8*) pEMSdata->textBuffer, content_len);
  2477.         }
  2478.         else
  2479.         {
  2480.             memset((S8*) content, 0, ENCODING_LENGTH);
  2481.         }
  2483.         OslMfree(textBuff);
  2484.         OslMfree(pEMSdata);
  2485.     }
  2486.     else
  2487.     {
  2488.         memset((S8*) content, 0, ENCODING_LENGTH);
  2489.     }
  2491.     return is_obj_present;
  2493. }
  2496. /*****************************************************************************
  2497.  * FUNCTION
  2498.  *  mmi_frm_sms_get_startup_sms_content
  2499.  * DESCRIPTION
  2500.  *  Get start up sms content
  2501.  * PARAMETERS
  2502.  *  entry       [?]     Message entry info
  2503.  *  content     [?]     Message content
  2504.  * RETURNS
  2505.  *  object present
  2506.  *****************************************************************************/
  2507. U8 mmi_frm_sms_get_startup_sms_content(MMI_FRM_SMS_STARTUP_READ_MSG_IND_STRUCT *entry, U8 *content)
  2508. {
  2509.     /*----------------------------------------------------------------*/
  2510.     /* Local Variables                                                */
  2511.     /*----------------------------------------------------------------*/
  2512.     U8 *date_p = entry->msg_data;
  2513.     EMSData *pEMSdata = NULL;
  2514.     U8 *textBuff;
  2515.     U8 *TPUD[1];
  2516.     U8 TPUDLEN[1];
  2517.     U8 is_obj_present = 0;
  2518.     U16 buffLen = entry->no_msg_data;
  2519.     U16 textLen = 0;
  2520.     U8 totalseg = 1;    /* always extract one segment at one time */
  2521.     EMSTATUS result;
  2523.     /*----------------------------------------------------------------*/
  2524.     /* Code Body                                                      */
  2525.     /*----------------------------------------------------------------*/
  2526.     TPUDLEN[0] = (U8) buffLen;
  2527.     TPUD[0] = (U8*) date_p;
  2529.     if (entry->dcs != SMSAL_UCS2_DCS)
  2530.     {
  2531.         buffLen *= 2;
  2532.     }
  2534.     if (buffLen)
  2535.     {
  2536.         pEMSdata = OslMalloc(sizeof(EMSData));
  2537.         textBuff = OslMalloc(buffLen);
  2538.         result = EMSMsgPreview(
  2539.                     totalseg,
  2540.                     entry->dcs,
  2541.                     (U8) GetUDHIBit(entry->fo),
  2542.                     TPUD,
  2543.                     TPUDLEN,
  2544.                     buffLen,
  2545.                     textBuff,
  2546.                     &is_obj_present,
  2547.                     &textLen);
  2549.         if (result == EMS_OK)
  2550.         {
  2551.             kal_uint16 content_len = 0;
  2553.             pEMSdata->textBuffer = textBuff;
  2554.             pEMSdata->textBufferSize = entry->no_msg_data;
  2555.             pEMSdata->textLength = textLen;
  2556.             pEMSdata->dcs = entry->dcs;
  2558.             EMS_ConvertGSM7BitDefaultEncodingToAsciiWithoutEMSlib(pEMSdata);
  2560.             content_len = (pEMSdata->textLength < MMI_FRM_SMS_MSG_LEN) ? pEMSdata->textLength : MMI_FRM_SMS_MSG_LEN;
  2562.             memcpy((S8*) content, (S8*) pEMSdata->textBuffer, content_len);
  2563.         }
  2564.         else
  2565.         {
  2566.             memset((S8*) content, 0, ENCODING_LENGTH);
  2567.         }
  2569.         OslMfree(textBuff);
  2570.         OslMfree(pEMSdata);
  2571.     }
  2572.     else
  2573.     {
  2574.         memset((S8*) content, 0, ENCODING_LENGTH);
  2575.     }
  2577.     return is_obj_present;
  2579. }
  2582. /*****************************************************************************
  2583.  * FUNCTION
  2584.  *  mmi_frm_sms_add_content_to_entry
  2585.  * DESCRIPTION
  2586.  *  Add message content to message box structure
  2587.  * PARAMETERS
  2588.  *  entry       [?]     
  2589.  *  content     [?]     
  2590.  * RETURNS
  2591.  *  void
  2592.  *****************************************************************************/
  2593. void mmi_frm_sms_add_content_to_entry(mmi_frm_sms_msgbox_struct *entry, U8 *content)
  2594. {
  2595.     /*----------------------------------------------------------------*/
  2596.     /* Local Variables                                                */
  2597.     /*----------------------------------------------------------------*/
  2599.     /*----------------------------------------------------------------*/
  2600.     /* Code Body                                                      */
  2601.     /*----------------------------------------------------------------*/
  2602.     memset((S8*) entry->content, 0, mmi_msg_get_max_content_size() * ENCODING_LENGTH);
  2603.     /* Decrease one due to the null terminator */
  2604.     pfnUnicodeStrncpy((S8*) entry->content, (S8*) content, mmi_msg_get_max_content_size() - 1);
  2605.     return;
  2606. }
  2609. /*****************************************************************************
  2610.  * FUNCTION
  2611.  *  mmi_frm_sms_get_content
  2612.  * DESCRIPTION
  2613.  *  get msg content
  2614.  * PARAMETERS
  2615.  *  msg_box_type        [IN]        
  2616.  *  msg_list_index      [IN]        
  2617.  *  content             [?]         
  2618.  *  max_subject_len     [IN]        
  2619.  * RETURNS
  2620.  *  void
  2621.  *****************************************************************************/
  2622. kal_bool mmi_frm_sms_get_content(
  2623.             kal_uint8 msg_box_type,
  2624.             kal_uint16 msg_list_index,
  2625.             kal_wchar *content,
  2626.             kal_uint8 max_subject_len)
  2627. {
  2628.     /*----------------------------------------------------------------*/
  2629.     /* Local Variables                                                */
  2630.     /*----------------------------------------------------------------*/
  2631.     U16 entryindex = 0;
  2633.     /*----------------------------------------------------------------*/
  2634.     /* Code Body                                                      */
  2635.     /*----------------------------------------------------------------*/
  2636.     switch (msg_box_type)
  2637.     {
  2638.         case MMI_FRM_SMS_INBOX:
  2639.         case MMI_FRM_SMS_UNREAD:
  2640.             entryindex = mmi_frm_sms_inbox_list[msg_list_index];
  2641.             break;
  2642.         case MMI_FRM_SMS_OUTBOX:
  2643.             entryindex = mmi_frm_sms_outbox_list[msg_list_index];
  2644.             break;
  2645.         case MMI_FRM_SMS_DRAFTS:
  2646.         case MMI_FRM_SMS_UNSENT:
  2647.             entryindex = mmi_frm_sms_drafts_list[msg_list_index];
  2648.             break;
  2649.         default:
  2650.             entryindex = msg_list_index;
  2651.     }
  2653.     pfnUnicodeStrncpy((S8*) content, (S8*) mmi_frm_sms_msg_box[entryindex].content, max_subject_len);
  2654.     return KAL_TRUE;
  2655. }
  2658. /*****************************************************************************
  2659.  * FUNCTION
  2660.  *  mmi_frm_sms_get_next_unsent_msg
  2661.  * DESCRIPTION
  2662.  *  get next unsent sms msg index
  2663.  * PARAMETERS
  2664.  *  current_msg_index       [?]     
  2665.  * RETURNS
  2666.  *  void
  2667.  *****************************************************************************/
  2668. kal_bool mmi_frm_sms_get_next_unsent_msg(kal_uint16 *current_msg_index)
  2669. {
  2670.     /*----------------------------------------------------------------*/
  2671.     /* Local Variables                                                */
  2672.     /*----------------------------------------------------------------*/
  2673.     kal_uint16 index = *current_msg_index;
  2674.     U8 *address = NULL;
  2676.     /*----------------------------------------------------------------*/
  2677.     /* Code Body                                                      */
  2678.     /*----------------------------------------------------------------*/
  2679.     while (index < mmi_frm_sms_drafts_size)
  2680.     {
  2681.         address = mmi_frm_sms_get_sms_address(MMI_FRM_SMS_APP_DRAFTS, index);
  2683.         if (strlen((char*)address))
  2684.         {
  2685.             *current_msg_index = index;
  2686.             return KAL_TRUE;
  2687.         }
  2688.         index++;
  2689.     }
  2690.     return KAL_FALSE;
  2691. }
  2694. /*****************************************************************************
  2695.  * FUNCTION
  2696.  *  mmi_frm_sms_get_next_draft_msg
  2697.  * DESCRIPTION
  2698.  *  get next draft sms msg index
  2699.  * PARAMETERS
  2700.  *  current_msg_index       [?]     
  2701.  * RETURNS
  2702.  *  void
  2703.  *****************************************************************************/
  2704. kal_bool mmi_frm_sms_get_next_draft_msg(kal_uint16 *current_msg_index)
  2705. {
  2706.     /*----------------------------------------------------------------*/
  2707.     /* Local Variables                                                */
  2708.     /*----------------------------------------------------------------*/
  2709.     kal_uint16 index = *current_msg_index;
  2710.     U8 *address = NULL;
  2712.     /*----------------------------------------------------------------*/
  2713.     /* Code Body                                                      */
  2714.     /*----------------------------------------------------------------*/
  2715.     while (index < mmi_frm_sms_drafts_size)
  2716.     {
  2717.         address = mmi_frm_sms_get_sms_address(MMI_FRM_SMS_APP_DRAFTS, index);
  2719.         if (strlen((char*)address) == 0)
  2720.         {
  2721.             *current_msg_index = index;
  2722.             return KAL_TRUE;
  2723.         }
  2724.         index++;
  2725.     }
  2726.     return KAL_FALSE;
  2727. }
  2730. /*****************************************************************************
  2731.  * FUNCTION
  2732.  *  mmi_frm_sms_get_unsent_msg_num
  2733.  * DESCRIPTION
  2734.  *  get sms msg number of each msg box
  2735.  * PARAMETERS
  2736.  *  unsent_msg_number       [?]     
  2737.  * RETURNS
  2738.  *  void
  2739.  *****************************************************************************/
  2740. void mmi_frm_sms_get_unsent_msg_num(kal_uint16 *unsent_msg_number)
  2741. {
  2742.     /*----------------------------------------------------------------*/
  2743.     /* Local Variables                                                */
  2744.     /*----------------------------------------------------------------*/
  2745.     kal_uint16 current_msg_index = 0;
  2747.     /*----------------------------------------------------------------*/
  2748.     /* Code Body                                                      */
  2749.     /*----------------------------------------------------------------*/
  2750.     (*unsent_msg_number) = 0;
  2752.     while (mmi_frm_sms_get_next_unsent_msg(&current_msg_index))
  2753.     {
  2754.         (*unsent_msg_number)++;
  2755.         current_msg_index++;
  2756.     }
  2757. }
  2760. /*****************************************************************************
  2761.  * FUNCTION
  2762.  *  mmi_frm_sms_get_draft_msg_num
  2763.  * DESCRIPTION
  2764.  *  get sms msg number of each msg box
  2765.  * PARAMETERS
  2766.  *  draft_msg_number        [?]     
  2767.  * RETURNS
  2768.  *  void
  2769.  *****************************************************************************/
  2770. void mmi_frm_sms_get_draft_msg_num(kal_uint16 *draft_msg_number)
  2771. {
  2772.     /*----------------------------------------------------------------*/
  2773.     /* Local Variables                                                */
  2774.     /*----------------------------------------------------------------*/
  2775.     kal_uint16 current_msg_index = 0;
  2777.     /*----------------------------------------------------------------*/
  2778.     /* Code Body                                                      */
  2779.     /*----------------------------------------------------------------*/
  2780.     (*draft_msg_number) = 0;
  2782.     while (mmi_frm_sms_get_next_draft_msg(&current_msg_index))
  2783.     {
  2784.         (*draft_msg_number)++;
  2785.         current_msg_index++;
  2786.     }
  2787. }
  2790. /*****************************************************************************
  2791.  * FUNCTION
  2792.  *  mmi_frm_sms_highlight_ind
  2793.  * DESCRIPTION
  2794.  *  indicate UM to change highlighted msg
  2795.  * PARAMETERS
  2796.  *  msg_box_type        [IN]        
  2797.  *  index               [IN]        
  2798.  * RETURNS
  2799.  *  void
  2800.  *****************************************************************************/
  2801. void mmi_frm_sms_highlight_ind(U8 msg_box_type, U16 index)
  2802. {
  2803.     /*----------------------------------------------------------------*/
  2804.     /* Local Variables                                                */
  2805.     /*----------------------------------------------------------------*/
  2807.     U8 type;
  2808.     U16 msg_list_index;
  2810.     /*----------------------------------------------------------------*/
  2811.     /* Code Body                                                      */
  2812.     /*----------------------------------------------------------------*/
  2813.     if (msg_box_type == MMI_FRM_SMS_NOBOX)
  2814.     {
  2815.         mmi_frm_sms_get_list_index(&type, &msg_list_index, index);
  2817.         if (type == MMI_FRM_SMS_INBOX)
  2818.         {
  2819.             type = UM_MSG_BOX_TYPE_INBOX;
  2820.         }
  2821.         else if (type == MMI_FRM_SMS_OUTBOX)
  2822.         {
  2823.             type = UM_MSG_BOX_TYPE_SENT;
  2824.         }
  2825.         else
  2826.         {
  2827.             U8 *address = NULL;
  2829.             address = mmi_frm_sms_get_sms_address(MMI_FRM_SMS_APP_DRAFTS, msg_list_index);
  2831.             if (strlen((char*)address))
  2832.             {
  2833.                 type = UM_MSG_BOX_TYPE_UNSENT;
  2834.             }
  2835.             else
  2836.             {
  2837.                 type = UM_MSG_BOX_TYPE_DRAFT;
  2838.             }
  2839.         }
  2840.     }
  2841.     else
  2842.     {
  2843.         switch (msg_box_type)
  2844.         {
  2845.             case MMI_FRM_SMS_INBOX:
  2846.             {
  2847.                 type = UM_MSG_BOX_TYPE_INBOX;
  2848.                 msg_list_index = index;
  2849.             }
  2850.                 break;
  2851.             case MMI_FRM_SMS_OUTBOX:
  2852.             {
  2853.                 type = UM_MSG_BOX_TYPE_SENT;
  2854.                 msg_list_index = index;
  2855.             }
  2856.                 break;
  2857.             case MMI_FRM_SMS_UNSENT:
  2858.             {
  2859.                 type = UM_MSG_BOX_TYPE_UNSENT;
  2860.                 msg_list_index = index;
  2861.             }
  2862.                 break;
  2863.             case MMI_FRM_SMS_DRAFTS:
  2864.             {
  2865.                 type = UM_MSG_BOX_TYPE_DRAFT;
  2866.                 msg_list_index = index;
  2867.             }
  2868.                 break;
  2869.             default:
  2870.             {
  2871.                 MMI_ASSERT(0);
  2872.             }
  2873.                 break;
  2874.         }
  2875.     }
  2877.     mmi_um_highlight_msg_ind(UM_MSG_TYPE_SMS, type, msg_list_index);
  2879. }
  2881. #endif /* __MMI_UNIFIED_MESSAGE__ */ 
  2884. /*****************************************************************************
  2885.  * FUNCTION
  2886.  *  mmi_frm_sms_add_escape_symbol_for_extension_char
  2887.  * DESCRIPTION
  2888.  *  added '1b' before extionsion char
  2889.  *  caller must make sure the dstBuf size is large enough
  2890.  *  The Euro sign is handled in this API.
  2891.  * PARAMETERS
  2892.  *  dstBuf      [?]         
  2893.  *  srcBuf      [?]         
  2894.  *  charNum     [IN]        number of char in srcBuffer
  2895.  * RETURNS
  2896.  *  void
  2897.  *****************************************************************************/
  2898. void mmi_frm_sms_add_escape_symbol_for_extension_char(U16 *dstBuf, U16 *srcBuf, U16 charNum)
  2899. {
  2900.     /*----------------------------------------------------------------*/
  2901.     /* Local Variables                                                */
  2902.     /*----------------------------------------------------------------*/
  2903.     U16 *dstBuffer = dstBuf;
  2904.     U16 *srcBuffer = srcBuf;
  2905.     U16 charNumber = charNum;
  2906.     U16 c;
  2907.     U16 srcCount = 0;
  2908.     U16 dstCount = 0;
  2910.     /*----------------------------------------------------------------*/
  2911.     /* Code Body                                                      */
  2912.     /*----------------------------------------------------------------*/
  2913.     while (srcCount < charNumber)
  2914.     {
  2915.         c = srcBuffer[srcCount];
  2916.         if (MMI_SMS_TEST_GSM7BIT_EXTENDED(c))
  2917.         {
  2918.             dstBuffer[dstCount] = EMS_ESCAPE_CHARACTER;
  2919.             dstCount++;
  2920.         }
  2922.         if (c == MMI_SMS_EURO_SIGN)
  2923.         {
  2924.             dstBuffer[dstCount] = EMS_EURO_CHARACTER;
  2925.         }
  2926.         else
  2927.         {
  2928.             dstBuffer[dstCount] = c;
  2929.         }
  2930.         
  2931.         srcCount++;
  2932.         dstCount++;
  2933.     }
  2935.     dstBuffer[dstCount] = '';
  2937.     return;
  2938. }
  2941. /*****************************************************************************
  2942.  * FUNCTION
  2943.  *  mmi_frm_sms_remove_escape_symbol_for_extension_char
  2944.  * DESCRIPTION
  2945.  *  remove '1b' before extionsion char
  2946.  *  caller must make sure the dstBuf size is large enough
  2947.  *  The Euro sign is handled in this API.
  2948.  * PARAMETERS
  2949.  *  dstBuf      [?]         
  2950.  *  srcBuf      [?]         
  2951.  *  charNum     [IN]        number of char in srcBuffer
  2952.  * RETURNS
  2953.  *  void
  2954.  *****************************************************************************/
  2955. void mmi_frm_sms_remove_escape_symbol_for_extension_char(U16 *dstBuf, U16 *srcBuf, U16 charNum)
  2956. {
  2957.     /*----------------------------------------------------------------*/
  2958.     /* Local Variables                                                */
  2959.     /*----------------------------------------------------------------*/
  2960.     U16 *dstBuffer = dstBuf;
  2961.     U16 *srcBuffer = srcBuf;
  2962.     U16 charNumber = charNum;
  2963.     U16 c;
  2964.     U16 srcCount = 0;
  2965.     U16 dstCount = 0;
  2967.     /*----------------------------------------------------------------*/
  2968.     /* Code Body                                                      */
  2969.     /*----------------------------------------------------------------*/
  2970.     while (srcCount < charNumber)
  2971.     {
  2972.         c = srcBuffer[srcCount];
  2973.         if (c == EMS_ESCAPE_CHARACTER)
  2974.         {
  2975.             srcCount++;
  2977.             c = srcBuffer[srcCount];
  2979.             if (c == EMS_EURO_CHARACTER)
  2980.             {
  2981.                 dstBuffer[dstCount] = MMI_SMS_EURO_SIGN;        
  2982.                 
  2983.                 srcCount++;
  2984.                 dstCount++;
  2985.             }
  2986.             continue;
  2987.         }
  2989.         dstBuffer[dstCount] = c;
  2990.         
  2991.         srcCount++;
  2992.         dstCount++;
  2993.     }
  2995.     dstBuffer[dstCount] = '';
  2997.     return;
  2998. }
  3001. /*****************************************************************************
  3002.  * FUNCTION
  3003.  *  mmi_frm_sms_init_msgbox
  3004.  * DESCRIPTION
  3005.  *  Init message box
  3006.  * PARAMETERS
  3007.  *  void
  3008.  * RETURNS
  3009.  *  void
  3010.  *****************************************************************************/
  3011. void mmi_frm_sms_init_msgbox(void)
  3012. {
  3013.     /*----------------------------------------------------------------*/
  3014.     /* Local Variables                                                */
  3015.     /*----------------------------------------------------------------*/
  3016.     U8 i = 0;
  3018.     /*----------------------------------------------------------------*/
  3019.     /* Code Body                                                      */
  3020.     /*----------------------------------------------------------------*/
  3021.     memset(
  3022.         (S8*) mmi_frm_sms_inbox_list,
  3023.         MMI_FRM_SMS_INVALID_NUM,
  3024.         sizeof(U16) * g_frm_sms_cntx.mmi_frm_sms_msg_box_size);
  3025.     memset(
  3026.         (S8*) mmi_frm_sms_outbox_list,
  3027.         MMI_FRM_SMS_INVALID_NUM,
  3028.         sizeof(U16) * g_frm_sms_cntx.mmi_frm_sms_msg_box_size);
  3029. #ifdef __MMI_MESSAGES_DRAFT_BOX__
  3030.     memset(
  3031.         (S8*) mmi_frm_sms_drafts_list,
  3032.         MMI_FRM_SMS_INVALID_NUM,
  3033.         sizeof(U16) * g_frm_sms_cntx.mmi_frm_sms_msg_box_size);
  3034. #endif /* __MMI_MESSAGES_DRAFT_BOX__ */ 
  3035.     memset(
  3036.         (S8*) mmi_frm_sms_msg_box,
  3037.         MMI_FRM_SMS_INVALID_NUM,
  3038.         sizeof(mmi_frm_sms_msgbox_struct) * g_frm_sms_cntx.mmi_frm_sms_msg_box_size);
  3039.     memset(
  3040.         (S8*) mmi_frm_sms_index_list,
  3041.         MMI_FRM_SMS_INVALID_NUM,
  3042.         sizeof(mmi_frm_sms_index_struct) * g_frm_sms_cntx.mmi_frm_sms_msg_box_size);
  3043.     memset(
  3044.         (S8*) mmi_frm_sms_awaited,
  3045.         MMI_FRM_SMS_INVALID_NUM,
  3046.         sizeof(mmi_frm_sms_deliver_msg_struct) * (MMI_FRM_SMS_ACTION_SIZE + 1));
  3047.     memset((S8*) mmi_frm_sms_awaited_counter, MMI_FRM_SMS_INVALID_NUM, sizeof(U8) * (MMI_FRM_SMS_ACTION_SIZE));
  3048.     memset(
  3049.         (S8*) mmi_frm_sms_data,
  3050.         MMI_FRM_SMS_INVALID_NUM,
  3051.         sizeof(mmi_frm_sms_deliver_data_struct) * (MMI_FRM_SMS_ACTION_SIZE + 1));
  3052.     memset((S8*) mmi_frm_sms_data_counter, MMI_FRM_SMS_INVALID_NUM, sizeof(U8) * (MMI_FRM_SMS_ACTION_SIZE));
  3053.     memset((S8*) mmi_frm_sms_content, 0, sizeof(mmi_frm_sms_content_struct) * (MMI_FRM_SMS_MSG_CONTENT_NUM + 1));
  3055. #ifdef __MMI_MESSAGES_SINGLE_DELIVERY_REPORT__
  3056.     memset(
  3057.         (S8*) mmi_frm_sms_delivery_report_awaited,
  3058.         0,
  3059.         sizeof(mmi_frm_sms_delivery_report_list_struct) * (MMI_FRM_SMS_ACTION_SIZE));
  3060. #endif /* __MMI_MESSAGES_SINGLE_DELIVERY_REPORT__ */ 
  3061.     for (i = 0; i < (MMI_FRM_SMS_MSG_CONTENT_NUM + 1); i++)
  3062.     {
  3063.         mmi_frm_sms_content[i].segment = MMI_FRM_SMS_INVALID_NUM;
  3064.         mmi_frm_sms_content[i].nextindex = MMI_FRM_SMS_INVALID_NUM;
  3065.     }
  3066.     mmi_frm_sms_inbox_size = 0;
  3067.     mmi_frm_sms_outbox_size = 0;
  3068. #ifdef __MMI_MESSAGES_DRAFT_BOX__
  3069.     mmi_frm_sms_drafts_size = 0;
  3070. #endif 
  3071.     /* reset message icon in the status bar in case of sim refresh */
  3072.     g_msg_cntx.msg_full_ind = FALSE;
  3073.     g_msg_cntx.msg_ind_in_idle = FALSE;
  3074.     mmi_msg_set_msg_icon(FALSE, FALSE);
  3075. }
  3077. #endif /* __MOD_SMSAL__ */