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_set(popup, EINA_TRUE);
 586         evas_object_show(popup);
 587
 588         cd->popup_end = popup;
 589
 590         D_LEAVE;
 591         return;
 592 }
 593
 594 static void __naviframe_back_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 595 {
 596         D_ENTER;
 597         D_MSG_RETM_IF(data == NULL, "Data == NULL");
 598         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
 599
 600         COMPOSER_EDIT_STATE_E edit_state = __msg_ui_composer_edit_check(cd);
 601         D_MSG("edit_state = %d", edit_state);
 602
 603         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
 604                 if (cd->isclosed) {
 605                         D_EMSG("back btn is already called");
 606                         return;
 607                 }
 608
 609                 /* isclosed is set to prevent showing invalid popup*/
 610                 cd->isclosed = true;
 611
 612                 if (edit_state == COMPOSER_EDIT_RECIPIENT || edit_state == COMPOSER_EDIT_BODY) {
 613                         __msg_ui_composer_end_popup(cd);
 614                         return;
 615                 }
 616         } else if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
 617                 if (edit_state == COMPOSER_EDIT_RECIPIENT) {
 618
 619                         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
 620
 621                         if (bubble_data->title_menu_opened)
 622                                 msg_ui_bubble_close_title_menu_genlist(bubble_data);
 623
 624                         if (bubble_data->bubble_count == 0) {
 625                                 int err = MSG_SUCCESS;
 626
 627                                 if (bubble_data->isDraft == true)
 628                                         err = msg_delete_thread_message_list(bubble_data->msgHandle, bubble_data->threadId, false);
 629
 630                                 if (err == MSG_SUCCESS) {
 631                                         service_h svc_handle;
 632                                         char buf[DEF_BUF_LEN_S] = {0,};
 633
 634                                         if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
 635                                                 D_EMSG("service_create() is failed !!");
 636                                         } else {
 637                                                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_RESULT, MSG_BUNDLE_VALUE_DEL_ALL);
 638                                                 snprintf(buf, sizeof(buf), "%d", bubble_data->threadId);
 639                                                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_THREAD_ID, buf);
 640                                                 ug_send_result(cd->ug, svc_handle);
 641
 642                                                 service_destroy(svc_handle);
 643                                         }
 644                                 } else {
 645                                         D_MSG("msg_delete_thread_message_list failed");
 646                                 }
 647                         }
 648                 }
 649         }
 650
 651         ug_destroy_me(cd->ug);
 652
 653         D_LEAVE;
 654 }
 655
 656 static void __preview_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 657 {
 658         D_ENTER;
 659         MSG_COMPOSER_VIEW_DATA_S *cd = data;
 660         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
 661         D_MSG_RETM_IF(cd->navi_it == NULL, "Naviitem is NULL");
 662
 663         msg_struct_t msgInfo = NULL;
 664         msg_ui_composer_message_init();
 665         msg_ui_composer_read_preview_message(cd);
 666
 667         /* make preview message data */
 668         msgInfo = msg_ui_composer_message_make_preview(cd->msg_handle);
 669
 670         if (msgInfo)
 671                 msg_ui_composer_external_call(cd, COMPOSER_EXT_TYPE_MSGVIEWER, msgInfo);
 672
 673         msg_ui_composer_message_destroy();
 674
 675         if (cd->ctx_popup) {
 676                 evas_object_del(cd->ctx_popup);
 677                 cd->ctx_popup = NULL;
 678         }
 679
 680         D_LEAVE;
 681 }
 682
 683 static void __pageduration_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 684 {
 685         D_ENTER;
 686         MSG_COMPOSER_VIEW_DATA_S *cd = data;
 687         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
 688         D_MSG_RETM_IF(cd->navi_it == NULL, "Naviitem is NULL");
 689
 690         msg_ui_composer_pageduration_popup_create(cd);
 691
 692         if (cd->ctx_popup) {
 693                 evas_object_del(cd->ctx_popup);
 694                 cd->ctx_popup = NULL;
 695         }
 696
 697         D_LEAVE;
 698 }
 699
 700 static void __msg_ui_composer_ctxpopup_dismissed_cb(void *data, Evas_Object *obj, void *event_info)
 701 {
 702         MSG_UI_ENTER();
 703         MSG_COMPOSER_VIEW_DATA_S *cd = data;
 704
 705         if (cd->ctx_popup) {
 706                 evas_object_del(cd->ctx_popup);
 707                 cd->ctx_popup = NULL;
 708         }
 709
 710         MSG_UI_LEAVE();
 711 }
 712
 713 static void msg_composer_naviframe_more_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 714 {
 715         MSG_UI_ENTER();
 716         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
 717
 718         MSG_COMPOSER_VIEW_DATA_S *cd = data;
 719         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
 720         Evas_Object *ctx_popup = NULL;
 721
 722         if (cd->popup_end) {
 723                 evas_object_del(cd->popup_end);
 724                 cd->popup_end = NULL;
 725         }
 726
 727         if (bubble_data) {
 728                 if (bubble_data->popup) {
 729                         evas_object_del(bubble_data->popup);
 730                         bubble_data->popup = NULL;
 731                 }
 732
 733                 if (bubble_data->title_menu_opened)
 734                         msg_ui_bubble_close_title_menu_genlist(bubble_data);
 735         }
 736
 737         /* fix ctx_popup flashing issue because of focus */
 738         ctx_popup = elm_ctxpopup_add(cd->main_window);
 739         elm_ctxpopup_direction_priority_set(ctx_popup, ELM_CTXPOPUP_DIRECTION_DOWN,
 740                                                  ELM_CTXPOPUP_DIRECTION_UNKNOWN,
 741                                                  ELM_CTXPOPUP_DIRECTION_UNKNOWN,
 742                                                  ELM_CTXPOPUP_DIRECTION_UNKNOWN);
 743
 744         evas_object_smart_callback_add(ctx_popup, "dismissed", __msg_ui_composer_ctxpopup_dismissed_cb, cd);
 745
 746         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER)
 747                 elm_ctxpopup_item_append(ctx_popup, dgettext("sys_string", "IDS_COM_SK_DELETE"), NULL, msg_ui_bubble_more_delete_clicked_cb, cd);
 748
 749         if (cd->msg_type == COMPOSER_MSG_TYPE_MMS) {
 750                 /* preview */
 751                 if (msg_ui_composer_body_has_media(cd))
 752                         elm_ctxpopup_item_append(ctx_popup, MSGC_STR_PREVIEW, NULL, __preview_btn_clicked_cb, cd);
 753
 754                 /* page duration */
 755                 char buf[DEF_BUF_LEN_S + 1] = {0,};
 756                 char duration[DEF_BUF_LEN_D + 1] = {0,};
 757                 const char *str = _MSGSTR("IDS_MSGC_OPT2_DURATION_HPS_SEC_ABB");
 758                 int pageduration = msg_ui_composer_pageduration_value_get(cd);
 759
 760                 snprintf(duration, sizeof(duration)-1, "%d", pageduration);
 761                 snprintf(buf, sizeof(buf)-1, str, duration);
 762                 elm_ctxpopup_item_append(ctx_popup, buf, NULL, __pageduration_btn_clicked_cb, cd);
 763         }
 764
 765         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER)
 766                 elm_ctxpopup_item_append(ctx_popup, dgettext(MESSAGE_PKGNAME, "IDS_MSG_HEADER_BACKUP"), NULL, msg_ui_bubble_backup_clicked_cb, cd);
 767
 768         Evas_Coord x = 0;
 769         Evas_Coord y = 0;
 770         Evas_Coord w = 0;
 771         Evas_Coord h = 0;
 772         evas_object_geometry_get(cd->more_btn, &x, &y, &w, &h);
 773         evas_object_move(ctx_popup, (x+(w/2)) , y+h);
 774         evas_object_show(ctx_popup);
 775
 776         cd->ctx_popup = ctx_popup;
 777
 778         MSG_UI_LEAVE();
 779 }
 780
 781 static void __naviframe_compose_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 782 {
 783         D_ENTER;
 784         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
 785
 786         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
 787
 788         if (cd->bubble_data->popup) {
 789                 evas_object_del(cd->bubble_data->popup);
 790                 cd->bubble_data->popup = NULL;
 791         }
 792
 793         service_h svc_handle;
 794
 795         if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
 796                 D_EMSG("service_create() is failed !!");
 797         } else {
 798                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_MODE, MSG_BUNDLE_VALUE_EDIT);
 799                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_FROM, MSG_BUNDLE_VALUE_INTERNAL);
 800                 msg_ui_composer_launch_composer_create(cd, svc_handle);
 801                 service_destroy(svc_handle);
 802         }
 803         D_LEAVE;
 804 }
 805
 806 static Evas_Object *__naviframe_back_btn_create(Evas_Object *parent, void *data, bool title)
 807 {
 808         D_ENTER;
 809         D_MSG_RETVM_IF(parent == NULL, NULL, "parent == NULL");
 810         D_MSG_RETVM_IF(data == NULL, NULL, "data == NULL");
 811         D_MSG("Title type = %d", title);
 812
 813         Evas_Object *btn = NULL;
 814         btn = elm_button_add(parent);
 815         if (btn == NULL)
 816                 return NULL;
 817
 818         if (title == true) {
 819                 elm_object_style_set(btn, "naviframe/back_btn/default");
 820         } else {
 821                 elm_object_style_set(btn, "naviframe/back_btn/default");
 822         }
 823         evas_object_smart_callback_add(btn, "clicked", __naviframe_back_btn_clicked_cb, data);
 824         evas_object_show(btn);
 825         D_LEAVE;
 826         return btn;
 827 }
 828
 829 static Evas_Object *__naviframe_more_btn_create(Evas_Object *parent, void *data)
 830 {
 831         D_ENTER;
 832         D_MSG_RETVM_IF(parent == NULL, NULL, "parent == NULL");
 833         D_MSG_RETVM_IF(data == NULL, NULL, "data == NULL");
 834
 835         Evas_Object *btn = elm_button_add(parent);
 836         if (!btn)
 837                 return NULL;
 838
 839         elm_object_style_set(btn, "naviframe/more/default");
 840
 841         evas_object_smart_callback_add(btn, "clicked", msg_composer_naviframe_more_btn_clicked_cb, data);
 842         evas_object_show(btn);
 843         D_LEAVE;
 844         return btn;
 845 }
 846
 847 static Evas_Object *__naviframe_compose_btn_create(Evas_Object *parent, void *data)
 848 {
 849         D_ENTER;
 850         D_MSG_RETVM_IF(parent == NULL, NULL, "parent == NULL");
 851         D_MSG_RETVM_IF(data == NULL, NULL, "data == NULL");
 852
 853         Evas_Object *btn = elm_button_add(parent);
 854         if (!btn)
 855                 return NULL;
 856         elm_object_style_set(btn, "naviframe/title_icon");
 857
 858         Evas_Object *icon = elm_icon_add(btn);
 859         elm_image_file_set(icon, MSG_IMAGES_EDJ, MSG_UI_THREAD_LIST_TITLE_ICON_COMPOSE);
 860         elm_image_resizable_set(icon, 1, 1);
 861         evas_object_image_smooth_scale_set(icon, 0);
 862         elm_object_content_set(btn, icon);
 863         evas_object_smart_callback_add(btn, "clicked", __naviframe_compose_btn_clicked_cb, data);
 864         D_LEAVE;
 865
 866         return btn;
 867 }
 868
 869 void msg_ui_composer_reset_request(MSG_COMPOSER_VIEW_DATA_S *cd, service_h svc_handle)
 870 {
 871         D_ENTER;
 872
 873         if (!cd)
 874                 return;
 875
 876         COMPOSER_EDIT_STATE_E edit_state = __msg_ui_composer_edit_check(cd);
 877         D_MSG("edit_state = %d", edit_state);
 878         D_MSG("composer mode = %d, msg_ug_mode = %d", cd->composer_mode, cd->msg_ug_mode);
 879
 880         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
 881                 if (edit_state == COMPOSER_EDIT_RECIPIENT_AND_BODY) {
 882                         /* auto saving */
 883                         msg_ui_composer_message_init();
 884
 885                         if (msg_ui_composer_get_message_data(cd) == COMPOSER_RETURN_SUCCESS) {
 886                                 /* delete draft message */
 887                                 msg_thread_id_t tid = 0;
 888
 889                                 if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
 890                                         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
 891                                         tid = bubble_data->threadId;
 892                                 } else {
 893                                         GSList *address_list = msg_ui_composer_message_get_address();
 894                                         msg_ui_composer_get_thread_id_by_address(cd->msg_handle, address_list, &tid);
 895                                 }
 896
 897                                 D_MSG("tid = %d", tid);
 898                                 if (tid > 0)
 899                                         msg_ui_composer_delete_draft_message(cd->msg_handle, tid);
 900
 901                                 D_MSG("save draft message");
 902                                 msg_ui_composer_save_message(cd->msg_handle, 0);
 903                         }
 904
 905                         msg_ui_composer_message_destroy();
 906                 }
 907         } else if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
 908                 if (edit_state == COMPOSER_EDIT_RECIPIENT) {
 909                         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
 910
 911                         if (bubble_data->title_menu_opened)
 912                                 msg_ui_bubble_close_title_menu_genlist(bubble_data);
 913
 914                         if (bubble_data->bubble_count == 0) {
 915                                 int err = MSG_SUCCESS;
 916
 917                                 if (bubble_data->isDraft == true)
 918                                         err = msg_delete_thread_message_list(bubble_data->msgHandle, bubble_data->threadId, false);
 919
 920                                 if (err == MSG_SUCCESS) {
 921                                         service_h svc_handle;
 922                                         if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
 923                                                 D_EMSG("service_create() is failed !!");
 924                                         } else {
 925                                                 char buf[DEF_BUF_LEN_S] = {0,};
 926                                                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_RESULT, MSG_BUNDLE_VALUE_DEL_ALL);
 927                                                 snprintf(buf, sizeof(buf), "%d", bubble_data->threadId);
 928                                                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_THREAD_ID, buf);
 929
 930                                                 ug_send_result(cd->ug, svc_handle);
 931
 932                                                 service_destroy(svc_handle);
 933                                         }
 934                                 } else {
 935                                         D_MSG("msg_delete_thread_message_list failed");
 936                                 }
 937                         } else {
 938                                 /* delete draft message */
 939                                 msg_struct_list_s msg_list = {0,};
 940
 941                                 if (msg_get_message_list(cd->msg_handle, MSG_DRAFT_ID, bubble_data->threadId, 0, 0, &msg_list) == COMPOSER_RETURN_SUCCESS) {
 942                                         int i = 0;
 943                                         int msgid = 0;
 944
 945                                         for (i = 0; i < msg_list.nCount; i++) {
 946                                                 msg_get_int_value(msg_list.msg_struct_info[i], MSG_MESSAGE_ID_INT, &msgid);
 947                                                 D_MSG("draft msg_id is %d", msgid);
 948                                                 if (msg_delete_message(cd->msg_handle, msgid) != COMPOSER_RETURN_SUCCESS)
 949                                                         D_EMSG("msg_ui_comp_core_delete_message is failed = %d", msgid);
 950                                         }
 951                                 }
 952
 953                                 msg_release_list_struct(&msg_list);
 954                         }
 955                 } else if (edit_state == COMPOSER_EDIT_RECIPIENT_AND_BODY) {
 956                         /* auto saving */
 957                         msg_ui_composer_message_init();
 958
 959                         if (msg_ui_composer_get_message_data(cd) == COMPOSER_RETURN_SUCCESS) {
 960                                 /* delete draft message */
 961                                 msg_thread_id_t tid = 0;
 962
 963                                 if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
 964                                         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
 965                                         tid = bubble_data->threadId;
 966                                 } else {
 967                                         GSList *address_list = msg_ui_composer_message_get_address();
 968                                         msg_ui_composer_get_thread_id_by_address(cd->msg_handle, address_list, &tid);
 969                                 }
 970
 971                                 D_MSG("tid = %d", tid);
 972                                 if (tid > 0)
 973                                         msg_ui_composer_delete_draft_message(cd->msg_handle, tid);
 974
 975                                 D_MSG("save draft message");
 976                                 msg_ui_composer_save_message(cd->msg_handle, 0);
 977                         }
 978
 979                         msg_ui_composer_message_destroy();
 980                 }
 981
 982                 /* clear recipient_list of bubble composer */
 983                 msg_ui_composer_recipient_clear_recipient_list(cd);
 984         }
 985
 986         /*process reset*/
 987         msg_ui_composer_reset(cd, svc_handle);
 988
 989         D_LEAVE;
 990 }
 991
 992 /*
 993  *      1. clear all composer editing obj
 994  *      2. make composer using bundle val
 995 */
 996 COMPOSER_RETURN_TYPE_E msg_ui_composer_reset(MSG_COMPOSER_VIEW_DATA_S *cd, service_h svc_handle)
 997 {
 998         D_ENTER;
 999         if (!cd)
1000                 return COMPOSER_RETURN_FAIL;
1001
1002         if (cd->working_path) {
1003                 ecore_file_recursive_rm(cd->working_path);
1004                 g_free(cd->working_path);
1005         }
1006
1007         cd->working_path = msg_composer_create_working_dir();
1008
1009         if (cd->working_path == NULL) {
1010                 D_EMSG("Fail of make working dir!!!");
1011                 return COMPOSER_RETURN_FAIL;
1012         }
1013
1014         if (svc_handle) {
1015                 msg_ui_composer_clear(cd);
1016
1017                 char *thread_id = NULL;
1018                 char *msg_id = NULL;
1019                 char *composer_mode = NULL;
1020                 char *from = NULL;
1021
1022                 service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_THREAD_ID, &thread_id);
1023                 service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_MSG_ID, &msg_id);
1024                 service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_MODE, &composer_mode);
1025                 service_get_extra_data(svc_handle, MSG_BUNDLE_KEY_FROM, &from);
1026
1027                 if (composer_mode) {
1028                         if (g_strcmp0(composer_mode, MSG_BUNDLE_VALUE_EDIT) == 0)
1029                                 cd->composer_mode = MSG_COMPOSER_MODE_EDIT;
1030                         else if (g_strcmp0(composer_mode, MSG_BUNDLE_VALUE_FORWARD) == 0)
1031                                 cd->composer_mode = MSG_COMPOSER_MODE_FORWARD;
1032                         else
1033                                 cd->composer_mode = MSG_COMPOSER_MODE_NORMAL;
1034                 } else {
1035                         cd->composer_mode = MSG_COMPOSER_MODE_NORMAL;
1036                 }
1037
1038                 if (from && g_strcmp0(from, MSG_BUNDLE_VALUE_INTERNAL) == 0)
1039                         cd->isMsgInternal = true;
1040                 else
1041                         cd->isMsgInternal = false;
1042
1043                 /*Change to Bubble view*/
1044                 if ((thread_id || msg_id) && cd->composer_mode == MSG_COMPOSER_MODE_NORMAL) {
1045                         D_MSG("bubble view composer mode = %d, msg_ug_mode = %d", cd->composer_mode, cd->msg_ug_mode);
1046
1047                         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER) {
1048                                 D_MSG("change bubble view");
1049                                 msg_ui_composer_change_bubble_view(cd);
1050                                 msg_ui_bubble_parse_bubble_data(cd->bubble_data, svc_handle);
1051                                 msg_ui_bubble_start_view(cd->bubble_data);
1052                                 msg_ui_composer_navi_title_set((void *)cd);
1053
1054                                 /* set recipient list for bubble composer */
1055                                 msg_ui_composer_recipient_set_recipient_list(cd, cd->bubble_data->threadId);
1056                         } else if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
1057                                 D_MSG("reload bubble view");
1058                                 msg_ui_bubble_parse_bubble_data(cd->bubble_data, svc_handle);
1059                                 msg_ui_bubble_list_load(cd->bubble_data);
1060                                 msg_ui_composer_navi_title_set((void *)cd);
1061
1062                                 /* set recipient list for bubble composer */
1063                                 msg_ui_composer_recipient_set_recipient_list(cd, cd->bubble_data->threadId);
1064                         } else {
1065                                 D_EMSG("Invalid type");
1066                         }
1067
1068                         cd->msg_ug_mode = MSG_UG_MODE_BUBBLE_COMPOSER;
1069                 } else {
1070                         D_MSG("normal composer composer mode = %d, msg_ug_mode = %d", cd->composer_mode, cd->msg_ug_mode);
1071
1072                         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
1073                                 D_MSG("change composer view");
1074                                 if (cd->bubble_data) {
1075                                         cd->bubble_data->ug_state = BUBBLE_UG_DESTROY;
1076                                         msg_ui_bubble_deinit_bubble_data(cd->bubble_data);
1077                                         cd->bubble_data = NULL;
1078                                 }
1079
1080                                 msg_ui_composer_change_composer_view(cd);
1081                         }
1082
1083                         if (cd->isMsgInternal == true)
1084                                 cd->msg_ug_mode = MSG_UG_MODE_FULL_COMPOSER;
1085                         else
1086                                 cd->msg_ug_mode = MSG_UG_MODE_ONLY_COMPOSER;
1087
1088                         __msg_ui_composer_bundle_data_process(cd, svc_handle);
1089                 }
1090         }
1091
1092         D_LEAVE;
1093         return COMPOSER_RETURN_SUCCESS;
1094 }
1095
1096 COMPOSER_RETURN_TYPE_E msg_ui_composer_start(MSG_COMPOSER_VIEW_DATA_S *cd, service_h svc_handle)
1097 {
1098         D_ENTER;
1099         D_MSG_RETVM_IF(cd == NULL, COMPOSER_RETURN_FAIL, "Composer Data is NULL");
1100
1101         COMPOSER_RETURN_TYPE_E ret = COMPOSER_RETURN_SUCCESS;
1102         cd->state = COMPOSER_STATE_TYPE_RUNNING;
1103
1104         /* bundle data parsing */
1105         if (svc_handle) {
1106                 if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1107                         cd->isLoad = true;
1108                         __msg_ui_composer_bundle_data_process(cd, svc_handle);
1109
1110                         if (cd->attachlist == NULL)
1111                                 cd->isLoad = false;
1112
1113                 } else if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
1114                         D_MSG("START BUBBLE COMPOSER");
1115                         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)cd->bubble_data;
1116                         msg_ui_bubble_parse_bubble_data(bubble_data, svc_handle);
1117                         msg_ui_bubble_start_view(bubble_data);
1118                         msg_ui_composer_navi_title_set((void *)cd);
1119
1120                         /* set recipient list for bubble composer */
1121                         msg_ui_composer_recipient_set_recipient_list(cd, cd->bubble_data->threadId);
1122                 }
1123         }
1124
1125         /* set first focus*/
1126         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1127                 if (!msg_ui_composer_popup_exist(cd)) {
1128
1129                         int recipient_count = msg_ui_composer_recipient_count_get(cd->recipient);
1130
1131                         if (recipient_count > 0) {
1132                                 msg_ui_composer_body_focus_set(cd, 0);
1133                                 msg_ui_composer_recipient_expanded_set(cd->recipient, EINA_FALSE);
1134                         } else {
1135                                 msg_ui_composer_recipient_focus_set(cd->recipient);
1136                         }
1137                 }
1138         }
1139
1140         D_LEAVE;
1141         return ret;
1142 }
1143
1144 static void __msg_composer_auto_save_and_delete_msg(MSG_COMPOSER_VIEW_DATA_S *cd)
1145 {
1146         D_ENTER;
1147         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
1148
1149         /* save and delete msg */
1150         if (!cd->disable_auto_save_mode) {
1151                 COMPOSER_EDIT_STATE_E edit_state = __msg_ui_composer_edit_check(cd);
1152                 if (edit_state == COMPOSER_EDIT_RECIPIENT_AND_BODY) {
1153
1154                         /* auto save composer data */
1155                         msg_ui_composer_message_init();
1156                         if (msg_ui_composer_get_message_data(cd) == COMPOSER_RETURN_SUCCESS) {
1157                                 /* delete draft message */
1158                                 msg_thread_id_t tid = 0;
1159
1160                                 if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
1161                                         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
1162                                         tid = bubble_data->threadId;
1163                                 } else {
1164                                         GSList *address_list = msg_ui_composer_message_get_address();
1165                                         msg_ui_composer_get_thread_id_by_address(cd->msg_handle, address_list, &tid);
1166                                 }
1167
1168                                 D_MSG("tid = %d", tid);
1169                                 if (tid > 0)
1170                                         msg_ui_composer_delete_draft_message(cd->msg_handle, tid);
1171
1172                                 D_MSG("save draft message");
1173                                 msg_ui_composer_save_message(cd->msg_handle, 0);
1174                                 /* show saved ticker popup */
1175                                 msg_ui_composer_common_tickernoti(cd, COMPOSER_TICKERNOTI_AUTO_SAVED);
1176                         }
1177
1178                         msg_ui_composer_message_destroy();
1179                 } else if (edit_state == COMPOSER_EDIT_RECIPIENT) {
1180                         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
1181                                 /* delete draft message */
1182                                 MSG_BUBBLE_DATA *bubble_data = cd->bubble_data;
1183
1184                                 if (bubble_data) {
1185                                         msg_ui_composer_delete_draft_message(cd->msg_handle, bubble_data->threadId);
1186                                 }
1187                         }
1188                 }
1189         }
1190
1191         D_LEAVE;
1192 }
1193
1194 COMPOSER_RETURN_TYPE_E msg_ui_composer_destroy(MSG_COMPOSER_VIEW_DATA_S *cd)
1195 {
1196         D_ENTER;
1197
1198         COMPOSER_RETURN_TYPE_E ret = COMPOSER_RETURN_SUCCESS;
1199         if (!cd)
1200                 return COMPOSER_RETURN_FAIL;
1201
1202         D_PRINT("===== Composer UG Destroy Start =====");
1203
1204         __msg_composer_auto_save_and_delete_msg(cd);
1205
1206         /* discoonect volume key handler */
1207         msg_ui_composer_disconnect_handler(cd);
1208
1209         contacts_disconnect2();
1210
1211         D_PRINT("----- Unregister vconf callback -----");
1212         if (vconf_ignore_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, __msgc_vconf_changed_cb) < 0) {
1213                 D_EMSG("Fail to unregister vconf CB with [%s]", VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE);
1214         }
1215         if (vconf_ignore_key_changed(VCONFKEY_MSG_APP_FONT_SIZE, __msgc_vconf_changed_cb) < 0) {
1216                 D_EMSG("Fail to unregister vconf CB with [%s]", VCONFKEY_MSG_APP_FONT_SIZE);
1217         }
1218
1219         if (cd->tapi_handle) {
1220                 if (tel_deinit(cd->tapi_handle) != TAPI_API_SUCCESS)
1221                         D_EMSG("tel_deinit is failed");
1222                 cd->tapi_handle = NULL;
1223         }
1224
1225         if(cd->job_thread_end) {
1226                 D_PRINT("----- Job Delete -----");
1227                 ecore_job_del(cd->job_thread_end);
1228                 cd->job_thread_end = NULL;
1229         }
1230
1231         if(cd->attach_thread) {
1232                 D_PRINT("----- Thread Delete -----");
1233                 ecore_thread_cancel(cd->attach_thread);
1234                 cd->attach_thread = NULL;
1235         }
1236
1237         if (cd->last_focus_idler) {
1238                 D_PRINT("----- idler Delete -----");
1239                 ecore_idler_del(cd->last_focus_idler);
1240                 cd->last_focus_idler = NULL;
1241         }
1242
1243         if (cd->flight_mode_timer) {
1244                 ecore_timer_del(cd->flight_mode_timer);
1245                 cd->flight_mode_timer = NULL;
1246         }
1247
1248         if (cd->recipient) {
1249                 D_PRINT("----- Recipient Delete -----");
1250                 msg_ui_composer_recipient_delete(cd->recipient);
1251                 cd->recipient = NULL;
1252         }
1253
1254         D_PRINT("----- Recipient list Clear -----");
1255         msg_ui_composer_recipient_clear_recipient_list(cd);
1256
1257         D_PRINT("----- Predict Search Delete -----");
1258         msg_ui_composer_predictsearch_list_delete(cd);
1259
1260         D_PRINT("----- Body Delete -----");
1261         msg_ui_composer_body_delete(cd);
1262
1263         D_PRINT("----- Close Msg Handle -----");
1264         msg_close_msg_handle(&cd->msg_handle);
1265
1266         D_PRINT("----- Delete Popup  -----");
1267         msg_ui_composer_popup_delete_all(cd);
1268
1269         if (cd->working_path) {
1270                 ecore_file_recursive_rm(cd->working_path);
1271                 g_free(cd->working_path);
1272                 cd->working_path = NULL;
1273         }
1274
1275         if (cd->th) {
1276                 elm_theme_extension_del(cd->th, MSG_CUSTOM_WINSET_EDJ);
1277                 elm_theme_free(cd->th);
1278                 cd->th = NULL;
1279         }
1280
1281         /* rollback indicator mode to previous mode */
1282         elm_win_indicator_mode_set(cd->main_window, cd->indicator_mode);
1283
1284         D_PRINT("===== Composer UG Destroy End =====");
1285
1286         D_LEAVE;
1287         return ret;
1288 }
1289
1290 void msg_ui_composer_change_language(MSG_COMPOSER_VIEW_DATA_S *cd)
1291 {
1292         D_ENTER;
1293         D_MSG_RETM_IF(cd == NULL, "cd is NULL");
1294
1295         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1296                 /* destroy popup */
1297                 msg_ui_composer_popup_delete_all(cd);
1298
1299                 if (cd->ctx_popup) {
1300                         evas_object_del(cd->ctx_popup);
1301                         cd->ctx_popup = NULL;
1302                 }
1303
1304                 /* title */
1305                 msg_ui_composer_navi_title_set(cd);
1306
1307                 /* recipient */
1308                 if (cd->recipient) {
1309                         Evas_Object *mbe = cd->recipient->mbe;
1310
1311                         /* set mbe label */
1312                         char label_txt[TO_FIELD_LABEL_SIZE_MAX] = { 0, };
1313                         gsize len = 0;
1314
1315                         len = snprintf(label_txt, (gsize)sizeof(label_txt), "%s:", MSGC_STR_TO);
1316                         if (len == -1) {
1317                                 D_EMSG("len = %d", len);
1318                         } else if (len > 0) {
1319                                 label_txt[len] = '\0';
1320                                 elm_object_text_set(mbe, label_txt);
1321                         } else {
1322                                 D_EMSG("len = %d", len);
1323                         }
1324
1325                         /* set guide text */
1326                         elm_object_part_text_set(mbe, "guide", MSGC_STR_ADD_RECIPIENT);
1327                 }
1328
1329                 /* subject */
1330                 if (cd->sub_data.entry)
1331                         edje_object_part_text_set(_EDJ(cd->sub_data.layout), "subject.guidetxt", MSGC_STR_SUBJECT);
1332
1333                 /* attachment */
1334                 if (cd->ly_attach_main) {
1335                         char buf[DEF_BUF_LEN_S + 1] = {0,};
1336                         const char *str = _MSGSTR("IDS_MSGC_BODY_PD_ATTACHMENTS");
1337
1338                         snprintf(buf, sizeof(buf), str, cd->attach_data.attachment_Cnt);
1339                         edje_object_part_text_set(_EDJ(cd->ly_attach_main), "text.filename", buf);
1340                 }
1341
1342                 /* mms size */
1343                 if (cd->msg_type == COMPOSER_MSG_TYPE_MMS)
1344                         msg_ui_composer_body_info_area_update(cd);
1345         }
1346
1347         cd->isclosed = false;
1348
1349         D_LEAVE;
1350 }
1351
1352 COMPOSER_RETURN_TYPE_E msg_ui_composer_rotate(MSG_COMPOSER_VIEW_DATA_S *cd, COMPOSER_ROTATE_TYPE_E rotate)
1353 {
1354         D_ENTER;
1355         D_MSG_RETVM_IF(cd == NULL, COMPOSER_RETURN_FAIL, "cd is NULL");
1356
1357         cd->rotate = rotate;
1358         D_MSG("rotate val [%d]", rotate);
1359
1360         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1361
1362                 RECIPIENT_S *r = cd->recipient;
1363                 if (!r) return COMPOSER_RETURN_FAIL;
1364
1365                 if (rotate == COMPOSER_ROTATE_PORTRAIT || rotate == COMPOSER_ROTATE_PORTRAIT_UPSIDEDOWN) {
1366                         elm_layout_theme_set(cd->base, "layout", "application", "default");
1367
1368                         elm_win_indicator_mode_set(cd->main_window, ELM_WIN_INDICATOR_SHOW);
1369
1370                         elm_box_horizontal_set(r->bx_main, EINA_FALSE);
1371                         elm_scroller_content_min_limit(r->sc, EINA_FALSE, EINA_TRUE);
1372                         evas_object_size_hint_max_set(r->sc, 9999, COMPOSER_RECIPIENT_PORTRAIT_HEIGHT_MAX);
1373                 } else if (rotate == COMPOSER_ROTATE_LANDSCAPE || rotate == COMPOSER_ROTATE_LANDSCAPE_UPSIDEDOWN) {
1374                         elm_layout_theme_set(cd->base, "layout", "application", "noindicator");/*hide indicator in Landscape*/
1375                         elm_win_indicator_mode_set(cd->main_window, ELM_WIN_INDICATOR_HIDE);
1376                         D_MSG("hide indicator");
1377                         elm_box_horizontal_set(r->bx_main, EINA_TRUE);
1378                         elm_scroller_content_min_limit(r->sc, EINA_FALSE, EINA_FALSE);
1379                         evas_object_size_hint_max_set(r->sc, 9999, -1);
1380                 }
1381
1382                 /* change body scroller size */
1383                 msg_ui_composer_change_body_scroll_size(cd, 0);
1384
1385         } else if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER) {
1386                 if (rotate == COMPOSER_ROTATE_PORTRAIT || rotate == COMPOSER_ROTATE_PORTRAIT_UPSIDEDOWN) {
1387                         if (cd->bubble_data)
1388                                 cd->bubble_data->isRotate = false;
1389
1390                         if (cd->compose_btn) {
1391                                 evas_object_hide(cd->compose_btn);
1392                                 elm_object_part_content_unset(cd->navi_title_layout, "compose_btn");
1393                         }
1394                 } else if (rotate == COMPOSER_ROTATE_LANDSCAPE || rotate == COMPOSER_ROTATE_LANDSCAPE_UPSIDEDOWN) {
1395                         if (cd->bubble_data) {
1396                                 cd->bubble_data->isRotate = true;
1397
1398                                 if (cd->compose_btn && cd->bubble_data->viewmode == BUBBLE_NORMAL_VIEW) {
1399                                         evas_object_show(cd->compose_btn);
1400                                         elm_object_part_content_set(cd->navi_title_layout, "compose_btn", cd->compose_btn);
1401                                 }
1402                         }
1403                 }
1404
1405                 elm_win_indicator_mode_set(cd->main_window, ELM_WIN_INDICATOR_SHOW);
1406
1407                 /* change body scroller size */
1408                 msg_ui_composer_change_body_scroll_size(cd, 0);
1409
1410         } else {
1411                 D_EMSG("Unknown Composer Mode");
1412                 return COMPOSER_RETURN_FAIL;
1413         }
1414
1415         D_LEAVE;
1416         return COMPOSER_RETURN_SUCCESS;
1417 }
1418
1419 COMPOSER_RETURN_TYPE_E msg_ui_composer_init(MSG_COMPOSER_VIEW_DATA_S *cd)
1420 {
1421         D_ENTER;
1422
1423         if (cd == NULL) {
1424                 D_EMSG("[ASSERT] pcmop_data is NULL");
1425                 return COMPOSER_RETURN_FAIL;
1426         }
1427
1428         /* create message handle */
1429         if (msg_open_msg_handle(&cd->msg_handle) != MSG_SUCCESS) {
1430                 D_EMSG("[ASSERT] msg-server doesn't response !!!");
1431                 return COMPOSER_RETURN_FAIL;
1432         }
1433
1434         /* set message sent status callback */
1435         if (msg_reg_sent_status_callback(cd->msg_handle, &__msg_ui_composer_sent_status_cb, cd) != MSG_SUCCESS) {
1436                 D_EMSG("[ASSERT] sent status callback register error!!!");
1437                 return COMPOSER_RETURN_FAIL;
1438         }
1439
1440         /* connect contacts svc*/
1441         if (contacts_connect2() != 0) {
1442                 D_EMSG("[ASSERT] Fail of contacts_connect2 !!!");
1443                 return COMPOSER_RETURN_FAIL;
1444         }
1445
1446         cd->working_path = msg_composer_create_working_dir();
1447         if (cd->working_path == NULL) {
1448                 D_EMSG("[ASSERT] Fail of make working dir!!!");
1449                 return COMPOSER_RETURN_FAIL;
1450         }
1451
1452         /* set default message type is SMS */
1453         cd->msg_type = COMPOSER_MSG_TYPE_SMS;
1454
1455         /* get sms setting */
1456         msg_struct_t sms_sent_opt = msg_create_struct(MSG_STRUCT_SETTING_SMS_SEND_OPT);
1457
1458         if (msg_get_sms_send_opt(cd->msg_handle, sms_sent_opt) != MSG_SUCCESS) {
1459                 D_EMSG("Getting SMS_SEND_OP ERROR");
1460         } else {
1461                 msg_get_int_value(sms_sent_opt, MSG_SMS_SENDOPT_ENCODE_TYPE_INT, &cd->encode_mode);
1462                 D_MSG("SMS Encode mode is %d", cd->encode_mode);
1463         }
1464
1465         msg_release_struct(&sms_sent_opt);
1466
1467         if (cd->cms_max_page == 0) {
1468                 // TODO: get cms max page from msgfw when it is supported by msgfw.
1469                 cd->cms_max_page = COMPOSER_CMS_MAX_PAGE;
1470         }
1471
1472         /* get mms max size */
1473         if (cd->mms_max_size == 0) {
1474                 msg_struct_t setting = msg_create_struct(MSG_STRUCT_SETTING_MSGSIZE_OPT);
1475
1476                 if (msg_get_msgsize_opt(cd->msg_handle, setting) != MSG_SUCCESS) {
1477                         D_EMSG("Getting MMS MAX SIZE ERROR");
1478                 } else {
1479                         if (setting)
1480                                 msg_get_int_value(setting, MSG_MESSAGE_SIZE_INT, &cd->mms_max_size);
1481
1482                         D_MSG("msg max size = [%d KB] !!!", cd->mms_max_size);
1483                         cd->mms_max_size = cd->mms_max_size * 1024;
1484                 }
1485                 msg_release_struct(&setting);
1486         }
1487
1488         /* set default font size*/
1489         __msgc_init_font_size(cd);
1490
1491         /* coonect volume key handler */
1492         msg_ui_composer_connect_handler(cd);
1493
1494         /* register vconf callback function */
1495         if (vconf_notify_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, __msgc_vconf_changed_cb, cd) < 0) {
1496                 D_EMSG("Fail to register vconf CB with [%s]", VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE);
1497         }
1498         if (vconf_notify_key_changed(VCONFKEY_MSG_APP_FONT_SIZE, __msgc_vconf_changed_cb, cd) < 0) {
1499                 D_EMSG("Fail to register vconf CB with [%s]", VCONFKEY_MSG_APP_FONT_SIZE);
1500         }
1501
1502         cd->th = elm_theme_new();
1503         elm_theme_ref_set(cd->th, NULL);
1504         elm_theme_extension_add(cd->th, MSG_CUSTOM_WINSET_EDJ);
1505
1506         return COMPOSER_RETURN_SUCCESS;
1507 }
1508
1509 /*
1510  * Create Composer First View
1511  */
1512 COMPOSER_RETURN_TYPE_E msg_ui_composer_create(MSG_COMPOSER_VIEW_DATA_S *cd)
1513 {
1514         D_ENTER;
1515         D_MSG_RETVM_IF(cd == NULL, COMPOSER_RETURN_FAIL, "Composer data is NULL");
1516         D_MSG_RETVM_IF(cd->main_window == NULL, COMPOSER_RETURN_FAIL, "main_window is NULL");
1517         D_MSG_RETVM_IF(cd->base == NULL, COMPOSER_RETURN_FAIL, "base layout is NULL");
1518
1519         Evas_Object *navi_frame = NULL;
1520         Evas_Object *more_button = NULL;
1521         Evas_Object *compose_button = NULL;
1522         Evas_Object *content_layout = NULL;
1523         Elm_Object_Item *navi_it = NULL;
1524         Evas_Object *back_btn = NULL;
1525
1526         /* State Set */
1527         cd->state = COMPOSER_STATE_TYPE_CREATE;
1528
1529         /* Create naviframe */
1530         navi_frame = elm_naviframe_add(cd->base);
1531         if (!navi_frame) {
1532                 D_EMSG("naviframe add fail");
1533                 goto error_return;
1534         }
1535
1536         evas_object_show(navi_frame);
1537         cd->navi_bar = navi_frame;
1538
1539         /* Create content layout */
1540         content_layout = elm_layout_add(navi_frame);
1541         if (!content_layout) {
1542                 D_EMSG("layout add fail");
1543                 goto error_return;
1544         }
1545
1546         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1547                 elm_layout_file_set(content_layout, MSGC_UI_DEFAULT_EDJ, MSGC_EDJ_GRP_CONTENT_LAYOUT);
1548         } else if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER){
1549                 elm_layout_file_set(content_layout, MSGC_UI_DEFAULT_EDJ, MSGC_EDJ_GRP_CONTENT_LAYOUT);
1550                 edje_object_signal_emit(_EDJ(content_layout), "change.bubble", "*");
1551         } else {
1552                 D_EMSG("UG mode Unknown");
1553                 goto error_return;
1554         }
1555
1556         evas_object_size_hint_weight_set(content_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1557         evas_object_size_hint_align_set(content_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
1558         edje_object_signal_emit(_EDJ(content_layout), "hide.predictsearch", "*");
1559         evas_object_show(content_layout);
1560
1561         cd->content_layout = content_layout;
1562
1563         /*Create content*/
1564         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1565                 cd->recipient = msg_ui_composer_recipient_create(content_layout, 1, cd);
1566                 if (cd->recipient == NULL)
1567                         goto error_return;
1568
1569                 elm_object_part_content_set(content_layout, "swl.recipient", cd->recipient->bx_main);
1570
1571                 Evas_Object *predict_search_layout = msg_ui_composer_predictsearch_list_create(content_layout, cd);
1572                 elm_object_part_content_set(content_layout, "swl.predictsearch", predict_search_layout);
1573
1574         } else {
1575                 PMSG_BUBBLE_DATA bubble_data = msg_ui_bubble_init_bubble_data(cd->msg_handle, cd);
1576                 if (!bubble_data) {
1577                         goto error_return;
1578                 }
1579
1580                 cd->bubble_data = bubble_data;
1581
1582                 Evas_Object *bubble_layout = msg_ui_bubble_create_view(content_layout, cd->bubble_data);
1583                 if (!bubble_layout) {
1584                         goto error_return;
1585                 }
1586                 elm_object_part_content_set(content_layout, "swl.bubble.content", bubble_layout);
1587         }
1588
1589         Evas_Object *body_layout = msg_ui_composer_body_create(cd, content_layout);
1590         if (!body_layout) {
1591                 goto error_return;
1592         }
1593
1594         elm_object_part_content_set(content_layout, "swl.composer.body", body_layout);
1595
1596         cd->ly_body = body_layout;
1597
1598         /*Push content to navi frame*/
1599         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1600                 if (cd->isMsgInternal)
1601                         back_btn = __naviframe_back_btn_create(navi_frame, (void *)cd, false);
1602                 else
1603                         back_btn = __naviframe_back_btn_create(navi_frame, (void *)cd, true);
1604         } else {
1605                 back_btn = __naviframe_back_btn_create(navi_frame, (void *)cd, false);
1606         }
1607
1608         navi_it = elm_naviframe_item_push(navi_frame, NULL, NULL, NULL, content_layout, "empty");
1609
1610         cd->navi_it = navi_it;
1611         cd->back_btn = back_btn;
1612
1613         /* create navi title layout */
1614         cd->navi_title_layout = msg_ui_composer_create_navi_title_bar(cd);
1615         msg_ui_composer_navi_title_set(cd);
1616         elm_object_item_part_content_set(cd->navi_it, "title", cd->navi_title_layout);
1617
1618         /*Create more button*/
1619         more_button = __naviframe_more_btn_create(navi_frame, cd);
1620
1621         elm_object_part_content_set(cd->navi_title_layout, "more_btn", more_button);
1622         elm_object_part_content_set(cd->navi_title_layout, "prev_btn", back_btn);
1623
1624         cd->more_btn = more_button;
1625
1626         if (cd->msg_type == COMPOSER_MSG_TYPE_SMS)
1627                 elm_object_disabled_set(cd->more_btn, EINA_TRUE);
1628
1629         /*Create compose button*/
1630         compose_button = __naviframe_compose_btn_create(navi_frame, cd);
1631
1632         if (cd->bubble_data != NULL && cd->bubble_data->isRotate == true) {
1633                 evas_object_show(compose_button);
1634                 elm_object_part_content_set(cd->navi_title_layout, "compose_btn", compose_button);
1635         } else {
1636                 evas_object_hide(compose_button);
1637                 elm_object_part_content_unset(cd->navi_title_layout, "compose_btn");
1638         }
1639
1640         cd->compose_btn = compose_button;
1641
1642         /* set navibar to main layout (base) */
1643         elm_object_part_content_set(cd->base, "elm.swallow.content", navi_frame);
1644
1645         D_LEAVE;
1646         return COMPOSER_RETURN_SUCCESS;
1647
1648 error_return:
1649         return COMPOSER_RETURN_FAIL;
1650 }
1651
1652 COMPOSER_RETURN_TYPE_E msg_ui_composer_bubble_data_set(MSG_COMPOSER_VIEW_DATA_S *cd, int thread_id)
1653 {
1654         D_ENTER;
1655         D_MSG_RETVM_IF(cd == NULL, COMPOSER_RETURN_FAIL, "Composer data is NULL");
1656         D_MSG_RETVM_IF(cd->msg_ug_mode != MSG_UG_MODE_BUBBLE_COMPOSER, COMPOSER_RETURN_FAIL, "msg_ug_mode is NOT BUBBLE TYPE");
1657         D_MSG_RETVM_IF(thread_id <=  0, COMPOSER_RETURN_FAIL, "Composer mode is Not Full");
1658         D_MSG_RETVM_IF(cd->bubble_data == NULL, COMPOSER_RETURN_FAIL, "bubble data is NULL");
1659
1660         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
1661         msg_struct_t threadInfo = NULL;
1662         int err;
1663
1664         /*Create bubble list*/
1665         bubble_data->threadId = thread_id;
1666         D_MSG("Thread ID = %d", bubble_data->threadId);
1667
1668         msg_struct_list_s addrList;
1669         int i = 0;
1670         memset(&addrList, 0x00, sizeof(msg_struct_list_s));
1671
1672         err = msg_get_address_list(bubble_data->msgHandle, bubble_data->threadId, &addrList);
1673
1674         if (err == MSG_SUCCESS) {
1675                 bubble_data->addr_list.addr_cnt = addrList.nCount;
1676
1677                 for (i = 0; i<addrList.nCount; i++) {
1678                         int contact_id = 0;
1679                         msg_get_int_value(addrList.msg_struct_info[i], MSG_ADDRESS_INFO_CONTACT_ID_INT, &contact_id);
1680                         /** addresss */
1681                         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);
1682
1683                         /** contact ID & display name */
1684                         if (contact_id > 0) {
1685                                 bubble_data->addr_list.addr_info[i].contact_id = contact_id;
1686                                 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);
1687                         } else {
1688                                 bubble_data->addr_list.addr_info[i].contact_id = 0;
1689                         }
1690                 }
1691
1692                 msg_release_list_struct(&addrList);
1693         } else {
1694                 D_MSG("[ERROR] msg_get_address_list returns error [%d]", err);
1695         }
1696
1697         threadInfo = msg_create_struct(MSG_STRUCT_THREAD_INFO);
1698         err = msg_get_thread(bubble_data->msgHandle, bubble_data->threadId, threadInfo);
1699
1700         if (err == MSG_SUCCESS)
1701                 msg_get_str_value(threadInfo, MSG_THREAD_NAME_STR, bubble_data->threadName, DEF_THREAD_NAME_LEN);
1702         else
1703                 D_MSG("[ERROR] msg_get_trhead returns error [%d", err);
1704
1705         msg_release_struct(&threadInfo);
1706
1707         return COMPOSER_RETURN_SUCCESS;
1708 }
1709
1710 COMPOSER_RETURN_TYPE_E msg_ui_composer_change_composer_view(MSG_COMPOSER_VIEW_DATA_S *cd)
1711 {
1712         D_ENTER;
1713         D_MSG_RETVM_IF(cd == NULL, COMPOSER_RETURN_FAIL, "Composer data is NULL");
1714         D_MSG_RETVM_IF(cd->msg_ug_mode != MSG_UG_MODE_BUBBLE_COMPOSER, COMPOSER_RETURN_FAIL, "Composer mode is Not Full");
1715
1716         /*Change Mode */
1717         cd->msg_ug_mode = MSG_UG_MODE_ONLY_COMPOSER;
1718
1719         /*Change content layout to composer layout*/
1720         edje_object_signal_emit(_EDJ(cd->content_layout), "change.composer", "*");
1721
1722         elm_scroller_content_min_limit(cd->body_scroll, 0, 0);
1723
1724         cd->recipient = msg_ui_composer_recipient_create(cd->content_layout, 1, cd);
1725         elm_object_part_content_set(cd->content_layout, "swl.recipient", cd->recipient->bx_main);
1726
1727         Evas_Object *predict_search_layout = msg_ui_composer_predictsearch_list_create(cd->content_layout, cd);
1728         elm_object_part_content_set(cd->content_layout, "swl.predictsearch", predict_search_layout);
1729
1730         MSGC_EVAS_OBJECT_DEL(cd->back_btn);
1731         Evas_Object *back_btn = __naviframe_back_btn_create(cd->navi_bar, (void *)cd, true);
1732         elm_object_part_content_set(cd->navi_title_layout, "prev_btn", back_btn);
1733         cd->back_btn = back_btn;
1734
1735         msg_ui_composer_navi_title_set(cd);
1736
1737         D_LEAVE;
1738         return COMPOSER_RETURN_SUCCESS;
1739 }
1740
1741 COMPOSER_RETURN_TYPE_E msg_ui_composer_change_bubble_view(MSG_COMPOSER_VIEW_DATA_S *cd)
1742 {
1743         D_ENTER;
1744         D_MSG_RETVM_IF(cd == NULL, COMPOSER_RETURN_FAIL, "Composer data is NULL");
1745         D_MSG_RETVM_IF(cd->msg_ug_mode != MSG_UG_MODE_FULL_COMPOSER, COMPOSER_RETURN_FAIL, "Composer mode is Not Full");
1746
1747         /*Change Mode */
1748         cd->msg_ug_mode = MSG_UG_MODE_BUBBLE_COMPOSER;
1749
1750         /*Change content layout to bubble layout*/
1751         edje_object_signal_emit(_EDJ(cd->content_layout), "hide.predictsearch", "*");
1752         edje_object_signal_emit(_EDJ(cd->content_layout), "change.bubble", "*");
1753
1754         elm_scroller_content_min_limit(cd->body_scroll, 0, 1);
1755         evas_object_size_hint_max_set(cd->body_scroll, 9999, 250);
1756
1757         /*Init bubble data*/
1758         PMSG_BUBBLE_DATA bubble_data = msg_ui_bubble_init_bubble_data(cd->msg_handle, cd);
1759         if (!bubble_data)
1760                 return COMPOSER_RETURN_FAIL;
1761
1762         cd->bubble_data = (void *)bubble_data;
1763
1764         /*Change naviframe layout for bubble*/
1765         Evas_Object *cancel_btn = __naviframe_back_btn_create(cd->navi_bar, (void *)cd, false);
1766         elm_object_part_content_set(cd->navi_title_layout, "prev_btn", cancel_btn);
1767         cd->back_btn = cancel_btn;
1768
1769         Evas_Object *layout = msg_ui_bubble_create_view(cd->content_layout, cd->bubble_data); // First parameter should be 'content_layout'.
1770         elm_object_part_content_set(cd->content_layout, "swl.bubble.content", layout);
1771
1772         /*remove unused layout*/
1773         MSGC_EVAS_OBJECT_DEL(cd->ly_recipient);
1774         msg_ui_composer_recipient_delete(cd->recipient);
1775         cd->recipient = NULL;
1776
1777         msg_ui_composer_predictsearch_list_delete(cd);
1778
1779         return COMPOSER_RETURN_SUCCESS;
1780 }
1781
1782 /*
1783  * msg_ui_composer_editable_set
1784  * editable == FALSE : hide body content & disable more button & close option header
1785  * editable == TRUE : show body content layout
1786  * */
1787 void msg_ui_composer_editable_set(MSG_COMPOSER_VIEW_DATA_S *cd, Eina_Bool editable)
1788 {
1789         D_ENTER;
1790         D_MSG_RETM_IF(cd == NULL, "Composer Data is NULL");
1791
1792         if (editable == EINA_FALSE){
1793                 Evas_Object *body_layout = elm_object_part_content_unset(cd->content_layout, "swl.composer.body");
1794                 evas_object_hide(body_layout);
1795
1796                 if (cd->more_btn)
1797                         elm_object_disabled_set(cd->more_btn, EINA_TRUE);
1798         } else {
1799                 elm_object_part_content_set(cd->content_layout, "swl.composer.body", cd->ly_body);
1800                 evas_object_show(cd->ly_body);
1801
1802                 if (cd->more_btn)
1803                         elm_object_disabled_set(cd->more_btn, EINA_FALSE);
1804
1805         }
1806
1807         D_LEAVE;
1808 }
1809
1810 void msg_ui_composer_bubble_del_all(void *data, service_h svc_handle)
1811 {
1812         D_ENTER;
1813
1814         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1815         D_MSG_RETM_IF(cd == NULL, "Composer data is NULL");
1816
1817         ug_send_result(cd->ug, svc_handle);
1818 }
1819
1820 Evas_Object *msg_ui_composer_create_navi_title_bar(void *data)
1821 {
1822         D_ENTER;
1823
1824         if (!data) {
1825                 D_EMSG("[ERROR] data is NULL");
1826                 return NULL;
1827         }
1828
1829         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1830
1831         Evas_Object *title_layout = elm_layout_add(cd->navi_bar);
1832         elm_layout_file_set(title_layout, MSG_COMMON_EDJ, "title");
1833         evas_object_size_hint_weight_set(title_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1834         evas_object_size_hint_align_set(title_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
1835         evas_object_show(title_layout);
1836
1837         return title_layout;
1838 }
1839
1840 void msg_ui_composer_navi_title_set(void *data)
1841 {
1842         D_ENTER;
1843
1844         if (!data) {
1845                 D_EMSG("data is NULL");
1846                 return;
1847         }
1848
1849         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1850         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
1851
1852         if (cd->msg_ug_mode == MSG_UG_MODE_FULL_COMPOSER || cd->msg_ug_mode == MSG_UG_MODE_ONLY_COMPOSER) {
1853                 elm_object_part_text_set(cd->navi_title_layout, "title_text", MSGC_STR_NEW_MESSAGE);
1854         } else if (cd->msg_ug_mode ==  MSG_UG_MODE_BUBBLE_COMPOSER) {
1855                 Evas_Object *title_button = NULL;
1856
1857                 elm_object_part_text_set(cd->navi_title_layout, "title_text", ""); // text part clear first
1858
1859                 title_button = elm_button_add(cd->navi_bar);
1860
1861                 elm_object_theme_set(title_button, cd->th);
1862                 elm_object_style_set(title_button, "title_button");
1863
1864                 evas_object_size_hint_weight_set(title_button, 0.0, 0.0);
1865                 evas_object_size_hint_align_set(title_button, EVAS_HINT_FILL, EVAS_HINT_FILL);
1866
1867                 if (bubble_data->addr_list.addr_cnt == 1) {
1868                         if (bubble_data->addr_list.addr_info[0].contact_id > 0 && bubble_data->addr_list.addr_info[0].name[0] != '\0')
1869                                 elm_object_text_set(title_button, bubble_data->addr_list.addr_info[0].name);
1870                         else if (bubble_data->addr_list.addr_info[0].address[0] != '\0')
1871                                 elm_object_text_set(title_button, bubble_data->addr_list.addr_info[0].address);
1872                         else
1873                                 elm_object_text_set(title_button, dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"));
1874                 } else if (bubble_data->addr_list.addr_cnt > 1) {
1875                         char title_text[DEF_BUF_LEN+1] = {0,};
1876
1877                         if (bubble_data->addr_list.addr_info[0].contact_id > 0 && bubble_data->addr_list.addr_info[0].name[0] != '\0')
1878                                 snprintf(title_text, sizeof(title_text), "%s +%d", bubble_data->addr_list.addr_info[0].name, bubble_data->addr_list.addr_cnt-1);
1879                         else if (bubble_data->addr_list.addr_info[0].address[0] != '\0')
1880                                 snprintf(title_text, sizeof(title_text), "%s +%d", bubble_data->addr_list.addr_info[0].address, bubble_data->addr_list.addr_cnt-1);
1881                         else
1882                                 snprintf(title_text, sizeof(title_text), "%s +%d", dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"), bubble_data->addr_list.addr_cnt-1);
1883
1884                         elm_object_text_set(title_button, title_text);
1885                 } else {
1886                         elm_object_text_set(title_button, dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"));
1887                 }
1888
1889                 evas_object_show(title_button);
1890                 elm_object_part_content_set(cd->navi_title_layout, "title_btn", title_button);
1891                 evas_object_smart_callback_add(title_button, "clicked", msg_ui_bubble_title_button_clicked_cb, cd);
1892
1893                 bubble_data->title_button = title_button;
1894         } else {
1895                 D_EMSG("Invalid msg_ui_mode [%d]", cd->msg_ug_mode);
1896                 return;
1897         }
1898 }
1899
1900 static Eina_Bool __msgc_up_key_long_press_cb(void *data)
1901 {
1902         D_ENTER;
1903         D_MSG_RETVM_IF(data == NULL, EINA_FALSE, "cd is NULL");
1904         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1905
1906         if (!msg_common_increase_font_size()) {
1907                 cd->vol_up_key_longpress = NULL;
1908                 return EINA_FALSE;
1909         }
1910
1911         /* apply font size */
1912         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER)
1913                 msg_common_apply_font_size("bubble", cd->content_layout);
1914
1915         msg_ui_composer_apply_font_size(cd, false);
1916
1917         return EINA_TRUE;
1918 }
1919
1920 static Eina_Bool __msgc_down_key_long_press_cb(void *data)
1921 {
1922         D_ENTER;
1923         D_MSG_RETVM_IF(data == NULL, EINA_FALSE, "cd is NULL");
1924         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1925
1926         if (!msg_common_decrease_font_size()) {
1927                 cd->vol_down_key_longpress = NULL;
1928                 return EINA_FALSE;
1929         }
1930
1931         /* apply font size */
1932         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER)
1933                 msg_common_apply_font_size("bubble", cd->content_layout);
1934
1935         msg_ui_composer_apply_font_size(cd, false);
1936
1937         return EINA_TRUE;
1938 }
1939
1940 Eina_Bool msg_ui_composer_key_release_cb(void *data, int type, void *event)
1941 {
1942         D_ENTER;
1943         D_MSG_RETVM_IF(data == NULL, EINA_FALSE, "cd is NULL");
1944         D_MSG_RETVM_IF(event == NULL, EINA_FALSE, "event is NULL");
1945         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1946         Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
1947         int use_volume_key = false;
1948
1949         vconf_get_bool(VCONFKEY_MSG_APP_USE_VOLUME_KEY, &use_volume_key);
1950
1951         if (use_volume_key) {
1952                 if (!g_strcmp0(ev->keyname, KEY_VOLUMEUP)) {    /* KEY_VOLUMEUP */
1953                         D_MSG("KEY_VOLUMEUP is released");
1954
1955                         if (cd->vol_up_key_longpress) {
1956                                 ecore_timer_del(cd->vol_up_key_longpress);
1957                                 cd->vol_up_key_longpress = NULL;
1958                         }
1959                 } else if (!g_strcmp0(ev->keyname, KEY_VOLUMEDOWN)) {   /* KEY_VOLUMEDOWN */
1960                         D_MSG("KEY_VOLUMEDOWN is released");
1961
1962                         if (cd->vol_down_key_longpress) {
1963                                 ecore_timer_del(cd->vol_down_key_longpress);
1964                                 cd->vol_down_key_longpress = NULL;
1965                         }
1966                 } else {
1967                         D_MSG("key_name is not applicable!");
1968                 }
1969         } else {
1970                 D_MSG("Use volume key setting is not activated. Do volume key action");
1971         }
1972
1973         return EINA_TRUE;
1974 }
1975
1976 Eina_Bool msg_ui_composer_key_press_cb(void *data, int type, void *event)
1977 {
1978         D_ENTER;
1979         D_MSG_RETVM_IF(data == NULL, EINA_FALSE, "cd is NULL");
1980         D_MSG_RETVM_IF(event == NULL, EINA_FALSE, "event is NULL");
1981         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1982         Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
1983         int use_volume_key = false;
1984
1985         vconf_get_bool(VCONFKEY_MSG_APP_USE_VOLUME_KEY, &use_volume_key);
1986
1987         if (use_volume_key) {
1988                 if (!g_strcmp0(ev->keyname, KEY_VOLUMEUP)) {    /* KEY_VOLUMEUP */
1989                         D_MSG("KEY_VOLUMEUP is pressed");
1990
1991                         msg_common_increase_font_size();
1992
1993                         /* apply font size */
1994                         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER)
1995                                 msg_common_apply_font_size("bubble", cd->content_layout);
1996
1997                         msg_ui_composer_apply_font_size(cd, false);
1998
1999                         cd->vol_up_key_longpress = ecore_timer_add(0.1, (Ecore_Task_Cb) __msgc_up_key_long_press_cb, (void *)cd);
2000                 } else if (!g_strcmp0(ev->keyname, KEY_VOLUMEDOWN)) {   /* KEY_VOLUMEDOWN */
2001                         D_MSG("KEY_VOLUMEDOWN is pressed");
2002
2003                         msg_common_decrease_font_size();
2004
2005                         /* apply font size */
2006                         if (cd->msg_ug_mode == MSG_UG_MODE_BUBBLE_COMPOSER)
2007                                 msg_common_apply_font_size("bubble", cd->content_layout);
2008
2009                         msg_ui_composer_apply_font_size(cd, false);
2010
2011                         cd->vol_down_key_longpress = ecore_timer_add(0.1, (Ecore_Task_Cb) __msgc_down_key_long_press_cb, (void *)cd);
2012                 } else {
2013                         D_MSG("key_name is not applicable!");
2014                 }
2015         } else {
2016                 D_MSG("Use volume key setting is not activated. Do volume key action");
2017         }
2018
2019         return EINA_TRUE;
2020 }
2021
2022 void msg_ui_composer_connect_handler(MSG_COMPOSER_VIEW_DATA_S *cd)
2023 {
2024         D_ENTER;
2025         D_MSG_RETM_IF(cd == NULL, "cd is NULL");
2026
2027         int use_volume_key = 0;
2028         vconf_get_bool(VCONFKEY_MSG_APP_USE_VOLUME_KEY, &use_volume_key);
2029
2030         if (use_volume_key) {
2031                 msg_ui_composer_grab_key_setting(cd->xdisplay, cd->main_window);
2032                 /* connect key handler for volume up/down */
2033                 if (!cd->volkey_press_handler)
2034                         cd->volkey_press_handler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, msg_ui_composer_key_press_cb, (void *)cd);
2035
2036                 if (!cd->volkey_release_handler)
2037                         cd->volkey_release_handler = ecore_event_handler_add(ECORE_EVENT_KEY_UP, msg_ui_composer_key_release_cb, (void *)cd);
2038         }
2039         D_MSG("use_volume_key = %d", use_volume_key);
2040
2041         D_LEAVE;
2042 }
2043
2044 void msg_ui_composer_disconnect_handler(MSG_COMPOSER_VIEW_DATA_S *cd)
2045 {
2046         D_ENTER;
2047         D_MSG_RETM_IF(cd == NULL, "cd is NULL");
2048
2049         if (cd->volkey_press_handler) {
2050                 ecore_event_handler_del(cd->volkey_press_handler);
2051                 cd->volkey_press_handler = NULL;
2052         }
2053
2054         if (cd->vol_down_key_longpress) {
2055                 ecore_timer_del(cd->vol_down_key_longpress);
2056                 cd->vol_down_key_longpress = NULL;
2057         }
2058
2059         if (cd->volkey_release_handler) {
2060                 ecore_event_handler_del(cd->volkey_release_handler);
2061                 cd->volkey_release_handler = NULL;
2062         }
2063
2064         if (cd->vol_up_key_longpress) {
2065                 ecore_timer_del(cd->vol_up_key_longpress);
2066                 cd->vol_up_key_longpress = NULL;
2067         }
2068
2069         msg_ui_composer_ungrab_key_setting(cd->xdisplay, cd->main_window);
2070
2071         D_LEAVE;
2072 }