include/notification.h

   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 #ifndef __NOTIFICATION_H__
  23 #define __NOTIFICATION_H__
  24
  25 #include <time.h>
  26 #include <bundle.h>
  27
  28 #include <notification_error.h>
  29 #include <notification_type.h>
  30 #include <notification_list.h>
  31 #include <notification_status.h>
  32 #include <notification_setting.h>
  33
  34 #ifdef __cplusplus
  35 extern "C" {
  36 #endif
  37
  38 /**
  39  * @file notification.h
  40  * @brief This file contains the notification APIs
  41  */
  42
  43 /**
  44  * @addtogroup NOTIFICATION_MODULE
  45  * @{
  46  */
  47
  48 /**
  49  * @brief Set absolute path for image file to display on notification view
  50  * @details
  51  * @remarks
  52  * @param[in] noti notification handle
  53  * @param[in] type notification image type
  54  * @param[in] image_path image file full path
  55  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
  56  * @retval NOTIFICATION_ERROR_NONE - success
  57  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
  58  * @pre Notification handle should be created by notification_new()
  59  * @post
  60  * @see #notification_image_type_e
  61  * @see notification_new()
  62  * @par Sample code:
  63  * @code
  64 #include <notification.h>
  65 ...
  66 {
  67         notification_h noti = NULL;
  68         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
  69
  70         noti = notification_new(NOTIFICATION_TYPE_NOTI, APP_GROUP_ID, NOTIFICATION_PRIV_ID_NONE);
  71         if(noti == NULL) {
  72                 return;
  73         }
  74
  75         noti_err  = notification_set_image(noti, NOTIFICATION_IMAGE_TYPE_ICON, APP_IMAGE_FULL_PATH);
  76         if(noti_err != NOTIFICATION_ERROR_NONE) {
  77                 notification_free(noti);
  78                 return;
  79         }
  80 }
  81  * @endcode
  82  */
  83 notification_error_e notification_set_image(notification_h noti,
  84                                             notification_image_type_e type,
  85                                             const char *image_path);
  86
  87 /**
  88  * @brief Get absolute path for image file
  89  * @details
  90  * @remarks Do not free image_path. It will be freed when notification_free() or notification_free_list().
  91  * @param[in] noti notification handle
  92  * @param[in] type notification image type
  93  * @param[out] image_path image file full path
  94  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
  95  * @retval NOTIFICATION_ERROR_NONE - success
  96  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
  97  * @pre Notification handle should be created by notification_new()
  98  * @post
  99  * @see #notification_image_type_e
 100  * @see notification_new()
 101  * @par Sample code:
 102  * @code
 103  #include <notification.h>
 104  ...
 105  {
 106         char *image_path = NULL;
 107         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 108
 109         noti_err  = notification_get_image(noti, NOTIFICATION_IMAGE_TYPE_ICON, &image_path);
 110         if(noti_err != NOTIFICATION_ERROR_NONE) {
 111                 return;
 112         }
 113 }
 114  * @endcode
 115  */
 116 notification_error_e notification_get_image(notification_h noti,
 117                                             notification_image_type_e type,
 118                                             char **image_path);
 119
 120 /**
 121  * @brief Set a timestamp
 122  * @details If input_time is 0, time information is set by current time.
 123  * @remarks
 124  * @param[in] noti notification handle
 125  * @param[in] input_time input time
 126  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 127  * @retval NOTIFICATION_ERROR_NONE - success
 128  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 129  * @pre Notification handle should be created by notification_new()
 130  * @post
 131  * @see notification_new()
 132  * @par Sample code:
 133  * @code
 134 #include <notification.h>
 135  ...
 136   {
 137          notification_h noti = NULL;
 138          notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 139
 140          noti = notification_new(NOTIFICATION_TYPE_NOTI, APP_GROUP_ID, NOTIFICATION_PRIV_ID_NONE);
 141          if(noti == NULL) {
 142                  return;
 143          }
 144
 145          noti_err  = notification_set_time(noti, time(NULL));
 146          if(noti_err != NOTIFICATION_ERROR_NONE) {
 147                 notification_free(noti);
 148                  return;
 149          }
 150  }
 151  * @endcode
 152  */
 153 notification_error_e notification_set_time(notification_h noti,
 154                                            time_t input_time);
 155
 156 /**
 157  * @brief Get a timestamp
 158  * @details If ret_time is 0, time information is not set before.
 159  * @remarks
 160  * @param[in] noti notification handle
 161  * @param[out] ret_time return time value
 162  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 163  * @retval NOTIFICATION_ERROR_NONE - success
 164  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 165  * @pre Notification handle should be created by notification_new()
 166  * @post
 167  * @see notification_new()
 168  * @par Sample code:
 169  * @code
 170  #include <notification.h>
 171  ...
 172  {
 173         time_t ret_time;
 174         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 175
 176         noti_err  = notification_get_time(noti, &ret_time);
 177         if(noti_err != NOTIFICATION_ERROR_NONE) {
 178                 return;
 179         }
 180 }
 181  * @endcode
 182  */
 183 notification_error_e notification_get_time(notification_h noti,
 184                                            time_t * ret_time);
 185
 186 /**
 187  * @brief Get timestamp that the notification is inserted
 188  * @details If ret_time is 0, this notification data is not inserted before.
 189  * @remarks
 190  * @param[in] noti notification handle
 191  * @param[out] ret_time return time value
 192  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 193  * @retval NOTIFICATION_ERROR_NONE - success
 194  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 195  * @pre
 196  * @post
 197  * @see
 198  * @par Sample code:
 199  * @code
 200  #include <notification.h>
 201   ...
 202   {
 203          time_t ret_time;
 204          notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 205
 206          noti_err  = notification_get_insert_time(noti, &ret_time);
 207          if(noti_err != NOTIFICATION_ERROR_NONE) {
 208                  return;
 209          }
 210  }
 211  * @endcode
 212  */
 213 notification_error_e notification_get_insert_time(notification_h noti,
 214                                                   time_t * ret_time);
 215
 216 /**
 217  * @brief Set text to display on the notification view
 218  * @details Set title, content string. If text is formated data(only support %d, %f, %s), type - value pair should be set.
 219  * If %d, type NOTIFICATION_VARIABLE_TYPE_INT and value is integer value.
 220  * If %f, type NOTIFICATION_VARIABLE_TYPE_DOUBLE and value is double value.
 221  * If %s, type NOTIFICATION_VARIABLE_TYPE_STRING and value is character string.
 222  * If type is NOTIFICATION_VARIABLE_TYPE_COUNT, notification count is displaying with text.
 223  * If value is NOTIFICATION_COUNT_POS_LEFT, count is displaying at the left of the text.
 224  * If value is NOTIFICATION_COUNT_POS_IN, count is displaying in the text that text has %d format.
 225  * If value is NOTIFICATION_COUNT_POS_RIGHT, count is displaying at the right of the text.
 226  * Variable parameter should be terminated NOTIFICATION_VARIABLE_TYPE_NONE.
 227  * @remarks
 228  * @param[in] noti notification handle
 229  * @param[in] type notification text type
 230  * @param[in] text basic text
 231  * @param[in] key text key for localization
 232  * @param[in] args_type variable parameter that type - value pair.
 233  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 234  * @retval NOTIFICATION_ERROR_NONE - success
 235  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 236  * @pre notification handle should be created by notification_new().
 237  * @post
 238  * @see
 239  * @par Sample code:
 240  * @code
 241 #include <notification.h>
 242 ...
 243 {
 244         notification_h noti = NULL;
 245         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 246
 247         noti = notification_new(NOTIFICATION_TYPE_NOTI, APP_GROUP_ID, NOTIFICATION_PRIV_ID_NONE);
 248         if(noti == NULL) {
 249                 return;
 250         }
 251
 252         noti_err  = notification_set_text(noti, NOTIFICATION_TEXT_TYPE_TITLE, "I'm Title", "IDS_APP_BODY_IM_TITLE", NOTIFICATION_VARIABLE_TYPE_NONE);
 253         if(noti_err != NOTIFICATION_ERROR_NONE) {
 254                 notification_free(noti);
 255                 return;
 256         }
 257 }
 258  * @endcode
 259  */
 260 notification_error_e notification_set_text(notification_h noti,
 261                                            notification_text_type_e type,
 262                                            const char *text,
 263                                            const char *key,
 264                                            int args_type, ...);
 265
 266 /**
 267  * @brief Get the text from the notification handle
 268  * @details
 269  * @remarks
 270  * @param[in] noti notification handle
 271  * @param[in] type notification text type.
 272  * @param[out] text text
 273  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 274  * @retval NOTIFICATION_ERROR_NONE - success
 275  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 276  * @pre
 277  * @post
 278  * @see
 279  * @par Sample code:
 280  * @code
 281 #include <notification.h>
 282 ...
 283 {
 284         notification_h noti = NULL;
 285         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 286         char *text = NULL;
 287
 288         noti_err  = notification_get_text(noti, NOTIFICATION_TEXT_TYPE_TITLE, &text);
 289         if(noti_err != NOTIFICATION_ERROR_NONE) {
 290                 return;
 291         }
 292 }
 293  * @endcode
 294  */
 295 notification_error_e notification_get_text(notification_h noti,
 296                                            notification_text_type_e type,
 297                                            char **text);
 298
 299 /**
 300  * @brief Set a timestamp to display on the notification view
 301  * @details the timestamp will be converted to formatted string and it will be displayed on the setted text area
 302  * @remarks
 303  * @param[in] noti notification handle
 304  * @param[in] type notification text type
 305  * @param[in] time time stamp
 306  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 307  * @retval NOTIFICATION_ERROR_NONE - success
 308  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 309  * @pre notification handle should be created by notification_new().
 310  * @post
 311  * @see
 312  */
 313 notification_error_e notification_set_time_to_text(notification_h noti, notification_text_type_e type,
 314                                                                 time_t time);
 315
 316 /**
 317  * @brief Get a timestamp from the notification handle
 318  * @details
 319  * @remarks
 320  * @param[in] noti notification handle
 321  * @param[in] type notification text type
 322  * @param[in] time pointer of time stamp
 323  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 324  * @retval NOTIFICATION_ERROR_NONE - success
 325  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 326  * @pre notification handle should be created by notification_new().
 327  * @post
 328  * @see
 329  */
 330 notification_error_e notification_get_time_from_text(notification_h noti, notification_text_type_e type,
 331                                                                 time_t *time);
 332
 333 /**
 334  * @brief Set text domain to localize the notification
 335  * @details
 336  * @remarks
 337  * @param[in] noti notification handle
 338  * @param[in] domain text domain
 339  * @param[in] dir text dir
 340  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 341  * @retval NOTIFICATION_ERROR_NONE - success
 342  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 343  * @pre
 344  * @post
 345  * @see
 346  * @par Sample code:
 347  * @code
 348 #include <notification.h>
 349 ...
 350 {
 351         notification_h noti = NULL;
 352         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 353
 354         noti = notification_new(NOTIFICATION_TYPE_NOTI, APP_GROUP_ID, NOTIFICATION_PRIV_ID_NONE);
 355         if(noti == NULL) {
 356                 return;
 357         }
 358
 359         noti_err  = notification_set_text_domain(noti, PACKAGE, LOCALEDIR);
 360         if(noti_err != NOTIFICATION_ERROR_NONE) {
 361                 notification_free(noti);
 362                 return;
 363         }
 364 }
 365  * @endcode
 366  */
 367 notification_error_e notification_set_text_domain(notification_h noti,
 368                                                   const char *domain,
 369                                                   const char *dir);
 370
 371 /**
 372  * @brief Get text domain from the notification handle
 373  * @details
 374  * @remarks Do not free returned domain and dir. These are freed when notification_free or notification_free_list.
 375  * @param[in] noti notification handle
 376  * @param[out] domain domain
 377  * @param[out] dir locale dir
 378  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 379  * @retval NOTIFICATION_ERROR_NONE - success
 380  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 381  * @pre
 382  * @post
 383  * @see
 384  * @par Sample code:
 385  * @code
 386 #include <notification.h>
 387 ...
 388 {
 389         notification_h noti = NULL;
 390         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 391         char *domain = NULL;
 392         char *dir = NULL;
 393
 394         noti_err  = notification_get_text_domain(noti, &domain, &dir);
 395         if(noti_err != NOTIFICATION_ERROR_NONE) {
 396                 return;
 397         }
 398 }
 399  * @endcode
 400  */
 401 notification_error_e notification_get_text_domain(notification_h noti,
 402                                                   char **domain,
 403                                                   char **dir);
 404
 405 /**
 406  * @brief Set sound option for the notification
 407  * @details
 408  * @remarks
 409  * @param[in] noti notification handle
 410  * @param[in] type notification sound type
 411  * @param[in] path user sound file path
 412  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 413  * @retval NOTIFICATION_ERROR_NONE - success
 414  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 415  * @pre
 416  * @post
 417  * @see
 418  * @par Sample code:
 419  * @code
 420 #include <notification.h>
 421 ...
 422 {
 423         notification_h noti = NULL;
 424         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 425
 426         noti_err  = notification_set_sound(noti, NOTIFICATION_SOUND_TYPE_DEFAULT, NULL);
 427         if(noti_err != NOTIFICATION_ERROR_NONE) {
 428                 return;
 429         }
 430 }
 431  * @endcode
 432  */
 433 notification_error_e notification_set_sound(notification_h noti,
 434                                             notification_sound_type_e type,
 435                                             const char *path);
 436
 437 /**
 438  * @brief Get sound option from the notification handle
 439  * @details
 440  * @remarks
 441  * @param[in] noti notification handle
 442  * @param[out] type notification sound type
 443  * @param[out] path user sound file path
 444  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 445  * @retval NOTIFICATION_ERROR_NONE - success
 446  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 447  * @pre
 448  * @post
 449  * @see
 450  * @par Sample code:
 451  * @code
 452 #include <notification.h>
 453 ...
 454 {
 455         notification_h noti = NULL;
 456         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 457         notification_sound_type_e type = NOTIFICATION_SOUND_TYPE_NONE;
 458
 459         noti_err  = notification_get_sound(noti, &type, NULL);
 460         if(noti_err != NOTIFICATION_ERROR_NONE) {
 461                 return;
 462         }
 463 }
 464  * @endcode
 465  */
 466 notification_error_e notification_get_sound(notification_h noti,
 467                                             notification_sound_type_e *type,
 468                                             const char **path);
 469
 470 /**
 471  * @brief Set vibrate option for the notification
 472  * @details
 473  * @remarks
 474  * @param[in] noti notification handle
 475  * @param[in] type notification vibration type
 476  * @param[in] path user vibration file path
 477  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 478  * @retval NOTIFICATION_ERROR_NONE - success
 479  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 480  * @pre
 481  * @post
 482  * @see
 483  * @par Sample code:
 484  * @code
 485 #include <notification.h>
 486 ...
 487 {
 488         notification_h noti = NULL;
 489         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 490
 491         noti_err  = notification_set_vibration(noti, NOTIFICATION_VIBRATION_TYPE_DEFAULT, NULL);
 492         if(noti_err != NOTIFICATION_ERROR_NONE) {
 493                 return;
 494         }
 495 }
 496  * @endcode
 497  */
 498 notification_error_e notification_set_vibration(notification_h noti,
 499                                                 notification_vibration_type_e type,
 500                                                 const char *path);
 501
 502 /**
 503   * @brief Get vibrate option from the notification handle
 504   * @details
 505   * @remarks
 506   * @param[in] noti notification handle
 507   * @param[out] type notification sound type
 508   * @param[out] path user vibration file path
 509   * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 510   * @retval NOTIFICATION_ERROR_NONE - success
 511   * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 512   * @pre
 513   * @post
 514   * @see
 515   * @par Sample code:
 516   * @code
 517 #include <notification.h>
 518 ...
 519  {
 520         notification_h noti = NULL;
 521         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 522         notification_vibration_type_e type = NOTIFICATION_VIBRATION_TYPE_NONE;
 523
 524         noti_err  = notification_get_vibration(noti, &type, NULL);
 525         if(noti_err != NOTIFICATION_ERROR_NONE) {
 526                 return;
 527         }
 528 }
 529   * @endcode
 530   */
 531 notification_error_e notification_get_vibration(notification_h noti,
 532                                                 notification_vibration_type_e *type,
 533                                                 const char **path);
 534
 535 /**
 536  * @brief Set option of displaying the LED
 537  * @details
 538  * @remarks
 539  * @param[in] noti notification handle
 540  * @param[in] operation led notification operation
 541  * @param[in] led_argb notification led color
 542  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 543  * @retval NOTIFICATION_ERROR_NONE - success
 544  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 545  * @pre
 546  * @post
 547  * @see
 548  * @par Sample code:
 549  * @code
 550 #include <notification.h>
 551 ...
 552 {
 553         notification_h noti = NULL;
 554         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 555
 556         noti_err  = notification_set_led(noti, NOTIFICATION_LED_TYPE_DEFAULT, NULL);
 557         if(noti_err != NOTIFICATION_ERROR_NONE) {
 558                 return;
 559         }
 560 }
 561  * @endcode
 562  */
 563 notification_error_e notification_set_led(notification_h noti,
 564                                                 notification_led_op_e operation,
 565                                                 int led_argb);
 566
 567 /**
 568   * @brief Get option of displaying the LED from the notification handle
 569   * @details
 570   * @remarks
 571   * @param[in] noti notification handle
 572   * @param[out] operation led notification operation
 573   * @param[out] led_argb notification led color
 574   * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 575   * @retval NOTIFICATION_ERROR_NONE - success
 576   * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 577   * @pre
 578   * @post
 579   * @see
 580   * @par Sample code:
 581   * @code
 582 #include <notification.h>
 583 ...
 584  {
 585         notification_h noti = NULL;
 586         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 587         notification_led_type_e type = NOTIFICATION_LED_TYPE_NONE;
 588
 589         noti_err  = notification_get_led(noti, &type, NULL);
 590         if(noti_err != NOTIFICATION_ERROR_NONE) {
 591                 return;
 592         }
 593 }
 594   * @endcode
 595   */
 596 notification_error_e notification_get_led(notification_h noti,
 597                                                 notification_led_op_e *operation,
 598                                                 int *led_argb);
 599
 600 /**
 601  * @brief Set time period of flashing the LED
 602  * @details
 603  * @remarks
 604  * @param[in] noti notification handle
 605  * @param[in] on_ms time for turning on the LED
 606  * @param[in] off_ms time for turning on the LED
 607  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 608  * @retval NOTIFICATION_ERROR_NONE - success
 609  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 610  * @pre
 611  * @post
 612  * @see
 613  * @par Sample code:
 614  * @code
 615 #include <notification.h>
 616 ...
 617 {
 618         notification_h noti = NULL;
 619         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 620
 621         noti_err  = notification_set_led_time_period(noti, 100, 100);
 622         if(noti_err != NOTIFICATION_ERROR_NONE) {
 623                 return;
 624         }
 625 }
 626  * @endcode
 627  */
 628 notification_error_e notification_set_led_time_period(notification_h noti,
 629                                                 int on_ms, int off_ms);
 630
 631 /**
 632   * @brief Get time period of flashing the LED from the notification handle
 633   * @details
 634   * @remarks
 635   * @param[in] noti notification handle
 636   * @param[out] on_ms time for turning on the LED
 637   * @param[out] off_ms time for turning on the LED
 638   * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 639   * @retval NOTIFICATION_ERROR_NONE - success
 640   * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 641   * @pre
 642   * @post
 643   * @see
 644   * @par Sample code:
 645   * @code
 646 #include <notification.h>
 647 ...
 648  {
 649         notification_h noti = NULL;
 650         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 651         int led_on_ms = 0;
 652         int led_off_ms = 0;
 653
 654         noti_err  = notification_get_led_time_period(noti, &led_on_ms, &led_off_ms);
 655         if(noti_err != NOTIFICATION_ERROR_NONE) {
 656                 return;
 657         }
 658 }
 659   * @endcode
 660   */
 661 notification_error_e notification_get_led_time_period(notification_h noti,
 662                                                 int *on_ms, int *off_ms);
 663
 664 /**
 665  * @brief Set execution option for a notification
 666  * @details When notification data selected in display application, application launched by appsvc_run_service with service_handle.
 667  * @remarks
 668  * @param[in] noti notification handle
 669  * @param[in] type notification execute type
 670  * @param[in] text basic text for button
 671  * @param[in] key value for localizaed text
 672  * @param[in] service_handle appsvc bundle data
 673  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 674  * @retval NOTIFICATION_ERROR_NONE - success
 675  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 676  * @pre
 677  * @post
 678  * @see
 679  * @par Sample code:
 680  * @code
 681 #include <notification.h>
 682 ...
 683 {
 684         notification_h noti = NULL;
 685         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 686         bundle *b = NULL;
 687
 688         ...
 689
 690         b = bundle_create();
 691         appsvc_set_operation(b, APPSVC_OPERATION_VIEW);
 692         appsvc_set_uri(b,"http://www.samsung.com");
 693
 694         noti_err  = notification_set_execute_option(noti, NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH, NULL, NULL, b);
 695         if(noti_err != NOTIFICATION_ERROR_NONE) {
 696                 notification_free(noti);
 697                 return;
 698         }
 699
 700         bundle_free(b);
 701 }
 702  * @endcode
 703  */
 704 notification_error_e notification_set_execute_option(notification_h noti,
 705                                                      notification_execute_type_e type,
 706                                                      const char *text,
 707                                                      const char *key,
 708                                                      bundle *service_handle);
 709
 710 /**
 711  * @brief Get execution option from the notification handle
 712  * @details
 713  * @remarks
 714  * @param[in] noti notification handle
 715  * @param[in] type notification execute type
 716  * @param[out] text text for button
 717  * @param[out] service_handle appsvc bundle data
 718  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 719  * @retval NOTIFICATION_ERROR_NONE - success
 720  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
 721  * @pre
 722  * @post
 723  * @see
 724  * @par Sample code:
 725  * @code
 726 #include <notification.h>
 727 ...
 728 {
 729         notification_h noti = NULL;
 730         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 731         bundle *b = NULL;
 732
 733         ...
 734
 735         noti_err  = notification_get_execute_option(noti, NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH, NULL, NULL, &b);
 736         if(noti_err != NOTIFICATION_ERROR_NONE) {
 737                 notification_free(noti);
 738                 return;
 739         }
 740 }
 741  * @endcode
 742  */
 743 notification_error_e notification_get_execute_option(notification_h noti,
 744                                                      notification_execute_type_e type,
 745                                                      const char **text,
 746                                                      bundle **service_handle);
 747
 748 /**
 749  * @brief Set the property of the notification
 750  * @details
 751  * @remarks
 752  * @param[in] noti notification handle
 753  * @param[in] flags property with | operation
 754  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 755  * @retval NOTIFICATION_ERROR_NONE - success
 756  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
 757  * @pre
 758  * @post
 759  * @see
 760  * @par Sample code:
 761  * @code
 762 #include <notification.h>
 763 ...
 764 {
 765         notification_h noti = NULL;
 766         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 767         bundle *b = NULL;
 768
 769         noti = notification_new(NOTIFICATION_TYPE_NOTI, APP_GROUP_ID, NOTIFICATION_PRIV_ID_NONE);
 770         if(noti == NULL) {
 771                 return;
 772         }
 773
 774         noti_err  = notification_set_property(noti, NOTIFICATION_PROP_DISPLAY_ONLY_SIMMODE | NOTIFICATION_PROP_DISABLE_APP_LAUNCH);
 775         if(noti_err != NOTIFICATION_ERROR_NONE) {
 776                 notification_free(noti);
 777                 return;
 778         }
 779 }
 780  * @endcode
 781  */
 782 notification_error_e notification_set_property(notification_h noti,
 783                                                int flags);
 784
 785 /**
 786  * @brief Get the property of the notification from the notification handle
 787  * @details
 788  * @remarks
 789  * @param[in] noti notification handle
 790  * @param[out] flags notification property
 791  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 792  * @retval NOTIFICATION_ERROR_NONE - success
 793  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
 794  * @pre
 795  * @post
 796  * @see
 797  * @par Sample code:
 798  * @code
 799 #include <notification.h>
 800 ...
 801 {
 802         notification_h noti = NULL;
 803         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 804         int flags = 0;
 805
 806         noti_err  = notification_get_property(noti, &flags);
 807         if(noti_err != NOTIFICATION_ERROR_NONE) {
 808                 return;
 809         }
 810 }
 811  * @endcode
 812  */
 813 notification_error_e notification_get_property(notification_h noti,
 814                                                int *flags);
 815
 816 /**
 817  * @brief Set applications to display the notification
 818  * @details All display application is enable(NOTIFICATION_DISPLAY_APP_ALL) if you are not call this API.
 819  * @remarks
 820  * @param[in] noti notification handle
 821  * @param[in] applist with | operation
 822  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 823  * @retval NOTIFICATION_ERROR_NONE - success
 824  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
 825  * @pre
 826  * @post
 827  * @see
 828  * @par Sample code:
 829  * @code
 830 #include <notification.h>
 831 ...
 832 {
 833         notification_h noti = NULL;
 834         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 835         bundle *b = NULL;
 836
 837         noti = notification_new(NOTIFICATION_TYPE_NOTI, APP_GROUP_ID, NOTIFICATION_PRIV_ID_NONE);
 838         if(noti == NULL) {
 839                 return;
 840         }
 841
 842         noti_err  = notification_set_display_applist(noti, NOTIFICATION_DISPLAY_APP_NOTIFICATION_TRAY | NOTIFICATION_DISPLAY_APP_TICKER);
 843         if(noti_err != NOTIFICATION_ERROR_NONE) {
 844                 notification_free(noti);
 845                 return;
 846         }
 847 }
 848 }
 849  * @endcode
 850  */
 851 notification_error_e notification_set_display_applist(notification_h noti,
 852                                                       int applist);
 853
 854 /**
 855  * @brief Get application list to display the notification from the notification handle
 856  * @details
 857  * @remarks
 858  * @param[in] noti notification handle
 859  * @param[out] applist display application list.
 860  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 861  * @retval NOTIFICATION_ERROR_NONE - success
 862  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
 863  * @pre
 864  * @post
 865  * @see
 866  * @par Sample code:
 867  * @code
 868 #include <notification.h>
 869 ...
 870 {
 871         notification_h noti = NULL;
 872         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 873         int applist = 0;
 874
 875         noti_err  = notification_get_display_applist(noti, &applist);
 876         if(noti_err != NOTIFICATION_ERROR_NONE) {
 877                 return;
 878         }
 879 }
 880  * @endcode
 881  */
 882 notification_error_e notification_get_display_applist(notification_h noti,
 883                                                       int *applist);
 884
 885 /**
 886  * @brief Set initial size for ongoing type.
 887  * @details After notification_insert, it does not upate size. If you want to update size, please call notification_update_size().
 888  * @remarks
 889  * @param[in] noti notification handle
 890  * @param[in] size double type size.
 891  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 892  * @retval NOTIFICATION_ERROR_NONE - success
 893  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
 894  * @pre
 895  * @post
 896  * @see
 897  * @par Sample code:
 898  * @code
 899 #include <notification.h>
 900 ...
 901 {
 902         notification_h noti = NULL;
 903         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 904
 905         noti = notification_new(NOTIFICATION_TYPE_NOTI, APP_GROUP_ID, NOTIFICATION_PRIV_ID_NONE);
 906         if(noti == NULL) {
 907                 return;
 908         }
 909
 910         noti_err  = notification_set_size(noti, 0.0);
 911         if(noti_err != NOTIFICATION_ERROR_NONE) {
 912                 notification_free(noti);
 913                 return;
 914         }
 915 }
 916  * @endcode
 917  */
 918 notification_error_e notification_set_size(notification_h noti,
 919                                            double size);
 920
 921 /**
 922  * @brief Get progress size.
 923  * @details
 924  * @remarks
 925  * @param[in] noti notification handle
 926  * @param[out] size progress size
 927  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 928  * @retval NOTIFICATION_ERROR_NONE - success
 929  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
 930  * @pre
 931  * @post
 932  * @see
 933  * @par Sample code:
 934  * @code
 935 #include <notification.h>
 936 ...
 937 {
 938         notification_h noti = NULL;
 939         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 940         double size = 0.0;
 941
 942         noti_err  = notification_get_size(noti, &size);
 943         if(noti_err != NOTIFICATION_ERROR_NONE) {
 944                 return;
 945         }
 946 }
 947  * @endcode
 948  */
 949 notification_error_e notification_get_size(notification_h noti,
 950                                            double *size);
 951
 952 /**
 953  * @brief Set initial progress for ongoing type.
 954  * @details After notification_insert, it does not upate progress. If you want to update progress, please call notification_update_progress().
 955  * @remarks
 956  * @param[in] noti notification handle
 957  * @param[in] percentage progress percentage
 958  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 959  * @retval NOTIFICATION_ERROR_NONE - success
 960  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
 961  * @pre
 962  * @post
 963  * @see
 964  * @par Sample code:
 965  * @code
 966 #include <notification.h>
 967 ...
 968 {
 969         notification_h noti = NULL;
 970         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
 971
 972         noti = notification_new(NOTIFICATION_TYPE_NOTI, APP_GROUP_ID, NOTIFICATION_PRIV_ID_NONE);
 973         if(noti == NULL) {
 974                 return;
 975         }
 976
 977         noti_err  = notification_set_progress(noti, 0.0);
 978         if(noti_err != NOTIFICATION_ERROR_NONE) {
 979                 notification_free(noti);
 980                 return;
 981         }
 982 }
 983  * @endcode
 984  */
 985 notification_error_e notification_set_progress(notification_h noti,
 986                                                double percentage);
 987
 988 /**
 989  * @brief Get progress from the notification handle
 990  * @details
 991  * @remarks At the end of the operation, progress should be 1.0
 992  * @param[in] noti notification handle
 993  * @param[out] percentage progress percentage
 994  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
 995  * @retval NOTIFICATION_ERROR_NONE - success
 996  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
 997  * @pre
 998  * @post
 999  * @see
1000  * @par Sample code:
1001  * @code
1002 #include <notification.h>
1003 ...
1004 {
1005         notification_h noti = NULL;
1006         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1007         double percentage = 0.0;
1008
1009         noti_err  = notification_get_progress(noti, &percentage);
1010         if(noti_err != NOTIFICATION_ERROR_NONE) {
1011                 return;
1012         }
1013 }
1014  * @endcode
1015  */
1016 notification_error_e notification_get_progress(notification_h noti,
1017                                                double *percentage);
1018
1019 /**
1020  * @brief Set the package name of caller
1021  * @details caller_pkgname is set automatically when notification_new. We are not recommend to use this API.
1022  * @remarks
1023  * @param[in] noti notification handle
1024  * @param[in] pkgname caller package name
1025  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1026  * @retval NOTIFICATION_ERROR_NONE - success
1027  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
1028  * @pre
1029  * @post
1030  * @see
1031  * @par Sample code:
1032  * @code
1033 #include <notification.h>
1034 ...
1035 {
1036         notification_h noti = NULL;
1037         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1038
1039         noti = notification_new(NOTIFICATION_TYPE_NOTI, APP_GROUP_ID, NOTIFICATION_PRIV_ID_NONE);
1040         if(noti == NULL) {
1041                 return;
1042         }
1043
1044         noti_err  = notification_set_pkgname(noti, "com.samsung.phone");
1045         if(noti_err != NOTIFICATION_ERROR_NONE) {
1046                 notification_free(noti);
1047                 return;
1048         }
1049 }
1050  * @endcode
1051  */
1052 notification_error_e notification_set_pkgname(notification_h noti,
1053                                               const char *pkgname);
1054
1055 /**
1056  * @brief Get the package name of caller from the notification handle
1057  * @details
1058  * @remarks
1059  * @param[in] noti notification handle
1060  * @param[out] pkgname caller package name
1061  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1062  * @retval NOTIFICATION_ERROR_NONE - success
1063  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
1064  * @pre
1065  * @post
1066  * @see
1067  * @par Sample code:
1068  * @code
1069 #include <notification.h>
1070 ...
1071 {
1072         notification_h noti = NULL;
1073         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1074         char *pkgname = NULL;
1075
1076         noti_err  = notification_get_pkgname(noti, &pkgname);
1077         if(noti_err != NOTIFICATION_ERROR_NONE) {
1078                 return;
1079         }
1080 }
1081  * @endcode
1082  */
1083 notification_error_e notification_get_pkgname(notification_h noti,
1084                                               char **pkgname);
1085
1086 /**
1087  * @brief Set the layout of the notification view
1088  * @details caller can set displaying layout of notification
1089  * @remarks
1090  * @param[in] noti notification handle
1091  * @param[in] type of layout
1092  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1093  * @retval NOTIFICATION_ERROR_NONE - success
1094  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
1095  * @pre
1096  * @post
1097  * @see #notification_ly_type_e
1098  */
1099 notification_error_e notification_set_layout(notification_h noti,
1100                 notification_ly_type_e layout);
1101
1102 /**
1103  * @brief Get the layout of the notification view from the notification handle
1104  * @details
1105  * @remarks
1106  * @param[in] noti notification handle
1107  * @param[out] type of layout
1108  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1109  * @retval NOTIFICATION_ERROR_NONE - success
1110  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
1111  * @pre
1112  * @post
1113  * @see #notification_ly_type_e
1114  */
1115 notification_error_e notification_get_layout(notification_h noti,
1116                 notification_ly_type_e *layout);
1117
1118 /**
1119  * @brief Get Group ID and Private ID
1120  * @details
1121  * @remarks ID is valid only after inserting the notification
1122  * @param[in] noti notification handle
1123  * @param[out] group_id Group ID
1124  * @param[out] priv_id Private ID
1125  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1126  * @retval NOTIFICATION_ERROR_NONE - success
1127  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
1128  * @pre
1129  * @post
1130  * @see
1131  * @par Sample code:
1132  * @code
1133 #include <notification.h>
1134  ...
1135   {
1136          notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1137          int group_id, priv_id;
1138
1139          noti_err  = notification_get_id(noti, &group_id, &priv_id);
1140          if(noti_err != NOTIFICATION_ERROR_NONE) {
1141                  return;
1142          }
1143  }
1144  * @endcode
1145  */
1146 notification_error_e notification_get_id(notification_h noti,
1147                                          int *group_id, int *priv_id);
1148
1149 /**
1150  * @brief Get the type of notification
1151  * @details
1152  * @remarks
1153  * @param[in] noti notification handle
1154  * @param[out] type notification type
1155  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1156  * @retval NOTIFICATION_ERROR_NONE - success
1157  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide parameter
1158  * @pre
1159  * @post
1160  * @see
1161  * @par Sample code:
1162  * @code
1163 #include <notification.h>
1164 ...
1165  {
1166         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1167         notification_type_e type;
1168
1169         noti_err  = notification_get_type(noti, &type);
1170         if(noti_err != NOTIFICATION_ERROR_NONE) {
1171                 return;
1172         }
1173 }
1174  * @endcode
1175  */
1176 notification_error_e notification_get_type(notification_h noti,
1177                                            notification_type_e * type);
1178
1179 /**
1180  * @brief Insert a notification
1181  * @details A notification will be inserted to DB and then it will be appeared on the notification area
1182  * When notification_new() call, if priv_id is NOTIFICATION_PRIV_ID_NONE, priv_id is return internally set priv_id.
1183  * @remarks
1184  * @param[in] noti notification handle
1185  * @param[out] priv_id private ID
1186  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1187  * @retval NOTIFICATION_ERROR_NONE - success
1188  * @retval NOTIFICATION_ERROR_INVALID_DATA - invalid parameter
1189  * @pre notification_new()
1190  * @post notification_free()
1191  * @see #notification_h
1192  * @par Sample code:
1193  * @code
1194 #include <notification.h>
1195 ...
1196  {
1197         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1198
1199         noti_err  = notification_insert(noti, NULL);
1200         if(noti_err != NOTIFICATION_ERROR_NONE) {
1201                 return;
1202         }
1203 }
1204  * @endcode
1205  */
1206 notification_error_e notification_insert(notification_h noti,
1207                                          int *priv_id);
1208
1209 /**
1210  * @brief Update notification data.
1211  * @details The updated notification will be appeared on the notification area
1212  * @remarks
1213  * @param[in] noti notification handle that is created by notification_new().
1214  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1215  * @retval NOTIFICATION_ERROR_NONE - success
1216  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
1217  * @retval NOTIFICATION_ERROR_NOT_EXIST_ID - not exist priv id
1218  * @pre
1219  * @post
1220  * @see #notification_h
1221  * @par Sample code:
1222  * @code
1223 #include <notification.h>
1224 ...
1225  {
1226         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1227
1228         noti_err  = notification_update(NULL);
1229         if(noti_err != NOTIFICATION_ERROR_NONE) {
1230                 return;
1231         }
1232 }
1233  * @endcode
1234  */
1235 notification_error_e notification_update(notification_h noti);
1236
1237 /**
1238  * @brief Update a notification
1239  * @details The updated notification will be appeared on the notification area
1240  * @remarks This function update a notification in async manner
1241  * @param[in] noti notification handle that is created by notification_new().
1242  * @param[in] result_cb callback called when update completed
1243  * @param[in] user_data user data which you want to use in callback
1244  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1245  * @retval NOTIFICATION_ERROR_NONE - success
1246  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
1247  * @retval NOTIFICATION_ERROR_NOT_EXIST_ID - not exist priv id
1248  * @pre
1249  * @post
1250  * @see #notification_h
1251  * @par Sample code:
1252  * @code
1253 #include <notification.h>
1254 ...
1255  {
1256         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1257
1258         noti_err  = notification_update_async(NULL, result_cb, data);
1259         if(noti_err != NOTIFICATION_ERROR_NONE) {
1260                 return;
1261         }
1262 }
1263  * @endcode
1264  */
1265 notification_error_e notification_update_async(notification_h noti,
1266                 void (*result_cb)(int priv_id, int result, void *data), void *user_data);
1267
1268 /**
1269  * @brief This function clear all notification of type.
1270  * @details Not recommand API. Only for notification tray's clear button operation.
1271  * @remarks
1272  * @param[in] type notification type
1273  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1274  * @retval NOTIFICATION_ERROR_NONE - success
1275  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
1276  * @pre
1277  * @post
1278  * @see #notification_type_e
1279  * @par Sample code:
1280  * @code
1281 #include <notification.h>
1282 ...
1283  {
1284         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1285
1286         noti_err  = notifiation_clear(NOTIFICATION_TYPE_NOTI);
1287         if(noti_err != NOTIFICATION_ERROR_NONE) {
1288                 return;
1289         }
1290 }
1291  * @endcode
1292  */
1293 notification_error_e notifiation_clear(notification_type_e type);
1294
1295 /**
1296  * @brief Delete all the notifications of the type.
1297  * @details If pkgname is NULL, caller_pkgname is set internally.
1298  * @remarks
1299  * @param[in] pkgname caller application package name or NULL
1300  * @param[in] type notification type
1301  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1302  * @retval NOTIFICATION_ERROR_NONE - success
1303  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
1304  * @pre
1305  * @post
1306  * @see
1307  * @par Sample code:
1308  * @code
1309 #include <notification.h>
1310 ...
1311  {
1312         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1313
1314         noti_err  = notification_delete_all_by_type(NULL, NOTIFICATION_TYPE_NOTI);
1315         if(noti_err != NOTIFICATION_ERROR_NONE) {
1316                 return;
1317         }
1318 }
1319  * @endcode
1320  */
1321 notification_error_e notification_delete_all_by_type(const char *pkgname,
1322                                                      notification_type_e type);
1323
1324 /**
1325  * @brief Delete a notification by priv_id.
1326  * @details If pkgname is NULL, caller_pkgname is set internally.
1327  * @remarks
1328  * @param[in] pkgname caller application package name or NULL
1329  * @param[in] type notification type
1330  * @param[in] priv_id priv ID
1331  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1332  * @retval NOTIFICATION_ERROR_NONE - success
1333  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
1334  * @pre
1335  * @post
1336  * @see
1337  * @par Sample code:
1338  * @code
1339 #include <notification.h>
1340 ...
1341  {
1342         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1343
1344         noti_err  = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NOTI, APP_PRIV_ID);
1345         if(noti_err != NOTIFICATION_ERROR_NONE) {
1346                 return;
1347         }
1348 }
1349  * @endcode
1350  */
1351 notification_error_e notification_delete_by_priv_id(const char *pkgname,
1352                                                     notification_type_e type,
1353                                                     int priv_id);
1354
1355 /**
1356  * @brief Delete a notification with the given handle
1357  * @details notification_delete() remove notification data from DB and notification_free release menory of notification data.
1358  * @remarks
1359  * @param[in] noti notification handle
1360  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1361  * @retval NOTIFICATION_ERROR_NONE - success
1362  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
1363  * @pre
1364  * @post
1365  * @see #notification_h
1366  * @par Sample code:
1367  * @code
1368 #include <notification.h>
1369 ...
1370  {
1371         notificaton_h noti = NULL;
1372         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1373
1374         ...
1375
1376         noti_err  = notification_delete(noti);
1377         if(noti_err != NOTIFICATION_ERROR_NONE) {
1378                 return;
1379         }
1380
1381 }
1382  * @endcode
1383  */
1384 notification_error_e notification_delete(notification_h noti);
1385
1386 /**
1387  * @brief Update progress of inserted notification. Only for the ongoing notification(NOTIFICATION_TYPE_ONGOING)
1388  * @details notification view on notification area could be updated
1389  * @remarks
1390  * @param[in] noti notification handle or NULL if priv_id is valid
1391  * @param[in] priv_id private ID
1392  * @param[in] progress % value of progressive data
1393  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1394  * @retval NOTIFICATION_ERROR_NONE - success
1395  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
1396  * @pre
1397  * @post
1398  * @par Sample code:
1399  * @code
1400 #include <notification.h>
1401 ...
1402  {
1403         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1404
1405         noti_err  = notification_update_progress(NULL, APP_NOTI_PRIV_ID, 0.6);
1406         if(noti_err != NOTIFICATION_ERROR_NONE) {
1407                 return;
1408         }
1409 }
1410  * @endcode
1411  */
1412 notification_error_e notification_update_progress(notification_h noti,
1413                                                   int priv_id,
1414                                                   double progress);
1415
1416 /**
1417  * @brief Update size of inserted notification data. Only for the ongoing notification(NOTIFICATION_TYPE_ONGOING)
1418  * @details notification view on notification area could be updated
1419  * @remarks
1420  * @param[in] noti notification handle or NULL if priv_id is valid
1421  * @param[in] priv_id private ID
1422  * @param[in] size bytes of progressive data
1423  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1424  * @retval NOTIFICATION_ERROR_NONE - success
1425  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
1426  * @pre
1427  * @post
1428  * @par Sample code:
1429  * @code
1430 #include <notification.h>
1431 ...
1432  {
1433         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1434
1435         noti_err  = notification_update_size(NULL, APP_NOTI_PRIV_ID, 3000000);
1436         if(noti_err != NOTIFICATION_ERROR_NONE) {
1437                 return;
1438         }
1439 }
1440  * @endcode
1441  */
1442 notification_error_e notification_update_size(notification_h noti,
1443                                               int priv_id, double size);
1444
1445 /**
1446  * @brief Update content of inserted notification data. Only for the ongoing notification(NOTIFICATION_TYPE_ONGOING)
1447  * @details notification view on notification area could be updated
1448  * @remarks
1449  * @param[in] noti notification handle or NULL if priv_id is valid
1450  * @param[in] priv_id private ID
1451  * @param[in] content text to update
1452  * @return NOTIFICATION_ERROR_NONE if success, other value if failure
1453  * @retval NOTIFICATION_ERROR_NONE - success
1454  * @retval NOTIFICATION_ERROR_INVALID_DATA - Invalide input value
1455  * @pre
1456  * @post
1457  * @par Sample code:
1458  * @code
1459 #include <notification.h>
1460 ...
1461  {
1462         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1463
1464         noti_err  = notification_update_content(NULL, APP_NOTI_PRIV_ID, "updated string");
1465         if(noti_err != NOTIFICATION_ERROR_NONE) {
1466                 return;
1467         }
1468 }
1469  * @endcode
1470  */
1471 notification_error_e notification_update_content(notification_h noti,
1472                                                          int priv_id,
1473                                                          const char *content);
1474
1475 /**
1476  * @brief Create internal structure data and return notification handle.
1477  * @details Available type is #NOTIFICATION_TYPE_NOTI and #NOTIFICATION_TYPE_ONGOING.
1478  * #NOTIFICATION_TYPE_NOTI is remaining notification data evenif device is restarted.
1479  * #NOTIFICATION_TYPE_ONGOING can display progressive feather, but notification data is removed after device is restarted.
1480  * If group_id is #NOTIFICATION_GROUP_ID_NONE, notification data is not grouping. #NOTIFICATION_GROUP_ID_DEFAULT,
1481  * notification data is grouping with same title. Positive number ( > 0 ) is grouping with same number.
1482  * If priv_id is #NOTIFICATION_PRIV_ID_NONE, priv_id is set internally and return it when notification_insert() call.
1483  * Positive number and zero ( >= 0 ) is application set private ID. These ID should have be unique each application package.
1484  * @remarks
1485  * @param[in] type notification type
1486  * @param[in] group_id Group ID
1487  * @param[in] priv_id Priv ID
1488  * @return notification handle(#notification_h) if success, NULL if failure.
1489  * @retval #notification_h - success
1490  * @retval NULL - failure
1491  * @pre
1492  * @post
1493  * @see #notification_type_e
1494  * @see #notification_h
1495  * @par Sample code:
1496  * @code
1497 #include <notification.h>
1498 ...
1499 {
1500         notification_h noti = NULL;
1501
1502         noti = notification_new(NOTIFICATION_TYPE_NOTI, APP_GROUP_ID, NOTIFICATION_PRIV_ID_NONE);
1503         if(noti == NULL) {
1504                 return;
1505         }
1506         ...
1507 }
1508  * @endcode
1509  */
1510 notification_h notification_new(notification_type_e type, int group_id,
1511                                 int priv_id);
1512
1513 /**
1514  * @brief This function create internal structure data and return notification handle.
1515  * @details Available type is #NOTIFICATION_TYPE_NOTI and #NOTIFICATION_TYPE_ONGOING.
1516  * #NOTIFICATION_TYPE_NOTI is remaining notification data evenif device is restarted.
1517  * #NOTIFICATION_TYPE_ONGOING can display progressive feather, but notification data is removed after device is restarted.
1518  * @remarks
1519  * @param[in] type notification type
1520  * @return notification handle(#notification_h) if success, NULL if failure.
1521  * @retval #notification_h - success
1522  * @retval NULL - failure
1523  * @pre
1524  * @post
1525  * @see #notification_type_e
1526  * @see #notification_h
1527  * @par Sample code:
1528  * @code
1529 #include <notification.h>
1530 ...
1531 {
1532         notification_h noti = NULL;
1533
1534         noti = notification_create(NOTIFICATION_TYPE_NOTI);
1535         if(noti == NULL) {
1536                 return;
1537         }
1538         ...
1539 }
1540  * @endcode
1541  */
1542 notification_h notification_create(notification_type_e type);
1543
1544 /**
1545  * @brief load a notification from the notification DB with private id
1546  * @details
1547  * @remarks
1548  * @param[in] type notification type
1549  * @param[in] group_id Group ID
1550  * @param[in] priv_id Priv ID
1551  * @return notification handle(#notification_h) if success, NULL if failure.
1552  * @retval #notification_h - success
1553  * @retval NULL - failure
1554  * @pre
1555  * @post
1556  * @see #notification_type_e
1557  * @see #notification_h
1558  * @par Sample code:
1559  * @code
1560 #include <notification.h>
1561 ...
1562 {
1563         notification_h noti = NULL;
1564
1565         noti = notification_load("org.tizen.app", priv_id);
1566         if(noti == NULL) {
1567                 return;
1568         }
1569         ...
1570 }
1571  * @endcode
1572  */
1573 notification_h notification_load(char *pkgname,
1574                                 int priv_id);
1575
1576 /**
1577  * @brief Create a notification clone
1578  * @details Newly created notification handle is returned.
1579  * @remarks This clone notification handle should be call notification_free().
1580  * @param[in] noti notification handle
1581  * @param[out] clone newly created notification handle that has same with input noti.
1582  * @return NOTIFICATION_ERROR_NONE if success, other value if failure.
1583  * @retval NOTIFICATION_ERROR_NONE - success
1584  * @retval NOTIFICATION_ERROR_INVALID_DATA - invalid parameter
1585  * @pre
1586  * @post
1587  * @see #notification_type_e
1588  * @see #notification_h
1589  * @par Sample code:
1590  * @code
1591 #include <notification.h>
1592 ...
1593 {
1594         notification_h noti = notification_new(NOTIFICATION_TYPE_NOTI, APP_GROUP_ID, NOTIFICATION_PRIV_ID_NONE);
1595         notification_h clone = NULL;
1596
1597         notification_clone(noti, &clone);
1598         ...
1599 }
1600  * @endcode
1601  */
1602 notification_error_e notification_clone(notification_h noti, notification_h *clone);
1603
1604 /**
1605  * @brief Free internal structure data of notification handle.
1606  * @details Internal data of notification handle is released. Notification data that inserted is not deleted.
1607  * @remarks
1608  * @param[in] noti notification handle
1609  * @return NOTIFICATION_ERROR_NONE if success, other value if failure.
1610  * @retval NOTIFICATION_ERROR_NONE - success
1611  * @retval NOTIFICATION_ERROR_INVALID_DATA - invalid parameter
1612  * @pre notification_new()
1613  * @post
1614  * @see #notification_h
1615  * @par Sample code:
1616  * @code
1617 #include <notification.h>
1618 ...
1619 {
1620         notification_h noti = NULL;
1621         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1622
1623         noti = notification_new(NOTIFICATION_TYPE_NOTI, APP_GROUP_ID, NOTIFICATION_PRIV_ID_NONE);
1624         if(noti == NULL) {
1625                 return;
1626         }
1627         ...
1628
1629         noti_err = notification_free(noti);
1630         if(noti_err != NOTIFICATION_ERROR_NONE) {
1631                 return;
1632         }
1633 }
1634  * @endcode
1635  */
1636 notification_error_e notification_free(notification_h noti);
1637
1638 /**
1639  * @}
1640  */
1641
1642 /**
1643  * @addtogroup NOTIFICATION_LIST
1644  * @{
1645  */
1646
1647 /**
1648  * @brief This function return notification list handle.
1649  * @details If count is -1, all of notification list is returned.
1650  * @remarks
1651  * @param[in] type notification type
1652  * @param[in] count returned notification data number
1653  * @param[out] NOTIFICATION_ERROR_NONE if success, other value if failure.
1654  * @return NOTIFICATION_ERROR_NONE if success, other value if failure.
1655  * @retval NOTIFICATION_ERROR_NONE - success
1656  * @retval NOTIFICATION_ERROR_INVALID_DATA - invalid parameter
1657  * @pre
1658  * @post
1659  * @see #notification_list_h
1660  * @par Sample code:
1661  * @code
1662 #include <notification.h>
1663 ...
1664 {
1665         notification_list_h noti_list = NULL;
1666         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1667
1668         noti_err = notification_get_list(NOTIFICATION_TYPE_NONE, -1, &noti_list);
1669         if(noti_err != NOTIFICATION_ERROR_NONE) {
1670                 return;
1671         }
1672 }
1673  * @endcode
1674  */
1675 notification_error_e notification_get_list(notification_type_e type,
1676                                            int count,
1677                                            notification_list_h * list);
1678
1679 /**
1680  * @brief This function will be deprecated.
1681  * @see notification_get_grouping_list()
1682  *
1683  */
1684 notification_error_e notification_get_grouping_list(notification_type_e type,
1685                                                     int count,
1686                                                     notification_list_h *list);
1687
1688 /**
1689  * @brief This function return notification detail list handle of grouping data.
1690  * @details If count is -1, all of notification list is returned.
1691  * @remarks
1692  * @param[in] pkgname caller application package name
1693  * @param[in] group_id group id
1694  * @param[in] priv_id private id
1695  * @param[in] count returned notification data number
1696  * @param[out] list notification list handle
1697  * @return NOTIFICATION_ERROR_NONE if success, other value if failure.
1698  * @retval NOTIFICATION_ERROR_NONE - success
1699  * @retval NOTIFICATION_ERROR_INVALID_DATA - invalid parameter
1700  * @pre
1701  * @post
1702  * @see #notification_list_h
1703  * @par Sample code:
1704  * @code
1705 #include <notification.h>
1706 ...
1707 {
1708         notification_list_h noti_list = NULL;
1709         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1710
1711         noti_err = notification_get_detail_list(pkgname, group_id, priv_id, -1, &noti_list);
1712         if(noti_err != NOTIFICATION_ERROR_NONE) {
1713                 return;
1714         }
1715 }
1716  * @endcode
1717  */
1718 notification_error_e notification_get_detail_list(const char *pkgname,
1719                                                   int group_id,
1720                                                   int priv_id,
1721                                                   int count,
1722                                                   notification_list_h *list);
1723
1724 /**
1725  * @brief Free notification list
1726  * @details
1727  * @remarks
1728  * @param[in] list notification list handle
1729  * @return NOTIFICATION_ERROR_NONE if success, other value if failure.
1730  * @retval NOTIFICATION_ERROR_NONE - success
1731  * @retval NOTIFICATION_ERROR_INVALID_DATA - invalid parameter
1732  * @pre notification_get_grouping_list() or notification_get_detail_list ()
1733  * @post
1734  * @see #notification_list_h
1735  * @par Sample code:
1736  * @code
1737 #include <notification.h>
1738 ...
1739 {
1740         notification_list_h noti_list = NULL;
1741         notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
1742
1743         ...
1744
1745         noti_err = notification_free_list(noti_list);
1746         if(noti_err != NOTIFICATION_ERROR_NONE) {
1747                 return;
1748         }
1749 }
1750  * @endcode
1751  */
1752 notification_error_e notification_free_list(notification_list_h list);
1753
1754 /**
1755  * @}
1756  */
1757
1758 /**
1759  * @brief Register a callback for all notification events
1760  * @details The registered callback could be called for all notification events
1761  * @remarks
1762  * @param[in] changed_cb callback function
1763  * @param[in] user_data user data
1764  * @return NOTIFICATION_ERROR_NONE if success, other value if failure.
1765  * @retval NOTIFICATION_ERROR_NONE - success
1766  * @retval NOTIFICATION_ERROR_INVALID_DATA - invalid parameter
1767  * @pre notification_new()
1768  * @post
1769  * @see notification_unresister_changed_cb()
1770  * @par Sample code:
1771  * @code
1772 #include <notification.h>
1773 ...
1774 {
1775         noti_err = notification_resister_changed_cb(app_changed_cb, user_data);
1776         if(noti_err != NOTIFICATION_ERROR_NONE) {
1777                 return;
1778         }
1779 }
1780  * @endcode
1781  */
1782 notification_error_e
1783 notification_resister_changed_cb(
1784         void (*changed_cb)(void *data, notification_type_e type),
1785         void *user_data);
1786
1787 /**
1788  * @brief Unregister a callback for all notification events
1789  * @details
1790  * @remarks
1791  * @param[in] changed_cb callback function
1792  * @return NOTIFICATION_ERROR_NONE if success, other value if failure.
1793  * @retval NOTIFICATION_ERROR_NONE - success
1794  * @retval NOTIFICATION_ERROR_INVALID_DATA - invalid parameter
1795  * @pre
1796  * @post
1797  * @see notification_resister_changed_cb()
1798  * @par Sample code:
1799  * @code
1800 #include <notification.h>
1801 ...
1802 {
1803         noti_err = notification_unresister_changed_cb(app_changed_cb);
1804         if(noti_err != NOTIFICATION_ERROR_NONE) {
1805                 return;
1806         }
1807 }
1808  * @endcode
1809  */
1810 notification_error_e
1811 notification_unresister_changed_cb(
1812         void (*changed_cb)(void *data, notification_type_e type));
1813
1814 /**
1815  * @brief Register a callback for all notification events
1816  * @details The registered callback could be called for all notification events
1817  * @remarks
1818  * @param[in] changed_cb callback function
1819  * @param[in] user_data user data
1820  * @return NOTIFICATION_ERROR_NONE if success, other value if failure.
1821  * @retval NOTIFICATION_ERROR_NONE - success
1822  * @retval NOTIFICATION_ERROR_INVALID_DATA - invalid parameter
1823  * @pre
1824  * @post
1825  * @see notification_unregister_detailed_changed_cb()
1826  * @par Sample code:
1827  * @code
1828 #include <notification.h>
1829 ...
1830 {
1831         noti_err = notification_resister_changed_cb(app_changed_cb, user_data);
1832         if(noti_err != NOTIFICATION_ERROR_NONE) {
1833                 return;
1834         }
1835 }
1836  * @endcode
1837  */
1838 notification_error_e
1839 notification_register_detailed_changed_cb(
1840                 void (*detailed_changed_cb)(void *data, notification_type_e type, notification_op *op_list, int num_op),
1841                 void *user_data);
1842
1843 /**
1844  * @brief Unregister a callback for all notification events
1845  * @details
1846  * @remarks
1847  * @param[in] changed_cb callback function
1848  * @return NOTIFICATION_ERROR_NONE if success, other value if failure.
1849  * @retval NOTIFICATION_ERROR_NONE - success
1850  * @retval NOTIFICATION_ERROR_INVALID_DATA - invalid parameter
1851  * @pre
1852  * @post
1853  * @see notification_register_detailed_changed_cb()
1854  * @par Sample code:
1855  * @code
1856 #include <notification.h>
1857 ...
1858 {
1859         noti_err = notification_unresister_changed_cb(app_changed_cb);
1860         if(noti_err != NOTIFICATION_ERROR_NONE) {
1861                 return;
1862         }
1863 }
1864  * @endcode
1865  */
1866 notification_error_e
1867 notification_unregister_detailed_changed_cb(
1868                 void (*detailed_changed_cb)(void *data, notification_type_e type, notification_op *op_list, int num_op),
1869                 void *user_data);
1870
1871 /**
1872  * @brief Get the information of notification event
1873  * @details
1874  * @remarks
1875  * @param[in] list notification list handle
1876  * @return NOTIFICATION_ERROR_NONE if success, other value if failure.
1877  * @retval NOTIFICATION_ERROR_NONE - success
1878  * @retval NOTIFICATION_ERROR_INVALID_DATA - invalid parameter
1879  * @pre notification_get_grouping_list() or notification_get_detail_list ()
1880  * @post
1881  * @see #notification_op
1882  */
1883 notification_error_e notification_op_get_data(notification_op *noti_op,
1884                                                        notification_op_data_type_e type,
1885                                                        void *data);
1886
1887 /**
1888  * @}
1889  */
1890
1891 void notification_call_changed_cb(notification_op *op_list, int op_num);
1892
1893 int notification_is_service_ready(void);
1894
1895 notification_error_e notification_add_deffered_task(
1896                 void (*deffered_task_cb)(void *data), void *user_data);
1897
1898 notification_error_e notification_del_deffered_task(
1899                 void (*deffered_task_cb)(void *data));
1900
1901 /**
1902  * @addtogroup NOTIFICATION_DEPRECATED
1903  * @{
1904  */
1905
1906 /**
1907  * @brief This function will be deprecated.
1908  * @see notification_set_image()
1909  *
1910  */
1911 notification_error_e notification_set_icon(notification_h noti,
1912                                            const char *icon_path);
1913
1914 /**
1915  * @brief This function will be deprecated.
1916  * @see notification_get_image()
1917  *
1918  */
1919 notification_error_e notification_get_icon(notification_h noti,
1920                                            char **icon_path);
1921
1922 /**
1923  * @brief This function will be deprecated.
1924  * @see notification_set_text()
1925  *
1926  */
1927 notification_error_e notification_set_title(notification_h noti,
1928                                             const char *title,
1929                                             const char *loc_title);
1930
1931 /**
1932  * @brief This function will be deprecated.
1933  * @see notification_get_text()
1934  *
1935  */
1936 notification_error_e notification_get_title(notification_h noti,
1937                                             char **title,
1938                                             char **loc_title);
1939
1940 /**
1941  * @brief This function will be deprecated.
1942  * @see notification_set_text()
1943  *
1944  */
1945 notification_error_e notification_set_content(notification_h noti,
1946                                               const char *content,
1947                                               const char *loc_content);
1948
1949 /**
1950  * @brief This function will be deprecated.
1951  * @see notification_get_text()
1952  *
1953  */
1954 notification_error_e notification_get_content(notification_h noti,
1955                                               char **content,
1956                                               char **loc_content);
1957
1958 /**
1959  * @brief This function will be deprecated.
1960  * @see notification_set_execute_option()
1961  *
1962  */
1963 notification_error_e notification_set_application(notification_h noti, const char *pkgname);    /* Do not use this */
1964
1965 /**
1966  * @brief This function will be deprecated.
1967  * @see notification_get_execute_option()
1968  *
1969  */
1970 notification_error_e notification_get_application(notification_h noti, char **pkgname); /* Do not use this */
1971
1972 /**
1973  * @brief This function will be deprecated.
1974  * @see notification_set_execute_option()
1975  *
1976  */
1977 notification_error_e notification_set_args(notification_h noti, bundle * args, bundle * group_args);    /* Do not use this */
1978
1979 /**
1980  * @brief This function will be deprecated.
1981  * @see notification_get_execute_option()
1982  *
1983  */
1984 notification_error_e notification_get_args(notification_h noti, bundle ** args, bundle ** group_args);  /* Do not use this */
1985
1986 /**
1987  * @brief This function will be deprecated.
1988  * @see notification_delete_by_priv_id()
1989  *
1990  */
1991 notification_error_e notification_delete_group_by_group_id(const char *pkgname,
1992                                                            notification_type_e type,
1993                                                            int group_id);
1994
1995 /**
1996  * @brief This function will be deprecated.
1997  * @see notification_delete_by_priv_id()
1998  *
1999  */
2000 notification_error_e notification_delete_group_by_priv_id(const char *pkgname,
2001                                                           notification_type_e type,
2002                                                           int priv_id);
2003 /**
2004  * @brief This function will be deprecated.
2005  *
2006  */
2007 notification_error_e notification_get_count(notification_type_e type,
2008                                             const char *pkgname,
2009                                             int group_id, int priv_id,
2010                                             int *count);
2011
2012 /**
2013  * @}
2014  */
2015
2016 #ifdef __cplusplus
2017 }
2018 #endif
2019 #endif                          /* __NOTIFICATION_H__ */