manager/src/msg-manager-notification.cpp

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved
   3  *
   4  * Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15 */
  16
  17 /*==================================================================================================
  18                                          INCLUDE FILES
  19 ==================================================================================================*/
  20
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <glib.h>
  24
  25 #include <libintl.h>
  26 #include <locale.h>
  27 #include <stdarg.h>
  28
  29 #include <app_control.h>
  30 #include <badge_internal.h>
  31 #include <notification_list.h>
  32 #include <notification_text_domain.h>
  33 #include <notification_internal.h>
  34 #include <notification_status.h>
  35 #include <notification_setting.h>
  36 #include <notification_setting_internal.h>
  37 #include <package_manager.h>
  38 #include <vconf.h>
  39
  40 #include <msg.h>
  41 #include <msg_storage.h>
  42
  43 #include <msg-manager-util.h>
  44 #include <msg-manager-contact.h>
  45 #include <msg-manager-debug.h>
  46 #include <msg-manager-notification.h>
  47 #include <msg-manager-sound.h>
  48
  49
  50 #define EMAIL_AT '@'
  51
  52 /*==================================================================================================
  53                                      VARIABLES
  54 ==================================================================================================*/
  55
  56 static GList *msg_report_notification_list = NULL;
  57 static bool is_init = false;
  58 extern msg_handle_t msg_handle;
  59 int g_alarmId = 0;
  60
  61
  62 /*==================================================================================================
  63                                          STRUCTURES
  64 ==================================================================================================*/
  65 typedef struct _report_notification_s
  66 {
  67         int priv_id;
  68         char addressVal[MAX_ADDRESS_VAL_LEN+1];
  69 } report_notification_s;
  70
  71
  72 typedef struct _msg_mgr_noti_info_s
  73 {
  74         msg_mgr_notification_type_t             type;
  75         int                     id;
  76         int                     layout;
  77         int                     count;
  78         int                     senderCount;
  79         time_t          time;
  80         char            sender[MSG_NOTI_TEXT_LEN_S+1];
  81         char            text[MSG_NOTI_TEXT_LEN+1];
  82         char            number[MSG_NOTI_TEXT_LEN_S+1];
  83         char            imagePath[MAX_IMAGE_PATH_LEN+1];                /**< Indicates the image path of contact. */
  84         int                     applist;
  85         app_control_h           svc_h;
  86         app_control_h           active_noti_svc_h[MSG_ACTIVE_NOTI_BUTTON_NUM];
  87         msg_message_id_t                msg_id;
  88         unsigned char           extra_data;
  89         int             sim_idx;
  90         int                     active_noti_button_num;
  91         int             active_media_cnt;
  92         int             active_media_size;
  93         unsigned char   active_subtype;         /**< to distinguish cb, push message */
  94         char            active_sender[MSG_NOTI_TEXT_LEN_S+1];
  95         char            active_subject[MSG_NOTI_TEXT_LEN_S+1];
  96         char            active_text[MSG_NOTI_TEXT_LEN+1];
  97 } MSG_MGR_NOTI_INFO_S;
  98
  99
 100 typedef struct _del_noti_info_s
 101 {
 102         msg_mgr_notification_type_t                     type;
 103         int             sim_idx;
 104 } DEL_NOTI_INFO_S;
 105
 106
 107 /*==================================================================================================
 108                                                                                 FUNCTION DEFINE
 109 ===================================================================================================*/
 110
 111 void MsgMgrInitReportNotiList();
 112 void MsgRefreshNotiCb(void *data);
 113 void MsgMgrDeleteNotiCb(void *data);
 114
 115 void MsgMgrDeleteNotification(msg_mgr_notification_type_t noti_type, int simIndex);
 116
 117 notification_h getHandle(int *noti_id);
 118
 119 int getPrivId(msg_mgr_notification_type_t noti_type, int sim_idx);
 120 void updatePrivId(msg_mgr_notification_type_t noti_type, int noti_id, int sim_idx);
 121
 122 void createInfoData(MSG_MGR_NOTI_INFO_S *noti_info, MSG_MGR_MESSAGE_INFO_S *msg_info); /* For addNoti() */
 123 void createInfoData(MSG_MGR_NOTI_INFO_S *noti_info, msg_mgr_active_notification_type_t active_noti);
 124 void createActiveInfoData(MSG_MGR_NOTI_INFO_S *noti_info, MSG_MGR_MESSAGE_INFO_S *msg_info);
 125 void clearInfoData(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info);
 126
 127 int getAppIcon(const char *app_id, char **icon_path);
 128 int getLatestMsgInfo(MSG_MGR_NOTI_INFO_S *noti_info, bool isForInstantMessage);
 129
 130 void setProperty(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info);
 131 void setTextDomain(notification_h noti_h, msg_mgr_notification_type_t noti_type);
 132 void setText(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info);
 133 void setIcon(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info);
 134 void setSoundAndVibration(notification_h noti_h, char *addressVal, bool bVoiceMail);
 135 void setActiveNotification(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info);
 136 void setActiveProperty(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info);
 137 void setActiveText(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info);
 138 void setActiveIcon(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info);
 139
 140 void setNotification(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info, bool bFeedback);
 141
 142 bool isExistAddressInReportTable(const char *addr);
 143
 144 /* Wrapper */
 145 void createServiceHandle(app_control_h *svc_h);
 146 void setServiceAppId(app_control_h svc_h, const char* app_id);
 147 void setServiceUri(app_control_h svc_h, const char* uri);
 148 void setServiceOperation(app_control_h svc_h, const char* operation);
 149 void addServiceExtraData(app_control_h svc_h, const char* bundle_key, const char* bundle_val);
 150 void addServiceExtraData(app_control_h svc_h, const char* bundle_key, int bundle_val);
 151 void setServicePackageName(app_control_h svc_h, const char* pkg_name);
 152 void sendServicelaunchRequest(app_control_h svc_h, app_control_reply_cb callback, void *user_data);
 153
 154 void setNotiTextDomain(notification_h noti_h, const char *pkg_name, const char *loc_dir);
 155 void setNotiText(notification_h noti_h, notification_text_type_e type, const char *text, const char *key);
 156 void setNotiTimeToText(notification_h noti_h, notification_text_type_e type, time_t time);
 157 void setNotiTime(notification_h noti_h, time_t time);
 158 void setNotiImage(notification_h noti_h, notification_image_type_e type, const char *image_path);
 159 void setNotiSound(notification_h noti_h, notification_sound_type_e type, const char *path);
 160 void setNotiVibration(notification_h noti_h, notification_vibration_type_e type, const char *path);
 161 void setNotiEventHandler(notification_h noti_h, notification_event_type_e type, app_control_h event_handler);
 162
 163 /* Alarm */
 164 void MsgMgrNotiSoundRepeatAlarmCB(int alarmId);
 165 void MsgMgrSoundCreateRepeatAlarm(int RepeatTime);
 166 void MsgMgrSoundSetRepeatAlarm();
 167
 168 char *get_translate_text(const char *pkg_name, const char *locale_dir, const char *text);
 169
 170 /*==================================================================================================
 171                                                                         FUNCTION IMPLEMENTATION
 172 ==================================================================================================*/
 173 bool _is_valid_email(char *pAddress)
 174 {
 175         if (!pAddress || pAddress[0] == 0)
 176                 return false;
 177         if (!strchr (pAddress, EMAIL_AT))
 178                 return false;
 179         return true;
 180 }
 181
 182
 183 bool isExistAddressInReportTable(const char *addr)
 184 {
 185         char sqlQuery[MAX_QUERY_LEN+1];
 186         int rowCnt = 0, colCnt = 0;
 187         char **db_res = NULL;
 188         int msg_err = 0;
 189
 190         char *normal_addr = msg_mgr_normalize_number((char *)addr);
 191
 192         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 193         snprintf(sqlQuery, sizeof(sqlQuery), "* FROM %s WHERE ADDRESS_VAL LIKE '%%%%%s'", MSGFW_SMS_REPORT_TABLE_NAME, normal_addr);
 194
 195         msg_err = msg_db_select_with_query(msg_handle, sqlQuery, &db_res, &rowCnt, &colCnt);
 196         if (msg_err != MSG_SUCCESS) {
 197                 MSG_MGR_ERR("msg_db_select_with_query() failed [%d]", msg_err);
 198                 return false;
 199         }
 200
 201         msg_err = msg_db_free(msg_handle, db_res);
 202         if (msg_err != MSG_SUCCESS) {
 203                 MSG_MGR_ERR("msg_db_free() failed [%d]", msg_err);
 204                 return false;
 205         }
 206
 207         if (rowCnt > 0)
 208                 return true;
 209
 210         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 211         snprintf(sqlQuery, sizeof(sqlQuery), "* FROM %s WHERE ADDRESS_VAL LIKE '%%%%%s'", MSGFW_REPORT_TABLE_NAME, normal_addr);
 212
 213         msg_err = msg_db_select_with_query(msg_handle, sqlQuery, &db_res, &rowCnt, &colCnt);
 214         if (msg_err != MSG_SUCCESS) {
 215                 MSG_MGR_ERR("msg_db_select_with_query() failed [%d]", msg_err);
 216                 return false;
 217         }
 218
 219         msg_err = msg_db_free(msg_handle, db_res);
 220         if (msg_err != MSG_SUCCESS) {
 221                 MSG_MGR_ERR("msg_db_free() failed [%d]", msg_err);
 222                 return false;
 223         }
 224
 225         if (rowCnt > 0)
 226                 return true;
 227
 228         return false;
 229 }
 230
 231
 232 void MsgMgrInitReportNotiList()
 233 {
 234         MSG_MGR_BEGIN();
 235
 236         if (msg_report_notification_list) {
 237                 MSG_MGR_DEBUG("Report Noti List is already inited");
 238                 return;
 239         }
 240
 241         msg_report_notification_list = NULL;
 242
 243         notification_h noti = NULL;
 244         notification_list_h noti_list = NULL;
 245         notification_list_h head_noti_list = NULL;
 246         int noti_err = NOTIFICATION_ERROR_NONE;
 247         app_control_h app_control = NULL;
 248
 249         noti_err = notification_get_list(NOTIFICATION_TYPE_NONE, -1, &noti_list);
 250         if (noti_err != NOTIFICATION_ERROR_NONE) {
 251                 MSG_MGR_DEBUG("notification_get_list() is failed!!");
 252                 return;
 253         }
 254
 255         head_noti_list = noti_list;
 256
 257         while (noti_list != NULL) {
 258                 noti = notification_list_get_data(noti_list);
 259
 260                 char tempAddr[MAX_ADDRESS_VAL_LEN+1];
 261                 memset(tempAddr, 0x00, sizeof(tempAddr));
 262
 263                 noti_err = notification_get_launch_option(noti, NOTIFICATION_LAUNCH_OPTION_APP_CONTROL, &app_control);
 264                 if (noti_err != NOTIFICATION_ERROR_NONE) {
 265                         MSG_MGR_DEBUG("notification_get_excute_option() failed!!");
 266                         break;
 267                 }
 268
 269                 char *addr = NULL;
 270
 271                 int ret = app_control_get_extra_data(app_control, "address", &addr);
 272                 if (ret == APP_CONTROL_ERROR_NONE && addr != NULL) {
 273                         if (isExistAddressInReportTable(addr)) {
 274                                 report_notification_s *info = new report_notification_s;
 275                                 memset(info, 0x00, sizeof(report_notification_s));
 276
 277                                 notification_get_id(noti, NULL, &(info->priv_id));
 278                                 snprintf(info->addressVal, sizeof(info->addressVal), "%s", addr);
 279
 280                                 msg_report_notification_list = g_list_append(msg_report_notification_list, (void *)info);
 281                                 MSG_MGR_SEC_DEBUG("appended list data = [priv_id = %d address = %s]", info->priv_id, info->addressVal);
 282                         }
 283
 284                         g_free(addr);
 285                         addr = NULL;
 286                 }
 287
 288                 noti_list = notification_list_get_next(noti_list);
 289         }
 290
 291         if (head_noti_list)
 292                 notification_free_list(head_noti_list);
 293
 294         MSG_MGR_END();
 295 }
 296
 297
 298 void MsgMgrInitNoti()
 299 {
 300         if (is_init)
 301                 return;
 302
 303         bool bNotiSvcReady = false;
 304
 305         bNotiSvcReady = notification_is_service_ready();
 306
 307         if (bNotiSvcReady == true) {
 308                 MSG_MGR_DEBUG("Notification server is available");
 309 #ifndef MSG_NOTI_INTEGRATION
 310                 MsgDeleteNotification(MSG_MGR_NOTI_TYPE_SIM, -1);
 311 #endif
 312                 MsgMgrRefreshAllNotification(false, true, MSG_MGR_ACTIVE_NOTI_TYPE_INSTANT);            /* On Booting */
 313                 MsgMgrInitReportNotiList();
 314         } else {
 315                 MSG_MGR_DEBUG("Notification server is not available. Init is defered");
 316 #ifndef MSG_NOTI_INTEGRATION
 317                 MSG_MGR_NOTI_INFO_S *delNotiInfo = (MSG_MGR_NOTI_INFO_S *)calloc(1, sizeof(MSG_MGR_NOTI_INFO_S));
 318                 if (delNotiInfo) {
 319                         delNotiInfo->type = MSG_MGR_NOTI_TYPE_SIM;
 320                         delNotiInfo->sim_idx = -1;
 321                 }
 322                 notification_add_deferred_task(MsgDeleteNotiCb, (void *)delNotiInfo);
 323 #endif
 324                 notification_add_deferred_task(MsgRefreshNotiCb, (void *)NULL);
 325         }
 326
 327         is_init = true;
 328 }
 329
 330
 331 void MsgRefreshNotiCb(void *data)
 332 {
 333         MsgMgrRefreshAllNotification(false, true, MSG_MGR_ACTIVE_NOTI_TYPE_INSTANT);
 334         MsgMgrInitReportNotiList();
 335
 336         if (data) {
 337                 free(data);
 338                 data = NULL;
 339         }
 340
 341         return;
 342 }
 343
 344
 345 void MsgMgrDeleteNotiCb(void *data)
 346 {
 347         if (data) {
 348                 DEL_NOTI_INFO_S *delNotiInfo = (DEL_NOTI_INFO_S *)data;
 349
 350                 MsgMgrDeleteNotification(delNotiInfo->type, delNotiInfo->sim_idx);
 351
 352                 free(data);
 353                 data = NULL;
 354         }
 355
 356         return;
 357 }
 358
 359
 360 int MsgMgrInsertOnlyActiveNotification(msg_mgr_notification_type_t noti_type, MSG_MGR_MESSAGE_INFO_S *msg_info)
 361 {
 362         MSG_MGR_BEGIN();
 363
 364         notification_h noti_h = NULL;
 365
 366         MSG_MGR_NOTI_INFO_S noti_info = {0, };
 367
 368         noti_info.type = noti_type;
 369         noti_info.active_noti_button_num = 1;
 370
 371         createActiveInfoData(&noti_info, msg_info);
 372
 373         noti_h = notification_create(NOTIFICATION_TYPE_NOTI);
 374
 375         setActiveNotification(noti_h, &noti_info);
 376
 377         clearInfoData(noti_h, &noti_info);
 378
 379         MSG_MGR_END();
 380         return 0;
 381 }
 382
 383
 384 int MsgMgrRefreshNotification(msg_mgr_notification_type_t noti_type, bool bFeedback, msg_mgr_active_notification_type_t active_type)
 385 {
 386         int err = 0;
 387         notification_h noti_h = NULL;
 388         int bNotification = 1;
 389 /*      bool bReplyPopup = false; */
 390
 391         MSG_MGR_NOTI_INFO_S noti_info = {0,};
 392         noti_info.type = noti_type;
 393         noti_info.id = getPrivId(noti_info.type, -1);
 394
 395         err = getLatestMsgInfo(&noti_info, false);
 396
 397         if (err != 0) {
 398                 MSG_MGR_DEBUG("getLatestMsgInfo() err = [%d]", err);
 399                 goto __END_OF_REFRESH_NOTI;
 400         }
 401
 402         if (active_type == MSG_MGR_ACTIVE_NOTI_TYPE_INSTANT) {
 403                 err = MsgMgrInsertInstantMessage(noti_type);
 404
 405                 if (err != 0) {
 406                         MSG_MGR_DEBUG(" MsgMgrInsertInstantMessage() err = [%d]", err);
 407                         goto __END_OF_REFRESH_NOTI;
 408                 }
 409         }
 410
 411         if (vconf_get_bool(MSG_SETTING_NOTIFICATION, &bNotification) != 0) {
 412                 MSG_MGR_DEBUG("vconf_get_bool is failed.");
 413         }
 414
 415         if (bNotification == 0) {
 416                 MSG_MGR_DEBUG("Msg Alert notification is off.");
 417                 goto __END_OF_REFRESH_NOTI;
 418         }
 419
 420         createInfoData(&noti_info, active_type);
 421
 422         noti_h = getHandle(&noti_info.id);
 423
 424         if (noti_h == NULL) {
 425                 MSG_MGR_DEBUG("Notification handle is NULL");
 426                 err = MSG_ERR_NULL_POINTER;
 427                 goto __END_OF_REFRESH_NOTI;
 428         }
 429
 430         setNotification(noti_h, &noti_info, bFeedback);
 431
 432 __END_OF_REFRESH_NOTI :
 433         clearInfoData(noti_h, &noti_info);
 434
 435         return err;
 436 }
 437
 438
 439 int MsgMgrAddReportNotification(msg_mgr_notification_type_t noti_type, MSG_MGR_MESSAGE_INFO_S *msg_info)
 440 {
 441         int ret = 0;
 442
 443         notification_h noti_h = NULL;
 444
 445         report_notification_s *info = new report_notification_s;
 446         memset(info, 0x00, sizeof(report_notification_s));
 447
 448         MSG_MGR_NOTI_INFO_S noti_info = {0,};
 449         noti_info.type = noti_type;
 450
 451         createInfoData(&noti_info, msg_info);
 452
 453         noti_h = getHandle(&noti_info.id);
 454
 455         if (noti_h == NULL) {
 456                 MSG_MGR_DEBUG("Notification handle is NULL");
 457                 ret = -1;
 458                 goto __END_OF_ADD_REPORT_NOTI;
 459         }
 460
 461         setNotification(noti_h, &noti_info, true);
 462
 463         info->priv_id = noti_info.id;
 464         snprintf(info->addressVal, sizeof(info->addressVal), "%s", msg_info->addressVal);
 465         msg_report_notification_list = g_list_append(msg_report_notification_list, (void *)info);
 466         MSG_MGR_SEC_DEBUG("appended list data = [priv_id = %d address = %s]", info->priv_id, info->addressVal);
 467
 468 __END_OF_ADD_REPORT_NOTI :
 469         clearInfoData(noti_h, &noti_info);
 470
 471         return ret;
 472 }
 473
 474
 475 int MsgMgrDeleteReportNotification(const char *addr)
 476 {
 477         MSG_MGR_BEGIN();
 478
 479         notification_h noti_h = NULL;
 480         int bNotification = 1;
 481
 482         if (vconf_get_bool(MSG_SETTING_NOTIFICATION, &bNotification) != 0) {
 483                 MSG_MGR_DEBUG("vconf_get_bool is failed.");
 484         }
 485
 486         if (bNotification == 0) {
 487                 MSG_MGR_DEBUG("Msg Alert notification is off.");
 488                 return 0;
 489         }
 490
 491         char* normalAddr = NULL;
 492         unsigned int list_length = g_list_length(msg_report_notification_list);
 493         bool isDelete = false;
 494
 495         MSG_MGR_DEBUG("list length [%d]", list_length);
 496
 497         if (list_length > 0) {
 498                 GList *iter = g_list_first(msg_report_notification_list);
 499
 500                 while (iter != NULL) {
 501                         isDelete = false;
 502                         report_notification_s *info = (report_notification_s*)(iter->data);
 503                         if (info == NULL) {
 504                                 MSG_MGR_DEBUG("info is NULL!");
 505                                 return -1;
 506                         }
 507
 508                         MSG_MGR_SEC_DEBUG("list data = [priv_id = %d address = %s]", info->priv_id, info->addressVal);
 509
 510                         noti_h = notification_load(NULL, info->priv_id);
 511                         if (noti_h == NULL) {
 512                                 MSG_MGR_DEBUG("notification with priv_id [%d] is NULL", info->priv_id);
 513                                 isDelete = true;
 514                         } else {
 515                                 normalAddr = msg_mgr_normalize_number(info->addressVal);
 516
 517                                 if (normalAddr) {
 518                                         MSG_MGR_SEC_DEBUG("normalized number = %s", normalAddr);
 519
 520                                         if (g_str_has_suffix(addr, normalAddr)) {
 521                                                 if (notification_delete(noti_h) == NOTIFICATION_ERROR_NONE) {
 522                                                         MSG_MGR_SEC_DEBUG("delete report notification address [%s]", info->addressVal);
 523                                                         isDelete = true;
 524                                                 } else {
 525                                                         MSG_MGR_DEBUG("delete notification failed");
 526                                                 }
 527                                         }
 528                                 }
 529
 530                                 notification_free(noti_h);
 531                                 noti_h = NULL;
 532                         }
 533
 534                         iter = g_list_next(iter);
 535
 536                         if (isDelete) {
 537                                 msg_report_notification_list = g_list_remove(msg_report_notification_list, (void *)info);
 538                                 if (info) {
 539                                         delete info;
 540                                         info = NULL;
 541                                 }
 542                         }
 543                 }
 544         }
 545
 546         MSG_MGR_END();
 547
 548         return 0;
 549 }
 550
 551 int MsgMgrAddNotification(msg_mgr_notification_type_t noti_type, MSG_MGR_MESSAGE_INFO_S *msg_info)
 552 {
 553         int ret = 0;
 554
 555         notification_h noti_h = NULL;
 556
 557         MSG_MGR_NOTI_INFO_S noti_info = {0, };
 558
 559         noti_info.type = noti_type;
 560
 561         createInfoData(&noti_info, msg_info);
 562
 563         /* check mwi or voicemail count is 0 then skip add notification */
 564         if (noti_info.count == 0) {
 565                 MSG_MGR_DEBUG("Notification count is 0");
 566                 ret = -1;
 567                 goto __END_OF_ADD_NOTI;
 568         }
 569
 570         noti_h = getHandle(&noti_info.id);
 571
 572         if (noti_h == NULL) {
 573                 MSG_MGR_DEBUG("Notification handle is NULL");
 574                 ret = -1;
 575                 goto __END_OF_ADD_NOTI;
 576         }
 577
 578         setNotification(noti_h, &noti_info, true);
 579
 580 __END_OF_ADD_NOTI :
 581         clearInfoData(noti_h, &noti_info);
 582
 583         return ret;
 584 }
 585
 586
 587 void MsgMgrDeleteNotification(msg_mgr_notification_type_t noti_type, int simIndex)
 588 {
 589         int noti_err = NOTIFICATION_ERROR_NONE;
 590
 591         if (noti_type == MSG_MGR_NOTI_TYPE_ALL) {
 592                 noti_err = notification_delete_all(NOTIFICATION_TYPE_NOTI);
 593         } else if (noti_type == MSG_MGR_NOTI_TYPE_VOICE_1 || noti_type == MSG_MGR_NOTI_TYPE_VOICE_2 || noti_type == MSG_MGR_NOTI_TYPE_SIM) {
 594                 int notiId = 0;
 595
 596                 notiId = getPrivId(noti_type, simIndex);
 597                 MSG_MGR_DEBUG("deleted notification ID = [%d] Type = [%d]", notiId, noti_type);
 598
 599                 if (notiId > 0)
 600                         noti_err = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NOTI, notiId);
 601
 602         } else {
 603                 MSG_MGR_DEBUG("No matching type [%d]", noti_type);
 604         }
 605
 606         if (noti_err != NOTIFICATION_ERROR_NONE) {
 607                 MSG_MGR_DEBUG("Fail to notification_delete_all noti_err [%d]", noti_err);
 608         }
 609
 610         updatePrivId(noti_type, 0, simIndex);
 611 }
 612
 613
 614 int MsgMgrDeleteNoti(msg_mgr_notification_type_t noti_type, int simIndex)
 615 {
 616         bool bNotiSvcReady = false;
 617
 618         DEL_NOTI_INFO_S *delNotiInfo = (DEL_NOTI_INFO_S *)calloc(1, sizeof(DEL_NOTI_INFO_S));
 619
 620         if (delNotiInfo) {
 621                 delNotiInfo->type = noti_type;
 622                 delNotiInfo->sim_idx = simIndex;
 623         }
 624
 625         bNotiSvcReady = notification_is_service_ready();
 626
 627         if (bNotiSvcReady == true) {
 628                 MSG_MGR_DEBUG("Notification server is available");
 629                 MsgMgrDeleteNotiCb((void *)delNotiInfo);
 630         } else {
 631                 MSG_MGR_DEBUG("Notification server is not available. Delete is defered");
 632                 notification_add_deferred_task(MsgMgrDeleteNotiCb, (void *)delNotiInfo);
 633         }
 634         return 0;
 635 }
 636
 637
 638 void MsgMgrRefreshAllNotification(bool bWithSimNoti, bool bFeedback, msg_mgr_active_notification_type_t active_type)
 639 {
 640         MSG_MGR_BEGIN();
 641
 642         int err = 0;
 643
 644 #ifndef MSG_NOTI_INTEGRATION
 645         MsgDeleteNotification(MSG_MGR_NOTI_TYPE_SIM);
 646 #endif
 647
 648 #ifdef MSG_NOTI_INTEGRATION
 649         err = MsgMgrRefreshNotification(MSG_MGR_NOTI_TYPE_NORMAL, bFeedback, active_type);
 650         if (err != 0)
 651                 MSG_MGR_DEBUG("refreshNoti is failed, [type=%d, err=%d]", MSG_MGR_NOTI_TYPE_NORMAL, err);
 652 #else
 653         err = MsgMgrRefreshNotification(MSG_MGR_NOTI_TYPE_NORMAL, bFeedback, active_type);
 654         if (err != 0)
 655                 MSG_MGR_DEBUG("refreshNoti is failed, [type=%d, err=%d]", MSG_MGR_NOTI_TYPE_NORMAL, err);
 656
 657         err = MsgMgrRefreshNotification(MSG_MGR_NOTI_TYPE_CB, bFeedback, active_type);
 658         if (err != 0)
 659                 MSG_MGR_DEBUG("refreshNoti is failed, [type=%d, err=%d]", MSG_MGR_NOTI_TYPE_CB, err);
 660
 661         if (bWithSimNoti) {
 662                 err = MsgMgrRefreshNotification(MSG_MGR_NOTI_TYPE_SIM, bFeedback, active_type);
 663                 if (err != 0)
 664                         MSG_MGR_DEBUG("refreshNoti is failed, [type=%d, err=%d]", MSG_MGR_NOTI_TYPE_SIM, err);
 665         }
 666 #endif
 667
 668         err = MsgMgrRefreshNotification(MSG_MGR_NOTI_TYPE_FAILED, bFeedback, active_type);
 669         if (err != 0)
 670                 MSG_MGR_DEBUG("refreshNoti is failed, [type=%d, err=%d]", MSG_MGR_NOTI_TYPE_FAILED, err);
 671
 672         MSG_MGR_END();
 673 }
 674
 675
 676 void setProperty(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info)
 677 {
 678         MSG_MGR_BEGIN();
 679
 680         int noti_err = NOTIFICATION_ERROR_NONE;
 681
 682         /* set layout */
 683         noti_err = notification_set_layout(noti_h, (notification_ly_type_e)noti_info->layout);
 684         if (noti_err != NOTIFICATION_ERROR_NONE) {
 685                 MSG_MGR_DEBUG("Fail to notification_set_layout : %d", noti_err);
 686         }
 687
 688         /* set led */
 689         noti_err = notification_set_led(noti_h, NOTIFICATION_LED_OP_ON, 0x00);
 690         if (noti_err != NOTIFICATION_ERROR_NONE) {
 691                 MSG_MGR_DEBUG("Fail to notification_set_led.");
 692         }
 693
 694         /* set execute option and property */
 695         switch (noti_info->type) {
 696         case MSG_MGR_NOTI_TYPE_NORMAL: {
 697                 if (noti_info->count > 1) {
 698                         notification_set_launch_option(noti_h, NOTIFICATION_LAUNCH_OPTION_APP_CONTROL, noti_info->svc_h);
 699                 } else {
 700                         if (noti_info->svc_h) { /* overwrite bundle key "type" */
 701                                 /* addServiceExtraData(noti_info->svc_h, "type", "reply"); */
 702                                 addServiceExtraData(noti_info->svc_h, "show_list", "list_show");
 703                         }
 704                         notification_set_launch_option(noti_h, NOTIFICATION_LAUNCH_OPTION_APP_CONTROL, noti_info->svc_h);
 705                 }
 706
 707                 notification_set_property(noti_h, NOTIFICATION_PROP_DISABLE_AUTO_DELETE);
 708                 break;
 709         }
 710         case MSG_MGR_NOTI_TYPE_CB:
 711         case MSG_MGR_NOTI_TYPE_SIM: {
 712                 notification_set_launch_option(noti_h, NOTIFICATION_LAUNCH_OPTION_APP_CONTROL, noti_info->svc_h);
 713                 notification_set_property(noti_h, NOTIFICATION_PROP_DISABLE_AUTO_DELETE|NOTIFICATION_PROP_VOLATILE_DISPLAY);
 714                 break;
 715         }
 716         case MSG_MGR_NOTI_TYPE_FAILED: {
 717                 notification_set_launch_option(noti_h, NOTIFICATION_LAUNCH_OPTION_APP_CONTROL, noti_info->svc_h);
 718                 notification_set_property(noti_h, NOTIFICATION_PROP_DISABLE_AUTO_DELETE);
 719                 break;
 720         }
 721         case MSG_MGR_NOTI_TYPE_SIM_FULL: {
 722                 notification_set_launch_option(noti_h, NOTIFICATION_LAUNCH_OPTION_APP_CONTROL, noti_info->svc_h);
 723                 break;
 724         }
 725         case MSG_MGR_NOTI_TYPE_VOICE_1:
 726         case MSG_MGR_NOTI_TYPE_VOICE_2:
 727         case MSG_MGR_NOTI_TYPE_MWI:
 728         case MSG_MGR_NOTI_TYPE_CLASS0:
 729         case MSG_MGR_NOTI_TYPE_SMS_DELIVERY_REPORT:
 730         case MSG_MGR_NOTI_TYPE_MMS_READ_REPORT:
 731         case MSG_MGR_NOTI_TYPE_MMS_DELIVERY_REPORT: {
 732                 notification_set_launch_option(noti_h, NOTIFICATION_LAUNCH_OPTION_APP_CONTROL, noti_info->svc_h);
 733                 break;
 734         }
 735         default:
 736                 MSG_MGR_DEBUG("No matching type for notification_set_launch_option() [%d]", noti_info->type);
 737                 break;
 738         }
 739
 740         /* set applist */
 741         noti_err = notification_set_display_applist(noti_h, noti_info->applist);
 742         if (noti_err != NOTIFICATION_ERROR_NONE) {
 743                 MSG_MGR_DEBUG("Fail to notification_set_display_applist");
 744         }
 745
 746
 747         MSG_MGR_END();
 748 }
 749
 750
 751 void setTextDomain(notification_h noti_h, msg_mgr_notification_type_t noti_type)
 752 {
 753         MSG_MGR_BEGIN();
 754
 755         setNotiTextDomain(noti_h, MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR);
 756         MSG_MGR_END();
 757 }
 758
 759
 760 void setText(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info)
 761 {
 762         MSG_MGR_BEGIN();
 763
 764         char unreadMsgCntStr[10] = {0};
 765         int bPreview = 1;
 766
 767         if (vconf_get_bool(MSG_SETTING_PREVIEW, &bPreview) != 0) {
 768                 MSG_MGR_DEBUG("vconf_get_bool is failed.");
 769         }
 770
 771         /* set title and content */
 772         switch (noti_info->type) {
 773 #ifdef MSG_NOTI_INTEGRATION
 774         case MSG_MGR_NOTI_TYPE_NORMAL:
 775         case MSG_MGR_NOTI_TYPE_CB:
 776         case MSG_MGR_NOTI_TYPE_SIM: {
 777                 if (noti_info->count > 1) {
 778                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "New Messages", NEW_MESSAGES);
 779                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->sender, NULL);
 780                         setNotiTime(noti_h, noti_info->time);
 781
 782                         snprintf(unreadMsgCntStr, sizeof(unreadMsgCntStr), "%d", noti_info->count);
 783                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_EVENT_COUNT, unreadMsgCntStr, NULL);
 784
 785                 } else {
 786                         if (bPreview) {
 787                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, noti_info->sender, NULL);
 788                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->text, NULL);
 789                         } else {
 790                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "New Message", NEW_MESSAGE);
 791                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->sender, NULL);
 792                         }
 793                         setNotiTime(noti_h, noti_info->time);
 794                 }
 795                 break;
 796         }
 797 #else
 798         case MSG_MGR_NOTI_TYPE_NORMAL: {
 799                 if (noti_info->count > 1) {
 800                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "New Messages", NEW_MESSAGES);
 801                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->sender, NULL);
 802                         setNotiTime(noti_h, noti_info->time);
 803
 804                         snprintf(unreadMsgCntStr, sizeof(unreadMsgCntStr), "%d", noti_info->count);
 805                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_EVENT_COUNT, unreadMsgCntStr, NULL);
 806                 } else {
 807                         if (bPreview) {
 808                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, noti_info->sender, NULL);
 809                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->text, NULL);
 810                         } else {
 811                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "New Message", NEW_MESSAGE);
 812                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->sender, NULL);
 813                         }
 814                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_EVENT_COUNT, "1", NULL);
 815                         setNotiTime(noti_h, noti_info->time);
 816                 }
 817                 break;
 818         }
 819         case MSG_MGR_NOTI_TYPE_CB: {
 820                 if (noti_info->count > 1) {
 821                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "Broadcast message", CB_MESSAGE);
 822                         snprintf(unreadMsgCntStr, sizeof(unreadMsgCntStr), "%d", noti_info->count);
 823                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_EVENT_COUNT, unreadMsgCntStr, NULL);
 824                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->sender, NULL);
 825                         setNotiTime(noti_h, noti_info->time);
 826
 827                 } else {
 828                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_EVENT_COUNT, "1", NULL);
 829                         setNotiTime(noti_h, noti_info->time);
 830
 831                         if (bPreview) {
 832                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, noti_info->sender, NULL);
 833                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->text, NULL);
 834                         } else {
 835                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "Broadcast message", CB_MESSAGE);
 836                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->sender, NULL);
 837                         }
 838                 }
 839                 break;
 840         }
 841         case MSG_MGR_NOTI_TYPE_SIM: {
 842                 if (noti_info->count > 1) {
 843                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "SIM card Message", SIM_CARD_MESSAGE);
 844                         snprintf(unreadMsgCntStr, sizeof(unreadMsgCntStr), "%d", noti_info->count);
 845                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_EVENT_COUNT, unreadMsgCntStr, NULL);
 846
 847                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->sender, NULL);
 848                         setNotiTime(noti_h, noti_info->time);
 849                 } else {
 850                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_EVENT_COUNT, "1", NULL);
 851                         setNotiTime(noti_h, noti_info->time);
 852
 853                         if (bPreview) {
 854                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, noti_info->sender, NULL);
 855                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->text, NULL);
 856                         } else {
 857                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "SIM card Message", SIM_CARD_MESSAGE);
 858                                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->sender, NULL);
 859                         }
 860                 }
 861                 break;
 862         }
 863 #endif
 864         case MSG_MGR_NOTI_TYPE_FAILED: {
 865                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "Message", MSG_MESSAGE);
 866                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, "Failed to send message.", FAILED_TO_SEND_MESSAGE);
 867                 if (noti_info->count > 1) {
 868                         snprintf(unreadMsgCntStr, sizeof(unreadMsgCntStr), "%d", noti_info->count);
 869                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_EVENT_COUNT, unreadMsgCntStr, NULL);
 870                 }
 871                 setNotiTime(noti_h, noti_info->time);
 872                 break;
 873         }
 874         case MSG_MGR_NOTI_TYPE_VOICE_1:
 875         case MSG_MGR_NOTI_TYPE_VOICE_2: {
 876                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "Voicemail", VOICE_MAIL);
 877                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->sender, NULL);
 878                 setNotiTime(noti_h, noti_info->time);
 879
 880                 if (noti_info->count == 1) {
 881                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_EVENT_COUNT, "1", NULL);
 882                 } else if (noti_info->count > 1) {
 883                         snprintf(unreadMsgCntStr, sizeof(unreadMsgCntStr), "%d", noti_info->count);
 884                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_EVENT_COUNT, unreadMsgCntStr, NULL);
 885                 } else {
 886                         MSG_MGR_DEBUG("Invalid notification count, [cnt = %d]", noti_info->count);
 887                 }
 888                 break;
 889         }
 890         case MSG_MGR_NOTI_TYPE_MWI: {
 891                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "MWI Message", NULL);
 892                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->sender, NULL);
 893                 setNotiTime(noti_h, noti_info->time);
 894                 break;
 895         }
 896         case MSG_MGR_NOTI_TYPE_CLASS0: {
 897                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "CLASS 0 Message", NULL);
 898                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->sender, NULL);
 899                 setNotiTime(noti_h, noti_info->time);
 900                 break;
 901         }
 902         case MSG_MGR_NOTI_TYPE_SMS_DELIVERY_REPORT: {
 903                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "Delivery report", DELIVERY_MESSAGE);
 904                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->sender, NULL);
 905
 906                 if (noti_info->extra_data == MSG_NETWORK_DELIVER_SUCCESS) {
 907                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_INFO_1, "Message delivered", DELIVERED_MESSAGE);
 908                 } else if (noti_info->extra_data == MSG_NETWORK_DELIVER_EXPIRED) {
 909                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_INFO_1, "Message expired", EXPIRED_MESSAGE);
 910                 } else {
 911                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_INFO_1, "Message deferred", DEFERRED_MESSAGE);
 912                 }
 913
 914                 setNotiTime(noti_h, noti_info->time);
 915                 break;
 916         }
 917         case MSG_MGR_NOTI_TYPE_MMS_READ_REPORT: {
 918                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "Read Report", READ_REPORT_MESSAGE);
 919                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->sender, NULL);
 920
 921                 if (noti_info->extra_data == MSG_READ_REPORT_IS_DELETED) {
 922                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_INFO_1, "Message deleted", READ_REPORT_DELETE);
 923                 /* CID 45672: noti_info->extra_data in unsigned char but MSG_READ_REPORT_NONE is -1. So the expression is always false */
 924 #if 0
 925                 } else if (noti_info->extra_data == MSG_READ_REPORT_NONE) {
 926                         /* notification free */
 927 #endif
 928                 } else {
 929                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_INFO_1, "Message read", READ_REPORT_READ);
 930                 }
 931
 932                 setNotiTime(noti_h, noti_info->time);
 933                 break;
 934         }
 935         case MSG_MGR_NOTI_TYPE_MMS_DELIVERY_REPORT: {
 936                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "Delivery Report", DELIVERY_MESSAGE);
 937                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->sender, NULL);
 938
 939                 if (noti_info->extra_data == MSG_DELIVERY_REPORT_EXPIRED)
 940                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_INFO_1, "Message expired", EXPIRED_MESSAGE);
 941                 else if (noti_info->extra_data == MSG_DELIVERY_REPORT_REJECTED)
 942                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_INFO_1, "Message rejected", REJECTED_MESSAGE);
 943                 else if (noti_info->extra_data == MSG_DELIVERY_REPORT_DEFERRED)
 944                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_INFO_1, "Message deferred", DEFERRED_MESSAGE);
 945                 else if (noti_info->extra_data == MSG_DELIVERY_REPORT_UNRECOGNISED)
 946                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_INFO_1, "Message unrecognised", UNRECOGNISED_MESSAGE);
 947                 else if (noti_info->extra_data == MSG_DELIVERY_REPORT_INDETERMINATE)
 948                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_INFO_1, "Message indeterminate", INDETEMINATE_MESSAGE);
 949                 else if (noti_info->extra_data == MSG_DELIVERY_REPORT_FORWARDED)
 950                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_INFO_1, "Message forwarded", NULL);
 951                 else if (noti_info->extra_data == MSG_DELIVERY_REPORT_UNREACHABLE)
 952                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_INFO_1, "Message unreachable", UNREACHABLE_MESSAGE);
 953                 else if (noti_info->extra_data == MSG_DELIVERY_REPORT_ERROR)
 954                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_INFO_1, "Message error", NULL);
 955                 /* CID 45672: noti_info->extra_data in unsigned char but MSG_READ_REPORT_NONE is -1. So the expression is always false */
 956 #if 0
 957                 else if (noti_info->extra_data == MSG_DELIVERY_REPORT_NONE) {
 958                         /* notification free */
 959                 }
 960 #endif
 961                 else
 962                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_INFO_1, "Message delivered", DELIVERED_MESSAGE);
 963
 964                 setNotiTime(noti_h, noti_info->time);
 965                 break;
 966         }
 967         case MSG_MGR_NOTI_TYPE_SIM_FULL: {
 968                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "SIM card full", SMS_SIM_CARD_FULL);
 969                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, "Not enough memory. Delete some items.", SMS_MESSAGE_MEMORY_FULL);
 970                 break;
 971         }
 972         default:
 973                 MSG_MGR_DEBUG("No matching type [%d]", noti_info->type);
 974                 break;
 975         }
 976
 977         MSG_MGR_END();
 978 }
 979
 980 void setIcon(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info)
 981 {
 982         MSG_MGR_BEGIN();
 983
 984         switch (noti_info->type) {
 985 #ifdef MSG_NOTI_INTEGRATION
 986         case MSG_MGR_NOTI_TYPE_NORMAL:
 987         case MSG_MGR_NOTI_TYPE_CB:
 988         case MSG_MGR_NOTI_TYPE_SIM: {
 989                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_INDICATOR, MSG_NORMAL_STATUS_ICON);
 990                 if (noti_info->count > 1 && noti_info->senderCount > 1) {
 991                         setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_LOCK, MSG_NORMAL_ICON_PATH);
 992                         setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_NORMAL_ICON_PATH);
 993                         setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_SUB, "");
 994                 } else {
 995                         if (noti_info->active_subtype == MSG_CB_SMS) {
 996                                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_LOCK, MSG_CB_ICON_PATH);
 997                                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_CB_ICON_PATH);
 998                         } else if (noti_info->active_subtype == MSG_WAP_SI_SMS || noti_info->active_subtype == MSG_WAP_SL_SMS) {
 999                                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_LOCK, MSG_ACTIVE_PUSH_ICON_PATH);
1000                                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_ACTIVE_PUSH_ICON_PATH);
1001                         } else if (noti_info->active_subtype == MSG_SYNCML_CP) {
1002                                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_OTA_ICON_PATH);
1003                         } else {
1004                                 if (noti_info->imagePath[0] != '\0') {
1005                                         setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_LOCK, noti_info->imagePath);
1006                                         setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, noti_info->imagePath);
1007                                 } else {
1008                                         setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_LOCK, MSG_NO_CONTACT_PROFILE_ICON_PATH);
1009                                         setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_NO_CONTACT_PROFILE_ICON_PATH);
1010                                 }
1011
1012                                 char *msg_icon_path = NULL;
1013                                 if (getAppIcon(MSG_DEFAULT_APP_ID, &msg_icon_path) == 0) {
1014                                         setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_SUB, msg_icon_path);
1015                                         g_free(msg_icon_path);
1016                                 } else {
1017                                         MSG_MGR_ERR("fail to get message-app icon");
1018                                 }
1019                         }
1020                 }
1021                 break;
1022         }
1023 #else
1024         case MSG_MGR_NOTI_TYPE_NORMAL: {
1025                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_INDICATOR, MSG_NORMAL_STATUS_ICON);
1026                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_LOCK, MSG_NORMAL_ICON_PATH);
1027
1028                 if (noti_info->count > 1) {
1029                         setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_NORMAL_ICON_PATH);
1030                 } else {
1031                         setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_REPLY_ICON_PATH);
1032                 }
1033                 break;
1034         }
1035         case MSG_MGR_NOTI_TYPE_CB: {
1036                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_CB_ICON_PATH);
1037                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_INDICATOR, MSG_CB_ICON_PATH);
1038                 break;
1039         }
1040         case MSG_MGR_NOTI_TYPE_SIM: {
1041                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_SIM_ICON_PATH);
1042                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_INDICATOR, MSG_SIM_ICON_PATH);
1043                 break;
1044         }
1045 #endif
1046         case MSG_MGR_NOTI_TYPE_FAILED: {
1047                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_SMS_SENDING_FAILED_ICON_PATH);
1048                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_INDICATOR, MSG_SMS_SENDING_FAILED_ICON_PATH);
1049                 break;
1050         }
1051         case MSG_MGR_NOTI_TYPE_VOICE_1:
1052         case MSG_MGR_NOTI_TYPE_VOICE_2:
1053         case MSG_MGR_NOTI_TYPE_MWI: {
1054                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_INDICATOR, MSG_VOICE_MSG_STATUS_ICON);
1055                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_VOICE_ICON_PATH);
1056                 break;
1057         }
1058         case MSG_MGR_NOTI_TYPE_CLASS0:
1059                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_NORMAL_ICON_PATH);
1060                 break;
1061         case MSG_MGR_NOTI_TYPE_SMS_DELIVERY_REPORT:
1062                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_INDICATOR, MSG_NORMAL_STATUS_ICON);
1063                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_NORMAL_ICON_PATH);
1064                 break;
1065         case MSG_MGR_NOTI_TYPE_MMS_READ_REPORT:
1066                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_INDICATOR, MSG_NORMAL_STATUS_ICON);
1067                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_NORMAL_ICON_PATH);
1068                 break;
1069         case MSG_MGR_NOTI_TYPE_MMS_DELIVERY_REPORT:
1070                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_INDICATOR, MSG_NORMAL_STATUS_ICON);
1071                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_NORMAL_ICON_PATH);
1072                 break;
1073         case MSG_MGR_NOTI_TYPE_SIM_FULL:
1074                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_NORMAL_ICON_PATH);
1075                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_FOR_INDICATOR, MSG_NORMAL_STATUS_ICON);
1076                 break;
1077         default:
1078                 MSG_MGR_DEBUG("No matching type for MsgNotiSetImage [%d]", noti_info->type);
1079                 break;
1080         }
1081
1082         MSG_MGR_END();
1083 }
1084
1085 void setActiveProperty(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info)
1086 {
1087         MSG_MGR_BEGIN();
1088
1089         int noti_err = NOTIFICATION_ERROR_NONE;
1090
1091         /* set layout */
1092         noti_err = notification_set_layout(noti_h, NOTIFICATION_LY_NOTI_EVENT_SINGLE);
1093         if (noti_err != NOTIFICATION_ERROR_NONE) {
1094                 MSG_MGR_DEBUG("Fail to notification_set_layout : %d", noti_err);
1095         }
1096
1097         /* set led */
1098         noti_err = notification_set_led(noti_h, NOTIFICATION_LED_OP_ON, 0x00);
1099         if (noti_err != NOTIFICATION_ERROR_NONE) {
1100                 MSG_MGR_DEBUG("Fail to notification_set_led.");
1101         }
1102
1103         /* set applist */
1104         noti_err = notification_set_display_applist(noti_h, NOTIFICATION_DISPLAY_APP_ACTIVE);
1105         if (noti_err != NOTIFICATION_ERROR_NONE) {
1106                 MSG_MGR_DEBUG("Fail to notification_set_display_applist");
1107         }
1108
1109         MSG_MGR_END();
1110 }
1111
1112
1113 void setActiveText(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info)
1114 {
1115         MSG_MGR_BEGIN();
1116
1117         switch (noti_info->type) {
1118         case MSG_MGR_NOTI_TYPE_NORMAL:
1119         case MSG_MGR_NOTI_TYPE_SIM:
1120         case MSG_MGR_NOTI_TYPE_CB: {
1121                 if (noti_info->active_subject[0] == '\0') {
1122                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, noti_info->active_sender, NULL);
1123                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->active_text, NULL);
1124                 } else {
1125                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, noti_info->active_sender, NULL);
1126                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_INFO_1, noti_info->active_subject, NULL);
1127                         setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->active_text, NULL);
1128                 }
1129                 break;
1130         }
1131         case MSG_MGR_NOTI_TYPE_CLASS0: {
1132                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_TITLE, "CLASS 0 Message", NULL);
1133                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info->active_sender, NULL);
1134                 break;
1135         }
1136         default:
1137                 MSG_MGR_DEBUG("No matching type [%d]", noti_info->type);
1138                 break;
1139         }
1140
1141         MSG_MGR_END();
1142 }
1143
1144
1145 void setActiveIcon(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info)
1146 {
1147         MSG_MGR_BEGIN();
1148
1149         switch (noti_info->type) {
1150         case MSG_MGR_NOTI_TYPE_NORMAL:
1151         case MSG_MGR_NOTI_TYPE_SIM: {
1152                 switch (noti_info->active_subtype) {
1153                 case MSG_CB_SMS:
1154                         setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_CB_ICON_PATH);
1155                         break;
1156                 case MSG_WAP_SI_SMS:
1157                 case MSG_WAP_SL_SMS:
1158                         setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_ACTIVE_PUSH_ICON_PATH);
1159                         break;
1160                 case MSG_SYNCML_CP:
1161                         setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_OTA_ICON_PATH);
1162                         break;
1163                 default:
1164                         if (noti_info->imagePath[0] != '\0')
1165                                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, noti_info->imagePath);
1166                         else
1167                                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_NO_CONTACT_PROFILE_ICON_PATH);
1168
1169                         char *msg_icon_path = NULL;
1170                         if (getAppIcon(MSG_DEFAULT_APP_ID, &msg_icon_path) == 0) {
1171                                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON_SUB, msg_icon_path);
1172                                 g_free(msg_icon_path);
1173                         } else {
1174                                 MSG_MGR_ERR("fail to get message-app icon");
1175                         }
1176
1177                         break;
1178                 }
1179
1180                 break;
1181         }
1182         case MSG_MGR_NOTI_TYPE_CB: {
1183                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_CB_ICON_PATH);
1184                 break;
1185         }
1186         case MSG_MGR_NOTI_TYPE_CLASS0:
1187                 setNotiImage(noti_h, NOTIFICATION_IMAGE_TYPE_ICON, MSG_NORMAL_ICON_PATH);
1188                 break;
1189         default:
1190                 MSG_MGR_DEBUG("No matching type for MsgNotiSetImage [%d]", noti_info->type);
1191                 break;
1192         }
1193
1194         MSG_MGR_END();
1195 }
1196
1197
1198 void setSoundAndVibration(notification_h noti_h, char *addressVal, bool bVoiceMail)
1199 {
1200         MSG_MGR_BEGIN();
1201
1202         MSG_MGR_ADDRESS_INFO_S addrInfo = {0,};
1203         MSG_MGR_CONTACT_INFO_S contactInfo = {0,};
1204
1205         if (addressVal != NULL) {
1206                 snprintf(addrInfo.addressVal, sizeof(addrInfo.addressVal), "%s", addressVal);
1207                 /* Get Contact Info */
1208                 if (MsgMgrGetContactInfo(&addrInfo, &contactInfo) != 0) {
1209                         MSG_MGR_DEBUG("MsgMgrGetContactInfo() fail.");
1210                 }
1211         } else {
1212                 MSG_MGR_DEBUG("addressVal is NULL.");
1213         }
1214
1215         char *msg_tone_file_path = NULL;
1216
1217         MsgMgrGetRingtonePath(contactInfo.alerttonePath, &msg_tone_file_path);
1218
1219         MSG_MGR_SEC_DEBUG("Sound File [%s]", msg_tone_file_path);
1220
1221         bool bPlaySound = false;
1222         bool bPlayVibration = false;
1223         bool bOnCall = false;
1224
1225         MsgMgrGetPlayStatus(bVoiceMail, &bPlaySound, &bPlayVibration, &bOnCall);
1226
1227         if (bPlaySound) {
1228                 if (msg_tone_file_path)
1229                         setNotiSound(noti_h, NOTIFICATION_SOUND_TYPE_USER_DATA, msg_tone_file_path);
1230                 else {
1231                         int tmpVal = 0;
1232                         if (vconf_get_int(MSG_SETTING_RINGTONE_TYPE, &tmpVal) != 0) {
1233                                 MSG_MGR_INFO("MsgSettingGetInt() is failed");
1234                         }
1235                         int ringtoneType = tmpVal;
1236                         if (ringtoneType == MSG_RINGTONE_TYPE_SILENT)
1237                                 setNotiSound(noti_h, NOTIFICATION_SOUND_TYPE_NONE, NULL);
1238                         else
1239                                 setNotiSound(noti_h, NOTIFICATION_SOUND_TYPE_DEFAULT, NULL);
1240                 }
1241         } else {
1242                 setNotiSound(noti_h, NOTIFICATION_SOUND_TYPE_NONE, NULL);
1243         }
1244
1245         if (bPlayVibration) {
1246                 if (contactInfo.vibrationPath[0] == '\0')
1247                         setNotiVibration(noti_h, NOTIFICATION_VIBRATION_TYPE_DEFAULT, NULL);
1248                 else
1249                         setNotiVibration(noti_h, NOTIFICATION_VIBRATION_TYPE_USER_DATA, contactInfo.vibrationPath);
1250         } else {
1251                 setNotiVibration(noti_h, NOTIFICATION_VIBRATION_TYPE_NONE, NULL);
1252         }
1253
1254         if (msg_tone_file_path)
1255                 delete [] msg_tone_file_path;
1256
1257         MSG_MGR_END();
1258 }
1259
1260
1261 void setActiveNotification(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info)
1262 {
1263         MSG_MGR_BEGIN();
1264
1265         int noti_err = NOTIFICATION_ERROR_NONE;
1266
1267         setActiveProperty(noti_h, noti_info);
1268
1269         setTextDomain(noti_h, noti_info->type);
1270
1271         setActiveText(noti_h, noti_info);
1272
1273         setActiveIcon(noti_h, noti_info);
1274
1275         if (noti_info->active_noti_button_num > 1) {
1276                 createServiceHandle(&noti_info->active_noti_svc_h[0]);
1277                 if (noti_info->active_noti_svc_h[0]) {
1278                         setServicePackageName(noti_info->active_noti_svc_h[0], MSG_CALL_APP_ID);
1279                         setServiceOperation(noti_info->active_noti_svc_h[0], APP_CONTROL_OPERATION_CALL);
1280
1281                         MSG_MGR_DEBUG("Active Notification button 1 - Msg Id = [%d]", noti_info->msg_id);
1282
1283                         char tel_num[MSG_NOTI_TEXT_LEN_S] = {0, };
1284                         snprintf(tel_num, sizeof(tel_num), "tel:%s", noti_info->number);
1285                         MSG_MGR_SEC_DEBUG("Active sender number [%s]", noti_info->number);
1286                         setServiceUri(noti_info->active_noti_svc_h[0], tel_num);
1287                 }
1288
1289                 createServiceHandle(&noti_info->active_noti_svc_h[1]);
1290                 if (noti_info->active_noti_svc_h[1]) {
1291                         setServicePackageName(noti_info->active_noti_svc_h[1], MSG_DEFAULT_APP_ID);
1292
1293                         MSG_MGR_DEBUG("Active Notification button 2 - Msg Id = [%d]", noti_info->msg_id);
1294                         addServiceExtraData(noti_info->active_noti_svc_h[1], "type", "reply");
1295                         addServiceExtraData(noti_info->active_noti_svc_h[1], "msgId", noti_info->msg_id);
1296
1297                         char slot_id[5] = {0, };
1298                         snprintf(slot_id, sizeof(slot_id), "%d", noti_info->sim_idx - 1);
1299                         addServiceExtraData(noti_info->active_noti_svc_h[1], "slot_id", slot_id);
1300                 }
1301         }
1302
1303         createServiceHandle(&noti_info->active_noti_svc_h[2]);
1304         if (noti_info->active_noti_svc_h[2]) {
1305                 setServicePackageName(noti_info->active_noti_svc_h[2], MSG_DEFAULT_APP_ID);
1306
1307                 MSG_MGR_DEBUG("Active Notification button 3 - msgId = [%d]", noti_info->msg_id);
1308                 addServiceExtraData(noti_info->active_noti_svc_h[2], "type", "new_msg");
1309                 addServiceExtraData(noti_info->active_noti_svc_h[2], "msgId", noti_info->msg_id);
1310                 addServiceExtraData(noti_info->active_noti_svc_h[2], "CALLER", "active_noti");
1311
1312                 char slot_id[5] = {0, };
1313                 snprintf(slot_id, sizeof(slot_id), "%d", noti_info->sim_idx - 1);
1314                 addServiceExtraData(noti_info->active_noti_svc_h[2], "slot_id", slot_id);
1315         }
1316
1317         if (noti_info->active_noti_button_num > 1) {
1318                 setNotiEventHandler(noti_h, NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_1, noti_info->active_noti_svc_h[0]);
1319                 setNotiEventHandler(noti_h, NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_2, noti_info->active_noti_svc_h[1]);
1320                 setNotiEventHandler(noti_h, NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_3, noti_info->active_noti_svc_h[2]);
1321
1322                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_BUTTON_1, "Call", NULL);
1323                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_BUTTON_2, "Reply", NULL);
1324                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_BUTTON_3, "View", NULL);
1325         } else {
1326                 setNotiEventHandler(noti_h, NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_1, noti_info->active_noti_svc_h[2]);
1327
1328                 setNotiText(noti_h, NOTIFICATION_TEXT_TYPE_BUTTON_1, "View", NULL);
1329         }
1330
1331         noti_err = notification_post(noti_h);
1332         if (noti_err != NOTIFICATION_ERROR_NONE) {
1333                 MSG_MGR_DEBUG("Fail to notification_post");
1334         }
1335
1336         MSG_MGR_END();
1337 }
1338
1339
1340 void setNotification(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info, bool bFeedback)
1341 {
1342         MSG_MGR_BEGIN();
1343
1344         int noti_err = NOTIFICATION_ERROR_NONE;
1345
1346         MSG_MGR_DEBUG("active num [%d]", noti_info->active_noti_button_num);
1347
1348         if (bFeedback && noti_info->active_noti_button_num > 0 &&
1349                 ((noti_info->type >= MSG_MGR_NOTI_TYPE_NORMAL && noti_info->type <= MSG_MGR_NOTI_TYPE_SIM) || noti_info->type == MSG_MGR_NOTI_TYPE_CLASS0)) {
1350                 notification_h active_noti_h = notification_create(NOTIFICATION_TYPE_NOTI);
1351
1352                 setActiveNotification(active_noti_h, noti_info);
1353
1354                 notification_free(active_noti_h);
1355                 active_noti_h = NULL;
1356         }
1357
1358         setProperty(noti_h, noti_info);
1359
1360         setTextDomain(noti_h, noti_info->type);
1361
1362         setText(noti_h, noti_info);
1363
1364         setIcon(noti_h, noti_info);
1365
1366         if (bFeedback) {
1367                 if (noti_info->type == MSG_MGR_NOTI_TYPE_VOICE_1 || noti_info->type == MSG_MGR_NOTI_TYPE_VOICE_2)
1368                         setSoundAndVibration(noti_h, noti_info->number, true);
1369                 else
1370                         setSoundAndVibration(noti_h, noti_info->number, false);
1371
1372         } else {
1373                 setNotiSound(noti_h, NOTIFICATION_SOUND_TYPE_NONE, NULL);
1374                 setNotiVibration(noti_h, NOTIFICATION_VIBRATION_TYPE_NONE, NULL);
1375         }
1376
1377         if (noti_info->id > 0) {
1378                 MSG_MGR_DEBUG("Notification update");
1379                 noti_err = notification_update(noti_h);
1380                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1381                         MSG_MGR_DEBUG("Fail to notification_update");
1382                 }
1383         } else {
1384                 MSG_MGR_DEBUG("Notification insert");
1385                 noti_err = notification_insert(noti_h, &noti_info->id);
1386                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1387                         MSG_MGR_DEBUG("Fail to notification_insert");
1388                 }
1389
1390                 updatePrivId(noti_info->type, noti_info->id, noti_info->sim_idx);
1391         }
1392
1393         MSG_MGR_END();
1394 }
1395
1396
1397 void createActiveInfoData(MSG_MGR_NOTI_INFO_S *noti_info, MSG_MGR_MESSAGE_INFO_S *msg_info)
1398 {
1399         MSG_MGR_BEGIN();
1400
1401         if (!msg_info) {
1402                 MSG_MGR_DEBUG("msg_info is NULL");
1403                 return;
1404         }
1405
1406         noti_info->msg_id = msg_info->msgId;
1407         noti_info->sim_idx = msg_info->sim_idx;
1408
1409         switch (noti_info->type) {
1410         case MSG_MGR_NOTI_TYPE_NORMAL: {
1411                 char *senderStr = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, PUSH_MESSAGE);
1412                 snprintf(noti_info->active_sender, MSG_NOTI_TEXT_LEN_S, "%s", senderStr);
1413                 if (senderStr) {
1414                         free(senderStr);
1415                         senderStr = NULL;
1416                 }
1417                 break;
1418         }
1419         case MSG_MGR_NOTI_TYPE_CLASS0: {
1420                 if (msg_info->displayName[0] == '\0')
1421                         snprintf(noti_info->active_sender, MSG_NOTI_TEXT_LEN_S, "%s", msg_info->addressVal);
1422                 else
1423                         snprintf(noti_info->active_sender, MSG_NOTI_TEXT_LEN_S, "%s", msg_info->displayName);
1424
1425                 snprintf(noti_info->active_text, MSG_NOTI_TEXT_LEN, "%s", msg_info->msgText);
1426                 break;
1427         }
1428         default:
1429                 MSG_MGR_DEBUG("No matching type [%d]", noti_info->type);
1430                 break;
1431         }
1432
1433         MSG_MGR_END();
1434 }
1435
1436
1437 void clearInfoData(notification_h noti_h, MSG_MGR_NOTI_INFO_S *noti_info)
1438 {
1439         MSG_MGR_BEGIN();
1440
1441         if (noti_h) {
1442                 notification_free(noti_h);
1443                 noti_h = NULL;
1444         }
1445
1446         if (noti_info->svc_h) {
1447                 app_control_destroy(noti_info->svc_h);
1448                 noti_info->svc_h = NULL;
1449         }
1450
1451         for (int i = 0; i < MSG_ACTIVE_NOTI_BUTTON_NUM; i++) {
1452                 if (noti_info->active_noti_svc_h[i]) {
1453                         app_control_destroy(noti_info->active_noti_svc_h[i]);
1454                         noti_info->active_noti_svc_h[i] = NULL;
1455                 }
1456         }
1457
1458         MSG_MGR_END();
1459 }
1460
1461
1462 int getAppIcon(const char *app_id, char **icon_path)
1463 {
1464         MSG_MGR_BEGIN();
1465
1466         package_info_h pkg_info_h = NULL;
1467         int pkg_err = PACKAGE_MANAGER_ERROR_NONE;
1468         int ret = 0;
1469
1470         if (app_id == NULL) {
1471                 MSG_MGR_ERR("app id is NULL");
1472                 ret = -1;
1473                 goto END_OF_GET_APP_ICON;
1474         }
1475
1476         pkg_err = package_info_create(app_id, &pkg_info_h);
1477         if (pkg_err != PACKAGE_MANAGER_ERROR_NONE) {
1478                 MSG_MGR_ERR("package_info_create failed (%d)", pkg_err);
1479                 ret = -1;
1480                 goto END_OF_GET_APP_ICON;
1481         }
1482
1483         pkg_err = package_info_get_icon(pkg_info_h, icon_path);
1484         if (pkg_err != PACKAGE_MANAGER_ERROR_NONE) {
1485                 MSG_MGR_ERR("package_info_get_icon failed (%d)", pkg_err);
1486                 ret = -1;
1487         } else {
1488                 if (icon_path == NULL) {
1489                         MSG_MGR_WARN("icon path is NULL");
1490                         ret = -1;
1491                 }
1492         }
1493
1494 END_OF_GET_APP_ICON:
1495         if (pkg_info_h) {
1496                 pkg_err = package_info_destroy(pkg_info_h);
1497                 if (pkg_err != PACKAGE_MANAGER_ERROR_NONE) {
1498                         MSG_MGR_ERR("package_info_destroy failed (%d)", pkg_err);
1499                 }
1500
1501                 pkg_info_h = NULL;
1502         }
1503
1504         MSG_MGR_END();
1505
1506         return ret;
1507 }
1508
1509
1510 int getLatestMsgInfo(MSG_MGR_NOTI_INFO_S *noti_info, bool isForInstantMessage)
1511 {
1512         MSG_MGR_BEGIN();
1513
1514         int noti_err = 0;
1515         msg_error_t msg_err = MSG_SUCCESS;
1516         char **db_res = NULL;
1517         int row_cnt = 0, col_cnt = 0;
1518
1519         switch (noti_info->type) {
1520         case MSG_MGR_NOTI_TYPE_NORMAL:
1521 #ifdef MSG_NOTI_INTEGRATION
1522         case MSG_MGR_NOTI_TYPE_CB:
1523         case MSG_MGR_NOTI_TYPE_SIM:
1524 #endif
1525     {
1526         int smsUnreadCnt = 0;
1527                 int mmsUnreadCnt = 0;
1528
1529                 char sqlQuery[MAX_QUERY_LEN     +1];
1530                 unsigned char mainType;
1531                 unsigned char subType;
1532                 int msgSize;
1533
1534                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1535 #ifdef MSG_NOTI_INTEGRATION
1536                 snprintf(sqlQuery, sizeof(sqlQuery), "DISTINCT "
1537                                 "A.ADDRESS_VAL, "
1538                                 "B.SUB_TYPE "
1539                                 "FROM %s A, %s B "
1540                                 "WHERE A.CONV_ID=B.CONV_ID "
1541                                 "AND B.READ_STATUS=0 AND (B.FOLDER_ID=%d OR B.FOLDER_ID=%d) "
1542                                 "AND B.STORAGE_ID = %d "
1543                                 "GROUP BY A.ADDRESS_VAL "
1544                                 "ORDER BY B.DISPLAY_TIME DESC LIMIT 5;",
1545                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
1546                                 MSG_INBOX_ID, MSG_CBMSGBOX_ID,
1547                                 MSG_STORAGE_PHONE);
1548 #else
1549                 snprintf(sqlQuery, sizeof(sqlQuery), "DISTINCT "
1550                                 "A.ADDRESS_VAL, "
1551                                 "B.SUB_TYPE "
1552                                 "FROM %s A, %s B "
1553                                 "WHERE A.CONV_ID=B.CONV_ID "
1554                                 "AND B.READ_STATUS=0 AND B.FOLDER_ID=%d "
1555                                 "AND B.STORAGE_ID = %d "
1556                                 "GROUP BY A.ADDRESS_VAL "
1557                                 "ORDER BY B.DISPLAY_TIME DESC LIMIT 5;",
1558                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
1559                                 MSG_INBOX_ID,
1560                                 MSG_STORAGE_PHONE);
1561 #endif
1562                 MSG_MGR_DEBUG("sqlQuery [%s]", sqlQuery);
1563
1564                 row_cnt = 0, col_cnt = 0;
1565                 msg_err = msg_db_select_with_query(msg_handle, sqlQuery, &db_res, &row_cnt, &col_cnt);
1566                 if (msg_err != MSG_SUCCESS) {
1567                         MSG_MGR_ERR("msg_db_select_with_query() failed [%d]", msg_err);
1568                         return -1;
1569                 }
1570
1571 /* contacts-service is not used for gear */
1572 #ifndef MSG_CONTACTS_SERVICE_NOT_SUPPORTED
1573                 MSG_MGR_ADDRESS_INFO_S tmpAddressInfo;
1574                 int normalAddCnt = 0;
1575                 int index = col_cnt;
1576
1577                 for (int i = 1; i <= row_cnt; i++) {
1578                         memset(&tmpAddressInfo, 0x00, sizeof(MSG_MGR_ADDRESS_INFO_S));
1579
1580                         char *address = db_res[index++];
1581                         normalAddCnt++;
1582                         if (address) {
1583                                 snprintf(tmpAddressInfo.addressVal, MAX_ADDRESS_VAL_LEN, "%s", address);
1584                                 if (_is_valid_email(address)) {
1585                                         tmpAddressInfo.addressType = MSG_ADDRESS_TYPE_EMAIL;
1586                                 } else {
1587                                         tmpAddressInfo.addressType = MSG_ADDRESS_TYPE_UNKNOWN;
1588                                 }
1589                         }
1590                         subType = atoi(db_res[index++]);
1591
1592                         MSG_MGR_CONTACT_INFO_S tmpContact;
1593                         memset(&tmpContact, 0x00, sizeof(MSG_MGR_CONTACT_INFO_S));
1594
1595                         MsgMgrGetContactInfo(&tmpAddressInfo, &tmpContact);
1596
1597                         if (row_cnt == 1) {
1598                                 snprintf(noti_info->imagePath, sizeof(noti_info->imagePath), "%s", tmpContact.imagePath);
1599                         }
1600
1601                         if (normalAddCnt > 1) {
1602                                 g_strlcat(noti_info->sender, ", ", sizeof(noti_info->sender)-strlen(noti_info->sender));
1603                         }
1604
1605                         if (tmpContact.firstName[0] != '\0') {
1606                                 g_strlcat(noti_info->sender, tmpContact.firstName, sizeof(noti_info->sender)-strlen(noti_info->sender));
1607                         } else if (tmpAddressInfo.addressVal[0] == '\0') {
1608                                 char *senderStr = NULL;
1609                                 senderStr = get_translate_text("message", MSG_APP_LOCALEDIR, MSG_UNKNOWN_SENDER);
1610                                 g_strlcat(noti_info->sender, senderStr, sizeof(noti_info->sender)-strlen(noti_info->sender));
1611                                 if (senderStr) {
1612                                         free(senderStr);
1613                                         senderStr = NULL;
1614                                 }
1615
1616                                 if (i == 1) {
1617                                         noti_info->active_noti_button_num = 1;
1618                                 }
1619                         } else {
1620                                 char *senderStr = NULL;
1621                                 if (subType == MSG_CB_SMS) {
1622                                         senderStr = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, CB_MESSAGE);
1623                                         g_strlcat(noti_info->sender, senderStr, sizeof(noti_info->sender)-strlen(noti_info->sender));
1624                                         noti_info->active_noti_button_num = 1;
1625                                 } else if (subType == MSG_SYNCML_CP) {
1626                                         senderStr = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, CP_MESSAGE);
1627                                         g_strlcat(noti_info->sender, senderStr, sizeof(noti_info->sender)-strlen(noti_info->sender));
1628                                         noti_info->active_noti_button_num = 1;
1629                                 } else if (subType == MSG_WAP_SI_SMS || subType == MSG_WAP_SL_SMS) {
1630                                         senderStr = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, PUSH_MESSAGE);
1631                                         g_strlcat(noti_info->sender, senderStr, sizeof(noti_info->sender)-strlen(noti_info->sender));
1632                                         noti_info->active_noti_button_num = 1;
1633                                 } else {
1634                                         g_strlcat(noti_info->sender, tmpAddressInfo.addressVal, sizeof(noti_info->sender)-strlen(noti_info->sender));
1635                                 }
1636
1637                                 if (senderStr) {
1638                                         free(senderStr);
1639                                         senderStr = NULL;
1640                                 }
1641                         }
1642
1643                         if (i == 1) {
1644                                 noti_info->active_subtype = subType;
1645                                 snprintf(noti_info->active_sender, MSG_NOTI_TEXT_LEN_S, "%s", noti_info->sender);
1646                                 snprintf(noti_info->imagePath, sizeof(noti_info->imagePath), "%s", tmpContact.imagePath);
1647                         }
1648                 }
1649
1650                 noti_info->senderCount = normalAddCnt;
1651 #endif /* MSG_CONTACTS_SERVICE_NOT_SUPPORTED */
1652                 msg_db_free(msg_handle, db_res);
1653
1654                 MSG_MGR_SEC_DEBUG("sender info = [%s]", noti_info->sender);
1655
1656                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1657
1658 #ifdef MSG_NOTI_INTEGRATION
1659                 snprintf(sqlQuery, sizeof(sqlQuery),
1660                                 "A.ADDRESS_VAL, "
1661                                 "B.DISPLAY_TIME, "
1662                                 "B.MSG_ID, "
1663                                 "B.SUBJECT, "
1664                                 "B.MSG_TEXT, "
1665                                 "B.MAIN_TYPE, "
1666                                 "(COUNT(DISTINCT(CASE WHEN B.MAIN_TYPE = %d THEN B.MSG_ID END))) AS SMS_UNREAD_CNT, "
1667                                 "(COUNT(DISTINCT(CASE WHEN B.MAIN_TYPE = %d THEN B.MSG_ID END))) AS MMS_UNREAD_CNT, "
1668                                 "(CASE WHEN B.MAIN_TYPE = %d AND B.NETWORK_STATUS = %d THEN (SELECT C.MSG_SIZE FROM %s C WHERE B.MSG_ID = C.MSG_ID) ELSE -1 END) "
1669                                 "FROM %s A, %s B "
1670                                 "WHERE A.CONV_ID=B.CONV_ID "
1671                                 "AND B.READ_STATUS=0 AND (B.FOLDER_ID=%d OR B.FOLDER_ID=%d) "
1672                                 "AND B.STORAGE_ID = %d "
1673                                 "ORDER BY B.DISPLAY_TIME DESC;",
1674                                 MSG_SMS_TYPE,
1675                                 MSG_MMS_TYPE,
1676                                 MSG_MMS_TYPE, MSG_NETWORK_RECEIVED, MMS_PLUGIN_MESSAGE_TABLE_NAME,
1677                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
1678                                 MSG_INBOX_ID, MSG_CBMSGBOX_ID,
1679                                 MSG_STORAGE_PHONE);
1680 #else
1681                 snprintf(sqlQuery, sizeof(sqlQuery),
1682                                 "A.ADDRESS_VAL, "
1683                                 "B.DISPLAY_TIME, "
1684                                 "B.MSG_ID, "
1685                                 "B.SUBJECT, "
1686                                 "B.MSG_TEXT, "
1687                                 "B.MAIN_TYPE, "
1688                                 "(COUNT(CASE WHEN B.MAIN_TYPE = %d THEN 1 END)) AS SMS_UNREAD_CNT, "
1689                                 "(COUNT(CASE WHEN B.MAIN_TYPE = %d THEN 1 END)) AS MMS_UNREAD_CNT "
1690                                 "FROM %s A, %s B "
1691                                 "WHERE A.CONV_ID=B.CONV_ID "
1692                                 "AND B.READ_STATUS=0 AND B.FOLDER_ID=%d "
1693                                 "AND B.STORAGE_ID = %d "
1694                                 "ORDER BY B.DISPLAY_TIME DESC;",
1695                                 MSG_SMS_TYPE,
1696                                 MSG_MMS_TYPE,
1697                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
1698                                 MSG_INBOX_ID,
1699                                 MSG_STORAGE_PHONE);
1700 #endif
1701                 MSG_MGR_DEBUG("sqlQuery [%s]", sqlQuery);
1702
1703                 msg_err = msg_db_select_with_query(msg_handle, sqlQuery, &db_res, &row_cnt, &col_cnt);
1704                 if (msg_err != MSG_SUCCESS) {
1705                         MSG_MGR_ERR("msg_db_select_with_query() failed [%d]", msg_err);
1706                         return -1;
1707                 }
1708
1709                 if (row_cnt > 0) {
1710                         smsUnreadCnt = atoi(db_res[col_cnt+6]);
1711                         mmsUnreadCnt = atoi(db_res[col_cnt+7]);
1712                         msgSize = atoi(db_res[col_cnt+8]);
1713
1714                         noti_info->count = smsUnreadCnt + mmsUnreadCnt;
1715
1716                         if (noti_info->count > 0) {
1717                                 snprintf(noti_info->number, sizeof(noti_info->number), "%s", db_res[col_cnt]);
1718
1719                                 noti_info->time = (time_t)atoi(db_res[col_cnt+1]);
1720
1721                                 noti_info->msg_id = (msg_message_id_t)atoi(db_res[col_cnt+2]);
1722
1723                                 mainType = (unsigned char)atoi(db_res[col_cnt+5]);
1724
1725                                 if (mainType == MSG_MMS_TYPE) {
1726                                         snprintf(noti_info->text, sizeof(noti_info->text), "%s", db_res[col_cnt+3]);
1727                                         if (noti_info->text[0] == '\0') {
1728                                                 char *noti_text = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, MSG_NO_SUBJECT);
1729                                                 snprintf(noti_info->text, sizeof(noti_info->text), "%s", noti_text);
1730                                                 g_free(noti_text);
1731                                         }
1732
1733                                         char *prefix_subject = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, MSG_SUBJECT_COLON);
1734                                         if (prefix_subject) {
1735                                                 snprintf(noti_info->active_subject, MSG_NOTI_TEXT_LEN_S, "%s%s", prefix_subject, noti_info->text);
1736                                                 g_free(prefix_subject);
1737                                         } else {
1738                                                 snprintf(noti_info->active_subject, MSG_NOTI_TEXT_LEN_S, "%s", noti_info->text);
1739                                         }
1740
1741                                         if (msgSize > -1) {
1742                                                 int kb_msg_size = msgSize / 1024;
1743                                                 if (kb_msg_size == 0 && msgSize > 0)
1744                                                         kb_msg_size = 1;
1745                                                 else if (msgSize % 1024 >= 512)
1746                                                         kb_msg_size++;
1747
1748                                                 char *msg_size_string = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, MESSAGE_SIZE_STRING);
1749                                                 char *msg_size_unit_kb = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, MESSAGE_SIZE_UNIT_KB);
1750
1751                                                 snprintf(noti_info->active_text, MSG_NOTI_TEXT_LEN, "%s : %d%s", msg_size_string, kb_msg_size, msg_size_unit_kb);
1752
1753                                                 g_free(msg_size_string);
1754                                                 g_free(msg_size_unit_kb);
1755                                         }
1756
1757                                 } else {
1758                                         snprintf(noti_info->text, sizeof(noti_info->text), "%s", db_res[col_cnt+4]);
1759                                 }
1760
1761                                 if (noti_info->active_text[0] == '\0')
1762                                         snprintf(noti_info->active_text, MSG_NOTI_TEXT_LEN, "%s", db_res[col_cnt+4]);
1763
1764                                 MSG_MGR_DEBUG("unread message ID [%d].", noti_info->msg_id);
1765
1766                                 MSG_MGR_DEBUG("active sender [%s]", noti_info->active_sender);
1767                                 MSG_MGR_DEBUG("active subject [%s]", noti_info->active_subject);
1768                                 MSG_MGR_DEBUG("active text [%s]", noti_info->active_text);
1769
1770                                 if (!isForInstantMessage) {
1771                                         if (noti_info->id > 0 && noti_info->count == 1) {
1772                                                 noti_err = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NOTI, noti_info->id);
1773                                                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1774                                                         MSG_MGR_DEBUG("Fail to notification_delete_by_priv_id : %d", noti_err);
1775                                                 }
1776
1777                                                 noti_info->id = 0;
1778                                                 if (vconf_set_int(NOTIFICATION_PRIV_ID, noti_info->id) != 0)
1779                                                         MSG_MGR_DEBUG("vconf_set_int fail : NOTIFICATION_PRIV_ID");
1780                                         }
1781
1782                                         vconf_set_int(VCONFKEY_MESSAGE_RECV_SMS_STATE, smsUnreadCnt);
1783                                         vconf_set_int(VCONFKEY_MESSAGE_RECV_MMS_STATE, mmsUnreadCnt);
1784                                         MsgMgrInsertBadge(noti_info->count);
1785                                         MsgMgrSoundSetRepeatAlarm();
1786                                 }
1787                         } else {
1788                                 MSG_MGR_DEBUG("No unread message.");
1789                                 MSG_MGR_DEBUG("notiPrivId [%d]", noti_info->id);
1790
1791                                 msg_db_free(msg_handle, db_res);
1792
1793                                 if (!isForInstantMessage) {
1794                                         /* No unread message. */
1795                                         if (noti_info->id > 0) {
1796                                                 noti_err = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NOTI, noti_info->id);
1797                                                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1798                                                         MSG_MGR_DEBUG("Fail to notification_delete_by_priv_id : %d", noti_err);
1799                                                 }
1800                                         }
1801
1802                                         noti_info->id = 0;
1803
1804                                         if (vconf_set_int(NOTIFICATION_PRIV_ID, noti_info->id) != 0)
1805                                                 MSG_MGR_DEBUG("vconf_set_int fail : NOTIFICATION_PRIV_ID");
1806
1807                                         vconf_set_int(VCONFKEY_MESSAGE_RECV_SMS_STATE, 0);
1808                                         vconf_set_int(VCONFKEY_MESSAGE_RECV_MMS_STATE, 0);
1809                                         MsgMgrInsertBadge(0);
1810                                         MsgMgrSoundSetRepeatAlarm();
1811                                 }
1812
1813                                 return -1;
1814                         }
1815                 } else {
1816                         MSG_MGR_DEBUG("sqlQuery [%s]", sqlQuery);
1817                         msg_db_free(msg_handle, db_res);
1818                         return -1;
1819                 }
1820
1821                 msg_db_free(msg_handle, db_res);
1822                 break;
1823         }
1824
1825 #ifndef MSG_NOTI_INTEGRATION
1826         case MSG_MGR_NOTI_TYPE_CB: {
1827                 char sqlQuery[MAX_QUERY_LEN+1];
1828                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1829
1830                 snprintf(sqlQuery, sizeof(sqlQuery),
1831                                 "A.ADDRESS_VAL, "
1832                                 "B.DISPLAY_TIME, "
1833                                 "B.MSG_ID, "
1834                                 "B.MSG_TEXT "
1835                                 "FROM %s A, %s B "
1836                                 "WHERE A.CONV_ID=B.CONV_ID "
1837                                 "AND B.READ_STATUS=0 "
1838                                 "AND B.FOLDER_ID=%d "
1839                                 "AND B.STORAGE_ID = %d "
1840                                 "ORDER BY B.DISPLAY_TIME DESC;",
1841                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
1842                                 MSG_CBMSGBOX_ID,
1843                                 MSG_STORAGE_PHONE);
1844
1845                 if (dbhandler->prepareQuery(sqlQuery) != MSG_SUCCESS)
1846                         return MSG_ERR_DB_PREPARE;
1847
1848                 if (dbhandler->stepQuery() == MSG_ERR_DB_ROW) {
1849                         MSG_ADDRESS_INFO_S addrInfo;
1850                         memset(&addrInfo, 0x00, sizeof(MSG_ADDRESS_INFO_S));
1851
1852                         if (dbhandler->columnText(0) != NULL)
1853                                 snprintf(addrInfo.addressVal, sizeof(addrInfo.addressVal), "%s", (char*)dbhandler->columnText(0));
1854
1855                         MSG_CONTACT_INFO_S tmpContact;
1856                         memset(&tmpContact, 0x00, sizeof(MSG_CONTACT_INFO_S));
1857
1858                         MsgGetContactInfo(&addrInfo, &tmpContact);
1859
1860                         if (tmpContact.firstName[0] != '\0') {
1861                                 snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", tmpContact.firstName);
1862                         } else if (addrInfo.addressVal[0] == '\0') {
1863                                 char *senderStr = NULL;
1864                                 senderStr = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, MSG_UNKNOWN_SENDER);
1865                                 g_strlcat(noti_info->sender, senderStr, sizeof(noti_info->sender)-strlen(noti_info->sender));
1866                                 if (senderStr) {
1867                                         free(senderStr);
1868                                         senderStr = NULL;
1869                                 }
1870                         } else {
1871                                 snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", addrInfo.addressVal);
1872                         }
1873
1874                         snprintf(noti_info->number, sizeof(noti_info->number), "%s", addrInfo.addressVal);
1875
1876                         noti_info->time = (time_t)dbhandler->columnInt(1);
1877
1878                         noti_info->msg_id = (msg_message_id_t)dbhandler->columnInt(2);
1879
1880                         snprintf(noti_info->text, sizeof(noti_info->text), "%s", (char*)dbhandler->columnText(3));
1881
1882                         MSG_MGR_DEBUG("unread CB message [%d].", noti_info->msg_id);
1883                 } else {
1884                         MSG_MGR_DEBUG("No unread CB message.");
1885                         MSG_MGR_DEBUG("notiCbId [%d]", noti_info->id);
1886
1887                         dbhandler->finalizeQuery();
1888
1889                         if (!isForInstantMessage) {
1890                                 /* No unread message. */
1891                                 if (noti_info->id > 0) {
1892                                         noti_err = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NOTI, noti_info->id);
1893                                         if (noti_err != NOTIFICATION_ERROR_NONE) {
1894                                                 MSG_MGR_DEBUG("Fail to notification_delete_by_priv_id : %d", noti_err);
1895                                         }
1896                                 }
1897
1898                                 noti_info->id = 0;
1899
1900                                 if (MsgSettingSetInt(CB_NOTI_PRIV_ID, noti_info->id) != MSG_SUCCESS)
1901                                         MSG_MGR_DEBUG("MsgSettingSetInt fail : CB_NOTI_PRIV_ID");
1902                         }
1903                         return MSG_ERR_DB_STEP;
1904                 }
1905
1906                 dbhandler->finalizeQuery();
1907
1908                 if (dbhandler->getTable(sqlQuery, &noti_info->count, NULL) != MSG_SUCCESS) {
1909                         MSG_MGR_DEBUG("getTable is failed");
1910                         dbhandler->freeTable();
1911                         return MSG_ERR_DB_GETTABLE;
1912                 }
1913
1914                 dbhandler->freeTable();
1915                 MSG_MGR_DEBUG("notiCbId [%d], unreadCbMsgCnt [%d]", noti_info->id, noti_info->count);
1916                 break;
1917         }
1918         case MSG_MGR_NOTI_TYPE_SIM: {
1919                 char sqlQuery[MAX_QUERY_LEN+1];
1920                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1921
1922                 snprintf(sqlQuery, sizeof(sqlQuery),
1923                                 "A.ADDRESS_VAL, "
1924                                 "B.DISPLAY_TIME, "
1925                                 "B.MSG_ID, "
1926                                 "B.MSG_TEXT, "
1927                                 "(COUNT(CASE WHEN B.MAIN_TYPE = %d THEN 1 END)) AS SMS_UNREAD_CNT "
1928                                 "FROM %s A, %s B "
1929                                 "WHERE A.CONV_ID=B.CONV_ID "
1930                                 "AND B.READ_STATUS=0 AND B.FOLDER_ID=%d "
1931                                 "AND B.STORAGE_ID = %d "
1932                                 "ORDER BY B.DISPLAY_TIME DESC;",
1933                                 MSG_SMS_TYPE,
1934                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
1935                                 MSG_INBOX_ID,
1936                                 MSG_STORAGE_SIM);
1937
1938                 MSG_MGR_DEBUG("sqlQuery [%s]", sqlQuery);
1939
1940                 if (dbhandler->prepareQuery(sqlQuery) != MSG_SUCCESS)
1941                         return MSG_ERR_DB_PREPARE;
1942
1943                 if (dbhandler->stepQuery() == MSG_ERR_DB_ROW) {
1944                         noti_info->count = dbhandler->columnInt(4);
1945
1946                         if (noti_info->count > 0) {
1947                                 MSG_ADDRESS_INFO_S addrInfo;
1948                                 memset(&addrInfo, 0x00, sizeof(MSG_ADDRESS_INFO_S));
1949
1950                                 if (dbhandler->columnText(0) != NULL)
1951                                         snprintf(addrInfo.addressVal, sizeof(addrInfo.addressVal), "%s", (char*)dbhandler->columnText(0));
1952
1953                                 MSG_CONTACT_INFO_S tmpContact;
1954                                 memset(&tmpContact, 0x00, sizeof(MSG_CONTACT_INFO_S));
1955
1956                                 MsgGetContactInfo(&addrInfo, &tmpContact);
1957
1958                                 if (tmpContact.firstName[0] != '\0') {
1959                                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", tmpContact.firstName);
1960                                 } else if (addrInfo.addressVal[0] == '\0') {
1961                                         char *senderStr = NULL;
1962                                         senderStr = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, MSG_UNKNOWN_SENDER);
1963                                         g_strlcat(noti_info->sender, senderStr, sizeof(noti_info->sender)-strlen(noti_info->sender));
1964                                         if (senderStr) {
1965                                                 free(senderStr);
1966                                                 senderStr = NULL;
1967                                         }
1968                                 } else {
1969                                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", addrInfo.addressVal);
1970                                 }
1971
1972                                 snprintf(noti_info->number, sizeof(noti_info->number), "%s", addrInfo.addressVal);
1973
1974                                 noti_info->time = (time_t)dbhandler->columnInt(1);
1975
1976                                 noti_info->msg_id = (msg_message_id_t)dbhandler->columnInt(2);
1977
1978                                 snprintf(noti_info->text, sizeof(noti_info->text), "%s", (char*)dbhandler->columnText(3));
1979
1980                                 MSG_MGR_DEBUG("unread SIM message [%d].", noti_info->msg_id);
1981                         } else {
1982                                 MSG_MGR_DEBUG("No unread SIM message.");
1983                                 MSG_MGR_DEBUG("notiPrivId [%d]", noti_info->id);
1984
1985                                 dbhandler->finalizeQuery();
1986
1987                                 if (!isForInstantMessage) {
1988                                         /* No unread message. */
1989                                         if (noti_info->id > 0) {
1990                                                 noti_err = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NOTI, noti_info->id);
1991                                                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1992                                                         MSG_MGR_DEBUG("Fail to notification_delete_by_priv_id : %d", noti_err);
1993                                                 }
1994                                         }
1995
1996                                         noti_info->id = 0;
1997
1998                                         if (MsgSettingSetInt(SIM_MSG_NOTI_PRIV_ID, noti_info->id) != MSG_SUCCESS)
1999                                                 MSG_MGR_DEBUG("MsgSettingSetInt fail : SIM_MSG_NOTI_PRIV_ID");
2000                                 }
2001
2002                                 return MSG_ERR_DB_STEP;
2003                         }
2004                 } else {
2005                         MSG_MGR_DEBUG("sqlQuery [%s]", sqlQuery);
2006                         dbhandler->finalizeQuery();
2007                         return MSG_ERR_DB_STEP;
2008                 }
2009
2010                 dbhandler->finalizeQuery();
2011                 break;
2012         }
2013 #endif
2014         case MSG_MGR_NOTI_TYPE_FAILED: {
2015                 char sqlQuery[MAX_QUERY_LEN+1];
2016                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
2017
2018                 snprintf(sqlQuery, sizeof(sqlQuery),
2019                                 "A.ADDRESS_VAL, "
2020                                 "B.DISPLAY_TIME, "
2021                                 "B.MSG_ID, "
2022                                 "B.MSG_TEXT, "
2023                                 "B.SUBJECT, "
2024                                 "B.MAIN_TYPE, "
2025                                 "(COUNT(CASE WHEN B.NETWORK_STATUS = %d THEN 1 END)) AS SENT_FAILED_CNT "
2026                                 "FROM %s A, %s B "
2027                                 "WHERE A.CONV_ID=B.CONV_ID "
2028                                 "AND B.READ_STATUS=0 AND B.FOLDER_ID=%d "
2029                                 "AND B.STORAGE_ID = %d "
2030                                 "ORDER BY B.DISPLAY_TIME DESC;",
2031                                 MSG_NETWORK_SEND_FAIL,
2032                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
2033                                 MSG_OUTBOX_ID,
2034                                 MSG_STORAGE_PHONE);
2035
2036                 MSG_MGR_DEBUG("sqlQuery [%s]", sqlQuery);
2037
2038                 row_cnt = 0, col_cnt = 0;
2039                 msg_err = msg_db_select_with_query(msg_handle, sqlQuery, &db_res, &row_cnt, &col_cnt);
2040                 if (msg_err != MSG_SUCCESS) {
2041                         MSG_MGR_ERR("msg_db_select_with_query() failed [%d]", msg_err);
2042                         return -1;
2043                 }
2044
2045                 if (row_cnt > 0) {
2046                         noti_info->count = atoi(db_res[col_cnt+6]);
2047
2048                         if (noti_info->count > 0) {
2049                                 MSG_MGR_ADDRESS_INFO_S addrInfo = {0,};
2050
2051                                 snprintf(addrInfo.addressVal, MAX_ADDRESS_VAL_LEN, "%s", db_res[col_cnt]);
2052
2053                                 MSG_MGR_CONTACT_INFO_S tmpContact = {0,};
2054
2055                                 MsgMgrGetContactInfo(&addrInfo, &tmpContact);
2056
2057                                 if (tmpContact.firstName[0] != '\0') {
2058                                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", tmpContact.firstName);
2059                                 } else if (addrInfo.addressVal[0] == '\0') {
2060                                         char *senderStr = NULL;
2061                                         senderStr = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, MSG_UNKNOWN_SENDER);
2062                                         g_strlcat(noti_info->sender, senderStr, sizeof(noti_info->sender)-strlen(noti_info->sender));
2063                                         if (senderStr) {
2064                                                 free(senderStr);
2065                                                 senderStr = NULL;
2066                                         }
2067                                 } else {
2068                                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", addrInfo.addressVal);
2069                                 }
2070
2071                                 snprintf(noti_info->number, sizeof(noti_info->number), "%s", addrInfo.addressVal);
2072
2073                                 noti_info->time = (time_t)atoi(db_res[col_cnt+1]);
2074
2075                                 noti_info->msg_id = (msg_message_id_t)atoi(db_res[col_cnt+2]);
2076
2077                                 unsigned char mainType = (unsigned char)atoi(db_res[col_cnt+5]);
2078
2079                                 if (mainType == MSG_TYPE_MMS)
2080                                         snprintf(noti_info->text, sizeof(noti_info->text), "%s", db_res[col_cnt+4]);
2081                                 else
2082                                         snprintf(noti_info->text, sizeof(noti_info->text), "%s", db_res[col_cnt+3]);
2083
2084                                 MSG_MGR_DEBUG("Sent failed message ID [%d].", noti_info->msg_id);
2085
2086                                 if (!isForInstantMessage) {
2087                                         if (noti_info->id > 0 && noti_info->count == 1) {
2088                                                 noti_err = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NOTI, noti_info->id);
2089                                                 if (noti_err != NOTIFICATION_ERROR_NONE) {
2090                                                         MSG_MGR_DEBUG("Fail to notification_delete_by_priv_id : %d", noti_err);
2091                                                 }
2092                                                 noti_info->id = 0;
2093                                                 if (vconf_set_int(MSG_SENTFAIL_NOTI_ID, noti_info->id) != 0)
2094                                                         MSG_MGR_DEBUG("vconf_set_int fail : MSG_SENTFAIL_NOTI_ID");
2095                                         }
2096                                 }
2097                         } else {
2098                                 MSG_MGR_DEBUG("No sent failed message.");
2099                                 MSG_MGR_DEBUG("failedNotiId [%d]", noti_info->id);
2100
2101                                 msg_db_free(msg_handle, db_res);
2102
2103                                 if (!isForInstantMessage) {
2104                                         /* No unread message. */
2105                                         if (noti_info->id > 0) {
2106                                                 noti_err = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NOTI, noti_info->id);
2107                                                 if (noti_err != NOTIFICATION_ERROR_NONE) {
2108                                                         MSG_MGR_DEBUG("Fail to notification_delete_by_priv_id : %d", noti_err);
2109                                                 }
2110                                         }
2111
2112                                         noti_info->id = 0;
2113
2114                                         if (vconf_set_int(MSG_SENTFAIL_NOTI_ID, noti_info->id) != 0)
2115                                                 MSG_MGR_DEBUG("vconf_set_int fail : MSG_SENTFAIL_NOTI_ID");
2116                                 }
2117
2118                                 return -1;
2119                         }
2120                 } else {
2121                         msg_db_free(msg_handle, db_res);
2122                         return -1;
2123                 }
2124
2125                 msg_db_free(msg_handle, db_res);
2126                 break;
2127         }
2128         case MSG_MGR_NOTI_TYPE_SIM_FULL:
2129                 break;
2130         default:
2131                 MSG_MGR_DEBUG("No matching type [%d]", noti_info->type);
2132                 return -1;
2133         }
2134
2135         MSG_MGR_END();
2136
2137         return 0;
2138 }
2139
2140
2141 notification_h getHandle(int *noti_id)
2142 {
2143         notification_h noti_h = NULL;
2144
2145         if (*noti_id > 0) {
2146                 MSG_MGR_DEBUG("Notification load");
2147                 noti_h = notification_load(NULL, *noti_id);
2148                 if (noti_h == NULL)
2149                         MSG_MGR_DEBUG("notification_load is failed.");
2150         }
2151
2152         if (noti_h == NULL) {
2153                 MSG_MGR_DEBUG("Notification create");
2154                 noti_h = notification_create(NOTIFICATION_TYPE_NOTI);
2155                 if (noti_h == NULL) {
2156                         MSG_MGR_DEBUG("notification_create is failed.");
2157                         return NULL;
2158                 }
2159
2160                 *noti_id = 0;
2161         }
2162
2163         return noti_h;
2164 }
2165
2166
2167 int getPrivId(msg_mgr_notification_type_t noti_type, int sim_idx)
2168 {
2169         MSG_MGR_BEGIN();
2170
2171         int noti_id = 0;
2172
2173         switch (noti_type) {
2174 #ifdef MSG_NOTI_INTEGRATION
2175         case MSG_MGR_NOTI_TYPE_NORMAL:
2176         case MSG_MGR_NOTI_TYPE_SIM:
2177         case MSG_MGR_NOTI_TYPE_CB:
2178                 vconf_get_int(NOTIFICATION_PRIV_ID, &noti_id);
2179                 break;
2180 #else
2181         case MSG_MGR_NOTI_TYPE_NORMAL:
2182                 vconf_get_int(NOTIFICATION_PRIV_ID, &noti_id);
2183                 break;
2184         case MSG_MGR_NOTI_TYPE_SIM:
2185                 vconf_get_int(SIM_MSG_NOTI_PRIV_ID, &noti_id);
2186                 break;
2187         case MSG_MGR_NOTI_TYPE_CB:
2188                 vconf_get_int(CB_NOTI_PRIV_ID, &noti_id);
2189                 break;
2190 #endif
2191         case MSG_MGR_NOTI_TYPE_FAILED:
2192                 vconf_get_int(MSG_SENTFAIL_NOTI_ID, &noti_id);
2193                 break;
2194         case MSG_MGR_NOTI_TYPE_VOICE_1: {
2195                 char keyName[MAX_VCONFKEY_NAME_LEN] = {0, };
2196                 snprintf(keyName, sizeof(keyName), "%s/%d", VOICE_NOTI_ID_1, sim_idx);
2197                 vconf_get_int(keyName, &noti_id);
2198                 break;
2199         }
2200         case MSG_MGR_NOTI_TYPE_VOICE_2: {
2201                 char keyName[MAX_VCONFKEY_NAME_LEN] = {0, };
2202                 snprintf(keyName, sizeof(keyName), "%s/%d", VOICE_NOTI_ID_2, sim_idx);
2203                 vconf_get_int(keyName, &noti_id);
2204                 break;
2205         }
2206         case MSG_MGR_NOTI_TYPE_SIM_FULL:
2207                 vconf_get_int(SIM_FULL_NOTI_PRIV_ID, &noti_id);
2208                 break;
2209         default:
2210                 MSG_MGR_DEBUG("No matching noti type [%d]", noti_type);
2211                 break;
2212         }
2213
2214         MSG_MGR_DEBUG("Get noti type = %d, id = %d, sim_idx:%d", noti_type, noti_id, sim_idx);
2215
2216         MSG_MGR_END();
2217
2218         return noti_id;
2219 }
2220
2221
2222 void updatePrivId(msg_mgr_notification_type_t noti_type, int noti_id, int sim_idx)
2223 {
2224         MSG_MGR_BEGIN();
2225
2226         int err = 0;
2227
2228         MSG_MGR_DEBUG("Update noti type = %d, id = %d, sim_idx = %d", noti_type, noti_id, sim_idx);
2229
2230         switch (noti_type) {
2231 #ifdef MSG_NOTI_INTEGRATION
2232         case MSG_MGR_NOTI_TYPE_NORMAL:
2233         case MSG_MGR_NOTI_TYPE_SIM:
2234         case MSG_MGR_NOTI_TYPE_CB:
2235                 err = vconf_set_int(NOTIFICATION_PRIV_ID, noti_id);
2236                 break;
2237 #else
2238         case MSG_MGR_NOTI_TYPE_NORMAL:
2239                 err = vconf_set_int(NOTIFICATION_PRIV_ID, noti_id);
2240                 break;
2241         case MSG_MGR_NOTI_TYPE_SIM:
2242                 err = vconf_set_int(SIM_MSG_NOTI_PRIV_ID, noti_id);
2243                 break;
2244         case MSG_MGR_NOTI_TYPE_CB:
2245                 err = vconf_set_int(CB_NOTI_PRIV_ID, noti_id);
2246                 break;
2247 #endif
2248         case MSG_MGR_NOTI_TYPE_FAILED:
2249                 err = vconf_set_int(MSG_SENTFAIL_NOTI_ID, noti_id);
2250                 break;
2251         case MSG_MGR_NOTI_TYPE_VOICE_1: {
2252                 char keyName[MAX_VCONFKEY_NAME_LEN] = {0, };
2253                 snprintf(keyName, sizeof(keyName), "%s/%d", VOICE_NOTI_ID_1, sim_idx);
2254                 err = vconf_set_int(keyName, noti_id);
2255                 break;
2256         }
2257         case MSG_MGR_NOTI_TYPE_VOICE_2: {
2258                 char keyName[MAX_VCONFKEY_NAME_LEN] = {0, };
2259                 snprintf(keyName, sizeof(keyName), "%s/%d", VOICE_NOTI_ID_2, sim_idx);
2260                 err = vconf_set_int(keyName, noti_id);
2261                 break;
2262         }
2263         case MSG_MGR_NOTI_TYPE_SIM_FULL:
2264                 err = vconf_set_int(SIM_FULL_NOTI_PRIV_ID, noti_id);
2265                 break;
2266         default:
2267                 MSG_MGR_DEBUG("No matching type [%d]", noti_type);
2268                 break;
2269         }
2270
2271         if (err != 0)
2272                 MSG_MGR_INFO("vconf_set_int fail : noti type = %d, id = %d, sim_idx = %d", noti_type, noti_id, sim_idx);
2273
2274         MSG_MGR_END();
2275 }
2276
2277
2278 void createInfoData(MSG_MGR_NOTI_INFO_S *noti_info, MSG_MGR_MESSAGE_INFO_S *msg_info)
2279 {
2280         MSG_MGR_BEGIN();
2281
2282         if (msg_info) {
2283                 noti_info->id = getPrivId(noti_info->type, msg_info->sim_idx);
2284                 noti_info->msg_id = msg_info->msgId;
2285         } else {
2286                 MSG_MGR_DEBUG("msg_info is NULL");
2287                 return;
2288         }
2289
2290         noti_info->sim_idx = msg_info->sim_idx;
2291
2292         createServiceHandle(&noti_info->svc_h);
2293         char keyName[MAX_VCONFKEY_NAME_LEN];
2294
2295         switch (noti_info->type) {
2296         case MSG_MGR_NOTI_TYPE_VOICE_1:
2297         case MSG_MGR_NOTI_TYPE_VOICE_2: {
2298                 memset(keyName, 0x00, sizeof(keyName));
2299                 snprintf(keyName, sizeof(keyName), "%s/%d", VOICEMAIL_COUNT, msg_info->sim_idx);
2300                 vconf_get_int(keyName, &noti_info->count);
2301                 noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2302                 noti_info->time = msg_info->displayTime;
2303
2304                 memset(keyName, 0x00, sizeof(keyName));
2305                 snprintf(keyName, sizeof(keyName), "%s/%d", VOICEMAIL_NUMBER, msg_info->sim_idx);
2306                 char *voiceNumber = vconf_get_str(keyName);
2307                 memset(keyName, 0x00, sizeof(keyName));
2308                 snprintf(keyName, sizeof(keyName), "%s/%d", VOICEMAIL_ALPHA_ID, msg_info->sim_idx);
2309                 char *voiceAlphaId = vconf_get_str(keyName);
2310                 char *dialNumber = NULL;
2311
2312                 MSG_MGR_SEC_DEBUG("Voice mail server - alpha id = [%s], default num = [%s]", voiceAlphaId, voiceNumber);
2313
2314                 if (voiceNumber && strlen(voiceNumber))
2315                         dialNumber = voiceNumber;
2316
2317                 if (voiceAlphaId && strlen(voiceAlphaId) > 0) {
2318                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", voiceAlphaId);
2319                 } else if (dialNumber && strlen(dialNumber) > 0) {
2320                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", dialNumber);
2321                 }
2322
2323                 if (dialNumber && strlen(dialNumber) > 0)
2324                         snprintf(noti_info->number, sizeof(noti_info->number), "%s", dialNumber);
2325
2326                 if (noti_info->svc_h) {
2327                         setServiceOperation(noti_info->svc_h, APP_CONTROL_OPERATION_CALL);
2328                         setServiceUri(noti_info->svc_h, MSG_TEL_URI_VOICEMAIL);
2329
2330                         char slot_id[5] = {0, };
2331                         snprintf(slot_id, sizeof(slot_id), "%d", msg_info->sim_idx - 1);
2332                         addServiceExtraData(noti_info->svc_h, "slot_id", slot_id);
2333                 }
2334
2335                 if (voiceNumber)        g_free(voiceNumber);
2336                 if (voiceAlphaId) g_free(voiceAlphaId);
2337                 break;
2338         }
2339         case MSG_MGR_NOTI_TYPE_MWI:
2340         case MSG_MGR_NOTI_TYPE_CLASS0: {
2341                 noti_info->count = 1;
2342                 noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2343                 noti_info->time = msg_info->displayTime;
2344
2345                 if (msg_info->displayName[0] == '\0')
2346                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", msg_info->addressVal);
2347                 else
2348                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", msg_info->displayName);
2349
2350                 snprintf(noti_info->number, sizeof(noti_info->number), "%s", msg_info->addressVal);
2351
2352                 snprintf(noti_info->text, sizeof(noti_info->text), "%s", msg_info->msgText);
2353
2354                 if (noti_info->type == MSG_MGR_NOTI_TYPE_MWI) {
2355                         if (noti_info->svc_h) {
2356                                 setServiceOperation(noti_info->svc_h, APP_CONTROL_OPERATION_CALL);
2357                                 setServiceUri(noti_info->svc_h, MSG_TEL_URI_VOICEMAIL);
2358
2359                                 char slot_id[5] = {0, };
2360                                 snprintf(slot_id, sizeof(slot_id), "%d", msg_info->sim_idx - 1);
2361                                 addServiceExtraData(noti_info->svc_h, "slot_id", slot_id);
2362                         }
2363
2364                 } else {
2365                         setServiceAppId(noti_info->svc_h, "org.tizen.msg-ui-class0");
2366                         addServiceExtraData(noti_info->svc_h, "type", "new_msg");
2367                         addServiceExtraData(noti_info->svc_h, "msgId", noti_info->msg_id);
2368                 }
2369                 break;
2370         }
2371         case MSG_MGR_NOTI_TYPE_SMS_DELIVERY_REPORT: {
2372                 noti_info->count = 1;
2373                 noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2374                 noti_info->time = msg_info->displayTime;
2375                 noti_info->extra_data = msg_info->networkStatus;
2376
2377 /* contacts-service is not used for gear */
2378 #ifndef MSG_CONTACTS_SERVICE_NOT_SUPPORTED
2379                 MSG_MGR_CONTACT_INFO_S contactInfo = {0,};
2380                 MSG_MGR_ADDRESS_INFO_S tmpAddressInfo = {0,};
2381                 if (msg_info->addressVal[0] != '\0') {
2382                         snprintf(tmpAddressInfo.addressVal, MAX_ADDRESS_VAL_LEN, "%s", msg_info->addressVal);
2383                         if (_is_valid_email(msg_info->addressVal)) {
2384                                 tmpAddressInfo.addressType = MSG_ADDRESS_TYPE_EMAIL;
2385                         } else {
2386                                 tmpAddressInfo.addressType = MSG_ADDRESS_TYPE_UNKNOWN;
2387                         }
2388                 }
2389
2390                 if (MsgMgrGetContactInfo(&tmpAddressInfo, &contactInfo) != 0) {
2391                         MSG_MGR_WARN("MsgMgrGetContactInfo() fail.");
2392                 }
2393 #endif /*MSG_CONTACTS_SERVICE_NOT_SUPPORTED */
2394
2395                 if (contactInfo.firstName[0] == '\0')
2396                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", msg_info->addressVal);
2397                 else
2398                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", contactInfo.firstName);
2399
2400                 snprintf(noti_info->number, sizeof(noti_info->number), "%s", msg_info->addressVal);
2401
2402                 if (noti_info->msg_id > 0) {
2403                         setServiceAppId(noti_info->svc_h, MSG_DEFAULT_APP_ID);
2404                         addServiceExtraData(noti_info->svc_h, "type", "new_msg");
2405                         addServiceExtraData(noti_info->svc_h, "msgId", noti_info->msg_id);
2406                         addServiceExtraData(noti_info->svc_h, "address", msg_info->addressVal);
2407                 }
2408                 break;
2409         }
2410         case MSG_MGR_NOTI_TYPE_MMS_READ_REPORT:
2411         case MSG_MGR_NOTI_TYPE_MMS_DELIVERY_REPORT: {
2412                 noti_info->count = 1;
2413                 noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2414                 noti_info->time = msg_info->displayTime;
2415
2416 /* contacts-service is not used for gear */
2417 #ifndef MSG_CONTACTS_SERVICE_NOT_SUPPORTED
2418                 MSG_MGR_CONTACT_INFO_S contactInfo = {0,};
2419                 MSG_MGR_ADDRESS_INFO_S tmpAddressInfo = {0,};
2420                 if (msg_info->addressVal) {
2421                         snprintf(tmpAddressInfo.addressVal, MAX_ADDRESS_VAL_LEN, "%s", msg_info->addressVal);
2422                         if (_is_valid_email(msg_info->addressVal)) {
2423                                 tmpAddressInfo.addressType = MSG_ADDRESS_TYPE_EMAIL;
2424                         } else {
2425                                 tmpAddressInfo.addressType = MSG_ADDRESS_TYPE_UNKNOWN;
2426                         }
2427                 }
2428
2429                 if (MsgMgrGetContactInfo(&tmpAddressInfo, &contactInfo) != 0) {
2430                         MSG_MGR_WARN("MsgMgrGetContactInfo() fail.");
2431                 }
2432 #endif /*MSG_CONTACTS_SERVICE_NOT_SUPPORTED */
2433                 if (contactInfo.firstName[0] == '\0')
2434                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", msg_info->addressVal);
2435                 else
2436                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", contactInfo.firstName);
2437
2438                 snprintf(noti_info->number, sizeof(noti_info->number), "%s", msg_info->addressVal);
2439
2440                 char sqlQuery[MAX_QUERY_LEN+1];
2441                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
2442
2443                 int report_status_type;
2444                 int report_status_value;
2445
2446                 if (noti_info->type == MSG_MGR_NOTI_TYPE_MMS_READ_REPORT) {
2447                         report_status_type = MSG_REPORT_TYPE_READ;
2448                 } else {
2449                         report_status_type = MSG_REPORT_TYPE_DELIVERY;
2450                 }
2451
2452                 snprintf(sqlQuery, sizeof(sqlQuery),
2453                                 "STATUS "
2454                                 "FROM %s "
2455                                 "WHERE MSG_ID=%d AND STATUS_TYPE=%d AND ADDRESS_VAL LIKE '%%%s';",
2456                                 MSGFW_REPORT_TABLE_NAME, msg_info->msgId, report_status_type, msg_mgr_normalize_number(msg_info->addressVal));
2457
2458                 MSG_MGR_DEBUG("sqlQuery = [%s]", sqlQuery);
2459
2460                 char **db_res = NULL;
2461                 int row_cnt = 0, col_cnt = 0;
2462
2463                 int msg_err = msg_db_select_with_query(msg_handle, sqlQuery, &db_res, &row_cnt, &col_cnt);
2464                 if (msg_err != MSG_SUCCESS || row_cnt <= 0) {
2465                         MSG_MGR_ERR("msg_db_select_with_query() failed [%d]", msg_err);
2466                         return;
2467                 }
2468
2469                 report_status_value = atoi(db_res[col_cnt]);
2470
2471                 MSG_MGR_DEBUG("report status [type = %d, value = %d]", report_status_type, report_status_value);
2472
2473                 msg_err = msg_db_free(msg_handle, db_res);
2474                 if (msg_err != MSG_SUCCESS) {
2475                         MSG_MGR_ERR("msg_db_free() failed [%d]", msg_err);
2476                         return;
2477                 }
2478
2479                 if (noti_info->msg_id > 0) {
2480                         setServiceAppId(noti_info->svc_h, MSG_DEFAULT_APP_ID);
2481                         addServiceExtraData(noti_info->svc_h, "type", "new_msg");
2482                         addServiceExtraData(noti_info->svc_h, "msgId", noti_info->msg_id);
2483                         addServiceExtraData(noti_info->svc_h, "address", msg_info->addressVal);
2484                 }
2485
2486                 noti_info->extra_data = (unsigned char)report_status_value;
2487                 break;
2488         }
2489         default:
2490                 MSG_MGR_DEBUG("No matching type [%d]", noti_info->type);
2491                 break;
2492         }
2493
2494         noti_info->applist = NOTIFICATION_DISPLAY_APP_ALL^NOTIFICATION_DISPLAY_APP_LOCK;
2495         MSG_MGR_END();
2496 }
2497
2498
2499 void createInfoData(MSG_MGR_NOTI_INFO_S *noti_info, msg_mgr_active_notification_type_t active_noti)
2500 {
2501         MSG_MGR_BEGIN();
2502
2503         createServiceHandle(&noti_info->svc_h);
2504
2505         switch (noti_info->type) {
2506         case MSG_MGR_NOTI_TYPE_NORMAL: {
2507                 if (noti_info->count > 1) {
2508                         noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_MULTIPLE;
2509                 } else {
2510                         noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2511                 }
2512
2513                 setServiceAppId(noti_info->svc_h, MSG_DEFAULT_APP_ID);
2514                 addServiceExtraData(noti_info->svc_h, "type", "new_msg");
2515                 addServiceExtraData(noti_info->svc_h, "msgId", noti_info->msg_id);
2516                 addServiceExtraData(noti_info->svc_h, "http://tizen.org/appcontrol/data/notification", "new_message");
2517
2518                 noti_info->applist = NOTIFICATION_DISPLAY_APP_ALL^NOTIFICATION_DISPLAY_APP_TICKER;
2519
2520                 if (noti_info->active_noti_button_num == 0)
2521                         noti_info->active_noti_button_num = 3;
2522                 break;
2523         }
2524         case MSG_MGR_NOTI_TYPE_CB: {
2525                 if (noti_info->count > 1) {
2526                         noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_MULTIPLE;
2527                 } else {
2528                         noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2529                 }
2530
2531                 setServiceAppId(noti_info->svc_h, MSG_DEFAULT_APP_ID);
2532                 addServiceExtraData(noti_info->svc_h, "type", "new_msg");
2533                 addServiceExtraData(noti_info->svc_h, "msgId", noti_info->msg_id);
2534
2535                 if (active_noti == MSG_MGR_ACTIVE_NOTI_TYPE_INSTANT)
2536                         noti_info->applist = NOTIFICATION_DISPLAY_APP_ALL^NOTIFICATION_DISPLAY_APP_LOCK;
2537                 else
2538                         noti_info->applist = NOTIFICATION_DISPLAY_APP_NOTIFICATION_TRAY|NOTIFICATION_DISPLAY_APP_INDICATOR;
2539
2540                 noti_info->active_noti_button_num = 1;
2541                 break;
2542         }
2543         case MSG_MGR_NOTI_TYPE_SIM: {
2544                 if (noti_info->count > 1) {
2545                         noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_MULTIPLE;
2546                 } else {
2547                         noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2548                 }
2549
2550                 setServiceAppId(noti_info->svc_h, MSG_DEFAULT_APP_ID);
2551                 addServiceExtraData(noti_info->svc_h, "type", "new_msg");
2552                 addServiceExtraData(noti_info->svc_h, "msgId", noti_info->msg_id);
2553
2554                 if (active_noti == MSG_MGR_ACTIVE_NOTI_TYPE_INSTANT)
2555                         noti_info->applist = NOTIFICATION_DISPLAY_APP_ALL^NOTIFICATION_DISPLAY_APP_LOCK;
2556                 else
2557                         noti_info->applist = NOTIFICATION_DISPLAY_APP_NOTIFICATION_TRAY|NOTIFICATION_DISPLAY_APP_INDICATOR;
2558
2559                 if (noti_info->active_noti_button_num == 0)
2560                         noti_info->active_noti_button_num = 3;
2561                 break;
2562         }
2563         case MSG_MGR_NOTI_TYPE_FAILED: {
2564                 noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2565
2566                 setServiceAppId(noti_info->svc_h, MSG_DEFAULT_APP_ID);
2567                 addServiceExtraData(noti_info->svc_h, "type", "send_failed_msg");
2568                 addServiceExtraData(noti_info->svc_h, "msgId", noti_info->msg_id);
2569
2570                 noti_info->applist = NOTIFICATION_DISPLAY_APP_ALL^NOTIFICATION_DISPLAY_APP_TICKER^NOTIFICATION_DISPLAY_APP_LOCK;
2571                 break;
2572         }
2573         case MSG_MGR_NOTI_TYPE_SIM_FULL: {
2574                 noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2575
2576                 setServiceAppId(noti_info->svc_h, MSG_DEFAULT_APP_ID);
2577                 addServiceExtraData(noti_info->svc_h, "sim_list_show", "sim_setting");
2578
2579                 noti_info->applist = NOTIFICATION_DISPLAY_APP_NOTIFICATION_TRAY|NOTIFICATION_DISPLAY_APP_INDICATOR;
2580                 break;
2581         }
2582         default:
2583                 break;
2584         }
2585
2586         if (active_noti != MSG_MGR_ACTIVE_NOTI_TYPE_ACTIVE)
2587                 noti_info->active_noti_button_num = 0;
2588
2589         MSG_MGR_END();
2590 }
2591
2592
2593 void createServiceHandle(app_control_h *svc_h)
2594 {
2595         int svc_err = APP_CONTROL_ERROR_NONE;
2596
2597         svc_err = app_control_create(svc_h);
2598
2599         if (svc_err != APP_CONTROL_ERROR_NONE)
2600                 MSG_MGR_DEBUG("app_control_create() is failed, [%d]", svc_err);
2601 }
2602
2603
2604 void setServiceAppId(app_control_h svc_h, const char* app_id)
2605 {
2606         int svc_err = APP_CONTROL_ERROR_NONE;
2607
2608         svc_err = app_control_set_app_id(svc_h, app_id);
2609
2610         if (svc_err != APP_CONTROL_ERROR_NONE)
2611                 MSG_MGR_DEBUG("app_control_set_app_id() was failed, [%d]", svc_err);
2612 }
2613
2614
2615 void setServiceUri(app_control_h svc_h, const char* uri)
2616 {
2617         int svc_err = APP_CONTROL_ERROR_NONE;
2618
2619         svc_err = app_control_set_uri(svc_h, uri);
2620
2621         if (svc_err != APP_CONTROL_ERROR_NONE)
2622                 MSG_MGR_DEBUG("app_control_set_uri() was failed, [%d]", svc_err);
2623 }
2624
2625
2626 void setServiceOperation(app_control_h svc_h, const char* operation)
2627 {
2628         int svc_err = APP_CONTROL_ERROR_NONE;
2629
2630         svc_err = app_control_set_operation(svc_h, operation);
2631
2632         if (svc_err != APP_CONTROL_ERROR_NONE)
2633                 MSG_MGR_DEBUG("app_control_set_operation() was failed, [%d]", svc_err);
2634 }
2635
2636
2637 void addServiceExtraData(app_control_h svc_h, const char* bundle_key, const char* bundle_val)
2638 {
2639         int svc_err = APP_CONTROL_ERROR_NONE;
2640
2641         svc_err = app_control_add_extra_data(svc_h, bundle_key, bundle_val);
2642
2643         if (svc_err != APP_CONTROL_ERROR_NONE)
2644                 MSG_MGR_DEBUG("app_control_add_extra_data() was failed, [%d]", svc_err);
2645 }
2646
2647
2648 void addServiceExtraData(app_control_h svc_h, const char* bundle_key, int bundle_val)
2649 {
2650         int svc_err = APP_CONTROL_ERROR_NONE;
2651
2652         char tempId[10];
2653         memset(&tempId, 0x00, sizeof(tempId));
2654         snprintf(tempId, sizeof(tempId), "%d", bundle_val);
2655
2656         svc_err = app_control_add_extra_data(svc_h, bundle_key, (const char *)tempId);
2657
2658         if (svc_err != APP_CONTROL_ERROR_NONE)
2659                 MSG_MGR_DEBUG("app_control_add_extra_data() was failed, [%d]", svc_err);
2660 }
2661
2662
2663 void setServicePackageName(app_control_h svc_h, const char* pkg_name)
2664 {
2665         int svc_err = APP_CONTROL_ERROR_NONE;
2666
2667         svc_err = app_control_set_app_id(svc_h, pkg_name);
2668
2669         if (svc_err != APP_CONTROL_ERROR_NONE)
2670                 MSG_MGR_DEBUG("app_control_set_app_id() was failed, [%d]", svc_err);
2671 }
2672
2673
2674 void sendServicelaunchRequest(app_control_h svc_h, app_control_reply_cb callback, void *user_data)
2675 {
2676         int svc_err = APP_CONTROL_ERROR_NONE;
2677
2678         svc_err = app_control_send_launch_request(svc_h, callback, user_data);
2679
2680         if (svc_err != APP_CONTROL_ERROR_NONE)
2681                 MSG_MGR_DEBUG("app_control_send_launch_request() is failed : %d", svc_err);
2682 }
2683
2684
2685 void setNotiTextDomain(notification_h noti_h, const char *pkg_name, const char *loc_dir)
2686 {
2687         int noti_err = NOTIFICATION_ERROR_NONE;
2688
2689         noti_err = notification_set_text_domain(noti_h, pkg_name, loc_dir);
2690         if (noti_err != NOTIFICATION_ERROR_NONE)
2691                 MSG_MGR_DEBUG("notification_set_text_domain() was failed. [%d]", noti_err);
2692 }
2693
2694
2695 void setNotiText(notification_h noti_h, notification_text_type_e type, const char *text, const char *key)
2696 {
2697         int noti_err = NOTIFICATION_ERROR_NONE;
2698
2699         noti_err = notification_set_text(noti_h, type, text, key, NOTIFICATION_VARIABLE_TYPE_NONE);
2700
2701         if (noti_err != NOTIFICATION_ERROR_NONE)
2702                 MSG_MGR_DEBUG("notification_set_text() was failed. [%d]", noti_err);
2703 }
2704
2705
2706 void setNotiTimeToText(notification_h noti_h, notification_text_type_e type, time_t time)
2707 {
2708         int noti_err = NOTIFICATION_ERROR_NONE;
2709
2710         noti_err = notification_set_time_to_text(noti_h, type, time);
2711
2712         if (noti_err != NOTIFICATION_ERROR_NONE)
2713                 MSG_MGR_DEBUG("notification_set_time_to_text() was failed. [%d]", noti_err);
2714 }
2715
2716
2717 void setNotiTime(notification_h noti_h, time_t time)
2718 {
2719         int noti_err = NOTIFICATION_ERROR_NONE;
2720
2721         noti_err = notification_set_time(noti_h, time);
2722
2723         if (noti_err != NOTIFICATION_ERROR_NONE)
2724                 MSG_MGR_DEBUG("notification_set_time() was failed. [%d]", noti_err);
2725 }
2726
2727
2728
2729 void setNotiImage(notification_h noti_h, notification_image_type_e type, const char *image_path)
2730 {
2731         int noti_err = NOTIFICATION_ERROR_NONE;
2732
2733         noti_err = notification_set_image(noti_h, type, image_path);
2734
2735         if (noti_err != NOTIFICATION_ERROR_NONE)
2736                 MSG_MGR_DEBUG("notification_set_image() was failed. [%d]", noti_err);
2737 }
2738
2739
2740 void setNotiSound(notification_h noti_h, notification_sound_type_e type, const char *path)
2741 {
2742         int noti_err = NOTIFICATION_ERROR_NONE;
2743
2744         noti_err = notification_set_sound(noti_h, type, path);
2745
2746         if (noti_err != NOTIFICATION_ERROR_NONE)
2747                 MSG_MGR_DEBUG("notification_set_sound() was failed. [%d]", noti_err);
2748 }
2749
2750
2751 void setNotiVibration(notification_h noti_h, notification_vibration_type_e type, const char *path)
2752 {
2753         int noti_err = NOTIFICATION_ERROR_NONE;
2754
2755         noti_err = notification_set_vibration(noti_h, type, path);
2756
2757         if (noti_err != NOTIFICATION_ERROR_NONE)
2758                 MSG_MGR_DEBUG("notification_set_vibration() was failed. [%d]", noti_err);
2759 }
2760
2761
2762 void setNotiEventHandler(notification_h noti_h, notification_event_type_e type, app_control_h event_handler)
2763 {
2764         int noti_err = NOTIFICATION_ERROR_NONE;
2765
2766         noti_err = notification_set_event_handler(noti_h, type, event_handler);
2767
2768         if (noti_err != NOTIFICATION_ERROR_NONE)
2769                 MSG_MGR_DEBUG("notification_set_event_handler() was failed. [%d]", noti_err);
2770 }
2771
2772
2773 int MsgMgrInsertInstantMessage(msg_mgr_notification_type_t noti_type)
2774 {
2775         MSG_MGR_BEGIN();
2776
2777         char *notiMsg = NULL;
2778
2779         notification_h noti = notification_create(NOTIFICATION_TYPE_NOTI);
2780
2781         switch (noti_type) {
2782         case MSG_MGR_NOTI_TYPE_NORMAL:
2783         case MSG_MGR_NOTI_TYPE_SIM:
2784         case MSG_MGR_NOTI_TYPE_CB: {
2785                 MSG_MGR_NOTI_INFO_S noti_info;
2786                 memset(&noti_info, 0x00, sizeof(MSG_MGR_NOTI_INFO_S));
2787
2788                 noti_info.type = noti_type;
2789                 int err = getLatestMsgInfo(&noti_info, true);
2790
2791                 if (err == 0) {
2792                         MSG_MGR_DEBUG("Unread count [%d]", noti_info.count);
2793                         if (noti_info.count == 1) {
2794                                 MSG_MGR_SEC_DEBUG("noti_info.sender [%s]", noti_info.sender);
2795                                 setNotiText(noti, NOTIFICATION_TEXT_TYPE_TITLE, noti_info.sender, NULL);
2796                                 setNotiText(noti, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info.text, NULL);
2797                         } else if (noti_info.count > 1) {
2798                                 gchar *cnt_string = g_strdup_printf("%i", noti_info.count);
2799
2800                                 notiMsg = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, NEW_MESSAGE);
2801                                 gchar *outString = g_strconcat(cnt_string, " ", notiMsg, NULL);
2802                                 setNotiText(noti, NOTIFICATION_TEXT_TYPE_TITLE, outString, NULL);
2803                                 setNotiText(noti, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info.sender, NULL);
2804                                 g_free(outString);
2805                                 g_free(cnt_string);
2806                         }
2807
2808                         setNotiImage(noti, NOTIFICATION_IMAGE_TYPE_ICON, MSG_NORMAL_ICON_PATH);
2809                 }
2810                 break;
2811         }
2812         case MSG_MGR_NOTI_TYPE_FAILED: {
2813                 notiMsg = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, FAILED_TO_SEND_MESSAGE);
2814                 setNotiText(noti, NOTIFICATION_TEXT_TYPE_TITLE, notiMsg, NULL);
2815                 setNotiImage(noti, NOTIFICATION_IMAGE_TYPE_ICON, MSG_SMS_SENDING_FAILED_ICON_PATH);
2816                 break;
2817         }
2818         default:
2819                 MSG_MGR_DEBUG("No matching type for MsgNotiType%d]", noti_type);
2820                 goto _END_OF_INSTANT_NOTI;
2821                 break;
2822         }
2823
2824         if (notification_set_display_applist(noti, NOTIFICATION_DISPLAY_APP_TICKER) != NOTIFICATION_ERROR_NONE)
2825                 MSG_MGR_DEBUG("Fail to notification_set_display_applist");
2826
2827         if (notification_post(noti) != NOTIFICATION_ERROR_NONE)
2828                 MSG_MGR_DEBUG("Fail to notification_post");
2829
2830 _END_OF_INSTANT_NOTI:
2831
2832         if (notification_delete(noti) != NOTIFICATION_ERROR_NONE)
2833                 MSG_MGR_DEBUG("Fail to notification_delete");
2834         if (notiMsg) {
2835                 free(notiMsg);
2836                 notiMsg = NULL;
2837         }
2838
2839         if (noti) {
2840                 if (notification_free(noti) != NOTIFICATION_ERROR_NONE)
2841                         MSG_MGR_DEBUG("Fail to notification_free");
2842                 noti = NULL;
2843         }
2844
2845         MSG_MGR_END();
2846         return 0;
2847 }
2848
2849
2850 bool MsgMgrCheckNotificationSettingEnable()
2851 {
2852         bool msg_noti_enabled = false;
2853         notification_system_setting_h system_setting = NULL;
2854         notification_setting_h setting = NULL;
2855
2856         int err = NOTIFICATION_ERROR_NONE;
2857
2858         err = notification_setting_get_setting_by_package_name(MSG_DEFAULT_APP_ID, &setting);
2859
2860         if (err != NOTIFICATION_ERROR_NONE || setting == NULL) {
2861                 MSG_MGR_ERR("getting setting handle for [%s] is failed. err = %d", MSG_DEFAULT_APP_ID, err);
2862         } else {
2863                 msg_noti_enabled = true;
2864
2865                 bool allow_to_notify = false;
2866                 err = notification_setting_get_allow_to_notify(setting, &allow_to_notify);
2867
2868                 if (err != NOTIFICATION_ERROR_NONE) {
2869                         MSG_MGR_ERR("getting do not disturb setting is failed. err = %d", err);
2870                         goto EXIT;
2871                 }
2872
2873                 if (allow_to_notify) {
2874                         MSG_MGR_DEBUG("message notification is allowed");
2875
2876                         /* check do not disturb mode */
2877                         err = notification_system_setting_load_system_setting(&system_setting);
2878
2879                         if (err != NOTIFICATION_ERROR_NONE || system_setting == NULL) {
2880                                 MSG_MGR_ERR("getting system setting is failed. err = %d", err);
2881                                 goto EXIT;
2882                         }
2883
2884                         bool do_not_disturb_mode = false;
2885                         err = notification_system_setting_get_do_not_disturb(system_setting, &do_not_disturb_mode);
2886
2887                         if (err != NOTIFICATION_ERROR_NONE) {
2888                                 MSG_MGR_ERR("getting do not disturb setting is failed. err = %d", err);
2889                                 goto EXIT;
2890                         }
2891
2892                         if (do_not_disturb_mode) {
2893                                 bool is_msg_excepted = false;
2894                                 err = notification_setting_get_do_not_disturb_except(setting, &is_msg_excepted);
2895                                 if (err != NOTIFICATION_ERROR_NONE) {
2896                                         MSG_MGR_ERR("getting do not disturb except status for [%s] is failed. err = %d", MSG_DEFAULT_APP_ID, err);
2897                                         msg_noti_enabled = false;
2898                                 } else {
2899                                         MSG_MGR_INFO("do not disturb mode status for [%s] : %d", MSG_DEFAULT_APP_ID, is_msg_excepted);
2900                                         msg_noti_enabled = (is_msg_excepted) ? true : false;
2901                                 }
2902                         } else {
2903                                 MSG_MGR_DEBUG("do not disturb mode is off");
2904                         }
2905                 } else {
2906                         MSG_MGR_INFO("message notification is not allowed");
2907                         msg_noti_enabled = false;
2908                 }
2909         }
2910
2911 EXIT:
2912         if (system_setting)
2913                 notification_system_setting_free_system_setting(system_setting);
2914
2915         if (setting)
2916                 notification_setting_free_notification(setting);
2917
2918         return msg_noti_enabled;
2919 }
2920
2921
2922 int MsgMgrInsertTicker(const char* pTickerMsg, const char* pLocaleTickerMsg, bool bPlayFeedback, int msgId)
2923 {
2924         MSG_MGR_DEBUG("pTickerMsg=[%s], pLocaleTickerMsg=[%s]", pTickerMsg, pLocaleTickerMsg);
2925         MSG_MGR_DEBUG("play feedback=[%d], msgId=[%d]", bPlayFeedback, msgId);
2926
2927         MsgMgrChangePmState();
2928
2929         char *notiMsg = NULL;
2930         msg_mgr_active_notification_type_t active_type = MSG_MGR_ACTIVE_NOTI_TYPE_NONE;
2931         int err = 0;
2932
2933         notiMsg = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, pLocaleTickerMsg);
2934         MSG_MGR_DEBUG("notiMsg %s", notiMsg);
2935
2936         if (g_strcmp0(pLocaleTickerMsg, SMS_MESSAGE_SENDING_FAIL) != 0 &&
2937                 g_strcmp0(pLocaleTickerMsg, SENDING_MULTIMEDIA_MESSAGE_FAILED) != 0 &&
2938                 g_strcmp0(pLocaleTickerMsg, MESSAGE_RETRIEVED) != 0) {
2939                 if (g_strcmp0(pLocaleTickerMsg, notiMsg) == 0) {
2940                         notification_status_message_post(pTickerMsg);
2941                 } else {
2942                         notification_status_message_post(notiMsg);
2943                 }
2944         } else {
2945                 /* Show ticker popup for sending failed msg. */
2946                 active_type = MSG_MGR_ACTIVE_NOTI_TYPE_INSTANT;
2947         }
2948
2949         if (notiMsg) {
2950                 free(notiMsg);
2951                 notiMsg = NULL;
2952         }
2953
2954         if (bPlayFeedback) {
2955                 if (msgId > 0 &&
2956                         (g_strcmp0(pLocaleTickerMsg, SMS_MESSAGE_SENDING_FAIL) == 0 || g_strcmp0(pLocaleTickerMsg, SENDING_MULTIMEDIA_MESSAGE_FAILED) == 0)) {
2957                         err = MsgMgrRefreshNotification(MSG_MGR_NOTI_TYPE_FAILED, true, active_type);
2958                         if (err != 0) {
2959                                 MSG_MGR_DEBUG("MsgRefreshFailedNoti err=[%d]", err);
2960                         }
2961                 } else if (g_strcmp0(pLocaleTickerMsg, SMS_MESSAGE_SIM_MESSAGE_FULL) == 0) {
2962                         err = MsgMgrRefreshNotification(MSG_MGR_NOTI_TYPE_SIM_FULL, true, MSG_MGR_ACTIVE_NOTI_TYPE_NONE);
2963                         if (err != 0) {
2964                                 MSG_MGR_DEBUG("MsgRefreshSimFullNoti err=[%d]", err);
2965                         }
2966                 } else {
2967                         MsgMgrSoundPlayStart(NULL, MSG_MGR_SOUND_PLAY_DEFAULT);
2968                 }
2969         }
2970
2971         return err;
2972 }
2973
2974
2975 int MsgMgrInsertBadge(unsigned int unreadMsgCnt)
2976 {
2977         MSG_MGR_DEBUG("Start to set badge to [%d].", unreadMsgCnt);
2978
2979         int err = BADGE_ERROR_NONE;
2980         bool exist = false;
2981
2982         err = badge_is_existing(MSG_DEFAULT_APP_ID, &exist);
2983
2984         if (err != BADGE_ERROR_NONE) {
2985                 MSG_MGR_ERR("Fail to badge_is_existing : %d", err);
2986                 return -1;
2987         }
2988
2989         if (!exist) {
2990                 /* create badge */
2991                 err = badge_add(MSG_DEFAULT_APP_ID);
2992                 if (err != BADGE_ERROR_NONE) {
2993                         MSG_MGR_ERR("Fail to badge_add : %d", err);
2994                         return -1;
2995                 }
2996         }
2997
2998         err = badge_set_count(MSG_DEFAULT_APP_ID, unreadMsgCnt);
2999
3000         if (err != BADGE_ERROR_NONE) {
3001                 MSG_MGR_ERR("Fail to badge_set_count : %d", err);
3002                 return -1;
3003         }
3004
3005         return 0;
3006 }
3007
3008
3009 void MsgMgrNotiSoundRepeatAlarmCB(int alarmId)
3010 {
3011         MSG_MGR_BEGIN();
3012
3013         MsgMgrRefreshNotification(MSG_MGR_NOTI_TYPE_NORMAL, true, MSG_MGR_ACTIVE_NOTI_TYPE_ACTIVE);
3014
3015 #ifndef MSG_NOTI_INTEGRATION
3016         MsgMgrRefreshNotification(MSG_MGR_NOTI_TYPE_SIM, true, MSG_MGR_ACTIVE_NOTI_TYPE_ACTIVE);
3017         MsgMgrRefreshNotification(MSG_MGR_NOTI_TYPE_CB, true, MSG_MGR_ACTIVE_NOTI_TYPE_ACTIVE);
3018 #endif
3019
3020         MSG_MGR_END();
3021         return;
3022 }
3023
3024
3025 void MsgMgrSoundCreateRepeatAlarm(int RepeatTime)
3026 {
3027         MSG_MGR_BEGIN();
3028
3029         int tmpAlarmId = 0;
3030         time_t tmp_time;
3031         struct tm repeat_tm;
3032
3033         time(&tmp_time);
3034
3035         tmp_time += (RepeatTime*60);
3036         tzset();
3037         localtime_r(&tmp_time, &repeat_tm);
3038
3039         if (MsgMgrAlarmRegistration(&repeat_tm, MsgMgrNotiSoundRepeatAlarmCB, &tmpAlarmId) != 0) {
3040                 MSG_MGR_DEBUG("MsgAlarmRegistration fail.");
3041                 return;
3042         }
3043
3044         g_alarmId = tmpAlarmId;
3045         MSG_MGR_DEBUG("Set alarmId to [%d]", g_alarmId);
3046
3047         MSG_MGR_END();
3048
3049         return;
3050 }
3051
3052
3053 void MsgMgrSoundSetRepeatAlarm()
3054 {
3055         int nRepeatValue = 0;
3056         long nRepeatTime = 0;
3057
3058         if (vconf_get_int(MSG_ALERT_REP_TYPE, &nRepeatValue) != 0) {
3059                 MSG_MGR_INFO("vconf_get_int() is failed");
3060         }
3061
3062         switch (nRepeatValue) {
3063         case MSG_ALERT_TONE_ONCE:
3064                 nRepeatTime = 0;
3065                 break;
3066         case MSG_ALERT_TONE_2MINS:
3067                 nRepeatTime = 2;
3068                 break;
3069         case MSG_ALERT_TONE_5MINS:
3070                 nRepeatTime = 5;
3071                 break;
3072         case MSG_ALERT_TONE_10MINS:
3073                 nRepeatTime = 10;
3074                 break;
3075         default:
3076                 MSG_MGR_DEBUG("Invalid Repetition time");
3077                 break;
3078         }
3079
3080         MSG_MGR_DEBUG("nRepeatTime = %d", nRepeatTime);
3081
3082         if (nRepeatTime > 0) {
3083                 if (g_alarmId > 0) {
3084                         if (MsgMgrAlarmRemove(g_alarmId) != 0) {
3085                                 MSG_MGR_FATAL("MsgAlarmRemove fail.");
3086                         }
3087                         g_alarmId = 0;
3088                 }
3089                 MsgMgrSoundCreateRepeatAlarm(nRepeatTime);
3090         }
3091
3092         return;
3093 }
3094
3095
3096 char *get_translate_text(const char *pkg_name, const char *locale_dir, const char *text)
3097 {
3098         char *notiMsg = NULL;
3099         char *lang = NULL;
3100
3101         lang = vconf_get_str(VCONFKEY_LANGSET);
3102
3103         setlocale(LC_MESSAGES, lang);
3104
3105         bindtextdomain(pkg_name, locale_dir);
3106
3107         notiMsg = dgettext(pkg_name, text);
3108
3109         if (lang) {
3110                 free(lang);
3111                 lang = NULL;
3112         }
3113
3114         return g_strdup(notiMsg);
3115 }
3116