src/notification.c

   1 /*
   2  *  libnotification
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Seungtaek Chung <seungtaek.chung@samsung.com>, Mi-Ju Lee <miju52.lee@samsung.com>, Xi Zhichan <zhichan.xi@samsung.com>, Youngsub Ko <ys4610.ko@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <libintl.h>
  28 #include <dbus/dbus.h>
  29 #include <dbus/dbus-glib-lowlevel.h>
  30
  31 #include <aul.h>
  32 #include <ail.h>
  33 #include <appsvc.h>
  34 #include <vconf-keys.h>
  35 #include <vconf.h>
  36
  37 #include <notification.h>
  38 #include <notification_list.h>
  39 #include <notification_debug.h>
  40 #include <notification_internal.h>
  41 #include <notification_noti.h>
  42 #include <notification_ongoing.h>
  43 #include <notification_group.h>
  44 #include <notification_ipc.h>
  45
  46 typedef struct _notification_cb_list notification_cb_list_s;
  47
  48 typedef enum __notification_cb_type {
  49         NOTIFICATION_CB_NORMAL = 1,
  50         NOTIFICATION_CB_DETAILED,
  51 } _notification_cb_type_e;
  52
  53 struct _notification_cb_list {
  54         notification_cb_list_s *prev;
  55         notification_cb_list_s *next;
  56
  57         _notification_cb_type_e cb_type;
  58         void (*changed_cb) (void *data, notification_type_e type);
  59         void (*detailed_changed_cb) (void *data, notification_type_e type, notification_op *op_list, int num_op);
  60         void *data;
  61 };
  62
  63 static notification_cb_list_s *g_notification_cb_list = NULL;
  64
  65 #define NOTI_TEXT_RESULT_LEN 2048
  66 #define NOTI_PKGNAME_LEN        512
  67 #define NOTI_CHANGED_NOTI       "notification_noti_changed"
  68 #define NOTI_CHANGED_ONGOING    "notification_ontoing_changed"
  69
  70 #define NOTI_DBUS_BUS_NAME      "org.tizen.libnotification"
  71 #define NOTI_DBUS_PATH          "/org/tizen/libnotification"
  72 #define NOTI_DBUS_INTERFACE     "org.tizen.libnotification.signal"
  73
  74 static char *_notification_get_pkgname_by_pid(void)
  75 {
  76         char pkgname[NOTI_PKGNAME_LEN + 1] = { 0, };
  77         int pid = 0, ret = AUL_R_OK;
  78         int fd;
  79         char  *dup_pkgname;
  80
  81         pid = getpid();
  82
  83         ret = aul_app_get_pkgname_bypid(pid, pkgname, sizeof(pkgname));
  84         if (ret != AUL_R_OK) {
  85                 char buf[NOTI_PKGNAME_LEN + 1] = { 0, };
  86
  87                 snprintf(buf, sizeof(buf), "/proc/%d/cmdline", pid);
  88
  89                 fd = open(buf, O_RDONLY);
  90                 if (fd < 0) {
  91                         return NULL;
  92                 }
  93
  94                 ret = read(fd, pkgname, sizeof(pkgname) - 1);
  95                 close(fd);
  96
  97                 if (ret <= 0) {
  98                         return NULL;
  99                 }
 100
 101                 pkgname[ret] = '\0';
 102                 /*!
 103                  * \NOTE
 104                  * "ret" is not able to be larger than "sizeof(pkgname) - 1",
 105                  * if the system is not going wrong.
 106                  */
 107         } else {
 108                 if (strlen(pkgname) <= 0) {
 109                         return NULL;
 110                 }
 111         }
 112
 113         dup_pkgname = strdup(pkgname);
 114         if (!dup_pkgname)
 115                 NOTIFICATION_ERR("Heap: %s\n", strerror(errno));
 116
 117         return dup_pkgname;
 118 }
 119
 120 static char *_notification_get_icon(const char *package)
 121 {
 122         ail_appinfo_h handle;
 123         ail_error_e ret;
 124         char *str = NULL;
 125         char *icon = NULL;
 126
 127         ret = ail_package_get_appinfo(package, &handle);
 128         if (ret != AIL_ERROR_OK) {
 129                 return NULL;
 130         }
 131
 132         ret = ail_appinfo_get_str(handle, AIL_PROP_ICON_STR, &str);
 133         if (ret != AIL_ERROR_OK) {
 134                 ail_package_destroy_appinfo(handle);
 135                 return NULL;
 136         }
 137
 138         icon = strdup(str);
 139
 140         ret = ail_package_destroy_appinfo(handle);
 141         if (ret != AIL_ERROR_OK) {
 142                 NOTIFICATION_ERR("Fail to ail_package_destroy_appinfo");
 143         }
 144
 145         return icon;
 146 }
 147
 148 static char *_notification_get_name(const char *package)
 149 {
 150         ail_appinfo_h handle;
 151         ail_error_e ret;
 152         char *str = NULL;
 153         char *name = NULL;
 154
 155         ret = ail_package_get_appinfo(package, &handle);
 156         if (ret != AIL_ERROR_OK) {
 157                 return NULL;
 158         }
 159
 160         ret = ail_appinfo_get_str(handle, AIL_PROP_NAME_STR, &str);
 161         if (ret != AIL_ERROR_OK) {
 162                 ail_package_destroy_appinfo(handle);
 163                 return NULL;
 164         }
 165
 166         name = strdup(str);
 167
 168         ret = ail_package_destroy_appinfo(handle);
 169         if (ret != AIL_ERROR_OK) {
 170                 NOTIFICATION_ERR("Fail to ail_package_destroy_appinfo");
 171         }
 172
 173         return name;
 174 }
 175
 176 static void _notification_get_text_domain(notification_h noti)
 177 {
 178         if (noti->domain != NULL) {
 179
 180         }
 181
 182         if (noti->dir != NULL) {
 183
 184         }
 185 }
 186
 187 /* notification_set_icon will be removed */
 188 EXPORT_API notification_error_e notification_set_icon(notification_h noti,
 189                                                       const char *icon_path)
 190 {
 191         int ret_err = NOTIFICATION_ERROR_NONE;
 192
 193         ret_err =
 194             notification_set_image(noti, NOTIFICATION_IMAGE_TYPE_ICON,
 195                                    icon_path);
 196
 197         return ret_err;
 198 }
 199
 200 /* notification_get_icon will be removed */
 201 EXPORT_API notification_error_e notification_get_icon(notification_h noti,
 202                                                       char **icon_path)
 203 {
 204         int ret_err = NOTIFICATION_ERROR_NONE;
 205         char *ret_image_path = NULL;
 206
 207         ret_err =
 208             notification_get_image(noti, NOTIFICATION_IMAGE_TYPE_ICON,
 209                                    &ret_image_path);
 210
 211         if (ret_err == NOTIFICATION_ERROR_NONE && icon_path != NULL) {
 212                 *icon_path = ret_image_path;
 213
 214                 //NOTIFICATION_DBG("Get icon : %s", *icon_path);
 215         }
 216
 217         return ret_err;
 218 }
 219
 220 EXPORT_API notification_error_e notification_set_image(notification_h noti,
 221                                                        notification_image_type_e type,
 222                                                        const char *image_path)
 223 {
 224         bundle *b = NULL;
 225         char buf_key[32] = { 0, };
 226         const char *ret_val = NULL;
 227
 228         /* Check noti and image_path are valid data */
 229         if (noti == NULL || image_path == NULL) {
 230                 return NOTIFICATION_ERROR_INVALID_DATA;
 231         }
 232
 233         /* Check image type is valid type */
 234         if (type <= NOTIFICATION_IMAGE_TYPE_NONE
 235             || type >= NOTIFICATION_IMAGE_TYPE_MAX) {
 236                 return NOTIFICATION_ERROR_INVALID_DATA;
 237         }
 238
 239         /* Check image path bundle is exist */
 240         if (noti->b_image_path) {
 241                 /* If image path bundle is exist, store local bundle value */
 242                 b = noti->b_image_path;
 243
 244                 /* Set image type to key as char string type */
 245                 snprintf(buf_key, sizeof(buf_key), "%d", type);
 246
 247                 /* Get value using key */
 248                 ret_val = bundle_get_val(b, buf_key);
 249                 if (ret_val != NULL) {
 250                         /* If key is exist, remove this value to store new image path */
 251                         bundle_del(b, buf_key);
 252                 }
 253
 254                 /* Add new image path with type key */
 255                 bundle_add(b, buf_key, image_path);
 256         } else {
 257                 /* If image path bundle is not exist, create new one */
 258                 b = bundle_create();
 259
 260                 /* Set image type to key as char string type */
 261                 snprintf(buf_key, sizeof(buf_key), "%d", type);
 262
 263                 /* Add new image path with type key */
 264                 bundle_add(b, buf_key, image_path);
 265
 266                 /* Save to image path bundle */
 267                 noti->b_image_path = b;
 268         }
 269
 270         return NOTIFICATION_ERROR_NONE;
 271 }
 272
 273 EXPORT_API notification_error_e notification_get_image(notification_h noti,
 274                                                        notification_image_type_e type,
 275                                                        char **image_path)
 276 {
 277         bundle *b = NULL;
 278         char buf_key[32] = { 0, };
 279         const char *ret_val = NULL;
 280         const char *pkgname = NULL;
 281
 282         /* Check noti and image_path is valid data */
 283         if (noti == NULL || image_path == NULL) {
 284                 return NOTIFICATION_ERROR_INVALID_DATA;
 285         }
 286
 287         /* Check image type is valid data */
 288         if (type <= NOTIFICATION_IMAGE_TYPE_NONE
 289             || type >= NOTIFICATION_IMAGE_TYPE_MAX) {
 290                 return NOTIFICATION_ERROR_INVALID_DATA;
 291         }
 292
 293         /* Check image path bundle exist */
 294         if (noti->b_image_path) {
 295                 /* If image path bundle exist, store local bundle data */
 296                 b = noti->b_image_path;
 297
 298                 /* Set image type to key as char string type */
 299                 snprintf(buf_key, sizeof(buf_key), "%d", type);
 300
 301                 /* Get value of key */
 302                 ret_val = bundle_get_val(b, buf_key);
 303
 304                 *image_path = (char *)ret_val;
 305         } else {
 306                 /* If image path bundle does not exist, image path is NULL */
 307                 *image_path = NULL;
 308         }
 309
 310         /* If image path is NULL and type is ICON, icon path set from AIL */
 311         /* order : user icon -> launch_pkgname icon -> caller_pkgname icon -> service app icon */
 312         if (*image_path == NULL && type == NOTIFICATION_IMAGE_TYPE_ICON) {
 313                 /* Check App icon path is already set */
 314                 if (noti->app_icon_path != NULL) {
 315                         /* image path will be app icon path */
 316                         *image_path = noti->app_icon_path;
 317                 } else {
 318                         /* Get image path using launch_pkgname */
 319                         if (noti->launch_pkgname != NULL) {
 320                                 noti->app_icon_path =
 321                                     _notification_get_icon(noti->launch_pkgname);
 322                         }
 323
 324                         /* If app icon path is NULL, get image path using caller_pkgname */
 325                         if (noti->app_icon_path == NULL
 326                             && noti->caller_pkgname != NULL) {
 327                                 noti->app_icon_path =
 328                                     _notification_get_icon(noti->caller_pkgname);
 329                         }
 330
 331                         /* If app icon path is NULL, get image path using service data */
 332                         if (noti->app_icon_path == NULL
 333                             && noti->b_service_single_launch != NULL) {
 334                                 pkgname =
 335                                     appsvc_get_pkgname(noti->b_service_single_launch);
 336                                 if (pkgname != NULL) {
 337                                         noti->app_icon_path =
 338                                             _notification_get_icon(pkgname);
 339                                 }
 340                         }
 341
 342                         *image_path = noti->app_icon_path;
 343                 }
 344         }
 345
 346         return NOTIFICATION_ERROR_NONE;
 347 }
 348
 349 EXPORT_API notification_error_e notification_set_time(notification_h noti,
 350                                                       time_t input_time)
 351 {
 352         /* Check noti is valid data */
 353         if (noti == NULL) {
 354                 return NOTIFICATION_ERROR_INVALID_DATA;
 355         }
 356
 357         if (input_time == 0) {
 358                 /* If input time is 0, set current time */
 359                 noti->time = time(NULL);
 360         } else {
 361                 /* save input time */
 362                 noti->time = input_time;
 363         }
 364
 365         return NOTIFICATION_ERROR_NONE;
 366 }
 367
 368 EXPORT_API notification_error_e notification_get_time(notification_h noti,
 369                                                       time_t * ret_time)
 370 {
 371         /* Check noti and time is valid data */
 372         if (noti == NULL || ret_time == NULL) {
 373                 return NOTIFICATION_ERROR_INVALID_DATA;
 374         }
 375
 376         /* Set time infomation */
 377         *ret_time = noti->time;
 378
 379         return NOTIFICATION_ERROR_NONE;
 380 }
 381
 382 EXPORT_API notification_error_e notification_get_insert_time(notification_h noti,
 383                                                              time_t * ret_time)
 384 {
 385         /* Check noti and ret_time is valid data */
 386         if (noti == NULL || ret_time == NULL) {
 387                 return NOTIFICATION_ERROR_INVALID_DATA;
 388         }
 389
 390         /* Set insert time information */
 391         *ret_time = noti->insert_time;
 392
 393         return NOTIFICATION_ERROR_NONE;
 394 }
 395
 396 EXPORT_API notification_error_e notification_set_title(notification_h noti,
 397                                                        const char *title,
 398                                                        const char *loc_title)
 399 {
 400         int noti_err = NOTIFICATION_ERROR_NONE;
 401
 402         noti_err = notification_set_text(noti, NOTIFICATION_TEXT_TYPE_TITLE,
 403                                          title, loc_title,
 404                                          NOTIFICATION_VARIABLE_TYPE_NONE);
 405
 406         return noti_err;
 407 }
 408
 409 EXPORT_API notification_error_e notification_get_title(notification_h noti,
 410                                                        char **title,
 411                                                        char **loc_title)
 412 {
 413         int noti_err = NOTIFICATION_ERROR_NONE;
 414         char *ret_text = NULL;
 415
 416         noti_err =
 417             notification_get_text(noti, NOTIFICATION_TEXT_TYPE_TITLE,
 418                                   &ret_text);
 419
 420         if (title != NULL) {
 421                 *title = ret_text;
 422         }
 423
 424         if (loc_title != NULL) {
 425                 *loc_title = NULL;
 426         }
 427
 428         return noti_err;
 429 }
 430
 431 EXPORT_API notification_error_e notification_set_content(notification_h noti,
 432                                                          const char *content,
 433                                                          const char *loc_content)
 434 {
 435         int noti_err = NOTIFICATION_ERROR_NONE;
 436
 437         noti_err = notification_set_text(noti, NOTIFICATION_TEXT_TYPE_CONTENT,
 438                                          content, loc_content,
 439                                          NOTIFICATION_VARIABLE_TYPE_NONE);
 440
 441         return noti_err;
 442 }
 443
 444 EXPORT_API notification_error_e notification_get_content(notification_h noti,
 445                                                          char **content,
 446                                                          char **loc_content)
 447 {
 448         int noti_err = NOTIFICATION_ERROR_NONE;
 449         char *ret_text = NULL;
 450
 451         noti_err =
 452             notification_get_text(noti, NOTIFICATION_TEXT_TYPE_CONTENT,
 453                                   &ret_text);
 454
 455         if (content != NULL) {
 456                 *content = ret_text;
 457         }
 458
 459         if (loc_content != NULL) {
 460                 *loc_content = NULL;
 461         }
 462
 463         return noti_err;
 464
 465 #if 0
 466         ret =
 467             vconf_get_bool
 468             (VCONFKEY_SETAPPL_STATE_TICKER_NOTI_DISPLAY_CONTENT_BOOL, &boolval);
 469
 470         if (ret == -1 || boolval == 0) {
 471                 if (content != NULL && noti->default_content != NULL) {
 472                         *content = noti->default_content;
 473                 }
 474
 475                 if (loc_content != NULL && noti->loc_default_content != NULL) {
 476                         *loc_content = noti->loc_default_content;
 477                 }
 478         }
 479 #endif
 480 }
 481
 482 EXPORT_API notification_error_e notification_set_text(notification_h noti,
 483                                                       notification_text_type_e type,
 484                                                       const char *text,
 485                                                       const char *key,
 486                                                       int args_type, ...)
 487 {
 488         bundle *b = NULL;
 489         char buf_key[32] = { 0, };
 490         char buf_val[1024] = { 0, };
 491         const char *ret_val = NULL;
 492         va_list var_args;
 493         notification_variable_type_e var_type;
 494         int num_args = 0;
 495         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 496         int var_value_int = 0;
 497         double var_value_double = 0.0;
 498         char *var_value_string = NULL;
 499         notification_count_pos_type_e var_value_count =
 500             NOTIFICATION_COUNT_POS_NONE;
 501
 502         /* Check noti is valid data */
 503         if (noti == NULL) {
 504                 return NOTIFICATION_ERROR_INVALID_DATA;
 505         }
 506
 507         /* Check text type is valid type */
 508         if (type <= NOTIFICATION_TEXT_TYPE_NONE
 509             || type >= NOTIFICATION_TEXT_TYPE_MAX) {
 510                 return NOTIFICATION_ERROR_INVALID_DATA;
 511         }
 512
 513         /* Check text bundle exist */
 514         if (text != NULL) {
 515                 if (noti->b_text != NULL) {
 516                         /* If text bundle exist, store local bundle data */
 517                         b = noti->b_text;
 518
 519                         /* Make type to key as char string */
 520                         snprintf(buf_key, sizeof(buf_key), "%d", type);
 521
 522                         /* Get value using type key */
 523                         ret_val = bundle_get_val(b, buf_key);
 524                         if (ret_val != NULL) {
 525                                 /* If value exist, remove this to add new value */
 526                                 bundle_del(b, buf_key);
 527                         }
 528
 529                         snprintf(buf_val, sizeof(buf_val), "%s", text);
 530
 531                         /* Add new text value */
 532                         bundle_add(b, buf_key, buf_val);
 533                 } else {
 534                         /* If text bundle does not exist, create new one */
 535                         b = bundle_create();
 536
 537                         /* Make type to key as char string */
 538                         snprintf(buf_key, sizeof(buf_key), "%d", type);
 539
 540                         snprintf(buf_val, sizeof(buf_val), "%s", text);
 541
 542                         /* Add new text value */
 543                         bundle_add(b, buf_key, buf_val);
 544
 545                         /* Save text bundle */
 546                         noti->b_text = b;
 547                 }
 548         } else {
 549                 /* Reset if text is NULL */
 550                 if (noti->b_text != NULL) {
 551                         /* If text bundle exist, store local bundle data */
 552                         b = noti->b_text;
 553
 554                         /* Make type to key as char string */
 555                         snprintf(buf_key, sizeof(buf_key), "%d", type);
 556
 557                         /* Get value using type key */
 558                         ret_val = bundle_get_val(b, buf_key);
 559                         if (ret_val != NULL) {
 560                                 /* If value exist, remove this */
 561                                 bundle_del(b, buf_key);
 562                         }
 563                 }
 564         }
 565
 566         /* Save key if key is valid data */
 567         if (key != NULL) {
 568                 /* Check key bundle exist */
 569                 if (noti->b_key != NULL) {
 570                         /* If key bundle exist,  store local bundle data */
 571                         b = noti->b_key;
 572
 573                         /* Make type to key as char string */
 574                         snprintf(buf_key, sizeof(buf_key), "%d", type);
 575
 576                         /* Get value using type key */
 577                         ret_val = bundle_get_val(b, buf_key);
 578                         if (ret_val != NULL) {
 579                                 /* If value exist, remove this to add new value */
 580                                 bundle_del(b, buf_key);
 581                         }
 582
 583                         snprintf(buf_val, sizeof(buf_val), "%s", key);
 584
 585                         /* Add new key value */
 586                         bundle_add(b, buf_key, buf_val);
 587                 } else {
 588                         /* If key bundle does not exist, create new one */
 589                         b = bundle_create();
 590
 591                         /* Make type to key as char string */
 592                         snprintf(buf_key, sizeof(buf_key), "%d", type);
 593
 594                         snprintf(buf_val, sizeof(buf_val), "%s", key);
 595
 596                         /* Add new key value */
 597                         bundle_add(b, buf_key, buf_val);
 598
 599                         /* Save key bundle */
 600                         noti->b_key = b;
 601                 }
 602         } else {
 603                 /* Reset if key is NULL */
 604                 if (noti->b_key != NULL) {
 605                         /* If key bundle exist,  store local bundle data */
 606                         b = noti->b_key;
 607
 608                         /* Make type to key as char string */
 609                         snprintf(buf_key, sizeof(buf_key), "%d", type);
 610
 611                         /* Get value using type key */
 612                         ret_val = bundle_get_val(b, buf_key);
 613                         if (ret_val != NULL) {
 614                                 /* If value exist, remove this */
 615                                 bundle_del(b, buf_key);
 616                         }
 617                 }
 618         }
 619
 620         if (noti->b_format_args != NULL) {
 621                 b = noti->b_format_args;
 622         } else {
 623                 b = bundle_create();
 624         }
 625
 626         va_start(var_args, args_type);
 627
 628         var_type = args_type;
 629         num_args = 0;
 630
 631         while (var_type != NOTIFICATION_VARIABLE_TYPE_NONE) {
 632                 /* Type */
 633                 snprintf(buf_key, sizeof(buf_key), "%dtype%d", type, num_args);
 634                 snprintf(buf_val, sizeof(buf_val), "%d", var_type);
 635
 636                 ret_val = bundle_get_val(b, buf_key);
 637                 if (ret_val != NULL) {
 638                         bundle_del(b, buf_key);
 639                 }
 640
 641                 bundle_add(b, buf_key, buf_val);
 642
 643                 switch (var_type) {
 644                 case NOTIFICATION_VARIABLE_TYPE_INT:
 645                         var_value_int = va_arg(var_args, int);
 646
 647                         /* Value */
 648                         snprintf(buf_key, sizeof(buf_key), "%dvalue%d", type,
 649                                  num_args);
 650                         snprintf(buf_val, sizeof(buf_val), "%d", var_value_int);
 651
 652                         ret_val = bundle_get_val(b, buf_key);
 653                         if (ret_val != NULL) {
 654                                 bundle_del(b, buf_key);
 655                         }
 656
 657                         bundle_add(b, buf_key, buf_val);
 658                         break;
 659                 case NOTIFICATION_VARIABLE_TYPE_DOUBLE:
 660                         var_value_double = va_arg(var_args, double);
 661
 662                         /* Value */
 663                         snprintf(buf_key, sizeof(buf_key), "%dvalue%d", type,
 664                                  num_args);
 665                         snprintf(buf_val, sizeof(buf_val), "%.2f",
 666                                  var_value_double);
 667
 668                         ret_val = bundle_get_val(b, buf_key);
 669                         if (ret_val != NULL) {
 670                                 bundle_del(b, buf_key);
 671                         }
 672
 673                         bundle_add(b, buf_key, buf_val);
 674                         break;
 675                 case NOTIFICATION_VARIABLE_TYPE_STRING:
 676                         var_value_string = va_arg(var_args, char *);
 677
 678                         /* Value */
 679                         snprintf(buf_key, sizeof(buf_key), "%dvalue%d", type,
 680                                  num_args);
 681                         snprintf(buf_val, sizeof(buf_val), "%s",
 682                                  var_value_string);
 683
 684                         ret_val = bundle_get_val(b, buf_key);
 685                         if (ret_val != NULL) {
 686                                 bundle_del(b, buf_key);
 687                         }
 688
 689                         bundle_add(b, buf_key, buf_val);
 690                         break;
 691                 case NOTIFICATION_VARIABLE_TYPE_COUNT:
 692                         var_value_count =
 693                             va_arg(var_args, notification_count_pos_type_e);
 694
 695                         /* Value */
 696                         snprintf(buf_key, sizeof(buf_key), "%dvalue%d", type,
 697                                  num_args);
 698                         snprintf(buf_val, sizeof(buf_val), "%d",
 699                                  var_value_count);
 700
 701                         ret_val = bundle_get_val(b, buf_key);
 702                         if (ret_val != NULL) {
 703                                 bundle_del(b, buf_key);
 704                         }
 705
 706                         bundle_add(b, buf_key, buf_val);
 707                         break;
 708                 default:
 709                         NOTIFICATION_ERR("Error. invalid variable type. : %d",
 710                                          var_type);
 711                         noti_err = NOTIFICATION_ERROR_INVALID_DATA;
 712                         break;
 713                 }
 714
 715                 num_args++;
 716                 var_type = va_arg(var_args, notification_variable_type_e);
 717         }
 718         va_end(var_args);
 719
 720         if (noti_err == NOTIFICATION_ERROR_NONE) {
 721                 noti->num_format_args = num_args;
 722         } else {
 723                 noti->num_format_args = 0;
 724         }
 725
 726         snprintf(buf_key, sizeof(buf_key), "num%d", type);
 727         snprintf(buf_val, sizeof(buf_val), "%d", noti->num_format_args);
 728
 729         ret_val = bundle_get_val(b, buf_key);
 730         if (ret_val != NULL) {
 731                 bundle_del(b, buf_key);
 732         }
 733
 734         bundle_add(b, buf_key, buf_val);
 735
 736         noti->b_format_args = b;
 737
 738         return noti_err;
 739 }
 740
 741 EXPORT_API notification_error_e notification_get_text(notification_h noti,
 742                                                       notification_text_type_e type,
 743                                                       char **text)
 744 {
 745         bundle *b = NULL;
 746         char buf_key[32] = { 0, };
 747         const char *ret_val = NULL;
 748         const char *pkgname = NULL;
 749         const char *get_str = NULL;
 750         const char *get_check_type_str = NULL;
 751         int ret = 0;
 752         int boolval = 0;
 753         notification_text_type_e check_type = NOTIFICATION_TEXT_TYPE_NONE;
 754         int display_option_flag = 0;
 755
 756         char *temp_str = NULL;
 757         char result_str[NOTI_TEXT_RESULT_LEN] = { 0, };
 758         char buf_str[1024] = { 0, };
 759         int num_args = 0;
 760         notification_variable_type_e ret_var_type = 0;
 761         int ret_variable_int = 0;
 762         double ret_variable_double = 0.0;
 763
 764         /* Check noti is valid data */
 765         if (noti == NULL || text == NULL) {
 766                 return NOTIFICATION_ERROR_INVALID_DATA;
 767         }
 768
 769         /* Check text type is valid type */
 770         if (type <= NOTIFICATION_TEXT_TYPE_NONE
 771             || type >= NOTIFICATION_TEXT_TYPE_MAX) {
 772                 return NOTIFICATION_ERROR_INVALID_DATA;
 773         }
 774
 775         /* Check key */
 776         if (noti->b_key != NULL) {
 777                 b = noti->b_key;
 778
 779                 /* Get text domain and dir */
 780                 _notification_get_text_domain(noti);
 781
 782                 snprintf(buf_key, sizeof(buf_key), "%d", type);
 783
 784                 ret_val = bundle_get_val(b, buf_key);
 785                 if (ret_val != NULL && noti->domain != NULL
 786                     && noti->dir != NULL) {
 787                         /* Get application string */
 788                         bindtextdomain(noti->domain, noti->dir);
 789
 790                         get_str = dgettext(noti->domain, ret_val);
 791                 } else if (ret_val != NULL) {
 792                         /* Get system string */
 793                         get_str = dgettext("sys_string", ret_val);
 794                 } else {
 795                         get_str = NULL;
 796                 }
 797         }
 798
 799         if (get_str == NULL && noti->b_text != NULL) {
 800                 b = noti->b_text;
 801                 /* Get basic text */
 802                 snprintf(buf_key, sizeof(buf_key), "%d", type);
 803
 804                 get_str = bundle_get_val(b, buf_key);
 805         }
 806
 807         check_type = type;
 808
 809         /* Set display option is off type when option is off, type is noti */
 810         if (get_str != NULL && display_option_flag == 1
 811             && noti->type == NOTIFICATION_TYPE_NOTI) {
 812                 if (type == NOTIFICATION_TEXT_TYPE_CONTENT
 813                     || type == NOTIFICATION_TEXT_TYPE_GROUP_CONTENT) {
 814                         /* Set check_type to option content string */
 815                         if (type == NOTIFICATION_TEXT_TYPE_CONTENT) {
 816                                 check_type =
 817                                     NOTIFICATION_TEXT_TYPE_CONTENT_FOR_DISPLAY_OPTION_IS_OFF;
 818                         } else if (type == NOTIFICATION_TEXT_TYPE_GROUP_CONTENT) {
 819                                 check_type =
 820                                     NOTIFICATION_TEXT_TYPE_GROUP_CONTENT_FOR_DISPLAY_OPTION_IS_OFF;
 821                         }
 822
 823                         /* Check key */
 824                         if (noti->b_key != NULL) {
 825                                 b = noti->b_key;
 826
 827                                 /* Get text domain and dir */
 828                                 _notification_get_text_domain(noti);
 829
 830                                 snprintf(buf_key, sizeof(buf_key), "%d",
 831                                          check_type);
 832
 833                                 ret_val = bundle_get_val(b, buf_key);
 834                                 if (ret_val != NULL && noti->domain != NULL
 835                                     && noti->dir != NULL) {
 836                                         /* Get application string */
 837                                         bindtextdomain(noti->domain, noti->dir);
 838
 839                                         get_check_type_str =
 840                                             dgettext(noti->domain, ret_val);
 841                                 } else if (ret_val != NULL) {
 842                                         /* Get system string */
 843                                         get_check_type_str =
 844                                             dgettext("sys_string", ret_val);
 845                                 } else {
 846                                         get_check_type_str = NULL;
 847                                 }
 848                         }
 849
 850                         if (get_check_type_str == NULL && noti->b_text != NULL) {
 851                                 b = noti->b_text;
 852                                 /* Get basic text */
 853                                 snprintf(buf_key, sizeof(buf_key), "%d",
 854                                          check_type);
 855
 856                                 get_check_type_str = bundle_get_val(b, buf_key);
 857                         }
 858                 }
 859
 860                 if (get_check_type_str != NULL) {
 861                         /* Replace option off type string */
 862                         get_str = get_check_type_str;
 863                 } else {
 864                         /* Set default string */
 865                         get_str =
 866                             dgettext("sys_string", "IDS_COM_POP_MISSED_EVENT");
 867                 }
 868         }
 869
 870         if (get_str != NULL) {
 871                 /* Get number format args */
 872                 b = noti->b_format_args;
 873                 noti->num_format_args = 0;
 874
 875                 if (b != NULL) {
 876                         snprintf(buf_key, sizeof(buf_key), "num%d", check_type);
 877                         ret_val = bundle_get_val(b, buf_key);
 878                         if (ret_val != NULL) {
 879                                 noti->num_format_args = atoi(ret_val);
 880                         }
 881                 }
 882
 883                 if (noti->num_format_args == 0) {
 884                         *text = (char *)get_str;
 885                 } else {
 886                         /* Check first variable is count, LEFT pos */
 887                         snprintf(buf_key, sizeof(buf_key), "%dtype%d",
 888                                  check_type, num_args);
 889                         ret_val = bundle_get_val(b, buf_key);
 890                         ret_var_type = atoi(ret_val);
 891
 892                         if (ret_var_type == NOTIFICATION_VARIABLE_TYPE_COUNT) {
 893                                 /* Get var Value */
 894                                 snprintf(buf_key, sizeof(buf_key), "%dvalue%d",
 895                                          check_type, num_args);
 896                                 ret_val = bundle_get_val(b, buf_key);
 897                                 ret_variable_int = atoi(ret_val);
 898
 899                                 if (ret_variable_int ==
 900                                     NOTIFICATION_COUNT_POS_LEFT) {
 901                                         notification_noti_get_count(noti->type,
 902                                                                     noti->caller_pkgname,
 903                                                                     noti->group_id,
 904                                                                     noti->priv_id,
 905                                                                     &ret_variable_int);
 906                                         snprintf(buf_str, sizeof(buf_str),
 907                                                  "%d ", ret_variable_int);
 908
 909                                         int src_len = strlen(result_str);
 910                                         int max_len = NOTI_TEXT_RESULT_LEN - src_len - 1;
 911
 912                                         strncat(result_str, buf_str,
 913                                                         max_len);
 914
 915                                         num_args++;
 916                                 }
 917
 918                         }
 919
 920                         /* Check variable IN pos */
 921                         for (temp_str = (char *)get_str; *temp_str != '\0';
 922                              temp_str++) {
 923                                 if (*temp_str != '%') {
 924                                         strncat(result_str, temp_str, 1);
 925                                 } else {
 926                                         if (*(temp_str + 1) == '%') {
 927                                                 strncat(result_str, temp_str,
 928                                                         1);
 929                                         } else if (*(temp_str + 1) == 'd') {
 930                                                 /* Get var Type */
 931                                                 ret_variable_int = 0;
 932
 933                                                 snprintf(buf_key,
 934                                                          sizeof(buf_key),
 935                                                          "%dtype%d", check_type,
 936                                                          num_args);
 937                                                 ret_val =
 938                                                     bundle_get_val(b, buf_key);
 939                                                 ret_var_type = atoi(ret_val);
 940                                                 if (ret_var_type ==
 941                                                     NOTIFICATION_VARIABLE_TYPE_COUNT)
 942                                                 {
 943                                                         /* Get notification count */
 944                                                         notification_noti_get_count
 945                                                             (noti->type,
 946                                                              noti->caller_pkgname,
 947                                                              noti->group_id,
 948                                                              noti->priv_id,
 949                                                              &ret_variable_int);
 950                                                 } else {
 951                                                         /* Get var Value */
 952                                                         snprintf(buf_key,
 953                                                                  sizeof
 954                                                                  (buf_key),
 955                                                                  "%dvalue%d",
 956                                                                  check_type,
 957                                                                  num_args);
 958                                                         ret_val =
 959                                                             bundle_get_val(b,
 960                                                                            buf_key);
 961                                                         ret_variable_int =
 962                                                             atoi(ret_val);
 963                                                 }
 964
 965                                                 snprintf(buf_str,
 966                                                          sizeof(buf_str), "%d",
 967                                                          ret_variable_int);
 968
 969                                                 int src_len = strlen(result_str);
 970                                                 int max_len = NOTI_TEXT_RESULT_LEN - src_len - 1;
 971
 972                                                 strncat(result_str, buf_str,
 973                                                                 max_len);
 974
 975                                                 temp_str++;
 976
 977                                                 num_args++;
 978                                         } else if (*(temp_str + 1) == 's') {
 979                                                 /* Get var Value */
 980                                                 snprintf(buf_key,
 981                                                          sizeof(buf_key),
 982                                                          "%dvalue%d",
 983                                                          check_type, num_args);
 984                                                 ret_val =
 985                                                     bundle_get_val(b, buf_key);
 986
 987                                                 snprintf(buf_str,
 988                                                          sizeof(buf_str), "%s",
 989                                                          ret_val);
 990
 991                                                 int src_len = strlen(result_str);
 992                                                 int max_len = NOTI_TEXT_RESULT_LEN - src_len - 1;
 993
 994                                                 strncat(result_str, buf_str,
 995                                                                 max_len);
 996
 997                                                 temp_str++;
 998
 999                                                 num_args++;
1000                                         } else if (*(temp_str + 1) == 'f') {
1001                                                 /* Get var Value */
1002                                                 snprintf(buf_key,
1003                                                          sizeof(buf_key),
1004                                                          "%dvalue%d",
1005                                                          check_type, num_args);
1006                                                 ret_val =
1007                                                     bundle_get_val(b, buf_key);
1008                                                 ret_variable_double =
1009                                                     atof(ret_val);
1010
1011                                                 snprintf(buf_str,
1012                                                          sizeof(buf_str),
1013                                                          "%.2f",
1014                                                          ret_variable_double);
1015
1016                                                 int src_len = strlen(result_str);
1017                                                 int max_len = NOTI_TEXT_RESULT_LEN - src_len - 1;
1018
1019                                                 strncat(result_str, buf_str,
1020                                                                 max_len);
1021
1022                                                 temp_str++;
1023
1024                                                 num_args++;
1025                                         }
1026                                 }
1027
1028                         }
1029
1030                         /* Check last variable is count, LEFT pos */
1031                         if (num_args < noti->num_format_args) {
1032                                 snprintf(buf_key, sizeof(buf_key), "%dtype%d",
1033                                          check_type, num_args);
1034                                 ret_val = bundle_get_val(b, buf_key);
1035                                 ret_var_type = atoi(ret_val);
1036                                 if (ret_var_type ==
1037                                     NOTIFICATION_VARIABLE_TYPE_COUNT) {
1038                                         /* Get var Value */
1039                                         snprintf(buf_key, sizeof(buf_key),
1040                                                  "%dvalue%d", check_type,
1041                                                  num_args);
1042                                         ret_val = bundle_get_val(b, buf_key);
1043                                         ret_variable_int = atoi(ret_val);
1044
1045                                         if (ret_variable_int ==
1046                                             NOTIFICATION_COUNT_POS_RIGHT) {
1047                                                 notification_noti_get_count
1048                                                     (noti->type,
1049                                                      noti->caller_pkgname,
1050                                                      noti->group_id,
1051                                                      noti->priv_id,
1052                                                      &ret_variable_int);
1053                                                 snprintf(buf_str,
1054                                                          sizeof(buf_str), " %d",
1055                                                          ret_variable_int);
1056
1057                                                 int src_len = strlen(result_str);
1058                                                 int max_len = NOTI_TEXT_RESULT_LEN - src_len - 1;
1059
1060                                                 strncat(result_str, buf_str,
1061                                                                 max_len);
1062
1063                                                 num_args++;
1064                                         }
1065
1066                                 }
1067                         }
1068
1069                         switch (check_type) {
1070                         case NOTIFICATION_TEXT_TYPE_TITLE:
1071                         case NOTIFICATION_TEXT_TYPE_GROUP_TITLE:
1072                                 if (noti->temp_title != NULL)
1073                                         free(noti->temp_title);
1074
1075                                 noti->temp_title = strdup(result_str);
1076
1077                                 *text = noti->temp_title;
1078                                 break;
1079                         case NOTIFICATION_TEXT_TYPE_CONTENT:
1080                         case NOTIFICATION_TEXT_TYPE_CONTENT_FOR_DISPLAY_OPTION_IS_OFF:
1081                         case NOTIFICATION_TEXT_TYPE_GROUP_CONTENT:
1082                         case NOTIFICATION_TEXT_TYPE_GROUP_CONTENT_FOR_DISPLAY_OPTION_IS_OFF:
1083                                 if (noti->temp_content !=
1084                                     NULL)
1085                                         free(noti->temp_content);
1086
1087                                 noti->temp_content = strdup(result_str);
1088
1089                                 *text = noti->temp_content;
1090                                 break;
1091                         default:
1092                                 break;
1093                         }
1094
1095                 }
1096
1097         } else {
1098                 if (check_type == NOTIFICATION_TEXT_TYPE_TITLE
1099                     || check_type == NOTIFICATION_TEXT_TYPE_GROUP_TITLE) {
1100                         /* Remove app name if exist, because pkgname is changed according to language setting */
1101                         if (noti->app_name != NULL) {
1102                                 free(noti->app_name);
1103                                 noti->app_name = NULL;
1104                         }
1105
1106                         /* First, get app name from launch_pkgname */
1107                         if (noti->launch_pkgname != NULL) {
1108                                 noti->app_name =
1109                                     _notification_get_name(noti->
1110                                                            launch_pkgname);
1111                         }
1112
1113                         /* Second, get app name from caller_pkgname */
1114                         if (noti->app_name == NULL
1115                             && noti->caller_pkgname != NULL) {
1116                                 noti->app_name =
1117                                     _notification_get_name(noti->
1118                                                            caller_pkgname);
1119                         }
1120
1121                         /* Third, get app name from service data */
1122                         if (noti->app_name == NULL
1123                             && noti->b_service_single_launch != NULL) {
1124                                 pkgname =
1125                                     appsvc_get_pkgname(noti->
1126                                                        b_service_single_launch);
1127
1128                                 if (pkgname != NULL) {
1129                                         noti->app_name =
1130                                             _notification_get_name(pkgname);
1131                                 }
1132                         }
1133
1134                         *text = noti->app_name;
1135                 } else {
1136                         *text = NULL;
1137                 }
1138         }
1139
1140         return NOTIFICATION_ERROR_NONE;
1141 }
1142
1143 EXPORT_API notification_error_e notification_set_text_domain(notification_h noti,
1144                                                              const char *domain,
1145                                                              const char *dir)
1146 {
1147         /* check noti and domain is valid data */
1148         if (noti == NULL || domain == NULL) {
1149                 return NOTIFICATION_ERROR_INVALID_DATA;
1150         }
1151
1152         /* Check domain */
1153         if (noti->domain) {
1154                 /* Remove previous domain */
1155                 free(noti->domain);
1156         }
1157         /* Copy domain */
1158         noti->domain = strdup(domain);
1159
1160         /* Check locale dir */
1161         if (noti->dir) {
1162                 /* Remove previous locale dir */
1163                 free(noti->dir);
1164         }
1165         /* Copy locale dir */
1166         noti->dir = strdup(dir);
1167
1168         return NOTIFICATION_ERROR_NONE;
1169 }
1170
1171 EXPORT_API notification_error_e notification_get_text_domain(notification_h noti,
1172                                                              char **domain,
1173                                                              char **dir)
1174 {
1175         /* Check noti is valid data */
1176         if (noti == NULL) {
1177                 return NOTIFICATION_ERROR_INVALID_DATA;
1178         }
1179
1180         /* Get domain */
1181         if (domain != NULL && noti->domain != NULL) {
1182                 *domain = noti->domain;
1183         }
1184
1185         /* Get locale dir */
1186         if (dir != NULL && noti->dir != NULL) {
1187                 *dir = noti->dir;
1188         }
1189
1190         return NOTIFICATION_ERROR_NONE;
1191 }
1192
1193 EXPORT_API notification_error_e notification_set_time_to_text(notification_h noti, notification_text_type_e type,
1194                                                                 time_t time)
1195 {
1196         notification_error_e ret = NOTIFICATION_ERROR_NONE;
1197         char buf[256] = { 0, };
1198         char buf_tag[512] = { 0, };
1199
1200         if (noti == NULL) {
1201                 return NOTIFICATION_ERROR_INVALID_DATA;
1202         }
1203         if (time <= 0) {
1204                 return NOTIFICATION_ERROR_INVALID_DATA;
1205         }
1206
1207         snprintf(buf, sizeof(buf), "%lu", time);
1208         ret = notification_noti_set_tag(TAG_TIME, buf, buf_tag, sizeof(buf_tag));
1209
1210         if (ret != NOTIFICATION_ERROR_NONE) {
1211                 return ret;
1212         }
1213
1214         return notification_set_text(noti, type, buf_tag, NULL, NOTIFICATION_VARIABLE_TYPE_NONE);
1215 }
1216
1217 EXPORT_API notification_error_e notification_get_time_from_text(notification_h noti, notification_text_type_e type,
1218                                                                 time_t *time)
1219 {
1220         notification_error_e ret = NOTIFICATION_ERROR_NONE;
1221         char buf[256] = { 0, };
1222         char buf_tag[512] = { 0, };
1223
1224         if (noti == NULL) {
1225                 return NOTIFICATION_ERROR_INVALID_DATA;
1226         }
1227         if (time == NULL) {
1228                 return NOTIFICATION_ERROR_INVALID_DATA;
1229         }
1230
1231         char *ret_text = NULL;
1232         ret = notification_get_text(noti, type, &ret_text);
1233
1234         if (ret != NOTIFICATION_ERROR_NONE || ret_text == NULL) {
1235                 return NOTIFICATION_ERROR_INVALID_DATA;
1236         }
1237
1238         if (notification_noti_get_tag_type(ret_text) == TAG_TYPE_INVALID) {
1239                 return NOTIFICATION_ERROR_INVALID_DATA;
1240         }
1241
1242         char *tag_value = NULL;
1243         tag_value = notification_noti_strip_tag(ret_text);
1244         if (tag_value == NULL) {
1245                 return NOTIFICATION_ERROR_INVALID_DATA;
1246         }
1247
1248         *time = atol(tag_value);
1249         free(tag_value);
1250
1251         return NOTIFICATION_ERROR_NONE;
1252 }
1253
1254 EXPORT_API notification_error_e notification_set_sound(notification_h noti,
1255                                                        notification_sound_type_e type,
1256                                                        const char *path)
1257 {
1258         /* Check noti is valid data */
1259         if (noti == NULL) {
1260                 return NOTIFICATION_ERROR_INVALID_DATA;
1261         }
1262
1263         /* Check type is valid */
1264         if (type < NOTIFICATION_SOUND_TYPE_NONE
1265             || type >= NOTIFICATION_SOUND_TYPE_MAX) {
1266                 return NOTIFICATION_ERROR_INVALID_DATA;
1267         }
1268
1269         /* Save sound type */
1270         noti->sound_type = type;
1271
1272         /* Save sound path if user data type */
1273         if (type == NOTIFICATION_SOUND_TYPE_USER_DATA && path != NULL) {
1274                 if (noti->sound_path != NULL) {
1275                         free(noti->sound_path);
1276                 }
1277
1278                 noti->sound_path = strdup(path);
1279         } else {
1280                 if (noti->sound_path != NULL) {
1281                         free(noti->sound_path);
1282                         noti->sound_path = NULL;
1283                 }
1284         }
1285
1286         return NOTIFICATION_ERROR_NONE;
1287 }
1288
1289 EXPORT_API notification_error_e notification_get_sound(notification_h noti,
1290                                                        notification_sound_type_e *type,
1291                                                        const char **path)
1292 {
1293         /* check noti and type is valid data */
1294         if (noti == NULL || type == NULL) {
1295                 return NOTIFICATION_ERROR_INVALID_DATA;
1296         }
1297
1298         /* Set sound type */
1299         *type = noti->sound_type;
1300
1301         /* Set sound path if user data type */
1302         if (noti->sound_type == NOTIFICATION_SOUND_TYPE_USER_DATA
1303             && path != NULL) {
1304                 *path = noti->sound_path;
1305         }
1306
1307         return NOTIFICATION_ERROR_NONE;
1308 }
1309
1310 EXPORT_API notification_error_e notification_set_vibration(notification_h noti,
1311                                                            notification_vibration_type_e type,
1312                                                            const char *path)
1313 {
1314         /* Check noti is valid data */
1315         if (noti == NULL) {
1316                 return NOTIFICATION_ERROR_INVALID_DATA;
1317         }
1318
1319         /* Check type is valid */
1320         if (type < NOTIFICATION_VIBRATION_TYPE_NONE
1321             || type >= NOTIFICATION_VIBRATION_TYPE_MAX) {
1322                 return NOTIFICATION_ERROR_INVALID_DATA;
1323         }
1324
1325         /* Save vibration type */
1326         noti->vibration_type = type;
1327
1328         /* Save sound path if user data type */
1329         if (type == NOTIFICATION_VIBRATION_TYPE_USER_DATA && path != NULL) {
1330                 if (noti->vibration_path != NULL) {
1331                         free(noti->vibration_path);
1332                 }
1333
1334                 noti->vibration_path = strdup(path);
1335         } else {
1336                 if (noti->vibration_path != NULL) {
1337                         free(noti->vibration_path);
1338                         noti->vibration_path = NULL;
1339                 }
1340         }
1341
1342         return NOTIFICATION_ERROR_NONE;
1343
1344 }
1345
1346 EXPORT_API notification_error_e notification_get_vibration(notification_h noti,
1347                                                            notification_vibration_type_e *type,
1348                                                            const char **path)
1349 {
1350         /* check noti and type is valid data */
1351         if (noti == NULL || type == NULL) {
1352                 return NOTIFICATION_ERROR_INVALID_DATA;
1353         }
1354
1355         /* Set vibration type */
1356         *type = noti->vibration_type;
1357
1358         /* Set sound path if user data type */
1359         if (noti->vibration_type == NOTIFICATION_VIBRATION_TYPE_USER_DATA
1360             && path != NULL) {
1361                 *path = noti->vibration_path;
1362         }
1363
1364         return NOTIFICATION_ERROR_NONE;
1365 }
1366
1367 EXPORT_API notification_error_e notification_set_led(notification_h noti,
1368                                                            notification_led_op_e operation,
1369                                                            int led_argb)
1370 {
1371         /* Check noti is valid data */
1372         if (noti == NULL) {
1373                 return NOTIFICATION_ERROR_INVALID_DATA;
1374         }
1375
1376         /* Check operation is valid */
1377         if (operation < NOTIFICATION_LED_OP_OFF
1378             || operation >= NOTIFICATION_LED_OP_MAX) {
1379                 return NOTIFICATION_ERROR_INVALID_DATA;
1380         }
1381
1382         /* Save led operation */
1383         noti->led_operation = operation;
1384
1385         /* Save led argb if operation is turning on LED with custom color */
1386         if (operation == NOTIFICATION_LED_OP_ON_CUSTOM_COLOR) {
1387                 noti->led_argb = led_argb;
1388         }
1389
1390         return NOTIFICATION_ERROR_NONE;
1391 }
1392
1393 EXPORT_API notification_error_e notification_get_led(notification_h noti,
1394                                                            notification_led_op_e *operation,
1395                                                            int *led_argb)
1396 {
1397         /* check noti and operation is valid data */
1398         if (noti == NULL || operation == NULL) {
1399                 return NOTIFICATION_ERROR_INVALID_DATA;
1400         }
1401
1402         /* Set led operation */
1403         *operation = noti->led_operation;
1404
1405         /* Save led argb if operation is turning on LED with custom color */
1406         if (noti->led_operation == NOTIFICATION_LED_OP_ON_CUSTOM_COLOR
1407             && led_argb != NULL) {
1408                 *led_argb = noti->led_argb;
1409         }
1410
1411         return NOTIFICATION_ERROR_NONE;
1412 }
1413
1414 EXPORT_API notification_error_e notification_set_led_time_period(notification_h noti,
1415                                                                         int on_ms, int off_ms)
1416 {
1417         /* Check noti is valid data */
1418         if (noti == NULL) {
1419                 return NOTIFICATION_ERROR_INVALID_DATA;
1420         }
1421
1422         /* Save led operation */
1423         noti->led_on_ms = on_ms;
1424         noti->led_off_ms = off_ms;
1425
1426         return NOTIFICATION_ERROR_NONE;
1427 }
1428
1429 EXPORT_API notification_error_e notification_get_led_time_period(notification_h noti,
1430                                                                         int *on_ms, int *off_ms)
1431 {
1432         /* check noti and operation is valid data */
1433         if (noti == NULL) {
1434                 return NOTIFICATION_ERROR_INVALID_DATA;
1435         }
1436
1437         /* Check noti is valid data */
1438         if (noti == NULL) {
1439                 return NOTIFICATION_ERROR_INVALID_DATA;
1440         }
1441
1442         if (on_ms)
1443                 *(on_ms) = noti->led_on_ms;
1444         if (off_ms)
1445                 *(off_ms) = noti->led_off_ms;
1446
1447         return NOTIFICATION_ERROR_NONE;
1448 }
1449
1450 EXPORT_API notification_error_e notification_set_application(notification_h noti,
1451                                                              const char *pkgname)
1452 {
1453         if (noti == NULL || pkgname == NULL) {
1454                 return NOTIFICATION_ERROR_INVALID_DATA;
1455         }
1456
1457         if (noti->launch_pkgname) {
1458                 free(noti->launch_pkgname);
1459         }
1460
1461         noti->launch_pkgname = strdup(pkgname);
1462
1463         return NOTIFICATION_ERROR_NONE;
1464 }
1465
1466 EXPORT_API notification_error_e notification_get_application(notification_h noti,
1467                                                              char **pkgname)
1468 {
1469         if (noti == NULL || pkgname == NULL) {
1470                 return NOTIFICATION_ERROR_INVALID_DATA;
1471         }
1472
1473         if (noti->launch_pkgname) {
1474                 *pkgname = noti->launch_pkgname;
1475         } else {
1476                 *pkgname = noti->caller_pkgname;
1477         }
1478
1479         return NOTIFICATION_ERROR_NONE;
1480 }
1481
1482 EXPORT_API notification_error_e notification_set_args(notification_h noti,
1483                                                       bundle * args,
1484                                                       bundle * group_args)
1485 {
1486         if (noti == NULL || args == NULL) {
1487                 return NOTIFICATION_ERROR_INVALID_DATA;
1488         }
1489
1490         if (noti->args) {
1491                 bundle_free(noti->args);
1492         }
1493
1494         noti->args = bundle_dup(args);
1495
1496         if (noti->group_args) {
1497                 bundle_free(noti->group_args);
1498                 noti->group_args = NULL;
1499         }
1500
1501         if (group_args != NULL) {
1502                 noti->group_args = bundle_dup(group_args);
1503         }
1504
1505         return NOTIFICATION_ERROR_NONE;
1506 }
1507
1508 EXPORT_API notification_error_e notification_get_args(notification_h noti,
1509                                                       bundle ** args,
1510                                                       bundle ** group_args)
1511 {
1512         if (noti == NULL || args == NULL) {
1513                 return NOTIFICATION_ERROR_INVALID_DATA;
1514         }
1515
1516         if (noti->args) {
1517                 *args = noti->args;
1518         } else {
1519                 *args = NULL;
1520         }
1521
1522         if (group_args != NULL && noti->group_args) {
1523                 *group_args = noti->group_args;
1524         }
1525
1526         return NOTIFICATION_ERROR_NONE;
1527 }
1528
1529 EXPORT_API notification_error_e notification_set_execute_option(notification_h noti,
1530                                                                 notification_execute_type_e type,
1531                                                                 const char *text,
1532                                                                 const char *key,
1533                                                                 bundle *service_handle)
1534 {
1535         char buf_key[32] = { 0, };
1536         const char *ret_val = NULL;
1537         bundle *b = NULL;
1538
1539         if (noti == NULL) {
1540                 return NOTIFICATION_ERROR_INVALID_DATA;
1541         }
1542
1543         if (type <= NOTIFICATION_EXECUTE_TYPE_NONE
1544             || type >= NOTIFICATION_EXECUTE_TYPE_MAX) {
1545                 return NOTIFICATION_ERROR_INVALID_DATA;
1546         }
1547
1548         /* Create execute option bundle if does not exist */
1549         if (noti->b_execute_option != NULL) {
1550                 noti->b_execute_option = bundle_create();
1551         }
1552
1553         b = noti->b_execute_option;
1554
1555         /* Save text */
1556         if (text != NULL) {
1557                 /* Make text key */
1558                 snprintf(buf_key, sizeof(buf_key), "text%d", type);
1559
1560                 /* Check text key exist */
1561                 ret_val = bundle_get_val(b, buf_key);
1562                 if (ret_val != NULL) {
1563                         /* Remove previous data */
1564                         bundle_del(b, buf_key);
1565                 }
1566
1567                 /* Add text data */
1568                 bundle_add(b, buf_key, text);
1569         }
1570
1571         /* Save key */
1572         if (key != NULL) {
1573                 /* Make key key */
1574                 snprintf(buf_key, sizeof(buf_key), "key%d", type);
1575
1576                 /* Check key key exist */
1577                 ret_val = bundle_get_val(b, buf_key);
1578                 if (ret_val != NULL) {
1579                         /* Remove previous data */
1580                         bundle_del(b, buf_key);
1581                 }
1582
1583                 /* Add text data */
1584                 bundle_add(b, buf_key, key);
1585         }
1586
1587         switch (type) {
1588         case NOTIFICATION_EXECUTE_TYPE_RESPONDING:
1589                 /* Remove previous data if exist */
1590                 if (noti->b_service_responding != NULL) {
1591                         bundle_free(noti->b_service_responding);
1592                         noti->b_service_responding = NULL;
1593                 }
1594
1595                 /* Save service handle */
1596                 if (service_handle != NULL) {
1597                         noti->b_service_responding = bundle_dup(service_handle);
1598                 }
1599                 break;
1600         case NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH:
1601                 /* Remove previous data if exist */
1602                 if (noti->b_service_single_launch != NULL) {
1603                         bundle_free(noti->b_service_single_launch);
1604                         noti->b_service_single_launch = NULL;
1605                 }
1606
1607                 /* Save service handle */
1608                 if (service_handle != NULL) {
1609                         noti->b_service_single_launch =
1610                             bundle_dup(service_handle);
1611                 }
1612                 break;
1613         case NOTIFICATION_EXECUTE_TYPE_MULTI_LAUNCH:
1614                 /* Remove previous data if exist */
1615                 if (noti->b_service_multi_launch != NULL) {
1616                         bundle_free(noti->b_service_multi_launch);
1617                         noti->b_service_multi_launch = NULL;
1618                 }
1619
1620                 /* Save service handle */
1621                 if (service_handle != NULL) {
1622                         noti->b_service_multi_launch =
1623                             bundle_dup(service_handle);
1624                 }
1625                 break;
1626         }
1627
1628         return NOTIFICATION_ERROR_NONE;
1629 }
1630
1631 EXPORT_API notification_error_e notification_get_execute_option(notification_h noti,
1632                                                                 notification_execute_type_e type,
1633                                                                 const char **text,
1634                                                                 bundle **service_handle)
1635 {
1636         char buf_key[32] = { 0, };
1637         const char *ret_val = NULL;
1638         char *get_str = NULL;
1639         bundle *b = NULL;
1640
1641         if (noti == NULL) {
1642                 return NOTIFICATION_ERROR_INVALID_DATA;
1643         }
1644
1645         if (type <= NOTIFICATION_EXECUTE_TYPE_NONE
1646             || type >= NOTIFICATION_EXECUTE_TYPE_MAX) {
1647                 return NOTIFICATION_ERROR_INVALID_DATA;
1648         }
1649
1650         switch (type) {
1651         case NOTIFICATION_EXECUTE_TYPE_RESPONDING:
1652                 b = noti->b_service_responding;
1653                 break;
1654         case NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH:
1655                 b = noti->b_service_single_launch;
1656                 break;
1657         case NOTIFICATION_EXECUTE_TYPE_MULTI_LAUNCH:
1658                 b = noti->b_service_multi_launch;
1659                 break;
1660         default:
1661                 b = NULL;
1662                 break;
1663         }
1664
1665         if (b != NULL) {
1666                 // Return text
1667                 if (text != NULL) {
1668                         // Get text domain and dir
1669                         if (noti->domain == NULL || noti->dir == NULL) {
1670                                 _notification_get_text_domain(noti);
1671                         }
1672
1673                         /* Make key */
1674                         snprintf(buf_key, sizeof(buf_key), "key%d", type);
1675
1676                         /* Check key key exist */
1677                         ret_val = bundle_get_val(b, buf_key);
1678                         if (ret_val != NULL && noti->domain != NULL
1679                             && noti->dir != NULL) {
1680                                 /* Get application string */
1681                                 bindtextdomain(noti->domain, noti->dir);
1682
1683                                 get_str = dgettext(noti->domain, ret_val);
1684
1685                                 *text = get_str;
1686                         } else if (ret_val != NULL) {
1687                                 /* Get system string */
1688                                 get_str = dgettext("sys_string", ret_val);
1689
1690                                 *text = get_str;
1691                         } else {
1692                                 /* Get basic text */
1693                                 snprintf(buf_key, sizeof(buf_key), "text%d",
1694                                          type);
1695
1696                                 ret_val = bundle_get_val(b, buf_key);
1697
1698                                 *text = ret_val;
1699                         }
1700                 }
1701         }
1702
1703         switch (type) {
1704         case NOTIFICATION_EXECUTE_TYPE_RESPONDING:
1705                 b = noti->b_service_responding;
1706                 break;
1707         case NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH:
1708                 b = noti->b_service_single_launch;
1709                 break;
1710         case NOTIFICATION_EXECUTE_TYPE_MULTI_LAUNCH:
1711                 b = noti->b_service_multi_launch;
1712                 break;
1713         default:
1714                 b = NULL;
1715                 break;
1716         }
1717
1718         if (service_handle != NULL) {
1719                 *service_handle = b;
1720         }
1721
1722         return NOTIFICATION_ERROR_NONE;
1723 }
1724
1725 EXPORT_API notification_error_e notification_set_property(notification_h noti,
1726                                                           int flags)
1727 {
1728         /* Check noti is valid data */
1729         if (noti == NULL) {
1730                 return NOTIFICATION_ERROR_INVALID_DATA;
1731         }
1732
1733         /* Set flags */
1734         noti->flags_for_property = flags;
1735
1736         return NOTIFICATION_ERROR_NONE;
1737 }
1738
1739 EXPORT_API notification_error_e notification_get_property(notification_h noti,
1740                                                           int *flags)
1741 {
1742         /* Check noti and flags are valid data */
1743         if (noti == NULL || flags == NULL) {
1744                 return NOTIFICATION_ERROR_INVALID_DATA;
1745         }
1746
1747         /* Set flags */
1748         *flags = noti->flags_for_property;
1749
1750         return NOTIFICATION_ERROR_NONE;
1751 }
1752
1753 EXPORT_API notification_error_e notification_set_display_applist(notification_h noti,
1754                                                                  int applist)
1755 {
1756         /* Check noti is valid data */
1757         if (noti == NULL) {
1758                 return NOTIFICATION_ERROR_INVALID_DATA;
1759         }
1760
1761         /* Set app list */
1762         noti->display_applist = applist;
1763
1764         return NOTIFICATION_ERROR_NONE;
1765 }
1766
1767 EXPORT_API notification_error_e notification_get_display_applist(notification_h noti,
1768                                                                  int *applist)
1769 {
1770         /* Check noti and applist are valid data */
1771         if (noti == NULL || applist == NULL) {
1772                 return NOTIFICATION_ERROR_INVALID_DATA;
1773         }
1774
1775         /* Set app list */
1776         *applist = noti->display_applist;
1777
1778         return NOTIFICATION_ERROR_NONE;
1779 }
1780
1781 EXPORT_API notification_error_e notification_set_size(notification_h noti,
1782                                                       double size)
1783 {
1784         /* Check noti is valid data */
1785         if (noti == NULL) {
1786                 return NOTIFICATION_ERROR_INVALID_DATA;
1787         }
1788
1789         /* Save progress size */
1790         noti->progress_size = size;
1791
1792         return NOTIFICATION_ERROR_NONE;
1793 }
1794
1795 EXPORT_API notification_error_e notification_get_size(notification_h noti,
1796                                                       double *size)
1797 {
1798         /* Check noti and size is valid data */
1799         if (noti == NULL || size == NULL) {
1800                 return NOTIFICATION_ERROR_INVALID_DATA;
1801         }
1802
1803         /* Set progress size */
1804         *size = noti->progress_size;
1805
1806         return NOTIFICATION_ERROR_NONE;
1807 }
1808
1809 EXPORT_API notification_error_e notification_set_progress(notification_h noti,
1810                                                           double percentage)
1811 {
1812         /* Check noti is valid data */
1813         if (noti == NULL) {
1814                 return NOTIFICATION_ERROR_INVALID_DATA;
1815         }
1816
1817         /* Save progress percentage */
1818         noti->progress_percentage = percentage;
1819
1820         return NOTIFICATION_ERROR_NONE;
1821 }
1822
1823 EXPORT_API notification_error_e notification_get_progress(notification_h noti,
1824                                                           double *percentage)
1825 {
1826         /* Check noti and percentage are valid data */
1827         if (noti == NULL || percentage == NULL) {
1828                 return NOTIFICATION_ERROR_INVALID_DATA;
1829         }
1830
1831         /* Set progress percentage */
1832         *percentage = noti->progress_percentage;
1833
1834         return NOTIFICATION_ERROR_NONE;
1835 }
1836
1837 EXPORT_API notification_error_e notification_set_pkgname(notification_h noti,
1838                                                          const char *pkgname)
1839 {
1840         /* check noti and pkgname are valid data */
1841         if (noti == NULL || pkgname == NULL) {
1842                 return NOTIFICATION_ERROR_INVALID_DATA;
1843         }
1844
1845         /* Remove previous caller pkgname */
1846         if (noti->caller_pkgname) {
1847                 free(noti->caller_pkgname);
1848                 noti->caller_pkgname = NULL;
1849         }
1850
1851         noti->caller_pkgname = strdup(pkgname);
1852
1853         return NOTIFICATION_ERROR_NONE;
1854 }
1855
1856 EXPORT_API notification_error_e notification_get_pkgname(notification_h noti,
1857                                                          char **pkgname)
1858 {
1859         /* Check noti and pkgname are valid data */
1860         if (noti == NULL || pkgname == NULL) {
1861                 return NOTIFICATION_ERROR_INVALID_DATA;
1862         }
1863
1864         /* Get caller pkgname */
1865         if (noti->caller_pkgname) {
1866                 *pkgname = noti->caller_pkgname;
1867         } else {
1868                 *pkgname = NULL;
1869         }
1870
1871         return NOTIFICATION_ERROR_NONE;
1872 }
1873
1874 EXPORT_API notification_error_e notification_set_layout(notification_h noti,
1875                 notification_ly_type_e layout)
1876 {
1877         /* check noti and pkgname are valid data */
1878         if (noti == NULL || (layout < NOTIFICATION_LY_NONE || layout >= NOTIFICATION_LY_MAX)) {
1879                 return NOTIFICATION_ERROR_INVALID_DATA;
1880         }
1881
1882         noti->layout = layout;
1883
1884         return NOTIFICATION_ERROR_NONE;
1885 }
1886
1887 EXPORT_API notification_error_e notification_get_layout(notification_h noti,
1888                 notification_ly_type_e *layout)
1889 {
1890         /* Check noti and pkgname are valid data */
1891         if (noti == NULL || layout == NULL) {
1892                 return NOTIFICATION_ERROR_INVALID_DATA;
1893         }
1894
1895         *layout = noti->layout;
1896
1897         return NOTIFICATION_ERROR_NONE;
1898 }
1899
1900 EXPORT_API notification_error_e notification_set_badge(const char *pkgname,
1901                                                        int group_id, int count)
1902 {
1903         char *caller_pkgname = NULL;
1904         int ret = NOTIFICATION_ERROR_NONE;
1905
1906         /* Check count is valid count */
1907         if (count < 0) {
1908                 return NOTIFICATION_ERROR_INVALID_DATA;
1909         }
1910
1911         /* Check pkgname */
1912         if (pkgname == NULL) {
1913                 caller_pkgname = _notification_get_pkgname_by_pid();
1914
1915                 /* Set count into Group DB */
1916                 ret =
1917                     notification_group_set_badge(caller_pkgname, group_id,
1918                                                  count);
1919
1920                 if (caller_pkgname != NULL) {
1921                         free(caller_pkgname);
1922                 }
1923         } else {
1924                 /* Set count into Group DB */
1925                 ret = notification_group_set_badge(pkgname, group_id, count);
1926         }
1927
1928         return ret;
1929 }
1930
1931 EXPORT_API notification_error_e notification_get_badge(const char *pkgname,
1932                                                        int group_id, int *count)
1933 {
1934         char *caller_pkgname = NULL;
1935         int ret = NOTIFICATION_ERROR_NONE;
1936         int ret_unread_count = 0;
1937
1938         /* Check pkgname */
1939         if (pkgname == NULL) {
1940                 caller_pkgname = _notification_get_pkgname_by_pid();
1941
1942                 /* Get count from Group DB */
1943                 ret =
1944                     notification_group_get_badge(caller_pkgname, group_id,
1945                                                  &ret_unread_count);
1946
1947                 if (caller_pkgname != NULL) {
1948                         free(caller_pkgname);
1949                 }
1950         } else {
1951                 /* Get count from Group DB */
1952                 ret =
1953                     notification_group_get_badge(pkgname, group_id,
1954                                                  &ret_unread_count);
1955         }
1956
1957         if (ret != NOTIFICATION_ERROR_NONE) {
1958                 return ret;
1959         }
1960
1961         /* Set count */
1962         if (count != NULL) {
1963                 *count = ret_unread_count;
1964         }
1965
1966         return NOTIFICATION_ERROR_NONE;
1967 }
1968
1969 EXPORT_API notification_error_e notification_get_id(notification_h noti,
1970                                                     int *group_id, int *priv_id)
1971 {
1972         /* check noti is valid data */
1973         if (noti == NULL) {
1974                 return NOTIFICATION_ERROR_INVALID_DATA;
1975         }
1976
1977         /* Check group_id is valid data */
1978         if (group_id) {
1979                 /* Set group id */
1980                 if (noti->group_id < NOTIFICATION_GROUP_ID_NONE) {
1981                         *group_id = NOTIFICATION_GROUP_ID_NONE;
1982                 } else {
1983                         *group_id = noti->group_id;
1984                 }
1985         }
1986
1987         /* Check priv_id is valid data */
1988         if (priv_id) {
1989                 /* Set priv_id */
1990                 *priv_id = noti->priv_id;
1991         }
1992
1993         return NOTIFICATION_ERROR_NONE;
1994 }
1995
1996 EXPORT_API notification_error_e notification_get_type(notification_h noti,
1997                                                       notification_type_e *type)
1998 {
1999         /* Check noti and type is valid data */
2000         if (noti == NULL || type == NULL) {
2001                 return NOTIFICATION_ERROR_INVALID_DATA;
2002         }
2003
2004         /* Set noti type */
2005         *type = noti->type;
2006
2007         return NOTIFICATION_ERROR_NONE;
2008 }
2009
2010 EXPORT_API notification_error_e notification_insert(notification_h noti,
2011                                                     int *priv_id)
2012 {
2013         int ret = 0;
2014         int id = 0;
2015
2016         /* Check noti is vaild data */
2017         if (noti == NULL) {
2018                 return NOTIFICATION_ERROR_INVALID_DATA;
2019         }
2020
2021         /* Check noti type is valid type */
2022         if (noti->type <= NOTIFICATION_TYPE_NONE
2023             || noti->type >= NOTIFICATION_TYPE_MAX) {
2024                 return NOTIFICATION_ERROR_INVALID_DATA;
2025         }
2026
2027         /* Save insert time */
2028         noti->insert_time = time(NULL);
2029         ret = notification_ipc_request_insert(noti, &id);
2030         if (ret != NOTIFICATION_ERROR_NONE) {
2031                 return ret;
2032         }
2033         noti->priv_id = id;
2034         NOTIFICATION_DBG("from master:%d", id);
2035
2036         /* If priv_id is valid data, set priv_id */
2037         if (priv_id != NULL) {
2038                 *priv_id = noti->priv_id;
2039         }
2040
2041         return NOTIFICATION_ERROR_NONE;
2042 }
2043
2044 EXPORT_API notification_error_e notification_update(notification_h noti)
2045 {
2046         int ret = 0;
2047
2048         /* Check noti is valid data */
2049         if (noti != NULL) {
2050                 /* Update insert time ? */
2051                 noti->insert_time = time(NULL);
2052                 ret = notification_ipc_request_update(noti);
2053                 if (ret != NOTIFICATION_ERROR_NONE) {
2054                         return ret;
2055                 }
2056         } else {
2057                 ret = notification_ipc_request_refresh();
2058                 if (ret != NOTIFICATION_ERROR_NONE) {
2059                         return ret;
2060                 }
2061         }
2062         return NOTIFICATION_ERROR_NONE;
2063 }
2064
2065 EXPORT_API notification_error_e notifiation_clear(notification_type_e type)
2066 {
2067         int ret = 0;
2068
2069         ret = notification_ipc_request_delete_multiple(type, NULL);
2070         if (ret != NOTIFICATION_ERROR_NONE) {
2071                 return ret;
2072         }
2073
2074         return NOTIFICATION_ERROR_NONE;
2075 }
2076
2077 EXPORT_API notification_error_e notification_delete_all_by_type(const char *pkgname,
2078                                                                 notification_type_e type)
2079 {
2080         int ret = 0;
2081         char *caller_pkgname = NULL;
2082
2083         if (pkgname == NULL) {
2084                 caller_pkgname = _notification_get_pkgname_by_pid();
2085         } else {
2086                 caller_pkgname = strdup(pkgname);
2087         }
2088
2089         ret = notification_ipc_request_delete_multiple(type, caller_pkgname);
2090         if (ret != NOTIFICATION_ERROR_NONE) {
2091                 return ret;
2092         }
2093
2094         if (caller_pkgname) {
2095                 free(caller_pkgname);
2096         }
2097         return NOTIFICATION_ERROR_NONE;
2098 }
2099
2100 EXPORT_API notification_error_e notification_delete_group_by_group_id(const char *pkgname,
2101                                                                       notification_type_e type,
2102                                                                       int group_id)
2103 {
2104         int ret = 0;
2105         char *caller_pkgname = NULL;
2106
2107         if (pkgname == NULL) {
2108                 caller_pkgname = _notification_get_pkgname_by_pid();
2109         } else {
2110                 caller_pkgname = strdup(pkgname);
2111         }
2112
2113         ret = notification_ipc_request_delete_multiple(type, caller_pkgname);
2114         if (ret != NOTIFICATION_ERROR_NONE) {
2115                 return ret;
2116         }
2117
2118         if (caller_pkgname) {
2119                 free(caller_pkgname);
2120         }
2121         return NOTIFICATION_ERROR_NONE;
2122 }
2123
2124 EXPORT_API notification_error_e notification_delete_group_by_priv_id(const char *pkgname,
2125                                                                      notification_type_e type,
2126                                                                      int priv_id)
2127 {
2128         int ret = 0;
2129         char *caller_pkgname = NULL;
2130
2131         if (pkgname == NULL) {
2132                 caller_pkgname = _notification_get_pkgname_by_pid();
2133         } else {
2134                 caller_pkgname = strdup(pkgname);
2135         }
2136
2137         ret = notification_ipc_request_delete_single(type, caller_pkgname, priv_id);
2138         if (ret != NOTIFICATION_ERROR_NONE) {
2139                 return ret;
2140         }
2141
2142         if (caller_pkgname) {
2143                 free(caller_pkgname);
2144         }
2145         return NOTIFICATION_ERROR_NONE;
2146 }
2147
2148 EXPORT_API notification_error_e notification_delete_by_priv_id(const char *pkgname,
2149                                                                notification_type_e type,
2150                                                                int priv_id)
2151 {
2152         int ret = 0;
2153         char *caller_pkgname = NULL;
2154
2155         if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
2156                 return NOTIFICATION_ERROR_INVALID_DATA;
2157         }
2158
2159         if (pkgname == NULL) {
2160                 caller_pkgname = _notification_get_pkgname_by_pid();
2161         } else {
2162                 caller_pkgname = strdup(pkgname);
2163         }
2164
2165         ret = notification_ipc_request_delete_single(type, caller_pkgname, priv_id);
2166         if (ret != NOTIFICATION_ERROR_NONE) {
2167                 return ret;
2168         }
2169
2170         if (caller_pkgname) {
2171                 free(caller_pkgname);
2172         }
2173         return ret;
2174 }
2175
2176 EXPORT_API notification_error_e notification_delete(notification_h noti)
2177 {
2178         int ret = 0;
2179
2180         if (noti == NULL) {
2181                 return NOTIFICATION_ERROR_INVALID_DATA;
2182         }
2183
2184         ret = notification_ipc_request_delete_single(NOTIFICATION_TYPE_NONE, noti->caller_pkgname, noti->priv_id);
2185         if (ret != NOTIFICATION_ERROR_NONE) {
2186                 return ret;
2187         }
2188
2189         return NOTIFICATION_ERROR_NONE;
2190 }
2191
2192 EXPORT_API notification_error_e notification_update_progress(notification_h noti,
2193                                                              int priv_id,
2194                                                              double progress)
2195 {
2196         char *caller_pkgname = NULL;
2197         int input_priv_id = 0;
2198         double input_progress = 0.0;
2199
2200         if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
2201                 if (noti == NULL) {
2202                         return NOTIFICATION_ERROR_INVALID_DATA;
2203                 } else {
2204                         input_priv_id = noti->priv_id;
2205                 }
2206         } else {
2207                 input_priv_id = priv_id;
2208         }
2209
2210         if (noti == NULL) {
2211                 caller_pkgname = _notification_get_pkgname_by_pid();
2212         } else {
2213                 caller_pkgname = strdup(noti->caller_pkgname);
2214         }
2215
2216         if (progress < 0.0) {
2217                 input_progress = 0.0;
2218         } else if (progress > 1.0) {
2219                 input_progress = 1.0;
2220         } else {
2221                 input_progress = progress;
2222         }
2223
2224         notification_ongoing_update_progress(caller_pkgname, input_priv_id,
2225                                              input_progress);
2226
2227         if (caller_pkgname) {
2228                 free(caller_pkgname);
2229         }
2230
2231         return NOTIFICATION_ERROR_NONE;
2232 }
2233
2234 EXPORT_API notification_error_e notification_update_size(notification_h noti,
2235                                                          int priv_id,
2236                                                          double size)
2237 {
2238         char *caller_pkgname = NULL;
2239         int input_priv_id = 0;
2240         double input_size = 0.0;
2241
2242         if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
2243                 if (noti == NULL) {
2244                         return NOTIFICATION_ERROR_INVALID_DATA;
2245                 } else {
2246                         input_priv_id = noti->priv_id;
2247                 }
2248         } else {
2249                 input_priv_id = priv_id;
2250         }
2251
2252         if (noti == NULL) {
2253                 caller_pkgname = _notification_get_pkgname_by_pid();
2254         } else {
2255                 caller_pkgname = strdup(noti->caller_pkgname);
2256         }
2257
2258         if (size < 0.0) {
2259                 input_size = 0.0;
2260         } else {
2261                 input_size = size;
2262         }
2263
2264         notification_ongoing_update_size(caller_pkgname, input_priv_id,
2265                                          input_size);
2266
2267         if (caller_pkgname) {
2268                 free(caller_pkgname);
2269         }
2270
2271         return NOTIFICATION_ERROR_NONE;
2272 }
2273
2274 EXPORT_API notification_error_e notification_update_content(notification_h noti,
2275                                                          int priv_id,
2276                                                          const char *content)
2277 {
2278         char *caller_pkgname = NULL;
2279         int input_priv_id = 0;
2280
2281         if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
2282                 if (noti == NULL) {
2283                         return NOTIFICATION_ERROR_INVALID_DATA;
2284                 } else {
2285                         input_priv_id = noti->priv_id;
2286                 }
2287         } else {
2288                 input_priv_id = priv_id;
2289         }
2290
2291         if (noti == NULL) {
2292                 caller_pkgname = _notification_get_pkgname_by_pid();
2293         } else {
2294                 caller_pkgname = strdup(noti->caller_pkgname);
2295         }
2296
2297         notification_ongoing_update_content(caller_pkgname, input_priv_id,
2298                                          content);
2299
2300         if (caller_pkgname) {
2301                 free(caller_pkgname);
2302         }
2303
2304         return NOTIFICATION_ERROR_NONE;
2305 }
2306
2307 static notification_h _notification_create(notification_type_e type)
2308 {
2309         notification_h noti = NULL;
2310
2311         if (type <= NOTIFICATION_TYPE_NONE || type >= NOTIFICATION_TYPE_MAX) {
2312                 NOTIFICATION_ERR("INVALID TYPE : %d", type);
2313                 return NULL;
2314         }
2315
2316         noti = (notification_h) calloc(1, sizeof(struct _notification));
2317         if (noti == NULL) {
2318                 NOTIFICATION_ERR("NO MEMORY : noti == NULL");
2319                 return NULL;
2320         }
2321
2322         noti->type = type;
2323
2324         if (type == NOTIFICATION_TYPE_NOTI)
2325                 noti->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2326         else if (type == NOTIFICATION_TYPE_ONGOING)
2327                 noti->layout = NOTIFICATION_LY_ONGOING_PROGRESS;
2328
2329         noti->caller_pkgname = _notification_get_pkgname_by_pid();
2330         noti->group_id = NOTIFICATION_GROUP_ID_NONE;
2331         noti->priv_id = NOTIFICATION_PRIV_ID_NONE;
2332         noti->sound_type = NOTIFICATION_SOUND_TYPE_NONE;
2333         noti->vibration_type = NOTIFICATION_VIBRATION_TYPE_NONE;
2334         noti->led_operation = NOTIFICATION_LED_OP_OFF;
2335         noti->display_applist = NOTIFICATION_DISPLAY_APP_ALL;
2336         /*!
2337          * \NOTE
2338          * Other fields are already initialized with ZERO.
2339          */
2340         return noti;
2341 }
2342
2343 EXPORT_API notification_h notification_new(notification_type_e type,
2344                                            int group_id, int priv_id)
2345 {
2346         return _notification_create(type);
2347 }
2348
2349 EXPORT_API notification_h notification_create(notification_type_e type)
2350 {
2351         return _notification_create(type);
2352 }
2353
2354 EXPORT_API notification_h notification_load(char *pkgname,
2355                                                       int priv_id)
2356 {
2357         int ret = 0;
2358         notification_h noti = NULL;
2359
2360         noti = (notification_h) malloc(sizeof(struct _notification));
2361         if (noti == NULL) {
2362                 NOTIFICATION_ERR("NO MEMORY : noti == NULL");
2363                 return NULL;
2364         }
2365         memset(noti, 0x00, sizeof(struct _notification));
2366
2367         ret = notification_noti_get_by_priv_id(noti, pkgname, priv_id);
2368         if (ret != NOTIFICATION_ERROR_NONE) {
2369                 notification_free(noti);
2370                 return NULL;
2371         }
2372
2373         return noti;
2374 }
2375
2376 EXPORT_API notification_error_e notification_clone(notification_h noti, notification_h *clone)
2377 {
2378         notification_h new_noti = NULL;
2379
2380         if (noti == NULL || clone == NULL) {
2381                 NOTIFICATION_ERR("INVALID PARAMETER.");
2382                 return NOTIFICATION_ERROR_INVALID_DATA;
2383         }
2384
2385         new_noti = (notification_h) malloc(sizeof(struct _notification));
2386         if (new_noti == NULL) {
2387                 NOTIFICATION_ERR("NO MEMORY : noti == NULL");
2388                 return NOTIFICATION_ERROR_NO_MEMORY;
2389         }
2390         memset(new_noti, 0x00, sizeof(struct _notification));
2391
2392         new_noti->type = noti->type;
2393         new_noti->layout = noti->layout;
2394
2395         new_noti->group_id = noti->group_id;
2396         new_noti->internal_group_id = noti->internal_group_id;
2397         new_noti->priv_id = noti->priv_id;
2398
2399         if(noti->caller_pkgname != NULL) {
2400                 new_noti->caller_pkgname = strdup(noti->caller_pkgname);
2401         } else {
2402                 new_noti->caller_pkgname = _notification_get_pkgname_by_pid();
2403         }
2404         if(noti->launch_pkgname != NULL) {
2405                 new_noti->launch_pkgname = strdup(noti->launch_pkgname);
2406         } else {
2407                 new_noti->launch_pkgname = NULL;
2408         }
2409
2410         if(noti->args != NULL) {
2411                 new_noti->args = bundle_dup(noti->args);
2412         } else {
2413                 new_noti->args = NULL;
2414         }
2415         if(noti->group_args != NULL) {
2416                 new_noti->group_args = bundle_dup(noti->group_args);
2417         } else {
2418                 new_noti->group_args = NULL;
2419         }
2420
2421         if(noti->b_execute_option != NULL) {
2422                 new_noti->b_execute_option = bundle_dup(noti->b_execute_option);
2423         } else {
2424                 new_noti->b_execute_option = NULL;
2425         }
2426         if(noti->b_service_responding != NULL) {
2427                 new_noti->b_service_responding = bundle_dup(noti->b_service_responding);
2428         } else {
2429                 new_noti->b_service_responding = NULL;
2430         }
2431         if(noti->b_service_single_launch != NULL) {
2432                 new_noti->b_service_single_launch = bundle_dup(noti->b_service_single_launch);
2433         } else {
2434                 new_noti->b_service_single_launch = NULL;
2435         }
2436         if(noti->b_service_multi_launch != NULL) {
2437                 new_noti->b_service_multi_launch = bundle_dup(noti->b_service_multi_launch);
2438         } else {
2439                 new_noti->b_service_multi_launch = NULL;
2440         }
2441
2442         new_noti->sound_type = noti->sound_type;
2443         if(noti->sound_path != NULL) {
2444                 new_noti->sound_path = strdup(noti->sound_path);
2445         } else {
2446                 new_noti->sound_path = NULL;
2447         }
2448         new_noti->vibration_type = noti->vibration_type;
2449         if(noti->vibration_path != NULL) {
2450                 new_noti->vibration_path = strdup(noti->vibration_path);
2451         } else {
2452                 new_noti->vibration_path = NULL;
2453         }
2454         new_noti->led_operation = noti->led_operation;
2455         new_noti->led_argb = noti->led_argb;
2456         new_noti->led_on_ms = noti->led_on_ms;
2457         new_noti->led_off_ms = noti->led_off_ms;
2458
2459         if(noti->domain != NULL) {
2460                 new_noti->domain = strdup(noti->domain);
2461         } else {
2462                 new_noti->domain = NULL;
2463         }
2464         if(noti->dir != NULL) {
2465                 new_noti->dir = strdup(noti->dir);
2466         } else {
2467                 new_noti->dir = NULL;
2468         }
2469
2470         if(noti->b_text != NULL) {
2471                 new_noti->b_text = bundle_dup(noti->b_text);
2472         } else {
2473                 new_noti->b_text = NULL;
2474         }
2475         if(noti->b_key != NULL) {
2476                 new_noti->b_key = bundle_dup(noti->b_key);
2477         } else {
2478                 new_noti->b_key = NULL;
2479         }
2480         if(noti->b_format_args != NULL) {
2481                 new_noti->b_format_args = bundle_dup(noti->b_format_args);
2482         } else {
2483                 new_noti->b_format_args = NULL;
2484         }
2485         new_noti->num_format_args = noti->num_format_args;
2486
2487         if(noti->b_image_path != NULL) {
2488                 new_noti->b_image_path = bundle_dup(noti->b_image_path);
2489         } else {
2490                 new_noti->b_image_path = NULL;
2491         }
2492
2493         new_noti->time = noti->time;
2494         new_noti->insert_time = noti->insert_time;
2495
2496         new_noti->flags_for_property = noti->flags_for_property;
2497         new_noti->display_applist = noti->display_applist;
2498
2499         new_noti->progress_size = noti->progress_size;
2500         new_noti->progress_percentage = noti->progress_percentage;
2501
2502         new_noti->app_icon_path = NULL;
2503         new_noti->app_name = NULL;
2504         new_noti->temp_title = NULL;
2505         new_noti->temp_content = NULL;
2506
2507         *clone = new_noti;
2508
2509         return NOTIFICATION_ERROR_NONE;
2510 }
2511
2512
2513 EXPORT_API notification_error_e notification_free(notification_h noti)
2514 {
2515         if (noti == NULL) {
2516                 return NOTIFICATION_ERROR_INVALID_DATA;
2517         }
2518
2519         if (noti->caller_pkgname) {
2520                 free(noti->caller_pkgname);
2521         }
2522         if (noti->launch_pkgname) {
2523                 free(noti->launch_pkgname);
2524         }
2525         if (noti->args) {
2526                 bundle_free(noti->args);
2527         }
2528         if (noti->group_args) {
2529                 bundle_free(noti->group_args);
2530         }
2531
2532         if (noti->b_execute_option) {
2533                 bundle_free(noti->b_execute_option);
2534         }
2535         if (noti->b_service_responding) {
2536                 bundle_free(noti->b_service_responding);
2537         }
2538         if (noti->b_service_single_launch) {
2539                 bundle_free(noti->b_service_single_launch);
2540         }
2541         if (noti->b_service_multi_launch) {
2542                 bundle_free(noti->b_service_multi_launch);
2543         }
2544
2545         if (noti->sound_path) {
2546                 free(noti->sound_path);
2547         }
2548         if (noti->vibration_path) {
2549                 free(noti->vibration_path);
2550         }
2551
2552         if (noti->domain) {
2553                 free(noti->domain);
2554         }
2555         if (noti->dir) {
2556                 free(noti->dir);
2557         }
2558
2559         if (noti->b_text) {
2560                 bundle_free(noti->b_text);
2561         }
2562         if (noti->b_key) {
2563                 bundle_free(noti->b_key);
2564         }
2565         if (noti->b_format_args) {
2566                 bundle_free(noti->b_format_args);
2567         }
2568
2569         if (noti->b_image_path) {
2570                 bundle_free(noti->b_image_path);
2571         }
2572
2573         if (noti->app_icon_path) {
2574                 free(noti->app_icon_path);
2575         }
2576         if (noti->app_name) {
2577                 free(noti->app_name);
2578         }
2579         if (noti->temp_title) {
2580                 free(noti->temp_title);
2581         }
2582         if (noti->temp_content) {
2583                 free(noti->temp_content);
2584         }
2585
2586         free(noti);
2587
2588         return NOTIFICATION_ERROR_NONE;
2589 }
2590
2591 EXPORT_API notification_error_e
2592 notification_resister_changed_cb(void (*changed_cb)
2593                                  (void *data, notification_type_e type),
2594                                  void *user_data)
2595 {
2596         notification_cb_list_s *noti_cb_list_new = NULL;
2597         notification_cb_list_s *noti_cb_list = NULL;
2598
2599         if (notification_ipc_monitor_init() != NOTIFICATION_ERROR_NONE) {
2600                 return NOTIFICATION_ERROR_IO;
2601         }
2602
2603         noti_cb_list_new =
2604             (notification_cb_list_s *) malloc(sizeof(notification_cb_list_s));
2605
2606         noti_cb_list_new->next = NULL;
2607         noti_cb_list_new->prev = NULL;
2608
2609         noti_cb_list_new->cb_type = NOTIFICATION_CB_NORMAL;
2610         noti_cb_list_new->changed_cb = changed_cb;
2611         noti_cb_list_new->detailed_changed_cb = NULL;
2612         noti_cb_list_new->data = user_data;
2613
2614         if (g_notification_cb_list == NULL) {
2615                 g_notification_cb_list = noti_cb_list_new;
2616         } else {
2617                 noti_cb_list = g_notification_cb_list;
2618
2619                 while (noti_cb_list->next != NULL) {
2620                         noti_cb_list = noti_cb_list->next;
2621                 }
2622
2623                 noti_cb_list->next = noti_cb_list_new;
2624                 noti_cb_list_new->prev = noti_cb_list;
2625         }
2626         return NOTIFICATION_ERROR_NONE;
2627 }
2628
2629 EXPORT_API notification_error_e
2630 notification_unresister_changed_cb(void (*changed_cb)
2631                                    (void *data, notification_type_e type))
2632 {
2633         notification_cb_list_s *noti_cb_list = NULL;
2634         notification_cb_list_s *noti_cb_list_prev = NULL;
2635         notification_cb_list_s *noti_cb_list_next = NULL;
2636
2637         noti_cb_list = g_notification_cb_list;
2638
2639         if (noti_cb_list == NULL) {
2640                 return NOTIFICATION_ERROR_INVALID_DATA;
2641         }
2642
2643         while (noti_cb_list->prev != NULL) {
2644                 noti_cb_list = noti_cb_list->prev;
2645         }
2646
2647         do {
2648                 if (noti_cb_list->changed_cb == changed_cb) {
2649                         noti_cb_list_prev = noti_cb_list->prev;
2650                         noti_cb_list_next = noti_cb_list->next;
2651
2652                         if (noti_cb_list_prev == NULL) {
2653                                 g_notification_cb_list = noti_cb_list_next;
2654                         } else {
2655                                 noti_cb_list_prev->next = noti_cb_list_next;
2656                         }
2657
2658                         if (noti_cb_list_next == NULL) {
2659                                 if (noti_cb_list_prev != NULL) {
2660                                         noti_cb_list_prev->next = NULL;
2661                                 }
2662                         } else {
2663                                 noti_cb_list_next->prev = noti_cb_list_prev;
2664                         }
2665
2666                         free(noti_cb_list);
2667
2668                         if (g_notification_cb_list == NULL)
2669                                 notification_ipc_monitor_fini();
2670
2671                         return NOTIFICATION_ERROR_NONE;
2672                 }
2673                 noti_cb_list = noti_cb_list->next;
2674         } while (noti_cb_list != NULL);
2675
2676         return NOTIFICATION_ERROR_INVALID_DATA;
2677 }
2678
2679 EXPORT_API notification_error_e
2680 notification_register_detailed_changed_cb(
2681                 void (*detailed_changed_cb)(void *data, notification_type_e type, notification_op *op_list, int num_op),
2682                 void *user_data)
2683 {
2684         notification_cb_list_s *noti_cb_list_new = NULL;
2685         notification_cb_list_s *noti_cb_list = NULL;
2686
2687         if (notification_ipc_monitor_init() != NOTIFICATION_ERROR_NONE) {
2688                 return NOTIFICATION_ERROR_IO;
2689         }
2690
2691         noti_cb_list_new =
2692             (notification_cb_list_s *) malloc(sizeof(notification_cb_list_s));
2693
2694         noti_cb_list_new->next = NULL;
2695         noti_cb_list_new->prev = NULL;
2696
2697         noti_cb_list_new->cb_type = NOTIFICATION_CB_DETAILED;
2698         noti_cb_list_new->changed_cb = NULL;
2699         noti_cb_list_new->detailed_changed_cb = detailed_changed_cb;
2700         noti_cb_list_new->data = user_data;
2701
2702         if (g_notification_cb_list == NULL) {
2703                 g_notification_cb_list = noti_cb_list_new;
2704         } else {
2705                 noti_cb_list = g_notification_cb_list;
2706
2707                 while (noti_cb_list->next != NULL) {
2708                         noti_cb_list = noti_cb_list->next;
2709                 }
2710
2711                 noti_cb_list->next = noti_cb_list_new;
2712                 noti_cb_list_new->prev = noti_cb_list;
2713         }
2714         return NOTIFICATION_ERROR_NONE;
2715 }
2716
2717 EXPORT_API notification_error_e
2718 notification_unregister_detailed_changed_cb(
2719                 void (*detailed_changed_cb)(void *data, notification_type_e type, notification_op *op_list, int num_op),
2720                 void *user_data)
2721 {
2722         notification_cb_list_s *noti_cb_list = NULL;
2723         notification_cb_list_s *noti_cb_list_prev = NULL;
2724         notification_cb_list_s *noti_cb_list_next = NULL;
2725
2726         noti_cb_list = g_notification_cb_list;
2727
2728         if (noti_cb_list == NULL) {
2729                 return NOTIFICATION_ERROR_INVALID_DATA;
2730         }
2731
2732         while (noti_cb_list->prev != NULL) {
2733                 noti_cb_list = noti_cb_list->prev;
2734         }
2735
2736         do {
2737                 if (noti_cb_list->detailed_changed_cb == detailed_changed_cb) {
2738                         noti_cb_list_prev = noti_cb_list->prev;
2739                         noti_cb_list_next = noti_cb_list->next;
2740
2741                         if (noti_cb_list_prev == NULL) {
2742                                 g_notification_cb_list = noti_cb_list_next;
2743                         } else {
2744                                 noti_cb_list_prev->next = noti_cb_list_next;
2745                         }
2746
2747                         if (noti_cb_list_next == NULL) {
2748                                 if (noti_cb_list_prev != NULL) {
2749                                         noti_cb_list_prev->next = NULL;
2750                                 }
2751                         } else {
2752                                 noti_cb_list_next->prev = noti_cb_list_prev;
2753                         }
2754
2755                         free(noti_cb_list);
2756
2757                         if (g_notification_cb_list == NULL)
2758                                 notification_ipc_monitor_fini();
2759
2760                         return NOTIFICATION_ERROR_NONE;
2761                 }
2762                 noti_cb_list = noti_cb_list->next;
2763         } while (noti_cb_list != NULL);
2764
2765         return NOTIFICATION_ERROR_INVALID_DATA;
2766 }
2767
2768 EXPORT_API notification_error_e
2769 notification_resister_badge_changed_cb(void (*changed_cb)
2770                                        (void *data, const char *pkgname,
2771                                         int group_id), void *user_data)
2772 {
2773         // Add DBus signal handler
2774         return NOTIFICATION_ERROR_NONE;
2775 }
2776
2777 EXPORT_API notification_error_e
2778 notification_unresister_badge_changed_cb(void (*changed_cb)
2779                                          (void *data, const char *pkgname,
2780                                           int group_id))
2781 {
2782         // Del DBus signal handler
2783         return NOTIFICATION_ERROR_NONE;
2784 }
2785
2786 EXPORT_API notification_error_e notification_get_count(notification_type_e type,
2787                                                        const char *pkgname,
2788                                                        int group_id,
2789                                                        int priv_id, int *count)
2790 {
2791         int ret = 0;
2792         int noti_count = 0;
2793
2794         ret =
2795             notification_noti_get_count(type, pkgname, group_id, priv_id,
2796                                         &noti_count);
2797         if (ret != NOTIFICATION_ERROR_NONE) {
2798                 return ret;
2799         }
2800
2801         if (count != NULL) {
2802                 *count = noti_count;
2803         }
2804
2805         return NOTIFICATION_ERROR_NONE;
2806 }
2807
2808 EXPORT_API notification_error_e notification_get_list(notification_type_e type,
2809                                                       int count,
2810                                                       notification_list_h *list)
2811 {
2812         notification_list_h get_list = NULL;
2813         int ret = 0;
2814
2815         ret = notification_noti_get_grouping_list(type, count, &get_list);
2816         if (ret != NOTIFICATION_ERROR_NONE) {
2817                 return ret;
2818         }
2819
2820         *list = get_list;
2821
2822         return NOTIFICATION_ERROR_NONE;
2823 }
2824
2825 EXPORT_API notification_error_e
2826 notification_get_grouping_list(notification_type_e type, int count,
2827                                notification_list_h * list)
2828 {
2829         notification_list_h get_list = NULL;
2830         int ret = 0;
2831
2832         ret = notification_noti_get_grouping_list(type, count, &get_list);
2833         if (ret != NOTIFICATION_ERROR_NONE) {
2834                 return ret;
2835         }
2836
2837         *list = get_list;
2838
2839         return NOTIFICATION_ERROR_NONE;
2840 }
2841
2842 EXPORT_API notification_error_e notification_get_detail_list(const char *pkgname,
2843                                                              int group_id,
2844                                                              int priv_id,
2845                                                              int count,
2846                                                              notification_list_h *list)
2847 {
2848         notification_list_h get_list = NULL;
2849         int ret = 0;
2850
2851         ret =
2852             notification_noti_get_detail_list(pkgname, group_id, priv_id, count,
2853                                               &get_list);
2854         if (ret != NOTIFICATION_ERROR_NONE) {
2855                 return ret;
2856         }
2857
2858         *list = get_list;
2859
2860         return NOTIFICATION_ERROR_NONE;
2861 }
2862
2863 EXPORT_API notification_error_e notification_free_list(notification_list_h list)
2864 {
2865         notification_list_h cur_list = NULL;
2866         notification_h noti = NULL;
2867
2868         if (list == NULL) {
2869                 NOTIFICATION_ERR("INVALID DATA : list == NULL");
2870                 return NOTIFICATION_ERROR_INVALID_DATA;
2871         }
2872
2873         cur_list = notification_list_get_head(list);
2874
2875         while (cur_list != NULL) {
2876                 noti = notification_list_get_data(cur_list);
2877                 cur_list = notification_list_remove(cur_list, noti);
2878
2879                 notification_free(noti);
2880         }
2881
2882         return NOTIFICATION_ERROR_NONE;
2883 }
2884
2885 EXPORT_API notification_error_e notification_op_get_data(notification_op *noti_op, notification_op_data_type_e type,
2886                                                        void *data)
2887 {
2888         if (noti_op == NULL || data == NULL) {
2889                 return NOTIFICATION_ERROR_INVALID_DATA;
2890         }
2891
2892         switch (type) {
2893                 case NOTIFICATION_OP_DATA_TYPE:
2894                         *((int*)data) = noti_op->type;
2895                         break;
2896                 case NOTIFICATION_OP_DATA_PRIV_ID:
2897                         *((int*)data) = noti_op->priv_id;
2898                         break;
2899                 case NOTIFICATION_OP_DATA_NOTI:
2900                         *((notification_h *)data) = noti_op->noti;
2901                         break;
2902                 case NOTIFICATION_OP_DATA_EXTRA_INFO_1:
2903                         *((int*)data) = noti_op->extra_info_1;
2904                         break;
2905                 case NOTIFICATION_OP_DATA_EXTRA_INFO_2:
2906                         *((int*)data) = noti_op->extra_info_2;
2907                         break;
2908                 default:
2909                         return NOTIFICATION_ERROR_INVALID_DATA;
2910                         break;
2911         }
2912
2913         return NOTIFICATION_ERROR_NONE;
2914 }
2915
2916 void notification_call_changed_cb(notification_op *op_list, int op_num)
2917 {
2918         notification_cb_list_s *noti_cb_list = NULL;
2919
2920
2921         if (g_notification_cb_list == NULL) {
2922                 return;
2923         }
2924         noti_cb_list = g_notification_cb_list;
2925
2926         while (noti_cb_list->prev != NULL) {
2927                 noti_cb_list = noti_cb_list->prev;
2928         }
2929
2930         if (op_list == NULL) {
2931                 NOTIFICATION_ERR("invalid data");
2932                 return ;
2933         }
2934
2935         while (noti_cb_list != NULL) {
2936                 if (noti_cb_list->cb_type == NOTIFICATION_CB_NORMAL && noti_cb_list->changed_cb) {
2937                         noti_cb_list->changed_cb(noti_cb_list->data,
2938                                                  NOTIFICATION_TYPE_NOTI);
2939                 }
2940                 if (noti_cb_list->cb_type == NOTIFICATION_CB_DETAILED && noti_cb_list->detailed_changed_cb) {
2941                         noti_cb_list->detailed_changed_cb(noti_cb_list->data,
2942                                                  NOTIFICATION_TYPE_NOTI, op_list, op_num);
2943                 }
2944
2945                 noti_cb_list = noti_cb_list->next;
2946         }
2947 }
2948
2949 EXPORT_API int notification_is_service_ready(void)
2950 {
2951         return notification_ipc_is_master_ready();
2952 }
2953
2954 EXPORT_API notification_error_e
2955 notification_add_deffered_task(
2956                 void (*deffered_task_cb)(void *data), void *user_data)
2957 {
2958         return notification_ipc_add_deffered_task(deffered_task_cb, user_data);
2959 }
2960
2961 EXPORT_API notification_error_e
2962 notification_del_deffered_task(
2963                 void (*deffered_task_cb)(void *data))
2964 {
2965         return notification_ipc_del_deffered_task(deffered_task_cb);
2966 }