apply resource handle list

Change-Id: Ic5a76bb3343f1a83b46c346d38de0f4b1798a97a
Signed-off-by: Minchul Lee <slotus.lee@samsung.com>

diff --git a/common/ic-dbus.c b/common/ic-dbus.c
index 6a89db3..29e33eb 100644 (file)
--- a/common/ic-dbus.c
+++ b/common/ic-dbus.c
@@ -207,12 +207,24 @@ static const _ExtendedGDBusArgInfo _ic_dbus_method_info_register_resource_IN_ARG
   FALSE
 };
 
+static const _ExtendedGDBusArgInfo _ic_dbus_method_info_register_resource_IN_ARG_signal_number =
+{
+  {
+    -1,
+    (gchar *) "signal_number",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
 static const _ExtendedGDBusArgInfo * const _ic_dbus_method_info_register_resource_IN_ARG_pointers[] =
 {
   &_ic_dbus_method_info_register_resource_IN_ARG_uri,
   &_ic_dbus_method_info_register_resource_IN_ARG_resource_types,
   &_ic_dbus_method_info_register_resource_IN_ARG_ifaces,
   &_ic_dbus_method_info_register_resource_IN_ARG_properties,
+  &_ic_dbus_method_info_register_resource_IN_ARG_signal_number,
   NULL
 };
 
@@ -1626,6 +1638,7 @@ ic_dbus_default_init (icDbusIface *iface)
    * @arg_resource_types: Argument passed by remote caller.
    * @arg_ifaces: Argument passed by remote caller.
    * @arg_properties: Argument passed by remote caller.
+   * @arg_signal_number: Argument passed by remote caller.
    *
    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-iotcon-dbus.registerResource">registerResource()</link> D-Bus method.
    *
@@ -1641,8 +1654,8 @@ ic_dbus_default_init (icDbusIface *iface)
     NULL,
     g_cclosure_marshal_generic,
     G_TYPE_BOOLEAN,
-    5,
-    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRV, G_TYPE_INT, G_TYPE_UCHAR);
+    6,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRV, G_TYPE_INT, G_TYPE_UCHAR, G_TYPE_UINT);
 
   /**
    * icDbus::handle-unregister-resource:
@@ -2158,6 +2171,7 @@ ic_dbus_default_init (icDbusIface *iface)
  * @arg_resource_types: Argument to pass with the method invocation.
  * @arg_ifaces: Argument to pass with the method invocation.
  * @arg_properties: Argument to pass with the method invocation.
+ * @arg_signal_number: Argument to pass with the method invocation.
  * @cancellable: (allow-none): A #GCancellable or %NULL.
  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
  * @user_data: User data to pass to @callback.
@@ -2175,17 +2189,19 @@ ic_dbus_call_register_resource (
     const gchar *const *arg_resource_types,
     gint arg_ifaces,
     guchar arg_properties,
+    guint arg_signal_number,
     GCancellable *cancellable,
     GAsyncReadyCallback callback,
     gpointer user_data)
 {
   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
     "registerResource",
-    g_variant_new ("(s^asiy)",
+    g_variant_new ("(s^asiyu)",
                    arg_uri,
                    arg_resource_types,
                    arg_ifaces,
-                   arg_properties),
+                   arg_properties,
+                   arg_signal_number),
     G_DBUS_CALL_FLAGS_NONE,
     -1,
     cancellable,
@@ -2230,6 +2246,7 @@ _out:
  * @arg_resource_types: Argument to pass with the method invocation.
  * @arg_ifaces: Argument to pass with the method invocation.
  * @arg_properties: Argument to pass with the method invocation.
+ * @arg_signal_number: Argument to pass with the method invocation.
  * @out_resource: (out): Return location for return parameter or %NULL to ignore.
  * @cancellable: (allow-none): A #GCancellable or %NULL.
  * @error: Return location for error or %NULL.
@@ -2247,6 +2264,7 @@ ic_dbus_call_register_resource_sync (
     const gchar *const *arg_resource_types,
     gint arg_ifaces,
     guchar arg_properties,
+    guint arg_signal_number,
     gint *out_resource,
     GCancellable *cancellable,
     GError **error)
@@ -2254,11 +2272,12 @@ ic_dbus_call_register_resource_sync (
   GVariant *_ret;
   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
     "registerResource",
-    g_variant_new ("(s^asiy)",
+    g_variant_new ("(s^asiyu)",
                    arg_uri,
                    arg_resource_types,
                    arg_ifaces,
-                   arg_properties),
+                   arg_properties,
+                   arg_signal_number),
     G_DBUS_CALL_FLAGS_NONE,
     -1,
     cancellable,

diff --git a/common/ic-dbus.h b/common/ic-dbus.h
index be8002e..3286945 100644 (file)
--- a/common/ic-dbus.h
+++ b/common/ic-dbus.h
@@ -124,7 +124,8 @@ struct _icDbusIface
     const gchar *arg_uri,
     const gchar *const *arg_resource_types,
     gint arg_ifaces,
-    guchar arg_properties);
+    guchar arg_properties,
+    guint arg_signal_number);
 
   gboolean (*handle_send_response) (
     icDbus *object,
@@ -292,6 +293,7 @@ void ic_dbus_call_register_resource (
     const gchar *const *arg_resource_types,
     gint arg_ifaces,
     guchar arg_properties,
+    guint arg_signal_number,
     GCancellable *cancellable,
     GAsyncReadyCallback callback,
     gpointer user_data);
@@ -308,6 +310,7 @@ gboolean ic_dbus_call_register_resource_sync (
     const gchar *const *arg_resource_types,
     gint arg_ifaces,
     guchar arg_properties,
+    guint arg_signal_number,
     gint *out_resource,
     GCancellable *cancellable,
     GError **error);

diff --git a/common/ic-dbus.xml b/common/ic-dbus.xml
index 47ab87d..f18a0e4 100644 (file)
--- a/common/ic-dbus.xml
+++ b/common/ic-dbus.xml
@@ -5,6 +5,7 @@
                        <arg type="as" name="resource_types" direction="in"/>
                        <arg type="i" name="ifaces" direction="in"/>
                        <arg type="y" name="properties" direction="in"/>
+                       <arg type="u" name="signal_number" direction="in"/>
                        <arg type="i" name="resource" direction="out"/>
                </method>
                <method name="unregisterResource">

diff --git a/daemon/icd-dbus.c b/daemon/icd-dbus.c
index 54feb37..6d20d39 100644 (file)
--- a/daemon/icd-dbus.c
+++ b/daemon/icd-dbus.c
@@ -18,13 +18,94 @@
 
 #include "iotcon.h"
 #include "ic-common.h"
+#include "ic-utils.h"
 #include "ic-dbus.h"
 #include "icd.h"
 #include "icd-ioty.h"
 #include "icd-dbus.h"
 
 static GDBusConnection *icd_dbus_conn;
-static icDbus *icd_dbus_object;
+static GList *icd_bus_list; /* global list to care resource handle for each sender bus */
+
+typedef struct _icd_bus_s {
+       gchar *sender;
+       GList *hdlist;
+} icd_bus_s;
+
+typedef struct _ic_resource_handle {
+       void *handle;
+       unsigned int number;
+} icd_resource_handle_s;
+
+static void _icd_dbus_resource_handle_free(int handle)
+{
+       icd_bus_s *bus;
+       GList *cur_bus, *cur_hd;
+       icd_resource_handle_s *rsrc_handle;
+
+       cur_bus = icd_bus_list;
+       while (cur_bus) {
+               bus = cur_bus->data;
+               if (NULL == bus) {
+                       ERR("bus is NULL");
+                       return;
+               }
+
+               cur_hd = bus->hdlist;
+               while (cur_hd) {
+                       rsrc_handle = cur_hd->data;
+
+                       if (rsrc_handle->handle == GINT_TO_POINTER(handle)) {
+                               DBG("resource handle(%u, %u) removed from handle list", handle, rsrc_handle->number);
+                               bus->hdlist = g_list_delete_link(bus->hdlist, cur_hd);
+                               free(rsrc_handle);
+                               return;
+                       }
+                       cur_hd = cur_hd->next;
+               }
+
+               cur_bus = cur_bus->next;
+       }
+
+       return;
+}
+
+int icd_dbus_bus_list_get_info(int handle, unsigned int *sig_num, const gchar **sender)
+{
+       FN_CALL;
+       icd_bus_s *bus;
+       GList *cur_bus, *cur_hd;
+       icd_resource_handle_s *rsrc_handle;
+
+       RETV_IF(NULL == sig_num, IOTCON_ERROR_INVALID_PARAMETER);
+       RETV_IF(NULL == sender, IOTCON_ERROR_INVALID_PARAMETER);
+
+       cur_bus = icd_bus_list;
+       while (cur_bus) {
+               bus = cur_bus->data;
+               if (NULL == bus) {
+                       ERR("bus is NULL");
+                       return IOTCON_ERROR_NO_DATA;
+               }
+
+               cur_hd = bus->hdlist;
+               while (cur_hd) {
+                       rsrc_handle = cur_hd->data;
+
+                       if (rsrc_handle->handle == GINT_TO_POINTER(handle)) {
+                               DBG("signal_number(%u) for resource handle(%u) found", rsrc_handle->number, handle);
+                               *sig_num = rsrc_handle->number;
+                               *sender = bus->sender;
+                               return IOTCON_ERROR_NONE;
+                       }
+                       cur_hd = cur_hd->next;
+               }
+
+               cur_bus = cur_bus->next;
+       }
+
+       return IOTCON_ERROR_NO_DATA;
+}
 
 int icd_dbus_emit_signal(const char *signal_name, const char *sender, GVariant *value)
 {
@@ -55,19 +136,234 @@ int icd_dbus_emit_signal(const char *signal_name, const char *sender, GVariant *
        return IOTCON_ERROR_NONE;
 }
 
+void _ic_dbus_cleanup_handle(icd_resource_handle_s *rsrc_handle)
+{
+       int ret;
+
+       RET_IF(NULL == rsrc_handle);
+       RET_IF(NULL == rsrc_handle->handle);
+
+       DBG("handle(%u, %u) deregistering", rsrc_handle->handle, rsrc_handle->number);
+
+       ret = icd_ioty_unregister_resource(rsrc_handle->handle);
+       if (IOTCON_ERROR_NONE != ret)
+               ERR("icd_ioty_unregister_resource() Fail(%d)", ret);
+
+       free(rsrc_handle);
+}
+
+static int _icd_dbus_bus_list_cleanup_handle_list(GList *list)
+{
+       icd_bus_s *bus;
+
+       RETV_IF(NULL == list, IOTCON_ERROR_INVALID_PARAMETER);
+
+       bus = list->data;
+       g_list_free_full(bus->hdlist, (GDestroyNotify)_ic_dbus_cleanup_handle);
+       free(bus->sender);
+       bus->sender = NULL;
+       free(bus);
+
+       return IOTCON_ERROR_NONE;
+}
+
+static int _icd_dbus_bus_list_find_sender(const gchar *owner, GList **ret_list)
+{
+       GList *cur;
+       icd_bus_s *bus;
+
+       RETV_IF(NULL == owner, IOTCON_ERROR_INVALID_PARAMETER);
+       RETV_IF(NULL == ret_list, IOTCON_ERROR_INVALID_PARAMETER);
+
+       cur = icd_bus_list;
+       while (cur) {
+               bus = cur->data;
+               if (NULL == bus) {
+                       ERR("bus is NULL");
+                       return IOTCON_ERROR_NO_DATA;
+               }
+
+               if (IC_STR_EQUAL == g_strcmp0(bus->sender, owner)) {
+                       *ret_list = cur;
+                       return IOTCON_ERROR_NONE;
+               }
+
+               cur = cur->next;
+       }
+
+       return IOTCON_ERROR_NONE;
+}
+
+static void _icd_dbus_name_owner_changed_cb(GDBusConnection *connection,
+               const gchar *sender_name,
+               const gchar *object_path,
+               const gchar *interface_name,
+               const gchar *signal_name,
+               GVariant *parameters,
+               gpointer user_data)
+{
+       int ret;
+       GList *sender = NULL;
+       gchar *name, *old_owner, *new_owner;
+
+       g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
+
+       if (0 == strlen(new_owner)) {
+               ret = _icd_dbus_bus_list_find_sender(old_owner, &sender);
+               if (IOTCON_ERROR_NONE != ret) {
+                       ERR("_icd_dbus_bus_list_find_sender() Fail(%d)", ret);
+                       return;
+               }
+
+               if (sender) { /* found bus name in our bus list */
+                       DBG("bus(%s) stopped", old_owner);
+
+                       ret = _icd_dbus_bus_list_cleanup_handle_list(sender);
+                       if (IOTCON_ERROR_NONE != ret) {
+                               ERR("_icd_dbus_bus_list_cleanup_handle_list() Fail(%d)", ret);
+                               return;
+                       }
+                       icd_bus_list = g_list_delete_link(icd_bus_list, sender);
+               }
+       }
+}
+
+static int _icd_dbus_subscribe_name_owner_changed()
+{
+       FN_CALL;
+       unsigned int id;
+
+       id = g_dbus_connection_signal_subscribe(icd_dbus_conn,
+                       "org.freedesktop.DBus", /* bus name */
+                       "org.freedesktop.DBus", /* interface */
+                       "NameOwnerChanged", /* member */
+                       "/org/freedesktop/DBus", /* path */
+                       NULL, /* arg0 */
+                       G_DBUS_SIGNAL_FLAGS_NONE,
+                       _icd_dbus_name_owner_changed_cb,
+                       NULL,
+                       NULL);
+       if (0 == id) {
+               ERR("g_dbus_connection_signal_subscribe() Fail");
+               return IOTCON_ERROR_DBUS;
+       }
+
+       return IOTCON_ERROR_NONE;
+}
+
+static int _icd_dbus_resource_list_append_handle(const gchar *sender, void *handle,
+               unsigned int signal_number)
+{
+       FN_CALL;
+       char *sender_dup;
+       GList *cur_bus, *cur_hd;
+       bool sender_exist = false;
+       icd_resource_handle_s *rsrc_handle;
+       icd_bus_s *new_bus = NULL;
+       icd_bus_s *bus;
+
+       RETV_IF(NULL == sender, IOTCON_ERROR_INVALID_PARAMETER);
+       RETV_IF(NULL == handle, IOTCON_ERROR_INVALID_PARAMETER);
+
+       cur_bus = icd_bus_list;
+
+       while (cur_bus) {
+               bus = cur_bus->data;
+               if (NULL == bus) {
+                       ERR("bus is NULL");
+                       return IOTCON_ERROR_NO_DATA;
+               }
+
+               if (IC_STR_EQUAL == g_strcmp0(bus->sender, sender)) {
+                       DBG("sender(%s) already exist", sender);
+                       sender_exist = true;
+                       break;
+               }
+
+               cur_bus = cur_bus->next;
+       }
+
+       if (false == sender_exist) {
+               DBG("sender(%s) not exist. make new one.", sender);
+
+               new_bus = calloc(1, sizeof(icd_bus_s));
+               if (NULL == new_bus) {
+                       ERR("calloc(bus) Fail(%d)", errno);
+                       return IOTCON_ERROR_OUT_OF_MEMORY;
+               }
+
+               sender_dup = ic_utils_strdup(sender);
+               if (NULL == sender_dup) {
+                       ERR("ic_utils_strdup() Fail");
+                       free(new_bus);
+                       return IOTCON_ERROR_OUT_OF_MEMORY;
+               }
+
+               new_bus->sender = sender_dup;
+               DBG("new bus(%s, %d) added", sender, signal_number);
+               bus = new_bus;
+       }
+
+       cur_hd = bus->hdlist;
+       while (cur_hd) {
+               rsrc_handle = cur_hd->data;
+
+               if (rsrc_handle->handle == GINT_TO_POINTER(handle)) {
+                       ERR("resource handle(%u, %u) already exist", rsrc_handle->handle, rsrc_handle->number);
+                       return IOTCON_ERROR_ALREADY;
+               }
+
+               cur_hd = cur_hd->next;
+       }
+
+       rsrc_handle = calloc(1, sizeof(icd_resource_handle_s));
+       if (NULL == rsrc_handle) {
+               ERR("calloc(handle) Fail(%d)", errno);
+               if (false == sender_exist) {
+                       free(new_bus->sender);
+                       free(new_bus);
+               }
+               return IOTCON_ERROR_OUT_OF_MEMORY;
+       }
+
+       rsrc_handle->handle = handle;
+       rsrc_handle->number = signal_number;
+
+       DBG("handle(%u) added in the bus(%s, %u)", handle, sender, signal_number);
+
+       bus->hdlist = g_list_append(bus->hdlist, rsrc_handle);
+
+       if (false == sender_exist)
+               icd_bus_list = g_list_append(icd_bus_list, bus);
+
+       return IOTCON_ERROR_NONE;
+}
 
 static gboolean _dbus_handle_register_resource(icDbus *object,
                GDBusMethodInvocation *invocation,
                const gchar *uri,
                const gchar* const *resource_types,
                gint ifaces,
-               guchar properties)
+               guchar properties,
+               guint signal_number)
 {
+       FN_CALL;
+       int ret;
+       const gchar *sender;
        void *handle = NULL;
 
        handle = icd_ioty_register_resource(uri, resource_types, ifaces, properties);
-       if (NULL == handle)
-               ERR("icd_ioty_register_resource() Fail");
+       if (handle) {
+               sender = g_dbus_method_invocation_get_sender(invocation);
+               ret = _icd_dbus_resource_list_append_handle(sender, handle, signal_number);
+               if (IOTCON_ERROR_NONE != ret) {
+                       ERR("_icd_dbus_resource_list_append_handle() Fail(%d)", ret);
+
+                       ret = icd_ioty_unregister_resource(handle);
+                       if (IOTCON_ERROR_NONE != ret)
+                               ERR("icd_ioty_unregister_resource(%u) Fail(%d)", handle, ret);
+               }
+       }
 
        ic_dbus_complete_register_resource(object, invocation, GPOINTER_TO_INT(handle));
 
@@ -82,7 +378,11 @@ static gboolean _dbus_handle_unregister_resource(icDbus *object,
 
        ret = icd_ioty_unregister_resource(GINT_TO_POINTER(resource));
        if (IOTCON_ERROR_NONE != ret)
-               ERR("icd_ioty_unregister_resource() Fail(%d)", ret);
+               ERR("icd_ioty_unregister_resource(%u) Fail(%d)", resource, ret);
+       else
+               DBG("handle(%u) deregistered", resource);
+
+       _icd_dbus_resource_handle_free(resource);
 
        ic_dbus_complete_unregister_resource(object, invocation, ret);
 
@@ -440,68 +740,77 @@ static gboolean _dbus_handle_unsubscribe_presence(icDbus *object,
 static void _dbus_on_bus_acquired(GDBusConnection *conn, const gchar *name,
                gpointer user_data)
 {
-       GError *error = NULL;
        gboolean ret;
+       icDbus *dbus_object;
+       GError *error = NULL;
+
 
        icd_dbus_conn = conn;
 
-       icd_dbus_object = ic_dbus_skeleton_new();
-       if (NULL == icd_dbus_object) {
+       dbus_object = ic_dbus_skeleton_new();
+       if (NULL == dbus_object) {
                ERR("ic_iotcon_skeletion_new() Fail");
                return;
        }
 
-       g_signal_connect(icd_dbus_object, "handle-register-resource",
+       g_signal_connect(dbus_object, "handle-register-resource",
                        G_CALLBACK(_dbus_handle_register_resource), NULL);
-       g_signal_connect(icd_dbus_object, "handle-unregister-resource",
+       g_signal_connect(dbus_object, "handle-unregister-resource",
                        G_CALLBACK(_dbus_handle_unregister_resource), NULL);
-       g_signal_connect(icd_dbus_object, "handle-bind-interface",
+       g_signal_connect(dbus_object, "handle-bind-interface",
                        G_CALLBACK(_dbus_handle_bind_interface), NULL);
-       g_signal_connect(icd_dbus_object, "handle-bind-type",
+       g_signal_connect(dbus_object, "handle-bind-type",
                        G_CALLBACK(_dbus_handle_bind_type), NULL);
-       g_signal_connect(icd_dbus_object, "handle-bind-resource",
+       g_signal_connect(dbus_object, "handle-bind-resource",
                        G_CALLBACK(_dbus_handle_bind_resource), NULL);
-       g_signal_connect(icd_dbus_object, "handle-unbind-resource",
+       g_signal_connect(dbus_object, "handle-unbind-resource",
                        G_CALLBACK(_dbus_handle_unbind_resource), NULL);
-       g_signal_connect(icd_dbus_object, "handle-find-resource",
+       g_signal_connect(dbus_object, "handle-find-resource",
                        G_CALLBACK(_dbus_handle_find_resource), NULL);
-       g_signal_connect(icd_dbus_object, "handle-get",
+       g_signal_connect(dbus_object, "handle-get",
                        G_CALLBACK(_dbus_handle_get), NULL);
-       g_signal_connect(icd_dbus_object, "handle-put",
+       g_signal_connect(dbus_object, "handle-put",
                        G_CALLBACK(_dbus_handle_put), NULL);
-       g_signal_connect(icd_dbus_object, "handle-post",
+       g_signal_connect(dbus_object, "handle-post",
                        G_CALLBACK(_dbus_handle_post), NULL);
-       g_signal_connect(icd_dbus_object, "handle-delete",
+       g_signal_connect(dbus_object, "handle-delete",
                        G_CALLBACK(_dbus_handle_delete), NULL);
-       g_signal_connect(icd_dbus_object, "handle-observer-start",
+       g_signal_connect(dbus_object, "handle-observer-start",
                        G_CALLBACK(_dbus_handle_observer_start), NULL);
-       g_signal_connect(icd_dbus_object, "handle-observer-stop",
+       g_signal_connect(dbus_object, "handle-observer-stop",
                        G_CALLBACK(_dbus_handle_observer_stop), NULL);
-       g_signal_connect(icd_dbus_object, "handle-notify-list-of-observers",
+       g_signal_connect(dbus_object, "handle-notify-list-of-observers",
                        G_CALLBACK(_dbus_handle_notify_list_of_observers), NULL);
-       g_signal_connect(icd_dbus_object, "handle-notify-all",
+       g_signal_connect(dbus_object, "handle-notify-all",
                        G_CALLBACK(_dbus_handle_notify_all), NULL);
-       g_signal_connect(icd_dbus_object, "handle-send-response",
+       g_signal_connect(dbus_object, "handle-send-response",
                        G_CALLBACK(_dbus_handle_send_response), NULL);
-       g_signal_connect(icd_dbus_object, "handle-register-device-info",
+       g_signal_connect(dbus_object, "handle-register-device-info",
                        G_CALLBACK(_dbus_handle_register_device_info), NULL);
-       g_signal_connect(icd_dbus_object, "handle-get-device-info",
+       g_signal_connect(dbus_object, "handle-get-device-info",
                        G_CALLBACK(_dbus_handle_get_device_info), NULL);
-       g_signal_connect(icd_dbus_object, "handle-start-presence",
+       g_signal_connect(dbus_object, "handle-start-presence",
                        G_CALLBACK(_dbus_handle_start_presence), NULL);
-       g_signal_connect(icd_dbus_object, "handle-stop-presence",
+       g_signal_connect(dbus_object, "handle-stop-presence",
                        G_CALLBACK(_dbus_handle_stop_presence), NULL);
-       g_signal_connect(icd_dbus_object, "handle-subscribe-presence",
+       g_signal_connect(dbus_object, "handle-subscribe-presence",
                        G_CALLBACK(_dbus_handle_subscribe_presence), NULL);
-       g_signal_connect(icd_dbus_object, "handle-unsubscribe-presence",
+       g_signal_connect(dbus_object, "handle-unsubscribe-presence",
                        G_CALLBACK(_dbus_handle_unsubscribe_presence), NULL);
 
-       ret = g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(icd_dbus_object), conn,
+       ret = g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(dbus_object), conn,
                        IOTCON_DBUS_OBJPATH, &error);
        if (FALSE == ret) {
                ERR("g_dbus_interface_skeleton_export() Fail(%s)", error->message);
                g_error_free(error);
        }
+
+       ret = _icd_dbus_subscribe_name_owner_changed();
+       if (IOTCON_ERROR_NONE != ret) {
+               ERR("_icd_dbus_subscribe_name_owner_changed() Fail(%d)", ret);
+               return;
+       }
+
 }
 
 

diff --git a/daemon/icd-dbus.h b/daemon/icd-dbus.h
index f344bb2..883428d 100644 (file)
--- a/daemon/icd-dbus.h
+++ b/daemon/icd-dbus.h
@@ -16,6 +16,7 @@
 #ifndef __IOT_CONNECTIVITY_MANAGER_DAEMON_DBUS_H__
 #define __IOT_CONNECTIVITY_MANAGER_DAEMON_DBUS_H__
 
+int icd_dbus_bus_list_get_info(int handle, unsigned int *sig_num, const gchar **sender);
 int icd_dbus_emit_signal(const char *sig_name, const char *sender, GVariant *value);
 unsigned int icd_dbus_init();
 void icd_dbus_deinit(unsigned int id);

diff --git a/daemon/icd-ioty.cpp b/daemon/icd-ioty.cpp
index 72f9b1b..64f213b 100644 (file)
--- a/daemon/icd-ioty.cpp
+++ b/daemon/icd-ioty.cpp
@@ -491,19 +491,15 @@ static OCEntityHandlerResult _icd_ioty_request_handler(
                shared_ptr<OCResourceRequest> request)
 {
        FN_CALL;
-       int ret;
        int types = 0;
-       int observer_id;
-       int observe_action;
-       int request_handle;
-       int resource_handle;
+       int ret, observer_id, observe_action, request_handle, resource_handle;
+       unsigned int signal_number;
        char sig_name[100] = {0};
+       const gchar *sender = NULL;
        const char *uri = NULL;
        const char *request_type = NULL;
        GVariant *value;
-       GVariantBuilder *options;
-       GVariantBuilder *query;
-       GVariantBuilder *repr;
+       GVariantBuilder *options, *query, *repr;
        HeaderOptions headerOptions;
        QueryParamsMap queryParams;
        OCRepresentation ocRep;
@@ -585,9 +581,15 @@ static OCEntityHandlerResult _icd_ioty_request_handler(
        g_variant_builder_unref(query);
        g_variant_builder_unref(repr);
 
+       ret = icd_dbus_bus_list_get_info(resource_handle, &signal_number, &sender);
+       if (IOTCON_ERROR_NONE != ret) {
+               ERR("icd_dbus_bus_list_get_info() Fail(%d)", ret);
+               return OC_EH_ERROR;
+       }
+
        snprintf(sig_name, sizeof(sig_name), "%s_%u", IC_DBUS_SIGNAL_REQUEST_HANDLER,
-                       resource_handle);
-       icd_dbus_emit_signal(sig_name, NULL, value);
+                       signal_number);
+       icd_dbus_emit_signal(sig_name, sender, value);
 
        return OC_EH_OK;
 }
@@ -596,7 +598,8 @@ static OCEntityHandlerResult _icd_ioty_request_handler(
 extern "C" OCResourceHandle icd_ioty_register_resource(const char *uri,
                const char* const* res_types, int ifaces, uint8_t properties)
 {
-       OCStackResult ret;
+       FN_CALL;
+       OCStackResult ret = OC_STACK_OK;
        string resUri;
        string resType;
        string resInterface;
@@ -619,10 +622,15 @@ extern "C" OCResourceHandle icd_ioty_register_resource(const char *uri,
                ifaces ^= IOTCON_INTERFACE_GROUP;
        }
 
-       ret = registerResource(handle, resUri, resType, resInterface,
-                       _icd_ioty_request_handler, properties);
-       if (OC_STACK_OK != ret) {
-               ERR("registerResource Fail(%d)", ret);
+       try {
+               ret = registerResource(handle, resUri, resType, resInterface,
+                               _icd_ioty_request_handler, properties);
+               if (OC_STACK_OK != ret) {
+                       ERR("registerResource Fail(%d)", ret);
+                       return NULL;
+               }
+       } catch (OCException& e) {
+               ERR("registerResource Fail(%s)", e.reason().c_str());
                return NULL;
        }
 
@@ -644,12 +652,17 @@ extern "C" OCResourceHandle icd_ioty_register_resource(const char *uri,
        return handle;
 }
 
-
-extern "C" int icd_ioty_unregister_resource(iotcon_resource_h resource_handle)
+extern "C" int icd_ioty_unregister_resource(OCResourceHandle resource_handle)
 {
-       OCResourceHandle resourceHandle = resource_handle;
+       FN_CALL;
+       OCStackResult result;
+       try {
+               result = unregisterResource(resource_handle);
+       } catch (OCException& e) {
+               ERR("unregisterResource Fail(%s)", e.reason().c_str());
+               return IOTCON_ERROR_IOTIVITY;
+       }
 
-       OCStackResult result = unregisterResource(resourceHandle);
        if (OC_STACK_OK != result) {
                ERR("unregisterResource Fail(%d)", result);
                return IOTCON_ERROR_IOTIVITY;

diff --git a/daemon/icd-ioty.h b/daemon/icd-ioty.h
index c5f921e..28b1fd1 100644 (file)
--- a/daemon/icd-ioty.h
+++ b/daemon/icd-ioty.h
@@ -25,7 +25,7 @@ void icd_ioty_config(const char *addr, unsigned short port);
 void* icd_ioty_register_resource(const char *uri, const char* const* res_types,
                int ifaces, uint8_t properties);
 
-int icd_ioty_unregister_resource(iotcon_resource_h resource_handle);
+int icd_ioty_unregister_resource(void *resource_handle);
 
 int icd_ioty_bind_interface(void *resource_handle, iotcon_interface_e iface);
 

diff --git a/lib/icl-dbus.c b/lib/icl-dbus.c
index 2d6f20f..c47b084 100644 (file)
--- a/lib/icl-dbus.c
+++ b/lib/icl-dbus.c
@@ -201,6 +201,7 @@ void* icl_dbus_register_resource(const char *uri, iotcon_resource_types_h types,
                int ifaces, uint8_t properties, iotcon_request_handler_cb cb, void *user_data)
 {
        int ret;
+       int signal_number;
        int resource_handle;
        GError *error = NULL;
        const gchar **res_types;
@@ -208,6 +209,8 @@ void* icl_dbus_register_resource(const char *uri, iotcon_resource_types_h types,
 
        RETV_IF(NULL == icl_dbus_object, NULL);
 
+       signal_number = _icl_dbus_generate_signal_number();
+
        res_types = icl_dbus_resource_types_to_array(types);
        if (NULL == res_types) {
                ERR("icl_dbus_resource_types_to_array() Fail");
@@ -215,7 +218,7 @@ void* icl_dbus_register_resource(const char *uri, iotcon_resource_types_h types,
        }
 
        ic_dbus_call_register_resource_sync(icl_dbus_object, uri, res_types,
-                       ifaces, properties, &resource_handle, NULL, &error);
+                       ifaces, properties, signal_number, &resource_handle, NULL, &error);
        if (error) {
                ERR("ic_dbus_call_register_resource_sync() Fail(%s)", error->message);
                g_error_free(error);
@@ -223,10 +226,9 @@ void* icl_dbus_register_resource(const char *uri, iotcon_resource_types_h types,
                return NULL;
        }
 
-       /* TODO
-        * Change how to determine signal_number of request_handler */
        snprintf(sig_name, sizeof(sig_name), "%s_%u", IC_DBUS_SIGNAL_REQUEST_HANDLER,
-                       resource_handle);
+                       signal_number);
+
        ret = _dbus_subscribe_signal(sig_name, cb, user_data, _icl_dbus_request_handler);
        if (IOTCON_ERROR_NONE != ret) {
                ERR("_dbus_subscribe_signal() Fail");
@@ -241,6 +243,7 @@ void* icl_dbus_register_resource(const char *uri, iotcon_resource_types_h types,
 
 int icl_dbus_unregister_resource(void *resource)
 {
+       FN_CALL;
        int ret;
        GError *error = NULL;