From 882279d5f4b2b2450e355092413873d78ef94a47 Mon Sep 17 00:00:00 2001 From: Minchul Lee Date: Mon, 22 Jun 2015 11:29:51 +0900 Subject: [PATCH] apply resource handle list Change-Id: Ic5a76bb3343f1a83b46c346d38de0f4b1798a97a Signed-off-by: Minchul Lee --- common/ic-dbus.c | 31 ++++- common/ic-dbus.h | 5 +- common/ic-dbus.xml | 1 + daemon/icd-dbus.c | 371 +++++++++++++++++++++++++++++++++++++++++++++++----- daemon/icd-dbus.h | 1 + daemon/icd-ioty.cpp | 51 +++++--- daemon/icd-ioty.h | 2 +- lib/icl-dbus.c | 11 +- 8 files changed, 411 insertions(+), 62 deletions(-) diff --git a/common/ic-dbus.c b/common/ic-dbus.c index 6a89db3..29e33eb 100644 --- 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 registerResource() 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 --- 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 --- a/common/ic-dbus.xml +++ b/common/ic-dbus.xml @@ -5,6 +5,7 @@ + diff --git a/daemon/icd-dbus.c b/daemon/icd-dbus.c index 54feb37..6d20d39 100644 --- 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 --- 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 --- a/daemon/icd-ioty.cpp +++ b/daemon/icd-ioty.cpp @@ -491,19 +491,15 @@ static OCEntityHandlerResult _icd_ioty_request_handler( shared_ptr 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 --- 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 --- 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; -- 2.7.4