fixed dbus subscription: specific sender name to NULL for all clients

Change-Id: I52f948617634c824144723affc86a9dd9c3fb0e1

diff --git a/client/cal_client_reminder.c b/client/cal_client_reminder.c
index ecf4c0d..4f1d515 100644 (file)
--- a/client/cal_client_reminder.c
+++ b/client/cal_client_reminder.c
@@ -48,16 +48,16 @@ API int calendar_reminder_add_cb(calendar_reminder_cb callback, void *user_data)
        /* check duplicate */
        GSList *cursor = __subscribe_list;
        while (cursor) {
-               callback_info_s *ci = (callback_info_s *)cursor->data;
-               if (NULL == ci) {
+               callback_info_s *cb_info = (callback_info_s *)cursor->data;
+               if (NULL == cb_info) {
                        cursor = g_slist_next(cursor);
                        continue;
                }
 
-               if (callback == ci->cb && user_data == ci->user_data) {
-                       DBG("This callback is already appended");
+               if (callback == cb_info->cb && user_data == cb_info->user_data) {
+                       DBG("This callback is already appended(%x)(%x)", callback, user_data);
                        pthread_mutex_unlock(&cal_mutex_reminder);
-                       return CALENDAR_ERROR_INVALID_PARAMETER;
+                       return CALENDAR_ERROR_NONE;
                }
                cursor = g_slist_next(cursor);
        }
@@ -70,7 +70,7 @@ API int calendar_reminder_add_cb(calendar_reminder_cb callback, void *user_data)
                return CALENDAR_ERROR_IPC;
        }
 
-       DBG("add reminer");
+       DBG("add reminer(0x%x)", callback);
        ci->id = cal_dbus_subscribe_signal(CAL_NOTI_REMINDER_CAHNGED,
                        cal_dbus_call_reminder_cb, user_data, NULL);
        ci->cb = callback;
@@ -91,13 +91,13 @@ API int calendar_reminder_remove_cb(calendar_reminder_cb callback, void *user_da
        int is_matched = 0;
        GSList *cursor = __subscribe_list;
        while (cursor) {
-               callback_info_s *ci = (callback_info_s *)cursor->data;
-               if (NULL == ci) {
+               callback_info_s *cb_info = (callback_info_s *)cursor->data;
+               if (NULL == cb_info) {
                        cursor = g_slist_next(cursor);
                        continue;
                }
 
-               if (callback == ci->cb && user_data == ci->user_data) {
+               if (callback == cb_info->cb && user_data == cb_info->user_data) {
                        is_matched = 1;
                        break;
                }
@@ -105,16 +105,15 @@ API int calendar_reminder_remove_cb(calendar_reminder_cb callback, void *user_da
        }
 
        if (0 == is_matched) {
-               ERR("Not matched callback");
+               ERR("Not matched callback(0x%x)", callback);
                pthread_mutex_unlock(&cal_mutex_reminder);
                return CALENDAR_ERROR_INVALID_PARAMETER;
        }
 
-       DBG("remove reminder");
+       DBG("remove reminder(0x%x)", callback);
        callback_info_s *ci = (callback_info_s *)cursor->data;
        cal_dbus_unsubscribe_signal(ci->id);
-       __subscribe_list = g_slist_remove(__subscribe_list, ci);
-       free(ci);
+       __subscribe_list = g_slist_delete_link(__subscribe_list, cursor);
 
        if (0 == g_slist_length(__subscribe_list)) {
                g_slist_free(__subscribe_list);
@@ -142,7 +141,7 @@ int cal_client_reminder_call_subscribe(const char *stream)
                        cursor = g_slist_next(cursor);
                        continue;
                }
-               DBG("-----------------------------------------------------called");
+               DBG("called reminder(0x%x)", ci->cb);
                ci->cb(stream, ci->user_data);
                cursor = g_slist_next(cursor);
        }

diff --git a/server/cal_server_alarm.c b/server/cal_server_alarm.c
index d63fcea..4bc8fd3 100644 (file)
--- a/server/cal_server_alarm.c
+++ b/server/cal_server_alarm.c
@@ -800,13 +800,13 @@ static bool __app_matched_cb(app_control_h app_control, const char *package, voi
                DBG("pkg[%s] time[%lld] tick[%d] unit[%d] record_type[%d]",
                                package, ad->time, ad->tick, ad->unit, ad->record);
 
-               int len = 0;
+               int slen = 0;
                char extra[CAL_STR_MIDDLE_LEN] = {0};
-               len = snprintf(extra, sizeof(extra), "%s=%d", "id", ad->event_id);
-               len += snprintf(extra+len, sizeof(extra)-len, "&%s=%lld", "time", ad->time);
-               len += snprintf(extra+len, sizeof(extra)-len, "&%s=%d", "tick", ad->tick);
-               len += snprintf(extra+len, sizeof(extra)-len, "&%s=%d", "unit", ad->unit);
-               len += snprintf(extra+len, sizeof(extra)-len, "&%s=%d", "type", ad->record);
+               slen = snprintf(extra, sizeof(extra), "%s=%d", "id", ad->event_id);
+               slen += snprintf(extra+slen, sizeof(extra)-slen, "&%s=%lld", "time", ad->time);
+               slen += snprintf(extra+slen, sizeof(extra)-slen, "&%s=%d", "tick", ad->tick);
+               slen += snprintf(extra+slen, sizeof(extra)-slen, "&%s=%d", "unit", ad->unit);
+               slen += snprintf(extra+slen, sizeof(extra)-slen, "&%s=%d", "type", ad->record);
 
                /*
                 * key: id, value: id=4&time=123123&..
@@ -814,7 +814,7 @@ static bool __app_matched_cb(app_control_h app_control, const char *package, voi
                char buf_id[CAL_STR_MIDDLE_LEN] = {0};
                snprintf(buf_id, sizeof(buf_id), "%d", ad->event_id);
                app_control_add_extra_data(ac, buf_id, extra);
-               DBG("value[%s]", extra);
+               DBG("value[%s] id[%s]", extra, buf_id);
 
                /* append ids */
                ids[i] = strdup(buf_id);

diff --git a/server/cal_server_dbus.c b/server/cal_server_dbus.c
index da6c021..727fc7d 100644 (file)
--- a/server/cal_server_dbus.c
+++ b/server/cal_server_dbus.c
@@ -59,7 +59,7 @@ static bool _has_sender(const char *name, GList **out_cursor)
                        continue;
                }
                if (CAL_STRING_EQUAL == g_strcmp0(sender->name, name)) {
-                       DBG("sender[%s] is already existed", name);
+                       DBG("found sender[%s]", name);
                        has_sender = true;
                        if (out_cursor)
                                *out_cursor = cursor;
@@ -72,6 +72,8 @@ static bool _has_sender(const char *name, GList **out_cursor)
 
 static int _append_sender(const char *name)
 {
+       RETV_IF(NULL == name, CALENDAR_ERROR_INVALID_PARAMETER);
+
        cal_sender_s *sender = NULL;
        sender = calloc(1, sizeof(cal_sender_s));
        if (NULL == sender) {
@@ -79,17 +81,11 @@ static int _append_sender(const char *name)
                return CALENDAR_ERROR_OUT_OF_MEMORY;
        }
        sender->name = cal_strdup(name);
-       DBG("sender name[%s]", sender->name);
+       DBG("[SENDER] Append sender[%s]", sender->name);
        cal_sender_list = g_list_append(cal_sender_list, sender);
        return CALENDAR_ERROR_NONE;
 }
 
-static void _free_sender(void)
-{
-       g_list_free_full(cal_sender_list, free);
-       cal_sender_list = NULL;
-}
-
 static gboolean _handle_register_resource(calDbus *object,
                GDBusMethodInvocation *invocation)
 {
@@ -131,13 +127,17 @@ static gboolean _handle_unregister_resource(calDbus *object,
        GList *cursor = NULL;
        g_mutex_lock(&cal_server_dbus_sender);
        if (true == _has_sender(sender_name, &cursor)) {
-               DBG("found sender[%s]", sender_name);
+               DBG("[SENDER] delete sender[%s]", sender_name);
+               cal_sender_s *sender = (cal_sender_s *)cursor->data;
+               free(sender->name);
+               sender->name = NULL;
                cal_sender_list = g_list_delete_link(cal_sender_list, cursor);
        }
 
        if (0 == g_list_length(cal_sender_list)) {
                DBG("sender list is 0");
-               _free_sender();
+               g_list_free_full(cal_sender_list, free);
+               cal_sender_list = NULL;
        }
        g_mutex_unlock(&cal_server_dbus_sender);
 
@@ -520,33 +520,25 @@ static int _cal_server_dbus_find_sender(const char *owner_name, cal_sender_s **o
                }
                cursor = g_list_next(cursor);
        }
-       return CALENDAR_ERROR_NONE;
-}
-
-static int _cal_server_dbus_cleanup_sender(cal_sender_s *sender) /* cleanup_handle_list */
-{
-       CAL_FN_CALL();
-       RETV_IF(NULL == sender, CALENDAR_ERROR_INVALID_PARAMETER);
 
        return CALENDAR_ERROR_NONE;
 }
 
-static void _cal_server_dbus_delete_link(cal_sender_s *sender)
+static void _delete_sender(cal_sender_s *sender)
 {
-       GList *cursor = NULL;
-
        RET_IF(NULL == sender);
 
-       g_mutex_lock(&cal_server_dbus_sender);
-       cursor = cal_sender_list;
+       GList *cursor = cal_sender_list;
        while (cursor) {
                if (cursor->data == sender) {
+                       DBG("[SENDER] Delete sender[%s]", sender->name);
+                       free(sender->name);
+                       sender->name = NULL;
                        cal_sender_list = g_list_delete_link(cal_sender_list, cursor);
                        break;
                }
                cursor = g_list_next(cursor);
        }
-       g_mutex_unlock(&cal_server_dbus_sender);
 }
 
 static void _cal_server_dbus_name_owner_changed_cb(GDBusConnection *connection,
@@ -565,31 +557,27 @@ static void _cal_server_dbus_name_owner_changed_cb(GDBusConnection *connection,
        gchar *new_owner = NULL;
 
        g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
-       if (new_owner) {
-               DBG("new_owner is NULL");
-               return;
-       }
-
        DBG("name[%s] old_owner[%s] new_owner[%s]", name, old_owner, new_owner);
 
+       if (0 != strlen(new_owner)) {
+               DBG("new_owner[%s]", new_owner);
+               return;
+       }
+       g_mutex_lock(&cal_server_dbus_sender);
        /* empty new_owner means server-kill */
        cal_sender_s *sender = NULL;
        ret = _cal_server_dbus_find_sender(old_owner, &sender);
        if (CALENDAR_ERROR_NONE != ret) {
                ERR("_cal_server_dbus_find_sender() Fail(%d)", ret);
+               g_mutex_unlock(&cal_server_dbus_sender);
                return;
        }
 
        if (sender) { /* found bus name in our bus list */
                DBG("owner[%s] stopped", old_owner);
-
-               ret = _cal_server_dbus_cleanup_sender(sender);
-               if (CALENDAR_ERROR_NONE != ret) {
-                       ERR("_cal_server_dbus_cleanup_sender() Fail(%d)", ret);
-                       return;
-               }
-               _cal_server_dbus_delete_link(sender);
+               _delete_sender(sender);
        }
+       g_mutex_unlock(&cal_server_dbus_sender);
 }
 
 static int _cal_server_dbus_subscribe_name_owner_changed(GDBusConnection *conn)
@@ -728,6 +716,8 @@ void cal_server_dbus_deinit(unsigned int id)
 
 int cal_dbus_emit_signal(const char *dest, const char *signal_name, GVariant *value)
 {
+       CAL_FN_CALL();
+
        gboolean ret;
        GError *error = NULL;
 
@@ -766,22 +756,7 @@ int cal_dbus_publish_reminder(int stream_size, char *stream)
 
        GVariant *value = NULL;
        value = cal_dbus_utils_stream_to_gvariant(stream_size, stream);
-
-       g_mutex_lock(&cal_server_dbus_sender);
-       GList *cursor = cal_sender_list;
-       while (cursor) {
-               cal_sender_s *sender = (cal_sender_s *)cursor->data;
-               if (NULL == sender) {
-                       ERR("sender is NULL");
-                       cursor = g_list_next(cursor);
-                       continue;
-               }
-
-               DBG("------------------[%s]", sender->name);
-               cal_dbus_emit_signal(sender->name, CAL_NOTI_REMINDER_CAHNGED, value);
-               cursor = g_list_next(cursor);
-       }
-       g_mutex_unlock(&cal_server_dbus_sender);
+       cal_dbus_emit_signal(NULL, CAL_NOTI_REMINDER_CAHNGED, value);
 
        return CALENDAR_ERROR_NONE;
 }

diff --git a/server/cal_server_ondemand.c b/server/cal_server_ondemand.c
index 79750e3..3245622 100644 (file)
--- a/server/cal_server_ondemand.c
+++ b/server/cal_server_ondemand.c
@@ -31,8 +31,6 @@ static gboolean cal_holding = FALSE;
 
 void cal_server_ondemand_stop(void)
 {
-       CAL_FN_CALL();
-
        int timeout = cal_server_get_timeout();
        if (timeout < 1)
                return;
@@ -45,8 +43,6 @@ void cal_server_ondemand_stop(void)
 
 static gboolean _timeout_cb(gpointer user_data)
 {
-       CAL_FN_CALL();
-
        pthread_mutex_lock(&cal_mutex_holding);
        if (FALSE == cal_holding) {
                DBG("exit");
@@ -58,8 +54,6 @@ static gboolean _timeout_cb(gpointer user_data)
 
 void cal_server_ondemand_start(void)
 {
-       CAL_FN_CALL();
-
        int timeout = cal_server_get_timeout();
        if (timeout < 1)
                return;