Adds logic for Application detail setting

 - If user set value that 'App badge' option of setting,
   badge is not shawn on the app icon when 'App badge' is off.
   Despite badge is not shown, display value is maintained consistently.
   So, data-provider-master emit fake signal to homescreen.

Signed-off-by: seungha.son <seungha.son@samsung.com>
Change-Id: Id138ddc4de9aeef6d62fd31c032509c738098729

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..48ce50a 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) {
+               __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 2830f7f..04027bb 100755 (executable)
--- a/src/notification_service.c
+++ b/src/notification_service.c
@@ -1837,22 +1837,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;
@@ -1943,10 +1927,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);
+}