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         if (caller_pkgname) {
2059                 free(caller_pkgname);
2060         }
2061         return NOTIFICATION_ERROR_NONE;
2062 }
2063
2064 EXPORT_API notification_error_e notification_delete_group_by_group_id(const char *pkgname,
2065                                                                       notification_type_e type,
2066                                                                       int group_id)
2067 {
2068         int ret = 0;
2069         char *caller_pkgname = NULL;
2070
2071         if (pkgname == NULL) {
2072                 caller_pkgname = _notification_get_pkgname_by_pid();
2073         } else {
2074                 caller_pkgname = strdup(pkgname);
2075         }
2076
2077         ret = notification_ipc_request_delete_multiple(type, caller_pkgname);
2078         if (ret != NOTIFICATION_ERROR_NONE) {
2079                 return ret;
2080         }
2081
2082         if (caller_pkgname) {
2083                 free(caller_pkgname);
2084         }
2085         return NOTIFICATION_ERROR_NONE;
2086 }
2087
2088 EXPORT_API notification_error_e notification_delete_group_by_priv_id(const char *pkgname,
2089                                                                      notification_type_e type,
2090                                                                      int priv_id)
2091 {
2092         int ret = 0;
2093         char *caller_pkgname = NULL;
2094
2095         if (pkgname == NULL) {
2096                 caller_pkgname = _notification_get_pkgname_by_pid();
2097         } else {
2098                 caller_pkgname = strdup(pkgname);
2099         }
2100
2101         ret = notification_ipc_request_delete_single(type, caller_pkgname, priv_id);
2102         if (ret != NOTIFICATION_ERROR_NONE) {
2103                 return ret;
2104         }
2105
2106         if (caller_pkgname) {
2107                 free(caller_pkgname);
2108         }
2109         return NOTIFICATION_ERROR_NONE;
2110 }
2111
2112 EXPORT_API notification_error_e notification_delete_by_priv_id(const char *pkgname,
2113                                                                notification_type_e type,
2114                                                                int priv_id)
2115 {
2116         int ret = 0;
2117         char *caller_pkgname = NULL;
2118
2119         if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
2120                 return NOTIFICATION_ERROR_INVALID_DATA;
2121         }
2122
2123         if (pkgname == NULL) {
2124                 caller_pkgname = _notification_get_pkgname_by_pid();
2125         } else {
2126                 caller_pkgname = strdup(pkgname);
2127         }
2128
2129         ret = notification_ipc_request_delete_single(type, caller_pkgname, priv_id);
2130         if (ret != NOTIFICATION_ERROR_NONE) {
2131                 return ret;
2132         }
2133
2134         if (caller_pkgname) {
2135                 free(caller_pkgname);
2136         }
2137         return ret;
2138 }
2139
2140 EXPORT_API notification_error_e notification_delete(notification_h noti)
2141 {
2142         int ret = 0;
2143
2144         if (noti == NULL) {
2145                 return NOTIFICATION_ERROR_INVALID_DATA;
2146         }
2147
2148         ret = notification_ipc_request_delete_single(NOTIFICATION_TYPE_NONE, noti->caller_pkgname, noti->priv_id);
2149         if (ret != NOTIFICATION_ERROR_NONE) {
2150                 return ret;
2151         }
2152
2153         return NOTIFICATION_ERROR_NONE;
2154 }
2155
2156 EXPORT_API notification_error_e notification_update_progress(notification_h noti,
2157                                                              int priv_id,
2158                                                              double progress)
2159 {
2160         char *caller_pkgname = NULL;
2161         int input_priv_id = 0;
2162         double input_progress = 0.0;
2163
2164         if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
2165                 if (noti == NULL) {
2166                         return NOTIFICATION_ERROR_INVALID_DATA;
2167                 } else {
2168                         input_priv_id = noti->priv_id;
2169                 }
2170         } else {
2171                 input_priv_id = priv_id;
2172         }
2173
2174         if (noti == NULL) {
2175                 caller_pkgname = _notification_get_pkgname_by_pid();
2176         } else {
2177                 caller_pkgname = strdup(noti->caller_pkgname);
2178         }
2179
2180         if (progress < 0.0) {
2181                 input_progress = 0.0;
2182         } else if (progress > 1.0) {
2183                 input_progress = 1.0;
2184         } else {
2185                 input_progress = progress;
2186         }
2187
2188         notification_ongoing_update_progress(caller_pkgname, input_priv_id,
2189                                              input_progress);
2190
2191         if (caller_pkgname) {
2192                 free(caller_pkgname);
2193         }
2194
2195         return NOTIFICATION_ERROR_NONE;
2196 }
2197
2198 EXPORT_API notification_error_e notification_update_size(notification_h noti,
2199                                                          int priv_id,
2200                                                          double size)
2201 {
2202         char *caller_pkgname = NULL;
2203         int input_priv_id = 0;
2204         double input_size = 0.0;
2205
2206         if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
2207                 if (noti == NULL) {
2208                         return NOTIFICATION_ERROR_INVALID_DATA;
2209                 } else {
2210                         input_priv_id = noti->priv_id;
2211                 }
2212         } else {
2213                 input_priv_id = priv_id;
2214         }
2215
2216         if (noti == NULL) {
2217                 caller_pkgname = _notification_get_pkgname_by_pid();
2218         } else {
2219                 caller_pkgname = strdup(noti->caller_pkgname);
2220         }
2221
2222         if (size < 0.0) {
2223                 input_size = 0.0;
2224         } else {
2225                 input_size = size;
2226         }
2227
2228         notification_ongoing_update_size(caller_pkgname, input_priv_id,
2229                                          input_size);
2230
2231         if (caller_pkgname) {
2232                 free(caller_pkgname);
2233         }
2234
2235         return NOTIFICATION_ERROR_NONE;
2236 }
2237
2238 EXPORT_API notification_error_e notification_update_content(notification_h noti,
2239                                                          int priv_id,
2240                                                          const char *content)
2241 {
2242         char *caller_pkgname = NULL;
2243         int input_priv_id = 0;
2244
2245         if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
2246                 if (noti == NULL) {
2247                         return NOTIFICATION_ERROR_INVALID_DATA;
2248                 } else {
2249                         input_priv_id = noti->priv_id;
2250                 }
2251         } else {
2252                 input_priv_id = priv_id;
2253         }
2254
2255         if (noti == NULL) {
2256                 caller_pkgname = _notification_get_pkgname_by_pid();
2257         } else {
2258                 caller_pkgname = strdup(noti->caller_pkgname);
2259         }
2260
2261         notification_ongoing_update_content(caller_pkgname, input_priv_id,
2262                                          content);
2263
2264         if (caller_pkgname) {
2265                 free(caller_pkgname);
2266         }
2267
2268         return NOTIFICATION_ERROR_NONE;
2269 }
2270
2271 static notification_h _notification_create(notification_type_e type)
2272 {
2273         notification_h noti = NULL;
2274
2275         if (type <= NOTIFICATION_TYPE_NONE || type >= NOTIFICATION_TYPE_MAX) {
2276                 NOTIFICATION_ERR("INVALID TYPE : %d", type);
2277                 return NULL;
2278         }
2279
2280         noti = (notification_h) calloc(1, sizeof(struct _notification));
2281         if (noti == NULL) {
2282                 NOTIFICATION_ERR("NO MEMORY : noti == NULL");
2283                 return NULL;
2284         }
2285
2286         noti->type = type;
2287
2288         if (type == NOTIFICATION_TYPE_NOTI)
2289                 noti->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
2290         else if (type == NOTIFICATION_TYPE_ONGOING)
2291                 noti->layout = NOTIFICATION_LY_ONGOING_PROGRESS;
2292
2293         noti->caller_pkgname = _notification_get_pkgname_by_pid();
2294         noti->group_id = NOTIFICATION_GROUP_ID_NONE;
2295         noti->priv_id = NOTIFICATION_PRIV_ID_NONE;
2296         noti->sound_type = NOTIFICATION_SOUND_TYPE_NONE;
2297         noti->vibration_type = NOTIFICATION_VIBRATION_TYPE_NONE;
2298         noti->led_operation = NOTIFICATION_LED_OP_OFF;
2299         noti->display_applist = NOTIFICATION_DISPLAY_APP_ALL;
2300         /*!
2301          * \NOTE
2302          * Other fields are already initialized with ZERO.
2303          */
2304         return noti;
2305 }
2306
2307 EXPORT_API notification_h notification_new(notification_type_e type,
2308                                            int group_id, int priv_id)
2309 {
2310         return _notification_create(type);
2311 }
2312
2313 EXPORT_API notification_h notification_create(notification_type_e type)
2314 {
2315         return _notification_create(type);
2316 }
2317
2318 EXPORT_API notification_h notification_load(char *pkgname,
2319                                                       int priv_id)
2320 {
2321         int ret = 0;
2322         notification_h noti = NULL;
2323
2324         noti = (notification_h) malloc(sizeof(struct _notification));
2325         if (noti == NULL) {
2326                 NOTIFICATION_ERR("NO MEMORY : noti == NULL");
2327                 return NULL;
2328         }
2329         memset(noti, 0x00, sizeof(struct _notification));
2330
2331         ret = notification_noti_get_by_priv_id(noti, pkgname, priv_id);
2332         if (ret != NOTIFICATION_ERROR_NONE) {
2333                 notification_free(noti);
2334                 return NULL;
2335         }
2336
2337         return noti;
2338 }
2339
2340 EXPORT_API notification_error_e notification_clone(notification_h noti, notification_h *clone)
2341 {
2342         notification_h new_noti = NULL;
2343
2344         if (noti == NULL || clone == NULL) {
2345                 NOTIFICATION_ERR("INVALID PARAMETER.");
2346                 return NOTIFICATION_ERROR_INVALID_DATA;
2347         }
2348
2349         new_noti = (notification_h) malloc(sizeof(struct _notification));
2350         if (new_noti == NULL) {
2351                 NOTIFICATION_ERR("NO MEMORY : noti == NULL");
2352                 return NOTIFICATION_ERROR_NO_MEMORY;
2353         }
2354         memset(new_noti, 0x00, sizeof(struct _notification));
2355
2356         new_noti->type = noti->type;
2357         new_noti->layout = noti->layout;
2358
2359         new_noti->group_id = noti->group_id;
2360         new_noti->internal_group_id = noti->internal_group_id;
2361         new_noti->priv_id = noti->priv_id;
2362
2363         if(noti->caller_pkgname != NULL) {
2364                 new_noti->caller_pkgname = strdup(noti->caller_pkgname);
2365         } else {
2366                 new_noti->caller_pkgname = _notification_get_pkgname_by_pid();
2367         }
2368         if(noti->launch_pkgname != NULL) {
2369                 new_noti->launch_pkgname = strdup(noti->launch_pkgname);
2370         } else {
2371                 new_noti->launch_pkgname = NULL;
2372         }
2373
2374         if(noti->args != NULL) {
2375                 new_noti->args = bundle_dup(noti->args);
2376         } else {
2377                 new_noti->args = NULL;
2378         }
2379         if(noti->group_args != NULL) {
2380                 new_noti->group_args = bundle_dup(noti->group_args);
2381         } else {
2382                 new_noti->group_args = NULL;
2383         }
2384
2385         if(noti->b_execute_option != NULL) {
2386                 new_noti->b_execute_option = bundle_dup(noti->b_execute_option);
2387         } else {
2388                 new_noti->b_execute_option = NULL;
2389         }
2390         if(noti->b_service_responding != NULL) {
2391                 new_noti->b_service_responding = bundle_dup(noti->b_service_responding);
2392         } else {
2393                 new_noti->b_service_responding = NULL;
2394         }
2395         if(noti->b_service_single_launch != NULL) {
2396                 new_noti->b_service_single_launch = bundle_dup(noti->b_service_single_launch);
2397         } else {
2398                 new_noti->b_service_single_launch = NULL;
2399         }
2400         if(noti->b_service_multi_launch != NULL) {
2401                 new_noti->b_service_multi_launch = bundle_dup(noti->b_service_multi_launch);
2402         } else {
2403                 new_noti->b_service_multi_launch = NULL;
2404         }
2405
2406         new_noti->sound_type = noti->sound_type;
2407         if(noti->sound_path != NULL) {
2408                 new_noti->sound_path = strdup(noti->sound_path);
2409         } else {
2410                 new_noti->sound_path = NULL;
2411         }
2412         new_noti->vibration_type = noti->vibration_type;
2413         if(noti->vibration_path != NULL) {
2414                 new_noti->vibration_path = strdup(noti->vibration_path);
2415         } else {
2416                 new_noti->vibration_path = NULL;
2417         }
2418         new_noti->led_operation = noti->led_operation;
2419         new_noti->led_argb = noti->led_argb;
2420
2421         if(noti->domain != NULL) {
2422                 new_noti->domain = strdup(noti->domain);
2423         } else {
2424                 new_noti->domain = NULL;
2425         }
2426         if(noti->dir != NULL) {
2427                 new_noti->dir = strdup(noti->dir);
2428         } else {
2429                 new_noti->dir = NULL;
2430         }
2431
2432         if(noti->b_text != NULL) {
2433                 new_noti->b_text = bundle_dup(noti->b_text);
2434         } else {
2435                 new_noti->b_text = NULL;
2436         }
2437         if(noti->b_key != NULL) {
2438                 new_noti->b_key = bundle_dup(noti->b_key);
2439         } else {
2440                 new_noti->b_key = NULL;
2441         }
2442         if(noti->b_format_args != NULL) {
2443                 new_noti->b_format_args = bundle_dup(noti->b_format_args);
2444         } else {
2445                 new_noti->b_format_args = NULL;
2446         }
2447         new_noti->num_format_args = noti->num_format_args;
2448
2449         if(noti->b_image_path != NULL) {
2450                 new_noti->b_image_path = bundle_dup(noti->b_image_path);
2451         } else {
2452                 new_noti->b_image_path = NULL;
2453         }
2454
2455         new_noti->time = noti->time;
2456         new_noti->insert_time = noti->insert_time;
2457
2458         new_noti->flags_for_property = noti->flags_for_property;
2459         new_noti->display_applist = noti->display_applist;
2460
2461         new_noti->progress_size = noti->progress_size;
2462         new_noti->progress_percentage = noti->progress_percentage;
2463
2464         new_noti->app_icon_path = NULL;
2465         new_noti->app_name = NULL;
2466         new_noti->temp_title = NULL;
2467         new_noti->temp_content = NULL;
2468
2469         *clone = new_noti;
2470
2471         return NOTIFICATION_ERROR_NONE;
2472 }
2473
2474
2475 EXPORT_API notification_error_e notification_free(notification_h noti)
2476 {
2477         if (noti == NULL) {
2478                 return NOTIFICATION_ERROR_INVALID_DATA;
2479         }
2480
2481         if (noti->caller_pkgname) {
2482                 free(noti->caller_pkgname);
2483         }
2484         if (noti->launch_pkgname) {
2485                 free(noti->launch_pkgname);
2486         }
2487         if (noti->args) {
2488                 bundle_free(noti->args);
2489         }
2490         if (noti->group_args) {
2491                 bundle_free(noti->group_args);
2492         }
2493
2494         if (noti->b_execute_option) {
2495                 bundle_free(noti->b_execute_option);
2496         }
2497         if (noti->b_service_responding) {
2498                 bundle_free(noti->b_service_responding);
2499         }
2500         if (noti->b_service_single_launch) {
2501                 bundle_free(noti->b_service_single_launch);
2502         }
2503         if (noti->b_service_multi_launch) {
2504                 bundle_free(noti->b_service_multi_launch);
2505         }
2506
2507         if (noti->sound_path) {
2508                 free(noti->sound_path);
2509         }
2510         if (noti->vibration_path) {
2511                 free(noti->vibration_path);
2512         }
2513
2514         if (noti->domain) {
2515                 free(noti->domain);
2516         }
2517         if (noti->dir) {
2518                 free(noti->dir);
2519         }
2520
2521         if (noti->b_text) {
2522                 bundle_free(noti->b_text);
2523         }
2524         if (noti->b_key) {
2525                 bundle_free(noti->b_key);
2526         }
2527         if (noti->b_format_args) {
2528                 bundle_free(noti->b_format_args);
2529         }
2530
2531         if (noti->b_image_path) {
2532                 bundle_free(noti->b_image_path);
2533         }
2534
2535         if (noti->app_icon_path) {
2536                 free(noti->app_icon_path);
2537         }
2538         if (noti->app_name) {
2539                 free(noti->app_name);
2540         }
2541         if (noti->temp_title) {
2542                 free(noti->temp_title);
2543         }
2544         if (noti->temp_content) {
2545                 free(noti->temp_content);
2546         }
2547
2548         free(noti);
2549
2550         return NOTIFICATION_ERROR_NONE;
2551 }
2552
2553 EXPORT_API notification_error_e
2554 notification_resister_changed_cb(void (*changed_cb)
2555                                  (void *data, notification_type_e type),
2556                                  void *user_data)
2557 {
2558         notification_cb_list_s *noti_cb_list_new = NULL;
2559         notification_cb_list_s *noti_cb_list = NULL;
2560
2561         if (notification_ipc_monitor_init() != NOTIFICATION_ERROR_NONE) {
2562                 return NOTIFICATION_ERROR_IO;
2563         }
2564
2565         noti_cb_list_new =
2566             (notification_cb_list_s *) malloc(sizeof(notification_cb_list_s));
2567
2568         noti_cb_list_new->next = NULL;
2569         noti_cb_list_new->prev = NULL;
2570
2571         noti_cb_list_new->cb_type = NOTIFICATION_CB_NORMAL;
2572         noti_cb_list_new->changed_cb = changed_cb;
2573         noti_cb_list_new->detailed_changed_cb = NULL;
2574         noti_cb_list_new->data = user_data;
2575
2576         if (g_notification_cb_list == NULL) {
2577                 g_notification_cb_list = noti_cb_list_new;
2578         } else {
2579                 noti_cb_list = g_notification_cb_list;
2580
2581                 while (noti_cb_list->next != NULL) {
2582                         noti_cb_list = noti_cb_list->next;
2583                 }
2584
2585                 noti_cb_list->next = noti_cb_list_new;
2586                 noti_cb_list_new->prev = noti_cb_list;
2587         }
2588         return NOTIFICATION_ERROR_NONE;
2589 }
2590
2591 EXPORT_API notification_error_e
2592 notification_unresister_changed_cb(void (*changed_cb)
2593                                    (void *data, notification_type_e type))
2594 {
2595         notification_cb_list_s *noti_cb_list = NULL;
2596         notification_cb_list_s *noti_cb_list_prev = NULL;
2597         notification_cb_list_s *noti_cb_list_next = NULL;
2598
2599         noti_cb_list = g_notification_cb_list;
2600
2601         if (noti_cb_list == NULL) {
2602                 return NOTIFICATION_ERROR_INVALID_DATA;
2603         }
2604
2605         while (noti_cb_list->prev != NULL) {
2606                 noti_cb_list = noti_cb_list->prev;
2607         }
2608
2609         do {
2610                 if (noti_cb_list->changed_cb == changed_cb) {
2611                         noti_cb_list_prev = noti_cb_list->prev;
2612                         noti_cb_list_next = noti_cb_list->next;
2613
2614                         if (noti_cb_list_prev == NULL) {
2615                                 g_notification_cb_list = noti_cb_list_next;
2616                         } else {
2617                                 noti_cb_list_prev->next = noti_cb_list_next;
2618                         }
2619
2620                         if (noti_cb_list_next == NULL) {
2621                                 if (noti_cb_list_prev != NULL) {
2622                                         noti_cb_list_prev->next = NULL;
2623                                 }
2624                         } else {
2625                                 noti_cb_list_next->prev = noti_cb_list_prev;
2626                         }
2627
2628                         free(noti_cb_list);
2629
2630                         if (g_notification_cb_list == NULL)
2631                                 notification_ipc_monitor_fini();
2632
2633                         return NOTIFICATION_ERROR_NONE;
2634                 }
2635                 noti_cb_list = noti_cb_list->next;
2636         } while (noti_cb_list != NULL);
2637
2638         return NOTIFICATION_ERROR_INVALID_DATA;
2639 }
2640
2641 EXPORT_API notification_error_e
2642 notification_register_detailed_changed_cb(
2643                 void (*detailed_changed_cb)(void *data, notification_type_e type, notification_op *op_list, int num_op),
2644                 void *user_data)
2645 {
2646         notification_cb_list_s *noti_cb_list_new = NULL;
2647         notification_cb_list_s *noti_cb_list = NULL;
2648
2649         if (notification_ipc_monitor_init() != NOTIFICATION_ERROR_NONE) {
2650                 return NOTIFICATION_ERROR_IO;
2651         }
2652
2653         noti_cb_list_new =
2654             (notification_cb_list_s *) malloc(sizeof(notification_cb_list_s));
2655
2656         noti_cb_list_new->next = NULL;
2657         noti_cb_list_new->prev = NULL;
2658
2659         noti_cb_list_new->cb_type = NOTIFICATION_CB_DETAILED;
2660         noti_cb_list_new->changed_cb = NULL;
2661         noti_cb_list_new->detailed_changed_cb = detailed_changed_cb;
2662         noti_cb_list_new->data = user_data;
2663
2664         if (g_notification_cb_list == NULL) {
2665                 g_notification_cb_list = noti_cb_list_new;
2666         } else {
2667                 noti_cb_list = g_notification_cb_list;
2668
2669                 while (noti_cb_list->next != NULL) {
2670                         noti_cb_list = noti_cb_list->next;
2671                 }
2672
2673                 noti_cb_list->next = noti_cb_list_new;
2674                 noti_cb_list_new->prev = noti_cb_list;
2675         }
2676         return NOTIFICATION_ERROR_NONE;
2677 }
2678
2679 EXPORT_API notification_error_e
2680 notification_unregister_detailed_changed_cb(
2681                 void (*detailed_changed_cb)(void *data, notification_type_e type, notification_op *op_list, int num_op),
2682                 void *user_data)
2683 {
2684         notification_cb_list_s *noti_cb_list = NULL;
2685         notification_cb_list_s *noti_cb_list_prev = NULL;
2686         notification_cb_list_s *noti_cb_list_next = NULL;
2687
2688         noti_cb_list = g_notification_cb_list;
2689
2690         if (noti_cb_list == NULL) {
2691                 return NOTIFICATION_ERROR_INVALID_DATA;
2692         }
2693
2694         while (noti_cb_list->prev != NULL) {
2695                 noti_cb_list = noti_cb_list->prev;
2696         }
2697
2698         do {
2699                 if (noti_cb_list->detailed_changed_cb == detailed_changed_cb) {
2700                         noti_cb_list_prev = noti_cb_list->prev;
2701                         noti_cb_list_next = noti_cb_list->next;
2702
2703                         if (noti_cb_list_prev == NULL) {
2704                                 g_notification_cb_list = noti_cb_list_next;
2705                         } else {
2706                                 noti_cb_list_prev->next = noti_cb_list_next;
2707                         }
2708
2709                         if (noti_cb_list_next == NULL) {
2710                                 if (noti_cb_list_prev != NULL) {
2711                                         noti_cb_list_prev->next = NULL;
2712                                 }
2713                         } else {
2714                                 noti_cb_list_next->prev = noti_cb_list_prev;
2715                         }
2716
2717                         free(noti_cb_list);
2718
2719                         if (g_notification_cb_list == NULL)
2720                                 notification_ipc_monitor_fini();
2721
2722                         return NOTIFICATION_ERROR_NONE;
2723                 }
2724                 noti_cb_list = noti_cb_list->next;
2725         } while (noti_cb_list != NULL);
2726
2727         return NOTIFICATION_ERROR_INVALID_DATA;
2728 }
2729
2730 EXPORT_API notification_error_e
2731 notification_resister_badge_changed_cb(void (*changed_cb)
2732                                        (void *data, const char *pkgname,
2733                                         int group_id), void *user_data)
2734 {
2735         // Add DBus signal handler
2736         return NOTIFICATION_ERROR_NONE;
2737 }
2738
2739 EXPORT_API notification_error_e
2740 notification_unresister_badge_changed_cb(void (*changed_cb)
2741                                          (void *data, const char *pkgname,
2742                                           int group_id))
2743 {
2744         // Del DBus signal handler
2745         return NOTIFICATION_ERROR_NONE;
2746 }
2747
2748 EXPORT_API notification_error_e notification_get_count(notification_type_e type,
2749                                                        const char *pkgname,
2750                                                        int group_id,
2751                                                        int priv_id, int *count)
2752 {
2753         int ret = 0;
2754         int noti_count = 0;
2755
2756         ret =
2757             notification_noti_get_count(type, pkgname, group_id, priv_id,
2758                                         &noti_count);
2759         if (ret != NOTIFICATION_ERROR_NONE) {
2760                 return ret;
2761         }
2762
2763         if (count != NULL) {
2764                 *count = noti_count;
2765         }
2766
2767         return NOTIFICATION_ERROR_NONE;
2768 }
2769
2770 EXPORT_API notification_error_e notification_get_list(notification_type_e type,
2771                                                       int count,
2772                                                       notification_list_h *list)
2773 {
2774         notification_list_h get_list = NULL;
2775         int ret = 0;
2776
2777         ret = notification_noti_get_grouping_list(type, count, &get_list);
2778         if (ret != NOTIFICATION_ERROR_NONE) {
2779                 return ret;
2780         }
2781
2782         *list = get_list;
2783
2784         return NOTIFICATION_ERROR_NONE;
2785 }
2786
2787 EXPORT_API notification_error_e
2788 notification_get_grouping_list(notification_type_e type, int count,
2789                                notification_list_h * list)
2790 {
2791         notification_list_h get_list = NULL;
2792         int ret = 0;
2793
2794         ret = notification_noti_get_grouping_list(type, count, &get_list);
2795         if (ret != NOTIFICATION_ERROR_NONE) {
2796                 return ret;
2797         }
2798
2799         *list = get_list;
2800
2801         return NOTIFICATION_ERROR_NONE;
2802 }
2803
2804 EXPORT_API notification_error_e notification_get_detail_list(const char *pkgname,
2805                                                              int group_id,
2806                                                              int priv_id,
2807                                                              int count,
2808                                                              notification_list_h *list)
2809 {
2810         notification_list_h get_list = NULL;
2811         int ret = 0;
2812
2813         ret =
2814             notification_noti_get_detail_list(pkgname, group_id, priv_id, count,
2815                                               &get_list);
2816         if (ret != NOTIFICATION_ERROR_NONE) {
2817                 return ret;
2818         }
2819
2820         *list = get_list;
2821
2822         return NOTIFICATION_ERROR_NONE;
2823 }
2824
2825 EXPORT_API notification_error_e notification_free_list(notification_list_h list)
2826 {
2827         notification_list_h cur_list = NULL;
2828         notification_h noti = NULL;
2829
2830         if (list == NULL) {
2831                 NOTIFICATION_ERR("INVALID DATA : list == NULL");
2832                 return NOTIFICATION_ERROR_INVALID_DATA;
2833         }
2834
2835         cur_list = notification_list_get_head(list);
2836
2837         while (cur_list != NULL) {
2838                 noti = notification_list_get_data(cur_list);
2839                 cur_list = notification_list_remove(cur_list, noti);
2840
2841                 notification_free(noti);
2842         }
2843
2844         return NOTIFICATION_ERROR_NONE;
2845 }
2846
2847 EXPORT_API notification_error_e notification_op_get_data(notification_op *noti_op, notification_op_data_type_e type,
2848                                                        void *data)
2849 {
2850         if (noti_op == NULL || data == NULL) {
2851                 return NOTIFICATION_ERROR_INVALID_DATA;
2852         }
2853
2854         switch (type) {
2855                 case NOTIFICATION_OP_DATA_TYPE:
2856                         *((int*)data) = noti_op->type;
2857                         break;
2858                 case NOTIFICATION_OP_DATA_PRIV_ID:
2859                         *((int*)data) = noti_op->priv_id;
2860                         break;
2861                 case NOTIFICATION_OP_DATA_NOTI:
2862                         *((notification_h *)data) = noti_op->noti;
2863                         break;
2864                 case NOTIFICATION_OP_DATA_EXTRA_INFO_1:
2865                         *((int*)data) = noti_op->extra_info_1;
2866                         break;
2867                 case NOTIFICATION_OP_DATA_EXTRA_INFO_2:
2868                         *((int*)data) = noti_op->extra_info_2;
2869                         break;
2870                 default:
2871                         return NOTIFICATION_ERROR_INVALID_DATA;
2872                         break;
2873         }
2874
2875         return NOTIFICATION_ERROR_NONE;
2876 }
2877
2878 void notification_call_changed_cb(notification_op *op_list, int op_num)
2879 {
2880         notification_cb_list_s *noti_cb_list = NULL;
2881
2882
2883         if (g_notification_cb_list == NULL) {
2884                 return;
2885         }
2886         noti_cb_list = g_notification_cb_list;
2887
2888         while (noti_cb_list->prev != NULL) {
2889                 noti_cb_list = noti_cb_list->prev;
2890         }
2891
2892         if (op_list == NULL) {
2893                 NOTIFICATION_ERR("invalid data");
2894                 return ;
2895         }
2896
2897         while (noti_cb_list != NULL) {
2898                 if (noti_cb_list->cb_type == NOTIFICATION_CB_NORMAL && noti_cb_list->changed_cb) {
2899                         noti_cb_list->changed_cb(noti_cb_list->data,
2900                                                  NOTIFICATION_TYPE_NOTI);
2901                 }
2902                 if (noti_cb_list->cb_type == NOTIFICATION_CB_DETAILED && noti_cb_list->detailed_changed_cb) {
2903                         noti_cb_list->detailed_changed_cb(noti_cb_list->data,
2904                                                  NOTIFICATION_TYPE_NOTI, op_list, op_num);
2905                 }
2906
2907                 noti_cb_list = noti_cb_list->next;
2908         }
2909 }
2910
2911 EXPORT_API int notification_is_service_ready(void)
2912 {
2913         return notification_ipc_is_master_ready();
2914 }
2915
2916 EXPORT_API notification_error_e
2917 notification_add_deffered_task(
2918                 void (*deffered_task_cb)(void *data), void *user_data)
2919 {
2920         return notification_ipc_add_deffered_task(deffered_task_cb, user_data);
2921 }
2922
2923 EXPORT_API notification_error_e
2924 notification_del_deffered_task(
2925                 void (*deffered_task_cb)(void *data))
2926 {
2927         return notification_ipc_del_deffered_task(deffered_task_cb);
2928 }