composer/src/message/msg-ui-composer-message.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 /* includes*/
  19 #include "msg-ui-composer-subject.h"
  20 #include "msg-ui-composer-util.h"
  21 #include "msg-ui-composer-body.h"
  22 #include "msg-ui-composer-message.h"
  23 #include "msg-ui-composer-message-data.h"
  24 #include "msg-ui-composer-attachment.h"
  25 #include "msg-ui-composer-common.h"
  26 #include "msg-ui-composer-recipient.h"
  27 #include "msg-ui-composer-popup.h"
  28
  29 #include <glib-object.h>
  30 #include <glib.h>
  31
  32 /* defines */
  33 #define MSG_DATA_TEMPPATH       DATADIR "/"
  34
  35 #define MSG_COMPOSER_SMIL_SCREEN_WIDTH  480
  36 #define MSG_COMPOSER_SMIL_SCREEN_HEIGHT 800
  37
  38 #define MSG_COMPOSER_SMIL_POS_TOP               1
  39 #define MSG_COMPOSER_SMIL_POS_BOTTOM    50
  40 #define MSG_COMPOSER_SMIL_POS_LEFT              0
  41
  42 #define MSG_COMPOSER_SMIL_REGION_WIDTH  100
  43 #define MSG_COMPOSER_SMIL_REGION_HEIGHT 50
  44
  45 #define MSG_COMPOSER_SMIL_DEFAULT_BGCOLOR 0xFFFFFF
  46 #define MSG_COMPOSER_SMIL_DEFAULT_FONT_COLOR 0x000000
  47 #define MSG_COMPOSER_SMIL_DEFAULT_FONT_SIZE 30
  48 #define MSG_COMPOSER_SMIL_DEFAULT_BOLD false
  49 #define MSG_COMPOSER_SMIL_DEFAULT_UNDERLINE false
  50
  51
  52
  53 /* globals */
  54 static MSG_COMP_MSG_DATA_S *msg_data = NULL;
  55
  56 /* function defines*/
  57
  58 /****************************************************
  59  *
  60  *      UI HANDLING
  61  *
  62  *****************************************************/
  63
  64 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_init()
  65 {
  66         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
  67
  68         if (msg_data != NULL) {
  69                 free(msg_data);
  70                 msg_data = NULL;
  71         }
  72
  73         msg_data = (MSG_COMP_MSG_DATA_S *)calloc(1, sizeof(MSG_COMP_MSG_DATA_S));
  74
  75         if (msg_data == NULL) {
  76                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] msg_data calloc error");
  77                 return COMPOSER_RETURN_FAIL;
  78         }
  79
  80         memset(msg_data, 0x00, sizeof(MSG_COMP_MSG_DATA_S));
  81
  82         return COMPOSER_RETURN_SUCCESS;
  83 }
  84
  85 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_destroy()
  86 {
  87         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
  88
  89         if (msg_data == NULL) {
  90                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] msg_data is already NULL");
  91                 return COMPOSER_RETURN_FAIL;
  92         }
  93         /* free recipient data */
  94         if (msg_data->recp_list != NULL) {
  95                 g_slist_foreach(msg_data->recp_list, (GFunc) free, NULL);
  96                 g_slist_free(msg_data->recp_list);
  97                 msg_data->recp_list = NULL;
  98         }
  99         /* free sms data. */
 100         if (msg_data->sms_data.body_text != NULL) {
 101                 free(msg_data->sms_data.body_text);
 102                 msg_data->sms_data.body_text = NULL;
 103         }
 104
 105         free(msg_data);
 106         msg_data = NULL;
 107
 108         return COMPOSER_RETURN_SUCCESS;
 109 }
 110
 111 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_add_address(char *number)
 112 {
 113         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 114
 115         if (number == NULL) {
 116                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] argument [number] is NULL !!");
 117                 return COMPOSER_RETURN_FAIL;
 118         }
 119
 120         char *address = strdup(number);
 121         msg_data->recp_list = g_slist_append(msg_data->recp_list, (void *)address);
 122
 123         return COMPOSER_RETURN_SUCCESS;
 124 }
 125
 126 GSList *msg_ui_composer_message_get_address(void)
 127 {
 128         D_ENTER;
 129         D_MSG_RETVM_IF(msg_data == NULL, NULL, "msg_data is NULL. need to init");
 130
 131         return msg_data->recp_list;
 132 }
 133
 134 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_set_msg_type(COMPOSER_MSG_TYPE_E msg_type)
 135 {
 136         if (!msg_data) {
 137                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] msg_data is NULL. need to init");
 138                 return COMPOSER_RETURN_NULL_POINTER;
 139         }
 140
 141         msg_data->msg_type = msg_type;
 142
 143         return COMPOSER_RETURN_SUCCESS;
 144 }
 145
 146 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_set_sms_body(char *body_text)
 147 {
 148         if (body_text == NULL) {
 149                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] argument [body_text] is NULL !!");
 150                 return COMPOSER_RETURN_FAIL;
 151         }
 152
 153         msg_data->sms_data.body_text = strdup(body_text);
 154         msg_data->sms_data.body_length = strlen(body_text);
 155
 156         return COMPOSER_RETURN_SUCCESS;
 157 }
 158
 159 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_set_subject(char *subject, int length)
 160 {
 161         D_ENTER;
 162         if (msg_data == NULL || subject == NULL) {
 163                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] message data is NULL or no subject");
 164                 return COMPOSER_RETURN_FAIL;
 165         }
 166
 167         if (subject && length > 0)
 168                 msg_data->mms_data.isSubject = true;
 169
 170         if (length <= sizeof(msg_data->mms_data.subject))
 171                 strncpy(msg_data->mms_data.subject, subject, length);
 172         else
 173                 strncpy(msg_data->mms_data.subject, subject, sizeof(msg_data->mms_data.subject)-1);
 174
 175         D_LEAVE;
 176         return COMPOSER_RETURN_SUCCESS;
 177 }
 178
 179 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_set_attach_count(int attach_count)
 180 {
 181         D_ENTER;
 182
 183         if (!msg_data) {
 184                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] msg_data is NULL");
 185                 return COMPOSER_RETURN_NULL_POINTER;
 186         }
 187
 188         MSG_COMP_MMS_DATA_S *mms_data = &msg_data->mms_data;
 189
 190         mms_data->attach_count = attach_count;
 191
 192         D_LEAVE;
 193         return COMPOSER_RETURN_SUCCESS;
 194 }
 195
 196 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_add_attachments(const char *filepath, int filetype)
 197 {
 198         D_ENTER;
 199         D_MSG_RETVM_IF(ecore_file_exists(filepath) == EINA_FALSE, COMPOSER_RETURN_FAIL,"File is NOT exist");
 200
 201         if (!msg_data) {
 202                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] msg_data is NULL");
 203                 return COMPOSER_RETURN_NULL_POINTER;
 204         }
 205
 206         MSG_COMP_MMS_DATA_S *mms_data = &msg_data->mms_data;
 207         int attach_count = mms_data->attach_count;
 208
 209         int i = 0;
 210         for (i = 0; i < attach_count; i++) {
 211                 if (strlen(mms_data->attachlist[i].filepath) <= 0) {
 212                         mms_data->attachlist[i].filetype = filetype;
 213
 214                         strncpy(mms_data->attachlist[i].filepath, filepath, strlen(filepath));
 215                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] attachment file path : [%s]", mms_data->attachlist[i].filepath);
 216                         break;
 217                 }
 218         }
 219
 220         D_LEAVE;
 221         return COMPOSER_RETURN_SUCCESS;
 222 }
 223
 224 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_set_page_count(int page_count)
 225 {
 226         D_ENTER;
 227
 228         if (!msg_data) {
 229                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] message data is not exist");
 230                 return COMPOSER_RETURN_NULL_POINTER;
 231         }
 232
 233         msg_data->mms_data.page_count = page_count;
 234
 235         D_LEAVE;
 236         return COMPOSER_RETURN_SUCCESS;
 237 }
 238
 239 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_set_is_text_top(bool isTextTop)
 240 {
 241         D_ENTER;
 242
 243         if (!msg_data) {
 244                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] message data is not exist");
 245                 return COMPOSER_RETURN_NULL_POINTER;
 246         }
 247
 248         msg_data->mms_data.isTextTop = isTextTop;
 249
 250         D_LEAVE;
 251         return COMPOSER_RETURN_SUCCESS;
 252 }
 253
 254 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_mms_set_text(const char *text, int nPage)
 255 {
 256         D_ENTER;
 257
 258         if (!msg_data) {
 259                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] message data is not exist !!");
 260                 return COMPOSER_RETURN_NULL_POINTER;
 261         }
 262
 263         MSG_COMP_MMS_DATA_S *mms_data = &msg_data->mms_data;
 264         int text_len = 0;
 265
 266         if (text)
 267                 text_len = strlen(text);
 268
 269         if (text && text_len > 0) {
 270                 mms_data->pagelist[nPage].isText = true;
 271
 272                 if (text_len <= COMPOSER_MMS_TEXT_MAX_BYTE)
 273                         strncpy(mms_data->pagelist[nPage].body_text, text, text_len);
 274                 else
 275                         strncpy(mms_data->pagelist[nPage].body_text, text, COMPOSER_MMS_TEXT_MAX_BYTE);
 276         } else {
 277                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] no text");
 278                 mms_data->pagelist[nPage].isText = false;
 279                 return COMPOSER_RETURN_FAIL;
 280         }
 281
 282         D_LEAVE;
 283         return COMPOSER_RETURN_SUCCESS;
 284 }
 285
 286 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_mms_set_page_duration(int nPage, int duration)
 287 {
 288         D_ENTER;
 289
 290         if (!msg_data) {
 291                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] message data is NOT exist");
 292                 return COMPOSER_RETURN_NULL_POINTER;
 293         }
 294
 295         if (nPage >= COMPOSER_MMS_MAX_PAGE) {
 296                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] Invalid nPage index");
 297                 return COMPOSER_RETURN_FAIL;
 298         }
 299
 300         MSG_COMP_MMS_DATA_S *mms_data = &msg_data->mms_data;
 301
 302         if (duration > COMPOSER_PAGE_DEFAULT_DURATION)
 303                 mms_data->pagelist[nPage].page_duration = duration;
 304
 305
 306         D_LEAVE;
 307         return COMPOSER_RETURN_SUCCESS;
 308 }
 309
 310 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_mms_set_media(const char *file_path, COMPOSER_MEDIA_TYPE_E media_type, int nPage)
 311 {
 312         D_ENTER;
 313         D_MSG_RETVM_IF(ecore_file_exists(file_path) == EINA_FALSE, COMPOSER_RETURN_FAIL, "File is NOT exist");
 314
 315         if (!msg_data) {
 316                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] message data is NOT exist");
 317                 return COMPOSER_RETURN_NULL_POINTER;
 318         }
 319
 320         MSG_COMP_MMS_DATA_S *mms_data = &msg_data->mms_data;
 321
 322         if (!file_path) {
 323                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] No file path");
 324                 return COMPOSER_RETURN_FAIL;
 325         }
 326
 327         switch (media_type) {
 328         case COMPOSER_MEDIA_TYPE_IMAGE:
 329                 mms_data->pagelist[nPage].isImage = true;
 330                 strncpy(mms_data->pagelist[nPage].image_file_path, file_path, strlen(file_path));
 331                 break;
 332
 333         case COMPOSER_MEDIA_TYPE_VIDEO:
 334                 mms_data->pagelist[nPage].isVideo = true;
 335                 strncpy(mms_data->pagelist[nPage].image_file_path, file_path, strlen(file_path));
 336                 break;
 337
 338         case COMPOSER_MEDIA_TYPE_AUDIO:
 339                 mms_data->pagelist[nPage].isSound = true;
 340                 strncpy(mms_data->pagelist[nPage].sound_file_path, file_path, strlen(file_path));
 341                 break;
 342
 343         default:
 344                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR] invalid media type");
 345                 return COMPOSER_RETURN_INVALID_MEDIA_TYPE;
 346         }
 347
 348         D_LEAVE;
 349         return COMPOSER_RETURN_SUCCESS;
 350 }
 351
 352 /*****************************************************
 353  *
 354  *       Framework message Handling
 355  *
 356  *******************************************************/
 357
 358 static COMPOSER_RETURN_TYPE_E __msg_ui_composer_set_recipient()
 359 {
 360         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 361
 362         if (msg_data == NULL || msg_data->msgInfo == NULL) {
 363                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] msgInfo is NULL !!");
 364                 return COMPOSER_RETURN_FAIL;
 365         }
 366
 367         int count = g_slist_length(msg_data->recp_list);
 368         int i = 0;
 369         msg_struct_list_s *addr_list = NULL;
 370
 371         msg_get_list_handle(msg_data->msgInfo, MSG_MESSAGE_ADDR_LIST_STRUCT, (void**)&addr_list);
 372
 373         addr_list->nCount = count;
 374         for (i = 0; i < count; i++) {
 375                 char *address = (char *)g_slist_nth_data(msg_data->recp_list, i);
 376                 if (address == NULL) {
 377                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR] address is value NULL, skip");
 378                         continue;
 379                 }
 380
 381                 int addr_type = get_address_type((const char*)address);
 382                 if (addr_type == COMPOSER_UTIL_ADDRTYPE_NUMBER)
 383                         msg_set_int_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_TYPE_INT, MSG_ADDRESS_TYPE_PLMN);
 384                 else if (addr_type == COMPOSER_UTIL_ADDRTYPE_EMAIL)
 385                         msg_set_int_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_TYPE_INT, MSG_ADDRESS_TYPE_EMAIL);
 386                 msg_set_int_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT, MSG_RECIPIENTS_TYPE_TO);
 387                 msg_set_str_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, address, strlen(address));
 388         }
 389
 390         return COMPOSER_RETURN_SUCCESS;
 391 }
 392
 393 COMPOSER_RETURN_TYPE_E msg_ui_composer_create_new_message()
 394 {
 395         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 396
 397         if (msg_data->msgInfo != NULL) {
 398                 msg_release_struct(&msg_data->msgInfo);
 399                 msg_data->msgInfo = NULL;
 400         }
 401
 402         msg_data->msgInfo = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 403
 404         if (msg_data->msgInfo == NULL) {
 405                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] msg_create_struct failed");
 406                 return COMPOSER_RETURN_FAIL;
 407         }
 408
 409         return COMPOSER_RETURN_SUCCESS;
 410 }
 411
 412 COMPOSER_RETURN_TYPE_E msg_ui_composer_release_message()
 413 {
 414         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 415
 416         if (msg_data->msgInfo == NULL) {
 417                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] msgInfo is already destroyed !!");
 418                 return COMPOSER_RETURN_FAIL;
 419         }
 420
 421         if (msg_release_struct(&msg_data->msgInfo) != MSG_SUCCESS) {
 422                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] msgInfo is already destroyed !!");
 423                 return COMPOSER_RETURN_FAIL;
 424         }
 425
 426         return COMPOSER_RETURN_SUCCESS;
 427 }
 428
 429 static COMPOSER_RETURN_TYPE_E __msg_ui_composer_make_sms_message(msg_handle_t msg_handle)
 430 {
 431         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 432
 433         if (msg_data == NULL || msg_data->msgInfo == NULL) {
 434                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] msgInfo is NULL !!");
 435                 return COMPOSER_RETURN_FAIL;
 436         }
 437
 438         int err = MSG_SUCCESS;
 439         /* set message type to SMS */
 440         if (msg_set_int_value(msg_data->msgInfo, MSG_MESSAGE_TYPE_INT, MSG_TYPE_SMS) != MSG_SUCCESS) {
 441                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT]msg_ui_comp_core_set_message_type error !!");
 442                 return COMPOSER_RETURN_FAIL;
 443         }
 444         /* set message body text */
 445         if (msg_data->sms_data.body_text)
 446                 err = msg_set_str_value(msg_data->msgInfo, MSG_MESSAGE_SMS_DATA_STR, msg_data->sms_data.body_text, strlen(msg_data->sms_data.body_text));
 447         else
 448                 err = msg_set_str_value(msg_data->msgInfo, MSG_MESSAGE_SMS_DATA_STR, NULL, 0);
 449
 450         if (err != MSG_SUCCESS) {
 451                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT]msg_ui_comp_core_set_sms_body error !!");
 452                 return COMPOSER_RETURN_FAIL;
 453         }
 454         /* set recipient */
 455         if (__msg_ui_composer_set_recipient(msg_data) != COMPOSER_RETURN_SUCCESS) {
 456                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT]__msg_ui_composer_set_recipient error !!");
 457                 return COMPOSER_RETURN_FAIL;
 458         }
 459
 460         return COMPOSER_RETURN_SUCCESS;
 461 }
 462
 463 static COMPOSER_RETURN_TYPE_E __msg_ui_composer_make_smil_header(msg_handle_t msg_handle, msg_struct_t mms_data, bool isTextTop)
 464 {
 465         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 466
 467         if (!mms_data) {
 468                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] msg_data is NULL");
 469                 return COMPOSER_RETURN_FAIL;
 470         }
 471
 472         msg_struct_t text_region = NULL;
 473         msg_struct_t image_region = NULL;
 474
 475         /************  make rootlayout ***************/
 476         msg_set_int_value(mms_data, MSG_MMS_ROOTLAYOUT_WIDTH_INT, MSG_COMPOSER_SMIL_SCREEN_WIDTH);
 477         msg_set_int_value(mms_data, MSG_MMS_ROOTLAYOUT_HEIGHT_INT, MSG_COMPOSER_SMIL_SCREEN_HEIGHT);
 478         msg_set_int_value(mms_data, MSG_MMS_ROOTLAYOUT_BGCOLOR_INT, MSG_COMPOSER_SMIL_DEFAULT_BGCOLOR);
 479
 480         /************ make region ********************/
 481         /* 1. add text region */
 482         msg_mms_add_item(mms_data, MSG_STRUCT_MMS_REGION, &text_region);
 483         msg_set_str_value(text_region, MSG_MMS_REGION_ID_STR, "Text", strlen("Text"));
 484         msg_set_int_value(text_region, MSG_MMS_REGION_LENGTH_LEFT_INT, MSG_COMPOSER_SMIL_POS_LEFT);
 485
 486         if (isTextTop)
 487                 msg_set_int_value(text_region, MSG_MMS_REGION_LENGTH_TOP_INT, MSG_COMPOSER_SMIL_POS_TOP);
 488         else
 489                 msg_set_int_value(text_region, MSG_MMS_REGION_LENGTH_TOP_INT, MSG_COMPOSER_SMIL_POS_BOTTOM);
 490
 491         msg_set_int_value(text_region, MSG_MMS_REGION_LENGTH_WIDTH_INT, MSG_COMPOSER_SMIL_REGION_WIDTH);
 492         msg_set_int_value(text_region, MSG_MMS_REGION_LENGTH_HEIGHT_INT, MSG_COMPOSER_SMIL_REGION_HEIGHT);
 493         msg_set_int_value(text_region, MSG_MMS_REGION_BGCOLOR_INT, MSG_COMPOSER_SMIL_DEFAULT_BGCOLOR);
 494
 495         /* 2. image(video) region */
 496         msg_mms_add_item(mms_data, MSG_STRUCT_MMS_REGION, &image_region);
 497         msg_set_str_value(image_region, MSG_MMS_REGION_ID_STR, "Image", strlen("Image"));
 498         msg_set_int_value(image_region, MSG_MMS_REGION_LENGTH_LEFT_INT, MSG_COMPOSER_SMIL_POS_LEFT);
 499
 500         if (isTextTop)
 501                 msg_set_int_value(image_region, MSG_MMS_REGION_LENGTH_TOP_INT, MSG_COMPOSER_SMIL_POS_BOTTOM);
 502         else
 503                 msg_set_int_value(image_region, MSG_MMS_REGION_LENGTH_TOP_INT, MSG_COMPOSER_SMIL_POS_TOP);
 504
 505         msg_set_int_value(image_region, MSG_MMS_REGION_LENGTH_WIDTH_INT, MSG_COMPOSER_SMIL_REGION_WIDTH);
 506         msg_set_int_value(image_region, MSG_MMS_REGION_LENGTH_HEIGHT_INT, MSG_COMPOSER_SMIL_REGION_HEIGHT);
 507         msg_set_int_value(image_region, MSG_MMS_REGION_BGCOLOR_INT, MSG_COMPOSER_SMIL_DEFAULT_BGCOLOR);
 508
 509         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 510         return COMPOSER_RETURN_SUCCESS;
 511 }
 512
 513 static COMPOSER_RETURN_TYPE_E __msg_ui_composer_make_mms_body(msg_handle_t msg_handle, msg_struct_t fw_mms_data)
 514 {
 515         D_ENTER;
 516
 517         if (!msg_data || !fw_mms_data) {
 518                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] message data or FW mms data pointer is NULL");
 519                 return COMPOSER_RETURN_NULL_POINTER;
 520         }
 521
 522         MSG_COMP_MMS_DATA_S *ui_mms_data = &msg_data->mms_data;
 523         int page_count = ui_mms_data->page_count;
 524         int i = 0;
 525
 526         for (i = 0; i < page_count; i++) {
 527                 msg_struct_t page_info = NULL;
 528                 int page_duration = 0;
 529
 530                 /* verify page duration */
 531                 if (COMPOSER_PAGE_DEFAULT_DURATION < ui_mms_data->pagelist[i].page_duration)
 532                         page_duration = ui_mms_data->pagelist[i].page_duration;
 533                 else
 534                         page_duration = COMPOSER_PAGE_DEFAULT_DURATION;
 535
 536                 D_MSG("%dth page's page duration = %d", i + 1, page_duration);
 537                 page_duration = page_duration * 1000;
 538
 539                 /* 1. make page */
 540                 if (msg_mms_add_item(fw_mms_data, MSG_STRUCT_MMS_PAGE, &page_info) != MSG_SUCCESS) {
 541                         MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] create mms page error");
 542                         return COMPOSER_RETURN_FAIL;
 543                 }
 544
 545                 msg_set_int_value(page_info, MSG_MMS_PAGE_PAGE_DURATION_INT, page_duration);
 546
 547                 /* 2. add media */
 548                 /* 1) text */
 549                 if (ui_mms_data->pagelist[i].isText) {
 550                         FILE *fp;
 551                         char szFilePath[DEF_BUF_LEN_L] = { 0x00, };
 552                         char szFileName[DEF_BUF_LEN_L] = { 0x00, };
 553                         char strMsg[COMPOSER_MMS_TEXT_MAX_BYTE + 1] = { 0x00, };
 554
 555                         msg_struct_t added_media = NULL;
 556                         msg_struct_t text_style = NULL;
 557
 558                         /* create txt file */
 559                         snprintf(szFilePath, sizeof(szFilePath), "%sMMS_Temp_%d.txt", MSG_DATA_TEMPPATH, i + 1);
 560                         snprintf(szFileName, sizeof(szFileName), "MMS_Temp_%d.txt", i + 1);
 561
 562                         fp = fopen(szFilePath, "wb");
 563                         if (!fp) {
 564                                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "fopen error");
 565                                 return COMPOSER_RETURN_FAIL;
 566                         }
 567
 568                         strncpy(strMsg, ui_mms_data->pagelist[i].body_text, sizeof(strMsg) - 1);
 569                         fwrite(strMsg, strlen(strMsg), 1, fp);
 570                         fclose(fp);
 571
 572                         msg_mms_add_item(page_info, MSG_STRUCT_MMS_MEDIA, &added_media);
 573                         msg_set_int_value(added_media, MSG_MMS_MEDIA_TYPE_INT, MMS_SMIL_MEDIA_TEXT);
 574                         msg_set_str_value(added_media, MSG_MMS_MEDIA_REGION_ID_STR, "Text", strlen("Text"));
 575                         msg_set_str_value(added_media, MSG_MMS_MEDIA_FILEPATH_STR, szFilePath, strlen(szFilePath));
 576
 577                         /** set font style */
 578                         text_style = msg_create_struct(MSG_STRUCT_MMS_SMIL_TEXT);
 579                         msg_set_int_value(text_style, MSG_MMS_SMIL_TEXT_COLOR_INT, MSG_COMPOSER_SMIL_DEFAULT_FONT_COLOR);
 580                         msg_set_int_value(text_style, MSG_MMS_SMIL_TEXT_SIZE_INT, MSG_COMPOSER_SMIL_DEFAULT_FONT_SIZE);
 581                         msg_set_int_value(text_style, MSG_MMS_SMIL_TEXT_BOLD_BOOL, MSG_COMPOSER_SMIL_DEFAULT_BOLD);
 582                         msg_set_int_value(text_style, MSG_MMS_SMIL_TEXT_BOLD_BOOL, MSG_COMPOSER_SMIL_DEFAULT_UNDERLINE);
 583
 584                         msg_set_struct_handle(added_media, MSG_MMS_MEDIA_SMIL_TEXT_HND, text_style);
 585                         msg_release_struct(&text_style);
 586                 }
 587
 588                 /* 2) image / video */
 589                 if (ui_mms_data->pagelist[i].isImage) {
 590                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] image file added");
 591                         msg_struct_t added_media = NULL;
 592                         char *filepath = ui_mms_data->pagelist[i].image_file_path;
 593
 594                         msg_mms_add_item(page_info, MSG_STRUCT_MMS_MEDIA, &added_media);
 595                         msg_set_int_value(added_media, MSG_MMS_MEDIA_TYPE_INT, MMS_SMIL_MEDIA_IMG);
 596                         msg_set_str_value(added_media, MSG_MMS_MEDIA_REGION_ID_STR, "Image", strlen("Image"));
 597                         msg_set_str_value(added_media, MSG_MMS_MEDIA_FILEPATH_STR, filepath, strlen(filepath));
 598                 } else if (ui_mms_data->pagelist[i].isVideo) {
 599                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] video file added");
 600                         msg_struct_t added_media = NULL;
 601                         char *filepath = ui_mms_data->pagelist[i].image_file_path;
 602
 603                         msg_mms_add_item(page_info, MSG_STRUCT_MMS_MEDIA, &added_media);
 604                         msg_set_int_value(added_media, MSG_MMS_MEDIA_TYPE_INT, MMS_SMIL_MEDIA_VIDEO);
 605                         msg_set_str_value(added_media, MSG_MMS_MEDIA_REGION_ID_STR, "Image", strlen("Image"));
 606                         msg_set_str_value(added_media, MSG_MMS_MEDIA_FILEPATH_STR, filepath, strlen(filepath));
 607                 }
 608                 /* 3) sound */
 609                 if (ui_mms_data->pagelist[i].isSound) {
 610                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] sound file added");
 611                         msg_struct_t added_media = NULL;
 612                         char *filepath = ui_mms_data->pagelist[i].sound_file_path;
 613
 614                         msg_mms_add_item(page_info, MSG_STRUCT_MMS_MEDIA, &added_media);
 615                         msg_set_int_value(added_media, MSG_MMS_MEDIA_TYPE_INT, MMS_SMIL_MEDIA_AUDIO);
 616                         msg_set_str_value(added_media, MSG_MMS_MEDIA_FILEPATH_STR, filepath, strlen(filepath));
 617                 }
 618         }
 619
 620         D_LEAVE;
 621         return COMPOSER_RETURN_SUCCESS;
 622 }
 623
 624 static COMPOSER_RETURN_TYPE_E __msg_ui_composer_make_mms_message(msg_handle_t msg_handle)
 625 {
 626         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 627
 628         msg_struct_t fw_mms_data = NULL;
 629         MSG_COMP_MMS_DATA_S ui_mms_data = { 0, };
 630
 631         if (msg_data == NULL || msg_data->msgInfo == NULL) {
 632                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] msg_data is NULL !! ");
 633                 return COMPOSER_RETURN_FAIL;
 634         }
 635
 636         ui_mms_data = msg_data->mms_data;
 637
 638         /* set msg type to MMS */
 639         if (msg_set_int_value(msg_data->msgInfo, MSG_MESSAGE_TYPE_INT, MSG_TYPE_MMS) != MSG_SUCCESS) {
 640                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] set message type[MMS] error");
 641                 return COMPOSER_RETURN_FAIL;
 642         }
 643         /* create mms data */
 644         fw_mms_data = msg_create_struct(MSG_STRUCT_MMS);
 645         if (fw_mms_data == NULL) {
 646                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] create mms message error!!");
 647                 return COMPOSER_RETURN_FAIL;
 648         }
 649
 650         /* create smil header <rootlayout> <region> */
 651         if (__msg_ui_composer_make_smil_header(msg_handle, fw_mms_data, ui_mms_data.isTextTop) != COMPOSER_RETURN_SUCCESS) {
 652                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] smil header create error");
 653                 msg_release_struct(&fw_mms_data);
 654                 return COMPOSER_RETURN_FAIL;
 655         }
 656         /* set subject */
 657         int subject_len = strlen(ui_mms_data.subject);
 658         if (ui_mms_data.isSubject == true || subject_len > 0) {
 659                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] Set subject ");
 660                 if (msg_set_str_value(msg_data->msgInfo, MSG_MESSAGE_SUBJECT_STR, ui_mms_data.subject, subject_len) != MSG_SUCCESS)
 661                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR] mms set subject error ");
 662         }
 663         /* set attachment */
 664         if (ui_mms_data.attach_count > 0) {
 665                 int i = 0;
 666                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "ui_mms_data.attach_count = %d", ui_mms_data.attach_count);
 667
 668                 if (ui_mms_data.attach_count > COMPOSER_MMS_MAX_ATTACH_COUNT) {
 669                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR] attachment count error, max count change");
 670                         ui_mms_data.attach_count = COMPOSER_MMS_MAX_ATTACH_COUNT;
 671                 }
 672
 673                 for (i = 0; i < ui_mms_data.attach_count; i++) {
 674                         MSG_COMP_ATTACH_DATA_S *attach_data = &ui_mms_data.attachlist[i];
 675                         if (attach_data == NULL) {
 676                                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] attachment data is NULL");
 677                                 break;
 678                         }
 679                         msg_struct_t attachment = NULL;
 680                         msg_mms_add_item(fw_mms_data, MSG_STRUCT_MMS_ATTACH, &attachment);
 681                         msg_set_str_value(attachment, MSG_MMS_ATTACH_FILEPATH_STR, attach_data->filepath, strlen(attach_data->filepath));
 682                 }
 683         }
 684         /* make body */
 685         /* 1) make page */
 686         __msg_ui_composer_make_mms_body(msg_handle, fw_mms_data);
 687
 688         /* 2) set MMS body */
 689         msg_set_mms_struct(msg_data->msgInfo, fw_mms_data);
 690         msg_release_struct(&fw_mms_data);
 691
 692         /* set recipient */
 693         if (__msg_ui_composer_set_recipient() != COMPOSER_RETURN_SUCCESS) {
 694                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT]__msg_ui_composer_set_recipient error !!");
 695                 return COMPOSER_RETURN_FAIL;
 696         }
 697
 698         return COMPOSER_RETURN_SUCCESS;
 699 }
 700
 701 static COMPOSER_RETURN_TYPE_E __msg_ui_composer_send(msg_handle_t msg_handle)
 702 {
 703         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 704
 705         if (msg_data == NULL || msg_data->msgInfo == NULL) {
 706                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] message is not initialized");
 707                 return COMPOSER_RETURN_FAIL;
 708         }
 709
 710         msg_struct_t req = msg_create_struct(MSG_STRUCT_REQUEST_INFO);
 711         int msg_type = MSG_TYPE_INVALID;
 712         int err;
 713
 714         msg_struct_t sendOpt = NULL;
 715         msg_get_struct_handle(req, MSG_REQUEST_SENDOPT_HND, &sendOpt);
 716         msg_set_bool_value(sendOpt, MSG_SEND_OPT_SETTING_BOOL, false);
 717
 718         msg_set_struct_handle(req, MSG_REQUEST_MESSAGE_HND, msg_data->msgInfo);
 719         msg_get_int_value(msg_data->msgInfo, MSG_MESSAGE_TYPE_INT, &msg_type);
 720
 721         if (msg_is_sms(msg_type)) {
 722                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] try to send sms");
 723                 err = msg_sms_send_message(msg_handle, req);
 724         } else if (msg_is_mms(msg_type)) {
 725                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] try to send mms");
 726                 err = msg_mms_send_message(msg_handle, req);
 727         } else {
 728                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] error message type");
 729                 msg_release_struct(&req);
 730                 return COMPOSER_RETURN_FAIL;
 731         }
 732
 733         msg_release_struct(&req);
 734
 735         if (err == MSG_SUCCESS) {
 736                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] sending success");
 737                 return COMPOSER_RETURN_SUCCESS;
 738         } else if (err == MSG_ERR_INVALID_PARAMETER) {
 739                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] sending failed error code [%d] : INVALID_PARAM ", err);
 740                 return COMPOSER_RETURN_NULL_POINTER;
 741         } else if (err == MSG_ERR_NO_SIM) {
 742                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] sending failed error code [%d] : NO SIM", err);
 743                 return COMPOSER_RETURN_NO_SIM;
 744         } else {
 745                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] sending failed error code [%d]", err);
 746                 return COMPOSER_RETURN_FAIL;
 747         }
 748 }
 749
 750 msg_struct_t msg_ui_composer_message_make_preview(msg_handle_t msg_handle)
 751 {
 752         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 753
 754         if (msg_data == NULL) {
 755                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] can not send message,,, msg_data is NULL");
 756                 return NULL;
 757         }
 758
 759         if (msg_ui_composer_create_new_message() != COMPOSER_RETURN_SUCCESS) {
 760                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR] create new message error !!!");
 761                 return NULL;
 762         }
 763
 764         if (__msg_ui_composer_make_mms_message(msg_handle)
 765             != COMPOSER_RETURN_SUCCESS) {
 766                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR] make mms message error !!!");
 767                 return NULL;
 768         }
 769
 770         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 771         return msg_data->msgInfo;
 772 }
 773
 774 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_make_and_send(msg_handle_t msg_handle, msg_thread_id_t *tid)
 775 {
 776         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 777
 778         if (msg_data == NULL) {
 779                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] can not send message,,, msg_data is NULL");
 780                 return COMPOSER_RETURN_FAIL;
 781         }
 782
 783         COMPOSER_RETURN_TYPE_E ret = COMPOSER_RETURN_SUCCESS;
 784
 785         /* 1. create a new message (create msg_struct_t) */
 786         if (msg_ui_composer_create_new_message() != COMPOSER_RETURN_SUCCESS) {
 787                 return COMPOSER_RETURN_FAIL;
 788         }
 789
 790         /* 2. make message */
 791         if (msg_data->msg_type == COMPOSER_MSG_TYPE_SMS) {
 792                 if (__msg_ui_composer_make_sms_message(msg_handle) != COMPOSER_RETURN_SUCCESS)
 793                         ret =  COMPOSER_RETURN_FAIL;
 794         } else if (msg_data->msg_type == COMPOSER_MSG_TYPE_MMS) {
 795                 if (__msg_ui_composer_make_mms_message(msg_handle) != COMPOSER_RETURN_SUCCESS)
 796                         ret = COMPOSER_RETURN_FAIL;
 797         } else {
 798                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] invalid message type");
 799                 ret = COMPOSER_RETURN_FAIL;
 800         }
 801
 802         /*3. send message */
 803         if (ret != COMPOSER_RETURN_FAIL) {
 804                 ret = __msg_ui_composer_send(msg_handle);
 805
 806                 if (ret == COMPOSER_RETURN_SUCCESS || ret == COMPOSER_RETURN_NO_SIM) {
 807                         msg_struct_list_s *addr_list = NULL;
 808
 809                         msg_get_list_handle(msg_data->msgInfo, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&addr_list);
 810                         msg_get_thread_id_by_address(msg_handle, addr_list, tid);
 811                 }
 812         }
 813
 814         /*4. release message */
 815         msg_release_struct(&msg_data->msgInfo);
 816         msg_data->msgInfo = NULL;
 817
 818         return ret;
 819 }
 820
 821 COMPOSER_RETURN_TYPE_E msg_ui_composer_save_message(msg_handle_t msg_handle)
 822 {
 823         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 824
 825         if (msg_data == NULL) {
 826                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] can not save message,,, msg_data is NULL");
 827                 return COMPOSER_RETURN_FAIL;
 828         }
 829
 830         COMPOSER_RETURN_TYPE_E ret = COMPOSER_RETURN_SUCCESS;
 831
 832         /* 1. create a new message (create msg_struct_t) */
 833         if (msg_ui_composer_create_new_message() != COMPOSER_RETURN_SUCCESS) {
 834                 return COMPOSER_RETURN_FAIL;
 835         }
 836
 837         /* 2. make message */
 838         if (msg_data->msg_type == COMPOSER_MSG_TYPE_SMS) {
 839                 if (__msg_ui_composer_make_sms_message(msg_handle) != COMPOSER_RETURN_SUCCESS)
 840                         ret =  COMPOSER_RETURN_FAIL;
 841         } else if (msg_data->msg_type == COMPOSER_MSG_TYPE_MMS) {
 842                 if (__msg_ui_composer_make_mms_message(msg_handle) != COMPOSER_RETURN_SUCCESS)
 843                         ret = COMPOSER_RETURN_FAIL;
 844         } else {
 845                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] invalid message type");
 846                 ret = COMPOSER_RETURN_FAIL;
 847         }
 848
 849         /*3. save message */
 850         if (ret != COMPOSER_RETURN_FAIL) {
 851                 msg_struct_t sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
 852                 msg_set_bool_value(sendOpt, MSG_SEND_OPT_SETTING_BOOL, false);
 853
 854                 ret = msg_add_message(msg_handle, msg_data->msgInfo, sendOpt);
 855
 856                 msg_release_struct(&sendOpt);
 857         }
 858
 859         /*4. release message */
 860         msg_release_struct(&msg_data->msgInfo);
 861         msg_data->msgInfo = NULL;
 862
 863         return ret;
 864 }
 865
 866 COMPOSER_RETURN_TYPE_E msg_ui_composer_get_message_data(MSG_COMPOSER_VIEW_DATA_S *cd)
 867 {
 868         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 869
 870         if (msg_data == NULL) {
 871                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] can not save message,,, msg_data is NULL");
 872                 return COMPOSER_RETURN_FAIL;
 873         }
 874
 875         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, cd == NULL, COMPOSER_RETURN_FAIL);
 876
 877         if (msg_ui_composer_recipient_read_data(cd) != COMPOSER_RETURN_SUCCESS) {
 878                 D_EMSG("Make recipient data Error");
 879                 return COMPOSER_RETURN_FAIL;
 880         }
 881
 882         if (__msg_ui_composer_body_read_data(cd) != COMPOSER_RETURN_SUCCESS) {
 883                 D_EMSG("Make body data Error");
 884                 return COMPOSER_RETURN_FAIL;
 885         }
 886
 887         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 888
 889         return COMPOSER_RETURN_SUCCESS;
 890 }
 891
 892 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_load_message(msg_handle_t msg_handle, int msgID)
 893 {
 894         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 895
 896         if (!msg_handle) {
 897                 MSG_UI_DEBUG(MSG_UI_LEVEL_ASSERT, "[ASSERT] msg_handle is NULL");
 898                 return COMPOSER_RETURN_NULL_POINTER;
 899         }
 900
 901         msg_struct_t load_msg = NULL;
 902         msg_struct_t sendOpt = NULL;
 903         msg_struct_t mmsBody = NULL;
 904
 905         /* create new message */
 906         load_msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 907         if (load_msg == NULL) {
 908                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR] message create message failed.");
 909                 return COMPOSER_RETURN_FAIL;
 910         }
 911         sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
 912         if (sendOpt == NULL) {
 913                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR] message create sendopt failed.");
 914                 msg_release_struct(&load_msg);
 915                 return COMPOSER_RETURN_FAIL;
 916         }
 917         /* load message */
 918         if (msg_get_message(msg_handle,(msg_message_id_t)msgID, load_msg, sendOpt) != MSG_SUCCESS) {
 919                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR] msg_get_message failed");
 920                 msg_release_struct(&load_msg);
 921                 msg_release_struct(&sendOpt);
 922                 return COMPOSER_RETURN_FAIL;
 923         }
 924
 925         /* load "FROM" address */
 926         msg_struct_list_s *addr_list = NULL;
 927         msg_get_list_handle(load_msg, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&addr_list);
 928
 929         if (addr_list) {
 930                 int addr_count = addr_list->nCount;
 931                 int i = 0;
 932                 char number_str[MAX_ADDRESS_VAL_LEN + 1] = {0,};
 933
 934                 for (i = 0; i < addr_count; i++) {
 935                         memset(number_str, 0, sizeof(number_str));
 936
 937                         msg_get_str_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, number_str, MAX_ADDRESS_VAL_LEN);
 938
 939                         if (strlen(number_str))
 940                                 msg_ui_composer_message_add_address(number_str);
 941                 }
 942         }
 943
 944         /* load message type */
 945         int msgType;
 946         msg_get_int_value(load_msg, MSG_MESSAGE_TYPE_INT, &msgType);
 947
 948         if (msgType == MSG_TYPE_SMS) {
 949                 char *body_text = NULL;
 950                 int body_size = 0;
 951
 952                 msg_data->msg_type = COMPOSER_MSG_TYPE_SMS;
 953
 954                 msg_get_int_value(load_msg, MSG_MESSAGE_DATA_SIZE_INT, &body_size);
 955
 956                 if (body_size > 0)
 957                         body_text = (char *)calloc(1, body_size+1);
 958
 959                 if (body_text)
 960                         msg_get_str_value(load_msg, MSG_MESSAGE_SMS_DATA_STR, body_text, body_size);
 961
 962                 if (body_text && strlen(body_text) > 0) {
 963                         msg_data->sms_data.body_text = strdup(body_text);
 964                         msg_data->sms_data.body_length = strlen(body_text);
 965                 }
 966
 967                 if (body_text)
 968                         free(body_text);
 969
 970         } else if (msgType == MSG_TYPE_MMS) {
 971                 char subject[MAX_SUBJECT_LEN+1] = {0,};
 972                 msg_data->msg_type = COMPOSER_MSG_TYPE_MMS;
 973
 974                 /* load mms body */
 975                 mmsBody = msg_create_struct(MSG_STRUCT_MMS);
 976                 if (mmsBody == NULL) {
 977                         msg_release_struct(&load_msg);
 978                         msg_release_struct(&sendOpt);
 979                         return COMPOSER_RETURN_FAIL;
 980                 }
 981                 msg_get_mms_struct(load_msg, mmsBody);
 982                 /* load subject */
 983                 if (msg_get_str_value(load_msg, MSG_MESSAGE_SUBJECT_STR, subject, MAX_SUBJECT_LEN) != MSG_SUCCESS) {
 984                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] No subject data");
 985                         msg_data->mms_data.isSubject = false;
 986                 } else {
 987                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "[DEBUG] loaded subject : [%s]", subject);
 988                         msg_data->mms_data.isSubject = true;
 989                         strncpy(msg_data->mms_data.subject, subject, COMPOSER_SUBJECT_MAX_BYTE);
 990                 }
 991
 992                 /* load region */
 993                 msg_list_handle_t region_list = NULL;
 994                 msg_get_list_handle(mmsBody, MSG_MMS_REGION_LIST_HND, (void **)&region_list);
 995
 996                 int region_count = msg_list_length(region_list);
 997                 if (region_count >= 2) {
 998                         msg_struct_t region_info_0 = NULL;
 999                         msg_struct_t region_info_1 = NULL;
1000                         bool is_text_top = false;
1001
1002                         region_info_0 = (msg_struct_t)msg_list_nth_data(region_list, 0);
1003                         region_info_1 = (msg_struct_t)msg_list_nth_data(region_list, 1);
1004
1005                         if (msg_ui_composer_check_is_text_top(region_info_0, region_info_1, &is_text_top) == COMPOSER_RETURN_SUCCESS)
1006                                 msg_data->mms_data.isTextTop = is_text_top;
1007                 } else {
1008                         D_EMSG("there is no region info region_count = %d", region_count);
1009                 }
1010
1011                 /* load attachment */
1012                 msg_list_handle_t attach_list = NULL;
1013                 msg_get_list_handle(mmsBody, MSG_MMS_ATTACH_LIST_HND, (void **)&attach_list);
1014                 msg_data->mms_data.attach_count = msg_list_length(attach_list);
1015
1016                 if (msg_data->mms_data.attach_count > 0) {
1017                         int i = 0;
1018
1019                         for (i = 0; i < msg_data->mms_data.attach_count ; i++) {
1020                                 msg_struct_t attach_info = (msg_struct_t)msg_list_nth_data(attach_list, i);
1021
1022                                 if (attach_info == NULL) {
1023                                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR] attachment [%d]th item loading error ", i);
1024                                         continue;
1025                                 }
1026
1027                                 msg_get_int_value(attach_info, MSG_MMS_ATTACH_MIME_TYPE_INT, &msg_data->mms_data.attachlist[i].filetype);
1028                                 msg_get_str_value(attach_info, MSG_MMS_ATTACH_FILEPATH_STR, msg_data->mms_data.attachlist[i].filepath, sizeof(msg_data->mms_data.attachlist[i].filepath));
1029                                 msg_get_str_value(attach_info, MSG_MMS_ATTACH_FILENAME_STR, msg_data->mms_data.attachlist[i].filename, sizeof(msg_data->mms_data.attachlist[i].filename));
1030                         }
1031                 }
1032
1033                 /* load body (page and text, media) */
1034                 msg_list_handle_t page_list = NULL;
1035                 msg_get_list_handle(mmsBody, MSG_MMS_PAGE_LIST_HND, (void **)&page_list);
1036
1037                 msg_data->mms_data.page_count = msg_list_length(page_list);
1038
1039                 if (msg_data->mms_data.page_count > 0) {
1040                         int i = 0;
1041
1042                         for (i = 0; i < msg_data->mms_data.page_count; i++) {
1043                                 msg_struct_t pageInfo = msg_list_nth_data(page_list, i);
1044                                 msg_list_handle_t media_list = NULL;
1045                                 int media_count = 0;
1046
1047                                 if (pageInfo == NULL) {
1048                                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR] MMS PAGE [%d]th page loading error ", i);
1049                                         continue;
1050                                 }
1051
1052                                 /* get page duration */
1053                                 int page_duration = 0;
1054                                 msg_get_int_value(pageInfo, MSG_MMS_PAGE_PAGE_DURATION_INT, &page_duration);
1055                                 if (page_duration % 1000)
1056                                         page_duration = page_duration / 1000 + 1;
1057                                 else
1058                                         page_duration = page_duration / 1000;
1059
1060                                 msg_data->mms_data.pagelist[i].page_duration = page_duration;
1061
1062                                 msg_get_list_handle(pageInfo, MSG_MMS_PAGE_MEDIA_LIST_HND, (void **)&media_list);
1063                                 media_count = msg_list_length(media_list);
1064
1065                                 if (media_count > 0) {
1066                                         int j = 0;
1067
1068                                         for (j = 0; j < media_count; j++) {
1069                                                 msg_struct_t mediaInfo = (msg_struct_t)msg_list_nth_data(media_list, j);
1070                                                 int mediatype;
1071
1072                                                 if (mediaInfo == NULL) {
1073                                                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR] MMS PAGE [%d]th page loading error ", j);
1074                                                         continue;
1075                                                 }
1076
1077                                                 msg_get_int_value(mediaInfo, MSG_MMS_MEDIA_TYPE_INT, &mediatype);
1078                                                 /* if media type image or video */
1079                                                 if (mediatype == MMS_SMIL_MEDIA_IMG) {
1080                                                         msg_data->mms_data.pagelist[i].isImage = true;
1081                                                         msg_get_str_value(mediaInfo, MSG_MMS_MEDIA_FILEPATH_STR, msg_data->mms_data.pagelist[i].image_file_path, sizeof(msg_data->mms_data.pagelist[i].image_file_path));
1082                                                 } else if (mediatype == MMS_SMIL_MEDIA_VIDEO || mediatype == MMS_SMIL_MEDIA_IMG_OR_VIDEO) {
1083                                                         msg_data->mms_data.pagelist[i].isVideo = true;
1084                                                         msg_get_str_value(mediaInfo, MSG_MMS_MEDIA_FILEPATH_STR, msg_data->mms_data.pagelist[i].image_file_path, sizeof(msg_data->mms_data.pagelist[i].image_file_path));
1085                                                 } else if (mediatype == MMS_SMIL_MEDIA_AUDIO) {
1086                                                         msg_data->mms_data.pagelist[i].isSound = true;
1087                                                         msg_get_str_value(mediaInfo, MSG_MMS_MEDIA_FILEPATH_STR, msg_data->mms_data.pagelist[i].sound_file_path, sizeof(msg_data->mms_data.pagelist[i].sound_file_path));
1088                                                 } else if (mediatype == MMS_SMIL_MEDIA_TEXT) {
1089                                                         FILE *fp = NULL;
1090                                                         char filepath[DEF_BUF_LEN_L] = {0,};
1091                                                         msg_get_str_value(mediaInfo, MSG_MMS_MEDIA_FILEPATH_STR, filepath, sizeof(filepath));
1092
1093                                                         if (access(filepath, R_OK) == 0) {
1094                                                                 if (!(fp = fopen(filepath, "r"))) {
1095                                                                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR]File Open Error");
1096                                                                         msg_data->mms_data.pagelist[i].isText = false;
1097                                                                         continue;
1098                                                                 }
1099
1100                                                                 struct stat stat_buf;
1101                                                                 if (stat(filepath, &stat_buf) != 0) {
1102                                                                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR]Getting file information Error");
1103                                                                         msg_data->mms_data.pagelist[i].isText = false;
1104                                                                         fclose(fp);
1105                                                                         continue;
1106                                                                 }
1107
1108                                                                 if (stat_buf.st_size <= 0) {
1109                                                                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR]Getting file size is ZERO");
1110                                                                         msg_data->mms_data.pagelist[i].isText = false;
1111                                                                         fclose(fp);
1112                                                                         continue;
1113                                                                 }
1114
1115                                                                 msg_data->mms_data.pagelist[i].isText = true;
1116
1117                                                                 int result = fread(msg_data->mms_data.pagelist[i].body_text, sizeof(char), stat_buf.st_size, fp);
1118                                                                 if (result != stat_buf.st_size)
1119                                                                         D_EMSG("fread result is different!! result = %d, stat_buf.st_size = %d", result, stat_buf.st_size);
1120
1121                                                                 fclose(fp);
1122                                                         } else {
1123                                                                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR] file access failed");
1124                                                                 msg_data->mms_data.pagelist[i].isText = false;
1125                                                         }
1126
1127                                                 } else {
1128                                                         msg_release_struct(&mmsBody);
1129                                                         msg_release_struct(&load_msg);
1130                                                         msg_release_struct(&sendOpt);
1131                                                         return COMPOSER_RETURN_INVALID_MEDIA_TYPE;
1132                                                 }
1133                                         }
1134                                 }
1135                         }
1136                 }
1137         } else {
1138                 msg_data->msg_type = COMPOSER_MSG_TYPE_INVALID;
1139                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "[ERROR] invalid message type");
1140                 msg_release_struct(&load_msg);
1141                 msg_release_struct(&sendOpt);
1142                 return COMPOSER_RETURN_INVALID_MSG_TYPE;
1143         }
1144
1145         if (msgType == MSG_TYPE_MMS)
1146                 msg_release_struct(&mmsBody);
1147
1148         msg_release_struct(&load_msg);
1149         msg_release_struct(&sendOpt);
1150         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
1151         return COMPOSER_RETURN_SUCCESS;
1152 }
1153
1154 static void __msgc_warning_popup_ok_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1155 {
1156         D_ENTER;
1157         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1158         D_MSG_RETM_IF(cd == NULL, "composer data is NULL");
1159         int page = (int)evas_object_data_get(cd->popup_end, "page_index");
1160
1161         MSGC_EVAS_OBJECT_DEL(cd->popup_end);
1162
1163         cd->body_data.creation_allowed = COMPOSER_CONTENT_CREATION_ALLOWED;
1164
1165         msg_ui_composer_message_set_page_data(cd, page);
1166
1167         cd->body_data.creation_allowed = COMPOSER_CONTENT_CREATION_NONE;
1168
1169         msg_ui_composer_message_destroy();
1170
1171         D_LEAVE;
1172 }
1173
1174 static void __msgc_warning_popup_cancel_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1175 {
1176         D_ENTER;
1177         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1178         D_MSG_RETM_IF(cd == NULL, "composer data is NULL");
1179
1180         int page = (int)evas_object_data_get(cd->popup_end, "page_index");
1181
1182         MSGC_EVAS_OBJECT_DEL(cd->popup_end);
1183
1184         cd->body_data.creation_allowed = COMPOSER_CONTENT_CREATION_NOT_ALLOWED;
1185
1186         msg_ui_composer_message_set_page_data(cd, page);
1187
1188         cd->body_data.creation_allowed = COMPOSER_CONTENT_CREATION_NONE;
1189
1190         msg_ui_composer_message_destroy();
1191
1192         D_LEAVE;
1193 }
1194
1195 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_set_page_data(void *composer_data, int page)
1196 {
1197         D_ENTER;
1198         D_MSG_RETVM_IF(composer_data == NULL, COMPOSER_RETURN_FAIL, "composer data is NULL");
1199         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)composer_data;
1200         int ret = COMPOSER_RETURN_SUCCESS;
1201         static bool is_drm = false;
1202         static bool is_restricted_mode = false;
1203
1204         D_MSG("MMS PAGE COUNT [%d], page = %d", msg_data->mms_data.page_count, page);
1205
1206         if (page > msg_data->mms_data.page_count)
1207                 return COMPOSER_RETURN_FAIL;
1208
1209         for (; page < msg_data->mms_data.page_count; page++) {
1210                 if (msg_data->mms_data.pagelist[page].isImage) {
1211                         ret = msg_ui_composer_body_set_loaded_media(cd, msg_data->mms_data.pagelist[page].image_file_path, COMPOSER_MEDIA_TYPE_IMAGE, page);
1212                 } else if (msg_data->mms_data.pagelist[page].isVideo) {
1213                         ret = msg_ui_composer_body_set_loaded_media(cd, msg_data->mms_data.pagelist[page].image_file_path, COMPOSER_MEDIA_TYPE_VIDEO, page);
1214                 }
1215
1216                 if (msg_data->mms_data.pagelist[page].isSound) {
1217                         ret = msg_ui_composer_body_set_loaded_media(cd, msg_data->mms_data.pagelist[page].sound_file_path, COMPOSER_MEDIA_TYPE_AUDIO, page);
1218                 }
1219
1220                 if (ret == COMPOSER_RETURN_DRM_FORWARDLOCK) {
1221                         D_MSG("ret COMPOSER_RETURN_DRM_FORWARDLOCK");
1222                         is_drm = true;
1223                 } else if (ret == COMPOSER_RETURN_CREATION_RESTRICTED_MODE_FAIL) {
1224                         D_MSG("ret COMPOSER_RETURN_CREATION_RESTRICTED_MODE_FAIL");
1225                         is_restricted_mode = true;
1226                 } else if (ret == COMPOSER_RETURN_CREATION_WARINING_MODE_FAIL) {
1227                         D_MSG("ret COMPOSER_RETURN_CREATION_WARINING_MODE_FAIL");
1228                         MSGC_EVAS_OBJECT_DEL(cd->popup_end);
1229                         /* show warning mode popup */
1230                         Evas_Object *popup = msg_ui_composer_status_popup_show(cd->navi_bar, cd, _MSGSTR("IDS_MSGF_POP_RESTRICTED_CONTENT_TYPE_ATTACH_ANYWAY_Q"), 0);
1231                         Evas_Object *btn1 = elm_button_add(popup);
1232                         elm_object_style_set(btn1, "popup_button/default");
1233                         elm_object_text_set(btn1, MSGC_STR_BUTTON_OK);
1234                         elm_object_part_content_set(popup, "button1", btn1);
1235                         evas_object_smart_callback_add(btn1, "clicked", __msgc_warning_popup_ok_btn_clicked_cb, cd);
1236
1237                         Evas_Object *btn2 = elm_button_add(popup);
1238                         elm_object_style_set(btn2, "popup_button/default");
1239                         elm_object_text_set(btn2, MSGC_STR_BUTTON_CANCEL);
1240                         elm_object_part_content_set(popup, "button2", btn2);
1241                         evas_object_smart_callback_add(btn2, "clicked", __msgc_warning_popup_cancel_btn_clicked_cb, cd);
1242                         cd->popup_end = popup;
1243
1244                         evas_object_data_set(popup, "page_index", (void *)page);
1245
1246                         return ret;
1247                 }
1248
1249                 if (msg_data->mms_data.pagelist[page].isText) {
1250                         msg_ui_composer_body_set_loaded_text(cd, msg_data->mms_data.pagelist[page].body_text, page);
1251                 }
1252
1253                 /* set page duration */
1254                 msg_ui_composer_body_set_loaded_page_duration(cd, msg_data->mms_data.pagelist[page].page_duration, page);
1255         }
1256
1257         if (is_drm) {
1258                 /* show drm forwardlock popup */
1259                 Evas_Object *popup = msg_ui_composer_status_popup_show(cd->navi_bar, cd, MSGC_STR_POP_FILE_IS_FORWARD_LOCK, 0);
1260                 Evas_Object *btn1 = elm_button_add(popup);
1261                 elm_object_style_set(btn1, "popup_button/default");
1262                 elm_object_text_set(btn1, MSGC_STR_BUTTON_CLOSE);
1263                 elm_object_part_content_set(popup, "button1", btn1);
1264                 evas_object_smart_callback_add(btn1, "clicked", msg_ui_composer_status_popup_response_cb, popup);
1265         } else if (is_restricted_mode) {
1266                 /* show restricted mode popup */
1267                 Evas_Object *popup = msg_ui_composer_status_popup_show(cd->navi_bar, cd, _MSGSTR("Unsupported media type"), 0);
1268                 Evas_Object *btn1 = elm_button_add(popup);
1269                 elm_object_style_set(btn1, "popup_button/default");
1270                 elm_object_text_set(btn1, MSGC_STR_BUTTON_CLOSE);
1271                 elm_object_part_content_set(popup, "button1", btn1);
1272                 evas_object_smart_callback_add(btn1, "clicked", msg_ui_composer_status_popup_response_cb, popup);
1273         }
1274
1275         is_drm = false;
1276         is_restricted_mode = false;
1277
1278         D_LEAVE;
1279         return COMPOSER_RETURN_SUCCESS;
1280 }
1281
1282 COMPOSER_RETURN_TYPE_E msg_ui_composer_message_set_loaded_data(void *composer_data, bool set_recipient)
1283 {
1284         D_ENTER;
1285         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)composer_data;
1286         int i = 0;
1287         int ret = COMPOSER_RETURN_SUCCESS;
1288
1289         /* recipient */
1290         if (set_recipient) {
1291                 if (msg_data->recp_list) {
1292
1293                         int count = g_slist_length(msg_data->recp_list);
1294                         char *address = NULL;
1295
1296                         for (i = 0; i < count; i++) {
1297                                 address = (char *)g_slist_nth_data(msg_data->recp_list, i);
1298
1299                                 if (address)
1300                                         msg_ui_composer_recipient_set_loaded_data(cd, address, 0);
1301                         }
1302                 }
1303         }
1304
1305         if (msg_data->msg_type == COMPOSER_MSG_TYPE_SMS) {
1306                 msg_ui_composer_body_set_loaded_text(cd, msg_data->sms_data.body_text, 0);
1307                 return COMPOSER_RETURN_SUCCESS;
1308         }
1309
1310         /* subject */
1311         if (msg_data->mms_data.isSubject)
1312                 msg_ui_composer_subject_set_loaded_data(cd, msg_data->mms_data.subject);
1313
1314         /* region */
1315         if (msg_data->mms_data.isTextTop)
1316                 cd->body_data.region_order = COMPOSER_REGION_ORDER_TEXT_TOP;
1317         else
1318                 cd->body_data.region_order = COMPOSER_REGION_ORDER_IMAGE_TOP;
1319
1320         /* attachment */
1321         for (i = 0; i < msg_data->mms_data.attach_count; i++) {
1322                 char *filepath = msg_data->mms_data.attachlist[i].filepath;
1323                 int filetype = msg_data->mms_data.attachlist[i].filetype;
1324
1325                 msg_ui_composer_attachment_set_loaded_data(cd, filepath, filetype);
1326         }
1327
1328         /* body page data*/
1329         ret = msg_ui_composer_message_set_page_data(cd, 0);
1330
1331         if (ret == COMPOSER_RETURN_CREATION_WARINING_MODE_FAIL)
1332                 return ret;
1333
1334         D_LEAVE;
1335         return COMPOSER_RETURN_SUCCESS;
1336 }