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                 MSG_MGR_ADDRESS_INFO_S tmpAddressInfo;
1572                 int normalAddCnt = 0;
1573                 int index = col_cnt;
1574
1575                 for (int i = 1; i <= row_cnt; i++) {
1576                         memset(&tmpAddressInfo, 0x00, sizeof(MSG_MGR_ADDRESS_INFO_S));
1577
1578                         char *address = db_res[index++];
1579                         normalAddCnt++;
1580                         if (address) {
1581                                 snprintf(tmpAddressInfo.addressVal, MAX_ADDRESS_VAL_LEN, "%s", address);
1582                                 if (_is_valid_email(address)) {
1583                                         tmpAddressInfo.addressType = MSG_ADDRESS_TYPE_EMAIL;
1584                                 } else {
1585                                         tmpAddressInfo.addressType = MSG_ADDRESS_TYPE_UNKNOWN;
1586                                 }
1587                         }
1588                         subType = atoi(db_res[index++]);
1589
1590                         MSG_MGR_CONTACT_INFO_S tmpContact;
1591                         memset(&tmpContact, 0x00, sizeof(MSG_MGR_CONTACT_INFO_S));
1592
1593                         MsgMgrGetContactInfo(&tmpAddressInfo, &tmpContact);
1594
1595                         if (row_cnt == 1) {
1596                                 snprintf(noti_info->imagePath, sizeof(noti_info->imagePath), "%s", tmpContact.imagePath);
1597                         }
1598
1599                         if (normalAddCnt > 1) {
1600                                 g_strlcat(noti_info->sender, ", ", sizeof(noti_info->sender)-strlen(noti_info->sender));
1601                         }
1602
1603                         if (tmpContact.firstName[0] != '\0') {
1604                                 g_strlcat(noti_info->sender, tmpContact.firstName, sizeof(noti_info->sender)-strlen(noti_info->sender));
1605                         } else if (tmpAddressInfo.addressVal[0] == '\0') {
1606                                 char *senderStr = NULL;
1607                                 senderStr = get_translate_text("message", MSG_APP_LOCALEDIR, MSG_UNKNOWN_SENDER);
1608                                 g_strlcat(noti_info->sender, senderStr, sizeof(noti_info->sender)-strlen(noti_info->sender));
1609                                 if (senderStr) {
1610                                         free(senderStr);
1611                                         senderStr = NULL;
1612                                 }
1613
1614                                 if (i == 1) {
1615                                         noti_info->active_noti_button_num = 1;
1616                                 }
1617                         } else {
1618                                 char *senderStr = NULL;
1619                                 if (subType == MSG_CB_SMS) {
1620                                         senderStr = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, CB_MESSAGE);
1621                                         g_strlcat(noti_info->sender, senderStr, sizeof(noti_info->sender)-strlen(noti_info->sender));
1622                                         noti_info->active_noti_button_num = 1;
1623                                 } else if (subType == MSG_SYNCML_CP) {
1624                                         senderStr = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, CP_MESSAGE);
1625                                         g_strlcat(noti_info->sender, senderStr, sizeof(noti_info->sender)-strlen(noti_info->sender));
1626                                         noti_info->active_noti_button_num = 1;
1627                                 } else if (subType == MSG_WAP_SI_SMS || subType == MSG_WAP_SL_SMS) {
1628                                         senderStr = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, PUSH_MESSAGE);
1629                                         g_strlcat(noti_info->sender, senderStr, sizeof(noti_info->sender)-strlen(noti_info->sender));
1630                                         noti_info->active_noti_button_num = 1;
1631                                 } else {
1632                                         g_strlcat(noti_info->sender, tmpAddressInfo.addressVal, sizeof(noti_info->sender)-strlen(noti_info->sender));
1633                                 }
1634
1635                                 if (senderStr) {
1636                                         free(senderStr);
1637                                         senderStr = NULL;
1638                                 }
1639                         }
1640
1641                         if (i == 1) {
1642                                 noti_info->active_subtype = subType;
1643                                 snprintf(noti_info->active_sender, MSG_NOTI_TEXT_LEN_S, "%s", noti_info->sender);
1644                                 snprintf(noti_info->imagePath, sizeof(noti_info->imagePath), "%s", tmpContact.imagePath);
1645                         }
1646                 }
1647
1648                 noti_info->senderCount = normalAddCnt;
1649                 msg_db_free(msg_handle, db_res);
1650
1651                 MSG_MGR_SEC_DEBUG("sender info = [%s]", noti_info->sender);
1652
1653                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1654
1655 #ifdef MSG_NOTI_INTEGRATION
1656                 snprintf(sqlQuery, sizeof(sqlQuery),
1657                                 "A.ADDRESS_VAL, "
1658                                 "B.DISPLAY_TIME, "
1659                                 "B.MSG_ID, "
1660                                 "B.SUBJECT, "
1661                                 "B.MSG_TEXT, "
1662                                 "B.MAIN_TYPE, "
1663                                 "(COUNT(DISTINCT(CASE WHEN B.MAIN_TYPE = %d THEN B.MSG_ID END))) AS SMS_UNREAD_CNT, "
1664                                 "(COUNT(DISTINCT(CASE WHEN B.MAIN_TYPE = %d THEN B.MSG_ID END))) AS MMS_UNREAD_CNT, "
1665                                 "(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) "
1666                                 "FROM %s A, %s B "
1667                                 "WHERE A.CONV_ID=B.CONV_ID "
1668                                 "AND B.READ_STATUS=0 AND (B.FOLDER_ID=%d OR B.FOLDER_ID=%d) "
1669                                 "AND B.STORAGE_ID = %d "
1670                                 "ORDER BY B.DISPLAY_TIME DESC;",
1671                                 MSG_SMS_TYPE,
1672                                 MSG_MMS_TYPE,
1673                                 MSG_MMS_TYPE, MSG_NETWORK_RECEIVED, MMS_PLUGIN_MESSAGE_TABLE_NAME,
1674                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
1675                                 MSG_INBOX_ID, MSG_CBMSGBOX_ID,
1676                                 MSG_STORAGE_PHONE);
1677 #else
1678                 snprintf(sqlQuery, sizeof(sqlQuery),
1679                                 "A.ADDRESS_VAL, "
1680                                 "B.DISPLAY_TIME, "
1681                                 "B.MSG_ID, "
1682                                 "B.SUBJECT, "
1683                                 "B.MSG_TEXT, "
1684                                 "B.MAIN_TYPE, "
1685                                 "(COUNT(CASE WHEN B.MAIN_TYPE = %d THEN 1 END)) AS SMS_UNREAD_CNT, "
1686                                 "(COUNT(CASE WHEN B.MAIN_TYPE = %d THEN 1 END)) AS MMS_UNREAD_CNT "
1687                                 "FROM %s A, %s B "
1688                                 "WHERE A.CONV_ID=B.CONV_ID "
1689                                 "AND B.READ_STATUS=0 AND B.FOLDER_ID=%d "
1690                                 "AND B.STORAGE_ID = %d "
1691                                 "ORDER BY B.DISPLAY_TIME DESC;",
1692                                 MSG_SMS_TYPE,
1693                                 MSG_MMS_TYPE,
1694                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
1695                                 MSG_INBOX_ID,
1696                                 MSG_STORAGE_PHONE);
1697 #endif
1698                 MSG_MGR_DEBUG("sqlQuery [%s]", sqlQuery);
1699
1700                 msg_err = msg_db_select_with_query(msg_handle, sqlQuery, &db_res, &row_cnt, &col_cnt);
1701                 if (msg_err != MSG_SUCCESS) {
1702                         MSG_MGR_ERR("msg_db_select_with_query() failed [%d]", msg_err);
1703                         return -1;
1704                 }
1705
1706                 if (row_cnt > 0) {
1707                         smsUnreadCnt = atoi(db_res[col_cnt+6]);
1708                         mmsUnreadCnt = atoi(db_res[col_cnt+7]);
1709                         msgSize = atoi(db_res[col_cnt+8]);
1710
1711                         noti_info->count = smsUnreadCnt + mmsUnreadCnt;
1712
1713                         if (noti_info->count > 0) {
1714                                 snprintf(noti_info->number, sizeof(noti_info->number), "%s", db_res[col_cnt]);
1715
1716                                 noti_info->time = (time_t)atoi(db_res[col_cnt+1]);
1717
1718                                 noti_info->msg_id = (msg_message_id_t)atoi(db_res[col_cnt+2]);
1719
1720                                 mainType = (unsigned char)atoi(db_res[col_cnt+5]);
1721
1722                                 if (mainType == MSG_MMS_TYPE) {
1723                                         snprintf(noti_info->text, sizeof(noti_info->text), "%s", db_res[col_cnt+3]);
1724                                         if (noti_info->text[0] == '\0') {
1725                                                 char *noti_text = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, MSG_NO_SUBJECT);
1726                                                 snprintf(noti_info->text, sizeof(noti_info->text), "%s", noti_text);
1727                                                 g_free(noti_text);
1728                                         }
1729
1730                                         char *prefix_subject = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, MSG_SUBJECT_COLON);
1731                                         if (prefix_subject) {
1732                                                 snprintf(noti_info->active_subject, MSG_NOTI_TEXT_LEN_S, "%s%s", prefix_subject, noti_info->text);
1733                                                 g_free(prefix_subject);
1734                                         } else {
1735                                                 snprintf(noti_info->active_subject, MSG_NOTI_TEXT_LEN_S, "%s", noti_info->text);
1736                                         }
1737
1738                                         if (msgSize > -1) {
1739                                                 int kb_msg_size = msgSize / 1024;
1740                                                 if (kb_msg_size == 0 && msgSize > 0)
1741                                                         kb_msg_size = 1;
1742                                                 else if (msgSize % 1024 >= 512)
1743                                                         kb_msg_size++;
1744
1745                                                 char *msg_size_string = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, MESSAGE_SIZE_STRING);
1746                                                 char *msg_size_unit_kb = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, MESSAGE_SIZE_UNIT_KB);
1747
1748                                                 snprintf(noti_info->active_text, MSG_NOTI_TEXT_LEN, "%s : %d%s", msg_size_string, kb_msg_size, msg_size_unit_kb);
1749
1750                                                 g_free(msg_size_string);
1751                                                 g_free(msg_size_unit_kb);
1752                                         }
1753
1754                                 } else {
1755                                         snprintf(noti_info->text, sizeof(noti_info->text), "%s", db_res[col_cnt+4]);
1756                                 }
1757
1758                                 if (noti_info->active_text[0] == '\0')
1759                                         snprintf(noti_info->active_text, MSG_NOTI_TEXT_LEN, "%s", db_res[col_cnt+4]);
1760
1761                                 MSG_MGR_DEBUG("unread message ID [%d].", noti_info->msg_id);
1762
1763                                 MSG_MGR_DEBUG("active sender [%s]", noti_info->active_sender);
1764                                 MSG_MGR_DEBUG("active subject [%s]", noti_info->active_subject);
1765                                 MSG_MGR_DEBUG("active text [%s]", noti_info->active_text);
1766
1767                                 if (!isForInstantMessage) {
1768                                         if (noti_info->id > 0 && noti_info->count == 1) {
1769                                                 noti_err = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NOTI, noti_info->id);
1770                                                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1771                                                         MSG_MGR_DEBUG("Fail to notification_delete_by_priv_id : %d", noti_err);
1772                                                 }
1773
1774                                                 noti_info->id = 0;
1775                                                 if (vconf_set_int(NOTIFICATION_PRIV_ID, noti_info->id) != 0)
1776                                                         MSG_MGR_DEBUG("vconf_set_int fail : NOTIFICATION_PRIV_ID");
1777                                         }
1778
1779                                         vconf_set_int(VCONFKEY_MESSAGE_RECV_SMS_STATE, smsUnreadCnt);
1780                                         vconf_set_int(VCONFKEY_MESSAGE_RECV_MMS_STATE, mmsUnreadCnt);
1781                                         MsgMgrInsertBadge(noti_info->count);
1782                                         MsgMgrSoundSetRepeatAlarm();
1783                                 }
1784                         } else {
1785                                 MSG_MGR_DEBUG("No unread message.");
1786                                 MSG_MGR_DEBUG("notiPrivId [%d]", noti_info->id);
1787
1788                                 msg_db_free(msg_handle, db_res);
1789
1790                                 if (!isForInstantMessage) {
1791                                         /* No unread message. */
1792                                         if (noti_info->id > 0) {
1793                                                 noti_err = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NOTI, noti_info->id);
1794                                                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1795                                                         MSG_MGR_DEBUG("Fail to notification_delete_by_priv_id : %d", noti_err);
1796                                                 }
1797                                         }
1798
1799                                         noti_info->id = 0;
1800
1801                                         if (vconf_set_int(NOTIFICATION_PRIV_ID, noti_info->id) != 0)
1802                                                 MSG_MGR_DEBUG("vconf_set_int fail : NOTIFICATION_PRIV_ID");
1803
1804                                         vconf_set_int(VCONFKEY_MESSAGE_RECV_SMS_STATE, 0);
1805                                         vconf_set_int(VCONFKEY_MESSAGE_RECV_MMS_STATE, 0);
1806                                         MsgMgrInsertBadge(0);
1807                                         MsgMgrSoundSetRepeatAlarm();
1808                                 }
1809
1810                                 return -1;
1811                         }
1812                 } else {
1813                         MSG_MGR_DEBUG("sqlQuery [%s]", sqlQuery);
1814                         msg_db_free(msg_handle, db_res);
1815                         return -1;
1816                 }
1817
1818                 msg_db_free(msg_handle, db_res);
1819                 break;
1820         }
1821
1822 #ifndef MSG_NOTI_INTEGRATION
1823         case MSG_MGR_NOTI_TYPE_CB: {
1824                 char sqlQuery[MAX_QUERY_LEN+1];
1825                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1826
1827                 snprintf(sqlQuery, sizeof(sqlQuery),
1828                                 "A.ADDRESS_VAL, "
1829                                 "B.DISPLAY_TIME, "
1830                                 "B.MSG_ID, "
1831                                 "B.MSG_TEXT "
1832                                 "FROM %s A, %s B "
1833                                 "WHERE A.CONV_ID=B.CONV_ID "
1834                                 "AND B.READ_STATUS=0 "
1835                                 "AND B.FOLDER_ID=%d "
1836                                 "AND B.STORAGE_ID = %d "
1837                                 "ORDER BY B.DISPLAY_TIME DESC;",
1838                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
1839                                 MSG_CBMSGBOX_ID,
1840                                 MSG_STORAGE_PHONE);
1841
1842                 if (dbhandler->prepareQuery(sqlQuery) != MSG_SUCCESS)
1843                         return MSG_ERR_DB_PREPARE;
1844
1845                 if (dbhandler->stepQuery() == MSG_ERR_DB_ROW) {
1846                         MSG_ADDRESS_INFO_S addrInfo;
1847                         memset(&addrInfo, 0x00, sizeof(MSG_ADDRESS_INFO_S));
1848
1849                         if (dbhandler->columnText(0) != NULL)
1850                                 snprintf(addrInfo.addressVal, sizeof(addrInfo.addressVal), "%s", (char*)dbhandler->columnText(0));
1851
1852                         MSG_CONTACT_INFO_S tmpContact;
1853                         memset(&tmpContact, 0x00, sizeof(MSG_CONTACT_INFO_S));
1854
1855                         MsgGetContactInfo(&addrInfo, &tmpContact);
1856
1857                         if (tmpContact.firstName[0] != '\0') {
1858                                 snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", tmpContact.firstName);
1859                         } else if (addrInfo.addressVal[0] == '\0') {
1860                                 char *senderStr = NULL;
1861                                 senderStr = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, MSG_UNKNOWN_SENDER);
1862                                 g_strlcat(noti_info->sender, senderStr, sizeof(noti_info->sender)-strlen(noti_info->sender));
1863                                 if (senderStr) {
1864                                         free(senderStr);
1865                                         senderStr = NULL;
1866                                 }
1867                         } else {
1868                                 snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", addrInfo.addressVal);
1869                         }
1870
1871                         snprintf(noti_info->number, sizeof(noti_info->number), "%s", addrInfo.addressVal);
1872
1873                         noti_info->time = (time_t)dbhandler->columnInt(1);
1874
1875                         noti_info->msg_id = (msg_message_id_t)dbhandler->columnInt(2);
1876
1877                         snprintf(noti_info->text, sizeof(noti_info->text), "%s", (char*)dbhandler->columnText(3));
1878
1879                         MSG_MGR_DEBUG("unread CB message [%d].", noti_info->msg_id);
1880                 } else {
1881                         MSG_MGR_DEBUG("No unread CB message.");
1882                         MSG_MGR_DEBUG("notiCbId [%d]", noti_info->id);
1883
1884                         dbhandler->finalizeQuery();
1885
1886                         if (!isForInstantMessage) {
1887                                 /* No unread message. */
1888                                 if (noti_info->id > 0) {
1889                                         noti_err = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NOTI, noti_info->id);
1890                                         if (noti_err != NOTIFICATION_ERROR_NONE) {
1891                                                 MSG_MGR_DEBUG("Fail to notification_delete_by_priv_id : %d", noti_err);
1892                                         }
1893                                 }
1894
1895                                 noti_info->id = 0;
1896
1897                                 if (MsgSettingSetInt(CB_NOTI_PRIV_ID, noti_info->id) != MSG_SUCCESS)
1898                                         MSG_MGR_DEBUG("MsgSettingSetInt fail : CB_NOTI_PRIV_ID");
1899                         }
1900                         return MSG_ERR_DB_STEP;
1901                 }
1902
1903                 dbhandler->finalizeQuery();
1904
1905                 if (dbhandler->getTable(sqlQuery, &noti_info->count, NULL) != MSG_SUCCESS) {
1906                         MSG_MGR_DEBUG("getTable is failed");
1907                         dbhandler->freeTable();
1908                         return MSG_ERR_DB_GETTABLE;
1909                 }
1910
1911                 dbhandler->freeTable();
1912                 MSG_MGR_DEBUG("notiCbId [%d], unreadCbMsgCnt [%d]", noti_info->id, noti_info->count);
1913                 break;
1914         }
1915         case MSG_MGR_NOTI_TYPE_SIM: {
1916                 char sqlQuery[MAX_QUERY_LEN+1];
1917                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1918
1919                 snprintf(sqlQuery, sizeof(sqlQuery),
1920                                 "A.ADDRESS_VAL, "
1921                                 "B.DISPLAY_TIME, "
1922                                 "B.MSG_ID, "
1923                                 "B.MSG_TEXT, "
1924                                 "(COUNT(CASE WHEN B.MAIN_TYPE = %d THEN 1 END)) AS SMS_UNREAD_CNT "
1925                                 "FROM %s A, %s B "
1926                                 "WHERE A.CONV_ID=B.CONV_ID "
1927                                 "AND B.READ_STATUS=0 AND B.FOLDER_ID=%d "
1928                                 "AND B.STORAGE_ID = %d "
1929                                 "ORDER BY B.DISPLAY_TIME DESC;",
1930                                 MSG_SMS_TYPE,
1931                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
1932                                 MSG_INBOX_ID,
1933                                 MSG_STORAGE_SIM);
1934
1935                 MSG_MGR_DEBUG("sqlQuery [%s]", sqlQuery);
1936
1937                 if (dbhandler->prepareQuery(sqlQuery) != MSG_SUCCESS)
1938                         return MSG_ERR_DB_PREPARE;
1939
1940                 if (dbhandler->stepQuery() == MSG_ERR_DB_ROW) {
1941                         noti_info->count = dbhandler->columnInt(4);
1942
1943                         if (noti_info->count > 0) {
1944                                 MSG_ADDRESS_INFO_S addrInfo;
1945                                 memset(&addrInfo, 0x00, sizeof(MSG_ADDRESS_INFO_S));
1946
1947                                 if (dbhandler->columnText(0) != NULL)
1948                                         snprintf(addrInfo.addressVal, sizeof(addrInfo.addressVal), "%s", (char*)dbhandler->columnText(0));
1949
1950                                 MSG_CONTACT_INFO_S tmpContact;
1951                                 memset(&tmpContact, 0x00, sizeof(MSG_CONTACT_INFO_S));
1952
1953                                 MsgGetContactInfo(&addrInfo, &tmpContact);
1954
1955                                 if (tmpContact.firstName[0] != '\0') {
1956                                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", tmpContact.firstName);
1957                                 } else if (addrInfo.addressVal[0] == '\0') {
1958                                         char *senderStr = NULL;
1959                                         senderStr = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, MSG_UNKNOWN_SENDER);
1960                                         g_strlcat(noti_info->sender, senderStr, sizeof(noti_info->sender)-strlen(noti_info->sender));
1961                                         if (senderStr) {
1962                                                 free(senderStr);
1963                                                 senderStr = NULL;
1964                                         }
1965                                 } else {
1966                                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", addrInfo.addressVal);
1967                                 }
1968
1969                                 snprintf(noti_info->number, sizeof(noti_info->number), "%s", addrInfo.addressVal);
1970
1971                                 noti_info->time = (time_t)dbhandler->columnInt(1);
1972
1973                                 noti_info->msg_id = (msg_message_id_t)dbhandler->columnInt(2);
1974
1975                                 snprintf(noti_info->text, sizeof(noti_info->text), "%s", (char*)dbhandler->columnText(3));
1976
1977                                 MSG_MGR_DEBUG("unread SIM message [%d].", noti_info->msg_id);
1978                         } else {
1979                                 MSG_MGR_DEBUG("No unread SIM message.");
1980                                 MSG_MGR_DEBUG("notiPrivId [%d]", noti_info->id);
1981
1982                                 dbhandler->finalizeQuery();
1983
1984                                 if (!isForInstantMessage) {
1985                                         /* No unread message. */
1986                                         if (noti_info->id > 0) {
1987                                                 noti_err = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NOTI, noti_info->id);
1988                                                 if (noti_err != NOTIFICATION_ERROR_NONE) {
1989                                                         MSG_MGR_DEBUG("Fail to notification_delete_by_priv_id : %d", noti_err);
1990                                                 }
1991                                         }
1992
1993                                         noti_info->id = 0;
1994
1995                                         if (MsgSettingSetInt(SIM_MSG_NOTI_PRIV_ID, noti_info->id) != MSG_SUCCESS)
1996                                                 MSG_MGR_DEBUG("MsgSettingSetInt fail : SIM_MSG_NOTI_PRIV_ID");
1997                                 }
1998
1999                                 return MSG_ERR_DB_STEP;
2000                         }
2001                 } else {
2002                         MSG_MGR_DEBUG("sqlQuery [%s]", sqlQuery);
2003                         dbhandler->finalizeQuery();
2004                         return MSG_ERR_DB_STEP;
2005                 }
2006
2007                 dbhandler->finalizeQuery();
2008                 break;
2009         }
2010 #endif
2011         case MSG_MGR_NOTI_TYPE_FAILED: {
2012                 char sqlQuery[MAX_QUERY_LEN+1];
2013                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
2014
2015                 snprintf(sqlQuery, sizeof(sqlQuery),
2016                                 "A.ADDRESS_VAL, "
2017                                 "B.DISPLAY_TIME, "
2018                                 "B.MSG_ID, "
2019                                 "B.MSG_TEXT, "
2020                                 "B.SUBJECT, "
2021                                 "B.MAIN_TYPE, "
2022                                 "(COUNT(CASE WHEN B.NETWORK_STATUS = %d THEN 1 END)) AS SENT_FAILED_CNT "
2023                                 "FROM %s A, %s B "
2024                                 "WHERE A.CONV_ID=B.CONV_ID "
2025                                 "AND B.READ_STATUS=0 AND B.FOLDER_ID=%d "
2026                                 "AND B.STORAGE_ID = %d "
2027                                 "ORDER BY B.DISPLAY_TIME DESC;",
2028                                 MSG_NETWORK_SEND_FAIL,
2029                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
2030                                 MSG_OUTBOX_ID,
2031                                 MSG_STORAGE_PHONE);
2032
2033                 MSG_MGR_DEBUG("sqlQuery [%s]", sqlQuery);
2034
2035                 row_cnt = 0, col_cnt = 0;
2036                 msg_err = msg_db_select_with_query(msg_handle, sqlQuery, &db_res, &row_cnt, &col_cnt);
2037                 if (msg_err != MSG_SUCCESS) {
2038                         MSG_MGR_ERR("msg_db_select_with_query() failed [%d]", msg_err);
2039                         return -1;
2040                 }
2041
2042                 if (row_cnt > 0) {
2043                         noti_info->count = atoi(db_res[col_cnt+6]);
2044
2045                         if (noti_info->count > 0) {
2046                                 MSG_MGR_ADDRESS_INFO_S addrInfo = {0,};
2047
2048                                 snprintf(addrInfo.addressVal, MAX_ADDRESS_VAL_LEN, "%s", db_res[col_cnt]);
2049
2050                                 MSG_MGR_CONTACT_INFO_S tmpContact = {0,};
2051
2052                                 MsgMgrGetContactInfo(&addrInfo, &tmpContact);
2053
2054                                 if (tmpContact.firstName[0] != '\0') {
2055                                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", tmpContact.firstName);
2056                                 } else if (addrInfo.addressVal[0] == '\0') {
2057                                         char *senderStr = NULL;
2058                                         senderStr = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, MSG_UNKNOWN_SENDER);
2059                                         g_strlcat(noti_info->sender, senderStr, sizeof(noti_info->sender)-strlen(noti_info->sender));
2060                                         if (senderStr) {
2061                                                 free(senderStr);
2062                                                 senderStr = NULL;
2063                                         }
2064                                 } else {
2065                                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", addrInfo.addressVal);
2066                                 }
2067
2068                                 snprintf(noti_info->number, sizeof(noti_info->number), "%s", addrInfo.addressVal);
2069
2070                                 noti_info->time = (time_t)atoi(db_res[col_cnt+1]);
2071
2072                                 noti_info->msg_id = (msg_message_id_t)atoi(db_res[col_cnt+2]);
2073
2074                                 unsigned char mainType = (unsigned char)atoi(db_res[col_cnt+5]);
2075
2076                                 if (mainType == MSG_TYPE_MMS)
2077                                         snprintf(noti_info->text, sizeof(noti_info->text), "%s", db_res[col_cnt+4]);
2078                                 else
2079                                         snprintf(noti_info->text, sizeof(noti_info->text), "%s", db_res[col_cnt+3]);
2080
2081                                 MSG_MGR_DEBUG("Sent failed message ID [%d].", noti_info->msg_id);
2082
2083                                 if (!isForInstantMessage) {
2084                                         if (noti_info->id > 0 && noti_info->count == 1) {
2085                                                 noti_err = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NOTI, noti_info->id);
2086                                                 if (noti_err != NOTIFICATION_ERROR_NONE) {
2087                                                         MSG_MGR_DEBUG("Fail to notification_delete_by_priv_id : %d", noti_err);
2088                                                 }
2089                                                 noti_info->id = 0;
2090                                                 if (vconf_set_int(MSG_SENTFAIL_NOTI_ID, noti_info->id) != 0)
2091                                                         MSG_MGR_DEBUG("vconf_set_int fail : MSG_SENTFAIL_NOTI_ID");
2092                                         }
2093                                 }
2094                         } else {
2095                                 MSG_MGR_DEBUG("No sent failed message.");
2096                                 MSG_MGR_DEBUG("failedNotiId [%d]", noti_info->id);
2097
2098                                 msg_db_free(msg_handle, db_res);
2099
2100                                 if (!isForInstantMessage) {
2101                                         /* No unread message. */
2102                                         if (noti_info->id > 0) {
2103                                                 noti_err = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NOTI, noti_info->id);
2104                                                 if (noti_err != NOTIFICATION_ERROR_NONE) {
2105                                                         MSG_MGR_DEBUG("Fail to notification_delete_by_priv_id : %d", noti_err);
2106                                                 }
2107                                         }
2108
2109                                         noti_info->id = 0;
2110
2111                                         if (vconf_set_int(MSG_SENTFAIL_NOTI_ID, noti_info->id) != 0)
2112                                                 MSG_MGR_DEBUG("vconf_set_int fail : MSG_SENTFAIL_NOTI_ID");
2113                                 }
2114
2115                                 return -1;
2116                         }
2117                 } else {
2118                         msg_db_free(msg_handle, db_res);
2119                         return -1;
2120                 }
2121
2122                 msg_db_free(msg_handle, db_res);
2123                 break;
2124         }
2125         case MSG_MGR_NOTI_TYPE_SIM_FULL:
2126                 break;
2127         default:
2128                 MSG_MGR_DEBUG("No matching type [%d]", noti_info->type);
2129                 return -1;
2130         }
2131
2132         MSG_MGR_END();
2133
2134         return 0;
2135 }
2136
2137
2138 notification_h getHandle(int *noti_id)
2139 {
2140         notification_h noti_h = NULL;
2141
2142         if (*noti_id > 0) {
2143                 MSG_MGR_DEBUG("Notification load");
2144                 noti_h = notification_load(NULL, *noti_id);
2145                 if (noti_h == NULL)
2146                         MSG_MGR_DEBUG("notification_load is failed.");
2147         }
2148
2149         if (noti_h == NULL) {
2150                 MSG_MGR_DEBUG("Notification create");
2151                 noti_h = notification_create(NOTIFICATION_TYPE_NOTI);
2152                 if (noti_h == NULL) {
2153                         MSG_MGR_DEBUG("notification_create is failed.");
2154                         return NULL;
2155                 }
2156
2157                 *noti_id = 0;
2158         }
2159
2160         return noti_h;
2161 }
2162
2163
2164 int getPrivId(msg_mgr_notification_type_t noti_type, int sim_idx)
2165 {
2166         MSG_MGR_BEGIN();
2167
2168         int noti_id = 0;
2169
2170         switch (noti_type) {
2171 #ifdef MSG_NOTI_INTEGRATION
2172         case MSG_MGR_NOTI_TYPE_NORMAL:
2173         case MSG_MGR_NOTI_TYPE_SIM:
2174         case MSG_MGR_NOTI_TYPE_CB:
2175                 vconf_get_int(NOTIFICATION_PRIV_ID, &noti_id);
2176                 break;
2177 #else
2178         case MSG_MGR_NOTI_TYPE_NORMAL:
2179                 vconf_get_int(NOTIFICATION_PRIV_ID, &noti_id);
2180                 break;
2181         case MSG_MGR_NOTI_TYPE_SIM:
2182                 vconf_get_int(SIM_MSG_NOTI_PRIV_ID, &noti_id);
2183                 break;
2184         case MSG_MGR_NOTI_TYPE_CB:
2185                 vconf_get_int(CB_NOTI_PRIV_ID, &noti_id);
2186                 break;
2187 #endif
2188         case MSG_MGR_NOTI_TYPE_FAILED:
2189                 vconf_get_int(MSG_SENTFAIL_NOTI_ID, &noti_id);
2190                 break;
2191         case MSG_MGR_NOTI_TYPE_VOICE_1: {
2192                 char keyName[MAX_VCONFKEY_NAME_LEN] = {0, };
2193                 snprintf(keyName, sizeof(keyName), "%s/%d", VOICE_NOTI_ID_1, sim_idx);
2194                 vconf_get_int(keyName, &noti_id);
2195                 break;
2196         }
2197         case MSG_MGR_NOTI_TYPE_VOICE_2: {
2198                 char keyName[MAX_VCONFKEY_NAME_LEN] = {0, };
2199                 snprintf(keyName, sizeof(keyName), "%s/%d", VOICE_NOTI_ID_2, sim_idx);
2200                 vconf_get_int(keyName, &noti_id);
2201                 break;
2202         }
2203         case MSG_MGR_NOTI_TYPE_SIM_FULL:
2204                 vconf_get_int(SIM_FULL_NOTI_PRIV_ID, &noti_id);
2205                 break;
2206         default:
2207                 MSG_MGR_DEBUG("No matching noti type [%d]", noti_type);
2208                 break;
2209         }
2210
2211         MSG_MGR_DEBUG("Get noti type = %d, id = %d, sim_idx:%d", noti_type, noti_id, sim_idx);
2212
2213         MSG_MGR_END();
2214
2215         return noti_id;
2216 }
2217
2218
2219 void updatePrivId(msg_mgr_notification_type_t noti_type, int noti_id, int sim_idx)
2220 {
2221         MSG_MGR_BEGIN();
2222
2223         int err = 0;
2224
2225         MSG_MGR_DEBUG("Update noti type = %d, id = %d, sim_idx = %d", noti_type, noti_id, sim_idx);
2226
2227         switch (noti_type) {
2228 #ifdef MSG_NOTI_INTEGRATION
2229         case MSG_MGR_NOTI_TYPE_NORMAL:
2230         case MSG_MGR_NOTI_TYPE_SIM:
2231         case MSG_MGR_NOTI_TYPE_CB:
2232                 err = vconf_set_int(NOTIFICATION_PRIV_ID, noti_id);
2233                 break;
2234 #else
2235         case MSG_MGR_NOTI_TYPE_NORMAL:
2236                 err = vconf_set_int(NOTIFICATION_PRIV_ID, noti_id);
2237                 break;
2238         case MSG_MGR_NOTI_TYPE_SIM:
2239                 err = vconf_set_int(SIM_MSG_NOTI_PRIV_ID, noti_id);
2240                 break;
2241         case MSG_MGR_NOTI_TYPE_CB:
2242                 err = vconf_set_int(CB_NOTI_PRIV_ID, noti_id);
2243                 break;
2244 #endif
2245         case MSG_MGR_NOTI_TYPE_FAILED:
2246                 err = vconf_set_int(MSG_SENTFAIL_NOTI_ID, noti_id);
2247                 break;
2248         case MSG_MGR_NOTI_TYPE_VOICE_1: {
2249                 char keyName[MAX_VCONFKEY_NAME_LEN] = {0, };
2250                 snprintf(keyName, sizeof(keyName), "%s/%d", VOICE_NOTI_ID_1, sim_idx);
2251                 err = vconf_set_int(keyName, noti_id);
2252                 break;
2253         }
2254         case MSG_MGR_NOTI_TYPE_VOICE_2: {
2255                 char keyName[MAX_VCONFKEY_NAME_LEN] = {0, };
2256                 snprintf(keyName, sizeof(keyName), "%s/%d", VOICE_NOTI_ID_2, sim_idx);
2257                 err = vconf_set_int(keyName, noti_id);
2258                 break;
2259         }
2260         case MSG_MGR_NOTI_TYPE_SIM_FULL:
2261                 err = vconf_set_int(SIM_FULL_NOTI_PRIV_ID, noti_id);
2262                 break;
2263         default:
2264                 MSG_MGR_DEBUG("No matching type [%d]", noti_type);
2265                 break;
2266         }
2267
2268         if (err != 0)
2269                 MSG_MGR_INFO("vconf_set_int fail : noti type = %d, id = %d, sim_idx = %d", noti_type, noti_id, sim_idx);
2270
2271         MSG_MGR_END();
2272 }
2273
2274
2275 void createInfoData(MSG_MGR_NOTI_INFO_S *noti_info, MSG_MGR_MESSAGE_INFO_S *msg_info)
2276 {
2277         MSG_MGR_BEGIN();
2278
2279         if (msg_info) {
2280                 noti_info->id = getPrivId(noti_info->type, msg_info->sim_idx);
2281                 noti_info->msg_id = msg_info->msgId;
2282         } else {
2283                 MSG_MGR_DEBUG("msg_info is NULL");
2284                 return;
2285         }
2286
2287         noti_info->sim_idx = msg_info->sim_idx;
2288
2289         createServiceHandle(&noti_info->svc_h);
2290         char keyName[MAX_VCONFKEY_NAME_LEN];
2291
2292         switch (noti_info->type) {
2293         case MSG_MGR_NOTI_TYPE_VOICE_1:
2294         case MSG_MGR_NOTI_TYPE_VOICE_2: {
2295                 memset(keyName, 0x00, sizeof(keyName));
2296                 snprintf(keyName, sizeof(keyName), "%s/%d", VOICEMAIL_COUNT, msg_info->sim_idx);
2297                 vconf_get_int(keyName, &noti_info->count);
2298                 noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2299                 noti_info->time = msg_info->displayTime;
2300
2301                 memset(keyName, 0x00, sizeof(keyName));
2302                 snprintf(keyName, sizeof(keyName), "%s/%d", VOICEMAIL_NUMBER, msg_info->sim_idx);
2303                 char *voiceNumber = vconf_get_str(keyName);
2304                 memset(keyName, 0x00, sizeof(keyName));
2305                 snprintf(keyName, sizeof(keyName), "%s/%d", VOICEMAIL_ALPHA_ID, msg_info->sim_idx);
2306                 char *voiceAlphaId = vconf_get_str(keyName);
2307                 char *dialNumber = NULL;
2308
2309                 MSG_MGR_SEC_DEBUG("Voice mail server - alpha id = [%s], default num = [%s]", voiceAlphaId, voiceNumber);
2310
2311                 if (voiceNumber && strlen(voiceNumber))
2312                         dialNumber = voiceNumber;
2313
2314                 if (voiceAlphaId && strlen(voiceAlphaId) > 0) {
2315                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", voiceAlphaId);
2316                 } else if (dialNumber && strlen(dialNumber) > 0) {
2317                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", dialNumber);
2318                 }
2319
2320                 if (dialNumber && strlen(dialNumber) > 0)
2321                         snprintf(noti_info->number, sizeof(noti_info->number), "%s", dialNumber);
2322
2323                 if (noti_info->svc_h) {
2324                         setServiceOperation(noti_info->svc_h, APP_CONTROL_OPERATION_CALL);
2325                         setServiceUri(noti_info->svc_h, MSG_TEL_URI_VOICEMAIL);
2326
2327                         char slot_id[5] = {0, };
2328                         snprintf(slot_id, sizeof(slot_id), "%d", msg_info->sim_idx - 1);
2329                         addServiceExtraData(noti_info->svc_h, "slot_id", slot_id);
2330                 }
2331
2332                 if (voiceNumber)        g_free(voiceNumber);
2333                 if (voiceAlphaId) g_free(voiceAlphaId);
2334                 break;
2335         }
2336         case MSG_MGR_NOTI_TYPE_MWI:
2337         case MSG_MGR_NOTI_TYPE_CLASS0: {
2338                 noti_info->count = 1;
2339                 noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2340                 noti_info->time = msg_info->displayTime;
2341
2342                 if (msg_info->displayName[0] == '\0')
2343                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", msg_info->addressVal);
2344                 else
2345                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", msg_info->displayName);
2346
2347                 snprintf(noti_info->number, sizeof(noti_info->number), "%s", msg_info->addressVal);
2348
2349                 snprintf(noti_info->text, sizeof(noti_info->text), "%s", msg_info->msgText);
2350
2351                 if (noti_info->type == MSG_MGR_NOTI_TYPE_MWI) {
2352                         if (noti_info->svc_h) {
2353                                 setServiceOperation(noti_info->svc_h, APP_CONTROL_OPERATION_CALL);
2354                                 setServiceUri(noti_info->svc_h, MSG_TEL_URI_VOICEMAIL);
2355
2356                                 char slot_id[5] = {0, };
2357                                 snprintf(slot_id, sizeof(slot_id), "%d", msg_info->sim_idx - 1);
2358                                 addServiceExtraData(noti_info->svc_h, "slot_id", slot_id);
2359                         }
2360
2361                 } else {
2362                         setServiceAppId(noti_info->svc_h, "org.tizen.msg-ui-class0");
2363                         addServiceExtraData(noti_info->svc_h, "type", "new_msg");
2364                         addServiceExtraData(noti_info->svc_h, "msgId", noti_info->msg_id);
2365                 }
2366                 break;
2367         }
2368         case MSG_MGR_NOTI_TYPE_SMS_DELIVERY_REPORT: {
2369                 noti_info->count = 1;
2370                 noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2371                 noti_info->time = msg_info->displayTime;
2372                 noti_info->extra_data = msg_info->networkStatus;
2373
2374                 MSG_MGR_CONTACT_INFO_S contactInfo = {0,};
2375                 MSG_MGR_ADDRESS_INFO_S tmpAddressInfo = {0,};
2376                 if (msg_info->addressVal[0] != '\0') {
2377                         snprintf(tmpAddressInfo.addressVal, MAX_ADDRESS_VAL_LEN, "%s", msg_info->addressVal);
2378                         if (_is_valid_email(msg_info->addressVal)) {
2379                                 tmpAddressInfo.addressType = MSG_ADDRESS_TYPE_EMAIL;
2380                         } else {
2381                                 tmpAddressInfo.addressType = MSG_ADDRESS_TYPE_UNKNOWN;
2382                         }
2383                 }
2384
2385                 if (MsgMgrGetContactInfo(&tmpAddressInfo, &contactInfo) != 0) {
2386                         MSG_MGR_WARN("MsgMgrGetContactInfo() fail.");
2387                 }
2388
2389                 if (contactInfo.firstName[0] == '\0')
2390                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", msg_info->addressVal);
2391                 else
2392                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", contactInfo.firstName);
2393
2394                 snprintf(noti_info->number, sizeof(noti_info->number), "%s", msg_info->addressVal);
2395
2396                 if (noti_info->msg_id > 0) {
2397                         setServiceAppId(noti_info->svc_h, MSG_DEFAULT_APP_ID);
2398                         addServiceExtraData(noti_info->svc_h, "type", "new_msg");
2399                         addServiceExtraData(noti_info->svc_h, "msgId", noti_info->msg_id);
2400                         addServiceExtraData(noti_info->svc_h, "address", msg_info->addressVal);
2401                 }
2402                 break;
2403         }
2404         case MSG_MGR_NOTI_TYPE_MMS_READ_REPORT:
2405         case MSG_MGR_NOTI_TYPE_MMS_DELIVERY_REPORT: {
2406                 noti_info->count = 1;
2407                 noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2408                 noti_info->time = msg_info->displayTime;
2409
2410                 MSG_MGR_CONTACT_INFO_S contactInfo = {0,};
2411                 MSG_MGR_ADDRESS_INFO_S tmpAddressInfo = {0,};
2412                 if (msg_info->addressVal[0] != '\0') {
2413                         snprintf(tmpAddressInfo.addressVal, MAX_ADDRESS_VAL_LEN, "%s", msg_info->addressVal);
2414                         if (_is_valid_email(msg_info->addressVal)) {
2415                                 tmpAddressInfo.addressType = MSG_ADDRESS_TYPE_EMAIL;
2416                         } else {
2417                                 tmpAddressInfo.addressType = MSG_ADDRESS_TYPE_UNKNOWN;
2418                         }
2419                 }
2420
2421                 if (MsgMgrGetContactInfo(&tmpAddressInfo, &contactInfo) != 0) {
2422                         MSG_MGR_WARN("MsgMgrGetContactInfo() fail.");
2423                 }
2424                 if (contactInfo.firstName[0] == '\0')
2425                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", msg_info->addressVal);
2426                 else
2427                         snprintf(noti_info->sender, sizeof(noti_info->sender), "%s", contactInfo.firstName);
2428
2429                 snprintf(noti_info->number, sizeof(noti_info->number), "%s", msg_info->addressVal);
2430
2431                 char sqlQuery[MAX_QUERY_LEN+1];
2432                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
2433
2434                 int report_status_type;
2435                 int report_status_value;
2436
2437                 if (noti_info->type == MSG_MGR_NOTI_TYPE_MMS_READ_REPORT) {
2438                         report_status_type = MSG_REPORT_TYPE_READ;
2439                 } else {
2440                         report_status_type = MSG_REPORT_TYPE_DELIVERY;
2441                 }
2442
2443                 snprintf(sqlQuery, sizeof(sqlQuery),
2444                                 "STATUS "
2445                                 "FROM %s "
2446                                 "WHERE MSG_ID=%d AND STATUS_TYPE=%d AND ADDRESS_VAL LIKE '%%%s';",
2447                                 MSGFW_REPORT_TABLE_NAME, msg_info->msgId, report_status_type, msg_mgr_normalize_number(msg_info->addressVal));
2448
2449                 MSG_MGR_DEBUG("sqlQuery = [%s]", sqlQuery);
2450
2451                 char **db_res = NULL;
2452                 int row_cnt = 0, col_cnt = 0;
2453
2454                 int msg_err = msg_db_select_with_query(msg_handle, sqlQuery, &db_res, &row_cnt, &col_cnt);
2455                 if (msg_err != MSG_SUCCESS || row_cnt <= 0) {
2456                         MSG_MGR_ERR("msg_db_select_with_query() failed [%d]", msg_err);
2457                         return;
2458                 }
2459
2460                 report_status_value = atoi(db_res[col_cnt]);
2461
2462                 MSG_MGR_DEBUG("report status [type = %d, value = %d]", report_status_type, report_status_value);
2463
2464                 msg_err = msg_db_free(msg_handle, db_res);
2465                 if (msg_err != MSG_SUCCESS) {
2466                         MSG_MGR_ERR("msg_db_free() failed [%d]", msg_err);
2467                         return;
2468                 }
2469
2470                 if (noti_info->msg_id > 0) {
2471                         setServiceAppId(noti_info->svc_h, MSG_DEFAULT_APP_ID);
2472                         addServiceExtraData(noti_info->svc_h, "type", "new_msg");
2473                         addServiceExtraData(noti_info->svc_h, "msgId", noti_info->msg_id);
2474                         addServiceExtraData(noti_info->svc_h, "address", msg_info->addressVal);
2475                 }
2476
2477                 noti_info->extra_data = (unsigned char)report_status_value;
2478                 break;
2479         }
2480         default:
2481                 MSG_MGR_DEBUG("No matching type [%d]", noti_info->type);
2482                 break;
2483         }
2484
2485         noti_info->applist = NOTIFICATION_DISPLAY_APP_ALL^NOTIFICATION_DISPLAY_APP_LOCK;
2486         MSG_MGR_END();
2487 }
2488
2489
2490 void createInfoData(MSG_MGR_NOTI_INFO_S *noti_info, msg_mgr_active_notification_type_t active_noti)
2491 {
2492         MSG_MGR_BEGIN();
2493
2494         createServiceHandle(&noti_info->svc_h);
2495
2496         switch (noti_info->type) {
2497         case MSG_MGR_NOTI_TYPE_NORMAL: {
2498                 if (noti_info->count > 1) {
2499                         noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_MULTIPLE;
2500                 } else {
2501                         noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2502                 }
2503
2504                 setServiceAppId(noti_info->svc_h, MSG_DEFAULT_APP_ID);
2505                 addServiceExtraData(noti_info->svc_h, "type", "new_msg");
2506                 addServiceExtraData(noti_info->svc_h, "msgId", noti_info->msg_id);
2507                 addServiceExtraData(noti_info->svc_h, "http://tizen.org/appcontrol/data/notification", "new_message");
2508
2509                 noti_info->applist = NOTIFICATION_DISPLAY_APP_ALL^NOTIFICATION_DISPLAY_APP_TICKER;
2510
2511                 if (noti_info->active_noti_button_num == 0)
2512                         noti_info->active_noti_button_num = 3;
2513                 break;
2514         }
2515         case MSG_MGR_NOTI_TYPE_CB: {
2516                 if (noti_info->count > 1) {
2517                         noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_MULTIPLE;
2518                 } else {
2519                         noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2520                 }
2521
2522                 setServiceAppId(noti_info->svc_h, MSG_DEFAULT_APP_ID);
2523                 addServiceExtraData(noti_info->svc_h, "type", "new_msg");
2524                 addServiceExtraData(noti_info->svc_h, "msgId", noti_info->msg_id);
2525
2526                 if (active_noti == MSG_MGR_ACTIVE_NOTI_TYPE_INSTANT)
2527                         noti_info->applist = NOTIFICATION_DISPLAY_APP_ALL^NOTIFICATION_DISPLAY_APP_LOCK;
2528                 else
2529                         noti_info->applist = NOTIFICATION_DISPLAY_APP_NOTIFICATION_TRAY|NOTIFICATION_DISPLAY_APP_INDICATOR;
2530
2531                 noti_info->active_noti_button_num = 1;
2532                 break;
2533         }
2534         case MSG_MGR_NOTI_TYPE_SIM: {
2535                 if (noti_info->count > 1) {
2536                         noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_MULTIPLE;
2537                 } else {
2538                         noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2539                 }
2540
2541                 setServiceAppId(noti_info->svc_h, MSG_DEFAULT_APP_ID);
2542                 addServiceExtraData(noti_info->svc_h, "type", "new_msg");
2543                 addServiceExtraData(noti_info->svc_h, "msgId", noti_info->msg_id);
2544
2545                 if (active_noti == MSG_MGR_ACTIVE_NOTI_TYPE_INSTANT)
2546                         noti_info->applist = NOTIFICATION_DISPLAY_APP_ALL^NOTIFICATION_DISPLAY_APP_LOCK;
2547                 else
2548                         noti_info->applist = NOTIFICATION_DISPLAY_APP_NOTIFICATION_TRAY|NOTIFICATION_DISPLAY_APP_INDICATOR;
2549
2550                 if (noti_info->active_noti_button_num == 0)
2551                         noti_info->active_noti_button_num = 3;
2552                 break;
2553         }
2554         case MSG_MGR_NOTI_TYPE_FAILED: {
2555                 noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2556
2557                 setServiceAppId(noti_info->svc_h, MSG_DEFAULT_APP_ID);
2558                 addServiceExtraData(noti_info->svc_h, "type", "send_failed_msg");
2559                 addServiceExtraData(noti_info->svc_h, "msgId", noti_info->msg_id);
2560
2561                 noti_info->applist = NOTIFICATION_DISPLAY_APP_ALL^NOTIFICATION_DISPLAY_APP_TICKER^NOTIFICATION_DISPLAY_APP_LOCK;
2562                 break;
2563         }
2564         case MSG_MGR_NOTI_TYPE_SIM_FULL: {
2565                 noti_info->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2566
2567                 setServiceAppId(noti_info->svc_h, MSG_DEFAULT_APP_ID);
2568                 addServiceExtraData(noti_info->svc_h, "sim_list_show", "sim_setting");
2569
2570                 noti_info->applist = NOTIFICATION_DISPLAY_APP_NOTIFICATION_TRAY|NOTIFICATION_DISPLAY_APP_INDICATOR;
2571                 break;
2572         }
2573         default:
2574                 break;
2575         }
2576
2577         if (active_noti != MSG_MGR_ACTIVE_NOTI_TYPE_ACTIVE)
2578                 noti_info->active_noti_button_num = 0;
2579
2580         MSG_MGR_END();
2581 }
2582
2583
2584 void createServiceHandle(app_control_h *svc_h)
2585 {
2586         int svc_err = APP_CONTROL_ERROR_NONE;
2587
2588         svc_err = app_control_create(svc_h);
2589
2590         if (svc_err != APP_CONTROL_ERROR_NONE)
2591                 MSG_MGR_DEBUG("app_control_create() is failed, [%d]", svc_err);
2592 }
2593
2594
2595 void setServiceAppId(app_control_h svc_h, const char* app_id)
2596 {
2597         int svc_err = APP_CONTROL_ERROR_NONE;
2598
2599         svc_err = app_control_set_app_id(svc_h, app_id);
2600
2601         if (svc_err != APP_CONTROL_ERROR_NONE)
2602                 MSG_MGR_DEBUG("app_control_set_app_id() was failed, [%d]", svc_err);
2603 }
2604
2605
2606 void setServiceUri(app_control_h svc_h, const char* uri)
2607 {
2608         int svc_err = APP_CONTROL_ERROR_NONE;
2609
2610         svc_err = app_control_set_uri(svc_h, uri);
2611
2612         if (svc_err != APP_CONTROL_ERROR_NONE)
2613                 MSG_MGR_DEBUG("app_control_set_uri() was failed, [%d]", svc_err);
2614 }
2615
2616
2617 void setServiceOperation(app_control_h svc_h, const char* operation)
2618 {
2619         int svc_err = APP_CONTROL_ERROR_NONE;
2620
2621         svc_err = app_control_set_operation(svc_h, operation);
2622
2623         if (svc_err != APP_CONTROL_ERROR_NONE)
2624                 MSG_MGR_DEBUG("app_control_set_operation() was failed, [%d]", svc_err);
2625 }
2626
2627
2628 void addServiceExtraData(app_control_h svc_h, const char* bundle_key, const char* bundle_val)
2629 {
2630         int svc_err = APP_CONTROL_ERROR_NONE;
2631
2632         svc_err = app_control_add_extra_data(svc_h, bundle_key, bundle_val);
2633
2634         if (svc_err != APP_CONTROL_ERROR_NONE)
2635                 MSG_MGR_DEBUG("app_control_add_extra_data() was failed, [%d]", svc_err);
2636 }
2637
2638
2639 void addServiceExtraData(app_control_h svc_h, const char* bundle_key, int bundle_val)
2640 {
2641         int svc_err = APP_CONTROL_ERROR_NONE;
2642
2643         char tempId[10];
2644         memset(&tempId, 0x00, sizeof(tempId));
2645         snprintf(tempId, sizeof(tempId), "%d", bundle_val);
2646
2647         svc_err = app_control_add_extra_data(svc_h, bundle_key, (const char *)tempId);
2648
2649         if (svc_err != APP_CONTROL_ERROR_NONE)
2650                 MSG_MGR_DEBUG("app_control_add_extra_data() was failed, [%d]", svc_err);
2651 }
2652
2653
2654 void setServicePackageName(app_control_h svc_h, const char* pkg_name)
2655 {
2656         int svc_err = APP_CONTROL_ERROR_NONE;
2657
2658         svc_err = app_control_set_app_id(svc_h, pkg_name);
2659
2660         if (svc_err != APP_CONTROL_ERROR_NONE)
2661                 MSG_MGR_DEBUG("app_control_set_app_id() was failed, [%d]", svc_err);
2662 }
2663
2664
2665 void sendServicelaunchRequest(app_control_h svc_h, app_control_reply_cb callback, void *user_data)
2666 {
2667         int svc_err = APP_CONTROL_ERROR_NONE;
2668
2669         svc_err = app_control_send_launch_request(svc_h, callback, user_data);
2670
2671         if (svc_err != APP_CONTROL_ERROR_NONE)
2672                 MSG_MGR_DEBUG("app_control_send_launch_request() is failed : %d", svc_err);
2673 }
2674
2675
2676 void setNotiTextDomain(notification_h noti_h, const char *pkg_name, const char *loc_dir)
2677 {
2678         int noti_err = NOTIFICATION_ERROR_NONE;
2679
2680         noti_err = notification_set_text_domain(noti_h, pkg_name, loc_dir);
2681         if (noti_err != NOTIFICATION_ERROR_NONE)
2682                 MSG_MGR_DEBUG("notification_set_text_domain() was failed. [%d]", noti_err);
2683 }
2684
2685
2686 void setNotiText(notification_h noti_h, notification_text_type_e type, const char *text, const char *key)
2687 {
2688         int noti_err = NOTIFICATION_ERROR_NONE;
2689
2690         noti_err = notification_set_text(noti_h, type, text, key, NOTIFICATION_VARIABLE_TYPE_NONE);
2691
2692         if (noti_err != NOTIFICATION_ERROR_NONE)
2693                 MSG_MGR_DEBUG("notification_set_text() was failed. [%d]", noti_err);
2694 }
2695
2696
2697 void setNotiTimeToText(notification_h noti_h, notification_text_type_e type, time_t time)
2698 {
2699         int noti_err = NOTIFICATION_ERROR_NONE;
2700
2701         noti_err = notification_set_time_to_text(noti_h, type, time);
2702
2703         if (noti_err != NOTIFICATION_ERROR_NONE)
2704                 MSG_MGR_DEBUG("notification_set_time_to_text() was failed. [%d]", noti_err);
2705 }
2706
2707
2708 void setNotiTime(notification_h noti_h, time_t time)
2709 {
2710         int noti_err = NOTIFICATION_ERROR_NONE;
2711
2712         noti_err = notification_set_time(noti_h, time);
2713
2714         if (noti_err != NOTIFICATION_ERROR_NONE)
2715                 MSG_MGR_DEBUG("notification_set_time() was failed. [%d]", noti_err);
2716 }
2717
2718
2719
2720 void setNotiImage(notification_h noti_h, notification_image_type_e type, const char *image_path)
2721 {
2722         int noti_err = NOTIFICATION_ERROR_NONE;
2723
2724         noti_err = notification_set_image(noti_h, type, image_path);
2725
2726         if (noti_err != NOTIFICATION_ERROR_NONE)
2727                 MSG_MGR_DEBUG("notification_set_image() was failed. [%d]", noti_err);
2728 }
2729
2730
2731 void setNotiSound(notification_h noti_h, notification_sound_type_e type, const char *path)
2732 {
2733         int noti_err = NOTIFICATION_ERROR_NONE;
2734
2735         noti_err = notification_set_sound(noti_h, type, path);
2736
2737         if (noti_err != NOTIFICATION_ERROR_NONE)
2738                 MSG_MGR_DEBUG("notification_set_sound() was failed. [%d]", noti_err);
2739 }
2740
2741
2742 void setNotiVibration(notification_h noti_h, notification_vibration_type_e type, const char *path)
2743 {
2744         int noti_err = NOTIFICATION_ERROR_NONE;
2745
2746         noti_err = notification_set_vibration(noti_h, type, path);
2747
2748         if (noti_err != NOTIFICATION_ERROR_NONE)
2749                 MSG_MGR_DEBUG("notification_set_vibration() was failed. [%d]", noti_err);
2750 }
2751
2752
2753 void setNotiEventHandler(notification_h noti_h, notification_event_type_e type, app_control_h event_handler)
2754 {
2755         int noti_err = NOTIFICATION_ERROR_NONE;
2756
2757         noti_err = notification_set_event_handler(noti_h, type, event_handler);
2758
2759         if (noti_err != NOTIFICATION_ERROR_NONE)
2760                 MSG_MGR_DEBUG("notification_set_event_handler() was failed. [%d]", noti_err);
2761 }
2762
2763
2764 int MsgMgrInsertInstantMessage(msg_mgr_notification_type_t noti_type)
2765 {
2766         MSG_MGR_BEGIN();
2767
2768         char *notiMsg = NULL;
2769
2770         notification_h noti = notification_create(NOTIFICATION_TYPE_NOTI);
2771
2772         switch (noti_type) {
2773         case MSG_MGR_NOTI_TYPE_NORMAL:
2774         case MSG_MGR_NOTI_TYPE_SIM:
2775         case MSG_MGR_NOTI_TYPE_CB: {
2776                 MSG_MGR_NOTI_INFO_S noti_info;
2777                 memset(&noti_info, 0x00, sizeof(MSG_MGR_NOTI_INFO_S));
2778
2779                 noti_info.type = noti_type;
2780                 int err = getLatestMsgInfo(&noti_info, true);
2781
2782                 if (err == 0) {
2783                         MSG_MGR_DEBUG("Unread count [%d]", noti_info.count);
2784                         if (noti_info.count == 1) {
2785                                 MSG_MGR_SEC_DEBUG("noti_info.sender [%s]", noti_info.sender);
2786                                 setNotiText(noti, NOTIFICATION_TEXT_TYPE_TITLE, noti_info.sender, NULL);
2787                                 setNotiText(noti, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info.text, NULL);
2788                         } else if (noti_info.count > 1) {
2789                                 gchar *cnt_string = g_strdup_printf("%i", noti_info.count);
2790
2791                                 notiMsg = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, NEW_MESSAGE);
2792                                 gchar *outString = g_strconcat(cnt_string, " ", notiMsg, NULL);
2793                                 setNotiText(noti, NOTIFICATION_TEXT_TYPE_TITLE, outString, NULL);
2794                                 setNotiText(noti, NOTIFICATION_TEXT_TYPE_CONTENT, noti_info.sender, NULL);
2795                                 g_free(outString);
2796                                 g_free(cnt_string);
2797                         }
2798
2799                         setNotiImage(noti, NOTIFICATION_IMAGE_TYPE_ICON, MSG_NORMAL_ICON_PATH);
2800                 }
2801                 break;
2802         }
2803         case MSG_MGR_NOTI_TYPE_FAILED: {
2804                 notiMsg = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, FAILED_TO_SEND_MESSAGE);
2805                 setNotiText(noti, NOTIFICATION_TEXT_TYPE_TITLE, notiMsg, NULL);
2806                 setNotiImage(noti, NOTIFICATION_IMAGE_TYPE_ICON, MSG_SMS_SENDING_FAILED_ICON_PATH);
2807                 break;
2808         }
2809         default:
2810                 MSG_MGR_DEBUG("No matching type for MsgNotiType%d]", noti_type);
2811                 goto _END_OF_INSTANT_NOTI;
2812                 break;
2813         }
2814
2815         if (notification_set_display_applist(noti, NOTIFICATION_DISPLAY_APP_TICKER) != NOTIFICATION_ERROR_NONE)
2816                 MSG_MGR_DEBUG("Fail to notification_set_display_applist");
2817
2818         if (notification_post(noti) != NOTIFICATION_ERROR_NONE)
2819                 MSG_MGR_DEBUG("Fail to notification_post");
2820
2821 _END_OF_INSTANT_NOTI:
2822
2823         if (notification_delete(noti) != NOTIFICATION_ERROR_NONE)
2824                 MSG_MGR_DEBUG("Fail to notification_delete");
2825         if (notiMsg) {
2826                 free(notiMsg);
2827                 notiMsg = NULL;
2828         }
2829
2830         if (noti) {
2831                 if (notification_free(noti) != NOTIFICATION_ERROR_NONE)
2832                         MSG_MGR_DEBUG("Fail to notification_free");
2833                 noti = NULL;
2834         }
2835
2836         MSG_MGR_END();
2837         return 0;
2838 }
2839
2840
2841 bool MsgMgrCheckNotificationSettingEnable()
2842 {
2843         bool msg_noti_enabled = false;
2844         notification_system_setting_h system_setting = NULL;
2845         notification_setting_h setting = NULL;
2846
2847         int err = NOTIFICATION_ERROR_NONE;
2848
2849         err = notification_setting_get_setting_by_package_name(MSG_DEFAULT_APP_ID, &setting);
2850
2851         if (err != NOTIFICATION_ERROR_NONE || setting == NULL) {
2852                 MSG_MGR_ERR("getting setting handle for [%s] is failed. err = %d", MSG_DEFAULT_APP_ID, err);
2853         } else {
2854                 msg_noti_enabled = true;
2855
2856                 bool allow_to_notify = false;
2857                 err = notification_setting_get_allow_to_notify(setting, &allow_to_notify);
2858
2859                 if (err != NOTIFICATION_ERROR_NONE) {
2860                         MSG_MGR_ERR("getting do not disturb setting is failed. err = %d", err);
2861                         goto EXIT;
2862                 }
2863
2864                 if (allow_to_notify) {
2865                         MSG_MGR_DEBUG("message notification is allowed");
2866
2867                         /* check do not disturb mode */
2868                         err = notification_system_setting_load_system_setting(&system_setting);
2869
2870                         if (err != NOTIFICATION_ERROR_NONE || system_setting == NULL) {
2871                                 MSG_MGR_ERR("getting system setting is failed. err = %d", err);
2872                                 goto EXIT;
2873                         }
2874
2875                         bool do_not_disturb_mode = false;
2876                         err = notification_system_setting_get_do_not_disturb(system_setting, &do_not_disturb_mode);
2877
2878                         if (err != NOTIFICATION_ERROR_NONE) {
2879                                 MSG_MGR_ERR("getting do not disturb setting is failed. err = %d", err);
2880                                 goto EXIT;
2881                         }
2882
2883                         if (do_not_disturb_mode) {
2884                                 bool is_msg_excepted = false;
2885                                 err = notification_setting_get_do_not_disturb_except(setting, &is_msg_excepted);
2886                                 if (err != NOTIFICATION_ERROR_NONE) {
2887                                         MSG_MGR_ERR("getting do not disturb except status for [%s] is failed. err = %d", MSG_DEFAULT_APP_ID, err);
2888                                         msg_noti_enabled = false;
2889                                 } else {
2890                                         MSG_MGR_INFO("do not disturb mode status for [%s] : %d", MSG_DEFAULT_APP_ID, is_msg_excepted);
2891                                         msg_noti_enabled = (is_msg_excepted) ? true : false;
2892                                 }
2893                         } else {
2894                                 MSG_MGR_DEBUG("do not disturb mode is off");
2895                         }
2896                 } else {
2897                         MSG_MGR_INFO("message notification is not allowed");
2898                         msg_noti_enabled = false;
2899                 }
2900         }
2901
2902 EXIT:
2903         if (system_setting)
2904                 notification_system_setting_free_system_setting(system_setting);
2905
2906         if (setting)
2907                 notification_setting_free_notification(setting);
2908
2909         return msg_noti_enabled;
2910 }
2911
2912
2913 int MsgMgrInsertTicker(const char* pTickerMsg, const char* pLocaleTickerMsg, bool bPlayFeedback, int msgId)
2914 {
2915         MSG_MGR_DEBUG("pTickerMsg=[%s], pLocaleTickerMsg=[%s]", pTickerMsg, pLocaleTickerMsg);
2916         MSG_MGR_DEBUG("play feedback=[%d], msgId=[%d]", bPlayFeedback, msgId);
2917
2918         MsgMgrChangePmState();
2919
2920         char *notiMsg = NULL;
2921         msg_mgr_active_notification_type_t active_type = MSG_MGR_ACTIVE_NOTI_TYPE_NONE;
2922         int err = 0;
2923
2924         notiMsg = get_translate_text(MSG_APP_PACKAGE_NAME, MSG_APP_LOCALEDIR, pLocaleTickerMsg);
2925         MSG_MGR_DEBUG("notiMsg %s", notiMsg);
2926
2927         if (g_strcmp0(pLocaleTickerMsg, SMS_MESSAGE_SENDING_FAIL) != 0 &&
2928                 g_strcmp0(pLocaleTickerMsg, SENDING_MULTIMEDIA_MESSAGE_FAILED) != 0 &&
2929                 g_strcmp0(pLocaleTickerMsg, MESSAGE_RETRIEVED) != 0) {
2930                 if (g_strcmp0(pLocaleTickerMsg, notiMsg) == 0) {
2931                         notification_status_message_post(pTickerMsg);
2932                 } else {
2933                         notification_status_message_post(notiMsg);
2934                 }
2935         } else {
2936                 /* Show ticker popup for sending failed msg. */
2937                 active_type = MSG_MGR_ACTIVE_NOTI_TYPE_INSTANT;
2938         }
2939
2940         if (notiMsg) {
2941                 free(notiMsg);
2942                 notiMsg = NULL;
2943         }
2944
2945         if (bPlayFeedback) {
2946                 if (msgId > 0 &&
2947                         (g_strcmp0(pLocaleTickerMsg, SMS_MESSAGE_SENDING_FAIL) == 0 || g_strcmp0(pLocaleTickerMsg, SENDING_MULTIMEDIA_MESSAGE_FAILED) == 0)) {
2948                         err = MsgMgrRefreshNotification(MSG_MGR_NOTI_TYPE_FAILED, true, active_type);
2949                         if (err != 0) {
2950                                 MSG_MGR_DEBUG("MsgRefreshFailedNoti err=[%d]", err);
2951                         }
2952                 } else if (g_strcmp0(pLocaleTickerMsg, SMS_MESSAGE_SIM_MESSAGE_FULL) == 0) {
2953                         err = MsgMgrRefreshNotification(MSG_MGR_NOTI_TYPE_SIM_FULL, true, MSG_MGR_ACTIVE_NOTI_TYPE_NONE);
2954                         if (err != 0) {
2955                                 MSG_MGR_DEBUG("MsgRefreshSimFullNoti err=[%d]", err);
2956                         }
2957                 } else {
2958                         MsgMgrSoundPlayStart(NULL, MSG_MGR_SOUND_PLAY_DEFAULT);
2959                 }
2960         }
2961
2962         return err;
2963 }
2964
2965
2966 int MsgMgrInsertBadge(unsigned int unreadMsgCnt)
2967 {
2968         MSG_MGR_DEBUG("Start to set badge to [%d].", unreadMsgCnt);
2969
2970         int err = BADGE_ERROR_NONE;
2971         bool exist = false;
2972
2973         err = badge_is_existing(MSG_DEFAULT_APP_ID, &exist);
2974
2975         if (err != BADGE_ERROR_NONE) {
2976                 MSG_MGR_ERR("Fail to badge_is_existing : %d", err);
2977                 return -1;
2978         }
2979
2980         if (!exist) {
2981                 /* create badge */
2982                 err = badge_add(MSG_DEFAULT_APP_ID);
2983                 if (err != BADGE_ERROR_NONE) {
2984                         MSG_MGR_ERR("Fail to badge_add : %d", err);
2985                         return -1;
2986                 }
2987         }
2988
2989         err = badge_set_count(MSG_DEFAULT_APP_ID, unreadMsgCnt);
2990
2991         if (err != BADGE_ERROR_NONE) {
2992                 MSG_MGR_ERR("Fail to badge_set_count : %d", err);
2993                 return -1;
2994         }
2995
2996         return 0;
2997 }
2998
2999
3000 void MsgMgrNotiSoundRepeatAlarmCB(int alarmId)
3001 {
3002         MSG_MGR_BEGIN();
3003
3004         MsgMgrRefreshNotification(MSG_MGR_NOTI_TYPE_NORMAL, true, MSG_MGR_ACTIVE_NOTI_TYPE_ACTIVE);
3005
3006 #ifndef MSG_NOTI_INTEGRATION
3007         MsgMgrRefreshNotification(MSG_MGR_NOTI_TYPE_SIM, true, MSG_MGR_ACTIVE_NOTI_TYPE_ACTIVE);
3008         MsgMgrRefreshNotification(MSG_MGR_NOTI_TYPE_CB, true, MSG_MGR_ACTIVE_NOTI_TYPE_ACTIVE);
3009 #endif
3010
3011         MSG_MGR_END();
3012         return;
3013 }
3014
3015
3016 void MsgMgrSoundCreateRepeatAlarm(int RepeatTime)
3017 {
3018         MSG_MGR_BEGIN();
3019
3020         int tmpAlarmId = 0;
3021         time_t tmp_time;
3022         struct tm repeat_tm;
3023
3024         time(&tmp_time);
3025
3026         tmp_time += (RepeatTime*60);
3027         tzset();
3028         localtime_r(&tmp_time, &repeat_tm);
3029
3030         if (MsgMgrAlarmRegistration(&repeat_tm, MsgMgrNotiSoundRepeatAlarmCB, &tmpAlarmId) != 0) {
3031                 MSG_MGR_DEBUG("MsgAlarmRegistration fail.");
3032                 return;
3033         }
3034
3035         g_alarmId = tmpAlarmId;
3036         MSG_MGR_DEBUG("Set alarmId to [%d]", g_alarmId);
3037
3038         MSG_MGR_END();
3039
3040         return;
3041 }
3042
3043
3044 void MsgMgrSoundSetRepeatAlarm()
3045 {
3046         int nRepeatValue = 0;
3047         long nRepeatTime = 0;
3048
3049         if (vconf_get_int(MSG_ALERT_REP_TYPE, &nRepeatValue) != 0) {
3050                 MSG_MGR_INFO("vconf_get_int() is failed");
3051         }
3052
3053         switch (nRepeatValue) {
3054         case MSG_ALERT_TONE_ONCE:
3055                 nRepeatTime = 0;
3056                 break;
3057         case MSG_ALERT_TONE_2MINS:
3058                 nRepeatTime = 2;
3059                 break;
3060         case MSG_ALERT_TONE_5MINS:
3061                 nRepeatTime = 5;
3062                 break;
3063         case MSG_ALERT_TONE_10MINS:
3064                 nRepeatTime = 10;
3065                 break;
3066         default:
3067                 MSG_MGR_DEBUG("Invalid Repetition time");
3068                 break;
3069         }
3070
3071         MSG_MGR_DEBUG("nRepeatTime = %d", nRepeatTime);
3072
3073         if (nRepeatTime > 0) {
3074                 if (g_alarmId > 0) {
3075                         if (MsgMgrAlarmRemove(g_alarmId) != 0) {
3076                                 MSG_MGR_FATAL("MsgAlarmRemove fail.");
3077                         }
3078                         g_alarmId = 0;
3079                 }
3080                 MsgMgrSoundCreateRepeatAlarm(nRepeatTime);
3081         }
3082
3083         return;
3084 }
3085
3086
3087 char *get_translate_text(const char *pkg_name, const char *locale_dir, const char *text)
3088 {
3089         char *notiMsg = NULL;
3090         char *lang = NULL;
3091
3092         lang = vconf_get_str(VCONFKEY_LANGSET);
3093
3094         setlocale(LC_MESSAGES, lang);
3095
3096         bindtextdomain(pkg_name, locale_dir);
3097
3098         notiMsg = dgettext(pkg_name, text);
3099
3100         if (lang) {
3101                 free(lang);
3102                 lang = NULL;
3103         }
3104
3105         return g_strdup(notiMsg);
3106 }
3107