summaryrefslogtreecommitdiff
path: root/src/notification.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/notification.c')
-rwxr-xr-xsrc/notification.c3267
1 files changed, 3267 insertions, 0 deletions
diff --git a/src/notification.c b/src/notification.c
new file mode 100755
index 0000000..d435218
--- /dev/null
+++ b/src/notification.c
@@ -0,0 +1,3267 @@
+/*
+ * libnotification
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * 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>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <libintl.h>
+#include <dbus/dbus.h>
+#include <dbus/dbus-glib-lowlevel.h>
+
+#include <aul.h>
+#include <ail.h>
+#include <appsvc.h>
+#include <vconf-keys.h>
+#include <vconf.h>
+
+#include <notification.h>
+#include <notification_list.h>
+#include <notification_debug.h>
+#include <notification_internal.h>
+#include <notification_noti.h>
+#include <notification_ongoing.h>
+#include <notification_group.h>
+
+typedef struct _notification_cb_list notification_cb_list_s;
+
+typedef enum __notification_cb_type {
+ NOTIFICATION_CB_NORMAL = 1,
+ NOTIFICATION_CB_DETAILED,
+} _notification_cb_type_e;
+
+struct _notification_cb_list {
+ notification_cb_list_s *prev;
+ notification_cb_list_s *next;
+
+ _notification_cb_type_e cb_type;
+ void (*changed_cb) (void *data, notification_type_e type);
+ void (*detailed_changed_cb) (void *data, notification_type_e type, notification_op *op_list, int num_op);
+ void *data;
+};
+
+static notification_cb_list_s *g_notification_cb_list = NULL;
+static DBusConnection *g_dbus_handle;
+
+#define NOTI_TEXT_RESULT_LEN 2048
+#define NOTI_PKGNAME_LEN 512
+#define NOTI_CHANGED_NOTI "notification_noti_changed"
+#define NOTI_CHANGED_ONGOING "notification_ontoing_changed"
+
+#define NOTI_DBUS_BUS_NAME "org.tizen.libnotification"
+#define NOTI_DBUS_PATH "/org/tizen/libnotification"
+#define NOTI_DBUS_INTERFACE "org.tizen.libnotification.signal"
+
+static char *_notification_get_pkgname_by_pid(void)
+{
+ char buf[NOTI_PKGNAME_LEN + 1] = { 0, };
+ char pkgname[NOTI_PKGNAME_LEN + 1] = { 0, };
+ int pid = 0, ret = AUL_R_OK;
+ int fd;
+
+ pid = getpid();
+
+ ret = aul_app_get_pkgname_bypid(pid, pkgname, sizeof(pkgname));
+ if (ret != AUL_R_OK) {
+ snprintf(buf, sizeof(buf), "/proc/%d/cmdline", pid);
+
+ fd = open(buf, O_RDONLY);
+ if (fd < 0) {
+ return NULL;
+ }
+
+ ret = read(fd, pkgname, sizeof(pkgname) - 1);
+ if (ret <= 0) {
+ close(fd);
+ return NULL;
+ }
+
+ if (ret > NOTI_PKGNAME_LEN)
+ pkgname[NOTI_PKGNAME_LEN] = '\0';
+ else
+ pkgname[ret] = '\0';
+
+ close(fd);
+ }
+
+ if (strlen(pkgname) <= 0) {
+ return NULL;
+ } else {
+ return strdup(pkgname);
+ }
+}
+
+static void _notification_pack_operation_msg(DBusMessageIter *iter, notification_op *op_list, int op_num)
+{
+ int i = 0;
+
+ if (op_list == NULL) {
+ int tmp_op_num = 0;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &tmp_op_num);
+ return ;
+ }
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &op_num);
+ for (i = 0; i < op_num; i++) {
+ NOTIFICATION_ERR("pack:%d/%d", i, op_num);
+ notification_op *op = op_list + i;
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &(op->type));
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &(op->priv_id));
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &(op->extra_info_1));
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &(op->extra_info_2));
+ }
+}
+
+static void _notification_unpack_operation_msg(DBusMessageIter *iter, notification_op **op_list, int *op_num)
+{
+ int i = 0;
+
+ if (iter == NULL || op_list == NULL || op_num == NULL) {
+ return;
+ }
+
+ dbus_message_iter_get_basic(iter, op_num);
+
+ int tmp_op_num = *op_num;
+
+ if (tmp_op_num <= 0) {
+ *op_list = NULL;
+ *op_num = 0;
+ return;
+ }
+
+ *op_list = (notification_op*)malloc(sizeof(notification_op) * (tmp_op_num));
+
+ dbus_message_iter_next(iter);
+
+ if (*op_list != NULL) {
+ for (i = 0; i < tmp_op_num; i++) {
+ notification_op *op = (*op_list) + i;
+ dbus_message_iter_get_basic(iter, &(op->type));
+ dbus_message_iter_next(iter);
+ dbus_message_iter_get_basic(iter, &(op->priv_id));
+ dbus_message_iter_next(iter);
+ dbus_message_iter_get_basic(iter, &(op->extra_info_1));
+ dbus_message_iter_next(iter);
+ dbus_message_iter_get_basic(iter, &(op->extra_info_2));
+ dbus_message_iter_next(iter);
+ }
+ }
+}
+
+static char *_notification_get_icon(const char *package)
+{
+ ail_appinfo_h handle;
+ ail_error_e ret;
+ char *str = NULL;
+ char *icon = NULL;
+
+ ret = ail_package_get_appinfo(package, &handle);
+ if (ret != AIL_ERROR_OK) {
+ return NULL;
+ }
+
+ ret = ail_appinfo_get_str(handle, AIL_PROP_ICON_STR, &str);
+ if (ret != AIL_ERROR_OK) {
+ ail_package_destroy_appinfo(handle);
+ return NULL;
+ }
+
+ icon = strdup(str);
+
+ ret = ail_package_destroy_appinfo(handle);
+ if (ret != AIL_ERROR_OK) {
+ NOTIFICATION_ERR("Fail to ail_package_destroy_appinfo");
+ }
+
+ return icon;
+}
+
+static char *_notification_get_name(const char *package)
+{
+ ail_appinfo_h handle;
+ ail_error_e ret;
+ char *str = NULL;
+ char *name = NULL;
+
+ ret = ail_package_get_appinfo(package, &handle);
+ if (ret != AIL_ERROR_OK) {
+ return NULL;
+ }
+
+ ret = ail_appinfo_get_str(handle, AIL_PROP_NAME_STR, &str);
+ if (ret != AIL_ERROR_OK) {
+ ail_package_destroy_appinfo(handle);
+ return NULL;
+ }
+
+ name = strdup(str);
+
+ ret = ail_package_destroy_appinfo(handle);
+ if (ret != AIL_ERROR_OK) {
+ NOTIFICATION_ERR("Fail to ail_package_destroy_appinfo");
+ }
+
+ return name;
+}
+
+static void _notification_get_text_domain(notification_h noti)
+{
+ if (noti->domain != NULL) {
+
+ }
+
+ if (noti->dir != NULL) {
+
+ }
+}
+
+static void _notification_chagned_noti_cb(DBusMessage *message, void *data)
+{
+ notification_cb_list_s *noti_cb_list = NULL;
+ DBusMessageIter iter;
+
+ int op_num = 0;
+ notification_op *op_list = NULL;
+
+ if (g_notification_cb_list == NULL) {
+ return;
+ }
+
+ noti_cb_list = g_notification_cb_list;
+
+ while (noti_cb_list->prev != NULL) {
+ noti_cb_list = noti_cb_list->prev;
+ }
+
+ if (message != NULL) {
+ if (dbus_message_iter_init(message, &iter)) {
+ _notification_unpack_operation_msg(&iter, &op_list, &op_num);
+ NOTIFICATION_ERR("operation num:%d", op_num);
+ }
+ }
+
+ while (noti_cb_list != NULL) {
+ if (noti_cb_list->cb_type == NOTIFICATION_CB_NORMAL && noti_cb_list->changed_cb) {
+ noti_cb_list->changed_cb(noti_cb_list->data,
+ NOTIFICATION_TYPE_NOTI);
+ }
+ if (noti_cb_list->cb_type == NOTIFICATION_CB_DETAILED && noti_cb_list->detailed_changed_cb) {
+ noti_cb_list->detailed_changed_cb(noti_cb_list->data,
+ NOTIFICATION_TYPE_NOTI, op_list, op_num);
+ }
+
+ noti_cb_list = noti_cb_list->next;
+ }
+
+ if (op_list != NULL) {
+ free(op_list);
+ }
+}
+
+#if 0
+static void _notification_chagned_ongoing_cb(void *data)
+{
+ notification_cb_list_s *noti_cb_list = NULL;
+
+ if (g_notification_cb_list == NULL) {
+ return;
+ }
+
+ noti_cb_list = g_notification_cb_list;
+
+ while (noti_cb_list->prev != NULL) {
+ noti_cb_list = noti_cb_list->prev;
+ }
+
+ while (noti_cb_list != NULL) {
+ if (noti_cb_list->changed_cb) {
+ noti_cb_list->changed_cb(noti_cb_list->data,
+ NOTIFICATION_TYPE_ONGOING);
+ }
+
+ noti_cb_list = noti_cb_list->next;
+ }
+}
+#endif
+
+static void _notification_pack_and_send_dbus_message(const char *type, notification_op *op_list , int op_num)
+{
+ DBusConnection *connection = NULL;
+ DBusMessage *message = NULL;
+ DBusMessageIter iter;
+ DBusError err;
+ dbus_bool_t ret;
+ int i = 0;
+
+ if (!type) {
+ NOTIFICATION_ERR("type is NULL");
+ return;
+ }
+
+ dbus_error_init(&err);
+ connection = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
+ if (!connection) {
+ NOTIFICATION_ERR("Fail to dbus_bus_get : %s", err.message);
+ return;
+ }
+
+ message = dbus_message_new_signal(NOTI_DBUS_PATH,
+ NOTI_DBUS_INTERFACE,
+ type);
+
+ if (!message) {
+ NOTIFICATION_ERR("fail to create dbus message");
+ goto release_n_return;
+ }
+
+ if (op_num > 0 && op_list != NULL) {
+ dbus_message_iter_init_append(message, &iter);
+ _notification_pack_operation_msg(&iter, op_list, op_num);
+ }
+
+ ret = dbus_connection_send(connection, message, NULL);
+ if (!ret) {
+ NOTIFICATION_ERR("fail to send dbus message : %s", type);
+ goto release_n_return;
+ }
+
+ dbus_connection_flush(connection);
+
+ NOTIFICATION_DBG("success to emit signal [%s]", type);
+
+release_n_return:
+ dbus_error_free(&err);
+
+ if (message)
+ dbus_message_unref(message);
+
+ if (connection)
+ dbus_connection_unref(connection);
+}
+
+#define SET_DBUS_MESSAGE 30
+
+static void _notification_changed(const char *type, notification_op *op_list , int op_num)
+{
+ int set = 0;
+ int set_total = 0;
+ int set_modular = 0;
+
+ if (op_num <= SET_DBUS_MESSAGE) {
+ _notification_pack_and_send_dbus_message(type, op_list, op_num);
+ } else {
+ set_total = op_num / SET_DBUS_MESSAGE;
+ set_modular = op_num - (set_total * SET_DBUS_MESSAGE);
+
+ for (set = 0; set < set_total; set++) {
+ _notification_pack_and_send_dbus_message(type, op_list + (set * SET_DBUS_MESSAGE), SET_DBUS_MESSAGE);
+ }
+
+ if (set_modular > 0) {
+ _notification_pack_and_send_dbus_message(type,
+ op_list + (set_total * SET_DBUS_MESSAGE), set_modular);
+ }
+ }
+}
+
+static DBusHandlerResult _dbus_signal_filter(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ const char *interface = NULL;
+
+ interface = dbus_message_get_interface(msg);
+ NOTIFICATION_DBG("path : %s", dbus_message_get_path(msg));
+ NOTIFICATION_DBG("interface : %s", interface);
+
+ if (strcmp(NOTI_DBUS_INTERFACE, interface))
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+
+ switch (dbus_message_get_type(msg)) {
+ case DBUS_MESSAGE_TYPE_SIGNAL:
+ _notification_chagned_noti_cb(msg, NULL);
+ return DBUS_HANDLER_RESULT_HANDLED;
+ default:
+ break;
+ }
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+static DBusConnection *_noti_changed_monitor_init()
+{
+ DBusError err;
+ DBusConnection *conn = NULL;
+ char rule[1024];
+
+ dbus_error_init(&err);
+ conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
+ if (!conn) {
+ printf("fail to get bus\n");
+ return NULL;
+ }
+ dbus_connection_setup_with_g_main(conn, NULL);
+ snprintf(rule, 1024,
+ "path='%s',type='signal',interface='%s',member='%s'",
+ NOTI_DBUS_PATH,
+ NOTI_DBUS_INTERFACE,
+ NOTI_CHANGED_NOTI);
+
+ dbus_bus_add_match(conn, rule, &err);
+ if (dbus_connection_add_filter(conn,_dbus_signal_filter,
+ NULL, NULL) == FALSE) {
+ NOTIFICATION_ERR("fail to dbus_connection_add_filter");
+ dbus_connection_close(conn);
+ return NULL;
+ }
+
+ dbus_connection_set_exit_on_disconnect(conn, FALSE);
+ return conn;
+}
+
+static void _noti_chanaged_monitor_fini()
+{
+ DBusConnection *conn = g_dbus_handle;
+ char rule[1024];
+
+ if (!conn)
+ return;
+ dbus_connection_remove_filter(conn, _dbus_signal_filter, NULL);
+
+ snprintf(rule, 1024,
+ "path='%s',type='signal',interface='%s',member='%s'",
+ NOTI_DBUS_PATH,
+ NOTI_DBUS_INTERFACE,
+ NOTI_CHANGED_NOTI);
+ dbus_bus_remove_match(conn, rule, NULL);
+
+ dbus_connection_close(conn);
+ g_dbus_handle = NULL;
+}
+
+notification_op *_notification_make_basic_op(notification_op_type_e type, int num_op, int *list_priv_id, int num_priv_id)
+{
+ int i = 0;
+ notification_op *op_list = NULL;
+
+ if (num_op <= 0) {
+ return NULL;
+ }
+
+ op_list = (notification_op *)malloc(sizeof(notification_op) * num_op);
+ memset(op_list, 0x0, sizeof(notification_op) * num_op);
+
+ for (i = 0; i < num_priv_id; i++) {
+ (op_list + i)->type = type;
+ if (list_priv_id != NULL) {
+ (op_list + i)->priv_id = *(list_priv_id + i);
+ }
+ }
+
+ return op_list;
+}
+
+/* notification_set_icon will be removed */
+EXPORT_API notification_error_e notification_set_icon(notification_h noti,
+ const char *icon_path)
+{
+ int ret_err = NOTIFICATION_ERROR_NONE;
+
+ ret_err =
+ notification_set_image(noti, NOTIFICATION_IMAGE_TYPE_ICON,
+ icon_path);
+
+ return ret_err;
+}
+
+/* notification_get_icon will be removed */
+EXPORT_API notification_error_e notification_get_icon(notification_h noti,
+ char **icon_path)
+{
+ int ret_err = NOTIFICATION_ERROR_NONE;
+ char *ret_image_path = NULL;
+
+ ret_err =
+ notification_get_image(noti, NOTIFICATION_IMAGE_TYPE_ICON,
+ &ret_image_path);
+
+ if (ret_err == NOTIFICATION_ERROR_NONE && icon_path != NULL) {
+ *icon_path = ret_image_path;
+
+ //NOTIFICATION_DBG("Get icon : %s", *icon_path);
+ }
+
+ return ret_err;
+}
+
+EXPORT_API notification_error_e notification_set_image(notification_h noti,
+ notification_image_type_e type,
+ const char *image_path)
+{
+ bundle *b = NULL;
+ char buf_key[32] = { 0, };
+ const char *ret_val = NULL;
+
+ /* Check noti and image_path are valid data */
+ if (noti == NULL || image_path == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Check image type is valid type */
+ if (type <= NOTIFICATION_IMAGE_TYPE_NONE
+ || type >= NOTIFICATION_IMAGE_TYPE_MAX) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Check image path bundle is exist */
+ if (noti->b_image_path) {
+ /* If image path bundle is exist, store local bundle value */
+ b = noti->b_image_path;
+
+ /* Set image type to key as char string type */
+ snprintf(buf_key, sizeof(buf_key), "%d", type);
+
+ /* Get value using key */
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL) {
+ /* If key is exist, remove this value to store new image path */
+ bundle_del(b, buf_key);
+ }
+
+ /* Add new image path with type key */
+ bundle_add(b, buf_key, image_path);
+ } else {
+ /* If image path bundle is not exist, create new one */
+ b = bundle_create();
+
+ /* Set image type to key as char string type */
+ snprintf(buf_key, sizeof(buf_key), "%d", type);
+
+ /* Add new image path with type key */
+ bundle_add(b, buf_key, image_path);
+
+ /* Save to image path bundle */
+ noti->b_image_path = b;
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_image(notification_h noti,
+ notification_image_type_e type,
+ char **image_path)
+{
+ bundle *b = NULL;
+ char buf_key[32] = { 0, };
+ const char *ret_val = NULL;
+ const char *pkgname = NULL;
+
+ /* Check noti and image_path is valid data */
+ if (noti == NULL || image_path == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Check image type is valid data */
+ if (type <= NOTIFICATION_IMAGE_TYPE_NONE
+ || type >= NOTIFICATION_IMAGE_TYPE_MAX) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Check image path bundle exist */
+ if (noti->b_image_path) {
+ /* If image path bundle exist, store local bundle data */
+ b = noti->b_image_path;
+
+ /* Set image type to key as char string type */
+ snprintf(buf_key, sizeof(buf_key), "%d", type);
+
+ /* Get value of key */
+ ret_val = bundle_get_val(b, buf_key);
+
+ *image_path = (char *)ret_val;
+ } else {
+ /* If image path bundle does not exist, image path is NULL */
+ *image_path = NULL;
+ }
+
+ /* If image path is NULL and type is ICON, icon path set from AIL */
+ /* order : user icon -> launch_pkgname icon -> caller_pkgname icon -> service app icon */
+ if (*image_path == NULL && type == NOTIFICATION_IMAGE_TYPE_ICON) {
+ /* Check App icon path is already set */
+ if (noti->app_icon_path != NULL) {
+ /* image path will be app icon path */
+ *image_path = noti->app_icon_path;
+ } else {
+ /* Get image path using launch_pkgname */
+ if (noti->launch_pkgname != NULL) {
+ noti->app_icon_path =
+ _notification_get_icon(noti->launch_pkgname);
+ }
+
+ /* If app icon path is NULL, get image path using caller_pkgname */
+ if (noti->app_icon_path == NULL
+ && noti->caller_pkgname != NULL) {
+ noti->app_icon_path =
+ _notification_get_icon(noti->caller_pkgname);
+ }
+
+ /* If app icon path is NULL, get image path using service data */
+ if (noti->app_icon_path == NULL
+ && noti->b_service_single_launch != NULL) {
+ pkgname =
+ appsvc_get_pkgname(noti->b_service_single_launch);
+ if (pkgname != NULL) {
+ noti->app_icon_path =
+ _notification_get_icon(pkgname);
+ }
+ }
+
+ *image_path = noti->app_icon_path;
+ }
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_time(notification_h noti,
+ time_t input_time)
+{
+ /* Check noti is valid data */
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ if (input_time == 0) {
+ /* If input time is 0, set current time */
+ noti->time = time(NULL);
+ } else {
+ /* save input time */
+ noti->time = input_time;
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_time(notification_h noti,
+ time_t * ret_time)
+{
+ /* Check noti and time is valid data */
+ if (noti == NULL || ret_time == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Set time infomation */
+ *ret_time = noti->time;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_insert_time(notification_h noti,
+ time_t * ret_time)
+{
+ /* Check noti and ret_time is valid data */
+ if (noti == NULL || ret_time == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Set insert time information */
+ *ret_time = noti->insert_time;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_title(notification_h noti,
+ const char *title,
+ const char *loc_title)
+{
+ int noti_err = NOTIFICATION_ERROR_NONE;
+
+ noti_err = notification_set_text(noti, NOTIFICATION_TEXT_TYPE_TITLE,
+ title, loc_title,
+ NOTIFICATION_VARIABLE_TYPE_NONE);
+
+ return noti_err;
+}
+
+EXPORT_API notification_error_e notification_get_title(notification_h noti,
+ char **title,
+ char **loc_title)
+{
+ int noti_err = NOTIFICATION_ERROR_NONE;
+ char *ret_text = NULL;
+
+ noti_err =
+ notification_get_text(noti, NOTIFICATION_TEXT_TYPE_TITLE,
+ &ret_text);
+
+ if (title != NULL) {
+ *title = ret_text;
+ }
+
+ if (loc_title != NULL) {
+ *loc_title = NULL;
+ }
+
+ return noti_err;
+}
+
+EXPORT_API notification_error_e notification_set_content(notification_h noti,
+ const char *content,
+ const char *loc_content)
+{
+ int noti_err = NOTIFICATION_ERROR_NONE;
+
+ noti_err = notification_set_text(noti, NOTIFICATION_TEXT_TYPE_CONTENT,
+ content, loc_content,
+ NOTIFICATION_VARIABLE_TYPE_NONE);
+
+ return noti_err;
+}
+
+EXPORT_API notification_error_e notification_get_content(notification_h noti,
+ char **content,
+ char **loc_content)
+{
+ int noti_err = NOTIFICATION_ERROR_NONE;
+ char *ret_text = NULL;
+
+ noti_err =
+ notification_get_text(noti, NOTIFICATION_TEXT_TYPE_CONTENT,
+ &ret_text);
+
+ if (content != NULL) {
+ *content = ret_text;
+ }
+
+ if (loc_content != NULL) {
+ *loc_content = NULL;
+ }
+
+ return noti_err;
+
+#if 0
+ ret =
+ vconf_get_bool
+ (VCONFKEY_SETAPPL_STATE_TICKER_NOTI_DISPLAY_CONTENT_BOOL, &boolval);
+
+ if (ret == -1 || boolval == 0) {
+ if (content != NULL && noti->default_content != NULL) {
+ *content = noti->default_content;
+ }
+
+ if (loc_content != NULL && noti->loc_default_content != NULL) {
+ *loc_content = noti->loc_default_content;
+ }
+ }
+#endif
+}
+
+EXPORT_API notification_error_e notification_set_text(notification_h noti,
+ notification_text_type_e type,
+ const char *text,
+ const char *key,
+ int args_type, ...)
+{
+ bundle *b = NULL;
+ char buf_key[32] = { 0, };
+ char buf_val[1024] = { 0, };
+ const char *ret_val = NULL;
+ va_list var_args;
+ notification_variable_type_e var_type;
+ int num_args = 0;
+ notification_error_e noti_err = NOTIFICATION_ERROR_NONE;
+ int var_value_int = 0;
+ double var_value_double = 0.0;
+ char *var_value_string = NULL;
+ notification_count_pos_type_e var_value_count =
+ NOTIFICATION_COUNT_POS_NONE;
+
+ /* Check noti is valid data */
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Check text type is valid type */
+ if (type <= NOTIFICATION_TEXT_TYPE_NONE
+ || type >= NOTIFICATION_TEXT_TYPE_MAX) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Check text bundle exist */
+ if (text != NULL) {
+ if (noti->b_text != NULL) {
+ /* If text bundle exist, store local bundle data */
+ b = noti->b_text;
+
+ /* Make type to key as char string */
+ snprintf(buf_key, sizeof(buf_key), "%d", type);
+
+ /* Get value using type key */
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL) {
+ /* If value exist, remove this to add new value */
+ bundle_del(b, buf_key);
+ }
+
+ snprintf(buf_val, sizeof(buf_val), "%s", text);
+
+ /* Add new text value */
+ bundle_add(b, buf_key, buf_val);
+ } else {
+ /* If text bundle does not exist, create new one */
+ b = bundle_create();
+
+ /* Make type to key as char string */
+ snprintf(buf_key, sizeof(buf_key), "%d", type);
+
+ snprintf(buf_val, sizeof(buf_val), "%s", text);
+
+ /* Add new text value */
+ bundle_add(b, buf_key, buf_val);
+
+ /* Save text bundle */
+ noti->b_text = b;
+ }
+ } else {
+ /* Reset if text is NULL */
+ if (noti->b_text != NULL) {
+ /* If text bundle exist, store local bundle data */
+ b = noti->b_text;
+
+ /* Make type to key as char string */
+ snprintf(buf_key, sizeof(buf_key), "%d", type);
+
+ /* Get value using type key */
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL) {
+ /* If value exist, remove this */
+ bundle_del(b, buf_key);
+ }
+ }
+ }
+
+ /* Save key if key is valid data */
+ if (key != NULL) {
+ /* Check key bundle exist */
+ if (noti->b_key != NULL) {
+ /* If key bundle exist, store local bundle data */
+ b = noti->b_key;
+
+ /* Make type to key as char string */
+ snprintf(buf_key, sizeof(buf_key), "%d", type);
+
+ /* Get value using type key */
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL) {
+ /* If value exist, remove this to add new value */
+ bundle_del(b, buf_key);
+ }
+
+ snprintf(buf_val, sizeof(buf_val), "%s", key);
+
+ /* Add new key value */
+ bundle_add(b, buf_key, buf_val);
+ } else {
+ /* If key bundle does not exist, create new one */
+ b = bundle_create();
+
+ /* Make type to key as char string */
+ snprintf(buf_key, sizeof(buf_key), "%d", type);
+
+ snprintf(buf_val, sizeof(buf_val), "%s", key);
+
+ /* Add new key value */
+ bundle_add(b, buf_key, buf_val);
+
+ /* Save key bundle */
+ noti->b_key = b;
+ }
+ } else {
+ /* Reset if key is NULL */
+ if (noti->b_key != NULL) {
+ /* If key bundle exist, store local bundle data */
+ b = noti->b_key;
+
+ /* Make type to key as char string */
+ snprintf(buf_key, sizeof(buf_key), "%d", type);
+
+ /* Get value using type key */
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL) {
+ /* If value exist, remove this */
+ bundle_del(b, buf_key);
+ }
+ }
+ }
+
+ if (noti->b_format_args != NULL) {
+ b = noti->b_format_args;
+ } else {
+ b = bundle_create();
+ }
+
+ va_start(var_args, args_type);
+
+ var_type = args_type;
+ num_args = 0;
+
+ while (var_type != NOTIFICATION_VARIABLE_TYPE_NONE) {
+ /* Type */
+ snprintf(buf_key, sizeof(buf_key), "%dtype%d", type, num_args);
+ snprintf(buf_val, sizeof(buf_val), "%d", var_type);
+
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL) {
+ bundle_del(b, buf_key);
+ }
+
+ bundle_add(b, buf_key, buf_val);
+
+ switch (var_type) {
+ case NOTIFICATION_VARIABLE_TYPE_INT:
+ var_value_int = va_arg(var_args, int);
+
+ /* Value */
+ snprintf(buf_key, sizeof(buf_key), "%dvalue%d", type,
+ num_args);
+ snprintf(buf_val, sizeof(buf_val), "%d", var_value_int);
+
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL) {
+ bundle_del(b, buf_key);
+ }
+
+ bundle_add(b, buf_key, buf_val);
+ break;
+ case NOTIFICATION_VARIABLE_TYPE_DOUBLE:
+ var_value_double = va_arg(var_args, double);
+
+ /* Value */
+ snprintf(buf_key, sizeof(buf_key), "%dvalue%d", type,
+ num_args);
+ snprintf(buf_val, sizeof(buf_val), "%.2f",
+ var_value_double);
+
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL) {
+ bundle_del(b, buf_key);
+ }
+
+ bundle_add(b, buf_key, buf_val);
+ break;
+ case NOTIFICATION_VARIABLE_TYPE_STRING:
+ var_value_string = va_arg(var_args, char *);
+
+ /* Value */
+ snprintf(buf_key, sizeof(buf_key), "%dvalue%d", type,
+ num_args);
+ snprintf(buf_val, sizeof(buf_val), "%s",
+ var_value_string);
+
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL) {
+ bundle_del(b, buf_key);
+ }
+
+ bundle_add(b, buf_key, buf_val);
+ break;
+ case NOTIFICATION_VARIABLE_TYPE_COUNT:
+ var_value_count =
+ va_arg(var_args, notification_count_pos_type_e);
+
+ /* Value */
+ snprintf(buf_key, sizeof(buf_key), "%dvalue%d", type,
+ num_args);
+ snprintf(buf_val, sizeof(buf_val), "%d",
+ var_value_count);
+
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL) {
+ bundle_del(b, buf_key);
+ }
+
+ bundle_add(b, buf_key, buf_val);
+ break;
+ default:
+ NOTIFICATION_ERR("Error. invalid variable type. : %d",
+ var_type);
+ noti_err = NOTIFICATION_ERROR_INVALID_DATA;
+ break;
+ }
+
+ num_args++;
+ var_type = va_arg(var_args, notification_variable_type_e);
+ }
+ va_end(var_args);
+
+ if (noti_err == NOTIFICATION_ERROR_NONE) {
+ noti->num_format_args = num_args;
+ } else {
+ noti->num_format_args = 0;
+ }
+
+ snprintf(buf_key, sizeof(buf_key), "num%d", type);
+ snprintf(buf_val, sizeof(buf_val), "%d", noti->num_format_args);
+
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL) {
+ bundle_del(b, buf_key);
+ }
+
+ bundle_add(b, buf_key, buf_val);
+
+ noti->b_format_args = b;
+
+ return noti_err;
+}
+
+EXPORT_API notification_error_e notification_get_text(notification_h noti,
+ notification_text_type_e type,
+ char **text)
+{
+ bundle *b = NULL;
+ char buf_key[32] = { 0, };
+ const char *ret_val = NULL;
+ const char *pkgname = NULL;
+ const char *get_str = NULL;
+ const char *get_check_type_str = NULL;
+ int ret = 0;
+ int boolval = 0;
+ notification_text_type_e check_type = NOTIFICATION_TEXT_TYPE_NONE;
+ int display_option_flag = 0;
+
+ char *temp_str = NULL;
+ char result_str[NOTI_TEXT_RESULT_LEN] = { 0, };
+ char buf_str[1024] = { 0, };
+ int num_args = 0;
+ notification_variable_type_e ret_var_type = 0;
+ int ret_variable_int = 0;
+ double ret_variable_double = 0.0;
+
+ /* Check noti is valid data */
+ if (noti == NULL || text == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Check text type is valid type */
+ if (type <= NOTIFICATION_TEXT_TYPE_NONE
+ || type >= NOTIFICATION_TEXT_TYPE_MAX) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Check key */
+ if (noti->b_key != NULL) {
+ b = noti->b_key;
+
+ /* Get text domain and dir */
+ _notification_get_text_domain(noti);
+
+ snprintf(buf_key, sizeof(buf_key), "%d", type);
+
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL && noti->domain != NULL
+ && noti->dir != NULL) {
+ /* Get application string */
+ bindtextdomain(noti->domain, noti->dir);
+
+ get_str = dgettext(noti->domain, ret_val);
+ } else if (ret_val != NULL) {
+ /* Get system string */
+ get_str = dgettext("sys_string", ret_val);
+ } else {
+ get_str = NULL;
+ }
+ }
+
+ if (get_str == NULL && noti->b_text != NULL) {
+ b = noti->b_text;
+ /* Get basic text */
+ snprintf(buf_key, sizeof(buf_key), "%d", type);
+
+ get_str = bundle_get_val(b, buf_key);
+ }
+
+ check_type = type;
+
+ /* Set display option is off type when option is off, type is noti */
+ if (get_str != NULL && display_option_flag == 1
+ && noti->type == NOTIFICATION_TYPE_NOTI) {
+ if (type == NOTIFICATION_TEXT_TYPE_CONTENT
+ || type == NOTIFICATION_TEXT_TYPE_GROUP_CONTENT) {
+ /* Set check_type to option content string */
+ if (type == NOTIFICATION_TEXT_TYPE_CONTENT) {
+ check_type =
+ NOTIFICATION_TEXT_TYPE_CONTENT_FOR_DISPLAY_OPTION_IS_OFF;
+ } else if (type == NOTIFICATION_TEXT_TYPE_GROUP_CONTENT) {
+ check_type =
+ NOTIFICATION_TEXT_TYPE_GROUP_CONTENT_FOR_DISPLAY_OPTION_IS_OFF;
+ }
+
+ /* Check key */
+ if (noti->b_key != NULL) {
+ b = noti->b_key;
+
+ /* Get text domain and dir */
+ _notification_get_text_domain(noti);
+
+ snprintf(buf_key, sizeof(buf_key), "%d",
+ check_type);
+
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL && noti->domain != NULL
+ && noti->dir != NULL) {
+ /* Get application string */
+ bindtextdomain(noti->domain, noti->dir);
+
+ get_check_type_str =
+ dgettext(noti->domain, ret_val);
+ } else if (ret_val != NULL) {
+ /* Get system string */
+ get_check_type_str =
+ dgettext("sys_string", ret_val);
+ } else {
+ get_check_type_str = NULL;
+ }
+ }
+
+ if (get_check_type_str == NULL && noti->b_text != NULL) {
+ b = noti->b_text;
+ /* Get basic text */
+ snprintf(buf_key, sizeof(buf_key), "%d",
+ check_type);
+
+ get_check_type_str = bundle_get_val(b, buf_key);
+ }
+ }
+
+ if (get_check_type_str != NULL) {
+ /* Replace option off type string */
+ get_str = get_check_type_str;
+ } else {
+ /* Set default string */
+ get_str =
+ dgettext("sys_string", "IDS_COM_POP_MISSED_EVENT");
+ }
+ }
+
+ if (get_str != NULL) {
+ /* Get number format args */
+ b = noti->b_format_args;
+ noti->num_format_args = 0;
+
+ if (b != NULL) {
+ snprintf(buf_key, sizeof(buf_key), "num%d", check_type);
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL) {
+ noti->num_format_args = atoi(ret_val);
+ }
+ }
+
+ if (noti->num_format_args == 0) {
+ *text = (char *)get_str;
+ } else {
+ /* Check first variable is count, LEFT pos */
+ snprintf(buf_key, sizeof(buf_key), "%dtype%d",
+ check_type, num_args);
+ ret_val = bundle_get_val(b, buf_key);
+ ret_var_type = atoi(ret_val);
+
+ if (ret_var_type == NOTIFICATION_VARIABLE_TYPE_COUNT) {
+ /* Get var Value */
+ snprintf(buf_key, sizeof(buf_key), "%dvalue%d",
+ check_type, num_args);
+ ret_val = bundle_get_val(b, buf_key);
+ ret_variable_int = atoi(ret_val);
+
+ if (ret_variable_int ==
+ NOTIFICATION_COUNT_POS_LEFT) {
+ notification_noti_get_count(noti->type,
+ noti->caller_pkgname,
+ noti->group_id,
+ noti->priv_id,
+ &ret_variable_int);
+ snprintf(buf_str, sizeof(buf_str),
+ "%d ", ret_variable_int);
+
+ int src_len = strlen(result_str);
+ int max_len = NOTI_TEXT_RESULT_LEN - src_len - 1;
+
+ strncat(result_str, buf_str,
+ max_len);
+
+ num_args++;
+ }
+
+ }
+
+ /* Check variable IN pos */
+ for (temp_str = (char *)get_str; *temp_str != '\0';
+ temp_str++) {
+ if (*temp_str != '%') {
+ strncat(result_str, temp_str, 1);
+ } else {
+ if (*(temp_str + 1) == '%') {
+ strncat(result_str, temp_str,
+ 1);
+ } else if (*(temp_str + 1) == 'd') {
+ /* Get var Type */
+ ret_variable_int = 0;
+
+ snprintf(buf_key,
+ sizeof(buf_key),
+ "%dtype%d", check_type,
+ num_args);
+ ret_val =
+ bundle_get_val(b, buf_key);
+ ret_var_type = atoi(ret_val);
+ if (ret_var_type ==
+ NOTIFICATION_VARIABLE_TYPE_COUNT)
+ {
+ /* Get notification count */
+ notification_noti_get_count
+ (noti->type,
+ noti->caller_pkgname,
+ noti->group_id,
+ noti->priv_id,
+ &ret_variable_int);
+ } else {
+ /* Get var Value */
+ snprintf(buf_key,
+ sizeof
+ (buf_key),
+ "%dvalue%d",
+ check_type,
+ num_args);
+ ret_val =
+ bundle_get_val(b,
+ buf_key);
+ ret_variable_int =
+ atoi(ret_val);
+ }
+
+ snprintf(buf_str,
+ sizeof(buf_str), "%d",
+ ret_variable_int);
+
+ int src_len = strlen(result_str);
+ int max_len = NOTI_TEXT_RESULT_LEN - src_len - 1;
+
+ strncat(result_str, buf_str,
+ max_len);
+
+ temp_str++;
+
+ num_args++;
+ } else if (*(temp_str + 1) == 's') {
+ /* Get var Value */
+ snprintf(buf_key,
+ sizeof(buf_key),
+ "%dvalue%d",
+ check_type, num_args);
+ ret_val =
+ bundle_get_val(b, buf_key);
+
+ snprintf(buf_str,
+ sizeof(buf_str), "%s",
+ ret_val);
+
+ int src_len = strlen(result_str);
+ int max_len = NOTI_TEXT_RESULT_LEN - src_len - 1;
+
+ strncat(result_str, buf_str,
+ max_len);
+
+ temp_str++;
+
+ num_args++;
+ } else if (*(temp_str + 1) == 'f') {
+ /* Get var Value */
+ snprintf(buf_key,
+ sizeof(buf_key),
+ "%dvalue%d",
+ check_type, num_args);
+ ret_val =
+ bundle_get_val(b, buf_key);
+ ret_variable_double =
+ atof(ret_val);
+
+ snprintf(buf_str,
+ sizeof(buf_str),
+ "%.2f",
+ ret_variable_double);
+
+ int src_len = strlen(result_str);
+ int max_len = NOTI_TEXT_RESULT_LEN - src_len - 1;
+
+ strncat(result_str, buf_str,
+ max_len);
+
+ temp_str++;
+
+ num_args++;
+ }
+ }
+
+ }
+
+ /* Check last variable is count, LEFT pos */
+ if (num_args < noti->num_format_args) {
+ snprintf(buf_key, sizeof(buf_key), "%dtype%d",
+ check_type, num_args);
+ ret_val = bundle_get_val(b, buf_key);
+ ret_var_type = atoi(ret_val);
+ if (ret_var_type ==
+ NOTIFICATION_VARIABLE_TYPE_COUNT) {
+ /* Get var Value */
+ snprintf(buf_key, sizeof(buf_key),
+ "%dvalue%d", check_type,
+ num_args);
+ ret_val = bundle_get_val(b, buf_key);
+ ret_variable_int = atoi(ret_val);
+
+ if (ret_variable_int ==
+ NOTIFICATION_COUNT_POS_RIGHT) {
+ notification_noti_get_count
+ (noti->type,
+ noti->caller_pkgname,
+ noti->group_id,
+ noti->priv_id,
+ &ret_variable_int);
+ snprintf(buf_str,
+ sizeof(buf_str), " %d",
+ ret_variable_int);
+
+ int src_len = strlen(result_str);
+ int max_len = NOTI_TEXT_RESULT_LEN - src_len - 1;
+
+ strncat(result_str, buf_str,
+ max_len);
+
+ num_args++;
+ }
+
+ }
+ }
+
+ switch (check_type) {
+ case NOTIFICATION_TEXT_TYPE_TITLE:
+ case NOTIFICATION_TEXT_TYPE_GROUP_TITLE:
+ if (noti->temp_title != NULL)
+ free(noti->temp_title);
+
+ noti->temp_title = strdup(result_str);
+
+ *text = noti->temp_title;
+ break;
+ case NOTIFICATION_TEXT_TYPE_CONTENT:
+ case NOTIFICATION_TEXT_TYPE_CONTENT_FOR_DISPLAY_OPTION_IS_OFF:
+ case NOTIFICATION_TEXT_TYPE_GROUP_CONTENT:
+ case NOTIFICATION_TEXT_TYPE_GROUP_CONTENT_FOR_DISPLAY_OPTION_IS_OFF:
+ if (noti->temp_content !=
+ NULL)
+ free(noti->temp_content);
+
+ noti->temp_content = strdup(result_str);
+
+ *text = noti->temp_content;
+ break;
+ default:
+ break;
+ }
+
+ }
+
+ } else {
+ if (check_type == NOTIFICATION_TEXT_TYPE_TITLE
+ || check_type == NOTIFICATION_TEXT_TYPE_GROUP_TITLE) {
+ /* Remove app name if exist, because pkgname is changed according to language setting */
+ if (noti->app_name != NULL) {
+ free(noti->app_name);
+ noti->app_name = NULL;
+ }
+
+ /* First, get app name from launch_pkgname */
+ if (noti->launch_pkgname != NULL) {
+ noti->app_name =
+ _notification_get_name(noti->
+ launch_pkgname);
+ }
+
+ /* Second, get app name from caller_pkgname */
+ if (noti->app_name == NULL
+ && noti->caller_pkgname != NULL) {
+ noti->app_name =
+ _notification_get_name(noti->
+ caller_pkgname);
+ }
+
+ /* Third, get app name from service data */
+ if (noti->app_name == NULL
+ && noti->b_service_single_launch != NULL) {
+ pkgname =
+ appsvc_get_pkgname(noti->
+ b_service_single_launch);
+
+ if (pkgname != NULL) {
+ noti->app_name =
+ _notification_get_name(pkgname);
+ }
+ }
+
+ *text = noti->app_name;
+ } else {
+ *text = NULL;
+ }
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_text_domain(notification_h noti,
+ const char *domain,
+ const char *dir)
+{
+ /* check noti and domain is valid data */
+ if (noti == NULL || domain == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Check domain */
+ if (noti->domain) {
+ /* Remove previous domain */
+ free(noti->domain);
+ }
+ /* Copy domain */
+ noti->domain = strdup(domain);
+
+ /* Check locale dir */
+ if (noti->dir) {
+ /* Remove previous locale dir */
+ free(noti->dir);
+ }
+ /* Copy locale dir */
+ noti->dir = strdup(dir);
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_text_domain(notification_h noti,
+ char **domain,
+ char **dir)
+{
+ /* Check noti is valid data */
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Get domain */
+ if (domain != NULL && noti->domain != NULL) {
+ *domain = noti->domain;
+ }
+
+ /* Get locale dir */
+ if (dir != NULL && noti->dir != NULL) {
+ *dir = noti->dir;
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_time_to_text(notification_h noti, notification_text_type_e type,
+ time_t time)
+{
+ notification_error_e ret = NOTIFICATION_ERROR_NONE;
+ char buf[256] = { 0, };
+ char buf_tag[512] = { 0, };
+
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+ if (time <= 0) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ snprintf(buf, sizeof(buf), "%lu", time);
+ ret = notification_noti_set_tag(TAG_TIME, buf, buf_tag, sizeof(buf_tag));
+
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ return ret;
+ }
+
+ return notification_set_text(noti, type, buf_tag, NULL, NOTIFICATION_VARIABLE_TYPE_NONE);
+}
+
+EXPORT_API notification_error_e notification_get_time_from_text(notification_h noti, notification_text_type_e type,
+ time_t *time)
+{
+ notification_error_e ret = NOTIFICATION_ERROR_NONE;
+ char buf[256] = { 0, };
+ char buf_tag[512] = { 0, };
+
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+ if (time == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ char *ret_text = NULL;
+ ret = notification_get_text(noti, type, &ret_text);
+
+ if (ret != NOTIFICATION_ERROR_NONE || ret_text == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ if (notification_noti_get_tag_type(ret_text) == TAG_TYPE_INVALID) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ char *tag_value = NULL;
+ tag_value = notification_noti_strip_tag(ret_text);
+ if (tag_value == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ *time = atol(tag_value);
+ free(tag_value);
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_sound(notification_h noti,
+ notification_sound_type_e type,
+ const char *path)
+{
+ /* Check noti is valid data */
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Check type is valid */
+ if (type < NOTIFICATION_SOUND_TYPE_NONE
+ || type >= NOTIFICATION_SOUND_TYPE_MAX) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Save sound type */
+ noti->sound_type = type;
+
+ /* Save sound path if user data type */
+ if (type == NOTIFICATION_SOUND_TYPE_USER_DATA && path != NULL) {
+ if (noti->sound_path != NULL) {
+ free(noti->sound_path);
+ }
+
+ noti->sound_path = strdup(path);
+ } else {
+ if (noti->sound_path != NULL) {
+ free(noti->sound_path);
+ noti->sound_path = NULL;
+ }
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_sound(notification_h noti,
+ notification_sound_type_e *type,
+ const char **path)
+{
+ /* check noti and type is valid data */
+ if (noti == NULL || type == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Set sound type */
+ *type = noti->sound_type;
+
+ /* Set sound path if user data type */
+ if (noti->sound_type == NOTIFICATION_SOUND_TYPE_USER_DATA
+ && path != NULL) {
+ *path = noti->sound_path;
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_vibration(notification_h noti,
+ notification_vibration_type_e type,
+ const char *path)
+{
+ /* Check noti is valid data */
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Check type is valid */
+ if (type < NOTIFICATION_VIBRATION_TYPE_NONE
+ || type >= NOTIFICATION_VIBRATION_TYPE_MAX) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Save vibration type */
+ noti->vibration_type = type;
+
+ /* Save sound path if user data type */
+ if (type == NOTIFICATION_VIBRATION_TYPE_USER_DATA && path != NULL) {
+ if (noti->vibration_path != NULL) {
+ free(noti->vibration_path);
+ }
+
+ noti->vibration_path = strdup(path);
+ } else {
+ if (noti->vibration_path != NULL) {
+ free(noti->vibration_path);
+ noti->vibration_path = NULL;
+ }
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+
+}
+
+EXPORT_API notification_error_e notification_get_vibration(notification_h noti,
+ notification_vibration_type_e *type,
+ const char **path)
+{
+ /* check noti and type is valid data */
+ if (noti == NULL || type == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Set vibration type */
+ *type = noti->vibration_type;
+
+ /* Set sound path if user data type */
+ if (noti->vibration_type == NOTIFICATION_VIBRATION_TYPE_USER_DATA
+ && path != NULL) {
+ *path = noti->vibration_path;
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_application(notification_h noti,
+ const char *pkgname)
+{
+ if (noti == NULL || pkgname == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ if (noti->launch_pkgname) {
+ free(noti->launch_pkgname);
+ }
+
+ noti->launch_pkgname = strdup(pkgname);
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_application(notification_h noti,
+ char **pkgname)
+{
+ if (noti == NULL || pkgname == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ if (noti->launch_pkgname) {
+ *pkgname = noti->launch_pkgname;
+ } else {
+ *pkgname = noti->caller_pkgname;
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_args(notification_h noti,
+ bundle * args,
+ bundle * group_args)
+{
+ if (noti == NULL || args == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ if (noti->args) {
+ bundle_free(noti->args);
+ }
+
+ noti->args = bundle_dup(args);
+
+ if (noti->group_args) {
+ bundle_free(noti->group_args);
+ noti->group_args = NULL;
+ }
+
+ if (group_args != NULL) {
+ noti->group_args = bundle_dup(group_args);
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_args(notification_h noti,
+ bundle ** args,
+ bundle ** group_args)
+{
+ if (noti == NULL || args == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ if (noti->args) {
+ *args = noti->args;
+ } else {
+ *args = NULL;
+ }
+
+ if (group_args != NULL && noti->group_args) {
+ *group_args = noti->group_args;
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_execute_option(notification_h noti,
+ notification_execute_type_e type,
+ const char *text,
+ const char *key,
+ bundle *service_handle)
+{
+ char buf_key[32] = { 0, };
+ const char *ret_val = NULL;
+ bundle *b = NULL;
+
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ if (type <= NOTIFICATION_EXECUTE_TYPE_NONE
+ || type >= NOTIFICATION_EXECUTE_TYPE_MAX) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Create execute option bundle if does not exist */
+ if (noti->b_execute_option != NULL) {
+ noti->b_execute_option = bundle_create();
+ }
+
+ b = noti->b_execute_option;
+
+ /* Save text */
+ if (text != NULL) {
+ /* Make text key */
+ snprintf(buf_key, sizeof(buf_key), "text%d", type);
+
+ /* Check text key exist */
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL) {
+ /* Remove previous data */
+ bundle_del(b, buf_key);
+ }
+
+ /* Add text data */
+ bundle_add(b, buf_key, text);
+ }
+
+ /* Save key */
+ if (key != NULL) {
+ /* Make key key */
+ snprintf(buf_key, sizeof(buf_key), "key%d", type);
+
+ /* Check key key exist */
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL) {
+ /* Remove previous data */
+ bundle_del(b, buf_key);
+ }
+
+ /* Add text data */
+ bundle_add(b, buf_key, key);
+ }
+
+ switch (type) {
+ case NOTIFICATION_EXECUTE_TYPE_RESPONDING:
+ /* Remove previous data if exist */
+ if (noti->b_service_responding != NULL) {
+ bundle_free(noti->b_service_responding);
+ noti->b_service_responding = NULL;
+ }
+
+ /* Save service handle */
+ if (service_handle != NULL) {
+ noti->b_service_responding = bundle_dup(service_handle);
+ }
+ break;
+ case NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH:
+ /* Remove previous data if exist */
+ if (noti->b_service_single_launch != NULL) {
+ bundle_free(noti->b_service_single_launch);
+ noti->b_service_single_launch = NULL;
+ }
+
+ /* Save service handle */
+ if (service_handle != NULL) {
+ noti->b_service_single_launch =
+ bundle_dup(service_handle);
+ }
+ break;
+ case NOTIFICATION_EXECUTE_TYPE_MULTI_LAUNCH:
+ /* Remove previous data if exist */
+ if (noti->b_service_multi_launch != NULL) {
+ bundle_free(noti->b_service_multi_launch);
+ noti->b_service_multi_launch = NULL;
+ }
+
+ /* Save service handle */
+ if (service_handle != NULL) {
+ noti->b_service_multi_launch =
+ bundle_dup(service_handle);
+ }
+ break;
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_execute_option(notification_h noti,
+ notification_execute_type_e type,
+ const char **text,
+ bundle **service_handle)
+{
+ char buf_key[32] = { 0, };
+ const char *ret_val = NULL;
+ char *get_str = NULL;
+ bundle *b = NULL;
+
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ if (type <= NOTIFICATION_EXECUTE_TYPE_NONE
+ || type >= NOTIFICATION_EXECUTE_TYPE_MAX) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ switch (type) {
+ case NOTIFICATION_EXECUTE_TYPE_RESPONDING:
+ b = noti->b_service_responding;
+ break;
+ case NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH:
+ b = noti->b_service_single_launch;
+ break;
+ case NOTIFICATION_EXECUTE_TYPE_MULTI_LAUNCH:
+ b = noti->b_service_multi_launch;
+ break;
+ default:
+ b = NULL;
+ break;
+ }
+
+ if (b != NULL) {
+ // Return text
+ if (text != NULL) {
+ // Get text domain and dir
+ if (noti->domain == NULL || noti->dir == NULL) {
+ _notification_get_text_domain(noti);
+ }
+
+ /* Make key */
+ snprintf(buf_key, sizeof(buf_key), "key%d", type);
+
+ /* Check key key exist */
+ ret_val = bundle_get_val(b, buf_key);
+ if (ret_val != NULL && noti->domain != NULL
+ && noti->dir != NULL) {
+ /* Get application string */
+ bindtextdomain(noti->domain, noti->dir);
+
+ get_str = dgettext(noti->domain, ret_val);
+
+ *text = get_str;
+ } else if (ret_val != NULL) {
+ /* Get system string */
+ get_str = dgettext("sys_string", ret_val);
+
+ *text = get_str;
+ } else {
+ /* Get basic text */
+ snprintf(buf_key, sizeof(buf_key), "text%d",
+ type);
+
+ ret_val = bundle_get_val(b, buf_key);
+
+ *text = ret_val;
+ }
+ }
+ }
+
+ switch (type) {
+ case NOTIFICATION_EXECUTE_TYPE_RESPONDING:
+ b = noti->b_service_responding;
+ break;
+ case NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH:
+ b = noti->b_service_single_launch;
+ break;
+ case NOTIFICATION_EXECUTE_TYPE_MULTI_LAUNCH:
+ b = noti->b_service_multi_launch;
+ break;
+ default:
+ b = NULL;
+ break;
+ }
+
+ if (service_handle != NULL) {
+ *service_handle = b;
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_property(notification_h noti,
+ int flags)
+{
+ /* Check noti is valid data */
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Set flags */
+ noti->flags_for_property = flags;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_property(notification_h noti,
+ int *flags)
+{
+ /* Check noti and flags are valid data */
+ if (noti == NULL || flags == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Set flags */
+ *flags = noti->flags_for_property;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_display_applist(notification_h noti,
+ int applist)
+{
+ /* Check noti is valid data */
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Set app list */
+ noti->display_applist = applist;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_display_applist(notification_h noti,
+ int *applist)
+{
+ /* Check noti and applist are valid data */
+ if (noti == NULL || applist == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Set app list */
+ *applist = noti->display_applist;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_size(notification_h noti,
+ double size)
+{
+ /* Check noti is valid data */
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Save progress size */
+ noti->progress_size = size;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_size(notification_h noti,
+ double *size)
+{
+ /* Check noti and size is valid data */
+ if (noti == NULL || size == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Set progress size */
+ *size = noti->progress_size;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_progress(notification_h noti,
+ double percentage)
+{
+ /* Check noti is valid data */
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Save progress percentage */
+ noti->progress_percentage = percentage;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_progress(notification_h noti,
+ double *percentage)
+{
+ /* Check noti and percentage are valid data */
+ if (noti == NULL || percentage == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Set progress percentage */
+ *percentage = noti->progress_percentage;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_pkgname(notification_h noti,
+ const char *pkgname)
+{
+ /* check noti and pkgname are valid data */
+ if (noti == NULL || pkgname == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Remove previous caller pkgname */
+ if (noti->caller_pkgname) {
+ free(noti->caller_pkgname);
+ noti->caller_pkgname = NULL;
+ }
+
+ noti->caller_pkgname = strdup(pkgname);
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_pkgname(notification_h noti,
+ char **pkgname)
+{
+ /* Check noti and pkgname are valid data */
+ if (noti == NULL || pkgname == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Get caller pkgname */
+ if (noti->caller_pkgname) {
+ *pkgname = noti->caller_pkgname;
+ } else {
+ *pkgname = NULL;
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_layout(notification_h noti,
+ notification_ly_type_e layout)
+{
+ /* check noti and pkgname are valid data */
+ if (noti == NULL || (layout < NOTIFICATION_LY_NONE || layout >= NOTIFICATION_LY_MAX)) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ noti->layout = layout;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_layout(notification_h noti,
+ notification_ly_type_e *layout)
+{
+ /* Check noti and pkgname are valid data */
+ if (noti == NULL || layout == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ *layout = noti->layout;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_set_badge(const char *pkgname,
+ int group_id, int count)
+{
+ char *caller_pkgname = NULL;
+ int ret = NOTIFICATION_ERROR_NONE;
+
+ /* Check count is valid count */
+ if (count < 0) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Check pkgname */
+ if (pkgname == NULL) {
+ caller_pkgname = _notification_get_pkgname_by_pid();
+
+ /* Set count into Group DB */
+ ret =
+ notification_group_set_badge(caller_pkgname, group_id,
+ count);
+
+ if (caller_pkgname != NULL) {
+ free(caller_pkgname);
+ }
+ } else {
+ /* Set count into Group DB */
+ ret = notification_group_set_badge(pkgname, group_id, count);
+ }
+
+ return ret;
+}
+
+EXPORT_API notification_error_e notification_get_badge(const char *pkgname,
+ int group_id, int *count)
+{
+ char *caller_pkgname = NULL;
+ int ret = NOTIFICATION_ERROR_NONE;
+ int ret_unread_count = 0;
+
+ /* Check pkgname */
+ if (pkgname == NULL) {
+ caller_pkgname = _notification_get_pkgname_by_pid();
+
+ /* Get count from Group DB */
+ ret =
+ notification_group_get_badge(caller_pkgname, group_id,
+ &ret_unread_count);
+
+ if (caller_pkgname != NULL) {
+ free(caller_pkgname);
+ }
+ } else {
+ /* Get count from Group DB */
+ ret =
+ notification_group_get_badge(pkgname, group_id,
+ &ret_unread_count);
+ }
+
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ return ret;
+ }
+
+ /* Set count */
+ if (count != NULL) {
+ *count = ret_unread_count;
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_id(notification_h noti,
+ int *group_id, int *priv_id)
+{
+ /* check noti is valid data */
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Check group_id is valid data */
+ if (group_id) {
+ /* Set group id */
+ if (noti->group_id < NOTIFICATION_GROUP_ID_NONE) {
+ *group_id = NOTIFICATION_GROUP_ID_NONE;
+ } else {
+ *group_id = noti->group_id;
+ }
+ }
+
+ /* Check priv_id is valid data */
+ if (priv_id) {
+ /* Set priv_id */
+ *priv_id = noti->priv_id;
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_type(notification_h noti,
+ notification_type_e *type)
+{
+ /* Check noti and type is valid data */
+ if (noti == NULL || type == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Set noti type */
+ *type = noti->type;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_insert(notification_h noti,
+ int *priv_id)
+{
+ int ret = 0;
+
+ /* Check noti is vaild data */
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Check noti type is valid type */
+ if (noti->type <= NOTIFICATION_TYPE_NONE
+ || noti->type >= NOTIFICATION_TYPE_MAX) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ /* Save insert time */
+ noti->insert_time = time(NULL);
+
+ /* Insert into DB */
+ ret = notification_noti_insert(noti);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ return ret;
+ }
+
+ /* Check disable update on insert property */
+ if (noti->flags_for_property
+ & NOTIFICATION_PROP_DISABLE_UPDATE_ON_INSERT) {
+ /* Disable changed cb */
+ } else {
+ /* Enable changed cb */
+ notification_op *noti_op = _notification_make_basic_op(NOTIFICATION_OP_INSERT, 1, &(noti->priv_id), 1);
+ if (noti_op != NULL) {
+ _notification_changed(NOTI_CHANGED_NOTI, noti_op, 1);
+ free(noti_op);
+ }
+ }
+
+ /* If priv_id is valid data, set priv_id */
+ if (priv_id != NULL) {
+ *priv_id = noti->priv_id;
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_update(notification_h noti)
+{
+ int ret = 0;
+
+ /* Check noti is valid data */
+ if (noti != NULL) {
+ /* Update insert time ? */
+ noti->insert_time = time(NULL);
+
+ ret = notification_noti_update(noti);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ return ret;
+ }
+
+ notification_op *noti_op = _notification_make_basic_op(NOTIFICATION_OP_UPDATE, 1, &(noti->priv_id), 1);
+ if (noti_op != NULL) {
+ _notification_changed(NOTI_CHANGED_NOTI, noti_op, 1);
+ free(noti_op);
+ }
+ } else {
+ /* Send changed notification */
+ notification_op *noti_op = _notification_make_basic_op(NOTIFICATION_OP_REFRESH, 1, NULL, 0);
+ if (noti_op != NULL) {
+ _notification_changed(NOTI_CHANGED_NOTI, noti_op, 1);
+ free(noti_op);
+ }
+ }
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notifiation_clear(notification_type_e type)
+{
+ int ret = 0;
+ int num_deleted = 0;
+ int *list_deleted = NULL;
+
+ /* Delete all notification of type */
+ ret = notification_noti_delete_all(type, NULL, &num_deleted, &list_deleted);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ return ret;
+ }
+
+ /* Send chagned notification */
+
+ if (num_deleted > 0 && list_deleted != NULL) {
+ notification_op *noti_op = _notification_make_basic_op(NOTIFICATION_OP_DELETE, num_deleted, list_deleted, num_deleted);
+ if (noti_op != NULL) {
+ NOTIFICATION_ERR("noti_op %x", noti_op);
+ _notification_changed(NOTI_CHANGED_NOTI, noti_op, num_deleted);
+ free(noti_op);
+ }
+ }
+
+ if (list_deleted != NULL) {
+ free(list_deleted);
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_delete_all_by_type(const char *pkgname,
+ notification_type_e type)
+{
+ int ret = 0;
+ int num_deleted = 0;
+ int *list_deleted = NULL;
+ char *caller_pkgname = NULL;
+
+ if (pkgname == NULL) {
+ caller_pkgname = _notification_get_pkgname_by_pid();
+ } else {
+ caller_pkgname = strdup(pkgname);
+ }
+
+ ret = notification_noti_delete_all(type, caller_pkgname, &num_deleted, &list_deleted);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ free(caller_pkgname);
+ return ret;
+ }
+
+ /* Send chagned notification */
+ if (num_deleted > 0 && list_deleted != NULL) {
+ notification_op *noti_op = _notification_make_basic_op(NOTIFICATION_OP_DELETE, num_deleted, list_deleted, num_deleted);
+ if (noti_op != NULL) {
+ _notification_changed(NOTI_CHANGED_NOTI, noti_op, num_deleted);
+ free(noti_op);
+ }
+ }
+ if (caller_pkgname != NULL) {
+ free(caller_pkgname);
+ caller_pkgname = NULL;
+ }
+ if (list_deleted != NULL) {
+ free(list_deleted);
+ list_deleted = NULL;
+ }
+
+ return ret;
+}
+
+EXPORT_API notification_error_e notification_delete_group_by_group_id(const char *pkgname,
+ notification_type_e type,
+ int group_id)
+{
+ int ret = 0;
+ int num_deleted = 0;
+ int *list_deleted = NULL;
+ char *caller_pkgname = NULL;
+
+ if (group_id < NOTIFICATION_GROUP_ID_NONE) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ if (pkgname == NULL) {
+ caller_pkgname = _notification_get_pkgname_by_pid();
+ } else {
+ caller_pkgname = strdup(pkgname);
+ }
+
+ ret =
+ notification_noti_delete_group_by_group_id(caller_pkgname,
+ group_id, &num_deleted, &list_deleted);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ free(caller_pkgname);
+ return ret;
+ }
+
+ if (num_deleted > 0 && list_deleted != NULL) {
+ notification_op *noti_op = _notification_make_basic_op(NOTIFICATION_OP_DELETE, num_deleted, list_deleted, num_deleted);
+ if (noti_op != NULL) {
+ _notification_changed(NOTI_CHANGED_NOTI, noti_op, num_deleted);
+ free(noti_op);
+ }
+ }
+
+ if (caller_pkgname != NULL) {
+ free(caller_pkgname);
+ caller_pkgname = NULL;
+ }
+ if (list_deleted != NULL) {
+ free(list_deleted);
+ list_deleted = NULL;
+ }
+
+ return ret;
+}
+
+EXPORT_API notification_error_e notification_delete_group_by_priv_id(const char *pkgname,
+ notification_type_e type,
+ int priv_id)
+{
+ int ret = 0;
+ char *caller_pkgname = NULL;
+
+ if (priv_id < NOTIFICATION_PRIV_ID_NONE) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ if (pkgname == NULL) {
+ caller_pkgname = _notification_get_pkgname_by_pid();
+ } else {
+ caller_pkgname = strdup(pkgname);
+ }
+
+ ret =
+ notification_noti_delete_group_by_priv_id(caller_pkgname, priv_id);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ free(caller_pkgname);
+ return ret;
+ }
+
+ notification_op *noti_op = _notification_make_basic_op(NOTIFICATION_OP_DELETE, 1, NULL, 0);
+ if (noti_op != NULL) {
+ _notification_changed(NOTI_CHANGED_NOTI, noti_op, 1);
+ free(noti_op);
+ }
+
+ free(caller_pkgname);
+
+ return ret;
+}
+
+EXPORT_API notification_error_e notification_delete_by_priv_id(const char *pkgname,
+ notification_type_e type,
+ int priv_id)
+{
+ int ret = 0;
+ char *caller_pkgname = NULL;
+
+ if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ if (pkgname == NULL) {
+ caller_pkgname = _notification_get_pkgname_by_pid();
+ } else {
+ caller_pkgname = strdup(pkgname);
+ }
+
+ ret = notification_noti_delete_by_priv_id(caller_pkgname, priv_id);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ free(caller_pkgname);
+ return ret;
+ }
+
+ notification_op *noti_op = _notification_make_basic_op(NOTIFICATION_OP_DELETE, 1, &priv_id, 1);
+ if (noti_op != NULL) {
+ _notification_changed(NOTI_CHANGED_NOTI, noti_op, 1);
+ free(noti_op);
+ }
+
+ free(caller_pkgname);
+
+ return ret;
+}
+
+EXPORT_API notification_error_e notification_delete(notification_h noti)
+{
+ int ret = 0;
+
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ ret =
+ notification_noti_delete_by_priv_id(noti->caller_pkgname,
+ noti->priv_id);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ return ret;
+ }
+
+ if (noti->flags_for_property
+ & NOTIFICATION_PROP_DISABLE_UPDATE_ON_DELETE) {
+ NOTIFICATION_INFO("Disabled update while delete.");
+ } else {
+ notification_op *noti_op = _notification_make_basic_op(NOTIFICATION_OP_DELETE, 1, &(noti->priv_id), 1);
+ if (noti_op != NULL) {
+ _notification_changed(NOTI_CHANGED_NOTI, noti_op, 1);
+ free(noti_op);
+ }
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_update_progress(notification_h noti,
+ int priv_id,
+ double progress)
+{
+ char *caller_pkgname = NULL;
+ int input_priv_id = 0;
+ double input_progress = 0.0;
+
+ if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ } else {
+ input_priv_id = noti->priv_id;
+ }
+ } else {
+ input_priv_id = priv_id;
+ }
+
+ if (noti == NULL) {
+ caller_pkgname = _notification_get_pkgname_by_pid();
+ } else {
+ caller_pkgname = strdup(noti->caller_pkgname);
+ }
+
+ if (progress < 0.0) {
+ input_progress = 0.0;
+ } else if (progress > 1.0) {
+ input_progress = 1.0;
+ } else {
+ input_progress = progress;
+ }
+
+ notification_ongoing_update_progress(caller_pkgname, input_priv_id,
+ input_progress);
+
+ if (caller_pkgname) {
+ free(caller_pkgname);
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_update_size(notification_h noti,
+ int priv_id,
+ double size)
+{
+ char *caller_pkgname = NULL;
+ int input_priv_id = 0;
+ double input_size = 0.0;
+
+ if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ } else {
+ input_priv_id = noti->priv_id;
+ }
+ } else {
+ input_priv_id = priv_id;
+ }
+
+ if (noti == NULL) {
+ caller_pkgname = _notification_get_pkgname_by_pid();
+ } else {
+ caller_pkgname = strdup(noti->caller_pkgname);
+ }
+
+ if (size < 0.0) {
+ input_size = 0.0;
+ } else {
+ input_size = size;
+ }
+
+ notification_ongoing_update_size(caller_pkgname, input_priv_id,
+ input_size);
+
+ if (caller_pkgname) {
+ free(caller_pkgname);
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_update_content(notification_h noti,
+ int priv_id,
+ const char *content)
+{
+ char *caller_pkgname = NULL;
+ int input_priv_id = 0;
+
+ if (priv_id <= NOTIFICATION_PRIV_ID_NONE) {
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ } else {
+ input_priv_id = noti->priv_id;
+ }
+ } else {
+ input_priv_id = priv_id;
+ }
+
+ if (noti == NULL) {
+ caller_pkgname = _notification_get_pkgname_by_pid();
+ } else {
+ caller_pkgname = strdup(noti->caller_pkgname);
+ }
+
+ notification_ongoing_update_content(caller_pkgname, input_priv_id,
+ content);
+
+ if (caller_pkgname) {
+ free(caller_pkgname);
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+static notification_h _notification_create(notification_type_e type) {
+ notification_h noti = NULL;
+
+ if (type <= NOTIFICATION_TYPE_NONE || type >= NOTIFICATION_TYPE_MAX) {
+ NOTIFICATION_ERR("INVALID TYPE : %d", type);
+ return NULL;
+ }
+
+ noti = (notification_h) malloc(sizeof(struct _notification));
+ if (noti == NULL) {
+ NOTIFICATION_ERR("NO MEMORY : noti == NULL");
+ return NULL;
+ }
+ memset(noti, 0x00, sizeof(struct _notification));
+
+ noti->type = type;
+
+ if (type == NOTIFICATION_TYPE_NOTI)
+ noti->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE;
+ else if (type == NOTIFICATION_TYPE_ONGOING)
+ noti->layout = NOTIFICATION_LY_ONGOING_PROGRESS;
+
+ noti->group_id = NOTIFICATION_GROUP_ID_NONE;
+ noti->internal_group_id = 0;
+ noti->priv_id = NOTIFICATION_PRIV_ID_NONE;
+
+ noti->caller_pkgname = _notification_get_pkgname_by_pid();
+ noti->launch_pkgname = NULL;
+ noti->args = NULL;
+ noti->group_args = NULL;
+
+ noti->b_execute_option = NULL;
+ noti->b_service_responding = NULL;
+ noti->b_service_single_launch = NULL;
+ noti->b_service_multi_launch = NULL;
+
+ noti->sound_type = NOTIFICATION_SOUND_TYPE_NONE;
+ noti->sound_path = NULL;
+
+ noti->vibration_type = NOTIFICATION_VIBRATION_TYPE_NONE;
+ noti->vibration_path = NULL;
+
+ noti->domain = NULL;
+ noti->dir = NULL;
+
+ noti->b_text = NULL;
+ noti->b_key = NULL;
+ noti->b_format_args = NULL;
+ noti->num_format_args = 0;
+
+ noti->b_image_path = NULL;
+
+ noti->time = 0;
+ noti->insert_time = 0;
+
+ noti->flags_for_property = 0;
+ noti->display_applist = NOTIFICATION_DISPLAY_APP_ALL;
+
+ noti->progress_size = 0.0;
+ noti->progress_percentage = 0.0;
+
+ noti->app_icon_path = NULL;
+ noti->app_name = NULL;
+ noti->temp_title = NULL;
+ noti->temp_content = NULL;
+
+ return noti;
+}
+
+EXPORT_API notification_h notification_new(notification_type_e type,
+ int group_id, int priv_id)
+{
+ return _notification_create(type);
+}
+
+EXPORT_API notification_h notification_create(notification_type_e type)
+{
+ return _notification_create(type);
+}
+
+EXPORT_API notification_h notification_load(char *pkgname,
+ int priv_id)
+{
+ int ret = 0;
+ notification_h noti = NULL;
+
+ noti = (notification_h) malloc(sizeof(struct _notification));
+ if (noti == NULL) {
+ NOTIFICATION_ERR("NO MEMORY : noti == NULL");
+ return NULL;
+ }
+ memset(noti, 0x00, sizeof(struct _notification));
+
+ ret = notification_noti_get_by_priv_id(noti, pkgname, priv_id);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ notification_free(noti);
+ return NULL;
+ }
+
+ return noti;
+}
+
+EXPORT_API notification_error_e notification_clone(notification_h noti, notification_h *clone)
+{
+ notification_h new_noti = NULL;
+
+ if (noti == NULL || clone == NULL) {
+ NOTIFICATION_ERR("INVALID PARAMETER.");
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ new_noti = (notification_h) malloc(sizeof(struct _notification));
+ if (new_noti == NULL) {
+ NOTIFICATION_ERR("NO MEMORY : noti == NULL");
+ return NOTIFICATION_ERROR_NO_MEMORY;
+ }
+ memset(new_noti, 0x00, sizeof(struct _notification));
+
+ new_noti->type = noti->type;
+ new_noti->layout = noti->layout;
+
+ new_noti->group_id = noti->group_id;
+ new_noti->internal_group_id = noti->internal_group_id;
+ new_noti->priv_id = noti->priv_id;
+
+ if(noti->caller_pkgname != NULL) {
+ new_noti->caller_pkgname = strdup(noti->caller_pkgname);
+ } else {
+ new_noti->caller_pkgname = _notification_get_pkgname_by_pid();
+ }
+ if(noti->launch_pkgname != NULL) {
+ new_noti->launch_pkgname = strdup(noti->launch_pkgname);
+ } else {
+ new_noti->launch_pkgname = NULL;
+ }
+
+ if(noti->args != NULL) {
+ new_noti->args = bundle_dup(noti->args);
+ } else {
+ new_noti->args = NULL;
+ }
+ if(noti->group_args != NULL) {
+ new_noti->group_args = bundle_dup(noti->group_args);
+ } else {
+ new_noti->group_args = NULL;
+ }
+
+ if(noti->b_execute_option != NULL) {
+ new_noti->b_execute_option = bundle_dup(noti->b_execute_option);
+ } else {
+ new_noti->b_execute_option = NULL;
+ }
+ if(noti->b_service_responding != NULL) {
+ new_noti->b_service_responding = bundle_dup(noti->b_service_responding);
+ } else {
+ new_noti->b_service_responding = NULL;
+ }
+ if(noti->b_service_single_launch != NULL) {
+ new_noti->b_service_single_launch = bundle_dup(noti->b_service_single_launch);
+ } else {
+ new_noti->b_service_single_launch = NULL;
+ }
+ if(noti->b_service_multi_launch != NULL) {
+ new_noti->b_service_multi_launch = bundle_dup(noti->b_service_multi_launch);
+ } else {
+ new_noti->b_service_multi_launch = NULL;
+ }
+
+ new_noti->sound_type = noti->sound_type;
+ if(noti->sound_path != NULL) {
+ new_noti->sound_path = strdup(noti->sound_path);
+ } else {
+ new_noti->sound_path = NULL;
+ }
+ new_noti->vibration_type = noti->vibration_type;
+ if(noti->vibration_path != NULL) {
+ new_noti->vibration_path = strdup(noti->vibration_path);
+ } else {
+ new_noti->vibration_path = NULL;
+ }
+
+ if(noti->domain != NULL) {
+ new_noti->domain = strdup(noti->domain);
+ } else {
+ new_noti->domain = NULL;
+ }
+ if(noti->dir != NULL) {
+ new_noti->dir = strdup(noti->dir);
+ } else {
+ new_noti->dir = NULL;
+ }
+
+ if(noti->b_text != NULL) {
+ new_noti->b_text = bundle_dup(noti->b_text);
+ } else {
+ new_noti->b_text = NULL;
+ }
+ if(noti->b_key != NULL) {
+ new_noti->b_key = bundle_dup(noti->b_key);
+ } else {
+ new_noti->b_key = NULL;
+ }
+ if(noti->b_format_args != NULL) {
+ new_noti->b_format_args = bundle_dup(noti->b_format_args);
+ } else {
+ new_noti->b_format_args = NULL;
+ }
+ new_noti->num_format_args = noti->num_format_args;
+
+ if(noti->b_image_path != NULL) {
+ new_noti->b_image_path = bundle_dup(noti->b_image_path);
+ } else {
+ new_noti->b_image_path = NULL;
+ }
+
+ new_noti->time = noti->time;
+ new_noti->insert_time = noti->insert_time;
+
+ new_noti->flags_for_property = noti->flags_for_property;
+ new_noti->display_applist = noti->display_applist;
+
+ new_noti->progress_size = noti->progress_size;
+ new_noti->progress_percentage = noti->progress_percentage;
+
+ new_noti->app_icon_path = NULL;
+ new_noti->app_name = NULL;
+ new_noti->temp_title = NULL;
+ new_noti->temp_content = NULL;
+
+ *clone = new_noti;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+
+EXPORT_API notification_error_e notification_free(notification_h noti)
+{
+ if (noti == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ if (noti->caller_pkgname) {
+ free(noti->caller_pkgname);
+ }
+ if (noti->launch_pkgname) {
+ free(noti->launch_pkgname);
+ }
+ if (noti->args) {
+ bundle_free(noti->args);
+ }
+ if (noti->group_args) {
+ bundle_free(noti->group_args);
+ }
+
+ if (noti->b_execute_option) {
+ bundle_free(noti->b_execute_option);
+ }
+ if (noti->b_service_responding) {
+ bundle_free(noti->b_service_responding);
+ }
+ if (noti->b_service_single_launch) {
+ bundle_free(noti->b_service_single_launch);
+ }
+ if (noti->b_service_multi_launch) {
+ bundle_free(noti->b_service_multi_launch);
+ }
+
+ if (noti->sound_path) {
+ free(noti->sound_path);
+ }
+ if (noti->vibration_path) {
+ free(noti->vibration_path);
+ }
+
+ if (noti->domain) {
+ free(noti->domain);
+ }
+ if (noti->dir) {
+ free(noti->dir);
+ }
+
+ if (noti->b_text) {
+ bundle_free(noti->b_text);
+ }
+ if (noti->b_key) {
+ bundle_free(noti->b_key);
+ }
+ if (noti->b_format_args) {
+ bundle_free(noti->b_format_args);
+ }
+
+ if (noti->b_image_path) {
+ bundle_free(noti->b_image_path);
+ }
+
+ if (noti->app_icon_path) {
+ free(noti->app_icon_path);
+ }
+ if (noti->app_name) {
+ free(noti->app_name);
+ }
+ if (noti->temp_title) {
+ free(noti->temp_title);
+ }
+ if (noti->temp_content) {
+ free(noti->temp_content);
+ }
+
+ free(noti);
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e
+notification_resister_changed_cb(void (*changed_cb)
+ (void *data, notification_type_e type),
+ void *user_data)
+{
+ notification_cb_list_s *noti_cb_list_new = NULL;
+ notification_cb_list_s *noti_cb_list = NULL;
+
+ if (!g_dbus_handle) {
+ g_dbus_handle = _noti_changed_monitor_init();
+ if (!g_dbus_handle)
+ return NOTIFICATION_ERROR_FROM_DBUS;
+ }
+
+ noti_cb_list_new =
+ (notification_cb_list_s *) malloc(sizeof(notification_cb_list_s));
+
+ noti_cb_list_new->next = NULL;
+ noti_cb_list_new->prev = NULL;
+
+ noti_cb_list_new->cb_type = NOTIFICATION_CB_NORMAL;
+ noti_cb_list_new->changed_cb = changed_cb;
+ noti_cb_list_new->detailed_changed_cb = NULL;
+ noti_cb_list_new->data = user_data;
+
+ if (g_notification_cb_list == NULL) {
+ g_notification_cb_list = noti_cb_list_new;
+ } else {
+ noti_cb_list = g_notification_cb_list;
+
+ while (noti_cb_list->next != NULL) {
+ noti_cb_list = noti_cb_list->next;
+ }
+
+ noti_cb_list->next = noti_cb_list_new;
+ noti_cb_list_new->prev = noti_cb_list;
+ }
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e
+notification_unresister_changed_cb(void (*changed_cb)
+ (void *data, notification_type_e type))
+{
+ notification_cb_list_s *noti_cb_list = NULL;
+ notification_cb_list_s *noti_cb_list_prev = NULL;
+ notification_cb_list_s *noti_cb_list_next = NULL;
+
+ noti_cb_list = g_notification_cb_list;
+
+ if (noti_cb_list == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ while (noti_cb_list->prev != NULL) {
+ noti_cb_list = noti_cb_list->prev;
+ }
+
+ do {
+ if (noti_cb_list->changed_cb == changed_cb) {
+ noti_cb_list_prev = noti_cb_list->prev;
+ noti_cb_list_next = noti_cb_list->next;
+
+ if (noti_cb_list_prev == NULL) {
+ g_notification_cb_list = noti_cb_list_next;
+ } else {
+ noti_cb_list_prev->next = noti_cb_list_next;
+ }
+
+ if (noti_cb_list_next == NULL) {
+ if (noti_cb_list_prev != NULL) {
+ noti_cb_list_prev->next = NULL;
+ }
+ } else {
+ noti_cb_list_next->prev = noti_cb_list_prev;
+ }
+
+ free(noti_cb_list);
+
+ if (g_notification_cb_list == NULL)
+ _noti_chanaged_monitor_fini();
+
+ return NOTIFICATION_ERROR_NONE;
+ }
+ noti_cb_list = noti_cb_list->next;
+ } while (noti_cb_list != NULL);
+
+ return NOTIFICATION_ERROR_INVALID_DATA;
+}
+
+EXPORT_API notification_error_e
+notification_register_detailed_changed_cb(
+ void (*detailed_changed_cb)(void *data, notification_type_e type, notification_op *op_list, int num_op),
+ void *user_data)
+{
+ notification_cb_list_s *noti_cb_list_new = NULL;
+ notification_cb_list_s *noti_cb_list = NULL;
+
+ if (!g_dbus_handle) {
+ g_dbus_handle = _noti_changed_monitor_init();
+ if (!g_dbus_handle)
+ return NOTIFICATION_ERROR_FROM_DBUS;
+ }
+
+ noti_cb_list_new =
+ (notification_cb_list_s *) malloc(sizeof(notification_cb_list_s));
+
+ noti_cb_list_new->next = NULL;
+ noti_cb_list_new->prev = NULL;
+
+ noti_cb_list_new->cb_type = NOTIFICATION_CB_DETAILED;
+ noti_cb_list_new->changed_cb = NULL;
+ noti_cb_list_new->detailed_changed_cb = detailed_changed_cb;
+ noti_cb_list_new->data = user_data;
+
+ if (g_notification_cb_list == NULL) {
+ g_notification_cb_list = noti_cb_list_new;
+ } else {
+ noti_cb_list = g_notification_cb_list;
+
+ while (noti_cb_list->next != NULL) {
+ noti_cb_list = noti_cb_list->next;
+ }
+
+ noti_cb_list->next = noti_cb_list_new;
+ noti_cb_list_new->prev = noti_cb_list;
+ }
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e
+notification_unregister_detailed_changed_cb(
+ void (*detailed_changed_cb)(void *data, notification_type_e type, notification_op_type_e op_type, int *list_priv_id, int num_priv_id),
+ void *user_data)
+{
+ notification_cb_list_s *noti_cb_list = NULL;
+ notification_cb_list_s *noti_cb_list_prev = NULL;
+ notification_cb_list_s *noti_cb_list_next = NULL;
+
+ noti_cb_list = g_notification_cb_list;
+
+ if (noti_cb_list == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ while (noti_cb_list->prev != NULL) {
+ noti_cb_list = noti_cb_list->prev;
+ }
+
+ do {
+ if (noti_cb_list->detailed_changed_cb == detailed_changed_cb) {
+ noti_cb_list_prev = noti_cb_list->prev;
+ noti_cb_list_next = noti_cb_list->next;
+
+ if (noti_cb_list_prev == NULL) {
+ g_notification_cb_list = noti_cb_list_next;
+ } else {
+ noti_cb_list_prev->next = noti_cb_list_next;
+ }
+
+ if (noti_cb_list_next == NULL) {
+ if (noti_cb_list_prev != NULL) {
+ noti_cb_list_prev->next = NULL;
+ }
+ } else {
+ noti_cb_list_next->prev = noti_cb_list_prev;
+ }
+
+ free(noti_cb_list);
+
+ if (g_notification_cb_list == NULL)
+ _noti_chanaged_monitor_fini();
+
+ return NOTIFICATION_ERROR_NONE;
+ }
+ noti_cb_list = noti_cb_list->next;
+ } while (noti_cb_list != NULL);
+
+ return NOTIFICATION_ERROR_INVALID_DATA;
+}
+
+EXPORT_API notification_error_e
+notification_resister_badge_changed_cb(void (*changed_cb)
+ (void *data, const char *pkgname,
+ int group_id), void *user_data)
+{
+ // Add DBus signal handler
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e
+notification_unresister_badge_changed_cb(void (*changed_cb)
+ (void *data, const char *pkgname,
+ int group_id))
+{
+ // Del DBus signal handler
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_count(notification_type_e type,
+ const char *pkgname,
+ int group_id,
+ int priv_id, int *count)
+{
+ int ret = 0;
+ int noti_count = 0;
+
+ ret =
+ notification_noti_get_count(type, pkgname, group_id, priv_id,
+ &noti_count);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ return ret;
+ }
+
+ if (count != NULL) {
+ *count = noti_count;
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_list(notification_type_e type,
+ int count,
+ notification_list_h *list)
+{
+ notification_list_h get_list = NULL;
+ int ret = 0;
+
+ ret = notification_noti_get_grouping_list(type, count, &get_list);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ return ret;
+ }
+
+ *list = get_list;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e
+notification_get_grouping_list(notification_type_e type, int count,
+ notification_list_h * list)
+{
+ notification_list_h get_list = NULL;
+ int ret = 0;
+
+ ret = notification_noti_get_grouping_list(type, count, &get_list);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ return ret;
+ }
+
+ *list = get_list;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_get_detail_list(const char *pkgname,
+ int group_id,
+ int priv_id,
+ int count,
+ notification_list_h *list)
+{
+ notification_list_h get_list = NULL;
+ int ret = 0;
+
+ ret =
+ notification_noti_get_detail_list(pkgname, group_id, priv_id, count,
+ &get_list);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ return ret;
+ }
+
+ *list = get_list;
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_free_list(notification_list_h list)
+{
+ notification_list_h cur_list = NULL;
+ notification_h noti = NULL;
+
+ if (list == NULL) {
+ NOTIFICATION_ERR("INVALID DATA : list == NULL");
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ cur_list = notification_list_get_head(list);
+
+ while (cur_list != NULL) {
+ noti = notification_list_get_data(cur_list);
+ cur_list = notification_list_remove(cur_list, noti);
+
+ notification_free(noti);
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
+
+EXPORT_API notification_error_e notification_op_get_data(notification_op *noti_op, notification_op_data_type_e type,
+ void *data)
+{
+ if (noti_op == NULL) {
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ }
+
+ switch (type) {
+ case NOTIFICATION_OP_DATA_TYPE:
+ *((int*)data) = noti_op->type;
+ break;
+ case NOTIFICATION_OP_DATA_PRIV_ID:
+ *((int*)data) = noti_op->priv_id;
+ break;
+ case NOTIFICATION_OP_DATA_EXTRA_INFO_1:
+ *((int*)data) = noti_op->extra_info_1;
+ break;
+ case NOTIFICATION_OP_DATA_EXTRA_INFO_2:
+ *((int*)data) = noti_op->extra_info_2;
+ break;
+ default:
+ return NOTIFICATION_ERROR_INVALID_DATA;
+ break;
+ }
+
+ return NOTIFICATION_ERROR_NONE;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-30 07:21:01 +0000