comp-manager: remove red-color log even they are not regarded as errors

mot-agent: make user-defined timeout value be applied during discovery

Signed-off-by: saerome.kim <saerome.kim@samsung.com>

diff --git a/capi/demo/comp-manager.c b/capi/demo/comp-manager.c
index 98874f9bdd8cf8f42657f85e56b7b84c676cf40f..f12abff643c3e86ac45eb17a22de8d3769cc0d5e 100644 (file)
--- a/capi/demo/comp-manager.c
+++ b/capi/demo/comp-manager.c
@@ -257,6 +257,7 @@ static int run_devices_show(MManager *mm, struct menu_data *menu)
        return RET_SUCCESS;
 }
 
+#if 0
 static int run_group_get_members(MManager *mm, struct menu_data *menu)
 {
        int ret;
@@ -312,6 +313,7 @@ static int run_group_get_members(MManager *mm, struct menu_data *menu)
 
        return RET_SUCCESS;
 }
+#endif
 
 static int run_group_merge(MManager *mm, struct menu_data *menu)
 {
@@ -861,9 +863,9 @@ static int run_send_data_all(MManager *mm, struct menu_data *menu)
        return RET_SUCCESS;
 }
 
-void _mowned_device_finish_cb(int num_of_devs, void *user_data)
+void _mowned_device_finish_cb(int result, void *user_data)
 {
-       msgp("%d Device(s) Found", num_of_devs);
+       msgb("Find My Owned Devices Finished ret: [0x%X] [%s]", result, comp_error_to_string(result));
 }
 
 bool _mowned_device_found_cb(companion_device_h device, void *user_data)
@@ -894,10 +896,13 @@ bool _mowned_device_found_cb(companion_device_h device, void *user_data)
 static int run_devices_find_mowned_device(MManager *mm, struct menu_data *menu)
 {
        int ret;
-
+       int duration;
        msg("Find My Owned Devices");
 
-       ret = companion_device_find_mowned_device(_mowned_device_found_cb, _mowned_device_finish_cb, NULL);
+       if (strlen(timeout))
+               duration = (unsigned short)strtol(timeout, NULL, 10);
+
+       ret = companion_device_find_mowned_device(duration, _mowned_device_found_cb, _mowned_device_finish_cb, NULL);
        if (COMP_ERROR_NONE != ret) {
                msgr("Failed to Find My Owned Devices: [%s(0x%X)]", comp_error_to_string(ret), ret);
                return RET_FAILURE;

diff --git a/capi/include/companion.h b/capi/include/companion.h
index 33e605598baf0b8b3f7fc9ec86dada16cedc9038..0abcc119009681514b6d108ea023ea959f6970d4 100755 (executable)
--- a/capi/include/companion.h
+++ b/capi/include/companion.h
@@ -72,7 +72,7 @@ int companion_group_get_member_devices(companion_group_h group, companion_device
 int companion_device_find(int timeout, companion_device_found_cb found_cb,
        companion_device_find_finish_cb finish_cb, void *user_data);
 int companion_device_get_found_devices(companion_device_h **devices, int *count);
-int companion_device_find_mowned_device(
+int companion_device_find_mowned_device(int timeout,
        companion_device_found_cb found_cb,  companion_device_find_finish_cb finish_cb, void *user_data);
 int companion_device_get_found_mowned_devices(
        companion_device_h **devices, int *count);

diff --git a/capi/src/companion.c b/capi/src/companion.c
index a72156e23fe990d6a5366845c335418375bf81e6..f1d5a3ca1bd7cbbcc1d885d573c31898f2100452 100644 (file)
--- a/capi/src/companion.c
+++ b/capi/src/companion.c
@@ -73,6 +73,18 @@ typedef struct _device_find_finish_cb_t {
 } device_find_finish_cb_t;
 device_find_finish_cb_t device_find_finish_cb;
 
+typedef struct _mowned_device_found_cb_t {
+        companion_device_found_cb found_cb;
+        void *user_data;
+} mowned_device_found_cb_t;
+mowned_device_found_cb_t mowned_device_found_cb;
+
+typedef struct _mowned_device_find_finish_cb_t {
+        companion_device_find_finish_cb finish_cb;
+        void *user_data;
+} mowned_device_find_finish_cb_t;
+mowned_device_find_finish_cb_t mowned_device_find_finish_cb;
+
 typedef struct _device_invite_result_cb_t {
         companion_device_invite_result_cb result_cb;
         void *user_data;
@@ -213,6 +225,50 @@ static void _device_find_finish_cb(Group *object,
                device_find_finish_cb.finish_cb(ret, device_find_finish_cb.user_data);
 }
 
+static void __mowned_device_found_cb(Group *object,
+        gint count, GVariant *va, gpointer user_data)
+{
+       GVariantIter *iter = NULL;
+       GVariantIter *iter_row = NULL;
+       const gchar *key;
+       GVariant *key_value;
+       companion_device_t *device = NULL;
+
+       g_variant_get(va, "aa{sv}", &iter);
+       while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
+               char *device_id;
+               char *ip;
+               char *device_type;
+               int port;
+
+               while (g_variant_iter_loop(iter_row, "{sv}", &key, &key_value)) {
+                       if (g_strcmp0(key, "DeviceID") == 0) {
+                               device_id = (char *)g_variant_get_string(key_value, NULL);
+                       } else if (g_strcmp0(key, "Address") == 0) {
+                               ip = (char *)g_variant_get_string(key_value, NULL);
+                       } else if (g_strcmp0(key, "SecVer") == 0) {
+                               device_type = (char *)g_variant_get_string(key_value, NULL);
+                       } else if (g_strcmp0(key, "Port") == 0) {
+                               port = g_variant_get_uint16(key_value);
+                       }
+
+               }
+               g_variant_iter_free(iter_row);
+
+               device = _create_device_handle(device_id, ip, device_type, port);
+               if (mowned_device_found_cb.found_cb)
+                       mowned_device_found_cb.found_cb(device, mowned_device_found_cb.user_data);
+       }
+       g_variant_iter_free(iter);
+}
+
+static void _mowned_device_find_finish_cb(Group *object,
+        gint ret, gpointer user_data)
+{
+       if (mowned_device_find_finish_cb.finish_cb)
+               mowned_device_find_finish_cb.finish_cb(ret, mowned_device_find_finish_cb.user_data);
+}
+
 static void __device_invite_result_cb(Group *object,
         gint ret, gpointer user_data)
 {
@@ -257,7 +313,8 @@ static void _group_proxy_init(void)
        g_signal_connect(group_proxy, "group-find-finish", G_CALLBACK(_group_find_finish_cb), NULL);
        g_signal_connect(group_proxy, "device-found", G_CALLBACK(__device_found_cb), NULL);
        g_signal_connect(group_proxy, "device-find-finish", G_CALLBACK(_device_find_finish_cb), NULL);
-       g_signal_connect(group_proxy, "mowned-device-found", G_CALLBACK(__device_found_cb), NULL);
+       g_signal_connect(group_proxy, "mowned-device-found", G_CALLBACK(__mowned_device_found_cb), NULL);
+       g_signal_connect(group_proxy, "mowned-device-find-finish", G_CALLBACK(_mowned_device_find_finish_cb), NULL);
        g_signal_connect(group_proxy, "device-invite-result", G_CALLBACK(__device_invite_result_cb), NULL);
        g_signal_connect(group_proxy, "device-eject-result", G_CALLBACK(__device_eject_result_cb), NULL);
        g_signal_connect(group_proxy, "send-data-finish", G_CALLBACK(__send_data_finish_cb), NULL);
@@ -394,7 +451,7 @@ int companion_group_get_found_groups(companion_group_h **groups, int *count)
        group_call_get_found_groups_sync(group_proxy, &ret, &va, NULL, &error);
        *count = g_variant_n_children(va);
 
-       _ERR("get found groups : %d", *count);
+       _DBG("get found groups : %d", *count);
 
        if (*count > 0) {
                GVariantIter *iter = NULL, *iter_row = NULL;
@@ -481,19 +538,19 @@ int companion_device_find(int timeout, companion_device_found_cb found_cb,
        return ret;
 }
 
-int companion_device_find_mowned_device(
+int companion_device_find_mowned_device(int timeout,
        companion_device_found_cb found_cb,  companion_device_find_finish_cb finish_cb, void *user_data)
 {
        int ret = 0;
        GError *error = NULL;
 
-       device_found_cb.found_cb = found_cb;
-       device_found_cb.user_data = user_data;
-       device_find_finish_cb.finish_cb= finish_cb;
-       device_find_finish_cb.user_data = user_data;
+       mowned_device_found_cb.found_cb = found_cb;
+       mowned_device_found_cb.user_data = user_data;
+       mowned_device_find_finish_cb.finish_cb= finish_cb;
+       mowned_device_find_finish_cb.user_data = user_data;
 
        /* get groups from daemon using gdbus */
-       group_call_find_mowned_devices_sync(group_proxy, &ret, NULL, &error);
+       group_call_find_mowned_devices_sync(group_proxy, timeout, &ret, NULL, &error);
 
        return ret;
 }
@@ -539,7 +596,7 @@ int companion_device_get_found_devices(companion_device_h **devices, int *count)
        /* *count = g_variant_n_children(va); */
        *count = num;
 
-       _ERR("get found devices : %d", *count);
+       _DBG("get found devices : %d", *count);
 
        if (*count > 0) {
                GVariantIter *iter = NULL, *iter_row = NULL;
@@ -594,7 +651,7 @@ int companion_device_get_found_mowned_devices(
        /* *count = g_variant_n_children(va); */
        *count = num;
 
-       _ERR("get found mowned devices : %d", *count);
+       _INFO("get found mowned devices : %d", *count);
 
        if (*count > 0) {
                GVariantIter *iter = NULL, *iter_row = NULL;
@@ -936,7 +993,7 @@ int companion_request_create_group(companion_device_h device, char *group_name)
        GError *error = NULL;
        companion_device_t *dev = (companion_device_t *)device;
 
-       _ERR("Device id : %s", dev->device_id);
+       _DBG("Device id : %s", dev->device_id);
 
        group_call_request_create_group_sync(group_proxy, dev->device_id, group_name, &ret, NULL, &error);
 
@@ -950,9 +1007,9 @@ int companion_request_invite(companion_group_h group, companion_device_h device,
        companion_group_t *grp = (companion_group_t *)group;
        companion_device_t *dev = (companion_device_t *)device;
 
-       _ERR("%s", grp->device_id);
-       _ERR("%s", grp->group_name);
-       _ERR("%s", dev->device_id);
+       _DBG("%s", grp->device_id);
+       _DBG("%s", grp->group_name);
+       _DBG("%s", dev->device_id);
 
        group_call_request_invite(group_proxy, grp->device_id, grp->group_name, dev->device_id, PIN,
                NULL, NULL, NULL);
@@ -967,9 +1024,9 @@ int companion_request_eject(companion_group_h group, companion_device_h device)
        companion_group_t *grp = (companion_group_t *)group;
        companion_device_t *dev = (companion_device_t *)device;
 
-       _ERR("%s", grp->device_id);
-       _ERR("%s", grp->group_name);
-       _ERR("%s", dev->device_id);
+       _DBG("%s", grp->device_id);
+       _DBG("%s", grp->group_name);
+       _DBG("%s", dev->device_id);
 
        group_call_request_eject(group_proxy, grp->device_id, grp->group_name, dev->device_id,
                NULL, NULL, NULL);

diff --git a/capi/src/companion_gdbus.xml b/capi/src/companion_gdbus.xml
index b895ecba6a01a94f00f0e42e4647b029515a7e7e..d72ef50e79a8fc5e449d4e6edc3c0befe13e1a24 100755 (executable)
--- a/capi/src/companion_gdbus.xml
+++ b/capi/src/companion_gdbus.xml
@@ -101,6 +101,7 @@
                        <arg type="i" name="result" direction="out" />
                </method>
                <method name="FindMownedDevices">
+                       <arg type="i" name="timeout" direction="in" />
                        <arg type="i" name="result" direction="out" />
                </method>
                <method name="GetMownedDevice">
@@ -160,6 +161,9 @@
                        <arg type="i" name="device_count" direction="out" />
                        <arg type="aa{sv}" name="device_info" direction="out" />
                </signal>
+               <signal name="MownedDeviceFindFinish">
+                       <arg type="i" name="result" direction="out" />
+               </signal>
                <signal name="JoinResult">
                        <arg type="i" name="result" direction="out" />
                </signal>

diff --git a/src/companion-manager/include/comp_gdbus_group.h b/src/companion-manager/include/comp_gdbus_group.h
index 4e9538b4ecfed9c6e72990002cfbd513d7aafd9a..b7e7946fa55eaf791633110c39b2345aa52c158b 100755 (executable)
--- a/src/companion-manager/include/comp_gdbus_group.h
+++ b/src/companion-manager/include/comp_gdbus_group.h
@@ -23,8 +23,8 @@ gboolean group_leave(Group *group, GDBusMethodInvocation *invocation,
 gboolean group_delete(Group *group, GDBusMethodInvocation *invocation,
        gpointer user_data);
 
-gboolean group_device_find(Group *group, GDBusMethodInvocation *invocation, gint timeout,
-       gpointer user_data);
+gboolean group_device_find(Group *group, GDBusMethodInvocation *invocation,
+       gint timeout ,gpointer user_data);
 
 gboolean group_device_invite(Group *group, GDBusMethodInvocation *invocation,
        gchar *uuid_dev1, gchar *uuid_dev2, gchar *pin, gchar *uri_1, gchar *rt_1,
@@ -56,7 +56,7 @@ gboolean group_send_data(Group *group, GDBusMethodInvocation *invocation,
        gchar *uuid_dev, gchar *addr, int port, gchar *data, int len, gpointer user_data);
 
 gboolean group_find_mowned_devices(Group *group,
-       GDBusMethodInvocation *invocation, gpointer user_data);
+       GDBusMethodInvocation *invocation, int timeout, gpointer user_data);
 
 gboolean group_get_mowned_device(Group *group,
        GDBusMethodInvocation *invocation, gpointer user_data);
@@ -86,6 +86,7 @@ void notify_device_find_finish(int ret);
 void notify_group_device_invite_result(int ret);
 void notify_group_device_eject_result(int ret);
 void notify_mowned_device_found(int device_count, GVariant *device_data);
+void notify_mowned_device_find_finish(int ret);
 void notify_group_join(int result);
 void notify_send_data_finish(char *resp_data, int ret);
 void notify_request_result(char *cmd, char *arg, int ret);

diff --git a/src/companion-manager/src/comp_gdbus_group.c b/src/companion-manager/src/comp_gdbus_group.c
index 35581b2ee528e174b867c5786244d9886a69a3f0..762835e2a36609427d1aac2e7c1925aab2d7d6e8 100755 (executable)
--- a/src/companion-manager/src/comp_gdbus_group.c
+++ b/src/companion-manager/src/comp_gdbus_group.c
@@ -224,13 +224,13 @@ gboolean group_send_data(Group *group, GDBusMethodInvocation *invocation,
 }
 
 gboolean group_find_mowned_devices(Group *group,
-       GDBusMethodInvocation *invocation, gpointer user_data)
+       GDBusMethodInvocation *invocation, gint timeout, gpointer user_data)
 {
        int ret = 0;
 
        LOG_DEBUG("find mot owned devices called using dbus successful");
 
-       ret = comp_group_find_mowned_devices();
+       ret = comp_group_find_mowned_devices(timeout);
 
        group_complete_find_mowned_devices(group, invocation, ret);
 
@@ -370,6 +370,10 @@ void notify_mowned_device_found(int device_count, GVariant *device_data)
        group_emit_mowned_device_found(group_dbus_get_object(), device_count, device_data);
 }
 
+void notify_mowned_device_find_finish(int ret)
+{
+       group_emit_mowned_device_find_finish(group_dbus_get_object(), ret);
+}
 void notify_group_join(int result)
 {
        group_emit_join_result(group_dbus_get_object(), result);

diff --git a/src/companion-manager/src/comp_group.c b/src/companion-manager/src/comp_group.c
index 07890a8d3cf3a6cb4717d0d3a78f16fed5aa30e6..1e45e5e6daa92542da1827af6cc21008b2d4f103 100644 (file)
--- a/src/companion-manager/src/comp_group.c
+++ b/src/companion-manager/src/comp_group.c
@@ -705,7 +705,7 @@ void comp_group_notify_mowned_device_find_done(int device_count)
        LOG_END();
 }
 
-int comp_group_find_mowned_devices()
+int comp_group_find_mowned_devices(int timeout)
 {
        int ret;
 
@@ -715,7 +715,7 @@ int comp_group_find_mowned_devices()
        g_list_free_full(mowned_dev_list, _mot_enb_dev_list_free_func);
        mowned_dev_list = NULL;
 
-       ret = agent_find_mowned_devices();
+       ret = agent_find_mowned_devices(timeout);
        if (ret != COMP_ERROR_NONE) {
                LOG_ERR("Failed to find mowned devices : %s",
                                 comp_log_get_error_string(ret));

diff --git a/src/companion-manager/src/comp_mot_agent.c b/src/companion-manager/src/comp_mot_agent.c
index 13d8353c1f1745834a63b21ace2ef215c385ad90..e2c01a979a7f5d746f7a2b500e4e08dbb6363fb3 100644 (file)
--- a/src/companion-manager/src/comp_mot_agent.c
+++ b/src/companion-manager/src/comp_mot_agent.c
@@ -55,7 +55,8 @@ static char *device_uuid1 = NULL;
 static char *device_uuid2 = NULL;
 #endif
 
-int found_device_count;
+int found_device_count; /**< Number of MOT enabled devices */
+int found_mowned_device_count; /**< Number of My Sub-Owned devices */
 
 int agent_get_ownerid(char* deviceid)
 {
@@ -108,7 +109,7 @@ int agent_find_mot_enable_devices(int timeout)
        found_device_count = 0;
 
        variant = g_dbus_proxy_call_sync(agent.gproxy_agent_service, "disc_mot_enb_devs",
-                               NULL, G_DBUS_CALL_FLAGS_NONE,  -1, NULL, &error);
+                               g_variant_new("(i)", timeout), G_DBUS_CALL_FLAGS_NONE,  -1, NULL, &error);
        if (variant) {
                g_variant_get(variant, "(i)", &result);
                LOGD("disc_mot_enb_devs status 0x%x", result);
@@ -123,7 +124,19 @@ int agent_find_mot_enable_devices(int timeout)
        return result;
 }
 
-int agent_find_mowned_devices()
+static gboolean _find_mowned_device_timeout_cb(gpointer data)
+{
+       int ret = -1;
+
+       if (found_mowned_device_count > 0)
+               ret = 0;
+
+       notify_mowned_device_find_finish(ret);
+
+       return false;
+}
+
+int agent_find_mowned_devices(int timeout)
 {
        GVariant *variant = NULL;
        int result = COMP_ERROR_NONE;
@@ -135,7 +148,7 @@ int agent_find_mowned_devices()
        }
 
        variant = g_dbus_proxy_call_sync(agent.gproxy_agent_service, "disc_mowned_devs",
-                               NULL, G_DBUS_CALL_FLAGS_NONE,  -1, NULL, &error);
+                               g_variant_new("(i)", timeout), G_DBUS_CALL_FLAGS_NONE,  -1, NULL, &error);
        if (variant) {
                g_variant_get(variant, "(i)", &result);
                LOGD("disc_mowned_devs status 0x%x", result);
@@ -145,6 +158,8 @@ int agent_find_mowned_devices()
                return COMP_ERROR_IO_ERROR;
        }
 
+       g_timeout_add_seconds(timeout + 1, _find_mowned_device_timeout_cb, NULL);
+
        return result;
 }
 
@@ -742,7 +757,7 @@ static void _agent_signal_handler(GDBusConnection *connection,
                g_variant_iter_free(iter);
 
                LOG_DEBUG("mowned_devs_cnt = %d", mowned_devs_cnt);
-
+               found_mowned_device_count = mowned_devs_cnt;
                comp_group_notify_mowned_device_find_done(mowned_devs_cnt);
        } else if (0 == g_strcmp0(signal_name, "acl_done")) {
                g_variant_get(parameters, "(i)", &result);

diff --git a/src/companion-manager/src/companion_gdbus.xml b/src/companion-manager/src/companion_gdbus.xml
index b895ecba6a01a94f00f0e42e4647b029515a7e7e..d72ef50e79a8fc5e449d4e6edc3c0befe13e1a24 100755 (executable)
--- a/src/companion-manager/src/companion_gdbus.xml
+++ b/src/companion-manager/src/companion_gdbus.xml
@@ -101,6 +101,7 @@
                        <arg type="i" name="result" direction="out" />
                </method>
                <method name="FindMownedDevices">
+                       <arg type="i" name="timeout" direction="in" />
                        <arg type="i" name="result" direction="out" />
                </method>
                <method name="GetMownedDevice">
@@ -160,6 +161,9 @@
                        <arg type="i" name="device_count" direction="out" />
                        <arg type="aa{sv}" name="device_info" direction="out" />
                </signal>
+               <signal name="MownedDeviceFindFinish">
+                       <arg type="i" name="result" direction="out" />
+               </signal>
                <signal name="JoinResult">
                        <arg type="i" name="result" direction="out" />
                </signal>

diff --git a/src/mot-agent/introspection/ma.xml b/src/mot-agent/introspection/ma.xml
index 003702c7dbb875bb302429a7c4330182dae3fa97..efa6a34cd6bdf0c4f6077492ef9f70d8ab6bdc66 100644 (file)
--- a/src/mot-agent/introspection/ma.xml
+++ b/src/mot-agent/introspection/ma.xml
@@ -12,9 +12,11 @@
             <arg type="i" name="result" direction="out"/>\r
         </method>\r
         <method name="disc_mot_enb_devs">\r
+            <arg type="i" name="timeout" direction="in"/>\r
             <arg type="i" name="result" direction="out"/>\r
         </method>\r
             <method name="disc_mowned_devs">\r
+            <arg type="i" name="timeout" direction="in"/>\r
             <arg type="i" name="result" direction="out"/>\r
         </method>\r
         <method name="mot">\r

diff --git a/src/mot-agent/ma-service-interface.c b/src/mot-agent/ma-service-interface.c
index c048eca55e73837a5f35fc4a3874fc8540f91db4..9298a8b3c064d0062b69f7ee3d371440c479df5d 100644 (file)
--- a/src/mot-agent/ma-service-interface.c
+++ b/src/mot-agent/ma-service-interface.c
@@ -154,6 +154,7 @@ static gboolean _ma_dbus_handle_get_ownerid(NetMa *object,
 \r
 static gboolean _ma_dbus_handle_disc_mot_enb_devs(NetMa *object,\r
                GDBusMethodInvocation *invocation,\r
+               gint timeout,\r
                gpointer user_data)\r
 {\r
        int ret = MA_ERROR_NONE;\r
@@ -161,7 +162,7 @@ static gboolean _ma_dbus_handle_disc_mot_enb_devs(NetMa *object,
 \r
        ma_check_null_ret_error("service", service, FALSE);\r
 \r
-       ret = ma_request_disc_mot_enb_devs(service);\r
+       ret = ma_request_disc_mot_enb_devs(service, timeout);\r
        if (MA_ERROR_NONE != ret)\r
                MA_LOGE("Failed to ma_request_disc_mot_enb_devs !");\r
 \r
@@ -172,6 +173,7 @@ static gboolean _ma_dbus_handle_disc_mot_enb_devs(NetMa *object,
 \r
 static gboolean _ma_dbus_handle_disc_mowned_devs(NetMa *object,\r
                GDBusMethodInvocation *invocation,\r
+               gint timeout,\r
                gpointer user_data)\r
 {\r
        int ret = MA_ERROR_NONE;\r
@@ -180,7 +182,7 @@ static gboolean _ma_dbus_handle_disc_mowned_devs(NetMa *object,
        ma_check_null_ret_error("service", service, FALSE);\r
 \r
 \r
-       ret = ma_request_disc_owned_devs(service);\r
+       ret = ma_request_disc_owned_devs(service, timeout);\r
        if (MA_ERROR_NONE != ret)\r
                MA_LOGE("Failed to ma_request_disc_owned_devs !");\r
 \r

diff --git a/src/mot-agent/ma-subowner.c b/src/mot-agent/ma-subowner.c
index e8b66cd03e93c540b47cb464c60a7703614ff1d1..4d66fe2706b5866d9e5bbfe0123ee142e9b9e851 100644 (file)
--- a/src/mot-agent/ma-subowner.c
+++ b/src/mot-agent/ma-subowner.c
@@ -78,6 +78,7 @@ OCStackResult GetDoxmDevOwnerId(OicUuid_t *devownerid);
 typedef struct {
        ma_cmd_id_e cid; /**< Command ID */
        int tid; /**< Timer ID */
+       int timeout; /**< Timeout value */
        GThread *thread; /**< Thread handle */
        unsigned int sid; /**< Subcribed signal ID */
        bool found; /**< Whether we discoverd devices */
@@ -765,7 +766,7 @@ static gpointer _disc_mot_env_devs_func(gpointer data)
        ma_check_null_ret_error("con", con, NULL);
 
        MA_LOGI("Discovering Multiple Ownership Transfer enabled Devices on Network..");
-       if (OC_STACK_OK != OCDiscoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
+       if (OC_STACK_OK != OCDiscoverMultipleOwnerEnabledDevices(con->timeout,
                &g_client->g_motdev_list)) {
                MA_LOGE( "OCDiscoverMultipleOwnerEnalbedDevices API error");
                goto DISC_MOT_ENB_DEVS_END;
@@ -782,7 +783,7 @@ DISC_MOT_ENB_DEVS_END:
        return NULL;
 }
 
-static int _disc_mot_enb_devs(ma_service *service)
+static int _disc_mot_enb_devs(ma_service *service, int timeout)
 {
        ma_req_cb_s *con = NULL;
        con = g_malloc0(sizeof(ma_req_cb_s));
@@ -806,8 +807,13 @@ static int _disc_mot_enb_devs(ma_service *service)
 
        con->userdata = service;
        con->cid = MA_DISC_MOT_ENB_DEVS;
+
+       if (timeout < 1)
+               timeout = DISCOVERY_TIMEOUT;
+       con->timeout = timeout;
+
 #ifdef TIMEOUT_USED
-       con->tid = g_timeout_add_seconds(DISCOVERY_TIMEOUT * 2, _ma_timeout_cb, con);
+       con->tid = g_timeout_add_seconds(timeout * 2, _ma_timeout_cb, con);
 #endif
        return MA_ERROR_NONE;
 }
@@ -823,7 +829,7 @@ static gpointer _disc_owned_devs_func(gpointer data)
        _remove_owned_client();
 
        MA_LOGD("Discovering Multiple Owned Devices");
-       ret = OCDiscoverMultipleOwnedDevices(DISCOVERY_TIMEOUT, &g_client->g_mowned_list);
+       ret = OCDiscoverMultipleOwnedDevices(con->timeout, &g_client->g_mowned_list);
        if (OC_STACK_OK != ret) {
                MA_LOGE( "OCDiscoverMultipleOwnerEnabledDevices API error");
                goto DISC_OWNED_DEVS_END;
@@ -838,7 +844,7 @@ DISC_OWNED_DEVS_END:
        return NULL;
 }
 
-static int _disc_owned_devs(ma_service *service)
+static int _disc_owned_devs(ma_service *service, int timeout)
 {
        ma_req_cb_s *con = NULL;
        con = g_malloc0(sizeof(ma_req_cb_s));
@@ -852,6 +858,10 @@ static int _disc_owned_devs(ma_service *service)
        con->userdata = service;
        con->cid = MA_DISC_MOWNED_DEVS;
 
+       if (timeout < 1)
+               timeout = DISCOVERY_TIMEOUT;
+       con->timeout = timeout;
+
        con->thread = g_thread_try_new("disc_owned_devs", _disc_owned_devs_func, con, NULL);
        if (!con->thread) {
                MA_LOGE("Failed to create thread");
@@ -860,7 +870,7 @@ static int _disc_owned_devs(ma_service *service)
        }
        g_thread_unref(con->thread);
 #ifdef TIMEOUT_USED
-       con->tid = g_timeout_add_seconds(DISCOVERY_TIMEOUT * 2, _ma_timeout_cb, con);
+       con->tid = g_timeout_add_seconds(timeout * 2, _ma_timeout_cb, con);
 #endif
        return MA_ERROR_NONE;
 }
@@ -2392,7 +2402,7 @@ int ma_request_get_ownerid(ma_service *service, gchar **uuid_str)
        return ret;
 }
 
-int ma_request_disc_mot_enb_devs(ma_service *service)
+int ma_request_disc_mot_enb_devs(ma_service *service, int timeout)
 {
        int ret =MA_ERROR_NONE;
 
@@ -2407,12 +2417,12 @@ int ma_request_disc_mot_enb_devs(ma_service *service)
        /* Set d2ds status 'pending' */
        g_atomic_int_set(&service->pending, 1);
 
-       ret = _disc_mot_enb_devs(service);
+       ret = _disc_mot_enb_devs(service, timeout);
 
        return ret;
 }
 
-int ma_request_disc_owned_devs(ma_service *service)
+int ma_request_disc_owned_devs(ma_service *service, int timeout)
 {
        int ret =MA_ERROR_NONE;
 
@@ -2427,7 +2437,7 @@ int ma_request_disc_owned_devs(ma_service *service)
        /* Set d2ds status 'pending' */
        g_atomic_int_set(&service->pending, 1);
 
-       ret = _disc_owned_devs(service);
+       ret = _disc_owned_devs(service, timeout);
 
        return ret;
 }

diff --git a/src/mot-agent/ma-subowner.h b/src/mot-agent/ma-subowner.h
index a89b08223de9c659f3c4bf71aa5ef6b7ec3deaca..2f3460c4557d94c6e716dba66178348a6cd02aae 100644 (file)
--- a/src/mot-agent/ma-subowner.h
+++ b/src/mot-agent/ma-subowner.h
@@ -53,8 +53,8 @@ typedef enum {
 int ma_request_enable(ma_service *service);
 int ma_request_disable(ma_service *service);
 int ma_request_get_ownerid(ma_service *service, gchar **uuid_str);
-int ma_request_disc_mot_enb_devs(ma_service *service);
-int ma_request_disc_owned_devs(ma_service *service);
+int ma_request_disc_mot_enb_devs(ma_service *service, int timeout);
+int ma_request_disc_owned_devs(ma_service *service, int timeout);
 int ma_request_mot(ma_service *service, gchar* uuid, gchar *pin);
 int ma_request_prov_acl(ma_service *service, gchar *target, gchar *subject,
        gchar *rsrc_uri, gchar *rsrc_type, gchar *rsrc_interface, int permission);