Allow a session to send an async request before receiving its reply

diff --git a/src/wifi-aware-private.c b/src/wifi-aware-private.c
index c5ef1eb..8e141a1 100644 (file)
--- a/src/wifi-aware-private.c
+++ b/src/wifi-aware-private.c
@@ -180,10 +180,10 @@ bool _wifi_aware_handle_is_valid(wifi_aware_h wifi_aware)
        return true;
 }
 
-static void __session_set_requested(wifi_aware_session_h session_handle)
+static void __session_set_requested(wifi_aware_session_h session_handle, bool requested)
 {
        wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle;
-       session->is_requested = true;
+       session->is_requested = requested;
 }
 
 static bool __session_is_requested(wifi_aware_session_h session_handle)
@@ -300,23 +300,15 @@ static void __wifi_aware_discovered_cb(wifi_aware_session_h session, wifi_aware_
                                handle->discovered_cb_data);
 }
 
-static void __publish_request_reply(GObject *src, GAsyncResult *res, gpointer user_data)
+static wifi_aware_error_e __get_dbus_result(GObject *src, GAsyncResult *res, unsigned int *id)
 {
-       GDBusConnection *conn = NULL;
+       GDBusConnection *conn = G_DBUS_CONNECTION(src);
        GError *dbus_error = NULL;
-       GVariant *reply = NULL;
-       wifi_aware_session_h session = (wifi_aware_session_h)user_data;
-       wifi_aware_publish_s *publish_config = NULL;
-       wifi_aware_error_e error = WIFI_AWARE_ERROR_NONE;
+       GVariant *reply = g_dbus_connection_call_finish(conn, res, &dbus_error);
        int nan_error = 0;
-       unsigned int publish_id = 0;
-
-       WIFI_AWARE_LOGI("Reply for Publish Request");
-       RET_IF(session == NULL, "Session is NULL");
+       wifi_aware_error_e error = WIFI_AWARE_ERROR_NONE;
 
-       conn = G_DBUS_CONNECTION(src);
-       reply = g_dbus_connection_call_finish(conn, res, &dbus_error);
-       RET_IF(reply == NULL, "reply is NULL");
+       RET_VAL_IF(reply == NULL, WIFI_AWARE_ERROR_INVALID_OPERATION, "reply is NULL");
 
        if (dbus_error != NULL) {
                WIFI_AWARE_LOGE("Publish Request failure: %s", dbus_error->message);
@@ -324,13 +316,26 @@ static void __publish_request_reply(GObject *src, GAsyncResult *res, gpointer us
                g_error_free(dbus_error);
        }
        else {
-               g_variant_get(reply, "(ui)", &publish_id, &nan_error);
-               WIFI_AWARE_LOGI("Publish ID: %u, error: %d", publish_id, nan_error);
+               g_variant_get(reply, "(ui)", id, &nan_error);
+               WIFI_AWARE_LOGI("Pub/Sub ID: %u, error: %d", *id, nan_error);
                error = _wifi_aware_convert_nan_manager_error(nan_error);
        }
+       return error;
+}
+
+static void __publish_request_reply(GObject *src, GAsyncResult *res, gpointer user_data)
+{
+       wifi_aware_session_h session = (wifi_aware_session_h)user_data;
+       wifi_aware_error_e error = WIFI_AWARE_ERROR_NONE;
+       unsigned int publish_id = 0;
+
+       WIFI_AWARE_LOGI("Reply for Publish Request");
+       RET_IF(session == NULL, "Session is NULL");
+
+       error = __get_dbus_result(src, res, &publish_id);
 
-       publish_config = __session_get_publish_config(session);
-       __wifi_aware_publish_set_id(publish_config, publish_id);
+       __session_set_requested(session, false);
+       __wifi_aware_publish_set_id(__session_get_publish_config(session), publish_id);
        __wifi_aware_publish_invoke_callback(session, error);
 }
 
@@ -374,35 +379,17 @@ wifi_aware_subscribe_request_s *_wifi_aware_subscribe_get_request(wifi_aware_sub
 
 static void __subscribe_request_reply(GObject *src, GAsyncResult *res, gpointer user_data)
 {
-       GDBusConnection *conn = NULL;
-       GError *dbus_error = NULL;
-       GVariant *reply = NULL;
        wifi_aware_session_h session = (wifi_aware_session_h)user_data;
-       wifi_aware_subscribe_s *subscribe_config = NULL;
        wifi_aware_error_e error = WIFI_AWARE_ERROR_NONE;
-       int nan_error = 0;
        unsigned int subscribe_id = 0;
 
        WIFI_AWARE_LOGI("Reply for Subscribe Request");
        RET_IF(session == NULL, "Session is NULL");
 
-       conn = G_DBUS_CONNECTION(src);
-       reply = g_dbus_connection_call_finish(conn, res, &dbus_error);
-       RET_IF(reply == NULL, "reply is NULL");
+       error = __get_dbus_result(src, res, &subscribe_id);
 
-       if (dbus_error != NULL) {
-               WIFI_AWARE_LOGE("Subscribe 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, "(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);
-       }
-
-       subscribe_config = __session_get_subscribe_config(session);
-       __wifi_aware_subscribe_set_id(subscribe_config, subscribe_id);
+       __session_set_requested(session, false);
+       __wifi_aware_subscribe_set_id(__session_get_subscribe_config(session), subscribe_id);
        __wifi_aware_subscribe_invoke_callback(session, error);
 }
 
@@ -615,16 +602,25 @@ int _wifi_aware_publish_request(wifi_aware_session_h session,
        RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
        RET_VAL_IF(!__is_publish_session(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
                        "This session is not for Publish");
-       RET_VAL_IF(__session_is_requested(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
-                       "Already requested");
+       RET_VAL_IF(__session_is_requested(session), WIFI_AWARE_ERROR_NOW_IN_PROGRESS,
+                       "There is a pending request");
+
+       int ret = WIFI_AWARE_ERROR_NONE;
 
        __session_set_publish_config(session, publish);
-       __session_set_requested(session);
        __session_add_published_callback(session, callback, user_data);
+       __session_set_requested(session, true);
 
-       return wifi_aware_gdbus_publish(session, publish,
+       ret = wifi_aware_gdbus_publish(session, publish,
                        __session_get_client_id(session),
                        __publish_request_reply);
+
+       if (ret != WIFI_AWARE_ERROR_NONE) {
+               WIFI_AWARE_LOGE("Fail to publish");
+               __session_set_requested(session, false);
+       }
+
+       return ret;
 }
 
 int _wifi_aware_update_publish_request(wifi_aware_session_h session,
@@ -637,13 +633,25 @@ int _wifi_aware_update_publish_request(wifi_aware_session_h session,
                        "This session is not for Publish");
        RET_VAL_IF(!__is_published(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
                        "The publish is not done yet");
+       RET_VAL_IF(__session_is_requested(session), WIFI_AWARE_ERROR_NOW_IN_PROGRESS,
+                       "There is a pending request");
+
+       int ret = WIFI_AWARE_ERROR_NONE;
 
        __session_set_publish_config(session, publish);
        __session_add_published_callback(session, callback, user_data);
+       __session_set_requested(session, true);
 
-       return wifi_aware_gdbus_update_publish(session, publish,
+       ret = wifi_aware_gdbus_update_publish(session,  publish,
                        __session_get_client_id(session),
                        __publish_request_reply);
+
+       if (ret != WIFI_AWARE_ERROR_NONE) {
+               WIFI_AWARE_LOGE("Fail to update publish");
+               __session_set_requested(session, false);
+       }
+
+       return ret;
 }
 
 
@@ -730,16 +738,25 @@ int _wifi_aware_subscribe_request(wifi_aware_session_h session,
        RET_VAL_IF(subscribe == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_h is NULL");
        RET_VAL_IF(!__is_subscribe_session(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
                        "This session is not for Subscribe");
-       RET_VAL_IF(__session_is_requested(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
-                       "Already requested");
+       RET_VAL_IF(__session_is_requested(session), WIFI_AWARE_ERROR_NOW_IN_PROGRESS,
+                       "There is a pending request");
+
+       int ret = WIFI_AWARE_ERROR_NONE;
 
        __session_set_subscribe_config(session, subscribe);
-       __session_set_requested(session);
        __session_add_subscribed_callback(session, callback, user_data);
+       __session_set_requested(session, true);
 
-       return wifi_aware_gdbus_subscribe(session, subscribe,
+       ret = wifi_aware_gdbus_subscribe(session, subscribe,
                        __session_get_client_id(session),
                        __subscribe_request_reply);
+
+       if (ret != WIFI_AWARE_ERROR_NONE) {
+               WIFI_AWARE_LOGE("Fail to subscribe");
+               __session_set_requested(session, false);
+       }
+
+       return ret;
 }
 
 int _wifi_aware_update_subscribe_request(wifi_aware_session_h session,
@@ -752,13 +769,25 @@ int _wifi_aware_update_subscribe_request(wifi_aware_session_h session,
                        "This session is not for Subscribe");
        RET_VAL_IF(!__is_subscribed(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
                        "The subscribe is not done yet");
+       RET_VAL_IF(__session_is_requested(session), WIFI_AWARE_ERROR_NOW_IN_PROGRESS,
+                       "There is a pending request");
 
        __session_set_subscribe_config(session, subscribe);
        __session_add_subscribed_callback(session, callback, user_data);
+       __session_set_requested(session, true);
+
+       int ret = WIFI_AWARE_ERROR_NONE;
 
-       return wifi_aware_gdbus_update_subscribe(session, subscribe,
+       ret = wifi_aware_gdbus_update_subscribe(session, subscribe,
                        __session_get_client_id(session),
                        __subscribe_request_reply);
+
+       if (ret != WIFI_AWARE_ERROR_NONE) {
+               WIFI_AWARE_LOGE("Fail to update subscribe");
+               __session_set_requested(session, false);
+       }
+
+       return ret;
 }
 
 static int __wifi_aware_cancel_publish_request(wifi_aware_session_h session)