Revert "Revert "Adds logic for Application detail setting""

This reverts commit c971e1dfc4edfb5dc5433086db2c50f11a20fe96.
Change-Id: I941c6a6d0d1fbbd66d28457823aa8831c3a66a0d

diff --git a/include/badge_service.h b/include/badge_service.h
index 7c9d0e5..3bbc725 100755 (executable)
--- a/include/badge_service.h
+++ b/include/badge_service.h
@@ -27,9 +27,13 @@ int badge_delete(GVariant *parameters, GVariant **reply_body, uid_t uid);
 int badge_set_badge_count(GVariant *parameters, GVariant **reply_body, uid_t uid);
 int badge_get_badge_count(GVariant *parameters, GVariant **reply_body, uid_t uid);
 int badge_set_display_option(GVariant *parameters, GVariant **reply_body, uid_t uid);
-int badge_get_display_option(GVariant *parameters, GVariant **reply_body, uid_t uid);
+int badge_get_display_option(GVariant *parameters, GVariant **reply_body, const gchar *sender, uid_t uid);
+int badge_update_badge_setting(GVariant *parameters, GVariant **reply_body, uid_t uid);
+int badge_get_setting_by_appid(GVariant *parameters, GVariant **reply_body, uid_t uid);
+int badge_get_setting_array(GVariant *parameters, GVariant **reply_body, uid_t uid);
 int badge_set_setting_property(GVariant *parameters, GVariant **reply_body, uid_t uid);
 int badge_get_setting_property(GVariant *parameters, GVariant **reply_body, uid_t uid);
+int badge_init_display(GVariant *parameters, GVariant **reply_body, uid_t uid);
 int badge_register_dbus_interface();
 
 /* End of a file */

diff --git a/include/service_common.h b/include/service_common.h
index 955a13a..eda0585 100755 (executable)
--- a/include/service_common.h
+++ b/include/service_common.h
@@ -61,5 +61,6 @@ int service_common_register_dbus_interface(char *introspection_xml, GDBusInterfa
 uid_t get_sender_uid(const char *sender_name);
 pid_t get_sender_pid(const char *sender_name);
 void free_monitoring_list(gpointer data);
+void service_common_init(void);
 
 /* End of a file */

diff --git a/src/badge_service.c b/src/badge_service.c
index d667cf3..08e63bc 100755 (executable)
--- a/src/badge_service.c
+++ b/src/badge_service.c
@@ -20,6 +20,9 @@
 #include <badge.h>
 #include <badge_db.h>
 #include <badge_internal.h>
+#include <badge_setting.h>
+#include <badge_setting_service.h>
+#include <badge_ipc.h>
 #include <tzplatform_config.h>
 
 #include "service_common.h"
@@ -79,7 +82,13 @@ static void _badge_dbus_method_call_handler(GDBusConnection *conn,
        else if (g_strcmp0(method_name, "set_disp_option") == 0)
                ret = badge_set_display_option(parameters, &reply_body, uid);
        else if (g_strcmp0(method_name, "get_disp_option") == 0)
-               ret = badge_get_display_option(parameters, &reply_body, uid);
+               ret = badge_get_display_option(parameters, &reply_body, sender, uid);
+       else if (g_strcmp0(method_name, "update_badge_setting") == 0)
+               ret = badge_update_badge_setting(parameters, &reply_body, uid);
+       else if (g_strcmp0(method_name, "get_setting_by_appid") == 0)
+               ret = badge_get_setting_by_appid(parameters, &reply_body, uid);
+       else if (g_strcmp0(method_name, "init_badge") == 0)
+               ret = badge_init_display(parameters, &reply_body, uid);
 
        if (ret == BADGE_ERROR_NONE) {
                DbgPrint("badge service success : %d", ret);
@@ -157,6 +166,23 @@ int badge_register_dbus_interface()
                        "          <arg type='i' name='is_display' direction='out'/>"
                        "        </method>"
 
+                       "        <method name='update_badge_setting'>"
+                       "          <arg type='s' name='pkgname' direction='in'/>"
+                       "          <arg type='s' name='appid' direction='in'/>"
+                       "          <arg type='i' name='allow_to_display' direction='in'/>"
+                       "          <arg type='i' name='uid' direction='in'/>"
+                       "        </method>"
+
+                       "        <method name='get_setting_by_appid'>"
+                       "          <arg type='s' name='appid' direction='in'/>"
+                       "          <arg type='i' name='uid' direction='in'/>"
+                       "          <arg type='v' name='setting' direction='out'/>"
+                       "        </method>"
+
+                       "        <method name='init_badge'>"
+                       "          <arg type='i' name='uid' direction='in'/>"
+                       "        </method>"
+
                        "  </interface>"
                        "  </node>";
 
@@ -278,6 +304,7 @@ int badge_insert(GVariant *parameters, GVariant **reply_body, uid_t uid)
        GVariant *body = NULL;
        GList *monitoring_list = NULL;
        uid_t param_uid;
+       int allow_to_display = 0;
 
        g_variant_get(parameters, "(&s&s&si)", &pkgname, &writable_pkg, &caller, &param_uid);
 
@@ -295,19 +322,27 @@ int badge_insert(GVariant *parameters, GVariant **reply_body, uid_t uid)
                return ret;
        }
 
-       body = g_variant_new("(si)", pkgname, param_uid);
-       if (body == NULL) {
-               ErrPrint("cannot make gvariant to noti");
-               return BADGE_ERROR_OUT_OF_MEMORY;
+       ret = badge_db_get_allow_to_display_by_appid(pkgname, &allow_to_display, param_uid);
+       if (ret != BADGE_ERROR_NONE) {
+               ErrPrint("failed to get allow_to_display by appid : %d\n", ret);
+               return ret;
        }
 
-       monitoring_list = (GList *)g_hash_table_lookup(_monitoring_hash, GUINT_TO_POINTER(param_uid));
-       ret = send_notify(body, "insert_badge_notify", monitoring_list, PROVIDER_BADGE_INTERFACE_NAME);
-       g_variant_unref(body);
+       if (allow_to_display) {
+               body = g_variant_new("(si)", pkgname, param_uid);
+               if (body == NULL) {
+                       ErrPrint("cannot make gvariant to noti");
+                       return BADGE_ERROR_OUT_OF_MEMORY;
+               }
 
-       if (ret != BADGE_ERROR_NONE) {
-               ErrPrint("failed to send notify:%d\n", ret);
-               return ret;
+               monitoring_list = (GList *)g_hash_table_lookup(_monitoring_hash, GUINT_TO_POINTER(param_uid));
+               ret = send_notify(body, "insert_badge_notify", monitoring_list, PROVIDER_BADGE_INTERFACE_NAME);
+               g_variant_unref(body);
+
+               if (ret != BADGE_ERROR_NONE) {
+                       ErrPrint("failed to send notify:%d\n", ret);
+                       return ret;
+               }
        }
 
        *reply_body = g_variant_new("()");
@@ -379,6 +414,7 @@ int badge_set_badge_count(GVariant *parameters, GVariant **reply_body, uid_t uid
        GVariant *body = NULL;
        GList *monitoring_list = NULL;
        uid_t param_uid;
+       int allow_to_display = 0;
 
        g_variant_get(parameters, "(&s&sii)", &pkgname, &caller, &count, &param_uid);
 
@@ -396,21 +432,29 @@ int badge_set_badge_count(GVariant *parameters, GVariant **reply_body, uid_t uid
                return ret;
        }
 
-       body = g_variant_new("(sii)", pkgname, count, param_uid);
-       if (body == NULL) {
-               ErrPrint("cannot make gvariant to noti");
-               return BADGE_ERROR_OUT_OF_MEMORY;
+       ret = badge_db_get_allow_to_display_by_appid(pkgname, &allow_to_display, param_uid);
+       if (ret != BADGE_ERROR_NONE) {
+               ErrPrint("failed to get allow_to_display by appid : %d\n", ret);
+               return ret;
        }
 
-       monitoring_list = (GList *)g_hash_table_lookup(_monitoring_hash, GUINT_TO_POINTER(param_uid));
-       ret = send_notify(body, "set_badge_count_notify", monitoring_list, PROVIDER_BADGE_INTERFACE_NAME);
-       g_variant_unref(body);
+       if (allow_to_display) {
+               body = g_variant_new("(sii)", pkgname, count, param_uid);
+               if (body == NULL) {
+                       ErrPrint("cannot make gvariant to noti");
+                       return BADGE_ERROR_OUT_OF_MEMORY;
+               }
 
-       if (ret != BADGE_ERROR_NONE) {
-               ErrPrint("failed to send notify:%d\n", ret);
-               return ret;
+               monitoring_list = (GList *)g_hash_table_lookup(_monitoring_hash, GUINT_TO_POINTER(param_uid));
+               ret = send_notify(body, "set_badge_count_notify", monitoring_list, PROVIDER_BADGE_INTERFACE_NAME);
+               g_variant_unref(body);
+
+               if (ret != BADGE_ERROR_NONE) {
+                       ErrPrint("failed to send notify:%d\n", ret);
+                       return ret;
+               }
+               DbgPrint("send badge count notify done ret : %d", ret);
        }
-       DbgPrint("send badge count notify done ret : %d", ret);
 
        *reply_body = g_variant_new("()");
        if (*reply_body == NULL) {
@@ -463,6 +507,7 @@ int badge_set_display_option(GVariant *parameters, GVariant **reply_body, uid_t
        GVariant *body = NULL;
        GList *monitoring_list = NULL;
        uid_t param_uid;
+       int allow_to_display = 0;
 
        g_variant_get(parameters, "(&s&sii)", &pkgname, &caller, &is_display, &param_uid);
 
@@ -482,19 +527,27 @@ int badge_set_display_option(GVariant *parameters, GVariant **reply_body, uid_t
                return ret;
        }
 
-       body = g_variant_new("(sii)", pkgname, is_display, param_uid);
-       if (body == NULL) {
-               ErrPrint("cannot make gvariant to noti");
-               return BADGE_ERROR_OUT_OF_MEMORY;
+       ret = badge_db_get_allow_to_display_by_appid(pkgname, &allow_to_display, param_uid);
+       if (ret != BADGE_ERROR_NONE) {
+               ErrPrint("failed to get allow_to_display by appid : %d\n", ret);
+               return ret;
        }
 
-       monitoring_list = (GList *)g_hash_table_lookup(_monitoring_hash, GUINT_TO_POINTER(param_uid));
-       ret = send_notify(body, "set_disp_option_notify", monitoring_list, PROVIDER_BADGE_INTERFACE_NAME);
-       g_variant_unref(body);
+       if (allow_to_display) {
+               body = g_variant_new("(sii)", pkgname, is_display, param_uid);
+               if (body == NULL) {
+                       ErrPrint("cannot make gvariant to noti");
+                       return BADGE_ERROR_OUT_OF_MEMORY;
+               }
 
-       if (ret != BADGE_ERROR_NONE) {
-               ErrPrint("failed to send notify:%d\n", ret);
-               return ret;
+               monitoring_list = (GList *)g_hash_table_lookup(_monitoring_hash, GUINT_TO_POINTER(param_uid));
+               ret = send_notify(body, "set_disp_option_notify", monitoring_list, PROVIDER_BADGE_INTERFACE_NAME);
+               g_variant_unref(body);
+
+               if (ret != BADGE_ERROR_NONE) {
+                       ErrPrint("failed to send notify:%d\n", ret);
+                       return ret;
+               }
        }
 
        *reply_body = g_variant_new("()");
@@ -506,12 +559,23 @@ int badge_set_display_option(GVariant *parameters, GVariant **reply_body, uid_t
        return ret;
 }
 
+static gint __compare_sender(gconstpointer a, gconstpointer b)
+{
+       if (!a)
+               return -1;
+
+       return strcmp(a, b);
+}
+
 /* get_disp_option */
-int badge_get_display_option(GVariant *parameters, GVariant **reply_body, uid_t uid)
+int badge_get_display_option(GVariant *parameters, GVariant **reply_body, const gchar *sender, uid_t uid)
 {
        int ret = BADGE_ERROR_NONE;
        char *pkgname = NULL;
        unsigned int is_display = 0;
+       int allow_to_display;
+       GList *monitoring_list = NULL;
+       GList *find_list = NULL;
        uid_t param_uid;
 
        g_variant_get(parameters, "(&si)", &pkgname, &param_uid);
@@ -532,11 +596,200 @@ int badge_get_display_option(GVariant *parameters, GVariant **reply_body, uid_t
                return ret;
        }
 
+       ret = badge_db_get_allow_to_display_by_appid(pkgname, &allow_to_display, param_uid);
+       if (ret != BADGE_ERROR_NONE) {
+               ErrPrint("failed to get allow_to_display by appid : %d\n", ret);
+               return ret;
+       }
+
+       if (!allow_to_display) {
+               monitoring_list = (GList *)g_hash_table_lookup(_monitoring_hash, GUINT_TO_POINTER(param_uid));
+               monitoring_list = g_list_first(monitoring_list);
+               find_list = g_list_find_custom(monitoring_list, (gconstpointer)sender,
+                                              (GCompareFunc)__compare_sender);
+               if (find_list != NULL)
+                       is_display = 0;
+       }
+
        *reply_body = g_variant_new("(i)", is_display);
        if (*reply_body == NULL) {
                ErrPrint("cannot make gvariant to noti");
                return BADGE_ERROR_OUT_OF_MEMORY;
        }
+
+       return ret;
+}
+
+static int __badge_emit_fake_signal(char *appid, unsigned int disp_option, uid_t uid)
+{
+       int ret;
+       GVariant *fake_body = NULL;
+       GList *monitoring_list = NULL;
+
+       fake_body = g_variant_new("(sii)", appid, disp_option, uid);
+       if (fake_body == NULL) {
+               ErrPrint("cannot make gvariant to noti");
+               return BADGE_ERROR_OUT_OF_MEMORY;
+       }
+
+       monitoring_list = (GList *)g_hash_table_lookup(_monitoring_hash, GUINT_TO_POINTER(uid));
+       ret = send_notify(fake_body, "set_disp_option_notify", monitoring_list, PROVIDER_BADGE_INTERFACE_NAME);
+       g_variant_unref(fake_body);
+       if (ret != BADGE_ERROR_NONE)
+               ErrPrint("failed to send notify:%d\n", ret);
+
+       return ret;
+}
+
+/* update_badge_setting */
+int badge_update_badge_setting(GVariant *parameters, GVariant **reply_body, uid_t uid)
+{
+       int ret = BADGE_ERROR_NONE;
+       uid_t param_uid;
+       unsigned int allow_to_display;
+       unsigned int disp_option = 0;
+       char *pkgname = NULL;
+       char *appid = NULL;
+
+       g_variant_get(parameters, "(&s&sii)", &pkgname, &appid, &allow_to_display, &param_uid);
+
+       ret = _validate_and_set_param_uid_with_uid(uid, &param_uid);
+       if (ret != BADGE_ERROR_NONE)
+               return ret;
+
+       ret = badge_db_update_setting(pkgname, appid, allow_to_display, param_uid);
+       if (ret != BADGE_ERROR_NONE) {
+               ErrPrint("Failed badge setting update");
+               return ret;
+       }
+
+       if (!allow_to_display) {
+               ret = __badge_emit_fake_signal(appid, allow_to_display, param_uid);
+               if (ret != BADGE_ERROR_NONE)
+                       return ret;
+       } else {
+               ret = badge_db_get_display_option(appid, &disp_option, param_uid);
+               if (ret != BADGE_ERROR_NONE) {
+                       ErrPrint("Failed badge_db_get_display_option");
+                       return ret;
+               }
+
+               if (disp_option) {
+                       ret = __badge_emit_fake_signal(appid, disp_option, param_uid);
+                       if (ret != BADGE_ERROR_NONE)
+                               return ret;
+               }
+       }
+
+       *reply_body = g_variant_new("()");
+       if (*reply_body == NULL) {
+               ErrPrint("Cannot make reply_body");
+               ret = BADGE_ERROR_OUT_OF_MEMORY;
+       }
+
+       return ret;
+}
+
+int badge_get_setting_by_appid(GVariant *parameters, GVariant **reply_body, uid_t uid)
+{
+       int ret;
+       char *appid = NULL;
+       GVariant *body;
+       badge_setting_h setting = NULL;
+       uid_t param_uid;
+
+       g_variant_get(parameters, "(&si)", &appid, &param_uid);
+       if (appid == NULL)
+               return BADGE_ERROR_INVALID_PARAMETER;
+
+       ret = _validate_and_set_param_uid_with_uid(uid, &param_uid);
+       if (ret != NOTIFICATION_ERROR_NONE)
+               return ret;
+
+       ret = badge_db_get_setting_by_appid(appid, &setting, param_uid);
+       if (ret == BADGE_ERROR_NONE) {
+               body = badge_ipc_make_gvariant_from_setting(setting);
+               badge_setting_free_setting(setting);
+               if (body == NULL) {
+                       ErrPrint("fail to make gvariant from setting");
+                       return NOTIFICATION_ERROR_OUT_OF_MEMORY;
+               }
+       } else {
+               return ret;
+       }
+
+       *reply_body = g_variant_new("(v)", body);
+       if (*reply_body == NULL) {
+               ErrPrint("cannot make reply_body");
+               return BADGE_ERROR_OUT_OF_MEMORY;
+       }
+
+       return ret;
+}
+
+/* init badge */
+int badge_init_display(GVariant *parameters, GVariant **reply_body, uid_t uid)
+{
+       int ret = BADGE_ERROR_NONE;
+       unsigned int disp_option;
+       int allow_to_display;
+       GList *badge_list = NULL;
+       GList *iter_list  = NULL;
+       GList *monitoring_list = NULL;
+       GVariant *body = NULL;
+       badge_info_s *badge;
+       uid_t param_uid;
+
+       g_variant_get(parameters, "(i)", &param_uid);
+       ret = _validate_and_set_param_uid_with_uid(uid, &param_uid);
+       if (ret != BADGE_ERROR_NONE)
+               return ret;
+
+       ret = badge_db_get_list(&badge_list, param_uid);
+       if (ret != BADGE_ERROR_NONE) {
+               ErrPrint("badge get list fail : %d", ret);
+               return ret;
+       }
+
+       iter_list = g_list_first(badge_list);
+       while (iter_list) {
+               badge = (badge_info_s *)g_list_nth_data(iter_list, 0);
+               iter_list = g_list_next(iter_list);
+
+               ret = badge_db_get_display_option(badge->pkg, &disp_option, param_uid);
+               if (ret != BADGE_ERROR_NONE) {
+                       ErrPrint("failed to get display option");
+                       continue;
+               }
+
+               ret = badge_db_get_allow_to_display_by_appid(badge->pkg, &allow_to_display, param_uid);
+               if (ret != BADGE_ERROR_NONE) {
+                       ErrPrint("failed to get allow_to_display");
+                       continue;
+               }
+
+               if (disp_option && allow_to_display) {
+                       monitoring_list = (GList *)g_hash_table_lookup(_monitoring_hash, GUINT_TO_POINTER(param_uid));
+
+                       body = g_variant_new("(sii)", badge->pkg, disp_option, param_uid);
+                       ret = send_notify(body, "set_disp_option_notify", monitoring_list, PROVIDER_BADGE_INTERFACE_NAME);
+                       if (ret != BADGE_ERROR_NONE) {
+                               ErrPrint("failed to get allow_to_display");
+                               continue;
+                       }
+                       g_variant_unref(body);
+               }
+       }
+
+       if (badge_list)
+               g_list_free_full(badge_list, (GDestroyNotify)_release_badge_info);
+
+       *reply_body = g_variant_new("()");
+       if (*reply_body == NULL) {
+               ErrPrint("cannot make reply_body");
+               return NOTIFICATION_ERROR_OUT_OF_MEMORY;
+       }
+
        return ret;
 }
 
@@ -561,6 +814,8 @@ HAPI int badge_service_init(void)
                return BADGE_ERROR_IO_ERROR;
        }
 
+       badge_setting_refresh_setting_table(tzplatform_getuid(TZ_SYS_DEFAULT_USER));
+
        return BADGE_ERROR_NONE;
 }
 

diff --git a/src/main.c b/src/main.c
index c787d16..4abec56 100755 (executable)
--- a/src/main.c
+++ b/src/main.c
@@ -84,6 +84,8 @@ static inline int app_create(void)
        if (ret < 0)
                DbgPrint("badge: %d\n", ret);
 
+       service_common_init();
+
        return 0;
 }
 

diff --git a/src/notification_service.c b/src/notification_service.c
index 99d1e66..4d4b9ee 100755 (executable)
--- a/src/notification_service.c
+++ b/src/notification_service.c
@@ -1856,22 +1856,6 @@ static void _notification_data_init(void)
                notification_free_list(noti_list_head);
 }
 
-static int _package_install_cb(uid_t uid, const char *pkgname, enum pkgmgr_status status, double value, void *data)
-{
-       if (status == PKGMGR_STATUS_END)
-               notification_setting_insert_package_for_uid(pkgname, uid);
-       return 0;
-}
-
-static int _package_uninstall_cb(uid_t uid, const char *pkgname, enum pkgmgr_status status, double value, void *data)
-{
-       if (status == PKGMGR_STATUS_END) {
-               notification_setting_delete_package_for_uid(pkgname, uid);
-               notification_noti_delete_template(pkgname);
-       }
-       return 0;
-}
-
 static int _check_dnd_schedule(uid_t uid)
 {
        int ret;
@@ -1962,10 +1946,6 @@ HAPI int notification_service_init(void)
        if (uids)
                free(uids);
 
-       pkgmgr_init();
-       pkgmgr_add_event_callback(PKGMGR_EVENT_INSTALL, _package_install_cb, NULL);
-       pkgmgr_add_event_callback(PKGMGR_EVENT_UPDATE, _package_install_cb, NULL);
-       pkgmgr_add_event_callback(PKGMGR_EVENT_UNINSTALL, _package_uninstall_cb, NULL);
        DbgPrint("Successfully initiated\n");
        return NOTIFICATION_ERROR_NONE;
 }

diff --git a/src/service_common.c b/src/service_common.c
index 92014dc..2f2f2f7 100755 (executable)
--- a/src/service_common.c
+++ b/src/service_common.c
@@ -19,10 +19,16 @@
 #include <gio/gio.h>
 #include <dlog.h>
 #include <notification.h>
+#include <notification_setting.h>
+#include <notification_setting_internal.h>
+#include <notification_noti.h>
+#include <badge_setting.h>
+#include <badge_setting_service.h>
 
 #include "service_common.h"
 #include "debug.h"
 
+#include "pkgmgr.h"
 #include "notification_service.h"
 #include "badge_service.h"
 #ifndef WEARABLE
@@ -370,3 +376,31 @@ out:
 
        return result;
 }
+
+static int _package_install_cb(uid_t uid, const char *pkgname, enum pkgmgr_status status, double value, void *data)
+{
+       if (status == PKGMGR_STATUS_END) {
+               notification_setting_insert_package_for_uid(pkgname, uid);
+               badge_setting_insert_package_for_uid(pkgname, uid);
+       }
+
+       return 0;
+}
+
+static int _package_uninstall_cb(uid_t uid, const char *pkgname, enum pkgmgr_status status, double value, void *data)
+{
+       if (status == PKGMGR_STATUS_END) {
+               notification_setting_delete_package_for_uid(pkgname, uid);
+               badge_setting_delete_package_for_uid(pkgname, uid);
+               notification_noti_delete_template(pkgname);
+       }
+       return 0;
+}
+
+void service_common_init(void)
+{
+       pkgmgr_init();
+       pkgmgr_add_event_callback(PKGMGR_EVENT_INSTALL, _package_install_cb, NULL);
+       pkgmgr_add_event_callback(PKGMGR_EVENT_UPDATE, _package_install_cb, NULL);
+       pkgmgr_add_event_callback(PKGMGR_EVENT_UNINSTALL, _package_uninstall_cb, NULL);
+}