composer/src/ui-composer/msg-ui-composer-common.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 #include <Elementary.h>
  19 #include <utilX.h>
  20 #include <Ecore_X.h>
  21 #include <mmf/mm_error.h>
  22 #include <metadata_extractor.h>
  23 #include <image_util.h>
  24
  25 #include "msg-ui-composer-common.h"
  26 #include "msg-ui-composer-subject.h"
  27 #include "msg-ui-composer-body.h"
  28 #include "msg-ui-composer-body-callback.h"
  29 #include "msg-ui-composer-attachment.h"
  30 #include "msg-ui-composer-recipient.h"
  31 #include "msg-ui-composer-popup.h"
  32 #include "msg-ui-composer-data.h"
  33 #include "msg-ui-composer-bubble.h"
  34 #include "msg-ui-composer-main.h"
  35
  36 /* MIME type table*/
  37
  38 const composer_mime_type_t composer_mime_table[] = {
  39 /*audio*/
  40         {"aac", "audio/aac", COMPOSER_MEDIA_TYPE_AUDIO},
  41         {"amr", "audio/amr", COMPOSER_MEDIA_TYPE_AUDIO},
  42         {"amr", "audio/x-amr", COMPOSER_MEDIA_TYPE_AUDIO},
  43         {"amr", "audio/amr-wb", COMPOSER_MEDIA_TYPE_AUDIO},
  44         {"imy", "audio/imelody", COMPOSER_MEDIA_TYPE_AUDIO},
  45         {"imy", "audio/imy", COMPOSER_MEDIA_TYPE_AUDIO},
  46         {"imy", "audio/iMelody", COMPOSER_MEDIA_TYPE_AUDIO},
  47         {"imy", "audio/melody", COMPOSER_MEDIA_TYPE_AUDIO},
  48         {"imy", "audio/x-iMelody", COMPOSER_MEDIA_TYPE_AUDIO},
  49         {"imy", "text/iMelody", COMPOSER_MEDIA_TYPE_AUDIO},
  50         {"imy", "text/x-iMelody", COMPOSER_MEDIA_TYPE_AUDIO},
  51         {"imy", "text/x-imelody", COMPOSER_MEDIA_TYPE_AUDIO},
  52         {"mid", "audio/mid", COMPOSER_MEDIA_TYPE_AUDIO},
  53         {"mid", "audio/midi", COMPOSER_MEDIA_TYPE_AUDIO},
  54         {"mid", "audio/x-mid", COMPOSER_MEDIA_TYPE_AUDIO},
  55         {"mid", "audio/x-midi", COMPOSER_MEDIA_TYPE_AUDIO},
  56         {"midi", "audio/mid", COMPOSER_MEDIA_TYPE_AUDIO},
  57         {"mmf", "application/vnd.smaf", COMPOSER_MEDIA_TYPE_AUDIO},
  58         {"mmf", "application/x-smaf", COMPOSER_MEDIA_TYPE_AUDIO},
  59         {"mmf", "audio/mmf", COMPOSER_MEDIA_TYPE_AUDIO},
  60         {"mmf", "audio/smaf", COMPOSER_MEDIA_TYPE_AUDIO},
  61         {"mmf", "audio/x-mmf", COMPOSER_MEDIA_TYPE_AUDIO},
  62         {"mmf", "audio/x-smaf", COMPOSER_MEDIA_TYPE_AUDIO},
  63         {"mp3", "audio/mpeg", COMPOSER_MEDIA_TYPE_AUDIO},
  64         {"mp3", "audio/mp3", COMPOSER_MEDIA_TYPE_AUDIO},
  65         {"mp3", "audio/mpg3", COMPOSER_MEDIA_TYPE_AUDIO},
  66         {"mp3", "audio/mpeg3", COMPOSER_MEDIA_TYPE_AUDIO},
  67         {"mp3", "audio/mpg", COMPOSER_MEDIA_TYPE_AUDIO},
  68         {"mp3", "audio/x-mp3", COMPOSER_MEDIA_TYPE_AUDIO},
  69         {"mp3", "audio/x-mpeg", COMPOSER_MEDIA_TYPE_AUDIO},
  70         {"mp3", "audio/x-mpeg3", COMPOSER_MEDIA_TYPE_AUDIO},
  71         {"mp3", "audio/x-mpegaudio", COMPOSER_MEDIA_TYPE_AUDIO},
  72         {"mp3", "audio/x-mpg", COMPOSER_MEDIA_TYPE_AUDIO},
  73         {"mpg", "audio/x-mpeg", COMPOSER_MEDIA_TYPE_AUDIO},
  74         {"m4a", "audio/m4a", COMPOSER_MEDIA_TYPE_AUDIO},
  75         {"ra", "audio/x-pn-realaudio", COMPOSER_MEDIA_TYPE_AUDIO},
  76         {"rm", "audio/vnd.rn-realaudio", COMPOSER_MEDIA_TYPE_AUDIO},
  77         {"rm", "audio/x-pn-multirate-realaudio", COMPOSER_MEDIA_TYPE_AUDIO},
  78         {"rm", "audio/x-pn-multirate-realaudio-live", COMPOSER_MEDIA_TYPE_AUDIO},
  79         {"spm", "audio/sp-midi", COMPOSER_MEDIA_TYPE_AUDIO},
  80         {"wav", "audio/wav", COMPOSER_MEDIA_TYPE_AUDIO},
  81         {"wav", "audio/wave", COMPOSER_MEDIA_TYPE_AUDIO},
  82         {"wav", "audio/x-wav", COMPOSER_MEDIA_TYPE_AUDIO},
  83         {"wav", "audio/x-wave", COMPOSER_MEDIA_TYPE_AUDIO},
  84         {"wma", "audio/wma", COMPOSER_MEDIA_TYPE_AUDIO},
  85         {"wma", "audio/x-ms-wma", COMPOSER_MEDIA_TYPE_AUDIO},
  86         {"xmf", "audio/mobile-xmf", COMPOSER_MEDIA_TYPE_AUDIO},
  87         {"xmf", "audio/xmf", COMPOSER_MEDIA_TYPE_AUDIO},
  88         {"xmf", "audio/x-xmf", COMPOSER_MEDIA_TYPE_AUDIO},
  89         {"3gp", "audio/3gpp", COMPOSER_MEDIA_TYPE_AUDIO},
  90         {"mp4", "audio/mp4", COMPOSER_MEDIA_TYPE_AUDIO},
  91         {"mp4", "audio/MP4A-LATM", COMPOSER_MEDIA_TYPE_AUDIO},
  92         {"mp4", "audio/mpeg4", COMPOSER_MEDIA_TYPE_AUDIO},
  93 /*image*/
  94         {"bmp", "image/bmp", COMPOSER_MEDIA_TYPE_IMAGE},
  95         {"bmp", "image/x-bmp", COMPOSER_MEDIA_TYPE_IMAGE},
  96         {"gif", "image/gif", COMPOSER_MEDIA_TYPE_IMAGE},
  97         {"GIF", "image/gif", COMPOSER_MEDIA_TYPE_IMAGE},
  98         {"gif", "image/vnd.tmo.my5-gif", COMPOSER_MEDIA_TYPE_IMAGE},
  99         {"jpg", "image/jpg", COMPOSER_MEDIA_TYPE_IMAGE},
 100         {"jpg", "image/jpeg", COMPOSER_MEDIA_TYPE_IMAGE},
 101         {"jpg", "image/vnd.tmo.my5-jpg", COMPOSER_MEDIA_TYPE_IMAGE},
 102         {"jpeg", "image/jpeg", COMPOSER_MEDIA_TYPE_IMAGE},
 103         {"JPG", "image/jpeg", COMPOSER_MEDIA_TYPE_IMAGE},
 104         {"jpg", "image/pjpeg", COMPOSER_MEDIA_TYPE_IMAGE},
 105         {"jpe", "image/jpeg", COMPOSER_MEDIA_TYPE_IMAGE},
 106         {"png", "image/png", COMPOSER_MEDIA_TYPE_IMAGE},
 107         {"wbmp", "image/vnd.wap.wbmp", COMPOSER_MEDIA_TYPE_IMAGE},
 108         {"wbmp", "image/wbmp", COMPOSER_MEDIA_TYPE_IMAGE},
 109         {"swf", "application/x-shockwave-flash", COMPOSER_MEDIA_TYPE_UNKNOWN},
 110         {"tif", "image/tiff", COMPOSER_MEDIA_TYPE_IMAGE},
 111         {"tif", "image/tif", COMPOSER_MEDIA_TYPE_IMAGE},
 112         {"pmd", "audio/pmd", COMPOSER_MEDIA_TYPE_IMAGE},
 113 /*video*/
 114         {"3gp", "video/3gpp", COMPOSER_MEDIA_TYPE_VIDEO},
 115         {"3gp", "video/3gp", COMPOSER_MEDIA_TYPE_VIDEO},
 116         {"3gp", "video/h263", COMPOSER_MEDIA_TYPE_VIDEO},
 117         {"3gp", "video/mp4v-es", COMPOSER_MEDIA_TYPE_VIDEO},
 118         {"asf", "audio/x-ms-asf", COMPOSER_MEDIA_TYPE_VIDEO},
 119         {"asf", "video/x-ms-asf", COMPOSER_MEDIA_TYPE_VIDEO},
 120         {"asx", "video/x-ms-asf", COMPOSER_MEDIA_TYPE_VIDEO},
 121         {"avi", "video/avi", COMPOSER_MEDIA_TYPE_VIDEO},
 122         {"mp2", "video/mpeg", COMPOSER_MEDIA_TYPE_VIDEO},
 123         {"mp4", "video/mp4", COMPOSER_MEDIA_TYPE_VIDEO},
 124         {"mp4", "video/mpeg4", COMPOSER_MEDIA_TYPE_VIDEO},
 125         {"mp4", "video/x-mp4", COMPOSER_MEDIA_TYPE_VIDEO},
 126         {"mp4", "video/x-pv-mp4", COMPOSER_MEDIA_TYPE_VIDEO},
 127         {"mpg", "video/mpeg", COMPOSER_MEDIA_TYPE_VIDEO},
 128         {"mpeg", "video/mpeg", COMPOSER_MEDIA_TYPE_VIDEO},
 129         {"rm", "video/x-pn-multirate-realvideo", COMPOSER_MEDIA_TYPE_VIDEO},
 130         {"rm", "video/vnd.rn-realmedia", COMPOSER_MEDIA_TYPE_VIDEO},
 131         {"rm", "video/vnd.rn-realvideo", COMPOSER_MEDIA_TYPE_VIDEO},
 132         {"rv", "video/x-pn-realvideo", COMPOSER_MEDIA_TYPE_VIDEO},
 133         {"sdp", "application/sdp", COMPOSER_MEDIA_TYPE_VIDEO},
 134         {"sdp", "video/sdp", COMPOSER_MEDIA_TYPE_VIDEO},
 135         {"wmv", "video/x-ms-wmv", COMPOSER_MEDIA_TYPE_VIDEO},
 136 /*text*/
 137         {"txt", "text/plain", COMPOSER_MEDIA_TYPE_TEXT},
 138         {"text", "text/plain", COMPOSER_MEDIA_TYPE_TEXT},
 139         {"html", "text/html", COMPOSER_MEDIA_TYPE_TEXT},
 140         {"htm", "text/html", COMPOSER_MEDIA_TYPE_TEXT},
 141         {"wml", "text/vnd.wap.wml", COMPOSER_MEDIA_TYPE_TEXT},
 142         {"xml", "text/xml", COMPOSER_MEDIA_TYPE_TEXT},
 143 /*vObject*/
 144         {"vbm", "text/x-vbookmark", COMPOSER_MEDIA_TYPE_UNKNOWN},
 145         {"vcf", "text/x-vcard", COMPOSER_MEDIA_TYPE_UNKNOWN},
 146         {"vcs", "text/x-vCalendar", COMPOSER_MEDIA_TYPE_UNKNOWN},
 147         {"vnt", "text/x-vnote", COMPOSER_MEDIA_TYPE_UNKNOWN},
 148 /*drm*/
 149         {"dcf", "application/vnd.oma.drm.content", COMPOSER_MEDIA_TYPE_DRM},
 150         {"dm", "application/vnd.oma.drm.message", COMPOSER_MEDIA_TYPE_DRM},
 151         {"odf", "application/vnd.oma.drm.dcf", COMPOSER_MEDIA_TYPE_DRM},
 152         {"oro", "application/vnd.oma.drm.ro+xml", COMPOSER_MEDIA_TYPE_DRM},
 153         {"ro", "application/vnd.oma.drm.rights+xml", COMPOSER_MEDIA_TYPE_DRM},
 154         {"ro", "application/vnd.oma.drm.rights+wbxml", COMPOSER_MEDIA_TYPE_DRM},
 155 /*doc*/
 156         {"doc", "application/msword", COMPOSER_MEDIA_TYPE_UNKNOWN},
 157         {"doc", "applcation/vnd.ms-word", COMPOSER_MEDIA_TYPE_UNKNOWN},
 158         {"xls", "application/vnd.ms-excel", COMPOSER_MEDIA_TYPE_UNKNOWN},
 159         {"xls", "application/x-msexcel", COMPOSER_MEDIA_TYPE_UNKNOWN},
 160         {"ppt", "application/vnd.ms-powerpoint", COMPOSER_MEDIA_TYPE_UNKNOWN},
 161         {"ppt", "application/x-mspowerpoint", COMPOSER_MEDIA_TYPE_UNKNOWN},
 162         {"pdf", "application/pdf", COMPOSER_MEDIA_TYPE_UNKNOWN},
 163 /*etc*/
 164         {"rm ", "application/vnd.rn-realmedia", COMPOSER_MEDIA_TYPE_UNKNOWN},
 165         {"smi", "application/smil", COMPOSER_MEDIA_TYPE_UNKNOWN},
 166         {"smil", "application/smil", COMPOSER_MEDIA_TYPE_UNKNOWN},
 167         {"xml", "application/vnd.oma.drm.roap-pdu+xml", COMPOSER_MEDIA_TYPE_UNKNOWN},
 168         {"xml", "application/vnd.oma.drm.roap-trigger+xml", COMPOSER_MEDIA_TYPE_UNKNOWN},
 169         {"xxx", "application/octet-stream", COMPOSER_MEDIA_TYPE_UNKNOWN},
 170 };
 171
 172 char *msg_ui_composer_edj_get(MSG_COMPOSER_VIEW_DATA_S *cd)
 173 {
 174         return MSGC_UI_DEFAULT_EDJ;
 175 }
 176
 177 Evas_Object *msg_ui_composer_load_edj(Evas_Object *parent, const char *edj_file, const char *group)
 178 {
 179         Evas_Object *layout;
 180         layout = elm_layout_add(parent);
 181
 182         elm_layout_file_set(layout, edj_file, group);
 183         return layout;
 184 }
 185
 186 Evas_Object *msg_ui_composer_layout_create(Evas_Object *parent, bool indicator)
 187 {
 188         D_ENTER;
 189         D_MSG_RETVM_IF(parent == NULL, NULL, "parent object  == NULL");
 190
 191         Evas_Object *layout;
 192
 193         layout = elm_layout_add(parent);
 194         if (layout == NULL) {
 195                 D_EMSG("[ASSERT] elm_layout_add failed!!");
 196                 return NULL;
 197         }
 198
 199         if (indicator == true)
 200                 elm_layout_theme_set(layout, "layout", "application", "default");
 201         else
 202                 elm_layout_theme_set(layout, "layout", "application", "noindicator");
 203
 204         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 205         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 206         evas_object_show(layout);
 207         D_LEAVE;
 208         return layout;
 209 }
 210
 211 Evas_Object *msg_ui_composer_bg_create(Evas_Object *parent)
 212 {
 213         D_MSG_RETVM_IF(parent == NULL, NULL, "parent object  == NULL");
 214     Evas_Object *bg = elm_bg_add(parent);
 215     evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 216     evas_object_show(bg);
 217     return bg;
 218 }
 219
 220 int64 msg_composer_get_file_size(const char *path)
 221 {
 222         return ecore_file_size(path);
 223 }
 224
 225 char *msg_composer_get_file_ext(const char *a_pszfile_name)
 226 {
 227         if (a_pszfile_name != NULL) {
 228                 int nlen = strlen(a_pszfile_name);
 229                 char *psztemp = (char *)a_pszfile_name + nlen;
 230
 231                 while (nlen--) {
 232                         psztemp--;
 233                         if (*psztemp == '.') {
 234                                 psztemp++;
 235                                 break;
 236                         }
 237                 }
 238                 return psztemp;
 239         }
 240
 241         return NULL;
 242 }
 243
 244 COMPOSER_MEDIA_TRACK_TYPE_E msg_composer_get_media_track_type(const char *a_pszfile_name)
 245 {
 246         D_ENTER;
 247         D_MSG_RETVM_IF(a_pszfile_name == NULL, COMPOSER_MEDIA_TRACK_TYPE_NONE, "file path is null");
 248
 249         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 250         metadata_extractor_h metadata = NULL;
 251
 252         ret = metadata_extractor_create(&metadata);
 253         if(ret != METADATA_EXTRACTOR_ERROR_NONE) {
 254                 D_EMSG("Fail metadata_extractor_create [%d]", ret);
 255                 return COMPOSER_MEDIA_TRACK_TYPE_NONE;
 256         }
 257
 258         ret = metadata_extractor_set_path(metadata, a_pszfile_name);
 259         if(ret != METADATA_EXTRACTOR_ERROR_NONE) {
 260                 D_EMSG("Fail metadata_extractor_set_path [%d]", ret);
 261                 metadata_extractor_destroy(metadata);
 262                 return COMPOSER_MEDIA_TRACK_TYPE_NONE;
 263         }
 264
 265         /* check video first */
 266         char *video_track_cnt = NULL;
 267         metadata_extractor_get_metadata(metadata, METADATA_HAS_VIDEO, &video_track_cnt);
 268         if (video_track_cnt) {
 269                 D_MSG("video_track_cnt = [%s]", video_track_cnt);
 270                 if (atoi(video_track_cnt) > 0) {
 271                         metadata_extractor_destroy(metadata);
 272                         return COMPOSER_MEDIA_TRACK_TYPE_VIDEO;
 273                 }
 274         }
 275
 276         /* if curren meta_info has no video track, check audio again */
 277         char *audio_track_cnt = NULL;
 278         metadata_extractor_get_metadata(metadata, METADATA_HAS_AUDIO, &audio_track_cnt);
 279         if (audio_track_cnt) {
 280                 D_MSG("audio_track_cnt = [%s]", audio_track_cnt);
 281                 if (atoi(audio_track_cnt) > 0) {
 282                         metadata_extractor_destroy(metadata);
 283                         return COMPOSER_MEDIA_TRACK_TYPE_AUDIO;
 284                 }
 285         }
 286
 287         metadata_extractor_destroy(metadata);
 288
 289         return COMPOSER_MEDIA_TRACK_TYPE_NONE;
 290 }
 291
 292 COMPOSER_MEDIA_TYPE_E msg_composer_get_media_type(const char *a_pszfile_path)
 293 {
 294         char *pext = NULL;
 295         unsigned int nmimeidx = 0;
 296         unsigned int nmime_max = 0;
 297         COMPOSER_MEDIA_TRACK_TYPE_E track_type = COMPOSER_MEDIA_TRACK_TYPE_NONE;
 298
 299         if (a_pszfile_path == NULL)
 300                 return COMPOSER_MEDIA_TYPE_UNKNOWN;
 301
 302         pext = msg_composer_get_file_ext(a_pszfile_path);
 303         nmime_max = (sizeof(composer_mime_table) / sizeof(composer_mime_type_t));
 304         track_type = msg_composer_get_media_track_type(a_pszfile_path);
 305
 306         for (; nmimeidx < nmime_max; nmimeidx++) {
 307                 int nlen = strlen(composer_mime_table[nmimeidx].m_szextend);
 308
 309                 if (strncasecmp(composer_mime_table[nmimeidx].m_szextend, pext, nlen) == 0) {
 310                         if (track_type == COMPOSER_MEDIA_TRACK_TYPE_VIDEO) {
 311                                 if (strstr(composer_mime_table[nmimeidx].m_szmime_type, "video") != NULL)
 312                                         return composer_mime_table[nmimeidx].m_ncontent_type;
 313                         } else if (track_type == COMPOSER_MEDIA_TRACK_TYPE_AUDIO) {
 314                                 if (strstr(composer_mime_table[nmimeidx].m_szmime_type, "audio") != NULL)
 315                                         return composer_mime_table[nmimeidx].m_ncontent_type;
 316                         } else {
 317                                 return composer_mime_table[nmimeidx].m_ncontent_type;
 318                         }
 319                 }
 320         }
 321
 322         return COMPOSER_MEDIA_TYPE_UNKNOWN;
 323 }
 324
 325 COMPOSER_RETURN_TYPE_E msg_composer_common_get_media_duration(const char *file_path, int *duration)
 326 {
 327         D_ENTER;
 328
 329         metadata_extractor_h metadata_h = NULL;
 330         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 331         char *value = NULL;
 332
 333         if (!file_path || !duration) {
 334                 D_EMSG("file_path or duration is not exist");
 335                 return COMPOSER_RETURN_FAIL;
 336         }
 337
 338         ret = metadata_extractor_create(&metadata_h);
 339         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 340                 D_EMSG("metadata_extractor_create is failed ret = %d", ret);
 341                 return COMPOSER_RETURN_FAIL;
 342         }
 343
 344         ret = metadata_extractor_set_path(metadata_h, file_path);
 345         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 346                 D_EMSG("metadata_extractor_set_path is failed ret = %d", ret);
 347                 metadata_extractor_destroy(metadata_h);
 348                 return COMPOSER_RETURN_FAIL;
 349         }
 350
 351         ret = metadata_extractor_get_metadata(metadata_h, METADATA_DURATION, &value);
 352         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 353                 D_EMSG("metadata_extractor_get_metadata is failed ret = %d", ret);
 354                 metadata_extractor_destroy(metadata_h);
 355                 return COMPOSER_RETURN_FAIL;
 356         }
 357
 358         if (value) {
 359                 *duration = atoi(value);
 360                 free(value);
 361         }
 362
 363         D_MSG("file : %s, duration : %d", file_path, *duration);
 364
 365         metadata_extractor_destroy(metadata_h);
 366
 367         D_LEAVE;
 368
 369         return COMPOSER_RETURN_SUCCESS;
 370 }
 371
 372 COMPOSER_RETURN_TYPE_E msg_composer_common_get_thumbnail(MSG_COMPOSER_VIEW_DATA_S *cd, const char *src_file_path, char *thumb_file_path, int size_thumb_file_path)
 373 {
 374         D_ENTER;
 375         COMPOSER_MEDIA_TYPE_E media_type;
 376         int ret;
 377         char temp_img_file[COMPOSER_FILEPATH_LEN_MAX] = {0,};
 378         char *filename_without_ext = NULL;
 379         const char *filename = NULL;
 380
 381         if (!src_file_path || !thumb_file_path) {
 382                 D_EMSG("file path or thumbnail path is NULL");
 383                 return COMPOSER_RETURN_NULL_POINTER;
 384         }
 385
 386         if (!ecore_file_exists(src_file_path)) {
 387                 D_EMSG("file path is not exist");
 388                 return COMPOSER_RETURN_NULL_POINTER;
 389         }
 390
 391         media_type = msg_composer_get_media_type(src_file_path);
 392         if (media_type == COMPOSER_MEDIA_TYPE_VIDEO) {
 393
 394                 filename = ecore_file_file_get(src_file_path);
 395                 if (filename) {
 396                         filename_without_ext = ecore_file_strip_ext(filename);
 397
 398                         if (filename_without_ext) {
 399                                 snprintf(temp_img_file, sizeof(temp_img_file)-1, "%s/temp_image_%s.jpg", cd->working_path, filename_without_ext);
 400                                 g_free(filename_without_ext);
 401                         } else {
 402                                 return COMPOSER_RETURN_FAIL;
 403                         }
 404
 405                 } else {
 406                         return COMPOSER_RETURN_FAIL;
 407                 }
 408
 409                 /* get image of video*/
 410                 ret = msg_composer_common_get_image_in_video(src_file_path, temp_img_file);
 411                 if (ret == COMPOSER_RETURN_SUCCESS) {
 412                         strncpy(thumb_file_path, temp_img_file, size_thumb_file_path);
 413                 }
 414         } else {
 415                 D_EMSG("media type is not video type media_type = %d !!", media_type);
 416                 return COMPOSER_RETURN_FAIL;
 417         }
 418
 419         D_LEAVE;
 420         return COMPOSER_RETURN_SUCCESS;
 421 }
 422
 423 void msg_ui_composer_clear(MSG_COMPOSER_VIEW_DATA_S *cd)
 424 {
 425         D_ENTER;
 426         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
 427
 428         /*Clear recipient */
 429         if (cd->recipient)
 430                 msg_ui_composer_recipient_clear(cd->recipient);
 431
 432         /*Clear Body*/
 433         if (cd->isSubject) {
 434                 msg_ui_composer_subject_clear(cd);
 435                 cd->isSubject = false;
 436         }
 437
 438         if (cd->attach_data.attachment_Cnt > 0) {
 439                 msg_ui_composer_attachment_clear(cd);
 440         }
 441
 442         msg_ui_composer_body_clear(cd);
 443
 444         D_LEAVE;
 445 }
 446
 447 static void __msg_ui_composer_change_to_sms(MSG_COMPOSER_VIEW_DATA_S *cd)
 448 {
 449         D_ENTER;
 450
 451         if (!cd) {
 452                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] composer data is NULL");
 453                 return;
 454         }
 455
 456         MSG_COMPOSER_BODY_PAGE_S *page_data = NULL;
 457         MSG_COMPOSER_BODY_S *body_data = &cd->body_data;
 458
 459         /* reset region info */
 460         body_data->region_order = COMPOSER_REGION_ORDER_UNDETERMINDED;
 461
 462         page_data = (MSG_COMPOSER_BODY_PAGE_S *)eina_list_nth(cd->body_data.page_list, 0);
 463
 464         char *body_text = elm_entry_markup_to_utf8(elm_entry_entry_get(page_data->entry));
 465         if (body_text) {
 466                 msg_ui_composer_body_info_area_update(cd);
 467                 free(body_text);
 468         }
 469
 470         D_LEAVE;
 471 }
 472
 473 static void __msg_ui_composer_change_to_mms(MSG_COMPOSER_VIEW_DATA_S *cd)
 474 {
 475         D_ENTER;
 476         if (!cd) {
 477                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] composer data is NULL");
 478                 return;
 479         }
 480
 481         msg_ui_composer_body_info_area_update(cd);
 482         D_LEAVE;
 483 }
 484
 485 COMPOSER_RETURN_TYPE_E msg_ui_composer_change_message_type(MSG_COMPOSER_VIEW_DATA_S *cd, COMPOSER_MSG_TYPE_E msg_type)
 486 {
 487         D_ENTER;
 488         if (!cd) {
 489                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] composer data is NULL");
 490                 return COMPOSER_RETURN_FAIL;
 491         }
 492
 493         if (cd->msg_type == msg_type) {
 494                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] it doesn't need to change message type");
 495                 return COMPOSER_RETURN_SUCCESS;
 496         }
 497
 498         switch (msg_type) {
 499         case COMPOSER_MSG_TYPE_SMS:
 500                 msg_ui_composer_common_tickernoti(cd, COMPOSER_TICKERNOTI_CHANGED_SMS);
 501
 502                 cd->msg_type = COMPOSER_MSG_TYPE_SMS;
 503                 __msg_ui_composer_change_to_sms(cd);
 504                 break;
 505         case COMPOSER_MSG_TYPE_MMS:
 506                 if (cd->loading_draft == false)
 507                         msg_ui_composer_common_tickernoti(cd, COMPOSER_TICKERNOTI_CHANGED_MMS);
 508                 else
 509                         cd->loading_draft = false;
 510
 511                 cd->msg_type = COMPOSER_MSG_TYPE_MMS;
 512                 __msg_ui_composer_change_to_mms(cd);
 513                 break;
 514         default:
 515                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] invalid message type");
 516                 return COMPOSER_RETURN_FAIL;
 517         }
 518
 519         bool ret = msg_ui_composer_common_is_send_possible(cd);
 520         msg_ui_composer_body_update_send_btn_icon(cd, !ret);
 521
 522         if (cd->msg_type == COMPOSER_MSG_TYPE_SMS && cd->msg_ug_mode != MSG_UG_MODE_BUBBLE_COMPOSER)
 523                 elm_object_disabled_set(cd->more_btn, EINA_TRUE);
 524         else if (cd->msg_type == COMPOSER_MSG_TYPE_MMS)
 525                 elm_object_disabled_set(cd->more_btn, EINA_FALSE);
 526
 527         D_LEAVE;
 528         return COMPOSER_RETURN_SUCCESS;
 529 }
 530
 531 COMPOSER_MSG_TYPE_E msg_ui_composer_check_message_type(MSG_COMPOSER_VIEW_DATA_S *cd)
 532 {
 533         D_ENTER;
 534
 535         if (!cd) {
 536                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSSERT] composer data in NULL");
 537                 return COMPOSER_MSG_TYPE_INVALID;
 538         }
 539
 540         if (cd->isSubject)
 541                 return COMPOSER_MSG_TYPE_MMS;
 542
 543         if (cd->attach_data.attachment_Cnt > 0)
 544                 return COMPOSER_MSG_TYPE_MMS;
 545
 546         if (msg_ui_composer_body_is_mms(cd) == EINA_TRUE)
 547                 return COMPOSER_MSG_TYPE_MMS;
 548
 549         if (msg_ui_composer_recipient_is_mms(cd) == EINA_TRUE)
 550                 return COMPOSER_MSG_TYPE_MMS;
 551
 552         return COMPOSER_MSG_TYPE_SMS;
 553 }
 554
 555 void msg_ui_composer_message_type_check_and_change(MSG_COMPOSER_VIEW_DATA_S *cd)
 556 {
 557         D_ENTER;
 558
 559         COMPOSER_MSG_TYPE_E checked_type;
 560
 561         checked_type = msg_ui_composer_check_message_type(cd);
 562
 563         if (cd->msg_type == COMPOSER_MSG_TYPE_SMS && checked_type == COMPOSER_MSG_TYPE_MMS) {
 564                 D_MSG("### Message Type Change from [SMS] to [MMS] ###");
 565                 msg_ui_composer_change_message_type(cd, COMPOSER_MSG_TYPE_MMS);
 566         } else if (cd->msg_type == COMPOSER_MSG_TYPE_MMS && checked_type == COMPOSER_MSG_TYPE_SMS) {
 567                 D_MSG("### Message Type Change from [MMS] to [SMS] ###");
 568                 msg_ui_composer_change_message_type(cd, COMPOSER_MSG_TYPE_SMS);
 569         } else {
 570                 D_MSG("Now msg type is [%d] & checked msg type is [%d](0: INVAILD, 1: SMS, 2: MMS)", cd->msg_type, checked_type);
 571         }
 572
 573         D_LEAVE;
 574 }
 575
 576 Eina_Bool msg_ui_composer_last_focus_load(void *data)
 577 {
 578         D_ENTER;
 579         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
 580         if(!cd) return EINA_FALSE;
 581
 582         if (cd->last_focus_entry == NULL) {
 583                 D_MSG("NO ENTRY FOCUS");
 584                 return EINA_FALSE;
 585         }
 586
 587         elm_object_focus_set(cd->last_focus_entry, EINA_TRUE);
 588         D_MSG("### Focused Entry Load = %p",cd->last_focus_entry);
 589         D_LEAVE;
 590         return EINA_FALSE;
 591 }
 592
 593 Eina_Bool msg_ui_composer_last_body_page_focus_load(void *data)
 594 {
 595         D_ENTER;
 596
 597         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
 598
 599         MSG_COMPOSER_BODY_PAGE_S *last_page_data = eina_list_nth(cd->body_data.page_list, cd->body_data.page_count-1);
 600
 601         if (last_page_data && last_page_data->entry) {
 602                 elm_object_focus_set(last_page_data->entry, EINA_TRUE);
 603                 D_MSG("### Last body page entry focused = %p",last_page_data->entry);
 604                 msg_ui_composer_last_focused_entry_set(cd, last_page_data->entry);
 605         } else {
 606                 D_MSG("Failed to get last body page entry");
 607                 return EINA_FALSE;
 608         }
 609
 610         D_LEAVE;
 611         return EINA_TRUE;
 612 }
 613
 614 void msg_ui_composer_last_focused_entry_set(void *data, Evas_Object *entry)
 615 {
 616         MSG_COMPOSER_VIEW_DATA_S *cd;
 617         cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
 618         cd->last_focus_entry = entry;
 619 }
 620
 621 Evas_Object *msg_ui_composer_last_focused_entry_get(void *data)
 622 {
 623         MSG_COMPOSER_VIEW_DATA_S *cd;
 624         cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
 625         if (!cd) return NULL;
 626
 627         return cd->last_focus_entry;
 628 }
 629
 630 Evas_Object *msg_ui_composer_last_body_entry_get(void *data)
 631 {
 632         D_ENTER;
 633
 634         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
 635
 636         MSG_COMPOSER_BODY_PAGE_S *page_data = eina_list_nth(cd->body_data.page_list, cd->current_edit_entry);
 637         D_MSG("cd->current_edit_entry = %d", cd->current_edit_entry);
 638
 639         if (page_data && page_data->entry) {
 640                 return page_data->entry;
 641         } else {
 642                 D_MSG("No Entry Saved");
 643                 return NULL;
 644         }
 645
 646         D_LEAVE;
 647         return NULL;
 648 }
 649
 650 void msg_ui_composer_set_body_keypad_layout(void *data, int mode)
 651 {
 652         D_ENTER;
 653         D_MSG_RETM_IF(data == NULL, "data is NULL");
 654         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
 655         MSG_COMPOSER_BODY_PAGE_S *page_data = NULL;
 656
 657         page_data = (MSG_COMPOSER_BODY_PAGE_S *)eina_list_nth(cd->body_data.page_list, 0);
 658
 659         if (page_data && page_data->entry)
 660                 elm_entry_input_panel_layout_set(page_data->entry, mode);
 661         else
 662                 D_EMSG("entry is not found");
 663
 664         D_LEAVE;
 665 }
 666
 667 bool msg_ui_composer_last_focus_is_recipient(void *data)
 668 {
 669         D_ENTER;
 670         D_MSG_RETVM_IF(data == NULL, false, "data is NULL");
 671
 672         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
 673         RECIPIENT_S *recipient = cd->recipient;
 674         Evas_Object *last_focus = msg_ui_composer_last_focused_entry_get(cd);
 675
 676         if (last_focus && recipient) {
 677                 if (last_focus == recipient->mbe) {
 678                         return true;
 679                 }
 680         }
 681
 682         D_LEAVE;
 683         return false;
 684 }
 685
 686 void bundle_send_to_result(void *data, char *key, char *val)
 687 {
 688         D_ENTER;
 689         D_MSG("key = %s, val = %s", key, val);
 690
 691         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
 692         service_h svc_handle;
 693         if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
 694                 D_EMSG("service_create() is failed !!");
 695         } else {
 696                 service_add_extra_data(svc_handle, key, val);
 697                 ug_send_result(cd->ug, svc_handle);
 698                 service_destroy(svc_handle);
 699         }
 700         D_LEAVE;
 701 }
 702
 703 bool msg_ui_composer_common_is_send_possible(MSG_COMPOSER_VIEW_DATA_S *cd)
 704 {
 705         D_ENTER;
 706
 707         if (!cd) {
 708                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] composer data is NULL");
 709                 return false;
 710         }
 711
 712         MSG_COMPOSER_BODY_S *body_data = &cd->body_data;
 713         MSG_COMPOSER_BODY_PAGE_S *page_data = NULL;
 714
 715         if (cd->msg_type == COMPOSER_MSG_TYPE_MMS) {
 716                 if (cd->isSubject) {
 717                         char *subject = elm_entry_markup_to_utf8(elm_entry_entry_get(cd->sub_data.entry));
 718                         if (subject && strlen(subject) > 0) {
 719                                 g_free(subject);
 720                                 return true;
 721                         } else {
 722                                 g_free(subject);
 723                         }
 724                 }
 725
 726                 if (cd->attach_data.attachment_Cnt > 0) {
 727                         return true;
 728                 }
 729
 730                 int i = 0;
 731                 for (i = 0; i < cd->body_data.page_count; i++) {
 732                         page_data = (MSG_COMPOSER_BODY_PAGE_S *)eina_list_nth(body_data->page_list, i);
 733
 734                         if (page_data->is_image_item)
 735                                 return true;
 736
 737                         if (page_data->is_sound_item)
 738                                 return true;
 739
 740                         char *body_text = elm_entry_markup_to_utf8(elm_entry_entry_get(page_data->entry));
 741                         if (body_text) {
 742                                 if (strlen(body_text) > 0) {
 743                                         g_free(body_text);
 744                                         return true;
 745                                 }
 746                                 g_free(body_text);
 747                         }
 748                 }
 749         } else if (cd->msg_type == COMPOSER_MSG_TYPE_SMS) {
 750                 page_data = (MSG_COMPOSER_BODY_PAGE_S *)eina_list_nth(body_data->page_list, 0);
 751                 if(page_data) {
 752                         char *body_text = elm_entry_markup_to_utf8(elm_entry_entry_get(page_data->entry));
 753                         if (body_text) {
 754                                 if (strlen(body_text) > 0) {
 755                                         g_free(body_text);
 756                                         return true;
 757                                 }
 758                                 g_free(body_text);
 759                         }
 760                 }
 761         } else {
 762                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] invalid message type");
 763                 return false;
 764         }
 765
 766         D_LEAVE;
 767         return false;
 768 }
 769
 770 COMPOSER_RETURN_TYPE_E msg_composer_common_get_image_in_video(const char *video_file_path, char *image_file_path)
 771 {
 772         D_ENTER;
 773
 774         COMPOSER_MEDIA_TYPE_E media_type;
 775         metadata_extractor_h metadata_h = NULL;
 776         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 777         int video_w = 0;
 778         int video_h = 0;
 779         int thumbsize = 0;
 780         void *thumbnail = NULL;
 781         char *value = NULL;
 782
 783         media_type = msg_composer_get_media_type(video_file_path);
 784         if (media_type != COMPOSER_MEDIA_TYPE_VIDEO) {
 785                 D_EMSG("It is not video file %s", video_file_path);
 786                 return COMPOSER_RETURN_FAIL;
 787         }
 788
 789         ret = metadata_extractor_create(&metadata_h);
 790         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 791                 D_EMSG("metadata_extractor_create is failed ret = %d", ret);
 792                 return COMPOSER_RETURN_FAIL;
 793         }
 794
 795         ret = metadata_extractor_set_path(metadata_h, video_file_path);
 796         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 797                 D_EMSG("metadata_extractor_set_path is failed ret = %d", ret);
 798                 metadata_extractor_destroy(metadata_h);
 799                 return COMPOSER_RETURN_FAIL;
 800         }
 801
 802         ret = metadata_extractor_get_metadata(metadata_h, METADATA_VIDEO_WIDTH, &value);
 803         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 804                 D_EMSG("metadata_extractor_get_metadata is failed ret = %d", ret);
 805                 metadata_extractor_destroy(metadata_h);
 806                 return COMPOSER_RETURN_FAIL;
 807         }
 808
 809         if (value) {
 810                 video_w = atoi(value);
 811                 free(value);
 812                 value = NULL;
 813         }
 814
 815         ret = metadata_extractor_get_metadata(metadata_h, METADATA_VIDEO_HEIGHT, &value);
 816         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 817                 D_EMSG("metadata_extractor_get_metadata is failed ret = %d", ret);
 818                 metadata_extractor_destroy(metadata_h);
 819                 return COMPOSER_RETURN_FAIL;
 820         }
 821
 822         if (value) {
 823                 video_h = atoi(value);
 824                 free(value);
 825                 value = NULL;
 826         }
 827
 828         ret = metadata_extractor_get_frame(metadata_h, &thumbnail, &thumbsize);
 829         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 830                 D_EMSG("metadata_extractor_get_frame is failed ret = %d", ret);
 831                 metadata_extractor_destroy(metadata_h);
 832                 return COMPOSER_RETURN_FAIL;
 833         }
 834
 835         if (thumbnail) {
 836                 ret = image_util_encode_jpeg((unsigned char *)thumbnail, video_w, video_h, IMAGE_UTIL_COLORSPACE_RGB888, 100, image_file_path);
 837
 838                 free(thumbnail);
 839
 840                 if (ret != IMAGE_UTIL_ERROR_NONE) {
 841                         D_EMSG("image_util_encode_jpeg is failed ret = %d", ret);
 842                         metadata_extractor_destroy(metadata_h);
 843                         return COMPOSER_RETURN_FAIL;
 844                 }
 845         }
 846
 847         metadata_extractor_destroy(metadata_h);
 848
 849         D_LEAVE;
 850         return COMPOSER_RETURN_SUCCESS;
 851 }
 852
 853 COMPOSER_RETURN_TYPE_E msg_ui_composer_common_get_file(MSG_COMPOSER_VIEW_DATA_S *cd, const char *src_file_path, char *dst_file_path, int size_dst_file_path)
 854 {
 855         D_ENTER;
 856         D_MSG_RETVM_IF(cd == NULL, COMPOSER_RETURN_FAIL, "cd is NULL");
 857         D_MSG_RETVM_IF(src_file_path == NULL, COMPOSER_RETURN_FAIL, "src_file_path is NULL");
 858         D_MSG_RETVM_IF(dst_file_path == NULL, COMPOSER_RETURN_FAIL, "dst_file_path is NULL");
 859
 860         const char *filename = NULL;
 861         char *ext = NULL;
 862         int i = 0;
 863         char temp_file_path[COMPOSER_FILEPATH_LEN_MAX + 1] = {0,};
 864         char file_name_without_ext[COMPOSER_FILENAME_LEN_MAX + 1] = {0};
 865
 866         if (ecore_file_exists(src_file_path) == EINA_FALSE) {
 867                 D_EMSG("file is not existed");
 868                 return COMPOSER_RETURN_FAIL;
 869         }
 870
 871         filename = ecore_file_file_get(src_file_path);
 872
 873         if (filename) {
 874                 strncpy(file_name_without_ext, filename, COMPOSER_FILENAME_LEN_MAX);
 875                 ext = msg_composer_get_file_ext(filename);
 876
 877                 if (ext)
 878                         file_name_without_ext[strlen(file_name_without_ext) - strlen(ext) - 1] = '\0';
 879
 880                 /*make new filename*/
 881                 do {
 882                         memset(temp_file_path, 0x00, sizeof(temp_file_path));
 883                         if (i == 0) {
 884                                 snprintf(temp_file_path, sizeof(temp_file_path), "%s%s", cd->working_path, filename);
 885                         } else {
 886                                 if (ext && strlen(ext) > 0)
 887                                         snprintf(temp_file_path, sizeof(temp_file_path), "%s%s_%02d.%s", cd->working_path, file_name_without_ext, i, ext);
 888                                 else
 889                                         snprintf(temp_file_path, sizeof(temp_file_path), "%s%s_%02d", cd->working_path, file_name_without_ext, i);
 890                         }
 891
 892                         i++;
 893
 894                         if (i > COMPOSER_MMS_MAX_MEDIA_COUNT) {
 895                                 D_EMSG("maximum count is reached = %d", i);
 896                                 return COMPOSER_RETURN_FAIL;
 897                         }
 898                 } while (ecore_file_exists(temp_file_path));
 899
 900
 901                 if (ecore_file_cp(src_file_path, temp_file_path) == EINA_FALSE) {
 902                         D_MSG("temp_file_path = %s", temp_file_path);
 903                         return COMPOSER_RETURN_FAIL;
 904                 }
 905
 906                 strncpy(dst_file_path, temp_file_path, size_dst_file_path);
 907                 D_MSG("copy file from %s to %s", src_file_path, dst_file_path);
 908         } else {
 909                 D_EMSG("filename is NULL");
 910                 return COMPOSER_RETURN_FAIL;
 911         }
 912
 913         D_LEAVE;
 914         return COMPOSER_RETURN_SUCCESS;
 915 }
 916
 917 static char *__get_item_tag(char *text)
 918 {
 919         char *fulltext = NULL;
 920         char *tagStart = NULL;
 921         char *tagEnd = NULL;
 922         int tagStrLength = 0;
 923
 924         if (text == NULL)
 925                 return NULL;
 926
 927         fulltext = text;
 928         D_MSG("text(%p)[%d] = %s", text, strlen(text), text);
 929
 930         tagStart = strstr(fulltext, "<item");
 931         if (tagStart) {
 932                 tagEnd = strchr(tagStart, '>');
 933                 if (tagEnd) {
 934                         tagStrLength = tagEnd - tagStart + 1;
 935                         return strndup(tagStart, tagStrLength);
 936                 }
 937         }
 938
 939         return NULL;
 940 }
 941
 942 static char *__remove_item_tag(char *text)
 943 {
 944         char *fulltext = NULL;
 945         char *tagStart = NULL;
 946         char *tagEnd = NULL;
 947         char *braceStart = NULL;
 948         char *braceEnd = NULL;
 949         char *postStr = NULL;
 950
 951         int strLength = 0;
 952         int postStrLength = 0;
 953         bool isitemTag = false;
 954
 955         if (text == NULL)
 956                 return NULL;
 957
 958         char *textBuf = strdup(text);
 959
 960         if (!textBuf) {
 961                 D_EMSG("strdup is failed");
 962                 return NULL;
 963         }
 964
 965         fulltext = textBuf;
 966         strLength = strlen(textBuf);
 967         D_MSG("text length = %d, text = [%s]", strLength, textBuf);
 968
 969         while ((tagStart = strstr(fulltext, "<item"))) {
 970                 braceEnd = strchr(tagStart, '>');
 971                 if (braceEnd) {
 972                         braceStart = strstr(braceEnd, "</item>");
 973                         if (braceStart) {
 974                                 tagEnd = (braceStart + strlen("</item>") - 1);
 975                         } else {
 976                                 D_EMSG("There is no close item tag");
 977                                 tagEnd = braceEnd;
 978                         }
 979                 } else {
 980                         D_EMSG("There is no close tag");
 981                         g_free(textBuf);
 982                         return NULL;
 983                 }
 984
 985                 postStrLength = strLength - (tagEnd - fulltext + 1);
 986                 postStr = strndup(tagEnd + 1, postStrLength);
 987                 if (!postStr) {
 988                         D_EMSG("strndup is failed");
 989                         g_free(textBuf);
 990                         return NULL;
 991                 }
 992
 993                 strncpy(tagStart, postStr, postStrLength);
 994                 *(tagStart + postStrLength) = '\0';
 995                 D_MSG("after textBuf = [%s]", textBuf);
 996
 997                 g_free(postStr);
 998                 postStr = NULL;
 999
1000                 isitemTag = true;
1001         }
1002
1003         if (isitemTag)
1004                 return textBuf;
1005
1006         g_free(textBuf);
1007
1008         return NULL;
1009 }
1010
1011 static char *__get_tag_value(const char *tag_str, const char *tag_name)
1012 {
1013         char *tag;
1014
1015         if (!tag_name || !tag_str)
1016                 return NULL;
1017
1018         if ((tag = strstr(tag_str, tag_name))) {
1019                 if (tag[strlen(tag_name)] == '_')
1020                         return NULL;
1021                 char *value = strchr(tag, '=');
1022                 if (value) {
1023
1024                         do {
1025                                 value++;
1026                         } while (!isalnum(*value) && *value != '#');
1027
1028                         int spCnt = 5;
1029                         char *spArray[spCnt];
1030                         spArray[0] = strchr(value, '>');
1031                         spArray[1] = strchr(value, '\"');
1032                         spArray[2] = strchr(value, '\'');
1033                         spArray[3] = strchr(value, '\t');
1034                         spArray[4] = strchr(value, '\n');
1035                         char *valueEnd = strchr(value, '\0');
1036
1037                         int i;
1038                         int start = 0;
1039                         if (!strcmp(tag_str, "item") && !strcmp(tag_name, "href"))
1040                                 start = 1;
1041
1042                         for (i = start; i < spCnt; i++) {
1043                                 if (spArray[i] && spArray[i] < valueEnd) {
1044                                         valueEnd = spArray[i];
1045                                 }
1046                         }
1047
1048                         int valueLength = valueEnd - value;
1049                         return strndup(value, valueLength);
1050                 }
1051         }
1052
1053         return NULL;
1054 }
1055
1056 void msg_composer_entry_filter_addimage(void *data, Evas_Object *entry, char **text)
1057 {
1058         D_ENTER;
1059
1060         char *item_val = NULL;
1061         char *item_tag = NULL;
1062         char *filepath = NULL;
1063         char *realpath = NULL;
1064
1065         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1066
1067         D_MSG_RETM_IF(cd == NULL, "Composer Data is Invalid");
1068         D_MSG_RETM_IF(entry == NULL,"Parameter Entry is Invalid");
1069         D_MSG_RETM_IF((!text || !(*text)),"Parameter Text is Invalid");
1070
1071         /*get <item xxx> tag at insert text*/
1072         item_tag = __get_item_tag(*text);
1073
1074         if (item_tag) {
1075
1076                 D_MSG("item_tag = %s", item_tag);
1077
1078                 /*get value of href in the item tag*/
1079                 item_val = __get_tag_value(item_tag, "href");
1080                 if (item_val) {
1081                         D_MSG("item_href_val = %s", item_val);
1082                         filepath = strstr(item_val, "file:");
1083                         if (filepath) {
1084                                 realpath = filepath + 5;
1085                         } else {
1086                                 realpath = filepath;
1087                         }
1088
1089                         if (realpath) {
1090                                 if (ecore_file_exists(realpath) == EINA_TRUE) {
1091                                         char * list_item_data  = g_strdup(realpath);
1092                                         if (list_item_data) {
1093                                                 cd->attachlist= eina_list_append(cd->attachlist, list_item_data);
1094                                                 msg_ui_composer_body_items_add(data);
1095                                         } else {
1096                                                 D_EMSG("Fail to g_strdup");
1097                                         }
1098                                 } else {
1099                                         D_EMSG("File is NOT exist %s", realpath);
1100                                 }
1101                         } else {
1102                                 D_EMSG("File Path is NULL");
1103                         }
1104
1105                         g_free(item_val);
1106                 }
1107
1108                 g_free(item_tag);
1109
1110                 /* remove item tag */
1111                 char *removed_text = __remove_item_tag(*text);
1112                 g_free(*text);
1113
1114                 if (removed_text)
1115                         *text = removed_text;
1116                 else
1117                         *text = NULL;
1118
1119         }
1120         D_LEAVE;
1121 }
1122
1123
1124 void
1125 msg_composer_entry_filter_remove_markup(void *data, Evas_Object *entry, char **text)
1126 {
1127         D_ENTER;
1128         D_MSG_RETM_IF(text == NULL || *text == NULL, "New Text is NULL");
1129
1130         char *preedit_tag_start = NULL;
1131         char *preedit_tag_end = NULL;
1132         char *utf8_text = NULL;
1133         char *convert_text = NULL;
1134         D_MSG("text [%s]", *text);
1135
1136         /* Check preeditting text and return if it exist*/
1137         preedit_tag_start = strstr(*text, "<preedit");
1138         preedit_tag_end = strstr(*text, "</preedit");
1139
1140         if (preedit_tag_start && preedit_tag_end)
1141                 return;
1142
1143         /* convert from markup text to utf8 text from entry */
1144         utf8_text  = elm_entry_markup_to_utf8(*text);
1145
1146         if (utf8_text) {
1147                 /* If the string contains "Carrage return ('\n'), it should be changed "<br>" to show properly*/
1148                 convert_text = elm_entry_utf8_to_markup(utf8_text);
1149                 if(convert_text) {
1150                         free(*text);
1151                         *text = strdup(convert_text);
1152                         free(convert_text);
1153                 }
1154                 free(utf8_text);
1155         }
1156
1157         D_LEAVE;
1158 }
1159
1160 void msg_ui_composer_common_tickernoti(MSG_COMPOSER_VIEW_DATA_S *cd, COMPOSER_TICKERNOTI_TYPE_E tickertype)
1161 {
1162         char popup_msg[DEF_BUF_LEN_L] = {0,};
1163
1164         D_MSG_RETM_IF(cd == NULL, "Composer Data is Invalid");
1165
1166         if (tickertype == COMPOSER_TICKERNOTI_COUNT_MAX) {
1167                 const char *str = MSGC_STR_NOTI_RECIPIENT_MAX;
1168                 snprintf(popup_msg, sizeof(popup_msg), str, COMPOSER_RECIPIENT_COUNT_MAX);
1169         } else if (tickertype == COMPOSER_TICKERNOTI_DUP_RECP) {
1170                 snprintf(popup_msg, sizeof(popup_msg), MSGC_STR_NOTI_RECIPIENT_DUP);
1171         } else if (tickertype == COMPOSER_TICKERNOTI_INVALID_RECP) {
1172                 snprintf(popup_msg, sizeof(popup_msg), MSGC_STR_NOTI_RECIPIENT_INVALID);
1173         } else if (tickertype == COMPOSER_TICKERNOTI_CHANGED_SMS) {
1174                 snprintf(popup_msg, sizeof(popup_msg), MSGC_STR_NOTI_CHANGE_SMS);
1175         } else if (tickertype == COMPOSER_TICKERNOTI_CHANGED_MMS) {
1176                 snprintf(popup_msg, sizeof(popup_msg), MSGC_STR_NOTI_CHANGE_MMS);
1177         } else if (tickertype == COMPOSER_TICKERNOTI_AUTO_SAVED) {
1178                 snprintf(popup_msg, sizeof(popup_msg), _MSGSTR("IDS_MSGC_POP_MESSAGE_SAVED_AS_DRAFT"));
1179         } else if (tickertype == COMPOSER_TICKERNOTI_NO_RECIPIENT) {
1180                 snprintf(popup_msg, sizeof(popup_msg), _MSGSTR("IDS_MSGF_POP_NO_RECIPIENTS_ADDED_ENTER_RECIPIENTS"));
1181         } else if (tickertype == COMPOSER_TICKERNOTI_MAXLENGHT_CHAR) {
1182                 snprintf(popup_msg, sizeof(popup_msg), _MSGSTR("IDS_MSGF_POP_MAXIMUM_CHARACTERS"));
1183         } else {
1184                 return;
1185         }
1186
1187         msg_ui_composer_status_noti_show(popup_msg);
1188 }
1189
1190 int msg_ui_composer_get_keypad_height(Evas_Object *entry)
1191 {
1192         D_MSG_RETVM_IF(entry == NULL, 0, "param is NULL");
1193         int keypad_x = 0;
1194         int keypad_y = 0;
1195         int keypad_w = 0;
1196         int keypad_h = 0;
1197
1198         Ecore_IMF_Context *entry_ctx = elm_entry_imf_context_get(entry);
1199         ecore_imf_context_input_panel_geometry_get(entry_ctx, &keypad_x, &keypad_y, &keypad_w, &keypad_h);
1200
1201         return keypad_h;
1202 }
1203
1204 void msg_ui_composer_change_body_scroll_size(MSG_COMPOSER_VIEW_DATA_S *cd, int keypad_height)
1205 {
1206         D_ENTER;
1207         D_MSG_RETM_IF(cd == NULL, "Composer Data is Invalid");
1208
1209         int total_height = 0;
1210         int scroll_height = 0;
1211         int scroll_x = 0;
1212         int scroll_y = 0;
1213         int scroll_w = 0;
1214         int scroll_h = 0;
1215
1216         elm_scroller_region_get(cd->body_scroll, &scroll_x, &scroll_y, &scroll_w, &scroll_h);
1217         D_MSG("scroll region x=%d, y=%d, w=%d, h=%d", scroll_x, scroll_y, scroll_w, scroll_h);
1218
1219         if (cd->rotate == COMPOSER_ROTATE_PORTRAIT || cd->rotate == COMPOSER_ROTATE_PORTRAIT_UPSIDEDOWN)
1220                 total_height = (cd->window_h > cd->window_w) ? cd->window_h : cd->window_w;
1221         else
1222                 total_height = (cd->window_h > cd->window_w) ? cd->window_w : cd->window_h;
1223
1224         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1225                 RECIPIENT_S *rd = cd->recipient;
1226                 D_MSG_RETM_IF(rd == NULL, "recipient Data is NULL");
1227                 int recipient_h = 0;
1228
1229                 recipient_h = rd->recipient_h;
1230
1231                 D_MSG("recipient_h = %d", recipient_h);
1232                 if (cd->rotate == COMPOSER_ROTATE_PORTRAIT || cd->rotate == COMPOSER_ROTATE_PORTRAIT_UPSIDEDOWN)
1233                         scroll_height = (total_height - keypad_height - recipient_h - MSGC_NAVIBAR_TITLE_H - MSGC_BODY_PADDING - MSGC_INDICATOR_H);
1234                 else
1235                         scroll_height = (total_height - keypad_height - recipient_h - MSGC_NAVIBAR_TITLE_H - MSGC_BODY_PADDING);
1236
1237                 D_MSG("scroll_height = %d", scroll_height);
1238
1239                 if (scroll_height <= COMPOSER_FRAME_BODY_LANDSCAPE_HEIGHT_MIN)
1240                         scroll_height = COMPOSER_FRAME_BODY_LANDSCAPE_HEIGHT_MIN;
1241
1242                 if (scroll_h != scroll_height) {
1243                         evas_object_size_hint_max_set(cd->body_scroll, 9999, scroll_height);
1244                         elm_scroller_content_min_limit(cd->body_scroll, EINA_FALSE, EINA_TRUE);
1245                         D_MSG("scroll size updated w = %d, h = %d", scroll_w, scroll_height);
1246                 }
1247         } else if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
1248                 scroll_height = (total_height - keypad_height - MSGC_NAVIBAR_TITLE_H - MSGC_INDICATOR_H - MSGC_BODY_PADDING);
1249                 D_MSG("scroll_height = %d", scroll_height);
1250
1251                 if (scroll_height <= COMPOSER_FRAME_BODY_LANDSCAPE_HEIGHT_MIN)
1252                         scroll_height = COMPOSER_FRAME_BODY_LANDSCAPE_HEIGHT_MIN;
1253
1254                 if (scroll_h != scroll_height) {
1255                         evas_object_size_hint_max_set(cd->body_scroll, 9999, scroll_height);
1256                         elm_scroller_content_min_limit(cd->body_scroll, EINA_FALSE, EINA_TRUE);
1257                         D_MSG("scroll size updated w = %d, h = %d", scroll_w, scroll_height);
1258                 }
1259         } else {
1260                 D_EMSG("Unknown Composer Mode");
1261         }
1262
1263         D_LEAVE;
1264 }
1265
1266 void msg_ui_composer_make_default_body_size(MSG_COMPOSER_VIEW_DATA_S *cd)
1267 {
1268         D_ENTER;
1269         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
1270
1271         int scroll_height = COMPOSER_FRAME_BODY_LANDSCAPE_HEIGHT_MIN;
1272
1273         cd->is_default_body_size = true;
1274
1275         msg_ui_composer_contract_attach_list(cd);
1276
1277         evas_object_size_hint_max_set(cd->body_scroll, 9999, scroll_height);
1278         elm_scroller_content_min_limit(cd->body_scroll, EINA_FALSE, EINA_TRUE);
1279         /* move scroll to top */
1280         elm_scroller_region_show(cd->body_scroll, 0, 0, 0, 0);
1281
1282         evas_object_event_callback_add(cd->body_box, EVAS_CALLBACK_MOUSE_UP, msg_ui_composer_body_body_layout_clicked_cb, cd);
1283
1284         D_LEAVE;
1285 }
1286
1287 void msg_ui_composer_entry_imf_resize_cb(void * data, Ecore_IMF_Context *ctx, int value)
1288 {
1289         D_ENTER;
1290         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1291         D_MSG_RETM_IF(cd == NULL, "Composer Data is Invalid");
1292         D_MSG_RETM_IF(ctx == NULL, "Ecore_IMF_Context is Invalid");
1293         int keypad_x = 0;
1294         int keypad_y = 0;
1295         int keypad_w = 0;
1296         int keypad_h = 0;
1297
1298         ecore_imf_context_input_panel_geometry_get(ctx, &keypad_x, &keypad_y, &keypad_w, &keypad_h);
1299         D_MSG("keypad x = %d, y = %d, w = %d, h = %d", keypad_x, keypad_y, keypad_w, keypad_h);
1300         D_MSG("cd->make_default_body_size = %d", cd->make_default_body_size);
1301
1302         if (cd->make_default_body_size) {
1303                  if (!cd->is_keypad_show)
1304                          cd->make_default_body_size = false;
1305         } else {
1306                 if (keypad_w != 0 && keypad_h != 0)
1307                         msg_ui_composer_change_body_scroll_size(cd, keypad_h);
1308         }
1309
1310         D_LEAVE;
1311 }
1312
1313 void msg_ui_composer_entry_imf_state_cb(void * data, Ecore_IMF_Context *ctx, int value)
1314 {
1315         D_ENTER;
1316
1317         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1318         D_MSG_RETM_IF(cd == NULL, "Composer Data is Invalid");
1319         D_MSG_RETM_IF(ctx == NULL, "Ecore_IMF_Context is Invalid");
1320
1321         if (value == ECORE_IMF_INPUT_PANEL_STATE_SHOW) {
1322                 int keypad_x = 0;
1323                 int keypad_y = 0;
1324                 int keypad_w = 0;
1325                 int keypad_h = 0;
1326
1327                 D_MSG("Imf status SHOW");
1328
1329                 cd->is_keypad_show = true;
1330
1331                 ecore_imf_context_input_panel_geometry_get(ctx, &keypad_x, &keypad_y, &keypad_w, &keypad_h);
1332                 D_MSG("keypad x = %d, y = %d, w = %d, h = %d", keypad_x, keypad_y, keypad_w, keypad_h);
1333
1334                 msg_ui_composer_change_body_scroll_size(cd, keypad_h);
1335         } else if (value == ECORE_IMF_INPUT_PANEL_STATE_HIDE) {
1336                 D_MSG("Imf status HIDE");
1337
1338                 cd->is_keypad_show = false;
1339
1340                 D_MSG("cd->make_default_body_size = %d", cd->make_default_body_size);
1341
1342                 if (cd->make_default_body_size) {
1343                         cd->make_default_body_size = false;
1344                         msg_ui_composer_make_default_body_size(cd);
1345                 } else {
1346                         msg_ui_composer_change_body_scroll_size(cd, 0);
1347                 }
1348         } else {
1349                 D_EMSG("imf status INVALID");
1350         }
1351
1352         D_LEAVE;
1353 }
1354
1355 int msg_ui_composer_get_font_size(int type)
1356 {
1357         D_ENTER;
1358
1359         int font_size = 0;
1360         int converted_size = -1;
1361
1362         if (type == COMPOSER_TYPE_BODY) {
1363                 int index = 0;
1364
1365                 if (msg_common_get_font_size(&index) == FALSE) {
1366                         D_EMSG("msg_common_get_font_size() is failed !!");
1367                         return -1;
1368                 } else {
1369                         D_MSG("selected font_size index = %d", index);
1370                 }
1371
1372                 font_size = msg_common_get_font_size_from_index(index);
1373
1374                 if (font_size == -1) {
1375                         D_EMSG("msg_common_get_font_size_from_index() is failed !!");
1376                         return -1;
1377                 }
1378
1379                 converted_size = (MSGC_BODY_FONT_SIZE * font_size) / MSG_APP_FONT_SIZE_NORMAL;
1380         } else if (type == COMPOSER_TYPE_SUBJECT) {
1381                 int access_font_index = 0;
1382
1383                 /* get accessibility font index */
1384                 if (vconf_get_int(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, &access_font_index) < 0) {
1385                         D_EMSG("vconf_get_int(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE) is failed !!");
1386                         access_font_index = MSG_SYS_FONT_SIZE_INDEX_NORMAL;     /* 1 */
1387                 }
1388
1389                 font_size = msg_common_get_font_size_from_index(access_font_index);
1390                 if (font_size == -1) {
1391                         D_EMSG("msg_common_get_font_size_from_index() is failed !!");
1392                         return -1;
1393                 }
1394
1395                 converted_size = (MSGC_SUBJECT_FONT_SIZE * font_size) / MSG_APP_FONT_SIZE_NORMAL;
1396         } else {
1397                 D_EMSG("Invalid type");
1398         }
1399
1400         D_LEAVE;
1401         return converted_size;
1402 }
1403
1404 void msg_ui_composer_apply_font_size(MSG_COMPOSER_VIEW_DATA_S *cd, bool update_subject)
1405 {
1406         D_ENTER;
1407         D_MSG_RETM_IF(cd == NULL, "Composer Data is Invalid");
1408
1409         int index = 0;
1410         int font_size = 0;
1411         int converted_size = cd->font_size;
1412
1413         if (msg_common_get_font_size(&index) == FALSE) {
1414                 D_EMSG("msg_common_get_font_size() is failed !!");
1415                 return;
1416         } else {
1417                 D_MSG("selected font_size index = %d", index);
1418         }
1419
1420         font_size = msg_common_get_font_size_from_index(index);
1421
1422         if (font_size == -1) {
1423                 D_EMSG("msg_common_get_font_size_from_index() is failed !!");
1424                 return;
1425         }
1426
1427         converted_size = (MSGC_BODY_FONT_SIZE * font_size) / MSG_APP_FONT_SIZE_NORMAL;
1428
1429         /* apply font size */
1430         char font_style_str[DEF_BUF_LEN_S + 1] = {0,};
1431         snprintf(font_style_str, sizeof(font_style_str), "DEFAULT='font_size=%d'", converted_size);
1432         D_MSG("font_style_str = (%s)", font_style_str);
1433
1434         msg_ui_composer_recipient_apply_font_size(cd, font_style_str);
1435         msg_ui_composer_body_apply_font_size(cd, font_style_str);
1436
1437         if (update_subject) {
1438                 int access_font_index = 0;
1439                 /* get accessibility font index */
1440                 if (vconf_get_int(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, &access_font_index) < 0) {
1441                         D_EMSG("vconf_get_int(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE) is failed !!");
1442                         access_font_index = MSG_SYS_FONT_SIZE_INDEX_NORMAL;     /* 1 */
1443                 }
1444
1445                 font_size = msg_common_get_font_size_from_index(access_font_index);
1446                 if (font_size == -1) {
1447                         D_EMSG("msg_common_get_font_size_from_index() is failed !!");
1448                         return;
1449                 }
1450
1451                 converted_size = (MSGC_SUBJECT_FONT_SIZE * font_size) / MSG_APP_FONT_SIZE_NORMAL;
1452
1453                 /* apply font size */
1454                 memset(font_style_str, 0, sizeof(font_style_str));
1455                 snprintf(font_style_str, sizeof(font_style_str), "DEFAULT='font_size=%d'", converted_size);
1456                 D_MSG("subject font_style_str = (%s)", font_style_str);
1457
1458                 msg_ui_composer_subject_apply_font_size(cd, font_style_str);
1459         }
1460
1461         D_LEAVE;
1462 }
1463
1464 void msg_ui_composer_naviframe_size_hints_changed(void *data, Evas *e, Evas_Object *obj, void *event_info)
1465 {
1466         D_ENTER;
1467         D_MSG_RETM_IF(data == NULL, "Composer Data is NULL");
1468         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1469         Evas_Display_Mode dispmode;
1470
1471         dispmode = evas_object_size_hint_display_mode_get(obj);
1472         if (dispmode == EVAS_DISPLAY_MODE_COMPRESS) {
1473                 D_MSG("dispmode = EVAS_DISPLAY_MODE_COMPRESS");
1474                 cd->is_keypad_show = true;
1475         } else if (dispmode == EVAS_DISPLAY_MODE_NONE) {
1476                 D_MSG("dispmode = EVAS_DISPLAY_MODE_NONE");
1477                 cd->is_keypad_show = false;
1478         }
1479         D_LEAVE;
1480 }
1481