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_application(notification_h noti,
1415                                                              const char *pkgname)
1416 {
1417         if (noti == NULL || pkgname == NULL) {
1418                 return NOTIFICATION_ERROR_INVALID_DATA;
1419         }
1420
1421         if (noti->launch_pkgname) {
1422                 free(noti->launch_pkgname);
1423         }
1424
1425         noti->launch_pkgname = strdup(pkgname);
1426
1427         return NOTIFICATION_ERROR_NONE;
1428 }
1429
1430 EXPORT_API notification_error_e notification_get_application(notification_h noti,
1431                                                              char **pkgname)
1432 {
1433         if (noti == NULL || pkgname == NULL) {
1434                 return NOTIFICATION_ERROR_INVALID_DATA;
1435         }
1436
1437         if (noti->launch_pkgname) {
1438                 *pkgname = noti->launch_pkgname;
1439         } else {
1440                 *pkgname = noti->caller_pkgname;
1441         }
1442
1443         return NOTIFICATION_ERROR_NONE;
1444 }
1445
1446 EXPORT_API notification_error_e notification_set_args(notification_h noti,
1447                                                       bundle * args,
1448                                                       bundle * group_args)
1449 {
1450         if (noti == NULL || args == NULL) {
1451                 return NOTIFICATION_ERROR_INVALID_DATA;
1452         }
1453
1454         if (noti->args) {
1455                 bundle_free(noti->args);
1456         }
1457
1458         noti->args = bundle_dup(args);
1459
1460         if (noti->group_args) {
1461                 bundle_free(noti->group_args);
1462                 noti->group_args = NULL;
1463         }
1464
1465         if (group_args != NULL) {
1466                 noti->group_args = bundle_dup(group_args);
1467         }
1468
1469         return NOTIFICATION_ERROR_NONE;
1470 }
1471
1472 EXPORT_API notification_error_e notification_get_args(notification_h noti,
1473                                                       bundle ** args,
1474                                                       bundle ** group_args)
1475 {
1476         if (noti == NULL || args == NULL) {
1477                 return NOTIFICATION_ERROR_INVALID_DATA;
1478         }
1479
1480         if (noti->args) {
1481                 *args = noti->args;
1482         } else {
1483                 *args = NULL;
1484         }
1485
1486         if (group_args != NULL && noti->group_args) {
1487                 *group_args = noti->group_args;
1488         }
1489
1490         return NOTIFICATION_ERROR_NONE;
1491 }
1492
1493 EXPORT_API notification_error_e notification_set_execute_option(notification_h noti,
1494                                                                 notification_execute_type_e type,
1495                                                                 const char *text,
1496                                                                 const char *key,
1497                                                                 bundle *service_handle)
1498 {
1499         char buf_key[32] = { 0, };
1500         const char *ret_val = NULL;
1501         bundle *b = NULL;
1502
1503         if (noti == NULL) {
1504                 return NOTIFICATION_ERROR_INVALID_DATA;
1505         }
1506
1507         if (type <= NOTIFICATION_EXECUTE_TYPE_NONE
1508             || type >= NOTIFICATION_EXECUTE_TYPE_MAX) {
1509                 return NOTIFICATION_ERROR_INVALID_DATA;
1510         }
1511
1512         /* Create execute option bundle if does not exist */
1513         if (noti->b_execute_option != NULL) {
1514                 noti->b_execute_option = bundle_create();
1515         }
1516
1517         b = noti->b_execute_option;
1518
1519         /* Save text */
1520         if (text != NULL) {
1521                 /* Make text key */
1522                 snprintf(buf_key, sizeof(buf_key), "text%d", type);
1523
1524                 /* Check text key exist */
1525                 ret_val = bundle_get_val(b, buf_key);
1526                 if (ret_val != NULL) {
1527                         /* Remove previous data */
1528                         bundle_del(b, buf_key);
1529                 }
1530
1531                 /* Add text data */
1532                 bundle_add(b, buf_key, text);
1533         }
1534
1535         /* Save key */
1536         if (key != NULL) {
1537                 /* Make key key */
1538                 snprintf(buf_key, sizeof(buf_key), "key%d", type);
1539
1540                 /* Check key key exist */
1541                 ret_val = bundle_get_val(b, buf_key);
1542                 if (ret_val != NULL) {
1543                         /* Remove previous data */
1544                         bundle_del(b, buf_key);
1545                 }
1546
1547                 /* Add text data */
1548                 bundle_add(b, buf_key, key);
1549         }
1550
1551         switch (type) {
1552         case NOTIFICATION_EXECUTE_TYPE_RESPONDING:
1553                 /* Remove previous data if exist */
1554                 if (noti->b_service_responding != NULL) {
1555                         bundle_free(noti->b_service_responding);
1556                         noti->b_service_responding = NULL;
1557                 }
1558
1559                 /* Save service handle */
1560                 if (service_handle != NULL) {
1561                         noti->b_service_responding = bundle_dup(service_handle);
1562                 }
1563                 break;
1564         case NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH:
1565                 /* Remove previous data if exist */
1566                 if (noti->b_service_single_launch != NULL) {
1567                         bundle_free(noti->b_service_single_launch);
1568                         noti->b_service_single_launch = NULL;
1569                 }
1570
1571                 /* Save service handle */
1572                 if (service_handle != NULL) {
1573                         noti->b_service_single_launch =
1574                             bundle_dup(service_handle);
1575                 }
1576                 break;
1577         case NOTIFICATION_EXECUTE_TYPE_MULTI_LAUNCH:
1578                 /* Remove previous data if exist */
1579                 if (noti->b_service_multi_launch != NULL) {
1580                         bundle_free(noti->b_service_multi_launch);
1581                         noti->b_service_multi_launch = NULL;
1582                 }
1583
1584                 /* Save service handle */
1585                 if (service_handle != NULL) {
1586                         noti->b_service_multi_launch =
1587                             bundle_dup(service_handle);
1588                 }
1589                 break;
1590         }
1591
1592         return NOTIFICATION_ERROR_NONE;
1593 }
1594
1595 EXPORT_API notification_error_e notification_get_execute_option(notification_h noti,
1596                                                                 notification_execute_type_e type,
1597                                                                 const char **text,
1598                                                                 bundle **service_handle)
1599 {
1600         char buf_key[32] = { 0, };
1601         const char *ret_val = NULL;
1602         char *get_str = NULL;
1603         bundle *b = NULL;
1604
1605         if (noti == NULL) {
1606                 return NOTIFICATION_ERROR_INVALID_DATA;
1607         }
1608
1609         if (type <= NOTIFICATION_EXECUTE_TYPE_NONE
1610             || type >= NOTIFICATION_EXECUTE_TYPE_MAX) {
1611                 return NOTIFICATION_ERROR_INVALID_DATA;
1612         }
1613
1614         switch (type) {
1615         case NOTIFICATION_EXECUTE_TYPE_RESPONDING:
1616                 b = noti->b_service_responding;
1617                 break;
1618         case NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH:
1619                 b = noti->b_service_single_launch;
1620                 break;
1621         case NOTIFICATION_EXECUTE_TYPE_MULTI_LAUNCH:
1622                 b = noti->b_service_multi_launch;
1623                 break;
1624         default:
1625                 b = NULL;
1626                 break;
1627         }
1628
1629         if (b != NULL) {
1630                 // Return text
1631                 if (text != NULL) {
1632                         // Get text domain and dir
1633                         if (noti->domain == NULL || noti->dir == NULL) {
1634                                 _notification_get_text_domain(noti);
1635                         }
1636
1637                         /* Make key */
1638                         snprintf(buf_key, sizeof(buf_key), "key%d", type);
1639
1640                         /* Check key key exist */
1641                         ret_val = bundle_get_val(b, buf_key);
1642                         if (ret_val != NULL && noti->domain != NULL
1643                             && noti->dir != NULL) {
1644                                 /* Get application string */
1645                                 bindtextdomain(noti->domain, noti->dir);
1646
1647                                 get_str = dgettext(noti->domain, ret_val);
1648
1649                                 *text = get_str;
1650                         } else if (ret_val != NULL) {
1651                                 /* Get system string */
1652                                 get_str = dgettext("sys_string", ret_val);
1653
1654                                 *text = get_str;
1655                         } else {
1656                                 /* Get basic text */
1657                                 snprintf(buf_key, sizeof(buf_key), "text%d",
1658                                          type);
1659
1660                                 ret_val = bundle_get_val(b, buf_key);
1661
1662                                 *text = ret_val;
1663                         }
1664                 }
1665         }
1666
1667         switch (type) {
1668         case NOTIFICATION_EXECUTE_TYPE_RESPONDING:
1669                 b = noti->b_service_responding;
1670                 break;
1671         case NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH:
1672                 b = noti->b_service_single_launch;
1673                 break;
1674         case NOTIFICATION_EXECUTE_TYPE_MULTI_LAUNCH:
1675                 b = noti->b_service_multi_launch;
1676                 break;
1677         default:
1678                 b = NULL;
1679                 break;
1680         }
1681
1682         if (service_handle != NULL) {
1683                 *service_handle = b;
1684         }
1685
1686         return NOTIFICATION_ERROR_NONE;
1687 }
1688
1689 EXPORT_API notification_error_e notification_set_property(notification_h noti,
1690                                                           int flags)
1691 {
1692         /* Check noti is valid data */
1693         if (noti == NULL) {
1694                 return NOTIFICATION_ERROR_INVALID_DATA;
1695         }
1696
1697         /* Set flags */
1698         noti->flags_for_property = flags;
1699
1700         return NOTIFICATION_ERROR_NONE;
1701 }
1702
1703 EXPORT_API notification_error_e notification_get_property(notification_h noti,
1704                                                           int *flags)
1705 {
1706         /* Check noti and flags are valid data */
1707         if (noti == NULL || flags == NULL) {
1708                 return NOTIFICATION_ERROR_INVALID_DATA;
1709         }
1710
1711         /* Set flags */
1712         *flags = noti->flags_for_property;
1713
1714         return NOTIFICATION_ERROR_NONE;
1715 }
1716
1717 EXPORT_API notification_error_e notification_set_display_applist(notification_h noti,
1718                                                                  int applist)
1719 {
1720         /* Check noti is valid data */
1721         if (noti == NULL) {
1722                 return NOTIFICATION_ERROR_INVALID_DATA;
1723         }
1724
1725         /* Set app list */
1726         noti->display_applist = applist;
1727
1728         return NOTIFICATION_ERROR_NONE;
1729 }
1730
1731 EXPORT_API notification_error_e notification_get_display_applist(notification_h noti,
1732                                                                  int *applist)
1733 {
1734         /* Check noti and applist are valid data */
1735         if (noti == NULL || applist == NULL) {
1736                 return NOTIFICATION_ERROR_INVALID_DATA;
1737         }
1738
1739         /* Set app list */
1740         *applist = noti->display_applist;
1741
1742         return NOTIFICATION_ERROR_NONE;
1743 }
1744
1745 EXPORT_API notification_error_e notification_set_size(notification_h noti,
1746                                                       double size)
1747 {
1748         /* Check noti is valid data */
1749         if (noti == NULL) {
1750                 return NOTIFICATION_ERROR_INVALID_DATA;
1751         }
1752
1753         /* Save progress size */
1754         noti->progress_size = size;
1755
1756         return NOTIFICATION_ERROR_NONE;
1757 }
1758
1759 EXPORT_API notification_error_e notification_get_size(notification_h noti,
1760                                                       double *size)
1761 {
1762         /* Check noti and size is valid data */
1763         if (noti == NULL || size == NULL) {
1764                 return NOTIFICATION_ERROR_INVALID_DATA;
1765         }
1766
1767         /* Set progress size */
1768         *size = noti->progress_size;
1769
1770         return NOTIFICATION_ERROR_NONE;
1771 }
1772
1773 EXPORT_API notification_error_e notification_set_progress(notification_h noti,
1774                                                           double percentage)
1775 {
1776         /* Check noti is valid data */
1777         if (noti == NULL) {
1778                 return NOTIFICATION_ERROR_INVALID_DATA;
1779         }
1780
1781         /* Save progress percentage */
1782         noti->progress_percentage = percentage;
1783
1784         return NOTIFICATION_ERROR_NONE;
1785 }
1786
1787 EXPORT_API notification_error_e notification_get_progress(notification_h noti,
1788                                                           double *percentage)
1789 {
1790         /* Check noti and percentage are valid data */
1791         if (noti == NULL || percentage == NULL) {
1792                 return NOTIFICATION_ERROR_INVALID_DATA;
1793         }
1794
1795         /* Set progress percentage */
1796         *percentage = noti->progress_percentage;
1797
1798         return NOTIFICATION_ERROR_NONE;
1799 }
1800
1801 EXPORT_API notification_error_e notification_set_pkgname(notification_h noti,
1802                                                          const char *pkgname)
1803 {
1804         /* check noti and pkgname are valid data */
1805         if (noti == NULL || pkgname == NULL) {
1806                 return NOTIFICATION_ERROR_INVALID_DATA;
1807         }
1808
1809         /* Remove previous caller pkgname */
1810         if (noti->caller_pkgname) {
1811                 free(noti->caller_pkgname);
1812                 noti->caller_pkgname = NULL;
1813         }
1814
1815         noti->caller_pkgname = strdup(pkgname);
1816
1817         return NOTIFICATION_ERROR_NONE;
1818 }
1819
1820 EXPORT_API notification_error_e notification_get_pkgname(notification_h noti,
1821                                                          char **pkgname)
1822 {
1823         /* Check noti and pkgname are valid data */
1824         if (noti == NULL || pkgname == NULL) {
1825                 return NOTIFICATION_ERROR_INVALID_DATA;
1826         }
1827
1828         /* Get caller pkgname */
1829         if (noti->caller_pkgname) {
1830                 *pkgname = noti->caller_pkgname;
1831         } else {
1832                 *pkgname = NULL;
1833         }
1834
1835         return NOTIFICATION_ERROR_NONE;
1836 }
1837
1838 EXPORT_API notification_error_e notification_set_layout(notification_h noti,
1839                 notification_ly_type_e layout)
1840 {
1841         /* check noti and pkgname are valid data */
1842         if (noti == NULL || (layout < NOTIFICATION_LY_NONE || layout >= NOTIFICATION_LY_MAX)) {
1843                 return NOTIFICATION_ERROR_INVALID_DATA;
1844         }
1845
1846         noti->layout = layout;
1847
1848         return NOTIFICATION_ERROR_NONE;
1849 }
1850
1851 EXPORT_API notification_error_e notification_get_layout(notification_h noti,
1852                 notification_ly_type_e *layout)
1853 {
1854         /* Check noti and pkgname are valid data */
1855         if (noti == NULL || layout == NULL) {
1856                 return NOTIFICATION_ERROR_INVALID_DATA;
1857         }
1858
1859         *layout = noti->layout;
1860
1861         return NOTIFICATION_ERROR_NONE;
1862 }
1863
1864 EXPORT_API notification_error_e notification_set_badge(const char *pkgname,
1865                                                        int group_id, int count)
1866 {
1867         char *caller_pkgname = NULL;
1868         int ret = NOTIFICATION_ERROR_NONE;
1869
1870         /* Check count is valid count */
1871         if (count < 0) {
1872                 return NOTIFICATION_ERROR_INVALID_DATA;
1873         }
1874
1875         /* Check pkgname */
1876         if (pkgname == NULL) {
1877                 caller_pkgname = _notification_get_pkgname_by_pid();
1878
1879                 /* Set count into Group DB */
1880                 ret =
1881                     notification_group_set_badge(caller_pkgname, group_id,
1882                                                  count);
1883
1884                 if (caller_pkgname != NULL) {
1885                         free(caller_pkgname);
1886                 }
1887         } else {
1888                 /* Set count into Group DB */
1889                 ret = notification_group_set_badge(pkgname, group_id, count);
1890         }
1891
1892         return ret;
1893 }
1894
1895 EXPORT_API notification_error_e notification_get_badge(const char *pkgname,
1896                                                        int group_id, int *count)
1897 {
1898         char *caller_pkgname = NULL;
1899         int ret = NOTIFICATION_ERROR_NONE;
1900         int ret_unread_count = 0;
1901
1902         /* Check pkgname */
1903         if (pkgname == NULL) {
1904                 caller_pkgname = _notification_get_pkgname_by_pid();
1905
1906                 /* Get count from Group DB */
1907                 ret =
1908                     notification_group_get_badge(caller_pkgname, group_id,
1909                                                  &ret_unread_count);
1910
1911                 if (caller_pkgname != NULL) {
1912                         free(caller_pkgname);
1913                 }
1914         } else {
1915                 /* Get count from Group DB */
1916                 ret =
1917                     notification_group_get_badge(pkgname, group_id,
1918                                                  &ret_unread_count);
1919         }
1920
1921         if (ret != NOTIFICATION_ERROR_NONE) {
1922                 return ret;
1923         }
1924
1925         /* Set count */
1926         if (count != NULL) {
1927                 *count = ret_unread_count;
1928         }
1929
1930         return NOTIFICATION_ERROR_NONE;
1931 }
1932
1933 EXPORT_API notification_error_e notification_get_id(notification_h noti,
1934                                                     int *group_id, int *priv_id)
1935 {
1936         /* check noti is valid data */
1937         if (noti == NULL) {
1938                 return NOTIFICATION_ERROR_INVALID_DATA;
1939         }
1940
1941         /* Check group_id is valid data */
1942         if (group_id) {
1943                 /* Set group id */
1944                 if (noti->group_id < NOTIFICATION_GROUP_ID_NONE) {
1945                         *group_id = NOTIFICATION_GROUP_ID_NONE;
1946                 } else {
1947                         *group_id = noti->group_id;
1948                 }
1949         }
1950
1951         /* Check priv_id is valid data */
1952         if (priv_id) {
1953                 /* Set priv_id */
1954                 *priv_id = noti->priv_id;
1955         }
1956
1957         return NOTIFICATION_ERROR_NONE;
1958 }
1959
1960 EXPORT_API notification_error_e notification_get_type(notification_h noti,
1961                                                       notification_type_e *type)
1962 {
1963         /* Check noti and type is valid data */
1964         if (noti == NULL || type == NULL) {
1965                 return NOTIFICATION_ERROR_INVALID_DATA;
1966         }
1967
1968         /* Set noti type */
1969         *type = noti->type;
1970
1971         return NOTIFICATION_ERROR_NONE;
1972 }
1973
1974 EXPORT_API notification_error_e notification_insert(notification_h noti,
1975                                                     int *priv_id)
1976 {
1977         int ret = 0;
1978         int id = 0;
1979
1980         /* Check noti is vaild data */
1981         if (noti == NULL) {
1982                 return NOTIFICATION_ERROR_INVALID_DATA;
1983         }
1984
1985         /* Check noti type is valid type */
1986         if (noti->type <= NOTIFICATION_TYPE_NONE
1987             || noti->type >= NOTIFICATION_TYPE_MAX) {
1988                 return NOTIFICATION_ERROR_INVALID_DATA;
1989         }
1990
1991         /* Save insert time */
1992         noti->insert_time = time(NULL);
1993         ret = notification_ipc_request_insert(noti, &id);
1994         if (ret != NOTIFICATION_ERROR_NONE) {
1995                 return ret;
1996         }
1997         noti->priv_id = id;
1998         NOTIFICATION_DBG("from master:%d", id);
1999
2000         /* If priv_id is valid data, set priv_id */
2001         if (priv_id != NULL) {
2002                 *priv_id = noti->priv_id;
2003         }
2004
2005         return NOTIFICATION_ERROR_NONE;
2006 }
2007
2008 EXPORT_API notification_error_e notification_update(notification_h noti)
2009 {
2010         int ret = 0;
2011
2012         /* Check noti is valid data */
2013         if (noti != NULL) {
2014                 /* Update insert time ? */
2015                 noti->insert_time = time(NULL);
2016                 ret = notification_ipc_request_update(noti);
2017                 if (ret != NOTIFICATION_ERROR_NONE) {
2018                         return ret;
2019                 }
2020         } else {
2021                 ret = notification_ipc_request_refresh();
2022                 if (ret != NOTIFICATION_ERROR_NONE) {
2023                         return ret;
2024                 }
2025         }
2026         return NOTIFICATION_ERROR_NONE;
2027 }
2028
2029 EXPORT_API notification_error_e notifiation_clear(notification_type_e type)
2030 {
2031         int ret = 0;
2032
2033         ret = notification_ipc_request_delete_multiple(type, NULL);
2034         if (ret != NOTIFICATION_ERROR_NONE) {
2035                 return ret;
2036         }
2037
2038         return NOTIFICATION_ERROR_NONE;
2039 }
2040
2041 EXPORT_API notification_error_e notification_delete_all_by_type(const char *pkgname,
2042                                                                 notification_type_e type)
2043 {
2044         int ret = 0;
2045         char *caller_pkgname = NULL;
2046
2047         if (pkgname == NULL) {
2048                 caller_pkgname = _notification_get_pkgname_by_pid();
2049         } else {
2050                 caller_pkgname = strdup(pkgname);
2051         }
2052
2053         ret = notification_ipc_request_delete_multiple(type, caller_pkgname);
2054         if (ret != NOTIFICATION_ERROR_NONE) {
2055                 return ret;
2056         }
2057
2058         return NOTIFICATION_ERROR_NONE;
2059 }
2060
2061 EXPORT_API notification_error_e notification_delete_group_by_group_id(const char *pkgname,
2062                                                                       notification_type_e type,
2063                                                                       int group_id)
2064 {
2065         int ret = 0;
2066         char *caller_pkgname = NULL;
2067
2068         if (pkgname == NULL) {
2069                 caller_pkgname = _notification_get_pkgname_by_pid();
2070         } else {
2071                 caller_pkgname = strdup(pkgname);
2072         }
2073
2074         ret = notification_ipc_request_delete_multiple(type, caller_pkgname);
2075         if (ret != NOTIFICATION_ERROR_NONE) {
2076                 return ret;
2077         }
2078
2079         return NOTIFICATION_ERROR_NONE;
2080 }
2081
2082 EXPORT_API notification_error_e notification_delete_group_by_priv_id(const char *pkgname,
2083                                                                      notification_type_e type,
2084                                                                      int priv_id)
2085 {
2086         int ret = 0;
2087         char *caller_pkgname = NULL;
2088
2089         if (pkgname == NULL) {
2090                 caller_pkgname = _notification_get_pkgname_by_pid();
2091         } else {
2092                 caller_pkgname = strdup(pkgname);
2093         }
2094
2095         ret = notification_ipc_request_delete_single(type, caller_pkgname, priv_id);
2096         if (ret != NOTIFICATION_ERROR_NONE) {
2097                 return ret;
2098         }
2099
2100         return NOTIFICATION_ERROR_NONE;
2101 }
2102
2103 EXPORT_API notification_error_e notification_delete_by_priv_id(const char *pkgname,
2104                                                                notification_type_e type,
2105                                                                int priv_id)
2106 {
2107         int ret = 0;
2108         char *caller_pkgname = NULL;
2109
2110         if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
2111                 return NOTIFICATION_ERROR_INVALID_DATA;
2112         }
2113
2114         if (pkgname == NULL) {
2115                 caller_pkgname = _notification_get_pkgname_by_pid();
2116         } else {
2117                 caller_pkgname = strdup(pkgname);
2118         }
2119
2120         ret = notification_ipc_request_delete_single(type, caller_pkgname, priv_id);
2121         if (ret != NOTIFICATION_ERROR_NONE) {
2122                 return ret;
2123         }
2124
2125         return ret;
2126 }
2127
2128 EXPORT_API notification_error_e notification_delete(notification_h noti)
2129 {
2130         int ret = 0;
2131
2132         if (noti == NULL) {
2133                 return NOTIFICATION_ERROR_INVALID_DATA;
2134         }
2135
2136         ret = notification_ipc_request_delete_single(NOTIFICATION_TYPE_NONE, noti->caller_pkgname, noti->priv_id);
2137         if (ret != NOTIFICATION_ERROR_NONE) {
2138                 return ret;
2139         }
2140
2141         return NOTIFICATION_ERROR_NONE;
2142 }
2143
2144 EXPORT_API notification_error_e notification_update_progress(notification_h noti,
2145                                                              int priv_id,
2146                                                              double progress)
2147 {
2148         char *caller_pkgname = NULL;
2149         int input_priv_id = 0;
2150         double input_progress = 0.0;
2151
2152         if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
2153                 if (noti == NULL) {
2154                         return NOTIFICATION_ERROR_INVALID_DATA;
2155                 } else {
2156                         input_priv_id = noti->priv_id;
2157                 }
2158         } else {
2159                 input_priv_id = priv_id;
2160         }
2161
2162         if (noti == NULL) {
2163                 caller_pkgname = _notification_get_pkgname_by_pid();
2164         } else {
2165                 caller_pkgname = strdup(noti->caller_pkgname);
2166         }
2167
2168         if (progress < 0.0) {
2169                 input_progress = 0.0;
2170         } else if (progress > 1.0) {
2171                 input_progress = 1.0;
2172         } else {
2173                 input_progress = progress;
2174         }
2175
2176         notification_ongoing_update_progress(caller_pkgname, input_priv_id,
2177                                              input_progress);
2178
2179         if (caller_pkgname) {
2180                 free(caller_pkgname);
2181         }
2182
2183         return NOTIFICATION_ERROR_NONE;
2184 }
2185
2186 EXPORT_API notification_error_e notification_update_size(notification_h noti,
2187                                                          int priv_id,
2188                                                          double size)
2189 {
2190         char *caller_pkgname = NULL;
2191         int input_priv_id = 0;
2192         double input_size = 0.0;
2193
2194         if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
2195                 if (noti == NULL) {
2196                         return NOTIFICATION_ERROR_INVALID_DATA;
2197                 } else {
2198                         input_priv_id = noti->priv_id;
2199                 }
2200         } else {
2201                 input_priv_id = priv_id;
2202         }
2203
2204         if (noti == NULL) {
2205                 caller_pkgname = _notification_get_pkgname_by_pid();
2206         } else {
2207                 caller_pkgname = strdup(noti->caller_pkgname);
2208         }
2209
2210         if (size < 0.0) {
2211                 input_size = 0.0;
2212         } else {
2213                 input_size = size;
2214         }
2215
2216         notification_ongoing_update_size(caller_pkgname, input_priv_id,
2217                                          input_size);
2218
2219         if (caller_pkgname) {
2220                 free(caller_pkgname);
2221         }
2222
2223         return NOTIFICATION_ERROR_NONE;
2224 }
2225
2226 EXPORT_API notification_error_e notification_update_content(notification_h noti,
2227                                                          int priv_id,
2228                                                          const char *content)
2229 {
2230         char *caller_pkgname = NULL;
2231         int input_priv_id = 0;
2232
2233         if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
2234                 if (noti == NULL) {
2235                         return NOTIFICATION_ERROR_INVALID_DATA;
2236                 } else {
2237                         input_priv_id = noti->priv_id;
2238                 }
2239         } else {
2240                 input_priv_id = priv_id;
2241         }
2242
2243         if (noti == NULL) {
2244                 caller_pkgname = _notification_get_pkgname_by_pid();
2245         } else {
2246                 caller_pkgname = strdup(noti->caller_pkgname);
2247         }
2248
2249         notification_ongoing_update_content(caller_pkgname, input_priv_id,
2250                                          content);
2251
2252         if (caller_pkgname) {
2253                 free(caller_pkgname);
2254         }
2255
2256         return NOTIFICATION_ERROR_NONE;
2257 }
2258
2259 static notification_h _notification_create(notification_type_e type)
2260 {
2261         notification_h noti = NULL;
2262
2263         if (type <= NOTIFICATION_TYPE_NONE || type >= NOTIFICATION_TYPE_MAX) {
2264                 NOTIFICATION_ERR("INVALID TYPE : %d", type);
2265                 return NULL;
2266         }
2267
2268         noti = (notification_h) calloc(1, sizeof(struct _notification));
2269         if (noti == NULL) {
2270                 NOTIFICATION_ERR("NO MEMORY : noti == NULL");
2271                 return NULL;
2272         }
2273
2274         noti->type = type;
2275
2276         if (type == NOTIFICATION_TYPE_NOTI)
2277                 noti->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2278         else if (type == NOTIFICATION_TYPE_ONGOING)
2279                 noti->layout = NOTIFICATION_LY_ONGOING_PROGRESS;
2280
2281         noti->caller_pkgname = _notification_get_pkgname_by_pid();
2282         noti->group_id = NOTIFICATION_GROUP_ID_NONE;
2283         noti->priv_id = NOTIFICATION_PRIV_ID_NONE;
2284         noti->sound_type = NOTIFICATION_SOUND_TYPE_NONE;
2285         noti->vibration_type = NOTIFICATION_VIBRATION_TYPE_NONE;
2286         noti->led_operation = NOTIFICATION_LED_OP_OFF;
2287         noti->display_applist = NOTIFICATION_DISPLAY_APP_ALL;
2288         /*!
2289          * \NOTE
2290          * Other fields are already initialized with ZERO.
2291          */
2292         return noti;
2293 }
2294
2295 EXPORT_API notification_h notification_new(notification_type_e type,
2296                                            int group_id, int priv_id)
2297 {
2298         return _notification_create(type);
2299 }
2300
2301 EXPORT_API notification_h notification_create(notification_type_e type)
2302 {
2303         return _notification_create(type);
2304 }
2305
2306 EXPORT_API notification_h notification_load(char *pkgname,
2307                                                       int priv_id)
2308 {
2309         int ret = 0;
2310         notification_h noti = NULL;
2311
2312         noti = (notification_h) malloc(sizeof(struct _notification));
2313         if (noti == NULL) {
2314                 NOTIFICATION_ERR("NO MEMORY : noti == NULL");
2315                 return NULL;
2316         }
2317         memset(noti, 0x00, sizeof(struct _notification));
2318
2319         ret = notification_noti_get_by_priv_id(noti, pkgname, priv_id);
2320         if (ret != NOTIFICATION_ERROR_NONE) {
2321                 notification_free(noti);
2322                 return NULL;
2323         }
2324
2325         return noti;
2326 }
2327
2328 EXPORT_API notification_error_e notification_clone(notification_h noti, notification_h *clone)
2329 {
2330         notification_h new_noti = NULL;
2331
2332         if (noti == NULL || clone == NULL) {
2333                 NOTIFICATION_ERR("INVALID PARAMETER.");
2334                 return NOTIFICATION_ERROR_INVALID_DATA;
2335         }
2336
2337         new_noti = (notification_h) malloc(sizeof(struct _notification));
2338         if (new_noti == NULL) {
2339                 NOTIFICATION_ERR("NO MEMORY : noti == NULL");
2340                 return NOTIFICATION_ERROR_NO_MEMORY;
2341         }
2342         memset(new_noti, 0x00, sizeof(struct _notification));
2343
2344         new_noti->type = noti->type;
2345         new_noti->layout = noti->layout;
2346
2347         new_noti->group_id = noti->group_id;
2348         new_noti->internal_group_id = noti->internal_group_id;
2349         new_noti->priv_id = noti->priv_id;
2350
2351         if(noti->caller_pkgname != NULL) {
2352                 new_noti->caller_pkgname = strdup(noti->caller_pkgname);
2353         } else {
2354                 new_noti->caller_pkgname = _notification_get_pkgname_by_pid();
2355         }
2356         if(noti->launch_pkgname != NULL) {
2357                 new_noti->launch_pkgname = strdup(noti->launch_pkgname);
2358         } else {
2359                 new_noti->launch_pkgname = NULL;
2360         }
2361
2362         if(noti->args != NULL) {
2363                 new_noti->args = bundle_dup(noti->args);
2364         } else {
2365                 new_noti->args = NULL;
2366         }
2367         if(noti->group_args != NULL) {
2368                 new_noti->group_args = bundle_dup(noti->group_args);
2369         } else {
2370                 new_noti->group_args = NULL;
2371         }
2372
2373         if(noti->b_execute_option != NULL) {
2374                 new_noti->b_execute_option = bundle_dup(noti->b_execute_option);
2375         } else {
2376                 new_noti->b_execute_option = NULL;
2377         }
2378         if(noti->b_service_responding != NULL) {
2379                 new_noti->b_service_responding = bundle_dup(noti->b_service_responding);
2380         } else {
2381                 new_noti->b_service_responding = NULL;
2382         }
2383         if(noti->b_service_single_launch != NULL) {
2384                 new_noti->b_service_single_launch = bundle_dup(noti->b_service_single_launch);
2385         } else {
2386                 new_noti->b_service_single_launch = NULL;
2387         }
2388         if(noti->b_service_multi_launch != NULL) {
2389                 new_noti->b_service_multi_launch = bundle_dup(noti->b_service_multi_launch);
2390         } else {
2391                 new_noti->b_service_multi_launch = NULL;
2392         }
2393
2394         new_noti->sound_type = noti->sound_type;
2395         if(noti->sound_path != NULL) {
2396                 new_noti->sound_path = strdup(noti->sound_path);
2397         } else {
2398                 new_noti->sound_path = NULL;
2399         }
2400         new_noti->vibration_type = noti->vibration_type;
2401         if(noti->vibration_path != NULL) {
2402                 new_noti->vibration_path = strdup(noti->vibration_path);
2403         } else {
2404                 new_noti->vibration_path = NULL;
2405         }
2406         new_noti->led_operation = noti->led_operation;
2407         new_noti->led_argb = noti->led_argb;
2408
2409         if(noti->domain != NULL) {
2410                 new_noti->domain = strdup(noti->domain);
2411         } else {
2412                 new_noti->domain = NULL;
2413         }
2414         if(noti->dir != NULL) {
2415                 new_noti->dir = strdup(noti->dir);
2416         } else {
2417                 new_noti->dir = NULL;
2418         }
2419
2420         if(noti->b_text != NULL) {
2421                 new_noti->b_text = bundle_dup(noti->b_text);
2422         } else {
2423                 new_noti->b_text = NULL;
2424         }
2425         if(noti->b_key != NULL) {
2426                 new_noti->b_key = bundle_dup(noti->b_key);
2427         } else {
2428                 new_noti->b_key = NULL;
2429         }
2430         if(noti->b_format_args != NULL) {
2431                 new_noti->b_format_args = bundle_dup(noti->b_format_args);
2432         } else {
2433                 new_noti->b_format_args = NULL;
2434         }
2435         new_noti->num_format_args = noti->num_format_args;
2436
2437         if(noti->b_image_path != NULL) {
2438                 new_noti->b_image_path = bundle_dup(noti->b_image_path);
2439         } else {
2440                 new_noti->b_image_path = NULL;
2441         }
2442
2443         new_noti->time = noti->time;
2444         new_noti->insert_time = noti->insert_time;
2445
2446         new_noti->flags_for_property = noti->flags_for_property;
2447         new_noti->display_applist = noti->display_applist;
2448
2449         new_noti->progress_size = noti->progress_size;
2450         new_noti->progress_percentage = noti->progress_percentage;
2451
2452         new_noti->app_icon_path = NULL;
2453         new_noti->app_name = NULL;
2454         new_noti->temp_title = NULL;
2455         new_noti->temp_content = NULL;
2456
2457         *clone = new_noti;
2458
2459         return NOTIFICATION_ERROR_NONE;
2460 }
2461
2462
2463 EXPORT_API notification_error_e notification_free(notification_h noti)
2464 {
2465         if (noti == NULL) {
2466                 return NOTIFICATION_ERROR_INVALID_DATA;
2467         }
2468
2469         if (noti->caller_pkgname) {
2470                 free(noti->caller_pkgname);
2471         }
2472         if (noti->launch_pkgname) {
2473                 free(noti->launch_pkgname);
2474         }
2475         if (noti->args) {
2476                 bundle_free(noti->args);
2477         }
2478         if (noti->group_args) {
2479                 bundle_free(noti->group_args);
2480         }
2481
2482         if (noti->b_execute_option) {
2483                 bundle_free(noti->b_execute_option);
2484         }
2485         if (noti->b_service_responding) {
2486                 bundle_free(noti->b_service_responding);
2487         }
2488         if (noti->b_service_single_launch) {
2489                 bundle_free(noti->b_service_single_launch);
2490         }
2491         if (noti->b_service_multi_launch) {
2492                 bundle_free(noti->b_service_multi_launch);
2493         }
2494
2495         if (noti->sound_path) {
2496                 free(noti->sound_path);
2497         }
2498         if (noti->vibration_path) {
2499                 free(noti->vibration_path);
2500         }
2501
2502         if (noti->domain) {
2503                 free(noti->domain);
2504         }
2505         if (noti->dir) {
2506                 free(noti->dir);
2507         }
2508
2509         if (noti->b_text) {
2510                 bundle_free(noti->b_text);
2511         }
2512         if (noti->b_key) {
2513                 bundle_free(noti->b_key);
2514         }
2515         if (noti->b_format_args) {
2516                 bundle_free(noti->b_format_args);
2517         }
2518
2519         if (noti->b_image_path) {
2520                 bundle_free(noti->b_image_path);
2521         }
2522
2523         if (noti->app_icon_path) {
2524                 free(noti->app_icon_path);
2525         }
2526         if (noti->app_name) {
2527                 free(noti->app_name);
2528         }
2529         if (noti->temp_title) {
2530                 free(noti->temp_title);
2531         }
2532         if (noti->temp_content) {
2533                 free(noti->temp_content);
2534         }
2535
2536         free(noti);
2537
2538         return NOTIFICATION_ERROR_NONE;
2539 }
2540
2541 EXPORT_API notification_error_e
2542 notification_resister_changed_cb(void (*changed_cb)
2543                                  (void *data, notification_type_e type),
2544                                  void *user_data)
2545 {
2546         notification_cb_list_s *noti_cb_list_new = NULL;
2547         notification_cb_list_s *noti_cb_list = NULL;
2548
2549         if (notification_ipc_monitor_init() != NOTIFICATION_ERROR_NONE) {
2550                 return NOTIFICATION_ERROR_IO;
2551         }
2552
2553         noti_cb_list_new =
2554             (notification_cb_list_s *) malloc(sizeof(notification_cb_list_s));
2555
2556         noti_cb_list_new->next = NULL;
2557         noti_cb_list_new->prev = NULL;
2558
2559         noti_cb_list_new->cb_type = NOTIFICATION_CB_NORMAL;
2560         noti_cb_list_new->changed_cb = changed_cb;
2561         noti_cb_list_new->detailed_changed_cb = NULL;
2562         noti_cb_list_new->data = user_data;
2563
2564         if (g_notification_cb_list == NULL) {
2565                 g_notification_cb_list = noti_cb_list_new;
2566         } else {
2567                 noti_cb_list = g_notification_cb_list;
2568
2569                 while (noti_cb_list->next != NULL) {
2570                         noti_cb_list = noti_cb_list->next;
2571                 }
2572
2573                 noti_cb_list->next = noti_cb_list_new;
2574                 noti_cb_list_new->prev = noti_cb_list;
2575         }
2576         return NOTIFICATION_ERROR_NONE;
2577 }
2578
2579 EXPORT_API notification_error_e
2580 notification_unresister_changed_cb(void (*changed_cb)
2581                                    (void *data, notification_type_e type))
2582 {
2583         notification_cb_list_s *noti_cb_list = NULL;
2584         notification_cb_list_s *noti_cb_list_prev = NULL;
2585         notification_cb_list_s *noti_cb_list_next = NULL;
2586
2587         noti_cb_list = g_notification_cb_list;
2588
2589         if (noti_cb_list == NULL) {
2590                 return NOTIFICATION_ERROR_INVALID_DATA;
2591         }
2592
2593         while (noti_cb_list->prev != NULL) {
2594                 noti_cb_list = noti_cb_list->prev;
2595         }
2596
2597         do {
2598                 if (noti_cb_list->changed_cb == changed_cb) {
2599                         noti_cb_list_prev = noti_cb_list->prev;
2600                         noti_cb_list_next = noti_cb_list->next;
2601
2602                         if (noti_cb_list_prev == NULL) {
2603                                 g_notification_cb_list = noti_cb_list_next;
2604                         } else {
2605                                 noti_cb_list_prev->next = noti_cb_list_next;
2606                         }
2607
2608                         if (noti_cb_list_next == NULL) {
2609                                 if (noti_cb_list_prev != NULL) {
2610                                         noti_cb_list_prev->next = NULL;
2611                                 }
2612                         } else {
2613                                 noti_cb_list_next->prev = noti_cb_list_prev;
2614                         }
2615
2616                         free(noti_cb_list);
2617
2618                         if (g_notification_cb_list == NULL)
2619                                 notification_ipc_monitor_fini();
2620
2621                         return NOTIFICATION_ERROR_NONE;
2622                 }
2623                 noti_cb_list = noti_cb_list->next;
2624         } while (noti_cb_list != NULL);
2625
2626         return NOTIFICATION_ERROR_INVALID_DATA;
2627 }
2628
2629 EXPORT_API notification_error_e
2630 notification_register_detailed_changed_cb(
2631                 void (*detailed_changed_cb)(void *data, notification_type_e type, notification_op *op_list, int num_op),
2632                 void *user_data)
2633 {
2634         notification_cb_list_s *noti_cb_list_new = NULL;
2635         notification_cb_list_s *noti_cb_list = NULL;
2636
2637         if (notification_ipc_monitor_init() != NOTIFICATION_ERROR_NONE) {
2638                 return NOTIFICATION_ERROR_IO;
2639         }
2640
2641         noti_cb_list_new =
2642             (notification_cb_list_s *) malloc(sizeof(notification_cb_list_s));
2643
2644         noti_cb_list_new->next = NULL;
2645         noti_cb_list_new->prev = NULL;
2646
2647         noti_cb_list_new->cb_type = NOTIFICATION_CB_DETAILED;
2648         noti_cb_list_new->changed_cb = NULL;
2649         noti_cb_list_new->detailed_changed_cb = detailed_changed_cb;
2650         noti_cb_list_new->data = user_data;
2651
2652         if (g_notification_cb_list == NULL) {
2653                 g_notification_cb_list = noti_cb_list_new;
2654         } else {
2655                 noti_cb_list = g_notification_cb_list;
2656
2657                 while (noti_cb_list->next != NULL) {
2658                         noti_cb_list = noti_cb_list->next;
2659                 }
2660
2661                 noti_cb_list->next = noti_cb_list_new;
2662                 noti_cb_list_new->prev = noti_cb_list;
2663         }
2664         return NOTIFICATION_ERROR_NONE;
2665 }
2666
2667 EXPORT_API notification_error_e
2668 notification_unregister_detailed_changed_cb(
2669                 void (*detailed_changed_cb)(void *data, notification_type_e type, notification_op *op_list, int num_op),
2670                 void *user_data)
2671 {
2672         notification_cb_list_s *noti_cb_list = NULL;
2673         notification_cb_list_s *noti_cb_list_prev = NULL;
2674         notification_cb_list_s *noti_cb_list_next = NULL;
2675
2676         noti_cb_list = g_notification_cb_list;
2677
2678         if (noti_cb_list == NULL) {
2679                 return NOTIFICATION_ERROR_INVALID_DATA;
2680         }
2681
2682         while (noti_cb_list->prev != NULL) {
2683                 noti_cb_list = noti_cb_list->prev;
2684         }
2685
2686         do {
2687                 if (noti_cb_list->detailed_changed_cb == detailed_changed_cb) {
2688                         noti_cb_list_prev = noti_cb_list->prev;
2689                         noti_cb_list_next = noti_cb_list->next;
2690
2691                         if (noti_cb_list_prev == NULL) {
2692                                 g_notification_cb_list = noti_cb_list_next;
2693                         } else {
2694                                 noti_cb_list_prev->next = noti_cb_list_next;
2695                         }
2696
2697                         if (noti_cb_list_next == NULL) {
2698                                 if (noti_cb_list_prev != NULL) {
2699                                         noti_cb_list_prev->next = NULL;
2700                                 }
2701                         } else {
2702                                 noti_cb_list_next->prev = noti_cb_list_prev;
2703                         }
2704
2705                         free(noti_cb_list);
2706
2707                         if (g_notification_cb_list == NULL)
2708                                 notification_ipc_monitor_fini();
2709
2710                         return NOTIFICATION_ERROR_NONE;
2711                 }
2712                 noti_cb_list = noti_cb_list->next;
2713         } while (noti_cb_list != NULL);
2714
2715         return NOTIFICATION_ERROR_INVALID_DATA;
2716 }
2717
2718 EXPORT_API notification_error_e
2719 notification_resister_badge_changed_cb(void (*changed_cb)
2720                                        (void *data, const char *pkgname,
2721                                         int group_id), void *user_data)
2722 {
2723         // Add DBus signal handler
2724         return NOTIFICATION_ERROR_NONE;
2725 }
2726
2727 EXPORT_API notification_error_e
2728 notification_unresister_badge_changed_cb(void (*changed_cb)
2729                                          (void *data, const char *pkgname,
2730                                           int group_id))
2731 {
2732         // Del DBus signal handler
2733         return NOTIFICATION_ERROR_NONE;
2734 }
2735
2736 EXPORT_API notification_error_e notification_get_count(notification_type_e type,
2737                                                        const char *pkgname,
2738                                                        int group_id,
2739                                                        int priv_id, int *count)
2740 {
2741         int ret = 0;
2742         int noti_count = 0;
2743
2744         ret =
2745             notification_noti_get_count(type, pkgname, group_id, priv_id,
2746                                         &noti_count);
2747         if (ret != NOTIFICATION_ERROR_NONE) {
2748                 return ret;
2749         }
2750
2751         if (count != NULL) {
2752                 *count = noti_count;
2753         }
2754
2755         return NOTIFICATION_ERROR_NONE;
2756 }
2757
2758 EXPORT_API notification_error_e notification_get_list(notification_type_e type,
2759                                                       int count,
2760                                                       notification_list_h *list)
2761 {
2762         notification_list_h get_list = NULL;
2763         int ret = 0;
2764
2765         ret = notification_noti_get_grouping_list(type, count, &get_list);
2766         if (ret != NOTIFICATION_ERROR_NONE) {
2767                 return ret;
2768         }
2769
2770         *list = get_list;
2771
2772         return NOTIFICATION_ERROR_NONE;
2773 }
2774
2775 EXPORT_API notification_error_e
2776 notification_get_grouping_list(notification_type_e type, int count,
2777                                notification_list_h * list)
2778 {
2779         notification_list_h get_list = NULL;
2780         int ret = 0;
2781
2782         ret = notification_noti_get_grouping_list(type, count, &get_list);
2783         if (ret != NOTIFICATION_ERROR_NONE) {
2784                 return ret;
2785         }
2786
2787         *list = get_list;
2788
2789         return NOTIFICATION_ERROR_NONE;
2790 }
2791
2792 EXPORT_API notification_error_e notification_get_detail_list(const char *pkgname,
2793                                                              int group_id,
2794                                                              int priv_id,
2795                                                              int count,
2796                                                              notification_list_h *list)
2797 {
2798         notification_list_h get_list = NULL;
2799         int ret = 0;
2800
2801         ret =
2802             notification_noti_get_detail_list(pkgname, group_id, priv_id, count,
2803                                               &get_list);
2804         if (ret != NOTIFICATION_ERROR_NONE) {
2805                 return ret;
2806         }
2807
2808         *list = get_list;
2809
2810         return NOTIFICATION_ERROR_NONE;
2811 }
2812
2813 EXPORT_API notification_error_e notification_free_list(notification_list_h list)
2814 {
2815         notification_list_h cur_list = NULL;
2816         notification_h noti = NULL;
2817
2818         if (list == NULL) {
2819                 NOTIFICATION_ERR("INVALID DATA : list == NULL");
2820                 return NOTIFICATION_ERROR_INVALID_DATA;
2821         }
2822
2823         cur_list = notification_list_get_head(list);
2824
2825         while (cur_list != NULL) {
2826                 noti = notification_list_get_data(cur_list);
2827                 cur_list = notification_list_remove(cur_list, noti);
2828
2829                 notification_free(noti);
2830         }
2831
2832         return NOTIFICATION_ERROR_NONE;
2833 }
2834
2835 EXPORT_API notification_error_e notification_op_get_data(notification_op *noti_op, notification_op_data_type_e type,
2836                                                        void *data)
2837 {
2838         if (noti_op == NULL || data == NULL) {
2839                 return NOTIFICATION_ERROR_INVALID_DATA;
2840         }
2841
2842         switch (type) {
2843                 case NOTIFICATION_OP_DATA_TYPE:
2844                         *((int*)data) = noti_op->type;
2845                         break;
2846                 case NOTIFICATION_OP_DATA_PRIV_ID:
2847                         *((int*)data) = noti_op->priv_id;
2848                         break;
2849                 case NOTIFICATION_OP_DATA_NOTI:
2850                         *((notification_h *)data) = noti_op->noti;
2851                         break;
2852                 case NOTIFICATION_OP_DATA_EXTRA_INFO_1:
2853                         *((int*)data) = noti_op->extra_info_1;
2854                         break;
2855                 case NOTIFICATION_OP_DATA_EXTRA_INFO_2:
2856                         *((int*)data) = noti_op->extra_info_2;
2857                         break;
2858                 default:
2859                         return NOTIFICATION_ERROR_INVALID_DATA;
2860                         break;
2861         }
2862
2863         return NOTIFICATION_ERROR_NONE;
2864 }
2865
2866 void notification_call_changed_cb(notification_op *op_list, int op_num)
2867 {
2868         notification_cb_list_s *noti_cb_list = NULL;
2869
2870
2871         if (g_notification_cb_list == NULL) {
2872                 return;
2873         }
2874         noti_cb_list = g_notification_cb_list;
2875
2876         while (noti_cb_list->prev != NULL) {
2877                 noti_cb_list = noti_cb_list->prev;
2878         }
2879
2880         if (op_list == NULL) {
2881                 NOTIFICATION_ERR("invalid data");
2882                 return ;
2883         }
2884
2885         while (noti_cb_list != NULL) {
2886                 if (noti_cb_list->cb_type == NOTIFICATION_CB_NORMAL && noti_cb_list->changed_cb) {
2887                         noti_cb_list->changed_cb(noti_cb_list->data,
2888                                                  NOTIFICATION_TYPE_NOTI);
2889                 }
2890                 if (noti_cb_list->cb_type == NOTIFICATION_CB_DETAILED && noti_cb_list->detailed_changed_cb) {
2891                         noti_cb_list->detailed_changed_cb(noti_cb_list->data,
2892                                                  NOTIFICATION_TYPE_NOTI, op_list, op_num);
2893                 }
2894
2895                 noti_cb_list = noti_cb_list->next;
2896         }
2897 }
2898
2899 EXPORT_API int notification_is_service_ready(void)
2900 {
2901         return notification_ipc_is_master_ready();
2902 }
2903
2904 EXPORT_API notification_error_e
2905 notification_add_deffered_task(
2906                 void (*deffered_task_cb)(void *data), void *user_data)
2907 {
2908         return notification_ipc_add_deffered_task(deffered_task_cb, user_data);
2909 }
2910
2911 EXPORT_API notification_error_e
2912 notification_del_deffered_task(
2913                 void (*deffered_task_cb)(void *data))
2914 {
2915         return notification_ipc_del_deffered_task(deffered_task_cb);
2916 }