composer/src/ui-composer/msg-ui-composer-main.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 /* includes*/
  18 #include <Ecore_X.h>
  19 #include <tapi_common.h>
  20 #include <TapiUtility.h>
  21 #include <utilX.h>
  22
  23 #include "msg-ui-composer-main.h"
  24 #include "msg-ui-composer-recipient.h"
  25 #include "msg-ui-composer-popup.h"
  26 #include "msg-ui-composer-predictsearch.h"
  27 #include "msg-ui-composer-subject.h"
  28 #include "msg-ui-composer-body.h"
  29 #include "msg-ui-composer-pageduration.h"
  30 #include "msg-ui-composer-message.h"
  31 #include "msg-ui-composer-common.h"
  32 #include "msg-ui-composer-external.h"
  33 #include "msg-ui-composer-bubble.h"
  34 #include "msg-ui-composer-main.h"       /*for page duration, it should be removed if more option concept is changed*/
  35
  36 #include "msg-ui-common-utility.h"
  37
  38 #define COMPOSER_BUNDLE_ATTACH_TOKEN "\n"
  39 #define COMPOSER_BUNDLE_RECP_TOKEN ","
  40
  41 /*==================================================================================================
  42 *                                                               FUNCTION IMPLEMENTATIONS
  43 *==================================================================================================*/
  44 static COMPOSER_EDIT_STATE_E __msg_ui_composer_edit_check(MSG_COMPOSER_VIEW_DATA_S *cd)
  45 {
  46         D_ENTER;
  47         D_MSG_RETVM_IF(cd == NULL, COMPOSER_EDIT_NONE, "Composer Data == NULL");
  48
  49         bool isvalid_address = false;
  50         bool iscontent_edited = false;
  51
  52         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
  53                 int recipient_count = msg_ui_composer_recipient_count_get(cd->recipient);
  54                 if (recipient_count > 0) {
  55                         isvalid_address = true;
  56                 }
  57
  58                 const char *entry_str = msg_ui_composer_recipient_entry_text_get(cd->recipient);
  59                 if (entry_str && strlen(entry_str)) {
  60                         if (msg_ui_composer_recipient_vaild_check(entry_str) == EINA_TRUE)
  61                                 isvalid_address = true;
  62                 }
  63         } else if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
  64                 isvalid_address = true;
  65         }
  66
  67         /* valid address & there is body content */
  68         if (msg_ui_composer_common_is_send_possible(cd) == true)
  69                 iscontent_edited = true;
  70
  71         if (isvalid_address && iscontent_edited)
  72                 return COMPOSER_EDIT_RECIPIENT_AND_BODY;
  73         else if (isvalid_address)
  74                 return COMPOSER_EDIT_RECIPIENT;
  75         else if (iscontent_edited)
  76                 return COMPOSER_EDIT_BODY;
  77         else
  78                 return COMPOSER_EDIT_NONE;
  79 }
  80
  81 static void __msgc_vconf_changed_cb(keynode_t *key, void *data)
  82 {
  83         D_ENTER;
  84
  85         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
  86         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
  87         D_MSG_RETM_IF(key == NULL, "key is NULL");
  88
  89         int index = 0;
  90         int font_size = 0;
  91         int converted_size = 0;
  92         char *key_name = NULL;
  93
  94         key_name = vconf_keynode_get_name(key);
  95         if (!key_name) {
  96                 D_EMSG("key_name is NULL");
  97                 return;
  98         }
  99
 100         if (!strcmp(key_name, VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE)) {
 101                 index = vconf_keynode_get_int(key);
 102                 font_size = msg_common_get_font_size_from_index(index);
 103                 converted_size = (MSGC_BODY_FONT_SIZE * font_size) / MSG_APP_FONT_SIZE_NORMAL;
 104
 105                 cd->font_size = converted_size;
 106
 107                 /* sync current font size as accessibility font index */
 108                 if (msg_common_set_font_size(index) == FALSE)
 109                         D_EMSG("msg_common_set_font_size(index = %d) is failed !!", index);
 110
 111                 /* sync msg accessibility font size with accessibility font index */
 112                 if (msg_common_set_access_font_size(index) == FALSE)
 113                         D_EMSG("vconf_set_int(VCONFKEY_MSG_APP_ACCESS_FONT_SIZE) is failed !!, [%d]", index);
 114         } else if (!strcmp(key_name, VCONFKEY_MSG_APP_FONT_SIZE)) {
 115                 index = vconf_keynode_get_int(key);
 116                 font_size = msg_common_get_font_size_from_index(index);
 117                 converted_size = (MSGC_BODY_FONT_SIZE * font_size) / MSG_APP_FONT_SIZE_NORMAL;
 118
 119                 cd->font_size = converted_size;
 120         } else {
 121                 D_EMSG("key did not match.");
 122         }
 123
 124         D_MSG("font size = %d", font_size);
 125         D_MSG("converted font size = %d", converted_size);
 126
 127         D_LEAVE;
 128 }
 129
 130 static void __msgc_init_font_size(MSG_COMPOSER_VIEW_DATA_S *cd)
 131 {
 132         D_ENTER;
 133         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
 134
 135         int index = 0;
 136         int access_font_index = 0;
 137         int msg_access_font_index = 0;
 138         int font_size = 0;
 139         int converted_size = 0;
 140
 141         /* get msg accessibility font index */
 142         if (msg_common_get_access_font_size(&msg_access_font_index) == FALSE) {
 143                 D_EMSG("msg_common_get_access_font_size is failed !!");
 144                 msg_access_font_index = MSG_APP_FONT_SIZE_INDEX_NORMAL; /* 1 */
 145         }
 146
 147         /* get accessibility font index */
 148         if (vconf_get_int(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, &access_font_index) < 0) {
 149                 D_EMSG("vconf_get_int(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE) is failed !!");
 150                 access_font_index = MSG_SYS_FONT_SIZE_INDEX_NORMAL;     /* 1 */
 151         }
 152
 153         if (msg_common_get_font_size(&index) == FALSE) {
 154                 D_EMSG("msg_common_get_font_size() is failed");
 155                 cd->font_size = MSGC_BODY_FONT_SIZE;
 156                 return;
 157         } else {
 158                 D_MSG("selected font_size index = %d", index);
 159         }
 160
 161         D_MSG("VCONFKEY_MSG_APP_ACCESS_FONT_SIZE = %d", msg_access_font_index);
 162         D_MSG("VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE = %d", access_font_index);
 163
 164         if (msg_access_font_index != access_font_index) {
 165                 font_size = msg_common_get_font_size_from_index(access_font_index);
 166
 167                 /* sync current font size as accessibility font index */
 168                 if (msg_common_set_font_size(access_font_index) == FALSE)
 169                         D_EMSG("msg_common_set_font_size(index = %d) is failed !!", access_font_index);
 170
 171                 /* sync msg accessibility font size with accessibility font index */
 172                 if (msg_common_set_access_font_size(access_font_index) == FALSE)
 173                         D_EMSG("vconf_set_int(VCONFKEY_MSG_APP_ACCESS_FONT_SIZE) is failed !!, [%d]", access_font_index);
 174         } else {
 175                 font_size = msg_common_get_font_size_from_index(index);
 176         }
 177
 178         converted_size = (MSGC_BODY_FONT_SIZE * font_size) / MSG_APP_FONT_SIZE_NORMAL;
 179
 180         cd->font_size = converted_size;
 181         D_MSG("font size = %d, converted_size = %d", font_size, converted_size);
 182
 183         D_LEAVE;
 184 }
 185
 186 static void __msgc_parse_recipient_list(MSG_COMPOSER_VIEW_DATA_S *cd, const char *address)
 187 {
 188         D_ENTER;
 189         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
 190         D_MSG_RETM_IF(address == NULL, "address is NULL");
 191
 192         bool bMaxCount = false;
 193         bool bInvalidNum = false;
 194         bool bDup = false;
 195
 196         Eina_List *recipient_list = make_tokenize_list(address, ",");
 197
 198         if (recipient_list) {
 199                 Eina_List *l = NULL;
 200                 char *recipient;
 201                 EINA_LIST_FOREACH(recipient_list, l, recipient) {
 202                         if (recipient) {
 203                                 D_MSG("TO = %s", recipient);
 204                                 if (msg_ui_composer_recipient_count_get(cd->recipient) >= COMPOSER_RECIPIENT_COUNT_MAX) {
 205                                         bMaxCount = true;
 206                                         g_free(recipient);
 207                                         break;
 208                                 }
 209
 210                                 if (msg_ui_composer_recipient_duplicate_check(cd->recipient, recipient) == COMPOSER_RETURN_RECIPIENT_DUPLICATE) {
 211                                         bDup = true;
 212                                         g_free(recipient);
 213                                         continue;
 214                                 }
 215
 216                                 if (msg_ui_composer_recipient_vaild_check(recipient) == EINA_FALSE) {
 217                                         bInvalidNum = true;
 218                                 } else {
 219                                         msg_ui_composer_recipient_append(cd->recipient, recipient, 0);
 220                                 }
 221
 222                                 g_free(recipient);
 223                         }
 224                 }
 225
 226                 D_MSG("bMaxCount = %d, bInvalidNum = %d, bDup = %d", bMaxCount, bInvalidNum, bDup);
 227                 if (bMaxCount) {
 228                         msg_ui_composer_common_tickernoti(cd, COMPOSER_TICKERNOTI_COUNT_MAX);
 229                 } else if (bInvalidNum) {
 230                         msg_ui_composer_status_btn_popup_show(cd, MSGC_STR_NOTI_RECIPIENT_INVALID, 0, MSGC_STR_BUTTON_OK);
 231                 } else if (bDup) {
 232                         msg_ui_composer_common_tickernoti(cd, COMPOSER_TICKERNOTI_DUP_RECP);
 233                 }
 234         }
 235
 236         D_LEAVE;
 237 }
 238
 239 static void __msgc_ui_parse_mmsto_uri(MSG_COMPOSER_VIEW_DATA_S *cd, service_h svc_handle, const char *uri)
 240 {
 241         D_ENTER;
 242         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
 243         D_MSG_RETM_IF(svc_handle == NULL, "svc_handle is NULL");
 244         D_MSG_RETM_IF(uri == NULL, "uri is NULL");
 245
 246         char *content = NULL;
 247         char *recipient = NULL;
 248         char *body_text = NULL;
 249         char *subject = NULL;
 250         char *attachment = NULL;
 251         char *cc = NULL;
 252         char *scheme = g_strdup(uri);
 253
 254         if (scheme) {
 255                 strtok_r(scheme, ":", &content);
 256
 257                 if (content) {
 258                         if (g_ascii_isdigit(content[0]) || (content[0] == '+' && g_ascii_isdigit(content[1]))) {
 259                                 recipient = strtok_r(NULL, "?", &content);
 260                                 cc = strtok_r(NULL, "&", &content);
 261                                 if (cc)
 262                                         strtok_r(NULL, "=", &cc);
 263
 264                                 D_MSG("RECIPIENT = [%s]", recipient);
 265                                 if (recipient)
 266                                         __msgc_parse_recipient_list(cd, (const char *)recipient);
 267                         }
 268                 }
 269                 g_free(scheme);
 270         } else {
 271                 if ((service_get_extra_data(svc_handle, SERVICE_DATA_TO, &recipient) == SERVICE_ERROR_NONE) && recipient) {
 272                         __msgc_parse_recipient_list(cd, (const char *)recipient);
 273                 }
 274         }
 275
 276         if ((service_get_extra_data(svc_handle, SERVICE_DATA_TEXT, &body_text) == SERVICE_ERROR_NONE) && body_text)
 277                 msg_ui_composer_body_set_loaded_text(cd, (const char *)body_text, 0);
 278
 279         if ((service_get_extra_data(svc_handle, SERVICE_DATA_SUBJECT, &subject) == SERVICE_ERROR_NONE) && subject)
 280                 msg_ui_composer_subject_set_loaded_data(cd, (const char *)subject);
 281
 282         if ((service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_ATTACHFILE, &attachment) == SERVICE_ERROR_NONE) && attachment) {
 283                 cd->attachlist = make_tokenize_list((const char *)attachment, COMPOSER_BUNDLE_ATTACH_TOKEN);
 284                 if (cd->attachlist)
 285                         msg_ui_composer_body_items_add(cd);
 286         }
 287
 288         D_LEAVE;
 289 }
 290
 291 static void __msgc_ui_parse_file_uri(MSG_COMPOSER_VIEW_DATA_S *cd, service_h svc_handle, const char *uri)
 292 {
 293         D_ENTER;
 294         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
 295         D_MSG_RETM_IF(uri == NULL, "uri is NULL");
 296
 297         char *content = NULL;
 298         char attachment[DEF_IMG_PATH_LEN + 1] = {0, };
 299         int i = 0;
 300         int len = 0;
 301         char *scheme = g_strdup(uri);
 302
 303         if (scheme) {
 304                 strtok_r(scheme, ":", &content);
 305                 D_MSG("content = [%s]", content);
 306
 307                 if (content) {
 308                         len = strlen(content) - 2;
 309                         if (len <= 0) {
 310                                 D_EMSG("len is less than 0 !!");
 311                                 g_free(scheme);
 312                                 return;
 313                         }
 314
 315                         /* Remove '//' from content string */
 316                         for (i = 0; i < len; i++) {
 317                                 attachment[i] = content[i+2];
 318                         }
 319
 320                         if (attachment[0] != '\0') {
 321                                 D_MSG("APPSVC ATTACHMENT = [%s]", attachment);
 322                                 cd->attachlist = make_tokenize_list((const char *)attachment, COMPOSER_BUNDLE_ATTACH_TOKEN);
 323                                 if (cd->attachlist)
 324                                         msg_ui_composer_body_items_add(cd);
 325                         }
 326                 }
 327                 g_free(scheme);
 328         } else {
 329                 D_EMSG("scheme is NULL!!");
 330         }
 331
 332         D_LEAVE;
 333 }
 334
 335 static void __msg_ui_parse_sms_uri(MSG_COMPOSER_VIEW_DATA_S *cd, service_h svc_handle, const char *uri)
 336 {
 337         D_ENTER;
 338         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
 339         D_MSG_RETM_IF(svc_handle == NULL, "svc_handle is NULL");
 340         D_MSG_RETM_IF(uri == NULL, "uri is NULL");
 341
 342         char *content = NULL;
 343         char *recipient = NULL;
 344         char *body_text = NULL;
 345         char *scheme = g_strdup(uri);
 346
 347         if (scheme) {
 348                 strtok_r(scheme, ":", &content);
 349
 350                 if (content) {
 351                         if (g_ascii_isdigit(content[0]) || (content[0] == '+' && g_ascii_isdigit(content[1]))) {
 352                                 recipient = strtok_r(NULL, "?", &content);
 353                                 D_MSG("RECIPIENT = [%s]", recipient);
 354
 355                                 if (recipient)
 356                                         __msgc_parse_recipient_list(cd, (const char *)recipient);
 357                         }
 358                 }
 359                 g_free(scheme);
 360         } else {
 361                 if ((service_get_extra_data(svc_handle, SERVICE_DATA_TO, &recipient) == SERVICE_ERROR_NONE) && recipient)
 362                         __msgc_parse_recipient_list(cd, (const char *)recipient);
 363         }
 364
 365         if ((service_get_extra_data(svc_handle, SERVICE_DATA_TEXT, &body_text) == SERVICE_ERROR_NONE) && body_text)
 366                 msg_ui_composer_body_set_loaded_text(cd, (const char *)body_text, 0);
 367
 368         D_LEAVE;
 369 }
 370
 371 static void __msgc_get_service_app_svc_op(MSG_COMPOSER_VIEW_DATA_S *cd, service_h svc_handle, char *operation)
 372 {
 373         D_ENTER;
 374         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
 375         D_MSG_RETM_IF(svc_handle == NULL, "svc_handle is NULL");
 376         D_MSG_RETM_IF(operation == NULL, "operation is NULL");
 377
 378         char *uri = NULL;
 379         char *recipient = NULL;
 380         char *body_text = NULL;
 381         char *attachment = NULL;
 382         char *subject = NULL;
 383
 384         if (g_strcmp0(operation, SERVICE_OPERATION_SEND) == 0) {
 385                 if (service_get_uri(svc_handle, &uri) == SERVICE_ERROR_NONE)
 386                         D_MSG("URI = [%s]", uri);
 387
 388                 if (uri) {
 389                         if (g_str_has_prefix(uri, MSG_BUNDLE_VALUE_MMSTO_URI)) { /* MMS URI : mmsto */
 390                                  __msgc_ui_parse_mmsto_uri(cd, svc_handle, (const char *)uri);
 391                         } else if (g_str_has_prefix(uri, MSG_BUNDLE_VALUE_FILE_URI)) { /* URI : file */
 392                                  __msgc_ui_parse_file_uri(cd, svc_handle, (const char *)uri);
 393                         } else if (g_str_has_prefix(uri, "/")) {
 394                                 cd->attachlist = make_tokenize_list((const char *)uri, COMPOSER_BUNDLE_ATTACH_TOKEN);
 395                                 if (cd->attachlist)
 396                                         msg_ui_composer_body_items_add(cd);
 397                         } else {
 398                                 D_EMSG("Not supported URI type");
 399                                 return;
 400                         }
 401                 } else {
 402                         if ((service_get_extra_data(svc_handle, SERVICE_DATA_TO, &recipient) == SERVICE_ERROR_NONE) && recipient)
 403                                 __msgc_parse_recipient_list(cd, (const char *)recipient);
 404
 405                         if ((service_get_extra_data(svc_handle, SERVICE_DATA_TEXT, &body_text) == SERVICE_ERROR_NONE) && body_text)
 406                                 msg_ui_composer_body_set_loaded_text(cd, (const char *)body_text, 0);
 407
 408                         if ((service_get_extra_data(svc_handle, SERVICE_DATA_SUBJECT, &subject) == SERVICE_ERROR_NONE) && subject)
 409                                 msg_ui_composer_subject_set_loaded_data(cd, (const char *)subject);
 410
 411                         if ((service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_ATTACHFILE, &attachment) == SERVICE_ERROR_NONE) && attachment) {
 412                                 cd->attachlist = make_tokenize_list((const char *)attachment, COMPOSER_BUNDLE_ATTACH_TOKEN);
 413                                 if (cd->attachlist)
 414                                         msg_ui_composer_body_items_add(cd);
 415                         }
 416                 }
 417         } else if (g_strcmp0(operation, SERVICE_OPERATION_SEND_TEXT) == 0) {
 418                 if (service_get_uri(svc_handle, &uri) == SERVICE_ERROR_NONE)
 419                         D_MSG("URI = [%s]", uri);
 420
 421                 if (uri) {
 422                         if (g_str_has_prefix(uri, MSG_BUNDLE_VALUE_SMS_URI)) {  /* SMS URI : sms */
 423                                 __msg_ui_parse_sms_uri(cd, svc_handle, (const char *)uri);
 424                         } else {
 425                                 D_EMSG("Not supported mime type");
 426                                 return;
 427                         }
 428                 } else {
 429                         if ((service_get_extra_data(svc_handle, SERVICE_DATA_TO, &recipient) == SERVICE_ERROR_NONE) && recipient)
 430                                 __msgc_parse_recipient_list(cd, (const char *)recipient);
 431
 432                         if ((service_get_extra_data(svc_handle, SERVICE_DATA_TEXT, &body_text) == SERVICE_ERROR_NONE) && body_text)
 433                                 msg_ui_composer_body_set_loaded_text(cd, (const char *)body_text, 0);
 434                 }
 435         } else {
 436                 D_EMSG("Invalid operation type !!");
 437         }
 438
 439         D_LEAVE;
 440 }
 441
 442 /* function definitions*/
 443 static void __msg_ui_composer_bundle_data_process(MSG_COMPOSER_VIEW_DATA_S *cd, service_h svc_handle)
 444 {
 445         D_ENTER;
 446         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
 447         D_MSG_RETM_IF(svc_handle == NULL, "Bundle Data is NULL");
 448
 449         char *bundle_txt = NULL;
 450
 451         if (cd->isAppControl) { /* composer launching from appcontrol */
 452                 char *operation = NULL;
 453
 454                 service_get_operation(svc_handle, &operation);
 455                 __msgc_get_service_app_svc_op(cd, svc_handle, operation);
 456         } else {
 457                 if (cd->composer_mode == MSG_COMPOSER_MODE_EDIT || cd->composer_mode == MSG_COMPOSER_MODE_FORWARD) {
 458                         if ((service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_MSG_ID, &bundle_txt) == SERVICE_ERROR_NONE) && bundle_txt) {
 459                                 bool set_recipient = false;
 460                                 int msg_id = atoi(bundle_txt);
 461
 462                                 if (cd->composer_mode == MSG_COMPOSER_MODE_EDIT) {
 463                                         cd->msg_id = msg_id;
 464                                         set_recipient = true;
 465                                 }
 466
 467                                 msg_ui_composer_message_init();
 468                                 msg_ui_composer_message_load_message(cd->msg_handle, msg_id);
 469                                 if (msg_ui_composer_message_set_loaded_data(cd, set_recipient) != COMPOSER_RETURN_CREATION_WARINING_MODE_FAIL)
 470                                         msg_ui_composer_message_destroy();
 471
 472                         } else {
 473                                 D_EMSG("there is no msgid");
 474                         }
 475                 } else {
 476                         if ((service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_TO, &bundle_txt) == SERVICE_ERROR_NONE) && bundle_txt) {
 477                                 __msgc_parse_recipient_list(cd, bundle_txt);
 478                         } else {
 479                                 if ((service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_NUMBER_INDEX, &bundle_txt)== SERVICE_ERROR_NONE) && bundle_txt) {
 480                                         char *recipient = NULL;
 481                                         char *index  = NULL;
 482                                         char *save_p = NULL;
 483                                         int idx = 0;
 484
 485                                         char *copy_string = MSG_STRDUP(bundle_txt);
 486                                         if (copy_string) {
 487
 488                                                 recipient = strtok_r(copy_string, "/", &save_p);
 489                                                 if (recipient) {
 490                                                         index = strtok_r(NULL, "/", &save_p);
 491                                                         if (index) {
 492                                                                 D_MSG("NUMBER_INDEX = %s[%s]", recipient, index);
 493                                                                 idx = atoi(index);
 494                                                         } else {
 495                                                                 idx = 0;
 496                                                         }
 497
 498                                                         if (msg_ui_composer_recipient_count_get(cd->recipient) >= COMPOSER_RECIPIENT_COUNT_MAX) {
 499                                                                 msg_ui_composer_common_tickernoti(cd, COMPOSER_TICKERNOTI_COUNT_MAX);
 500                                                         } else {
 501                                                                 if (msg_ui_composer_recipient_duplicate_check(cd->recipient, recipient) == COMPOSER_RETURN_RECIPIENT_DUPLICATE) {
 502                                                                         msg_ui_composer_common_tickernoti(cd, COMPOSER_TICKERNOTI_DUP_RECP);
 503                                                                 } else {
 504                                                                         if (msg_ui_composer_recipient_vaild_check(recipient) == EINA_FALSE) {
 505                                                                                 msg_ui_composer_status_btn_popup_show(cd, MSGC_STR_NOTI_RECIPIENT_INVALID, 0, MSGC_STR_BUTTON_OK);
 506                                                                         } else {
 507                                                                                 msg_ui_composer_recipient_append(cd->recipient, recipient, idx);
 508                                                                         }
 509                                                                 }
 510                                                         }
 511                                                 }
 512
 513                                                 g_free(copy_string);
 514                                         }
 515                                 }
 516                         }
 517
 518                         if (SERVICE_ERROR_NONE == service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_SUBJECT, &bundle_txt))
 519                                 msg_ui_composer_subject_set_loaded_data(cd, bundle_txt);
 520
 521                         if (SERVICE_ERROR_NONE == service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_BODY, &bundle_txt))
 522                                 msg_ui_composer_body_set_loaded_text(cd, bundle_txt, 0);
 523
 524                         if (SERVICE_ERROR_NONE == service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_ATTACHFILE, &bundle_txt)) {
 525                                 cd->attachlist = make_tokenize_list(bundle_txt, COMPOSER_BUNDLE_ATTACH_TOKEN);
 526                                 if (cd->attachlist)
 527                                         msg_ui_composer_body_items_add(cd);
 528                         }
 529                 }
 530         }
 531
 532         D_LEAVE;
 533 }
 534
 535 static void __msg_ui_composer_sent_status_cb(msg_handle_t Handle, msg_struct_t pStatus, void *pUserParam)
 536 {
 537         D_ENTER;
 538         D_LEAVE;
 539
 540         return;
 541 }
 542
 543 static void __end_popup_ok_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 544 {
 545         D_ENTER;
 546         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
 547         D_MSG_RETM_IF(cd == NULL, "composer data is NULL");
 548
 549         MSGC_EVAS_OBJECT_DEL(cd->popup_end);
 550
 551         ug_destroy_me(cd->ug);
 552 }
 553
 554 static void __end_popup_cancel_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 555 {
 556         D_ENTER;
 557         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
 558         D_MSG_RETM_IF(cd == NULL, "composer data is NULL");
 559
 560         MSGC_EVAS_OBJECT_DEL(cd->popup_end);
 561
 562         cd->isclosed = false;
 563
 564         msg_ui_composer_last_focus_load(cd);
 565         D_LEAVE;
 566 }
 567
 568 static void  __msg_ui_composer_end_popup(MSG_COMPOSER_VIEW_DATA_S *cd)
 569 {
 570         D_ENTER;
 571
 572         MSGC_EVAS_OBJECT_DEL(cd->popup_end);
 573
 574         Evas_Object *popup = msg_ui_composer_status_popup_show(cd->main_window, cd, MSGC_STR_POP_DISCARD_Q, 0);
 575         Evas_Object *btn1 = elm_button_add(popup);
 576         elm_object_style_set(btn1, "popup_button/default");
 577         elm_object_text_set(btn1, MSGC_STR_BUTTON_OK);
 578         elm_object_part_content_set(popup, "button1", btn1);
 579         evas_object_smart_callback_add(btn1, "clicked", __end_popup_ok_btn_clicked_cb, cd);
 580         Evas_Object *btn2 = elm_button_add(popup);
 581         elm_object_style_set(btn2, "popup_button/default");
 582         elm_object_text_set(btn2, MSGC_STR_BUTTON_CANCEL);
 583         elm_object_part_content_set(popup, "button2", btn2);
 584         evas_object_smart_callback_add(btn2, "clicked", __end_popup_cancel_btn_clicked_cb, cd);
 585         elm_object_focus_allow_set(popup, EINA_TRUE);
 586         elm_object_focus_set(popup, EINA_TRUE);
 587         evas_object_show(popup);
 588
 589         cd->popup_end = popup;
 590
 591         D_LEAVE;
 592         return;
 593 }
 594
 595 static void __naviframe_back_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 596 {
 597         D_ENTER;
 598         D_MSG_RETM_IF(data == NULL, "Data == NULL");
 599         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
 600
 601         COMPOSER_EDIT_STATE_E edit_state = __msg_ui_composer_edit_check(cd);
 602         D_MSG("edit_state = %d", edit_state);
 603
 604         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
 605                 if (cd->isclosed) {
 606                         D_EMSG("back btn is already called");
 607                         return;
 608                 }
 609
 610                 /* isclosed is set to prevent showing invalid popup*/
 611                 cd->isclosed = true;
 612
 613                 if (edit_state == COMPOSER_EDIT_RECIPIENT || edit_state == COMPOSER_EDIT_BODY) {
 614                         __msg_ui_composer_end_popup(cd);
 615                         return;
 616                 }
 617         } else if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
 618                 if (edit_state == COMPOSER_EDIT_RECIPIENT) {
 619
 620                         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
 621
 622                         if (bubble_data->title_menu_opened)
 623                                 msg_ui_bubble_close_title_menu_genlist(bubble_data);
 624
 625                         if (bubble_data->bubble_count == 0) {
 626                                 int err = MSG_SUCCESS;
 627
 628                                 if (bubble_data->isDraft == true)
 629                                         err = msg_delete_thread_message_list(bubble_data->msgHandle, bubble_data->threadId, false);
 630
 631                                 if (err == MSG_SUCCESS) {
 632                                         service_h svc_handle;
 633                                         char buf[DEF_BUF_LEN_S] = {0,};
 634
 635                                         if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
 636                                                 D_EMSG("service_create() is failed !!");
 637                                         } else {
 638                                                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_RESULT, MSG_BUNDLE_VALUE_DEL_ALL);
 639                                                 snprintf(buf, sizeof(buf), "%d", bubble_data->threadId);
 640                                                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_THREAD_ID, buf);
 641                                                 ug_send_result(cd->ug, svc_handle);
 642
 643                                                 service_destroy(svc_handle);
 644                                         }
 645                                 } else {
 646                                         D_MSG("msg_delete_thread_message_list failed");
 647                                 }
 648                         }
 649                 }
 650         }
 651
 652         ug_destroy_me(cd->ug);
 653
 654         D_LEAVE;
 655 }
 656
 657 static void __preview_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 658 {
 659         D_ENTER;
 660         MSG_COMPOSER_VIEW_DATA_S *cd = data;
 661         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
 662         D_MSG_RETM_IF(cd->navi_it == NULL, "Naviitem is NULL");
 663
 664         msg_struct_t msgInfo = NULL;
 665         msg_ui_composer_message_init();
 666         msg_ui_composer_read_preview_message(cd);
 667
 668         /* make preview message data */
 669         msgInfo = msg_ui_composer_message_make_preview(cd->msg_handle);
 670
 671         if (msgInfo)
 672                 msg_ui_composer_external_call(cd, COMPOSER_EXT_TYPE_MSGVIEWER, msgInfo);
 673
 674         msg_ui_composer_message_destroy();
 675
 676         if (cd->ctx_popup) {
 677                 evas_object_del(cd->ctx_popup);
 678                 cd->ctx_popup = NULL;
 679         }
 680
 681         D_LEAVE;
 682 }
 683
 684 static void __pageduration_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 685 {
 686         D_ENTER;
 687         MSG_COMPOSER_VIEW_DATA_S *cd = data;
 688         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
 689         D_MSG_RETM_IF(cd->navi_it == NULL, "Naviitem is NULL");
 690
 691         msg_ui_composer_pageduration_popup_create(cd);
 692
 693         if (cd->ctx_popup) {
 694                 evas_object_del(cd->ctx_popup);
 695                 cd->ctx_popup = NULL;
 696         }
 697
 698         D_LEAVE;
 699 }
 700
 701 static void __msg_ui_composer_ctxpopup_dismissed_cb(void *data, Evas_Object *obj, void *event_info)
 702 {
 703         MSG_UI_ENTER();
 704         MSG_COMPOSER_VIEW_DATA_S *cd = data;
 705
 706         if (cd->ctx_popup) {
 707                 evas_object_del(cd->ctx_popup);
 708                 cd->ctx_popup = NULL;
 709         }
 710
 711         MSG_UI_LEAVE();
 712 }
 713
 714 static void msg_composer_naviframe_more_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 715 {
 716         MSG_UI_ENTER();
 717         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
 718
 719         MSG_COMPOSER_VIEW_DATA_S *cd = data;
 720         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
 721         Evas_Object *ctx_popup = NULL;
 722
 723         if (cd->popup_end) {
 724                 evas_object_del(cd->popup_end);
 725                 cd->popup_end = NULL;
 726         }
 727
 728         if (bubble_data) {
 729                 if (bubble_data->popup) {
 730                         evas_object_del(bubble_data->popup);
 731                         bubble_data->popup = NULL;
 732                 }
 733
 734                 if (bubble_data->title_menu_opened)
 735                         msg_ui_bubble_close_title_menu_genlist(bubble_data);
 736         }
 737
 738         /* fix ctx_popup flashing issue because of focus */
 739         ctx_popup = elm_ctxpopup_add(cd->main_window);
 740         elm_ctxpopup_direction_priority_set(ctx_popup, ELM_CTXPOPUP_DIRECTION_DOWN,
 741                                                  ELM_CTXPOPUP_DIRECTION_UNKNOWN,
 742                                                  ELM_CTXPOPUP_DIRECTION_UNKNOWN,
 743                                                  ELM_CTXPOPUP_DIRECTION_UNKNOWN);
 744
 745         evas_object_smart_callback_add(ctx_popup, "dismissed", __msg_ui_composer_ctxpopup_dismissed_cb, cd);
 746
 747         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER)
 748                 elm_ctxpopup_item_append(ctx_popup, dgettext("sys_string", "IDS_COM_SK_DELETE"), NULL, msg_ui_bubble_more_delete_clicked_cb, cd);
 749
 750         if (cd->msg_type == COMPOSER_MSG_TYPE_MMS) {
 751                 /* preview */
 752                 if (msg_ui_composer_body_has_media(cd))
 753                         elm_ctxpopup_item_append(ctx_popup, MSGC_STR_PREVIEW, NULL, __preview_btn_clicked_cb, cd);
 754
 755                 /* page duration */
 756                 char buf[DEF_BUF_LEN_S + 1] = {0,};
 757                 char duration[DEF_BUF_LEN_D + 1] = {0,};
 758                 const char *str = _MSGSTR("IDS_MSGC_OPT2_DURATION_HPS_SEC_ABB");
 759                 int pageduration = msg_ui_composer_pageduration_value_get(cd);
 760
 761                 snprintf(duration, sizeof(duration)-1, "%d", pageduration);
 762                 snprintf(buf, sizeof(buf)-1, str, duration);
 763                 elm_ctxpopup_item_append(ctx_popup, buf, NULL, __pageduration_btn_clicked_cb, cd);
 764         }
 765
 766         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER)
 767                 elm_ctxpopup_item_append(ctx_popup, dgettext(MESSAGE_PKGNAME, "IDS_MSG_HEADER_BACKUP"), NULL, msg_ui_bubble_backup_clicked_cb, cd);
 768
 769         Evas_Coord x = 0;
 770         Evas_Coord y = 0;
 771         Evas_Coord w = 0;
 772         Evas_Coord h = 0;
 773         evas_object_geometry_get(cd->more_btn, &x, &y, &w, &h);
 774         evas_object_move(ctx_popup, (x+(w/2)) , y+h);
 775         evas_object_show(ctx_popup);
 776
 777         cd->ctx_popup = ctx_popup;
 778
 779         MSG_UI_LEAVE();
 780 }
 781
 782 static void __naviframe_compose_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 783 {
 784         D_ENTER;
 785         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
 786
 787         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
 788
 789         if (cd->bubble_data->popup) {
 790                 evas_object_del(cd->bubble_data->popup);
 791                 cd->bubble_data->popup = NULL;
 792         }
 793
 794         service_h svc_handle;
 795
 796         if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
 797                 D_EMSG("service_create() is failed !!");
 798         } else {
 799                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_MODE, MSG_BUNDLE_VALUE_EDIT);
 800                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_FROM, MSG_BUNDLE_VALUE_INTERNAL);
 801                 msg_ui_composer_launch_composer_create(cd, svc_handle);
 802                 service_destroy(svc_handle);
 803         }
 804         D_LEAVE;
 805 }
 806
 807 static Evas_Object *__naviframe_back_btn_create(Evas_Object *parent, void *data, bool title)
 808 {
 809         D_ENTER;
 810         D_MSG_RETVM_IF(parent == NULL, NULL, "parent == NULL");
 811         D_MSG_RETVM_IF(data == NULL, NULL, "data == NULL");
 812         D_MSG("Title type = %d", title);
 813
 814         Evas_Object *btn = NULL;
 815         btn = elm_button_add(parent);
 816         if (btn == NULL)
 817                 return NULL;
 818
 819         if (title == true) {
 820                 elm_object_style_set(btn, "naviframe/back_btn/default");
 821         } else {
 822                 elm_object_style_set(btn, "naviframe/back_btn/default");
 823         }
 824         evas_object_smart_callback_add(btn, "clicked", __naviframe_back_btn_clicked_cb, data);
 825         evas_object_show(btn);
 826         D_LEAVE;
 827         return btn;
 828 }
 829
 830 static Evas_Object *__naviframe_more_btn_create(Evas_Object *parent, void *data)
 831 {
 832         D_ENTER;
 833         D_MSG_RETVM_IF(parent == NULL, NULL, "parent == NULL");
 834         D_MSG_RETVM_IF(data == NULL, NULL, "data == NULL");
 835
 836         Evas_Object *btn = elm_button_add(parent);
 837         if (!btn)
 838                 return NULL;
 839
 840         elm_object_style_set(btn, "naviframe/more/default");
 841
 842         evas_object_smart_callback_add(btn, "clicked", msg_composer_naviframe_more_btn_clicked_cb, data);
 843         evas_object_show(btn);
 844         D_LEAVE;
 845         return btn;
 846 }
 847
 848 static Evas_Object *__naviframe_compose_btn_create(Evas_Object *parent, void *data)
 849 {
 850         D_ENTER;
 851         D_MSG_RETVM_IF(parent == NULL, NULL, "parent == NULL");
 852         D_MSG_RETVM_IF(data == NULL, NULL, "data == NULL");
 853
 854         Evas_Object *btn = elm_button_add(parent);
 855         if (!btn)
 856                 return NULL;
 857         elm_object_style_set(btn, "naviframe/title_icon");
 858
 859         Evas_Object *icon = elm_icon_add(btn);
 860         elm_image_file_set(icon, MSG_IMAGES_EDJ, MSG_UI_THREAD_LIST_TITLE_ICON_COMPOSE);
 861         elm_image_resizable_set(icon, 1, 1);
 862         evas_object_image_smooth_scale_set(icon, 0);
 863         elm_object_content_set(btn, icon);
 864         evas_object_smart_callback_add(btn, "clicked", __naviframe_compose_btn_clicked_cb, data);
 865         D_LEAVE;
 866
 867         return btn;
 868 }
 869
 870 void msg_ui_composer_reset_request(MSG_COMPOSER_VIEW_DATA_S *cd, service_h svc_handle)
 871 {
 872         D_ENTER;
 873
 874         if (!cd)
 875                 return;
 876
 877         COMPOSER_EDIT_STATE_E edit_state = __msg_ui_composer_edit_check(cd);
 878         D_MSG("edit_state = %d", edit_state);
 879         D_MSG("composer mode = %d, msg_ug_mode = %d", cd->composer_mode, cd->msg_ug_mode);
 880
 881         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
 882                 if (edit_state == COMPOSER_EDIT_RECIPIENT_AND_BODY) {
 883                         /* auto saving */
 884                         msg_ui_composer_message_init();
 885
 886                         if (msg_ui_composer_get_message_data(cd) == COMPOSER_RETURN_SUCCESS) {
 887                                 /* delete draft message */
 888                                 msg_thread_id_t tid = 0;
 889
 890                                 if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
 891                                         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
 892                                         tid = bubble_data->threadId;
 893                                 } else {
 894                                         GSList *address_list = msg_ui_composer_message_get_address();
 895                                         msg_ui_composer_get_thread_id_by_address(cd->msg_handle, address_list, &tid);
 896                                 }
 897
 898                                 D_MSG("tid = %d", tid);
 899                                 if (tid > 0)
 900                                         msg_ui_composer_delete_draft_message(cd->msg_handle, tid);
 901
 902                                 D_MSG("save draft message");
 903                                 msg_ui_composer_save_message(cd->msg_handle, 0);
 904                         }
 905
 906                         msg_ui_composer_message_destroy();
 907                 }
 908         } else if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
 909                 if (edit_state == COMPOSER_EDIT_RECIPIENT) {
 910                         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
 911
 912                         if (bubble_data->title_menu_opened)
 913                                 msg_ui_bubble_close_title_menu_genlist(bubble_data);
 914
 915                         if (bubble_data->bubble_count == 0) {
 916                                 int err = MSG_SUCCESS;
 917
 918                                 if (bubble_data->isDraft == true)
 919                                         err = msg_delete_thread_message_list(bubble_data->msgHandle, bubble_data->threadId, false);
 920
 921                                 if (err == MSG_SUCCESS) {
 922                                         service_h svc_handle;
 923                                         if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
 924                                                 D_EMSG("service_create() is failed !!");
 925                                         } else {
 926                                                 char buf[DEF_BUF_LEN_S] = {0,};
 927                                                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_RESULT, MSG_BUNDLE_VALUE_DEL_ALL);
 928                                                 snprintf(buf, sizeof(buf), "%d", bubble_data->threadId);
 929                                                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_THREAD_ID, buf);
 930
 931                                                 ug_send_result(cd->ug, svc_handle);
 932
 933                                                 service_destroy(svc_handle);
 934                                         }
 935                                 } else {
 936                                         D_MSG("msg_delete_thread_message_list failed");
 937                                 }
 938                         } else {
 939                                 /* delete draft message */
 940                                 msg_struct_list_s msg_list = {0,};
 941
 942                                 if (msg_get_message_list(cd->msg_handle, MSG_DRAFT_ID, bubble_data->threadId, 0, 0, &msg_list) == COMPOSER_RETURN_SUCCESS) {
 943                                         int i = 0;
 944                                         int msgid = 0;
 945
 946                                         for (i = 0; i < msg_list.nCount; i++) {
 947                                                 msg_get_int_value(msg_list.msg_struct_info[i], MSG_MESSAGE_ID_INT, &msgid);
 948                                                 D_MSG("draft msg_id is %d", msgid);
 949                                                 if (msg_delete_message(cd->msg_handle, msgid) != COMPOSER_RETURN_SUCCESS)
 950                                                         D_EMSG("msg_ui_comp_core_delete_message is failed = %d", msgid);
 951                                         }
 952                                 }
 953
 954                                 msg_release_list_struct(&msg_list);
 955                         }
 956                 } else if (edit_state == COMPOSER_EDIT_RECIPIENT_AND_BODY) {
 957                         /* auto saving */
 958                         msg_ui_composer_message_init();
 959
 960                         if (msg_ui_composer_get_message_data(cd) == COMPOSER_RETURN_SUCCESS) {
 961                                 /* delete draft message */
 962                                 msg_thread_id_t tid = 0;
 963
 964                                 if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
 965                                         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
 966                                         tid = bubble_data->threadId;
 967                                 } else {
 968                                         GSList *address_list = msg_ui_composer_message_get_address();
 969                                         msg_ui_composer_get_thread_id_by_address(cd->msg_handle, address_list, &tid);
 970                                 }
 971
 972                                 D_MSG("tid = %d", tid);
 973                                 if (tid > 0)
 974                                         msg_ui_composer_delete_draft_message(cd->msg_handle, tid);
 975
 976                                 D_MSG("save draft message");
 977                                 msg_ui_composer_save_message(cd->msg_handle, 0);
 978                         }
 979
 980                         msg_ui_composer_message_destroy();
 981                 }
 982
 983                 /* clear recipient_list of bubble composer */
 984                 msg_ui_composer_recipient_clear_recipient_list(cd);
 985         }
 986
 987         /*process reset*/
 988         msg_ui_composer_reset(cd, svc_handle);
 989
 990         D_LEAVE;
 991 }
 992
 993 /*
 994  *      1. clear all composer editing obj
 995  *      2. make composer using bundle val
 996 */
 997 COMPOSER_RETURN_TYPE_E msg_ui_composer_reset(MSG_COMPOSER_VIEW_DATA_S *cd, service_h svc_handle)
 998 {
 999         D_ENTER;
1000         if (!cd)
1001                 return COMPOSER_RETURN_FAIL;
1002
1003         if (cd->working_path) {
1004                 ecore_file_recursive_rm(cd->working_path);
1005                 g_free(cd->working_path);
1006         }
1007
1008         cd->working_path = msg_composer_create_working_dir();
1009
1010         if (cd->working_path == NULL) {
1011                 D_EMSG("Fail of make working dir!!!");
1012                 return COMPOSER_RETURN_FAIL;
1013         }
1014
1015         if (svc_handle) {
1016                 msg_ui_composer_clear(cd);
1017
1018                 char *thread_id = NULL;
1019                 char *msg_id = NULL;
1020                 char *composer_mode = NULL;
1021                 char *from = NULL;
1022
1023                 service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_THREAD_ID, &thread_id);
1024                 service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_MSG_ID, &msg_id);
1025                 service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_MODE, &composer_mode);
1026                 service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_FROM, &from);
1027
1028                 if (composer_mode) {
1029                         if (g_strcmp0(composer_mode, MSG_BUNDLE_VALUE_EDIT) == 0)
1030                                 cd->composer_mode = MSG_COMPOSER_MODE_EDIT;
1031                         else if (g_strcmp0(composer_mode, MSG_BUNDLE_VALUE_FORWARD) == 0)
1032                                 cd->composer_mode = MSG_COMPOSER_MODE_FORWARD;
1033                         else
1034                                 cd->composer_mode = MSG_COMPOSER_MODE_NORMAL;
1035                 } else {
1036                         cd->composer_mode = MSG_COMPOSER_MODE_NORMAL;
1037                 }
1038
1039                 if (from && g_strcmp0(from, MSG_BUNDLE_VALUE_INTERNAL) == 0)
1040                         cd->isMsgInternal = true;
1041                 else
1042                         cd->isMsgInternal = false;
1043
1044                 /*Change to Bubble view*/
1045                 if ((thread_id || msg_id) && cd->composer_mode == MSG_COMPOSER_MODE_NORMAL) {
1046                         D_MSG("bubble view composer mode = %d, msg_ug_mode = %d", cd->composer_mode, cd->msg_ug_mode);
1047
1048                         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER) {
1049                                 D_MSG("change bubble view");
1050                                 msg_ui_composer_change_bubble_view(cd);
1051                                 msg_ui_bubble_parse_bubble_data(cd->bubble_data, svc_handle);
1052                                 msg_ui_bubble_start_view(cd->bubble_data);
1053                                 msg_ui_composer_navi_title_set((void *)cd);
1054
1055                                 /* set recipient list for bubble composer */
1056                                 msg_ui_composer_recipient_set_recipient_list(cd, cd->bubble_data->threadId);
1057                         } else if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
1058                                 D_MSG("reload bubble view");
1059                                 msg_ui_bubble_parse_bubble_data(cd->bubble_data, svc_handle);
1060                                 msg_ui_bubble_list_load(cd->bubble_data, true);
1061                                 msg_ui_composer_navi_title_set((void *)cd);
1062
1063                                 /* set recipient list for bubble composer */
1064                                 msg_ui_composer_recipient_set_recipient_list(cd, cd->bubble_data->threadId);
1065                         } else {
1066                                 D_EMSG("Invalid type");
1067                         }
1068
1069                         cd->msg_ug_mode = MSG_UG_MODE_BUBBLE_COMPOSER;
1070                 } else {
1071                         D_MSG("normal composer composer mode = %d, msg_ug_mode = %d", cd->composer_mode, cd->msg_ug_mode);
1072
1073                         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
1074                                 D_MSG("change composer view");
1075                                 if (cd->bubble_data) {
1076                                         cd->bubble_data->ug_state = BUBBLE_UG_DESTROY;
1077                                         msg_ui_bubble_deinit_bubble_data(cd->bubble_data);
1078                                         cd->bubble_data = NULL;
1079                                 }
1080
1081                                 msg_ui_composer_change_composer_view(cd);
1082                         }
1083
1084                         if (cd->isMsgInternal == true)
1085                                 cd->msg_ug_mode = MSG_UG_MODE_FULL_COMPOSER;
1086                         else
1087                                 cd->msg_ug_mode = MSG_UG_MODE_ONLY_COMPOSER;
1088
1089                         __msg_ui_composer_bundle_data_process(cd, svc_handle);
1090                 }
1091         }
1092
1093         D_LEAVE;
1094         return COMPOSER_RETURN_SUCCESS;
1095 }
1096
1097 COMPOSER_RETURN_TYPE_E msg_ui_composer_start(MSG_COMPOSER_VIEW_DATA_S *cd, service_h svc_handle)
1098 {
1099         D_ENTER;
1100         D_MSG_RETVM_IF(cd == NULL, COMPOSER_RETURN_FAIL, "Composer Data is NULL");
1101
1102         COMPOSER_RETURN_TYPE_E ret = COMPOSER_RETURN_SUCCESS;
1103         cd->state = COMPOSER_STATE_TYPE_RUNNING;
1104
1105         /* bundle data parsing */
1106         if (svc_handle) {
1107                 if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1108                         cd->isLoad = true;
1109                         __msg_ui_composer_bundle_data_process(cd, svc_handle);
1110
1111                         if (cd->attachlist == NULL)
1112                                 cd->isLoad = false;
1113
1114                 } else if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
1115                         D_MSG("START BUBBLE COMPOSER");
1116                         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)cd->bubble_data;
1117                         msg_ui_bubble_parse_bubble_data(bubble_data, svc_handle);
1118                         msg_ui_bubble_start_view(bubble_data);
1119                         msg_ui_composer_navi_title_set((void *)cd);
1120
1121                         /* set recipient list for bubble composer */
1122                         msg_ui_composer_recipient_set_recipient_list(cd, cd->bubble_data->threadId);
1123                 }
1124         }
1125
1126         /* set first focus*/
1127         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1128                 if (!msg_ui_composer_popup_exist(cd)) {
1129
1130                         int recipient_count = msg_ui_composer_recipient_count_get(cd->recipient);
1131
1132                         if (recipient_count > 0) {
1133                                 msg_ui_composer_body_focus_set(cd, 0);
1134                                 msg_ui_composer_recipient_expanded_set(cd->recipient, EINA_FALSE);
1135                         } else {
1136                                 msg_ui_composer_recipient_focus_set(cd->recipient);
1137                         }
1138                 }
1139         }
1140
1141         D_LEAVE;
1142         return ret;
1143 }
1144
1145 static void __msg_composer_auto_save_and_delete_msg(MSG_COMPOSER_VIEW_DATA_S *cd)
1146 {
1147         D_ENTER;
1148         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
1149
1150         /* save and delete msg */
1151         if (!cd->disable_auto_save_mode) {
1152                 COMPOSER_EDIT_STATE_E edit_state = __msg_ui_composer_edit_check(cd);
1153                 if (edit_state == COMPOSER_EDIT_RECIPIENT_AND_BODY) {
1154
1155                         /* auto save composer data */
1156                         msg_ui_composer_message_init();
1157                         if (msg_ui_composer_get_message_data(cd) == COMPOSER_RETURN_SUCCESS) {
1158                                 /* delete draft message */
1159                                 msg_thread_id_t tid = 0;
1160
1161                                 if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
1162                                         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
1163                                         tid = bubble_data->threadId;
1164                                 } else {
1165                                         GSList *address_list = msg_ui_composer_message_get_address();
1166                                         msg_ui_composer_get_thread_id_by_address(cd->msg_handle, address_list, &tid);
1167                                 }
1168
1169                                 D_MSG("tid = %d", tid);
1170                                 if (tid > 0)
1171                                         msg_ui_composer_delete_draft_message(cd->msg_handle, tid);
1172
1173                                 D_MSG("save draft message");
1174                                 msg_ui_composer_save_message(cd->msg_handle, 0);
1175                                 /* show saved ticker popup */
1176                                 msg_ui_composer_common_tickernoti(cd, COMPOSER_TICKERNOTI_AUTO_SAVED);
1177                         }
1178
1179                         msg_ui_composer_message_destroy();
1180                 } else if (edit_state == COMPOSER_EDIT_RECIPIENT) {
1181                         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
1182                                 /* delete draft message */
1183                                 MSG_BUBBLE_DATA *bubble_data = cd->bubble_data;
1184
1185                                 if (bubble_data) {
1186                                         msg_ui_composer_delete_draft_message(cd->msg_handle, bubble_data->threadId);
1187                                 }
1188                         }
1189                 }
1190         }
1191
1192         D_LEAVE;
1193 }
1194
1195 COMPOSER_RETURN_TYPE_E msg_ui_composer_destroy(MSG_COMPOSER_VIEW_DATA_S *cd)
1196 {
1197         D_ENTER;
1198         COMPOSER_RETURN_TYPE_E ret = COMPOSER_RETURN_SUCCESS;
1199
1200         msg_ui_composer_decrease_ref_count();
1201
1202         if (!cd)
1203                 return COMPOSER_RETURN_FAIL;
1204
1205         D_PRINT("===== Composer UG Destroy Start =====");
1206
1207         __msg_composer_auto_save_and_delete_msg(cd);
1208
1209         /* discoonect volume key handler */
1210         msg_ui_composer_disconnect_handler(cd);
1211
1212         contacts_disconnect2();
1213
1214         D_PRINT("----- Unregister vconf callback -----");
1215         if (vconf_ignore_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, __msgc_vconf_changed_cb) < 0) {
1216                 D_EMSG("Fail to unregister vconf CB with [%s]", VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE);
1217         }
1218         if (vconf_ignore_key_changed(VCONFKEY_MSG_APP_FONT_SIZE, __msgc_vconf_changed_cb) < 0) {
1219                 D_EMSG("Fail to unregister vconf CB with [%s]", VCONFKEY_MSG_APP_FONT_SIZE);
1220         }
1221
1222         if (cd->tapi_handle) {
1223                 if (tel_deinit(cd->tapi_handle) != TAPI_API_SUCCESS)
1224                         D_EMSG("tel_deinit is failed");
1225                 cd->tapi_handle = NULL;
1226         }
1227
1228         if(cd->job_thread_end) {
1229                 D_PRINT("----- Job Delete -----");
1230                 ecore_job_del(cd->job_thread_end);
1231                 cd->job_thread_end = NULL;
1232         }
1233
1234         if(cd->attach_thread) {
1235                 D_PRINT("----- Thread Delete -----");
1236                 ecore_thread_cancel(cd->attach_thread);
1237                 cd->attach_thread = NULL;
1238         }
1239
1240         if (cd->last_focus_idler) {
1241                 D_PRINT("----- idler Delete -----");
1242                 ecore_idler_del(cd->last_focus_idler);
1243                 cd->last_focus_idler = NULL;
1244         }
1245
1246         if (cd->flight_mode_timer) {
1247                 ecore_timer_del(cd->flight_mode_timer);
1248                 cd->flight_mode_timer = NULL;
1249         }
1250
1251         if (cd->recipient) {
1252                 D_PRINT("----- Recipient Delete -----");
1253                 msg_ui_composer_recipient_delete(cd->recipient);
1254                 cd->recipient = NULL;
1255         }
1256
1257         D_PRINT("----- Recipient list Clear -----");
1258         msg_ui_composer_recipient_clear_recipient_list(cd);
1259
1260         D_PRINT("----- Predict Search Delete -----");
1261         msg_ui_composer_predictsearch_list_delete(cd);
1262
1263         D_PRINT("----- Body Delete -----");
1264         msg_ui_composer_body_delete(cd);
1265
1266         D_PRINT("----- Close Msg Handle -----");
1267         msg_close_msg_handle(&cd->msg_handle);
1268
1269         D_PRINT("----- Delete Popup  -----");
1270         msg_ui_composer_popup_delete_all(cd);
1271
1272         if (cd->working_path) {
1273                 ecore_file_recursive_rm(cd->working_path);
1274                 g_free(cd->working_path);
1275                 cd->working_path = NULL;
1276         }
1277
1278         if (cd->th) {
1279                 elm_theme_extension_del(cd->th, MSG_CUSTOM_WINSET_EDJ);
1280                 elm_theme_free(cd->th);
1281                 cd->th = NULL;
1282         }
1283
1284         /* rollback indicator mode to previous mode */
1285         if (msg_ui_composer_get_ref_count() <= 0)
1286                 elm_win_indicator_mode_set(cd->main_window, cd->indicator_mode);
1287
1288         D_PRINT("===== Composer UG Destroy End =====");
1289
1290         D_LEAVE;
1291         return ret;
1292 }
1293
1294 void msg_ui_composer_change_language(MSG_COMPOSER_VIEW_DATA_S *cd)
1295 {
1296         D_ENTER;
1297         D_MSG_RETM_IF(cd == NULL, "cd is NULL");
1298
1299         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1300                 /* destroy popup */
1301                 msg_ui_composer_popup_delete_all(cd);
1302
1303                 if (cd->ctx_popup) {
1304                         evas_object_del(cd->ctx_popup);
1305                         cd->ctx_popup = NULL;
1306                 }
1307
1308                 /* title */
1309                 msg_ui_composer_navi_title_set(cd);
1310
1311                 /* recipient */
1312                 if (cd->recipient) {
1313                         Evas_Object *mbe = cd->recipient->mbe;
1314
1315                         /* set mbe label */
1316                         char label_txt[TO_FIELD_LABEL_SIZE_MAX] = { 0, };
1317                         gsize len = 0;
1318
1319                         len = snprintf(label_txt, (gsize)sizeof(label_txt), "%s:", MSGC_STR_TO);
1320                         if (len == -1) {
1321                                 D_EMSG("len = %d", len);
1322                         } else if (len > 0) {
1323                                 label_txt[len] = '\0';
1324                                 elm_object_text_set(mbe, label_txt);
1325                         } else {
1326                                 D_EMSG("len = %d", len);
1327                         }
1328
1329                         /* set guide text */
1330                         elm_object_part_text_set(mbe, "guide", MSGC_STR_ADD_RECIPIENT);
1331                 }
1332
1333                 /* subject */
1334                 if (cd->sub_data.entry)
1335                         edje_object_part_text_set(_EDJ(cd->sub_data.layout), "subject.guidetxt", MSGC_STR_SUBJECT);
1336
1337                 /* attachment */
1338                 if (cd->ly_attach_main) {
1339                         char buf[DEF_BUF_LEN_S + 1] = {0,};
1340                         const char *str = _MSGSTR("IDS_MSGC_BODY_PD_ATTACHMENTS");
1341
1342                         snprintf(buf, sizeof(buf), str, cd->attach_data.attachment_Cnt);
1343                         edje_object_part_text_set(_EDJ(cd->ly_attach_main), "text.filename", buf);
1344                 }
1345
1346                 /* mms size */
1347                 if (cd->msg_type == COMPOSER_MSG_TYPE_MMS)
1348                         msg_ui_composer_body_info_area_update(cd);
1349         }
1350
1351         cd->isclosed = false;
1352
1353         D_LEAVE;
1354 }
1355
1356 COMPOSER_RETURN_TYPE_E msg_ui_composer_rotate(MSG_COMPOSER_VIEW_DATA_S *cd, COMPOSER_ROTATE_TYPE_E rotate)
1357 {
1358         D_ENTER;
1359         D_MSG_RETVM_IF(cd == NULL, COMPOSER_RETURN_FAIL, "cd is NULL");
1360
1361         cd->rotate = rotate;
1362         D_MSG("rotate val [%d]", rotate);
1363
1364         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1365
1366                 RECIPIENT_S *r = cd->recipient;
1367                 if (!r) return COMPOSER_RETURN_FAIL;
1368
1369                 if (rotate == COMPOSER_ROTATE_PORTRAIT || rotate == COMPOSER_ROTATE_PORTRAIT_UPSIDEDOWN) {
1370                         elm_layout_theme_set(cd->base, "layout", "application", "default");
1371
1372                         if (!cd->loaded_ug)
1373                                 elm_win_indicator_mode_set(cd->main_window, ELM_WIN_INDICATOR_SHOW);
1374
1375                         elm_box_horizontal_set(r->bx_main, EINA_FALSE);
1376                         elm_scroller_content_min_limit(r->sc, EINA_FALSE, EINA_TRUE);
1377                         evas_object_size_hint_max_set(r->sc, 9999, COMPOSER_RECIPIENT_PORTRAIT_HEIGHT_MAX);
1378                 } else if (rotate == COMPOSER_ROTATE_LANDSCAPE || rotate == COMPOSER_ROTATE_LANDSCAPE_UPSIDEDOWN) {
1379                         elm_layout_theme_set(cd->base, "layout", "application", "noindicator");/*hide indicator in Landscape*/
1380
1381                         if (!cd->loaded_ug) {
1382                                 elm_win_indicator_mode_set(cd->main_window, ELM_WIN_INDICATOR_HIDE);
1383                                 D_MSG("hide indicator");
1384                         }
1385
1386                         elm_box_horizontal_set(r->bx_main, EINA_TRUE);
1387                         elm_scroller_content_min_limit(r->sc, EINA_FALSE, EINA_FALSE);
1388                         evas_object_size_hint_max_set(r->sc, 9999, -1);
1389                 }
1390
1391                 /* change body scroller size */
1392                 msg_ui_composer_change_body_scroll_size(cd, 0);
1393
1394         } else if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
1395                 if (rotate == COMPOSER_ROTATE_PORTRAIT || rotate == COMPOSER_ROTATE_PORTRAIT_UPSIDEDOWN) {
1396                         if (cd->bubble_data)
1397                                 cd->bubble_data->isRotate = false;
1398
1399                         if (cd->compose_btn) {
1400                                 evas_object_hide(cd->compose_btn);
1401                                 elm_object_part_content_unset(cd->navi_title_layout, "compose_btn");
1402                         }
1403                 } else if (rotate == COMPOSER_ROTATE_LANDSCAPE || rotate == COMPOSER_ROTATE_LANDSCAPE_UPSIDEDOWN) {
1404                         if (cd->bubble_data) {
1405                                 cd->bubble_data->isRotate = true;
1406
1407                                 if (cd->compose_btn && cd->bubble_data->viewmode == BUBBLE_NORMAL_VIEW) {
1408                                         evas_object_show(cd->compose_btn);
1409                                         elm_object_part_content_set(cd->navi_title_layout, "compose_btn", cd->compose_btn);
1410                                 }
1411                         }
1412                 }
1413
1414                 elm_win_indicator_mode_set(cd->main_window, ELM_WIN_INDICATOR_SHOW);
1415
1416                 /* change body scroller size */
1417                 msg_ui_composer_change_body_scroll_size(cd, 0);
1418
1419         } else {
1420                 D_EMSG("Unknown Composer Mode");
1421                 return COMPOSER_RETURN_FAIL;
1422         }
1423
1424         D_LEAVE;
1425         return COMPOSER_RETURN_SUCCESS;
1426 }
1427
1428 COMPOSER_RETURN_TYPE_E msg_ui_composer_init(MSG_COMPOSER_VIEW_DATA_S *cd)
1429 {
1430         D_ENTER;
1431
1432         if (cd == NULL) {
1433                 D_EMSG("[ASSERT] pcmop_data is NULL");
1434                 return COMPOSER_RETURN_FAIL;
1435         }
1436
1437         /* create message handle */
1438         if (msg_open_msg_handle(&cd->msg_handle) != MSG_SUCCESS) {
1439                 D_EMSG("[ASSERT] msg-server doesn't response !!!");
1440                 return COMPOSER_RETURN_FAIL;
1441         }
1442
1443         /* set message sent status callback */
1444         if (msg_reg_sent_status_callback(cd->msg_handle, &__msg_ui_composer_sent_status_cb, cd) != MSG_SUCCESS) {
1445                 D_EMSG("[ASSERT] sent status callback register error!!!");
1446                 return COMPOSER_RETURN_FAIL;
1447         }
1448
1449         /* connect contacts svc*/
1450         if (contacts_connect2() != 0) {
1451                 D_EMSG("[ASSERT] Fail of contacts_connect2 !!!");
1452                 return COMPOSER_RETURN_FAIL;
1453         }
1454
1455         cd->working_path = msg_composer_create_working_dir();
1456         if (cd->working_path == NULL) {
1457                 D_EMSG("[ASSERT] Fail of make working dir!!!");
1458                 return COMPOSER_RETURN_FAIL;
1459         }
1460
1461         /* set default message type is SMS */
1462         cd->msg_type = COMPOSER_MSG_TYPE_SMS;
1463
1464         /* get sms setting */
1465         msg_struct_t sms_sent_opt = msg_create_struct(MSG_STRUCT_SETTING_SMS_SEND_OPT);
1466
1467         if (msg_get_sms_send_opt(cd->msg_handle, sms_sent_opt) != MSG_SUCCESS) {
1468                 D_EMSG("Getting SMS_SEND_OP ERROR");
1469         } else {
1470                 msg_get_int_value(sms_sent_opt, MSG_SMS_SENDOPT_ENCODE_TYPE_INT, &cd->encode_mode);
1471                 D_MSG("SMS Encode mode is %d", cd->encode_mode);
1472         }
1473
1474         msg_release_struct(&sms_sent_opt);
1475
1476         if (cd->cms_max_page == 0) {
1477                 // TODO: get cms max page from msgfw when it is supported by msgfw.
1478                 cd->cms_max_page = COMPOSER_CMS_MAX_PAGE;
1479         }
1480
1481         /* get mms max size */
1482         if (cd->mms_max_size == 0) {
1483                 msg_struct_t setting = msg_create_struct(MSG_STRUCT_SETTING_MSGSIZE_OPT);
1484
1485                 if (msg_get_msgsize_opt(cd->msg_handle, setting) != MSG_SUCCESS) {
1486                         D_EMSG("Getting MMS MAX SIZE ERROR");
1487                 } else {
1488                         if (setting)
1489                                 msg_get_int_value(setting, MSG_MESSAGE_SIZE_INT, &cd->mms_max_size);
1490
1491                         D_MSG("msg max size = [%d KB] !!!", cd->mms_max_size);
1492                         cd->mms_max_size = cd->mms_max_size * 1024;
1493                 }
1494                 msg_release_struct(&setting);
1495         }
1496
1497         /* set default font size*/
1498         __msgc_init_font_size(cd);
1499
1500         /* coonect volume key handler */
1501         msg_ui_composer_connect_handler(cd);
1502
1503         /* register vconf callback function */
1504         if (vconf_notify_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, __msgc_vconf_changed_cb, cd) < 0) {
1505                 D_EMSG("Fail to register vconf CB with [%s]", VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE);
1506         }
1507         if (vconf_notify_key_changed(VCONFKEY_MSG_APP_FONT_SIZE, __msgc_vconf_changed_cb, cd) < 0) {
1508                 D_EMSG("Fail to register vconf CB with [%s]", VCONFKEY_MSG_APP_FONT_SIZE);
1509         }
1510
1511         cd->th = elm_theme_new();
1512         elm_theme_ref_set(cd->th, NULL);
1513         elm_theme_extension_add(cd->th, MSG_CUSTOM_WINSET_EDJ);
1514
1515         return COMPOSER_RETURN_SUCCESS;
1516 }
1517
1518 /*
1519  * Create Composer First View
1520  */
1521 COMPOSER_RETURN_TYPE_E msg_ui_composer_create(MSG_COMPOSER_VIEW_DATA_S *cd)
1522 {
1523         D_ENTER;
1524         D_MSG_RETVM_IF(cd == NULL, COMPOSER_RETURN_FAIL, "Composer data is NULL");
1525         D_MSG_RETVM_IF(cd->main_window == NULL, COMPOSER_RETURN_FAIL, "main_window is NULL");
1526         D_MSG_RETVM_IF(cd->base == NULL, COMPOSER_RETURN_FAIL, "base layout is NULL");
1527
1528         Evas_Object *navi_frame = NULL;
1529         Evas_Object *more_button = NULL;
1530         Evas_Object *compose_button = NULL;
1531         Evas_Object *content_layout = NULL;
1532         Elm_Object_Item *navi_it = NULL;
1533         Evas_Object *back_btn = NULL;
1534
1535         /* State Set */
1536         cd->state = COMPOSER_STATE_TYPE_CREATE;
1537
1538         /* Create naviframe */
1539         navi_frame = elm_naviframe_add(cd->base);
1540         if (!navi_frame) {
1541                 D_EMSG("naviframe add fail");
1542                 goto error_return;
1543         }
1544
1545         evas_object_show(navi_frame);
1546         cd->navi_bar = navi_frame;
1547
1548         /* Create content layout */
1549         content_layout = elm_layout_add(navi_frame);
1550         if (!content_layout) {
1551                 D_EMSG("layout add fail");
1552                 goto error_return;
1553         }
1554
1555         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1556                 elm_layout_file_set(content_layout, MSGC_UI_DEFAULT_EDJ, MSGC_EDJ_GRP_CONTENT_LAYOUT);
1557         } else if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER){
1558                 elm_layout_file_set(content_layout, MSGC_UI_DEFAULT_EDJ, MSGC_EDJ_GRP_CONTENT_LAYOUT);
1559                 edje_object_signal_emit(_EDJ(content_layout), "change.bubble", "*");
1560         } else {
1561                 D_EMSG("UG mode Unknown");
1562                 goto error_return;
1563         }
1564
1565         evas_object_size_hint_weight_set(content_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1566         evas_object_size_hint_align_set(content_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
1567         edje_object_signal_emit(_EDJ(content_layout), "hide.predictsearch", "*");
1568         evas_object_show(content_layout);
1569
1570         cd->content_layout = content_layout;
1571
1572         /*Create content*/
1573         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1574                 cd->recipient = msg_ui_composer_recipient_create(content_layout, 1, cd);
1575                 if (cd->recipient == NULL)
1576                         goto error_return;
1577
1578                 elm_object_part_content_set(content_layout, "swl.recipient", cd->recipient->bx_main);
1579
1580                 Evas_Object *predict_search_layout = msg_ui_composer_predictsearch_list_create(content_layout, cd);
1581                 elm_object_part_content_set(content_layout, "swl.predictsearch", predict_search_layout);
1582
1583         } else {
1584                 PMSG_BUBBLE_DATA bubble_data = msg_ui_bubble_init_bubble_data(cd->msg_handle, cd);
1585                 if (!bubble_data) {
1586                         goto error_return;
1587                 }
1588
1589                 cd->bubble_data = bubble_data;
1590
1591                 Evas_Object *bubble_layout = msg_ui_bubble_create_view(content_layout, cd->bubble_data);
1592                 if (!bubble_layout) {
1593                         goto error_return;
1594                 }
1595                 elm_object_part_content_set(content_layout, "swl.bubble.content", bubble_layout);
1596         }
1597
1598         Evas_Object *body_layout = msg_ui_composer_body_create(cd, content_layout);
1599         if (!body_layout) {
1600                 goto error_return;
1601         }
1602
1603         elm_object_part_content_set(content_layout, "swl.composer.body", body_layout);
1604
1605         cd->ly_body = body_layout;
1606
1607         /*Push content to navi frame*/
1608         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1609                 if (cd->isMsgInternal)
1610                         back_btn = __naviframe_back_btn_create(navi_frame, (void *)cd, false);
1611                 else
1612                         back_btn = __naviframe_back_btn_create(navi_frame, (void *)cd, true);
1613         } else {
1614                 back_btn = __naviframe_back_btn_create(navi_frame, (void *)cd, false);
1615         }
1616
1617         navi_it = elm_naviframe_item_push(navi_frame, NULL, NULL, NULL, content_layout, "empty");
1618
1619         cd->navi_it = navi_it;
1620         cd->back_btn = back_btn;
1621
1622         /* create navi title layout */
1623         cd->navi_title_layout = msg_ui_composer_create_navi_title_bar(cd);
1624         msg_ui_composer_navi_title_set(cd);
1625         elm_object_item_part_content_set(cd->navi_it, "title", cd->navi_title_layout);
1626
1627         /*Create more button*/
1628         more_button = __naviframe_more_btn_create(navi_frame, cd);
1629
1630         elm_object_part_content_set(cd->navi_title_layout, "more_btn", more_button);
1631         elm_object_part_content_set(cd->navi_title_layout, "prev_btn", back_btn);
1632
1633         cd->more_btn = more_button;
1634
1635         if (cd->msg_type == COMPOSER_MSG_TYPE_SMS && cd->msg_ug_mode != MSG_UG_MODE_BUBBLE_COMPOSER)
1636                 elm_object_disabled_set(cd->more_btn, EINA_TRUE);
1637
1638         /*Create compose button*/
1639         compose_button = __naviframe_compose_btn_create(navi_frame, cd);
1640
1641         if (cd->bubble_data != NULL && cd->bubble_data->isRotate == true) {
1642                 evas_object_show(compose_button);
1643                 elm_object_part_content_set(cd->navi_title_layout, "compose_btn", compose_button);
1644         } else {
1645                 evas_object_hide(compose_button);
1646                 elm_object_part_content_unset(cd->navi_title_layout, "compose_btn");
1647         }
1648
1649         cd->compose_btn = compose_button;
1650
1651         /* set navibar to main layout (base) */
1652         elm_object_part_content_set(cd->base, "elm.swallow.content", navi_frame);
1653
1654         D_LEAVE;
1655         return COMPOSER_RETURN_SUCCESS;
1656
1657 error_return:
1658         return COMPOSER_RETURN_FAIL;
1659 }
1660
1661 COMPOSER_RETURN_TYPE_E msg_ui_composer_bubble_data_set(MSG_COMPOSER_VIEW_DATA_S *cd, int thread_id)
1662 {
1663         D_ENTER;
1664         D_MSG_RETVM_IF(cd == NULL, COMPOSER_RETURN_FAIL, "Composer data is NULL");
1665         D_MSG_RETVM_IF(cd->msg_ug_mode != MSG_UG_MODE_BUBBLE_COMPOSER, COMPOSER_RETURN_FAIL, "msg_ug_mode is NOT BUBBLE TYPE");
1666         D_MSG_RETVM_IF(thread_id <=  0, COMPOSER_RETURN_FAIL, "Composer mode is Not Full");
1667         D_MSG_RETVM_IF(cd->bubble_data == NULL, COMPOSER_RETURN_FAIL, "bubble data is NULL");
1668
1669         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
1670         msg_struct_t threadInfo = NULL;
1671         int err;
1672
1673         /*Create bubble list*/
1674         bubble_data->threadId = thread_id;
1675         D_MSG("Thread ID = %d", bubble_data->threadId);
1676
1677         msg_struct_list_s addrList;
1678         int i = 0;
1679         memset(&addrList, 0x00, sizeof(msg_struct_list_s));
1680
1681         err = msg_get_address_list(bubble_data->msgHandle, bubble_data->threadId, &addrList);
1682
1683         if (err == MSG_SUCCESS) {
1684                 bubble_data->addr_list.addr_cnt = addrList.nCount;
1685
1686                 for (i = 0; i<addrList.nCount; i++) {
1687                         int contact_id = 0;
1688                         msg_get_int_value(addrList.msg_struct_info[i], MSG_ADDRESS_INFO_CONTACT_ID_INT, &contact_id);
1689                         /** addresss */
1690                         msg_get_str_value(addrList.msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, bubble_data->addr_list.addr_info[i].address, DEF_THREAD_ADDR_LEN);
1691
1692                         /** contact ID & display name */
1693                         if (contact_id > 0) {
1694                                 bubble_data->addr_list.addr_info[i].contact_id = contact_id;
1695                                 msg_get_str_value(addrList.msg_struct_info[i], MSG_ADDRESS_INFO_DISPLAYNAME_STR, bubble_data->addr_list.addr_info[i].name, DEF_THREAD_NAME_LEN);
1696                         } else {
1697                                 bubble_data->addr_list.addr_info[i].contact_id = 0;
1698                         }
1699                 }
1700
1701                 msg_release_list_struct(&addrList);
1702         } else {
1703                 D_MSG("[ERROR] msg_get_address_list returns error [%d]", err);
1704         }
1705
1706         threadInfo = msg_create_struct(MSG_STRUCT_THREAD_INFO);
1707         err = msg_get_thread(bubble_data->msgHandle, bubble_data->threadId, threadInfo);
1708
1709         if (err == MSG_SUCCESS)
1710                 msg_get_str_value(threadInfo, MSG_THREAD_NAME_STR, bubble_data->threadName, DEF_THREAD_NAME_LEN);
1711         else
1712                 D_MSG("[ERROR] msg_get_trhead returns error [%d", err);
1713
1714         msg_release_struct(&threadInfo);
1715
1716         return COMPOSER_RETURN_SUCCESS;
1717 }
1718
1719 COMPOSER_RETURN_TYPE_E msg_ui_composer_change_composer_view(MSG_COMPOSER_VIEW_DATA_S *cd)
1720 {
1721         D_ENTER;
1722         D_MSG_RETVM_IF(cd == NULL, COMPOSER_RETURN_FAIL, "Composer data is NULL");
1723         D_MSG_RETVM_IF(cd->msg_ug_mode != MSG_UG_MODE_BUBBLE_COMPOSER, COMPOSER_RETURN_FAIL, "Composer mode is Not Full");
1724
1725         /*Change Mode */
1726         cd->msg_ug_mode = MSG_UG_MODE_ONLY_COMPOSER;
1727
1728         /*Change content layout to composer layout*/
1729         edje_object_signal_emit(_EDJ(cd->content_layout), "change.composer", "*");
1730
1731         elm_scroller_content_min_limit(cd->body_scroll, 0, 0);
1732
1733         cd->recipient = msg_ui_composer_recipient_create(cd->content_layout, 1, cd);
1734         elm_object_part_content_set(cd->content_layout, "swl.recipient", cd->recipient->bx_main);
1735
1736         Evas_Object *predict_search_layout = msg_ui_composer_predictsearch_list_create(cd->content_layout, cd);
1737         elm_object_part_content_set(cd->content_layout, "swl.predictsearch", predict_search_layout);
1738
1739         MSGC_EVAS_OBJECT_DEL(cd->back_btn);
1740         Evas_Object *back_btn = __naviframe_back_btn_create(cd->navi_bar, (void *)cd, true);
1741         elm_object_part_content_set(cd->navi_title_layout, "prev_btn", back_btn);
1742         cd->back_btn = back_btn;
1743
1744         msg_ui_composer_navi_title_set(cd);
1745
1746         D_LEAVE;
1747         return COMPOSER_RETURN_SUCCESS;
1748 }
1749
1750 COMPOSER_RETURN_TYPE_E msg_ui_composer_change_bubble_view(MSG_COMPOSER_VIEW_DATA_S *cd)
1751 {
1752         D_ENTER;
1753         D_MSG_RETVM_IF(cd == NULL, COMPOSER_RETURN_FAIL, "Composer data is NULL");
1754         D_MSG_RETVM_IF(cd->msg_ug_mode != MSG_UG_MODE_FULL_COMPOSER, COMPOSER_RETURN_FAIL, "Composer mode is Not Full");
1755
1756         /*Change Mode */
1757         cd->msg_ug_mode = MSG_UG_MODE_BUBBLE_COMPOSER;
1758
1759         /*Change content layout to bubble layout*/
1760         edje_object_signal_emit(_EDJ(cd->content_layout), "hide.predictsearch", "*");
1761         edje_object_signal_emit(_EDJ(cd->content_layout), "change.bubble", "*");
1762
1763         elm_scroller_content_min_limit(cd->body_scroll, 0, 1);
1764         evas_object_size_hint_max_set(cd->body_scroll, 9999, 250);
1765
1766         /*Init bubble data*/
1767         PMSG_BUBBLE_DATA bubble_data = msg_ui_bubble_init_bubble_data(cd->msg_handle, cd);
1768         if (!bubble_data)
1769                 return COMPOSER_RETURN_FAIL;
1770
1771         cd->bubble_data = (void *)bubble_data;
1772
1773         /*Change naviframe layout for bubble*/
1774         Evas_Object *cancel_btn = __naviframe_back_btn_create(cd->navi_bar, (void *)cd, false);
1775         elm_object_part_content_set(cd->navi_title_layout, "prev_btn", cancel_btn);
1776         cd->back_btn = cancel_btn;
1777
1778         Evas_Object *layout = msg_ui_bubble_create_view(cd->content_layout, cd->bubble_data); // First parameter should be 'content_layout'.
1779         elm_object_part_content_set(cd->content_layout, "swl.bubble.content", layout);
1780
1781         /*remove unused layout*/
1782         MSGC_EVAS_OBJECT_DEL(cd->ly_recipient);
1783         msg_ui_composer_recipient_delete(cd->recipient);
1784         cd->recipient = NULL;
1785
1786         msg_ui_composer_predictsearch_list_delete(cd);
1787
1788         return COMPOSER_RETURN_SUCCESS;
1789 }
1790
1791 /*
1792  * msg_ui_composer_editable_set
1793  * editable == FALSE : hide body content & disable more button & close option header
1794  * editable == TRUE : show body content layout
1795  * */
1796 void msg_ui_composer_editable_set(MSG_COMPOSER_VIEW_DATA_S *cd, Eina_Bool editable)
1797 {
1798         D_ENTER;
1799         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
1800
1801         if (editable == EINA_FALSE){
1802                 Evas_Object *body_layout = elm_object_part_content_unset(cd->content_layout, "swl.composer.body");
1803                 evas_object_hide(body_layout);
1804
1805                 if (cd->more_btn)
1806                         elm_object_disabled_set(cd->more_btn, EINA_TRUE);
1807         } else {
1808                 elm_object_part_content_set(cd->content_layout, "swl.composer.body", cd->ly_body);
1809                 evas_object_show(cd->ly_body);
1810
1811                 if (cd->more_btn)
1812                         elm_object_disabled_set(cd->more_btn, EINA_FALSE);
1813
1814         }
1815
1816         D_LEAVE;
1817 }
1818
1819 void msg_ui_composer_bubble_del_all(void *data, service_h svc_handle)
1820 {
1821         D_ENTER;
1822
1823         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1824         D_MSG_RETM_IF(cd == NULL, "Composer data is NULL");
1825
1826         ug_send_result(cd->ug, svc_handle);
1827 }
1828
1829 Evas_Object *msg_ui_composer_create_navi_title_bar(void *data)
1830 {
1831         D_ENTER;
1832
1833         if (!data) {
1834                 D_EMSG("[ERROR] data is NULL");
1835                 return NULL;
1836         }
1837
1838         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1839
1840         Evas_Object *title_layout = elm_layout_add(cd->navi_bar);
1841         elm_layout_file_set(title_layout, MSG_COMMON_EDJ, "title");
1842         evas_object_size_hint_weight_set(title_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1843         evas_object_size_hint_align_set(title_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
1844         evas_object_show(title_layout);
1845
1846         return title_layout;
1847 }
1848
1849 void msg_ui_composer_navi_title_set(void *data)
1850 {
1851         D_ENTER;
1852
1853         if (!data) {
1854                 D_EMSG("data is NULL");
1855                 return;
1856         }
1857
1858         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1859         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
1860
1861         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1862                 elm_object_part_text_set(cd->navi_title_layout, "title_text", MSGC_STR_NEW_MESSAGE);
1863         } else if (cd->msg_ug_mode ==  MSG_UG_MODE_BUBBLE_COMPOSER) {
1864                 Evas_Object *title_button = NULL;
1865
1866                 elm_object_part_text_set(cd->navi_title_layout, "title_text", ""); // text part clear first
1867
1868                 title_button = elm_button_add(cd->navi_bar);
1869
1870                 elm_object_theme_set(title_button, cd->th);
1871                 elm_object_style_set(title_button, "title_button");
1872
1873                 evas_object_size_hint_weight_set(title_button, 0.0, 0.0);
1874                 evas_object_size_hint_align_set(title_button, EVAS_HINT_FILL, EVAS_HINT_FILL);
1875
1876                 if (bubble_data->addr_list.addr_cnt == 1) {
1877                         if (bubble_data->addr_list.addr_info[0].contact_id > 0 && bubble_data->addr_list.addr_info[0].name[0] != '\0')
1878                                 elm_object_text_set(title_button, bubble_data->addr_list.addr_info[0].name);
1879                         else if (bubble_data->addr_list.addr_info[0].address[0] != '\0')
1880                                 elm_object_text_set(title_button, bubble_data->addr_list.addr_info[0].address);
1881                         else
1882                                 elm_object_text_set(title_button, dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"));
1883                 } else if (bubble_data->addr_list.addr_cnt > 1) {
1884                         char title_text[DEF_BUF_LEN+1] = {0,};
1885
1886                         if (bubble_data->addr_list.addr_info[0].contact_id > 0 && bubble_data->addr_list.addr_info[0].name[0] != '\0')
1887                                 snprintf(title_text, sizeof(title_text), "%s +%d", bubble_data->addr_list.addr_info[0].name, bubble_data->addr_list.addr_cnt-1);
1888                         else if (bubble_data->addr_list.addr_info[0].address[0] != '\0')
1889                                 snprintf(title_text, sizeof(title_text), "%s +%d", bubble_data->addr_list.addr_info[0].address, bubble_data->addr_list.addr_cnt-1);
1890                         else
1891                                 snprintf(title_text, sizeof(title_text), "%s +%d", dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"), bubble_data->addr_list.addr_cnt-1);
1892
1893                         elm_object_text_set(title_button, title_text);
1894                 } else {
1895                         elm_object_text_set(title_button, dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"));
1896                 }
1897
1898                 evas_object_show(title_button);
1899                 elm_object_part_content_set(cd->navi_title_layout, "title_btn", title_button);
1900                 evas_object_smart_callback_add(title_button, "clicked", msg_ui_bubble_title_button_clicked_cb, cd);
1901
1902                 bubble_data->title_button = title_button;
1903         } else {
1904                 D_EMSG("Invalid msg_ui_mode [%d]", cd->msg_ug_mode);
1905                 return;
1906         }
1907 }
1908
1909 static Eina_Bool __msgc_up_key_long_press_cb(void *data)
1910 {
1911         D_ENTER;
1912         D_MSG_RETVM_IF(data == NULL, EINA_FALSE, "cd is NULL");
1913         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1914
1915         if (!msg_common_increase_font_size()) {
1916                 cd->vol_up_key_longpress = NULL;
1917                 return EINA_FALSE;
1918         }
1919
1920         /* apply font size */
1921         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER)
1922                 msg_common_apply_font_size("bubble", cd->content_layout);
1923
1924         msg_ui_composer_apply_font_size(cd, false);
1925
1926         return EINA_TRUE;
1927 }
1928
1929 static Eina_Bool __msgc_down_key_long_press_cb(void *data)
1930 {
1931         D_ENTER;
1932         D_MSG_RETVM_IF(data == NULL, EINA_FALSE, "cd is NULL");
1933         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1934
1935         if (!msg_common_decrease_font_size()) {
1936                 cd->vol_down_key_longpress = NULL;
1937                 return EINA_FALSE;
1938         }
1939
1940         /* apply font size */
1941         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER)
1942                 msg_common_apply_font_size("bubble", cd->content_layout);
1943
1944         msg_ui_composer_apply_font_size(cd, false);
1945
1946         return EINA_TRUE;
1947 }
1948
1949 Eina_Bool msg_ui_composer_key_release_cb(void *data, int type, void *event)
1950 {
1951         D_ENTER;
1952         D_MSG_RETVM_IF(data == NULL, EINA_FALSE, "cd is NULL");
1953         D_MSG_RETVM_IF(event == NULL, EINA_FALSE, "event is NULL");
1954         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1955         Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
1956         int use_volume_key = false;
1957
1958         vconf_get_bool(VCONFKEY_MSG_APP_USE_VOLUME_KEY, &use_volume_key);
1959
1960         if (use_volume_key) {
1961                 if (!g_strcmp0(ev->keyname, KEY_VOLUMEUP)) {    /* KEY_VOLUMEUP */
1962                         D_MSG("KEY_VOLUMEUP is released");
1963
1964                         if (cd->vol_up_key_longpress) {
1965                                 ecore_timer_del(cd->vol_up_key_longpress);
1966                                 cd->vol_up_key_longpress = NULL;
1967                         }
1968                 } else if (!g_strcmp0(ev->keyname, KEY_VOLUMEDOWN)) {   /* KEY_VOLUMEDOWN */
1969                         D_MSG("KEY_VOLUMEDOWN is released");
1970
1971                         if (cd->vol_down_key_longpress) {
1972                                 ecore_timer_del(cd->vol_down_key_longpress);
1973                                 cd->vol_down_key_longpress = NULL;
1974                         }
1975                 } else {
1976                         D_MSG("key_name is not applicable!");
1977                 }
1978         } else {
1979                 D_MSG("Use volume key setting is not activated. Do volume key action");
1980         }
1981
1982         return EINA_TRUE;
1983 }
1984
1985 Eina_Bool msg_ui_composer_key_press_cb(void *data, int type, void *event)
1986 {
1987         D_ENTER;
1988         D_MSG_RETVM_IF(data == NULL, EINA_FALSE, "cd is NULL");
1989         D_MSG_RETVM_IF(event == NULL, EINA_FALSE, "event is NULL");
1990         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1991         Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
1992         int use_volume_key = false;
1993
1994         vconf_get_bool(VCONFKEY_MSG_APP_USE_VOLUME_KEY, &use_volume_key);
1995
1996         if (use_volume_key) {
1997                 if (!g_strcmp0(ev->keyname, KEY_VOLUMEUP)) {    /* KEY_VOLUMEUP */
1998                         D_MSG("KEY_VOLUMEUP is pressed");
1999
2000                         msg_common_increase_font_size();
2001
2002                         /* apply font size */
2003                         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER)
2004                                 msg_common_apply_font_size("bubble", cd->content_layout);
2005
2006                         msg_ui_composer_apply_font_size(cd, false);
2007
2008                         cd->vol_up_key_longpress = ecore_timer_add(0.1, (Ecore_Task_Cb) __msgc_up_key_long_press_cb, (void *)cd);
2009                 } else if (!g_strcmp0(ev->keyname, KEY_VOLUMEDOWN)) {   /* KEY_VOLUMEDOWN */
2010                         D_MSG("KEY_VOLUMEDOWN is pressed");
2011
2012                         msg_common_decrease_font_size();
2013
2014                         /* apply font size */
2015                         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER)
2016                                 msg_common_apply_font_size("bubble", cd->content_layout);
2017
2018                         msg_ui_composer_apply_font_size(cd, false);
2019
2020                         cd->vol_down_key_longpress = ecore_timer_add(0.1, (Ecore_Task_Cb) __msgc_down_key_long_press_cb, (void *)cd);
2021                 } else {
2022                         D_MSG("key_name is not applicable!");
2023                 }
2024         } else {
2025                 D_MSG("Use volume key setting is not activated. Do volume key action");
2026         }
2027
2028         return EINA_TRUE;
2029 }
2030
2031 void msg_ui_composer_connect_handler(MSG_COMPOSER_VIEW_DATA_S *cd)
2032 {
2033         D_ENTER;
2034         D_MSG_RETM_IF(cd == NULL, "cd is NULL");
2035
2036         int use_volume_key = 0;
2037         vconf_get_bool(VCONFKEY_MSG_APP_USE_VOLUME_KEY, &use_volume_key);
2038
2039         if (use_volume_key) {
2040                 msg_ui_composer_grab_key_setting(cd->xdisplay, cd->main_window);
2041                 /* connect key handler for volume up/down */
2042                 if (!cd->volkey_press_handler)
2043                         cd->volkey_press_handler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, msg_ui_composer_key_press_cb, (void *)cd);
2044
2045                 if (!cd->volkey_release_handler)
2046                         cd->volkey_release_handler = ecore_event_handler_add(ECORE_EVENT_KEY_UP, msg_ui_composer_key_release_cb, (void *)cd);
2047         }
2048         D_MSG("use_volume_key = %d", use_volume_key);
2049
2050         D_LEAVE;
2051 }
2052
2053 void msg_ui_composer_disconnect_handler(MSG_COMPOSER_VIEW_DATA_S *cd)
2054 {
2055         D_ENTER;
2056         D_MSG_RETM_IF(cd == NULL, "cd is NULL");
2057
2058         if (cd->volkey_press_handler) {
2059                 ecore_event_handler_del(cd->volkey_press_handler);
2060                 cd->volkey_press_handler = NULL;
2061         }
2062
2063         if (cd->vol_down_key_longpress) {
2064                 ecore_timer_del(cd->vol_down_key_longpress);
2065                 cd->vol_down_key_longpress = NULL;
2066         }
2067
2068         if (cd->volkey_release_handler) {
2069                 ecore_event_handler_del(cd->volkey_release_handler);
2070                 cd->volkey_release_handler = NULL;
2071         }
2072
2073         if (cd->vol_up_key_longpress) {
2074                 ecore_timer_del(cd->vol_up_key_longpress);
2075                 cd->vol_up_key_longpress = NULL;
2076         }
2077
2078         msg_ui_composer_ungrab_key_setting(cd->xdisplay, cd->main_window);
2079
2080         D_LEAVE;
2081 }