src/notification.c

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