Add followup request

diff --git a/include/wifi-aware.h b/include/wifi-aware.h
index ae89988..b0b2dbd 100644 (file)
--- a/include/wifi-aware.h
+++ b/include/wifi-aware.h
@@ -528,14 +528,25 @@ int wifi_aware_set_discovery_result_cb(wifi_aware_subscribe_h subscribe,
 /**
  * @brief
  * @since_tizen 6.0
+ * @param[in] error
+ * @param[in] user_data
+ */
+typedef void(*wifi_aware_send_message_result_cb)(wifi_aware_error_e error, void *user_data);
+
+/**
+ * @brief
+ * @since_tizen 6.0
  * @param[in] peer
  * @param[in] message
  * @param[in] len
+ * @param[in] callback
+ * @param[in] user_data
  * @return     0 on success, otherwise a negative error value
  * @retval     #WIFI_AWARE_ERROR_NONE
  */
-int wifi_aware_send_message(wifi_aware_peer_h peer, unsigned char *message, size_t len);
-
+int wifi_aware_send_message(wifi_aware_peer_h peer,
+               unsigned char *message, size_t len,
+               wifi_aware_send_message_result_cb callback, void *user_data);
 
 /**
  * @brief

diff --git a/src/include/wifi-aware-gdbus.h b/src/include/wifi-aware-gdbus.h
index 22278d1..fa414a6 100644 (file)
--- a/src/include/wifi-aware-gdbus.h
+++ b/src/include/wifi-aware-gdbus.h
@@ -64,6 +64,10 @@ int wifi_aware_gdbus_update_publish(wifi_aware_publish_h publish, int client_id,
 int wifi_aware_gdbus_subscribe(wifi_aware_subscribe_h subscribe, int client_id, GAsyncReadyCallback cb);
 int wifi_aware_gdbus_cancel_subscribe(wifi_aware_subscribe_h subscribe, int client_id);
 int wifi_aware_gdbus_update_subscribe(wifi_aware_subscribe_h subscribe, int client_id, GAsyncReadyCallback cb);
+
+int wifi_aware_gdbus_followup(int client_id, unsigned int peer_id,
+               unsigned char *message, size_t len,
+               GAsyncReadyCallback cb, void *user_data);
 #ifdef __cplusplus
 }
 #endif

diff --git a/src/include/wifi-aware-peer.h b/src/include/wifi-aware-peer.h
index 8c35435..4a8563e 100644 (file)
--- a/src/include/wifi-aware-peer.h
+++ b/src/include/wifi-aware-peer.h
@@ -28,7 +28,9 @@ extern "C" {
 int _wifi_aware_peer_create(wifi_aware_peer_h *peer, unsigned int peer_id);
 int _wifi_aware_peer_add(wifi_aware_h wifi_aware, wifi_aware_peer_h peer);
 int _wifi_aware_peer_remove(wifi_aware_h wifi_aware, wifi_aware_peer_h peer);
-wifi_aware_peer_h _wifi_aware_peer_get_handle(wifi_aware_h wifi_aware, unsigned int peer_id);
+wifi_aware_peer_h _wifi_aware_get_peer(wifi_aware_h wifi_aware, unsigned int peer_id);
+int _wifi_aware_peer_get_client_id(wifi_aware_peer_h peer);
+unsigned int _wifi_aware_peer_get_id(wifi_aware_peer_h peer);
 
 #ifdef __cplusplus
 }

diff --git a/src/include/wifi-aware-private.h b/src/include/wifi-aware-private.h
index da4c714..78542e5 100644 (file)
--- a/src/include/wifi-aware-private.h
+++ b/src/include/wifi-aware-private.h
@@ -93,6 +93,10 @@ unsigned int _wifi_aware_subscribe_get_id(wifi_aware_subscribe_h subscribe);
 void _wifi_aware_set_discovery_result_cb(wifi_aware_subscribe_h subscribe,
                wifi_aware_discovery_result_cb callback, void *user_data);
 
+int _wifi_aware_send_message(wifi_aware_peer_h peer,
+               unsigned char *message, size_t len,
+               wifi_aware_send_message_result_cb callback, void *user_data);
+
 //void _mac_address_changed(GDBusConnection *connection,
 //             const gchar *object_path, GVariant *parameters);
 

diff --git a/src/wifi-aware-gdbus.c b/src/wifi-aware-gdbus.c
index 789f5e3..2025193 100644 (file)
--- a/src/wifi-aware-gdbus.c
+++ b/src/wifi-aware-gdbus.c
@@ -339,6 +339,13 @@ static GVariant *__create_update_subscribe_request_param(int client_id,
        return params;
 }
 
+static GVariant *__create_followup_request_param(int client_id, unsigned int peer_id,
+                       unsigned char *message, size_t len)
+{
+       return g_variant_new("(iuuay)", client_id, peer_id, len,
+                       __pack_byte_array(message, len));
+}
+
 int wifi_aware_gdbus_enable(wifi_aware_h wifi_aware,
                wifi_aware_enable_request_s *req, GAsyncReadyCallback cb)
 {
@@ -469,7 +476,7 @@ int wifi_aware_gdbus_update_publish(wifi_aware_publish_h publish, int client_id,
                        WIFI_AWARE_DISCOVERY_PATH,
                        "UpdatePublish", params, cb, publish);
 
-       RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Publish failed");
+       RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "UpdatePublish failed");
 
        __WIFI_AWARE_FUNC_EXIT__;
        return ret;
@@ -557,9 +564,31 @@ int wifi_aware_gdbus_update_subscribe(wifi_aware_subscribe_h subscribe, int clie
                        WIFI_AWARE_DISCOVERY_PATH,
                        "UpdateSubscribe", params, cb, subscribe);
 
-       RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Subscribe failed");
+       RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "UpdateSubscribe failed");
 
        __WIFI_AWARE_FUNC_EXIT__;
        return ret;
 }
 
+int wifi_aware_gdbus_followup(int client_id, unsigned int peer_id,
+               unsigned char *message, size_t len,
+               GAsyncReadyCallback cb, void *user_data)
+{
+       __WIFI_AWARE_FUNC_ENTER__;
+       GVariant *params = NULL;
+       int ret = WIFI_AWARE_ERROR_NONE;
+
+       params = __create_followup_request_param(client_id, peer_id,
+                       message, len);
+       DBUS_DEBUG_VARIANT(params);
+
+       ret = __wifi_aware_dbus_method_call_async(
+                       WIFI_AWARE_DISCOVERY_INTERFACE,
+                       WIFI_AWARE_DISCOVERY_PATH,
+                       "Followup", params, cb, user_data);
+
+       RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Followup failed");
+
+       __WIFI_AWARE_FUNC_EXIT__;
+       return ret;
+}

diff --git a/src/wifi-aware-peer.c b/src/wifi-aware-peer.c
index 0b94164..cffc3be 100644 (file)
--- a/src/wifi-aware-peer.c
+++ b/src/wifi-aware-peer.c
@@ -25,12 +25,15 @@
 
 typedef struct {
        unsigned int id;
+       int client_id;
 } wifi_aware_peer_s;
 
 int _wifi_aware_peer_create(wifi_aware_peer_h *peer, unsigned int peer_id)
 {
-       *peer = (wifi_aware_peer_s *)g_try_malloc0(sizeof(wifi_aware_peer_s));
-       RET_VAL_IF(*peer == NULL, WIFI_AWARE_ERROR_OUT_OF_MEMORY, "g_try_malloc0 failed");
+       wifi_aware_peer_s *peer_handle = (wifi_aware_peer_s *)g_try_malloc0(sizeof(wifi_aware_peer_s));
+       RET_VAL_IF(peer_handle == NULL, WIFI_AWARE_ERROR_OUT_OF_MEMORY, "g_try_malloc0 failed");
+       peer_handle->client_id = -1;
+       *peer = peer_handle;
        return WIFI_AWARE_ERROR_NONE;
 }
 
@@ -41,6 +44,8 @@ int _wifi_aware_peer_add(wifi_aware_h wifi_aware, wifi_aware_peer_h peer)
        wifi_aware_peer_s *peer_handle = (wifi_aware_peer_s *)peer;
        RET_VAL_IF(peer_handle == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "peer is NULL");
 
+       peer_handle->client_id = aware_handle->client_id;
+
        WIFI_AWARE_HANDLE_LOCK;
        if (g_hash_table_contains(peer_map, GINT_TO_POINTER(peer_handle->id))) {
                WIFI_AWARE_LOGE("peer_id %d alread exists", peer_handle->id);
@@ -77,7 +82,7 @@ int _wifi_aware_peer_remove(wifi_aware_h wifi_aware, wifi_aware_peer_h peer)
        return WIFI_AWARE_ERROR_NONE;
 }
 
-wifi_aware_peer_h _wifi_aware_peer_get_handle(wifi_aware_h wifi_aware, unsigned int peer_id)
+wifi_aware_peer_h _wifi_aware_get_peer(wifi_aware_h wifi_aware, unsigned int peer_id)
 {
        wifi_aware_s *aware_handle = (wifi_aware_s *)wifi_aware;
        GHashTable *peer_map = aware_handle->peer_map;
@@ -88,3 +93,14 @@ wifi_aware_peer_h _wifi_aware_peer_get_handle(wifi_aware_h wifi_aware, unsigned
        WIFI_AWARE_HANDLE_UNLOCK;
        return peer;
 }
+
+int _wifi_aware_peer_get_client_id(wifi_aware_peer_h peer)
+{
+       wifi_aware_peer_s *handle = (wifi_aware_peer_s *)peer;
+       return handle->client_id;
+}
+unsigned int _wifi_aware_peer_get_id(wifi_aware_peer_h peer)
+{
+       wifi_aware_peer_s *handle = (wifi_aware_peer_s *)peer;
+       return handle->id;
+}

diff --git a/src/wifi-aware-private.c b/src/wifi-aware-private.c
index 70d2431..3da40a6 100644 (file)
--- a/src/wifi-aware-private.c
+++ b/src/wifi-aware-private.c
@@ -75,6 +75,11 @@ typedef struct {
        guint discovered_signal_id;
 } wifi_aware_subscribe_s;
 
+typedef struct {
+       wifi_aware_send_message_result_cb callback;
+       void *user_data;
+} wifi_aware_message_s;
+
 static bool __is_init = false;
 static GList *__wifi_aware_handle_list = NULL;
 
@@ -173,13 +178,6 @@ static int __get_client_id_with_subscribe(wifi_aware_subscribe_h subscribe)
        return handle->aware_handle->client_id;
 }
 
-static wifi_aware_error_e __parse_enable_reply(GVariant *reply, wifi_aware_s *aware)
-{
-       int error;
-       g_variant_get(reply, "(ii)", &aware->client_id, &error);
-       return _wifi_aware_convert_nan_manager_error(error);
-}
-
 static void __enable_request_reply(GObject *src, GAsyncResult *res, gpointer user_data)
 {
        GDBusConnection *conn = NULL;
@@ -187,6 +185,7 @@ static void __enable_request_reply(GObject *src, GAsyncResult *res, gpointer use
        GVariant *reply = NULL;
        wifi_aware_s *aware = (wifi_aware_s *)user_data;
        wifi_aware_error_e error = WIFI_AWARE_ERROR_NONE;
+       int nan_error = 0;
 
        WIFI_AWARE_LOGI("Reply for Enable Request");
 
@@ -197,9 +196,11 @@ static void __enable_request_reply(GObject *src, GAsyncResult *res, gpointer use
                WIFI_AWARE_LOGE("Enable Request failure: %s", dbus_error->message);
                error = _wifi_aware_convert_error_string_to_enum(dbus_error->message);
                g_error_free(dbus_error);
+       } else {
+               g_variant_get(reply, "(ii)", &aware->client_id, &nan_error);
+               WIFI_AWARE_LOGI("Client ID: %i, error: %d", aware->client_id, nan_error);
+               error = _wifi_aware_convert_nan_manager_error(nan_error);
        }
-
-       error = __parse_enable_reply(reply, aware);
        
        if (aware->enabled_cb)
                aware->enabled_cb(error, aware->enabled_cb_data);
@@ -253,7 +254,7 @@ static void __add_published_callback(wifi_aware_publish_h publish,
 
 static int __is_published(wifi_aware_publish_h publish)
 {
-       RET_IF(publish == NULL, "wifi_aware_publish_h is NULL");
+       RET_VAL_IF(publish == NULL, 0, "wifi_aware_publish_h is NULL");
        wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
        return handle->publish_id > 0;
 }
@@ -281,6 +282,7 @@ static void __publish_request_reply(GObject *src, GAsyncResult *res, gpointer us
        GVariant *reply = NULL;
        wifi_aware_publish_h publish = (wifi_aware_publish_h)user_data;
        wifi_aware_error_e error = WIFI_AWARE_ERROR_NONE;
+       int nan_error = 0;
        unsigned int publish_id = -1;
 
        WIFI_AWARE_LOGI("Reply for Publish Request");
@@ -295,13 +297,14 @@ static void __publish_request_reply(GObject *src, GAsyncResult *res, gpointer us
                g_error_free(dbus_error);
        }
        else {
-               g_variant_get(reply, "(ui)", &publish_id, &error);
-               WIFI_AWARE_LOGI("Publish ID: %u, error: %d", publish_id, error);
+               g_variant_get(reply, "(ui)", &publish_id, &nan_error);
+               WIFI_AWARE_LOGI("Publish ID: %u, error: %d", publish_id, nan_error);
+               error = _wifi_aware_convert_nan_manager_error(nan_error);
        }
 
        __wifi_aware_publish_set_id(publish, publish_id);
        __wifi_aware_publish_invoke_callback(
-                       _wifi_aware_convert_nan_manager_error(error),
+                       error,
                        publish);
 }
 
@@ -315,7 +318,7 @@ static void __add_subscribed_callback(wifi_aware_subscribe_h subscribe,
 
 static int __is_subscribed(wifi_aware_subscribe_h subscribe)
 {
-       RET_IF(subscribe == NULL, "wifi_aware_subscribe_h is NULL");
+       RET_VAL_IF(subscribe == NULL, 0, "wifi_aware_subscribe_h is NULL");
        wifi_aware_subscribe_s *handle = (wifi_aware_subscribe_s *)subscribe;
        return handle->subscribe_id > 0;
 }
@@ -350,6 +353,7 @@ static void __subscribe_request_reply(GObject *src, GAsyncResult *res, gpointer
        GVariant *reply = NULL;
        wifi_aware_subscribe_h subscribe = (wifi_aware_subscribe_h)user_data;
        wifi_aware_error_e error = WIFI_AWARE_ERROR_NONE;
+       int nan_error = 0;
        unsigned int subscribe_id = -1;
 
        WIFI_AWARE_LOGI("Reply for Subscribe Request");
@@ -364,13 +368,14 @@ static void __subscribe_request_reply(GObject *src, GAsyncResult *res, gpointer
                g_error_free(dbus_error);
        }
        else {
-               g_variant_get(reply, "(ui)", &subscribe_id, &error);
-               WIFI_AWARE_LOGI("Subscribe ID: %u, error: %d", subscribe_id, error);
+               g_variant_get(reply, "(ui)", &subscribe_id, &nan_error);
+               WIFI_AWARE_LOGI("Subscribe ID: %u, error: %d", subscribe_id, nan_error);
+               error = _wifi_aware_convert_nan_manager_error(nan_error);
        }
 
        __wifi_aware_subscribe_set_id(subscribe, subscribe_id);
        __wifi_aware_subscribe_invoke_callback(
-                       _wifi_aware_convert_nan_manager_error(error),
+                       error,
                        subscribe);
 }
 
@@ -729,7 +734,7 @@ static void __parsing_service_discovered_event(GVariant *parameters,
 static int __handle_new_peer(wifi_aware_s *aware_handle, unsigned int peer_id, wifi_aware_peer_h *peer)
 {
        int ret = WIFI_AWARE_ERROR_NONE;
-       if (_wifi_aware_peer_get_handle(aware_handle, peer_id) != NULL) {
+       if (_wifi_aware_get_peer(aware_handle, peer_id) != NULL) {
                WIFI_AWARE_LOGI("Peer %u already exists", peer_id);
                return WIFI_AWARE_ERROR_NONE;
        }
@@ -795,3 +800,65 @@ void _wifi_aware_set_discovery_result_cb(wifi_aware_subscribe_h subscribe,
                wifi_aware_gdbus_register_signal(SERVICE_DISCOVERED_SIGNAL,
                                __service_discovered_cb, handle);
 }
+
+wifi_aware_message_s *__create_message_data(wifi_aware_send_message_result_cb cb, void *user_data)
+{
+       wifi_aware_message_s *result =
+               (wifi_aware_message_s *)g_try_malloc0(sizeof(wifi_aware_message_s));
+       if (result == NULL)
+               return NULL;
+       result->callback = cb;
+       result->user_data = user_data;
+}
+
+static void __wifi_aware_followup_invoke_callback(wifi_aware_message_s *message, wifi_aware_error_e error)
+{
+       if (message && message->callback)
+               message->callback(error, message->user_data);
+}
+
+static void __send_message_reply(GObject *src, GAsyncResult *res, gpointer user_data)
+{
+       GDBusConnection *conn = NULL;
+       GError *dbus_error = NULL;
+       GVariant *reply = NULL;
+
+       wifi_aware_message_s *message = (wifi_aware_message_s *)user_data;
+       wifi_aware_error_e error = WIFI_AWARE_ERROR_NONE;
+       int nan_error = 0;
+
+       WIFI_AWARE_LOGI("Reply for Followup");
+
+       conn = G_DBUS_CONNECTION(src);
+       reply = g_dbus_connection_call_finish(conn, res, &dbus_error);
+       RET_IF(reply == NULL, "reply is NULL");
+
+       if (dbus_error != NULL) {
+               WIFI_AWARE_LOGE("Followup Request failure: %s", dbus_error->message);
+               error = _wifi_aware_convert_error_string_to_enum(dbus_error->message);
+               g_error_free(dbus_error);
+       }
+       else {
+               g_variant_get(reply, "(i)", &nan_error);
+               WIFI_AWARE_LOGI("error: %d", nan_error);
+               error = _wifi_aware_convert_nan_manager_error(nan_error);
+       }
+
+       __wifi_aware_followup_invoke_callback(message, error);
+}
+
+int _wifi_aware_send_message(wifi_aware_peer_h peer,
+               unsigned char *message, size_t len,
+               wifi_aware_send_message_result_cb callback, void *user_data)
+{
+       __WIFI_AWARE_FUNC_ENTER__;
+
+       wifi_aware_message_s *message_data = __create_message_data(callback, user_data);
+       RET_VAL_IF(message == NULL, WIFI_AWARE_ERROR_OUT_OF_MEMORY, "__create_cb_data fails");
+       return wifi_aware_gdbus_followup(
+                       _wifi_aware_peer_get_client_id(peer),
+                       _wifi_aware_peer_get_id(peer),
+                       message, len,
+                       __send_message_reply,
+                       message_data);
+}

diff --git a/src/wifi-aware.c b/src/wifi-aware.c
index 5eedd7f..92ea990 100644 (file)
--- a/src/wifi-aware.c
+++ b/src/wifi-aware.c
@@ -483,15 +483,16 @@ API int wifi_aware_set_discovery_result_cb(wifi_aware_subscribe_h subscribe,
 }
 
 API int wifi_aware_send_message(wifi_aware_peer_h peer,
-               unsigned char *message, size_t len)
+               unsigned char *message, size_t len,
+               wifi_aware_send_message_result_cb callback, void *user_data)
 {
        __WIFI_AWARE_FUNC_ENTER__;
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
 
-       // TODO
+       RET_VAL_IF(peer == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER,
+                       "wifi_aware_peer_h is NULL");
 
-       __WIFI_AWARE_FUNC_EXIT__;
-       return WIFI_AWARE_ERROR_NONE;
+       return _wifi_aware_send_message(peer, message, len, callback, user_data);
 }
 
 API int wifi_aware_set_received_message_cb(wifi_aware_h wifi_aware,