common/msg-ui-common-utility.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *    http://floralicense.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 /*=================
  19  * INCLUDE HEADERS
  20  * ================= */
  21 #include <msg-ui-util.h>
  22 #include <msg-ui-common-utility.h>
  23 #include <msg-ui-image-resource.h>
  24 #include <msg_storage.h>
  25 #include <elm_widget.h>
  26
  27 /* for i18n */
  28 #include <unicode/uloc.h>
  29 #include <unicode/ucal.h>
  30 #include <unicode/udat.h>
  31 #include <unicode/udatpg.h>
  32 #include <unicode/ustring.h>
  33
  34 #include <stdlib.h>
  35 #include <vconf-keys.h>
  36 #include <bundle.h>
  37 #include <syspopup_caller.h>
  38 #include <drm_client.h>
  39
  40 static char *icon_array[MSG_APP_FILE_TYPE_MAX] = {
  41         [MSG_APP_FILE_TYPE_IMAGE] = MSG_COMMON_FILE_IMAGE_ICON,
  42         [MSG_APP_FILE_TYPE_VIDEO] = MSG_COMMON_FILE_VIDEO_ICON,
  43         [MSG_APP_FILE_TYPE_MUSIC] = MSG_COMMON_FILE_MUSIC_ICON,
  44         [MSG_APP_FILE_TYPE_SOUND] = MSG_COMMON_FILE_SOUND_ICON,
  45         [MSG_APP_FILE_TYPE_PDF] = MSG_COMMON_FILE_PDF_ICON,
  46         [MSG_APP_FILE_TYPE_DOC] = MSG_COMMON_FILE_DOC_ICON,
  47         [MSG_APP_FILE_TYPE_PPT] = MSG_COMMON_FILE_PPT_ICON,
  48         [MSG_APP_FILE_TYPE_EXCEL] = MSG_COMMON_FILE_EXCEL_ICON,
  49         [MSG_APP_FILE_TYPE_VOICE] = MSG_COMMON_FILE_VOICE_ICON,
  50         [MSG_APP_FILE_TYPE_HTML] = MSG_COMMON_FILE_HTML_ICON,
  51         [MSG_APP_FILE_TYPE_FLASH] = MSG_COMMON_FILE_FLASH_ICON,
  52         [MSG_APP_FILE_TYPE_TXT] = MSG_COMMON_FILE_TXT_ICON,
  53         [MSG_APP_FILE_TYPE_VCONTACT] = MSG_COMMON_FILE_VCONTACT_ICON,
  54         [MSG_APP_FILE_TYPE_VCALENDAR] = MSG_COMMON_FILE_VCALENDAR_ICON,
  55         [MSG_APP_FILE_TYPE_VNOTE] = MSG_COMMON_FILE_VNOTE_ICON,
  56         [MSG_APP_FILE_TYPE_RSS] = MSG_COMMON_FILE_RSS_ICON,
  57         [MSG_APP_FILE_TYPE_JAVA] = MSG_COMMON_FILE_JAVA_ICON,
  58         [MSG_APP_FILE_TYPE_ETC] = MSG_COMMON_FILE_ETC_ICON,
  59 };
  60
  61 typedef struct {
  62         int     status;
  63         time_t time;
  64 } MSG_DETAIL_REPORT_STRUCT;
  65
  66 typedef struct {
  67         char address[MAX_ADDRESS_VAL_LEN+1];
  68         MSG_DETAIL_REPORT_STRUCT delivery;
  69         MSG_DETAIL_REPORT_STRUCT read;
  70 } MSG_DETAIL_REPORT_LIST_S;
  71
  72
  73 /*==========================
  74  * FUNCTION IMPLEMENTATIONS
  75  *========================== */
  76 const char *msg_common_get_default_locale()
  77 {
  78         const char *locale;
  79         UErrorCode status = U_ZERO_ERROR;
  80         /* ICU API to set default locale */
  81         uloc_setDefault(getenv("LC_TIME"), &status);
  82         locale = uloc_getDefault();
  83
  84         return locale;
  85 }
  86
  87 int msg_common_get_timeformat()
  88 {
  89         int timeformat = 0;
  90
  91         if (vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, &timeformat) < 0)
  92                 return MSG_TIME_FORMAT_UNKNOWN;
  93
  94         if (timeformat == VCONFKEY_TIME_FORMAT_12)
  95                 return MSG_TIME_FORMAT_12H;
  96         else if (timeformat == VCONFKEY_TIME_FORMAT_24)
  97                 return MSG_TIME_FORMAT_24H;
  98         else
  99                 return MSG_TIME_FORMAT_UNKNOWN;
 100 }
 101
 102 char *msg_common_get_date_best_pattern(const char* locale, char* skeleton)
 103 {
 104         D_ENTER;
 105         D_MSG_RETVM_IF(locale == NULL, NULL, "locale is NULL");
 106         D_MSG_RETVM_IF(skeleton == NULL, NULL, "skeleton is NULL");
 107
 108         UErrorCode status = U_ZERO_ERROR;
 109         UDateTimePatternGenerator *generator = NULL;
 110         UChar bestPattern[MSG_COMMON_MAX_UCHAR_PATTERN_LEN + 1] = {0,};
 111         char bestPatternString[MSG_COMMON_MAX_CHAR_PATTERN_LEN + 1] = {0,};
 112         int32_t bestPatternCapacity = 0;
 113         int32_t bestPatternLength = 0;
 114
 115         UChar customSkeleton[MSG_COMMON_MAX_UCHAR_PATTERN_LEN + 1] = {0,};
 116         int skeletonLength = 0;
 117
 118         skeletonLength = strlen(skeleton);
 119         /* convert char to uchar */
 120         if (skeletonLength <= MSG_COMMON_MAX_UCHAR_PATTERN_LEN)
 121                 u_uastrncpy(customSkeleton, skeleton, skeletonLength);
 122         else
 123                 u_uastrncpy(customSkeleton, skeleton, MSG_COMMON_MAX_UCHAR_PATTERN_LEN);
 124
 125         generator = udatpg_open(locale, &status);
 126         bestPatternCapacity = MSG_COMMON_MAX_UCHAR_PATTERN_LEN;
 127
 128         /* get bestpattern from customskeletom of uchar */
 129         bestPatternLength = udatpg_getBestPattern(generator, customSkeleton, u_strlen(customSkeleton), bestPattern, bestPatternCapacity, &status);
 130
 131         /* convert uchar to char to know bestpatternstring */
 132         u_austrcpy(bestPatternString, bestPattern);
 133
 134         udatpg_close(generator);
 135
 136         D_LEAVE;
 137
 138         return strdup(bestPatternString);
 139 }
 140
 141 char *msg_common_get_formatted_date(const char* locale, char* bestPattern, void *time)
 142 {
 143         D_MSG_RETVM_IF(locale == NULL, NULL, "locale is NULL");
 144         D_MSG_RETVM_IF(bestPattern == NULL, NULL, "bestPattern is NULL");
 145
 146         UErrorCode status = U_ZERO_ERROR;
 147         UDate date;
 148         UDateFormat *date_format = NULL;
 149         UChar uBestPattern[MSG_COMMON_MAX_UCHAR_PATTERN_LEN + 1] = {0,};
 150         UChar formatted[MSG_COMMON_MAX_UCHAR_PATTERN_LEN + 1] = {0,};
 151         char formattedString[MSG_COMMON_MAX_CHAR_PATTERN_LEN + 1] = {0,};
 152         int32_t formattedCapacity = 0;
 153         int patternLength = 0, formattedLength = 0;
 154
 155         patternLength = strlen(bestPattern);
 156         /* convert char to uchar */
 157         if (patternLength <= MSG_COMMON_MAX_UCHAR_PATTERN_LEN)
 158                 u_uastrncpy(uBestPattern, bestPattern, patternLength);
 159         else
 160                 u_uastrncpy(uBestPattern, bestPattern, MSG_COMMON_MAX_UCHAR_PATTERN_LEN);
 161
 162         /* convert time_t to UDate, if it is */
 163         if (time) {
 164                 time_t msg_time = *(time_t *) time;
 165                 date = (UDate) msg_time * 1000; /* Equivalent to Date = ucal_getNow() in Milliseconds */
 166         } else {
 167                 date = ucal_getNow();
 168         }
 169
 170         date_format = udat_open(UDAT_IGNORE, UDAT_IGNORE, locale, NULL, -1, uBestPattern, -1, &status);
 171         formattedCapacity = MSG_COMMON_MAX_UCHAR_PATTERN_LEN;
 172         /* get formatted string */
 173         formattedLength = udat_format(date_format, date, formatted, formattedCapacity, NULL, &status);
 174         /* convert uchar to char */
 175         u_austrcpy(formattedString, formatted);
 176
 177         udat_close(date_format);
 178
 179         return strdup(formattedString);
 180 }
 181
 182 char *msg_common_get_date_text(const char* locale, char* skeleton, void* time)
 183 {
 184         D_ENTER;
 185         D_MSG_RETVM_IF(locale == NULL, NULL, "locale is NULL");
 186         D_MSG_RETVM_IF(skeleton == NULL, NULL, "skeleton is NULL");
 187
 188         UChar customSkeleton[MSG_COMMON_MAX_UCHAR_PATTERN_LEN + 1] = {0,};
 189         int skeletonLength = 0;
 190
 191         skeletonLength = strlen(skeleton);
 192         /* convert char to uchar */
 193         if (skeletonLength <= MSG_COMMON_MAX_UCHAR_PATTERN_LEN)
 194                 u_uastrncpy(customSkeleton, skeleton, skeletonLength);
 195         else
 196                 u_uastrncpy(customSkeleton, skeleton, MSG_COMMON_MAX_UCHAR_PATTERN_LEN);
 197
 198         UErrorCode status = U_ZERO_ERROR;
 199         UDateTimePatternGenerator *generator = NULL;
 200         UDateFormat *date_format = NULL;
 201         UDate date;
 202         UChar bestPattern[MSG_COMMON_MAX_UCHAR_PATTERN_LEN + 1] = {0,};
 203         UChar formatted[MSG_COMMON_MAX_UCHAR_PATTERN_LEN + 1] = {0,};
 204         char bestPatternString[MSG_COMMON_MAX_CHAR_PATTERN_LEN + 1] = {0,};
 205         char formattedString[MSG_COMMON_MAX_CHAR_PATTERN_LEN + 1] = {0,};
 206         int32_t bestPatternCapacity = 0;
 207         int32_t bestPatternLength = 0;
 208         int32_t formattedCapacity = 0;
 209         int32_t formattedLength = 0;
 210
 211         generator = udatpg_open(locale, &status);
 212         bestPatternCapacity = MSG_COMMON_MAX_UCHAR_PATTERN_LEN;
 213
 214         /* get bestpattern from customskeletom of uchar */
 215         bestPatternLength = udatpg_getBestPattern(generator, customSkeleton, u_strlen(customSkeleton), bestPattern, bestPatternCapacity, &status);
 216
 217         /* convert uchar to char to know bestpatternstring */
 218         u_austrcpy(bestPatternString, bestPattern);
 219
 220         /* convert time_t to UDate, if it is */
 221         if (time) {
 222                 time_t msg_time = *(time_t *) time;
 223                 date = (UDate) msg_time * 1000; /* Equivalent to Date = ucal_getNow() in Milliseconds */
 224         } else
 225                 date = ucal_getNow();
 226
 227         date_format = udat_open(UDAT_IGNORE, UDAT_IGNORE, locale, NULL, -1, bestPattern, -1, &status);
 228         formattedCapacity = MSG_COMMON_MAX_UCHAR_PATTERN_LEN;
 229         /* get formatted string */
 230         formattedLength = udat_format(date_format, date, formatted, formattedCapacity, NULL, &status);
 231         /* convert uchar to char */
 232         u_austrcpy(formattedString, formatted);
 233
 234         udatpg_close(generator);
 235         udat_close(date_format);
 236
 237         return strdup(formattedString);
 238 }
 239
 240 char *msg_common_get_display_date(const char* locale, char* bestPattern, char* yearPattern, time_t *msg_t)
 241 {
 242         struct tm msg_time, cur_time;
 243         time_t cur_t;
 244         char msg_date_buf[DEF_BUF_LEN] = { '0', };
 245         char *date_str = NULL;
 246         int diffday = 0, msg_day = 0, cur_day = 0;
 247
 248         cur_t = (time_t) time(NULL);
 249
 250         localtime_r(msg_t, &msg_time);
 251         localtime_r(&cur_t, &cur_time);
 252
 253         msg_day = (msg_time.tm_year - 1900) * 365 + msg_time.tm_yday + (msg_time.tm_year - 1900 - 1) / 4;
 254         cur_day = (cur_time.tm_year - 1900) * 365 + cur_time.tm_yday + (cur_time.tm_year - 1900 - 1) / 4;
 255
 256         if (msg_time.tm_year - cur_time.tm_year != 0)
 257                 date_str = msg_common_get_formatted_date(locale, yearPattern, msg_t);
 258         else
 259                 date_str = msg_common_get_formatted_date(locale, bestPattern, msg_t);
 260
 261         diffday = cur_day - msg_day;
 262         if (diffday == 0)
 263                 snprintf(msg_date_buf, sizeof(msg_date_buf), "%s (%s)", dgettext("sys_string", "IDS_COM_BODY_TODAY"), date_str);
 264         else if (diffday == 1)
 265                 snprintf(msg_date_buf, sizeof(msg_date_buf), "%s (%s)", dgettext("sys_string", "IDS_COM_BODY_YESTERDAY"), date_str);
 266         else
 267                 strncpy(msg_date_buf, date_str, sizeof(msg_date_buf) - 1);
 268
 269         free(date_str);
 270         return strdup(msg_date_buf);
 271 }
 272
 273 static MSG_BOOL __msg_common_make_normal_markup_text(Eina_Strbuf *markup_text, Eina_Strbuf *font_style, const char *src, int strlen)
 274 {
 275         D_MSG_RETVM_IF(markup_text == NULL, FALSE, "markup_text is NULL");
 276         D_MSG_RETVM_IF(font_style == NULL, FALSE, "font_style is NULL");
 277         D_MSG_RETVM_IF(src == NULL, FALSE, "src is NULL");
 278
 279         char *tmp_body_buf = NULL;
 280         tmp_body_buf = (char *) calloc(strlen + 1, sizeof(char));
 281         if (tmp_body_buf) {
 282                 strncpy(tmp_body_buf, src, strlen);
 283         } else {
 284                 D_EMSG("calloc is failed");
 285                 return FALSE;
 286         }
 287
 288         eina_strbuf_append_printf(markup_text, "%s%s%s", MSG_COMMON_TAG_TEXT, eina_strbuf_string_get(font_style), tmp_body_buf);
 289         if (tmp_body_buf) {
 290                 free(tmp_body_buf);
 291                 tmp_body_buf = NULL;
 292         }
 293
 294         return TRUE;
 295 }
 296
 297 Eina_Strbuf *msg_common_get_markup_text(const char *src, char *fontcolor, char *fontstyle)
 298 {
 299         D_ENTER;
 300         D_MSG_RETVM_IF(src == NULL, NULL, "src is NULL");
 301
 302         const char *src_text = src;
 303
 304         if (src_text && strlen(src_text) > 0) {
 305                 Eina_Strbuf *markup_text = NULL;
 306                 Eina_Strbuf *font_buf = NULL;
 307                 char *token = NULL;
 308                 char *tmp_buf = NULL;
 309                 char *tmp_str = NULL;
 310                 int tmp_str_len = 0;
 311                 int src_text_len = 0;
 312                 size_t start = 0;
 313                 size_t end = 0;
 314
 315                 src_text_len = strlen(src_text);
 316                 D_MSG("src_text_len : %d", src_text_len);
 317                 tmp_buf = (char *) calloc(src_text_len + 1, sizeof(char));
 318                 if (tmp_buf == NULL) {
 319                         D_EMSG("tmp mem alloc is failed!");
 320                         return NULL;
 321                 }
 322
 323                 font_buf = eina_strbuf_new();
 324                 if (font_buf == NULL) {
 325                         D_EMSG("font_buf eina_strbuf_new is failed!");
 326                         if (tmp_buf) {
 327                                 free(tmp_buf);
 328                                 tmp_buf = NULL;
 329                         }
 330                         return NULL;
 331                 }
 332
 333                 markup_text = eina_strbuf_new();
 334                 if (markup_text == NULL) {
 335                         D_EMSG("markup_text eina_strbuf_new is failed!");
 336                         if (tmp_buf) {
 337                                 free(tmp_buf);
 338                                 tmp_buf = NULL;
 339                         }
 340
 341                         if (font_buf) {
 342                                 eina_strbuf_free(font_buf);
 343                                 font_buf = NULL;
 344                         }
 345                         return NULL;
 346                 }
 347
 348                 /* make font style */
 349                 if (fontstyle)
 350                         eina_strbuf_append_printf(font_buf, "<%s>", fontstyle);
 351
 352                 if (fontcolor)
 353                         eina_strbuf_append_printf(font_buf, "<color=%s>", fontcolor);
 354                 D_MSG("font_buf : (%s)", eina_strbuf_string_get(font_buf));
 355
 356                 snprintf(tmp_buf, src_text_len + 1, "%s\n", (char *) src_text);
 357
 358                 while (tmp_buf[start] != '\0') {
 359                         end = strcspn(tmp_buf + start, "\n");
 360
 361                         if (end == 0) {
 362                                 eina_strbuf_append(markup_text, "<br>");
 363                                 start += (tmp_buf[start + end] != '\0') ? end + 1 : end;
 364                                 continue;
 365                         }
 366
 367                         token = (char *)calloc(1, sizeof(char) * (end + 1));
 368                         if (token == NULL) {
 369                                 D_EMSG("calloc is failed");
 370                                 break;
 371                         }
 372
 373                         strncpy(token, tmp_buf + start, end);
 374
 375                         char *tmp_str = elm_entry_utf8_to_markup(token);
 376
 377                         if (!tmp_str) {
 378                                 D_EMSG("elm_entry_utf8_to_markup() is failed, [%s]. Stop parsing entry text", token);
 379                                 free(token);
 380                                 break;
 381                         }
 382
 383                         tmp_str_len = strlen(tmp_str);
 384
 385                         if (tmp_str[tmp_str_len - 1] == 0x0D) { /* if Enter is added via Window system, CR+LF is added. */
 386                                 D_MSG("CR length is decreased");
 387                                 tmp_str_len = tmp_str_len - 1;
 388                         }
 389
 390                         if (!__msg_common_make_normal_markup_text(markup_text, font_buf, tmp_str, tmp_str_len))
 391                                 D_MSG("__msg_common_make_normal_markup_text is failed");
 392
 393                         if (tmp_str)
 394                                 free(tmp_str);
 395
 396                         if (token)
 397                                 free(token);
 398
 399                         start += (tmp_buf[start+end] != '\0') ? end + 1 : end;
 400
 401                         if (start != end)
 402                                 eina_strbuf_append(markup_text, "<br>");
 403                 }
 404
 405                 if (tmp_buf) {
 406                         free(tmp_buf);
 407                         tmp_buf = NULL;
 408                 }
 409
 410                 if (font_buf) {
 411                         eina_strbuf_free(font_buf);
 412                         font_buf = NULL;
 413                 }
 414
 415                 return markup_text;
 416         } else {
 417                 return NULL;
 418         }
 419 }
 420
 421 MSG_BOOL msg_common_is_valid_phone_number(const char *address)
 422 {
 423         D_ENTER;
 424         D_MSG_RETVM_IF(address == NULL, FALSE, "address is NULL");
 425
 426         int addr_len = 0;
 427         addr_len = strlen(address);
 428
 429         if (addr_len == 0)
 430                 return FALSE;
 431
 432         /*  length check phone address should be longer than 2 and shorter than 40 */
 433         if (addr_len > 2 && addr_len <= MSG_COMMON_NUMBER_MAX_LEN) {
 434                 const char *pszOneChar = address;
 435
 436                 if (*pszOneChar == '+')
 437                         ++pszOneChar;
 438
 439                 while (*pszOneChar) {
 440                         if (!isdigit(*pszOneChar) && (*pszOneChar != '*') && (*pszOneChar != '#'))
 441                                 return FALSE;
 442
 443                         ++pszOneChar;
 444                 }
 445
 446                 return TRUE;
 447         } else {
 448                 D_MSG("invalid address length [%d]", addr_len);
 449                 return FALSE;
 450         }
 451 }
 452
 453 MSG_BOOL msg_common_is_valid_email_addr(const char *address)
 454 {
 455         D_ENTER;
 456         D_MSG_RETVM_IF(address == NULL, FALSE, "address is NULL");
 457
 458         char *token1 = NULL;
 459         char *token2 = NULL;
 460
 461         D_MSG("address = %s", address);
 462
 463         token1 = strchr(address, '@');
 464         if (!token1) {
 465                 D_EMSG("address has no @");
 466                 return FALSE;
 467         }
 468
 469         if (strchr(&token1[1], '@')) {
 470                 D_EMSG("address cannot have two more @");
 471                 return FALSE;
 472         }
 473
 474         token2 = strchr(token1, '.');
 475         if (!token2) {
 476                 D_EMSG("there's no . character");
 477                 return FALSE;
 478         }
 479
 480         if ((token2 == token1 + 1) || (*(token2 + 1) == '\0')) {
 481                 D_EMSG("address type should be \'xxx.xxx\'");
 482                 return FALSE;
 483         }
 484
 485         return TRUE;
 486 }
 487
 488 MSG_BOOL msg_common_is_connected_call(void)
 489 {
 490         int call_status = 0;
 491
 492         if (vconf_get_int(VCONFKEY_CALL_STATE, &call_status) < 0)
 493                 return FALSE;
 494
 495         D_MSG("call_status = %d", call_status);
 496
 497         if (call_status != VCONFKEY_CALL_OFF)
 498                 return TRUE;
 499         else
 500                 return FALSE;
 501 }
 502
 503 MSG_BOOL msg_common_is_sim_inserted(void)
 504 {
 505         int sim_slot_status = 0;
 506
 507         if (vconf_get_int(VCONFKEY_TELEPHONY_SIM_SLOT, &sim_slot_status) < 0)
 508                 return FALSE;
 509
 510         D_MSG("sim_slot_status = %d", sim_slot_status);
 511
 512         if (sim_slot_status == VCONFKEY_TELEPHONY_SIM_INSERTED)
 513                 return TRUE;
 514         else
 515                 return FALSE;
 516 }
 517
 518 MSG_BOOL msg_common_get_font_size(int *index)
 519 {
 520         D_ENTER;
 521         D_MSG_RETVM_IF(index == NULL, FALSE, "font_size is NULL");
 522
 523         if (vconf_get_int(VCONFKEY_MSG_APP_FONT_SIZE, index) < 0) {
 524                 D_EMSG("vconf_get_int(font_size) is failed !!");
 525                 return FALSE;
 526         }
 527
 528         if (*index < MSG_APP_FONT_SIZE_INDEX_SMALL || *index >= MSG_APP_FONT_SIZE_INDEX_MAX) {
 529                 D_EMSG("invalid index = %d", *index);
 530                 return FALSE;
 531         } else {
 532                 D_MSG("index = %d", *index);
 533         }
 534
 535         return TRUE;
 536 }
 537
 538 MSG_BOOL msg_common_set_font_size(int index)
 539 {
 540         D_ENTER;
 541
 542         if (index < MSG_APP_FONT_SIZE_INDEX_SMALL || index >= MSG_APP_FONT_SIZE_INDEX_MAX) {
 543                 D_EMSG("invalid index = %d", index);
 544                 return FALSE;
 545         } else {
 546                 D_MSG("index = %d", index);
 547         }
 548
 549         if (vconf_set_int(VCONFKEY_MSG_APP_FONT_SIZE, index) < 0) {
 550                 D_EMSG("vconf_set_int(font_size) is failed !!");
 551                 return FALSE;
 552         }
 553
 554         return TRUE;
 555 }
 556
 557 MSG_BOOL msg_common_increase_font_size()
 558 {
 559         D_ENTER;
 560
 561         int index = -1;
 562         int increase = -1;
 563         if (vconf_get_int(VCONFKEY_MSG_APP_FONT_SIZE, &index) < 0) {
 564                 D_EMSG("vconf_get_int(font_size) is failed !!");
 565                 return FALSE;
 566         } else {
 567                 D_MSG("index = %d", index);
 568         }
 569
 570         switch (index) {
 571         case MSG_APP_FONT_SIZE_INDEX_GIANT :
 572                 break;
 573         case MSG_APP_FONT_SIZE_INDEX_HUGE :
 574                 increase = MSG_APP_FONT_SIZE_INDEX_GIANT;
 575                 break;
 576         case MSG_APP_FONT_SIZE_INDEX_LARGE :
 577                 increase = MSG_APP_FONT_SIZE_INDEX_HUGE;
 578                 break;
 579         case MSG_APP_FONT_SIZE_INDEX_NORMAL :
 580                 increase = MSG_APP_FONT_SIZE_INDEX_LARGE;
 581                 break;
 582         case MSG_APP_FONT_SIZE_INDEX_SMALL :
 583                 increase = MSG_APP_FONT_SIZE_INDEX_NORMAL;
 584                 break;
 585         default :
 586                 increase = MSG_APP_FONT_SIZE_INDEX_NORMAL;
 587                 break;
 588         }
 589
 590         if (increase != -1) {
 591                 if (msg_common_set_font_size(increase) == FALSE) {
 592                         D_EMSG("msg_common_set_font_size is failed");
 593                         return FALSE;
 594                 }
 595         }
 596         return TRUE;
 597 }
 598
 599 MSG_BOOL msg_common_decrease_font_size()
 600 {
 601         D_ENTER;
 602
 603         int index = -1;
 604         int decrease = -1;
 605         if (vconf_get_int(VCONFKEY_MSG_APP_FONT_SIZE, &index) < 0) {
 606                 D_EMSG("vconf_get_int(font_size) is failed !!");
 607                 return FALSE;
 608         } else {
 609                 D_MSG("index = %d", index);
 610         }
 611
 612         switch (index) {
 613         case MSG_APP_FONT_SIZE_INDEX_GIANT :
 614                 decrease = MSG_APP_FONT_SIZE_INDEX_HUGE;
 615                 break;
 616         case MSG_APP_FONT_SIZE_INDEX_HUGE :
 617                 decrease = MSG_APP_FONT_SIZE_INDEX_LARGE;
 618                 break;
 619         case MSG_APP_FONT_SIZE_INDEX_LARGE :
 620                 decrease = MSG_APP_FONT_SIZE_INDEX_NORMAL;
 621                 break;
 622         case MSG_APP_FONT_SIZE_INDEX_NORMAL :
 623                 decrease = MSG_APP_FONT_SIZE_INDEX_SMALL;
 624                 break;
 625         case MSG_APP_FONT_SIZE_INDEX_SMALL :
 626                 break;
 627         default :
 628                 decrease = MSG_APP_FONT_SIZE_INDEX_NORMAL;
 629                 break;
 630         }
 631
 632         if (decrease != -1) {
 633                 if (msg_common_set_font_size(decrease) == FALSE) {
 634                         D_EMSG("msg_common_set_font_size is failed");
 635                         return FALSE;
 636                 }
 637         }
 638         return TRUE;
 639
 640 }
 641
 642 int msg_common_get_font_size_from_index(int index)
 643 {
 644         D_ENTER;
 645
 646         if (index < MSG_APP_FONT_SIZE_INDEX_SMALL || index >= MSG_APP_FONT_SIZE_INDEX_MAX) {
 647                 D_EMSG("invalid index = %d", index);
 648                 return -1;
 649         } else {
 650                 D_MSG("index = %d", index);
 651         }
 652         int font_size = 0;
 653
 654         switch (index) {
 655         case MSG_APP_FONT_SIZE_INDEX_SMALL :
 656                 font_size = MSG_APP_FONT_SIZE_SMALL;
 657                 break;
 658         case MSG_APP_FONT_SIZE_INDEX_NORMAL :
 659                 font_size = MSG_APP_FONT_SIZE_NORMAL;
 660                 break;
 661         case MSG_APP_FONT_SIZE_INDEX_LARGE :
 662                 font_size = MSG_APP_FONT_SIZE_LARGE;
 663                 break;
 664         case MSG_APP_FONT_SIZE_INDEX_HUGE :
 665                 font_size = MSG_APP_FONT_SIZE_HUGE;
 666                 break;
 667         case MSG_APP_FONT_SIZE_INDEX_GIANT :
 668                 font_size = MSG_APP_FONT_SIZE_GIANT;
 669                 break;
 670         default :
 671                 font_size = MSG_APP_FONT_SIZE_NORMAL;
 672                 break;
 673         }
 674
 675         return font_size;
 676 }
 677
 678
 679 int msg_common_get_index_from_font_size(int font_size)
 680 {
 681         D_ENTER;
 682
 683         if (font_size < MSG_APP_FONT_SIZE_SMALL || font_size >= MSG_APP_FONT_SIZE_MAX) {
 684                 D_EMSG("invalid font_size = %d", font_size);
 685                 return -1;
 686         } else {
 687                 D_MSG("font_size = %d", font_size);
 688         }
 689         int index = 0;
 690
 691         switch (font_size) {
 692         case MSG_APP_FONT_SIZE_SMALL :
 693                 index = MSG_APP_FONT_SIZE_INDEX_SMALL;
 694                 break;
 695         case MSG_APP_FONT_SIZE_NORMAL :
 696                 index = MSG_APP_FONT_SIZE_INDEX_NORMAL;
 697                 break;
 698         case MSG_APP_FONT_SIZE_LARGE :
 699                 index = MSG_APP_FONT_SIZE_INDEX_LARGE;
 700                 break;
 701         case MSG_APP_FONT_SIZE_HUGE :
 702                 index = MSG_APP_FONT_SIZE_INDEX_HUGE;
 703                 break;
 704         case MSG_APP_FONT_SIZE_GIANT :
 705                 index = MSG_APP_FONT_SIZE_INDEX_GIANT;
 706                 break;
 707         default :
 708                 index = MSG_APP_FONT_SIZE_INDEX_NORMAL;
 709                 break;
 710         }
 711
 712         return index;
 713 }
 714
 715 MSG_BOOL msg_common_get_access_font_size(int *index)
 716 {
 717         D_ENTER;
 718         D_MSG_RETVM_IF(index == NULL, FALSE, "index is NULL");
 719
 720         if (vconf_get_int(VCONFKEY_MSG_APP_ACCESS_FONT_SIZE, index) < 0) {
 721                 D_EMSG("vconf_get_int(font_size) is failed !!");
 722                 return FALSE;
 723         }
 724
 725         if (*index < MSG_APP_FONT_SIZE_INDEX_SMALL || *index >= MSG_APP_FONT_SIZE_INDEX_MAX) {
 726                 D_EMSG("invalid index = %d", *index);
 727                 return FALSE;
 728         } else {
 729                 D_MSG("index = %d", *index);
 730         }
 731
 732         return TRUE;
 733 }
 734
 735 MSG_BOOL msg_common_set_access_font_size(int index)
 736 {
 737         D_ENTER;
 738
 739         if (index < MSG_APP_FONT_SIZE_INDEX_SMALL || index >= MSG_APP_FONT_SIZE_INDEX_MAX) {
 740                 D_EMSG("invalid index = %d", index);
 741                 return FALSE;
 742         } else {
 743                 D_MSG("index = %d", index);
 744         }
 745
 746         if (vconf_set_int(VCONFKEY_MSG_APP_ACCESS_FONT_SIZE, index) < 0) {
 747                 D_EMSG("vconf_set_int(font_size) is failed !!");
 748                 return FALSE;
 749         }
 750
 751         return TRUE;
 752 }
 753
 754 MSG_BOOL msg_common_apply_font_size(const char *widget_name, Evas_Object *obj)
 755 {
 756         D_ENTER;
 757         D_MSG_RETVM_IF(widget_name == NULL, FALSE, "widget_name is NULL");
 758         D_MSG_RETVM_IF(obj == NULL, FALSE, "obj is NULL");
 759
 760         int index = 0;
 761         int font_size = 0;
 762         Evas_Font_Size font_size_scale = 0;
 763
 764         if (msg_common_get_font_size(&index) != TRUE) {
 765                 D_EMSG("msg_common_get_font_size() is failed !!");
 766                 return FALSE;
 767         } else {
 768                 D_MSG("selected index = %d", index);
 769         }
 770
 771         font_size = msg_common_get_font_size_from_index(index);
 772         if (font_size == -1) {
 773                 D_EMSG("msg_common_get_font_size_from_index() is failed !!");
 774                 return FALSE;
 775         }
 776
 777         /* Calculate the scale factor */
 778         font_size_scale -= (font_size * 100) / MSG_APP_FONT_SIZE_NORMAL;
 779
 780         D_MSG("font_size = %d, font_size_scale = %d", font_size, font_size_scale);
 781
 782         edje_text_class_del(widget_name);
 783         edje_text_class_set(widget_name, NULL, font_size_scale);
 784         elm_widget_theme_specific(obj, NULL, EINA_TRUE);
 785
 786         return TRUE;
 787 }
 788
 789 void msg_common_reset_font_size(const char *widget_name)
 790 {
 791         D_ENTER;
 792         D_MSG_RETM_IF(widget_name == NULL, "widget_name is NULL");
 793
 794         edje_text_class_del(widget_name);
 795
 796         return;
 797 }
 798
 799 static char *__msg_common_get_file_ext(const char *a_pszfile_name)
 800 {
 801         if (a_pszfile_name != NULL) {
 802                 int nlen = strlen(a_pszfile_name);
 803                 char *psztemp = (char *)a_pszfile_name + nlen;
 804
 805                 while (nlen--) {
 806                         psztemp--;
 807                         if (*psztemp == '.') {
 808                                 psztemp++;
 809                                 break;
 810                         }
 811                 }
 812                 return psztemp;
 813         }
 814
 815         return NULL;
 816 }
 817
 818 static MSG_BOOL __msg_common_is_drm_file(const char *filepath)
 819 {
 820         D_ENTER;
 821         D_MSG_RETVM_IF(filepath == NULL, FALSE, "filepath is NULL");
 822         drm_bool_type_e is_drm_file = DRM_UNKNOWN;
 823         int ret = DRM_RETURN_SUCCESS;
 824
 825         ret = drm_is_drm_file(filepath, &is_drm_file);
 826
 827         if (ret == DRM_RETURN_SUCCESS && is_drm_file == DRM_TRUE) {
 828                 return TRUE;
 829         } else {
 830                 D_MSG("ret = %d", ret);
 831                 return FALSE;
 832         }
 833 }
 834
 835 static MSG_APP_FILE_TYPE_E __msg_common_get_file_type_by_file_ext(const char *file_ext, const char *fullpath)
 836 {
 837         D_ENTER;
 838         int i = 0;
 839
 840         if (file_ext == NULL) {
 841                 D_EMSG("file_ext is NULL");
 842                 return MSG_APP_FILE_TYPE_ETC;
 843         }
 844
 845         switch (file_ext[i]) {
 846         case 'a':
 847         case 'A':
 848                 if (strcasecmp("ASF", &file_ext[i]) == 0) {
 849                         return MSG_APP_FILE_TYPE_VIDEO;
 850                 }
 851                 if (strcasecmp("AMR", &file_ext[i]) == 0) {
 852                         return MSG_APP_FILE_TYPE_VOICE;
 853                 }
 854                 if (strcasecmp("AWB", &file_ext[i]) == 0) {
 855                         return MSG_APP_FILE_TYPE_VOICE;
 856                 }
 857                 if (strcasecmp("AAC", &file_ext[i]) == 0) {
 858                         return MSG_APP_FILE_TYPE_MUSIC;
 859                 }
 860                 if (strcasecmp("AVI", &file_ext[i]) == 0) {
 861                         return MSG_APP_FILE_TYPE_VIDEO;
 862                 }
 863                 if (strcasecmp("AAC", &file_ext[i]) == 0) {
 864                         return MSG_APP_FILE_TYPE_MUSIC;
 865                 }
 866                 break;
 867
 868         case 'b':
 869         case 'B':
 870                 if (strcasecmp("BMP", &file_ext[i]) == 0) {
 871                         return MSG_APP_FILE_TYPE_IMAGE;
 872                 }
 873                 break;
 874
 875         case 'd':
 876         case 'D':
 877                 if (strcasecmp("DOC", &file_ext[i]) == 0) {
 878                         return MSG_APP_FILE_TYPE_DOC;
 879                 }
 880                 if (strcasecmp("DOCX", &file_ext[i]) == 0) {
 881                         return MSG_APP_FILE_TYPE_DOC;
 882                 }
 883                 if (strcasecmp("DIVX", &file_ext[i]) == 0) {
 884                         if (__msg_common_is_drm_file(fullpath) == 0) {
 885                                 return MSG_APP_FILE_TYPE_DRM;
 886                         } else {
 887                                 return MSG_APP_FILE_TYPE_VIDEO;
 888                         }
 889                 }
 890                 if (strcasecmp("DCF", &file_ext[i]) == 0) {
 891                         return MSG_APP_FILE_TYPE_DRM;
 892                 }
 893                 break;
 894
 895         case 'g':
 896         case 'G':
 897                 if (strcasecmp("GIF", &file_ext[i]) == 0) {
 898                         return MSG_APP_FILE_TYPE_IMAGE;
 899                 }
 900                 if (strcasecmp("G72", &file_ext[i]) == 0) {
 901                         return MSG_APP_FILE_TYPE_MUSIC;
 902                 }
 903                 break;
 904
 905         case 'h':
 906         case 'H':
 907                 if (strcasecmp("H263", &file_ext[i]) == 0) {
 908                         return MSG_APP_FILE_TYPE_MUSIC;
 909                 }
 910                 if (strcasecmp("HTML", &file_ext[i]) == 0) {
 911                         return MSG_APP_FILE_TYPE_HTML;
 912                 }
 913                 if (strcasecmp("HTM", &file_ext[i]) == 0) {
 914                         return MSG_APP_FILE_TYPE_HTML;
 915                 }
 916                 break;
 917
 918         case 'i':
 919         case 'I':
 920                 if (strcasecmp("IMY", &file_ext[i]) == 0) {
 921                         return MSG_APP_FILE_TYPE_SOUND;
 922                 }
 923                 break;
 924
 925         case 'j':
 926         case 'J':
 927                 if (strcasecmp("JAD", &file_ext[i]) == 0) {
 928                         return MSG_APP_FILE_TYPE_JAVA;
 929                 }
 930                 if (strcasecmp("JAR", &file_ext[i]) == 0) {
 931                         return MSG_APP_FILE_TYPE_JAVA;
 932                 }
 933
 934                 if (strcasecmp("JPG", &file_ext[i]) == 0) {
 935                         return MSG_APP_FILE_TYPE_IMAGE;
 936                 }
 937                 if (strcasecmp("JPEG", &file_ext[i]) == 0) {
 938                         return MSG_APP_FILE_TYPE_IMAGE;
 939                 }
 940                 if (strcasecmp("JPE", &file_ext[i]) == 0) {
 941                         return MSG_APP_FILE_TYPE_IMAGE;
 942                 }
 943                 break;
 944
 945         case 'm':
 946         case 'M':
 947                 if (strcasecmp("MMF", &file_ext[i]) == 0) {
 948                         return MSG_APP_FILE_TYPE_SOUND;
 949                 }
 950                 if (strcasecmp("MP3", &file_ext[i]) == 0) {
 951                         return MSG_APP_FILE_TYPE_MUSIC;
 952                 }
 953                 if (strcasecmp("MID", &file_ext[i]) == 0) {
 954                         return MSG_APP_FILE_TYPE_SOUND;
 955                 }
 956                 if (strcasecmp("MIDI", &file_ext[i]) == 0) {
 957                         return MSG_APP_FILE_TYPE_SOUND;
 958                 }
 959                 if (strcasecmp("MP4", &file_ext[i]) == 0) {
 960                         return MSG_APP_FILE_TYPE_VIDEO;
 961                 }
 962                 if (strcasecmp("MPG", &file_ext[i]) == 0) {
 963                         return MSG_APP_FILE_TYPE_VIDEO;
 964                 }
 965                 if (strcasecmp("MPEG", &file_ext[i]) == 0) {
 966                         return MSG_APP_FILE_TYPE_VIDEO;
 967                 }
 968                 if (strcasecmp("M4A", &file_ext[i]) == 0) {
 969                         return MSG_APP_FILE_TYPE_MUSIC;
 970                 }
 971                 if (strcasecmp("M3G", &file_ext[i]) == 0) {
 972                         return MSG_APP_FILE_TYPE_FLASH;
 973                 }
 974                 if (strcasecmp("MXMF", &file_ext[i]) == 0) {
 975                         return MSG_APP_FILE_TYPE_SOUND;
 976                 }
 977                 if (strcasecmp("MKV", &file_ext[i]) == 0) {
 978                         return MSG_APP_FILE_TYPE_VIDEO;
 979                 }
 980                 if (strcasecmp("MKA", &file_ext[i]) == 0) {
 981                         return MSG_APP_FILE_TYPE_MUSIC;
 982                 }
 983                 break;
 984
 985         case 'o':
 986         case 'O':
 987                 if (strcasecmp("opml", &file_ext[i]) == 0) {
 988                         return MSG_APP_FILE_TYPE_RSS;
 989                 }
 990                 break;
 991
 992         case 'p':
 993         case 'P':
 994                 if (strcasecmp("PNG", &file_ext[i]) == 0) {
 995                         return MSG_APP_FILE_TYPE_IMAGE;
 996                 }
 997                 if (strcasecmp("PJPEG", &file_ext[i]) == 0) {
 998                         return MSG_APP_FILE_TYPE_IMAGE;
 999                 }
1000                 if (strcasecmp("PDF", &file_ext[i]) == 0) {
1001                         return MSG_APP_FILE_TYPE_PDF;
1002                 }
1003                 if (strcasecmp("PPT", &file_ext[i]) == 0) {
1004                         return MSG_APP_FILE_TYPE_PPT;
1005                 }
1006                 if (strcasecmp("PPTX", &file_ext[i]) == 0) {
1007                         return MSG_APP_FILE_TYPE_PPT;
1008                 }
1009                 break;
1010
1011         case 'r':
1012         case 'R':
1013                 break;
1014
1015         case 's':
1016         case 'S':
1017                 if (strcasecmp("SDP", &file_ext[i]) == 0) {
1018                         return MSG_APP_FILE_TYPE_VIDEO;
1019                 }
1020                 if (strcasecmp("SPM", &file_ext[i]) == 0) {
1021                         return MSG_APP_FILE_TYPE_SOUND;
1022                 }
1023                 if (strcasecmp("SMP", &file_ext[i]) == 0) {
1024                         return MSG_APP_FILE_TYPE_SOUND;
1025                 }
1026                 if (strcasecmp("SPF", &file_ext[i]) == 0) {
1027                         return MSG_APP_FILE_TYPE_SOUND;
1028                 }
1029                 if (strcasecmp("SWF", &file_ext[i]) == 0) {
1030                         return MSG_APP_FILE_TYPE_FLASH;
1031                 }
1032                 if (strcasecmp("SVG", &file_ext[i]) == 0) {
1033                         return MSG_APP_FILE_TYPE_SVG;
1034                 }
1035                 if (strcasecmp("SVGZ", &file_ext[i]) == 0) {
1036                         return MSG_APP_FILE_TYPE_SVG;
1037                 }
1038                 break;
1039
1040         case 't':
1041         case 'T':
1042                 if (strcasecmp("TXT", &file_ext[i]) == 0) {
1043                         return MSG_APP_FILE_TYPE_TXT;
1044                 }
1045                 break;
1046
1047         case 'v':
1048         case 'V':
1049                 if (strcasecmp("VCF", &file_ext[i]) == 0) {
1050                         return MSG_APP_FILE_TYPE_VCONTACT;
1051                 }
1052                 if (strcasecmp("VCS", &file_ext[i]) == 0) {
1053                         return MSG_APP_FILE_TYPE_VCALENDAR;
1054                 }
1055                 if (strcasecmp("VNT", &file_ext[i]) == 0) {
1056                         return MSG_APP_FILE_TYPE_VNOTE;
1057                 }
1058                 if (strcasecmp("VBM", &file_ext[i]) == 0) {
1059                         return MSG_APP_FILE_TYPE_VBOOKMARK;
1060                 }
1061                 break;
1062
1063         case 'w':
1064         case 'W':
1065                 if (strcasecmp("WAV", &file_ext[i]) == 0) {
1066                         return MSG_APP_FILE_TYPE_SOUND;
1067                 }
1068                 if (strcasecmp("WBMP", &file_ext[i]) == 0) {
1069                         return MSG_APP_FILE_TYPE_IMAGE;
1070                 }
1071                 if (strcasecmp("WGT", &file_ext[i]) == 0) {
1072                         return MSG_APP_FILE_TYPE_WGT;
1073                 }
1074                 if (strcasecmp("WMA", &file_ext[i]) == 0) {
1075                         return MSG_APP_FILE_TYPE_MUSIC;
1076                 }
1077                 if (strcasecmp("WMV", &file_ext[i]) == 0) {
1078                         return MSG_APP_FILE_TYPE_VIDEO;
1079                 }
1080                 break;
1081
1082         case 'x':
1083         case 'X':
1084                 if (strcasecmp("XLS", &file_ext[i]) == 0) {
1085                         return MSG_APP_FILE_TYPE_EXCEL;
1086                 }
1087                 if (strcasecmp("XLSX", &file_ext[i]) == 0) {
1088                         return MSG_APP_FILE_TYPE_EXCEL;
1089                 }
1090                 if (strcasecmp("XMF", &file_ext[i]) == 0) {
1091                         return MSG_APP_FILE_TYPE_SOUND;
1092                 }
1093                 if (strcasecmp("XHTML", &file_ext[i]) == 0) {
1094                         return MSG_APP_FILE_TYPE_HTML;
1095                 }
1096                 break;
1097
1098         case '3':
1099                 if (strcasecmp("3GP", &file_ext[i]) == 0) {
1100                         return MSG_APP_FILE_TYPE_VIDEO;
1101                 }
1102                 if (strcasecmp("3GPP", &file_ext[i]) == 0) {
1103                         return MSG_APP_FILE_TYPE_VIDEO;
1104                 }
1105                 if (strcasecmp("3G2", &file_ext[i]) == 0) {
1106                         return MSG_APP_FILE_TYPE_VIDEO;
1107                 }
1108                 break;
1109         }
1110
1111         return MSG_APP_FILE_TYPE_ETC;
1112 }
1113
1114 const char *__msg_common_get_file_icon_by_file_type(MSG_APP_FILE_TYPE_E file_type)
1115 {
1116         const char *icon_path = MSG_COMMON_FILE_ETC_ICON;
1117         if (file_type <= MSG_APP_FILE_TYPE_NONE || file_type >= MSG_APP_FILE_TYPE_MAX) {
1118                 D_EMSG("Invalid file_type!! file_type = %d", file_type);
1119                 return NULL;
1120         }
1121
1122         if (icon_array[file_type]) {
1123                 icon_path = icon_array[file_type];
1124         }
1125
1126         return icon_path;
1127 }
1128
1129 const char *msg_common_get_file_icon(const char *filepath)
1130 {
1131         D_ENTER;
1132         D_MSG_RETVM_IF(filepath == NULL, NULL, "filepath is NULL");
1133         const char *icon_path = MSG_COMMON_FILE_ETC_ICON;
1134         char *file_ext = __msg_common_get_file_ext(filepath);
1135
1136         if (file_ext) {
1137                 MSG_APP_FILE_TYPE_E file_type = MSG_APP_FILE_TYPE_NONE;
1138
1139                 file_type = __msg_common_get_file_type_by_file_ext(file_ext, filepath);
1140                 icon_path = __msg_common_get_file_icon_by_file_type(file_type);
1141         } else {
1142                 D_EMSG("file_ext is NULL");
1143         }
1144
1145         return icon_path;
1146 }
1147
1148 int msg_common_add_block_number(msg_handle_t msgHandle, const char *address)
1149 {
1150         D_ENTER;
1151         msg_error_t err = MSG_SUCCESS;
1152         msg_struct_t filter = msg_create_struct(MSG_STRUCT_FILTER);
1153
1154         msg_set_int_value(filter, MSG_FILTER_TYPE_INT, MSG_FILTER_BY_ADDRESS_SAME);
1155         msg_set_str_value(filter, MSG_FILTER_VALUE_STR, (char *)address, DEF_MAX_FILTER_LEN);
1156
1157         err = msg_add_filter(msgHandle, filter);
1158         if (err != MSG_SUCCESS) {
1159                 D_EMSG("failed to add filter");
1160                 msg_release_struct(&filter);
1161                 return err;
1162         }
1163
1164         if (filter)
1165                 msg_release_struct(&filter);
1166
1167         D_LEAVE;
1168         return err;
1169 }
1170
1171 int msg_common_delete_block_number(msg_handle_t msgHandle, const char *address)
1172 {
1173         D_ENTER;
1174         D_MSG_RETVM_IF(!msgHandle, FALSE, "msgHandle is NULL");
1175         D_MSG_RETVM_IF(!address, FALSE, "address is NULL");
1176
1177         msg_struct_list_s filter_list = {0,};
1178         msg_error_t err = MSG_SUCCESS;
1179
1180         err = msg_get_filter_list(msgHandle, &filter_list);
1181
1182         if (err != MSG_SUCCESS) {
1183                 D_EMSG("Getting filter list fail");
1184                 return err;
1185         }
1186
1187         if (filter_list.nCount == 0) {
1188                 D_EMSG("filter count is 0");
1189                 msg_release_list_struct(&filter_list);
1190                 return MSG_ERR_UNKNOWN;
1191         }
1192
1193         int i = 0;
1194         int filter_type = -1;
1195         int filter_id = -1;
1196         char filter_address[DEF_BUF_LEN] = {0,};
1197
1198         for (i=0; i<filter_list.nCount; i++) {
1199                 msg_get_int_value(filter_list.msg_struct_info[i], MSG_FILTER_TYPE_INT, &filter_type);
1200                 if (filter_type == MSG_FILTER_BY_ADDRESS_SAME) {
1201                         msg_get_str_value(filter_list.msg_struct_info[i], MSG_FILTER_VALUE_STR, filter_address, sizeof(filter_address));
1202                         if (strncmp(filter_address, address, sizeof(filter_address)) == 0) {
1203                                 msg_get_int_value(filter_list.msg_struct_info[i], MSG_FILTER_ID_INT, &filter_id);
1204                                 break;
1205                         }
1206                 }
1207         }
1208
1209         if (filter_id != -1)
1210                 msg_delete_filter(msgHandle, filter_id);
1211
1212         msg_release_list_struct(&filter_list);
1213         return err;
1214 }
1215
1216 int msg_common_check_block_number(msg_handle_t msgHandle, const char *address, bool *result)
1217 {
1218         D_ENTER;
1219         D_MSG_RETVM_IF(!msgHandle, FALSE, "msgHandle is NULL");
1220         D_MSG_RETVM_IF(!address, FALSE, "address is NULL");
1221
1222         msg_struct_list_s filter_list = {0,};
1223         msg_error_t err = MSG_SUCCESS;
1224
1225         err = msg_get_filter_list(msgHandle, &filter_list);
1226
1227         if (err != MSG_SUCCESS) {
1228                 D_EMSG("Getting filter list fail");
1229                 return err;
1230         }
1231
1232         if (filter_list.nCount == 0) {
1233                 *result = false;
1234         } else {
1235                 bool isFound = false;
1236                 int i = 0;
1237                 int filter_type = -1;
1238                 char filter_address[DEF_BUF_LEN] = {0,};
1239                 for (i=0; i<filter_list.nCount; i++) {
1240                         msg_get_int_value(filter_list.msg_struct_info[i], MSG_FILTER_TYPE_INT, &filter_type);
1241                         if (filter_type == MSG_FILTER_BY_ADDRESS_SAME) {
1242                                 msg_get_str_value(filter_list.msg_struct_info[i], MSG_FILTER_VALUE_STR, filter_address, sizeof(filter_address));
1243
1244                                 if (strncmp(filter_address, address, sizeof(filter_address)) == 0) {
1245                                         isFound = true;
1246                                         break;
1247                                 }
1248                         }
1249                 }
1250                 *result = isFound;
1251         }
1252
1253         msg_release_list_struct(&filter_list);
1254         return err;
1255 }
1256
1257 /*********************
1258 * [SMS]
1259 *       [sent / outbox]
1260 *       1. Type:
1261 *       2. To:
1262 *       3. sent time:
1263 *       4. delivery report
1264 *       5. Status:
1265 *
1266 *       [inbox]
1267 *       1. Type:
1268 *       2. From
1269 *       3. Received time:
1270 *
1271 * [MMS notification]
1272 *       1. Type:
1273 *       2. From:
1274 *       3: Expire:
1275 *       4. Subject:
1276 *       5. Message size: KB
1277 *
1278 * [MMS]
1279 *       [ For sent/outbox msg]
1280 *       1. Type:
1281 *       2. To:
1282 *       3. Sent time:
1283 *       4. Subject:
1284 *       5. Message size:
1285 *       6. Delivery report:
1286 *       7. Read report:
1287 *
1288 *       [For inbox msg]
1289 *       1. Type:
1290 *       2. From:
1291 *       3. Received time:
1292 *       4. Subject:
1293 *       5. Message size: KB
1294 **********************/
1295
1296 char *msg_common_make_message_detail_text(msg_handle_t msgHandle, int msgId)
1297 {
1298         msg_error_t err = MSG_SUCCESS;
1299         int msg_type = MSG_TYPE_INVALID;
1300         int folder_id = MSG_MAX_FOLDER_ID;
1301         int thread_id = 0;
1302         int contact_id = 0;
1303         int timeformat = 0;
1304         bool delivery_flag = false;
1305         bool read_flag = false;
1306         char addr_value[MAX_ADDRESS_VAL_LEN+1] = {0,};
1307         char name[MAX_DISPLAY_NAME_LEN]= {0,};
1308
1309         msg_struct_list_s addrList = {0,};
1310         msg_struct_t msgInfo = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
1311         msg_struct_t sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
1312
1313         /** Get message **/
1314         err = msg_get_message(msgHandle, msgId, msgInfo, sendOpt);
1315         if (err != MSG_SUCCESS) {
1316                 D_EMSG("msg_get_message has failed");
1317                 msg_release_struct(&msgInfo);
1318                 msg_release_struct(&sendOpt);
1319                 return NULL;
1320         }
1321
1322         msg_get_int_value(msgInfo, MSG_MESSAGE_TYPE_INT, &msg_type);
1323         msg_get_int_value(msgInfo, MSG_MESSAGE_FOLDER_ID_INT, &folder_id);
1324         msg_get_int_value(msgInfo, MSG_MESSAGE_THREAD_ID_INT, &thread_id);
1325
1326         /** Get address list **/
1327         err = msg_get_address_list(msgHandle, thread_id, &addrList);
1328         if (err != MSG_SUCCESS) {
1329                 D_EMSG("msg_get_message has failed");
1330                 msg_release_struct(&msgInfo);
1331                 msg_release_struct(&sendOpt);
1332                 return NULL;
1333         }
1334
1335         /* create str buf */
1336         Eina_Strbuf *text_data = eina_strbuf_new();
1337
1338         /* set font size */
1339         eina_strbuf_append(text_data, "<font_size=32>");
1340
1341
1342         /*** Type ***/
1343         eina_strbuf_append(text_data, dgettext("sys_string", "IDS_COM_BODY_DETAILS_TYPE"));
1344         eina_strbuf_append(text_data, ": ");
1345
1346         if (msg_type == MSG_TYPE_MMS) {
1347                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_MULTIMEDIA_MESSAGE"));
1348         } else if (msg_type == MSG_TYPE_MMS_NOTI) {
1349                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_MULTIMEDIA_MESSAGE_NOTIFICATION"));
1350         } else if (msg_type == MSG_TYPE_SMS) {
1351                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_TEXT_MESSAGE"));
1352         } else {
1353                 D_EMSG("invalid msg type!");
1354                 msg_release_struct(&msgInfo);
1355                 msg_release_struct(&sendOpt);
1356
1357                 eina_strbuf_free(text_data);
1358                 return NULL;
1359         }
1360         eina_strbuf_append(text_data, "<br>");
1361
1362         /*** From / To ***/
1363         if (folder_id == MSG_SENTBOX_ID || folder_id == MSG_OUTBOX_ID) {
1364                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGC_OPT_CHANGE_RECIPIENTS_TO"));
1365                 eina_strbuf_append(text_data, ": ");
1366         } else if (folder_id == MSG_INBOX_ID) {
1367                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_FROM"));
1368                 eina_strbuf_append(text_data, ": ");
1369         } else {
1370                 D_EMSG("invalid msg type!");
1371                 msg_release_struct(&msgInfo);
1372                 msg_release_struct(&sendOpt);
1373
1374                 eina_strbuf_free(text_data);
1375                 return NULL;
1376         }
1377
1378         int index = 0;
1379         for (index  = 0; index < addrList.nCount; index ++) {
1380                 bzero(name, sizeof(name));
1381                 bzero(addr_value, sizeof(addr_value));
1382
1383                 msg_get_int_value(addrList.msg_struct_info[index], MSG_ADDRESS_INFO_CONTACT_ID_INT, &contact_id);
1384                 msg_get_str_value(addrList.msg_struct_info[index], MSG_ADDRESS_INFO_DISPLAYNAME_STR, name, MAX_DISPLAY_NAME_LEN);
1385                 msg_get_str_value(addrList.msg_struct_info[index], MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, addr_value, MAX_ADDRESS_VAL_LEN);
1386
1387                 if (name[0] != '\0') {
1388                         eina_strbuf_append(text_data, name);
1389                         eina_strbuf_append(text_data, "(");
1390                         eina_strbuf_append(text_data, addr_value);
1391                         eina_strbuf_append(text_data, ")");
1392                 } else {
1393                         eina_strbuf_append(text_data, addr_value);
1394                 }
1395                 if (index != addrList.nCount-1)
1396                         eina_strbuf_append(text_data, ", ");
1397         }
1398         eina_strbuf_append(text_data, "<br>");
1399
1400         /*** Sent / Received / Expire Time ***/
1401         timeformat = msg_common_get_timeformat();
1402
1403         if (msg_type == MSG_TYPE_MMS_NOTI) {
1404                 msg_struct_t mmsSendOpt = NULL;
1405                 int expiry_time;
1406                 char *str_time = NULL;
1407
1408                 char msg[DEF_BUF_LEN] = {0,};
1409                 const char *expire_str = dgettext(MESSAGE_PKGNAME, "IDS_MSGF_HEADER_EXPIRES_C_PS");
1410
1411                 msg_get_struct_handle(sendOpt, MSG_SEND_OPT_MMS_OPT_HND, &mmsSendOpt);
1412                 msg_get_int_value(mmsSendOpt, MSG_MMS_SENDOPTION_EXPIRY_TIME_INT, &expiry_time);
1413
1414                 if (timeformat == MSG_TIME_FORMAT_24H)
1415                         str_time = msg_common_get_formatted_date(msg_common_get_default_locale(), "HH:mm, d MMM y", &expiry_time);
1416                 else
1417                         str_time = msg_common_get_formatted_date(msg_common_get_default_locale(), "hh:mm a, d MMM y", &expiry_time);
1418
1419                 snprintf(msg, sizeof(msg), expire_str, str_time);
1420                 eina_strbuf_append(text_data, msg);
1421         } else {
1422                 if (folder_id == MSG_SENTBOX_ID || folder_id == MSG_OUTBOX_ID) {
1423                         eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_MMSNOTIMSGSTATUSSENT"));
1424                 } else if (folder_id == MSG_INBOX_ID) {
1425                         eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_RECEIVED"));
1426                 }
1427                 eina_strbuf_append(text_data, ": ");
1428
1429                 int dptime = 0;
1430                 msg_get_int_value(msgInfo, MSG_MESSAGE_DISPLAY_TIME_INT, &dptime);
1431
1432                 char *str_time = NULL;
1433                 if (timeformat == MSG_TIME_FORMAT_24H)
1434                         str_time = msg_common_get_formatted_date(msg_common_get_default_locale(), "HH:mm, d MMM y", &dptime);
1435                 else
1436                         str_time = msg_common_get_formatted_date(msg_common_get_default_locale(), "hh:mm a, d MMM y", &dptime);
1437                 eina_strbuf_append(text_data, str_time);
1438         }
1439
1440         /*line change*/
1441         eina_strbuf_append(text_data, "<br>");
1442
1443         if (msg_type == MSG_TYPE_SMS) { /*** SMS ***/
1444                 int status;
1445
1446                 switch (folder_id) {
1447                 case MSG_SENTBOX_ID:
1448                 case MSG_OUTBOX_ID:
1449                         /** delivery report */
1450                         eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_DELIVERY_REPORT"));
1451                         eina_strbuf_append(text_data, ": ");
1452                         // get delivery report setting value
1453                         msg_get_bool_value(sendOpt, MSG_SEND_OPT_DELIVER_REQ_BOOL, &delivery_flag);
1454
1455                         if (delivery_flag) {
1456                                 eina_strbuf_append(text_data, "<br>");
1457                                 // report status
1458                                 msg_struct_list_s report_list = {0,};
1459                                 err = msg_get_report_status(msgHandle, msgId, &report_list);
1460
1461                                 int i = 0;
1462                                 int j = 0;
1463
1464                                 if (report_list.nCount != 0) {
1465                                         msg_struct_t report = NULL;
1466                                         int type;
1467                                         int status;
1468                                         time_t time;
1469                                         char address[MAX_ADDRESS_VAL_LEN+1] = {0,};
1470
1471
1472                                         for (i=0; i < addrList.nCount; i++) {
1473                                                 bool report_found = false;
1474
1475                                                 bzero(addr_value, sizeof(addr_value));
1476                                                 bzero(address, sizeof(address));
1477                                                 msg_get_str_value(addrList.msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, addr_value, MAX_ADDRESS_VAL_LEN);
1478
1479                                                 eina_strbuf_append(text_data, addr_value);
1480                                                 eina_strbuf_append(text_data, " - ");
1481
1482                                                 for (j=0; j<report_list.nCount; j++) {
1483                                                         report = report_list.msg_struct_info[j];
1484                                                         msg_get_str_value(report, MSG_REPORT_ADDRESS_STR, address, sizeof(address));
1485
1486                                                         if (!strcmp(addr_value, address)) {
1487                                                                 report_found = true;
1488                                                                 msg_get_int_value(report, MSG_REPORT_TYPE_INT, &type);
1489                                                                 msg_get_int_value(report, MSG_REPORT_STATUS_INT, &status);
1490                                                                 msg_get_int_value(report, MSG_REPORT_TIME_INT, (int *)&time);
1491
1492                                                                 if (type == MSG_REPORT_TYPE_DELIVERY) {
1493                                                                         if (status == MSG_DELIVERY_REPORT_NONE) {
1494                                                                                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_REQUESTED"));
1495                                                                         } else if (status == MSG_DELIVERY_REPORT_EXPIRED) {
1496                                                                                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_EXPIRED"));
1497                                                                         } else if (status == MSG_DELIVERY_REPORT_SUCCESS) {
1498                                                                                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_RECEIVED"));
1499                                                                                 eina_strbuf_append(text_data, " (");
1500                                                                                 char *str_time = NULL;
1501                                                                                 if (timeformat == MSG_TIME_FORMAT_24H)
1502                                                                                         str_time = msg_common_get_formatted_date(msg_common_get_default_locale(), "HH:mm, d MMM", &time);
1503                                                                                 else
1504                                                                                         str_time = msg_common_get_formatted_date(msg_common_get_default_locale(), "hh:mm a, d MMM", &time);
1505                                                                                 eina_strbuf_append(text_data, str_time);
1506                                                                                 eina_strbuf_append(text_data, ")");
1507                                                                         } else if (status == MSG_DELIVERY_REPORT_REJECTED) {
1508                                                                                 eina_strbuf_append(text_data, dgettext("sys_string", "IDS_COM_POP_REJECTED"));
1509                                                                         } else {
1510                                                                                 eina_strbuf_append(text_data, dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"));
1511                                                                         }
1512                                                                 }
1513                                                         }
1514                                                 }
1515                                                 if (!report_found)
1516                                                         eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_REQUESTED"));
1517
1518                                                 eina_strbuf_append(text_data, "<br>");
1519                                         }
1520                                 } else {
1521                                         for (i=0; i < addrList.nCount; i++) {
1522                                                 bzero(addr_value, sizeof(addr_value));
1523                                                 msg_get_str_value(addrList.msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, addr_value, MAX_ADDRESS_VAL_LEN);
1524                                                 eina_strbuf_append(text_data, addr_value);
1525                                                 eina_strbuf_append(text_data, " - ");
1526                                                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_REQUESTED"));
1527                                                 eina_strbuf_append(text_data, "<br>");
1528                                         }
1529                                 }
1530
1531                                 msg_release_list_struct(&report_list);
1532                         } else {
1533                                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGC_BODY_NOT_REQUESTED"));
1534                         }
1535
1536                         eina_strbuf_append(text_data, "<br>");
1537
1538                         /** status **/
1539                         eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_STATUS"));
1540                         eina_strbuf_append(text_data, ": ");
1541                         msg_get_int_value(msgInfo, MSG_MESSAGE_NETWORK_STATUS_INT, &status);
1542                         if (status == MSG_NETWORK_SENDING)
1543                                 eina_strbuf_append(text_data, dgettext("sys_string", "IDS_COM_POP_SENDING"));
1544                         else if (status == MSG_NETWORK_SEND_SUCCESS)
1545                                 eina_strbuf_append(text_data, dgettext("sys_string", "IDS_COM_POP_SENT"));
1546                         else if (status == MSG_NETWORK_SEND_FAIL)
1547                                 eina_strbuf_append(text_data, dgettext("sys_string", "IDS_COM_POP_SENDING_FAILED"));
1548
1549                         eina_strbuf_append(text_data, "<br>");
1550                         break;
1551                 default:
1552                         break;
1553                 }
1554         } else if (msg_type == MSG_TYPE_MMS || msg_type == MSG_TYPE_MMS_NOTI) { /*** MMS ***/
1555                 /** subject **/
1556                 char subject[DEF_BUF_LEN_S] = {0,};
1557                 eina_strbuf_append(text_data, dgettext("sys_string", "IDS_COM_BODY_SUBJECT"));
1558                 eina_strbuf_append(text_data, ": ");
1559                 msg_get_str_value(msgInfo, MSG_MESSAGE_SUBJECT_STR, subject, sizeof(subject));
1560                 if (subject[0] != '\0')
1561                         eina_strbuf_append(text_data, subject);
1562                 else
1563                         eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_UNTITLED_M_MMS"));
1564                 eina_strbuf_append(text_data, "<br>");
1565
1566                 /** messae size **/
1567                 int msgSize = 0;
1568                 int sizeKB = 0;
1569                 char strSize[DEF_BUF_LEN_D] = {0,};
1570                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_MESSAGE_SIZE"));
1571                 eina_strbuf_append(text_data, ": ");
1572                 msg_get_int_value(msgInfo, MSG_MESSAGE_DATA_SIZE_INT, &msgSize);
1573
1574                 sizeKB = msgSize/1024;
1575                 if (msgSize%1024 > 512)
1576                         sizeKB++;
1577                 snprintf(strSize, sizeof(strSize), "%d%s", sizeKB, dgettext(MESSAGE_PKGNAME, "KB"));
1578                 eina_strbuf_append(text_data, strSize);
1579                 eina_strbuf_append(text_data, "<br>");
1580
1581                 if (folder_id == MSG_SENTBOX_ID || folder_id == MSG_OUTBOX_ID) {
1582                         msg_struct_list_s report_list = {0,};
1583                         MSG_DETAIL_REPORT_LIST_S *report_data_list = NULL;
1584                         msg_struct_t mms_send_opt = NULL;
1585
1586                         msg_get_bool_value(sendOpt, MSG_SEND_OPT_DELIVER_REQ_BOOL, &delivery_flag);
1587                         msg_get_struct_handle(sendOpt, MSG_SEND_OPT_MMS_OPT_HND, &mms_send_opt);
1588                         msg_get_bool_value(mms_send_opt, MSG_MMS_SENDOPTION_READ_REQUEST_BOOL, &read_flag);
1589
1590                         // getting delivery & read report information
1591                         if (delivery_flag || read_flag) {
1592                                 int i;
1593                                 report_data_list = (MSG_DETAIL_REPORT_LIST_S *)calloc(addrList.nCount, sizeof(MSG_DETAIL_REPORT_LIST_S));
1594                                 if (report_data_list == NULL)
1595                                         D_EMSG("report_list is null");
1596
1597                                 // get report status from FW
1598                                 msg_get_report_status(msgHandle, msgId, &report_list);
1599
1600                                 for (i=0; i<addrList.nCount; i++) {
1601                                         bzero(addr_value, sizeof(addr_value));
1602                                         msg_get_str_value(addrList.msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, addr_value, MAX_ADDRESS_VAL_LEN);
1603
1604                                         strncpy(report_data_list[i].address, addr_value, MAX_ADDRESS_VAL_LEN);
1605                                         report_data_list[i].delivery.status = MSG_DELIVERY_REPORT_NONE;
1606                                         report_data_list[i].read.status = MSG_READ_REPORT_NONE;
1607                                 }
1608
1609                                 for (i = 0; i < report_list.nCount; i++) {
1610                                         int type;
1611                                         int status;
1612                                         time_t time;
1613
1614                                         bzero(addr_value, sizeof(addr_value));
1615
1616                                         msg_get_int_value(report_list.msg_struct_info[i], MSG_REPORT_TYPE_INT, (int *)&type);
1617                                         msg_get_int_value(report_list.msg_struct_info[i], MSG_REPORT_STATUS_INT, (int *)&status);
1618                                         msg_get_str_value(report_list.msg_struct_info[i], MSG_REPORT_ADDRESS_STR, addr_value, MAX_ADDRESS_VAL_LEN);
1619                                         msg_get_int_value(report_list.msg_struct_info[i], MSG_REPORT_TIME_INT, (int *)&time);
1620
1621                                         int j = 0;
1622                                         /* fill values for viewer report list */
1623                                         for (j=0; j < addrList.nCount; j++) {
1624                                                 if (!strncmp(report_data_list[j].address, addr_value, MAX_ADDRESS_VAL_LEN)) {
1625                                                         if (type == MSG_REPORT_TYPE_DELIVERY) {
1626                                                                 report_data_list[j].delivery.status = status;
1627                                                                 report_data_list[j].delivery.time = time;
1628                                                         } else {
1629                                                                 report_data_list[j].read.status = status;
1630                                                                 report_data_list[j].read.time = time;
1631                                                         }
1632                                                 }
1633                                         }
1634                                 }
1635                                 msg_release_list_struct(&report_list);
1636                         }
1637
1638                         /** delivery report **/
1639                         eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_DELIVERY_REPORT"));
1640                         eina_strbuf_append(text_data, " : ");
1641                         //
1642                         if (!delivery_flag || report_data_list == NULL) {
1643                                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGC_BODY_NOT_REQUESTED"));
1644                         } else {
1645                                 int i;
1646                                 for (i = 0; i < addrList.nCount; i++) {
1647                                         eina_strbuf_append(text_data, report_data_list[i].address);
1648                                         eina_strbuf_append(text_data, " - ");
1649
1650                                         if (report_data_list[i].delivery.status == MSG_DELIVERY_REPORT_NONE) {
1651                                                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_REQUESTED"));
1652                                         } else if (report_data_list[i].delivery.status == MSG_DELIVERY_REPORT_EXPIRED) {
1653                                                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_EXPIRED"));
1654                                         } else if (report_data_list[i].delivery.status == MSG_DELIVERY_REPORT_SUCCESS) {
1655                                                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_RECEIVED"));
1656                                                 eina_strbuf_append(text_data, " (");
1657
1658                                                 char *str_time = NULL;
1659                                                 if (timeformat == MSG_TIME_FORMAT_24H)
1660                                                         str_time = msg_common_get_formatted_date(msg_common_get_default_locale(), "HH:mm, d MMM", &(report_data_list[i].delivery.time));
1661                                                 else
1662                                                         str_time = msg_common_get_formatted_date(msg_common_get_default_locale(), "hh:mm a, d MMM", &(report_data_list[i].delivery.time));
1663                                                 eina_strbuf_append(text_data, str_time);
1664                                                 eina_strbuf_append(text_data, ")");
1665                                         } else if (report_data_list[i].delivery.status == MSG_DELIVERY_REPORT_REJECTED) {
1666                                                 eina_strbuf_append(text_data, dgettext("sys_string", "IDS_COM_POP_REJECTED"));
1667                                         } else {
1668                                                 eina_strbuf_append(text_data, dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"));
1669                                         }
1670
1671                                         if (i != addrList.nCount-1)
1672                                                 eina_strbuf_append(text_data, "<br>");
1673                                 }
1674
1675                         }
1676                         eina_strbuf_append(text_data, "<br>");
1677
1678                         /** read report **/
1679                         eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_READ_REPORT"));
1680                         eina_strbuf_append(text_data, ": ");
1681                         //
1682                         if (!read_flag) {
1683                                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGC_BODY_NOT_REQUESTED"));
1684                         } else {
1685                                 int i = 0;
1686                                 for (i = 0; i < addrList.nCount; i++) {
1687                                         eina_strbuf_append(text_data, report_data_list[i].address);
1688                                         eina_strbuf_append(text_data, " - ");
1689                                         if (report_data_list[i].read.status == MSG_READ_REPORT_NONE) {
1690                                                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_REQUESTED"));
1691                                         } else if (report_data_list[i].read.status == MSG_READ_REPORT_IS_READ) {
1692                                                 eina_strbuf_append(text_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_MMSREADREPLYMSGREAD"));
1693                                                 eina_strbuf_append(text_data, " (");
1694
1695                                                 char *str_time = NULL;
1696                                                 if (timeformat == MSG_TIME_FORMAT_24H)
1697                                                         str_time = msg_common_get_formatted_date(msg_common_get_default_locale(), "HH:mm, d MMM", &(report_data_list[i].read.time));
1698                                                 else
1699                                                         str_time = msg_common_get_formatted_date(msg_common_get_default_locale(), "hh:mm a, d MMM", &(report_data_list[i].read.time));
1700                                                 eina_strbuf_append(text_data, str_time);
1701                                                 eina_strbuf_append(text_data, ")");
1702                                         } else if (report_data_list[i].read.status == MSG_READ_REPORT_IS_DELETED) {
1703                                                 eina_strbuf_append(text_data, dgettext("sys_string", "IDS_COM_POP_DELETED"));
1704                                         }
1705
1706                                         if (i != addrList.nCount-1)
1707                                                 eina_strbuf_append(text_data, "<br>");
1708                                 }
1709                         }
1710                         eina_strbuf_append(text_data, "<br>");
1711                 }
1712         }
1713
1714         char *str = strdup(eina_strbuf_string_get(text_data));
1715
1716         msg_release_list_struct(&addrList);
1717         eina_strbuf_free(text_data);
1718
1719         msg_release_struct(&msgInfo);
1720         msg_release_struct(&sendOpt);
1721
1722         return str;
1723 }
1724