Remove wifi_aware_h

diff --git a/include/wifi-aware.h b/include/wifi-aware.h
index 86799e1..f80207d 100644 (file)
--- a/include/wifi-aware.h
+++ b/include/wifi-aware.h
@@ -115,12 +115,6 @@ typedef enum {
 
 
 /**
- * @brief Wi-Fi Aware handle.
- * @since_tizen 6.0
- */
-typedef void *wifi_aware_h;
-
-/**
  * @brief Wi-Fi Aware Session
  * @since_tizen 6.0
  */
@@ -148,24 +142,21 @@ typedef void *wifi_aware_peer_h;
 /**
  * @brief
  * @since_tizen 6.0
- * @param[in]
- * @param[out]
  * @return     0 on success, otherwise a negative error value
  * @retval     #WIFI_AWARE_ERROR_NONE
+ * @retval     #WIFI_AWARE_ERROR_ALREADY_INITIALIZED
  * @see        wifi_aware_deinitialize
  */
-int wifi_aware_initialize(wifi_aware_h *wifi_aware);
+int wifi_aware_initialize();
 
 /**
  * @brief
  * @since_tizen 6.0
- * @param[in]
- * @param[out]
  * @return     0 on success, otherwise a negative error value
  * @retval     #WIFI_AWARE_ERROR_NONE
  * @see        wifi_aware_initialize
  */
-int wifi_aware_deinitialize(wifi_aware_h wifi_aware);
+int wifi_aware_deinitialize();
 
 /**
  * @brief Create a Publish request.
@@ -371,40 +362,34 @@ typedef void(*wifi_aware_enabled_cb)(wifi_aware_error_e error, void *user_data);
  * @remarks If the enable request is sucessfully done, the application can get the MAC address.
  *             TODO: Does an application need to know MAC address (NMI)?
  * @since_tizen 6.0
- * @param[in] wifi_aware The handle for the Wi-Fi aware
  * @param[in] callback The result of enable request is asynchrously delivered
  * @param[in] user_data User data
  * @return     0 on success, otherwise a negative error value
  * @retval     #WIFI_AWARE_ERROR_NONE
  */
-int wifi_aware_enable(wifi_aware_h wifi_aware,
-               wifi_aware_enabled_cb callback, void *user_data);
+int wifi_aware_enable(wifi_aware_enabled_cb callback, void *user_data);
 
 /**
  * @brief Disable Wi-Fi Aware functions.
  * @since_tizen 6.0
- * @param[in] wifi_aware The handle for the Wi-Fi aware
  * @return 0 on success, otherwise a negative error value
  * @retval #WIFI_AWARE_ERROR_NONE
  */
-int wifi_aware_disable(wifi_aware_h wifi_aware);
+int wifi_aware_disable();
 
 /**
  * @brief
  * @since_tizen 6.0
- * @param[in] wifi_aware
  * @param[in] session_type
  * @param[in] session
  * @return     0 on success, otherwise a negative error value
  * @retval     #WIFI_AWARE_ERROR_NONE
  */
-int wifi_aware_session_create(wifi_aware_h wifi_aware, wifi_aware_session_type_e session_type,
-               wifi_aware_session_h *session);
+int wifi_aware_session_create(wifi_aware_session_type_e session_type, wifi_aware_session_h *session);
 
 /**
  * @brief
  * @since_tizen 6.0
- * @param[in] wifi_aware
  * @param[in] session
  * @return     0 on success, otherwise a negative error value
  * @retval     #WIFI_AWARE_ERROR_NONE
@@ -609,8 +594,7 @@ int wifi_aware_unset_message_received_cb(wifi_aware_session_h session);
 /*
 typedef void(*wifi_aware_changed_mac_address_cb)(unsigned char *mac, size_t len);
 
-int wifi_aware_set_changed_mac_address_cb(wifi_aware_h wifi_aware,
-               wifi_aware_changed_mac_address_cb callback);
+int wifi_aware_set_changed_mac_address_cb(wifi_aware_changed_mac_address_cb callback);
 */
 
 /**

diff --git a/src/include/wifi-aware-gdbus.h b/src/include/wifi-aware-gdbus.h
index 101fd0f..8f1bd57 100644 (file)
--- a/src/include/wifi-aware-gdbus.h
+++ b/src/include/wifi-aware-gdbus.h
@@ -57,9 +57,8 @@ guint wifi_aware_gdbus_register_signal(wifi_aware_signal_e signal,
                GDBusSignalCallback callback, void *user_data);
 void wifi_aware_gdbus_deregister_signal(guint signal_id);
 
-int wifi_aware_gdbus_enable(wifi_aware_h wifi_aware,
-               wifi_aware_enable_request_s *req, GAsyncReadyCallback cb);
-int wifi_aware_gdbus_disable(wifi_aware_h wifi_aware, int client_id);
+int wifi_aware_gdbus_enable(wifi_aware_enable_request_s *req, GAsyncReadyCallback cb);
+int wifi_aware_gdbus_disable(int client_id);
 int wifi_aware_gdbus_publish(wifi_aware_session_h session,
                wifi_aware_publish_h publish, int client_id, GAsyncReadyCallback cb);
 int wifi_aware_gdbus_cancel_publish(wifi_aware_session_h session, int client_id);

diff --git a/src/include/wifi-aware-peer.h b/src/include/wifi-aware-peer.h
index 4a8563e..34c3ccf 100644 (file)
--- a/src/include/wifi-aware-peer.h
+++ b/src/include/wifi-aware-peer.h
@@ -26,10 +26,9 @@ extern "C" {
 #endif
 
 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_get_peer(wifi_aware_h wifi_aware, unsigned int peer_id);
-int _wifi_aware_peer_get_client_id(wifi_aware_peer_h peer);
+int _wifi_aware_peer_add(GHashTable *peer_map, wifi_aware_peer_h peer);
+int _wifi_aware_peer_remove(GHashTable *peer_map, wifi_aware_peer_h peer);
+wifi_aware_peer_h _wifi_aware_get_peer(GHashTable *peer_map, unsigned int peer_id);
 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 738dc4a..b428695 100644 (file)
--- a/src/include/wifi-aware-private.h
+++ b/src/include/wifi-aware-private.h
@@ -27,28 +27,16 @@
 extern "C" {
 #endif
 
-// TODO
-#define WIFI_AWARE_HANDLE_LOCK
-#define WIFI_AWARE_HANDLE_UNLOCK
-
-typedef struct {
-       int client_id;
-       wifi_aware_enabled_cb enabled_cb;
-       void *enabled_cb_data;
-       GHashTable *peer_map;
-} wifi_aware_s;
-
 const char *_wifi_aware_convert_error_type_to_string(wifi_aware_error_e err);
 
-int _wifi_aware_handle_create(wifi_aware_h *wifi_aware);
+bool _wifi_aware_is_initialized();
 int _wifi_aware_init();
-void _add_enabled_callback(wifi_aware_h wifi_aware, wifi_aware_enabled_cb callback, void *user_data);
-int _wifi_aware_enable_request(wifi_aware_h wifi_aware);
-int _wifi_aware_is_enabled(wifi_aware_h wifi_aware);
-int _wifi_aware_disable_request(wifi_aware_h wifi_aware);
+void _add_enabled_callback(wifi_aware_enabled_cb callback, void *user_data);
+int _wifi_aware_enable_request();
+int _wifi_aware_is_enabled();
+int _wifi_aware_disable_request();
 
-int _wifi_aware_session_handle_create(wifi_aware_h wifi_aware,
-               wifi_aware_session_type_e session_type, wifi_aware_session_h *session_handle);
+int _wifi_aware_session_handle_create(wifi_aware_session_type_e session_type, wifi_aware_session_h *session_handle);
 int _wifi_aware_session_handle_destroy(wifi_aware_session_h session_handle);
 
 int _wifi_aware_publish_handle_create(wifi_aware_publish_h *publish);

diff --git a/src/wifi-aware-gdbus.c b/src/wifi-aware-gdbus.c
index 9851f66..2f8e985 100644 (file)
--- a/src/wifi-aware-gdbus.c
+++ b/src/wifi-aware-gdbus.c
@@ -82,7 +82,7 @@ void wifi_aware_gdbus_deregister_signal(guint signal_id)
        g_dbus_connection_signal_unsubscribe(gdbus_data.connection, signal_id);
 }
 
-int wifi_aware_gdbus_init(wifi_aware_h wifi_aware)
+int wifi_aware_gdbus_init()
 {
        GError *error = NULL;
 
@@ -364,8 +364,7 @@ static GVariant *__create_followup_request_param(int client_id, unsigned int pee
        return params;
 }
 
-int wifi_aware_gdbus_enable(wifi_aware_h wifi_aware,
-               wifi_aware_enable_request_s *req, GAsyncReadyCallback cb)
+int wifi_aware_gdbus_enable(wifi_aware_enable_request_s *req, GAsyncReadyCallback cb)
 {
        __WIFI_AWARE_FUNC_ENTER__;
        GVariant *params = NULL;
@@ -380,7 +379,7 @@ int wifi_aware_gdbus_enable(wifi_aware_h wifi_aware,
        ret = __wifi_aware_dbus_method_call_async(
                WIFI_AWARE_DISCOVERY_INTERFACE,
                WIFI_AWARE_DISCOVERY_PATH,
-               "Enable", params, cb, wifi_aware);
+               "Enable", params, cb, NULL);
 
        if (ret != WIFI_AWARE_ERROR_NONE) {
                WIFI_AWARE_LOGE("wifi_aware_dbus_method_call_async() failed");
@@ -402,7 +401,7 @@ static int __handle_disable_reply(GVariant *reply)
        return error;
 }
 
-int wifi_aware_gdbus_disable(wifi_aware_h wifi_aware, int client_id)
+int wifi_aware_gdbus_disable(int client_id)
 {
        __WIFI_AWARE_FUNC_ENTER__;
        int ret = WIFI_AWARE_ERROR_NONE;

diff --git a/src/wifi-aware-peer.c b/src/wifi-aware-peer.c
index cffc3be..8658a83 100644 (file)
--- a/src/wifi-aware-peer.c
+++ b/src/wifi-aware-peer.c
@@ -25,46 +25,33 @@
 
 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)
 {
        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;
 }
 
-int _wifi_aware_peer_add(wifi_aware_h wifi_aware, wifi_aware_peer_h peer)
+int _wifi_aware_peer_add(GHashTable *peer_map, wifi_aware_peer_h peer)
 {
-       wifi_aware_s *aware_handle = (wifi_aware_s *)wifi_aware;
-       GHashTable *peer_map = aware_handle->peer_map;
        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);
-               WIFI_AWARE_HANDLE_UNLOCK;
                return WIFI_AWARE_ERROR_INVALID_PARAMETER;
        }
-       WIFI_AWARE_HANDLE_UNLOCK;
 
-       WIFI_AWARE_HANDLE_LOCK;
        g_hash_table_insert(peer_map, GINT_TO_POINTER(peer_handle->id), peer);
-       WIFI_AWARE_HANDLE_UNLOCK;
-       // Check peer_id validation
+
        return WIFI_AWARE_ERROR_NONE;
 }
 
-int _wifi_aware_peer_remove(wifi_aware_h wifi_aware, wifi_aware_peer_h peer)
+int _wifi_aware_peer_remove(GHashTable *peer_map, wifi_aware_peer_h peer)
 {
-       wifi_aware_s *aware_handle = (wifi_aware_s *)wifi_aware;
-       GHashTable *peer_map = aware_handle->peer_map;
        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");
 
@@ -73,32 +60,21 @@ int _wifi_aware_peer_remove(wifi_aware_h wifi_aware, wifi_aware_peer_h peer)
                return WIFI_AWARE_ERROR_INVALID_PARAMETER;
        }
 
-       WIFI_AWARE_HANDLE_LOCK;
        if (!g_hash_table_remove(peer_map, GINT_TO_POINTER(peer_handle->id))) {
                WIFI_AWARE_LOGE("peer %d doesn't exist", peer_handle->id);
        }
-       WIFI_AWARE_HANDLE_UNLOCK;
 
        return WIFI_AWARE_ERROR_NONE;
 }
 
-wifi_aware_peer_h _wifi_aware_get_peer(wifi_aware_h wifi_aware, unsigned int peer_id)
+wifi_aware_peer_h _wifi_aware_get_peer(GHashTable *peer_map, unsigned int peer_id)
 {
-       wifi_aware_s *aware_handle = (wifi_aware_s *)wifi_aware;
-       GHashTable *peer_map = aware_handle->peer_map;
        wifi_aware_peer_s *peer = NULL;
 
-       WIFI_AWARE_HANDLE_LOCK;
        peer = g_hash_table_lookup(peer_map, GINT_TO_POINTER(peer_id));
-       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;

diff --git a/src/wifi-aware-private.c b/src/wifi-aware-private.c
index 47d5b7f..5788bb3 100644 (file)
--- a/src/wifi-aware-private.c
+++ b/src/wifi-aware-private.c
@@ -54,6 +54,13 @@ enum {
 } nan_manager_error_e;
 
 typedef struct {
+       int client_id;
+       wifi_aware_enabled_cb enabled_cb;
+       void *enabled_cb_data;
+       GHashTable *peer_map;
+} wifi_aware_s;
+
+typedef struct {
     uint32_t publish_id;
     wifi_aware_publish_request_s req;
 } wifi_aware_publish_s;
@@ -64,7 +71,6 @@ typedef struct {
 } wifi_aware_subscribe_s;
 
 typedef struct {
-       wifi_aware_s *wifi_aware_handle;
        wifi_aware_session_type_e session_type;
        wifi_aware_publish_s *publish_config;
        wifi_aware_subscribe_s *subscribe_config;
@@ -95,7 +101,7 @@ typedef struct {
 } wifi_aware_message_s;
 
 static bool __is_init = false;
-static GList *__wifi_aware_handle_list = NULL;
+static wifi_aware_s *g_wifi_aware = NULL;
 
 const char *_wifi_aware_convert_error_type_to_string(wifi_aware_error_e err)
 {
@@ -174,12 +180,6 @@ wifi_aware_error_e _wifi_aware_convert_nan_manager_error(int error)
        }
 }
 
-bool _wifi_aware_handle_is_valid(wifi_aware_h wifi_aware)
-{
-       // TODO
-       return true;
-}
-
 static void __session_set_requested(wifi_aware_session_h session_handle, bool requested)
 {
        wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle;
@@ -192,10 +192,9 @@ static bool __session_is_requested(wifi_aware_session_h session_handle)
        return session->is_requested;
 }
 
-static int __session_get_client_id(wifi_aware_session_h session_handle)
+static int __get_client_id()
 {
-       wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle;
-       return session->wifi_aware_handle->client_id;
+       return g_wifi_aware->client_id;
 }
 
 static int __is_publish_session(wifi_aware_session_h session_handle)
@@ -210,12 +209,6 @@ static int __is_subscribe_session(wifi_aware_session_h session_handle)
        return session->session_type == WIFI_AWARE_SESSION_SUBSCRIBE;
 }
 
-static wifi_aware_s *__session_get_wifi_aware(wifi_aware_session_h session_handle)
-{
-       wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle;
-       return session->wifi_aware_handle;
-}
-
 static wifi_aware_publish_s *__session_get_publish_config(wifi_aware_session_h session_handle)
 {
        wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle;
@@ -239,7 +232,6 @@ static void __enable_request_reply(GObject *src, GAsyncResult *res, gpointer use
        GDBusConnection *conn = NULL;
        GError *dbus_error = NULL;
        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;
 
@@ -253,13 +245,13 @@ static void __enable_request_reply(GObject *src, GAsyncResult *res, gpointer use
                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);
+               g_variant_get(reply, "(ii)", &g_wifi_aware->client_id, &nan_error);
+               WIFI_AWARE_LOGI("Client ID: %i, error: %d", g_wifi_aware->client_id, nan_error);
                error = _wifi_aware_convert_nan_manager_error(nan_error);
        }
        
-       if (aware->enabled_cb)
-               aware->enabled_cb(error, aware->enabled_cb_data);
+       if (g_wifi_aware->enabled_cb)
+               g_wifi_aware->enabled_cb(error, g_wifi_aware->enabled_cb_data);
 }
 
 static void __session_add_published_callback(wifi_aware_session_h session,
@@ -427,25 +419,25 @@ unsigned int _wifi_aware_session_get_subscribe_id(wifi_aware_session_h session)
        return __session_get_subscribe_config(session)->subscribe_id;
 }
 
-int _wifi_aware_handle_create(wifi_aware_h *wifi_aware)
+static int __wifi_aware_create()
 {
-       wifi_aware_s *aware = (wifi_aware_s *)g_try_malloc0(sizeof(wifi_aware_s));
-       if (aware == NULL) {
+       g_wifi_aware = (wifi_aware_s *)g_try_malloc0(sizeof(wifi_aware_s));
+       if (g_wifi_aware == NULL) {
                WIFI_AWARE_LOGE("g_try_malloc0 failed");
                return WIFI_AWARE_ERROR_OUT_OF_MEMORY;
        }
 
-       aware->peer_map = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_free);
-       WIFI_AWARE_HANDLE_LOCK;
-       __wifi_aware_handle_list = g_list_append(__wifi_aware_handle_list, aware);
-       WIFI_AWARE_HANDLE_UNLOCK;
+       g_wifi_aware->peer_map = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_free);
 
-       *wifi_aware = aware;
-
-       WIFI_AWARE_LOGI("Crate new handle [%p]", *wifi_aware);
+       WIFI_AWARE_LOGI("Create wifi_aware_s [%p]", g_wifi_aware);
        return WIFI_AWARE_ERROR_NONE;
 }
 
+bool _wifi_aware_is_initialized()
+{
+       return __is_init;
+}
+
 int _wifi_aware_init()
 {
        int ret = WIFI_AWARE_ERROR_NONE;
@@ -454,6 +446,10 @@ int _wifi_aware_init()
                WIFI_AWARE_LOGE("Already initialized");
                return WIFI_AWARE_ERROR_ALREADY_INITIALIZED;
        }
+
+       ret = __wifi_aware_create();
+       RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "__wifi_aware_create() failed");
+
        ret = wifi_aware_gdbus_init();
        RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_gdbus_init() failed");
 
@@ -462,12 +458,10 @@ int _wifi_aware_init()
        return WIFI_AWARE_ERROR_NONE;
 }
 
-void _add_enabled_callback(wifi_aware_h wifi_aware,
-               wifi_aware_enabled_cb callback, void *user_data)
+void _add_enabled_callback(wifi_aware_enabled_cb callback, void *user_data)
 {
-       wifi_aware_s *aware = (wifi_aware_s *)wifi_aware;
-       aware->enabled_cb = callback;
-       aware->enabled_cb_data = user_data;
+       g_wifi_aware->enabled_cb = callback;
+       g_wifi_aware->enabled_cb_data = user_data;
 }
 
 static void __wifi_aware_enable_request_set_default_values(wifi_aware_enable_request_s *req)
@@ -480,7 +474,7 @@ static void __wifi_aware_enable_request_set_default_values(wifi_aware_enable_req
        req->discovery_window_interval_5g = 0;
 }
 
-int _wifi_aware_enable_request(wifi_aware_h wifi_aware)
+int _wifi_aware_enable_request()
 {
        wifi_aware_enable_request_s *req =
                (wifi_aware_enable_request_s *)g_try_malloc0(sizeof(wifi_aware_enable_request_s));
@@ -488,30 +482,27 @@ int _wifi_aware_enable_request(wifi_aware_h wifi_aware)
 
        __wifi_aware_enable_request_set_default_values(req);
 
-       return wifi_aware_gdbus_enable(wifi_aware, req, __enable_request_reply);
+       return wifi_aware_gdbus_enable(req, __enable_request_reply);
 }
 
-int _wifi_aware_is_enabled(wifi_aware_h wifi_aware)
+int _wifi_aware_is_enabled()
 {
-       wifi_aware_s *aware = (wifi_aware_s *)wifi_aware;
-       return (aware->client_id >= 0 ? 1 : 0);
+       return (g_wifi_aware->client_id >= 0 ? 1 : 0);
 }
 
-int _wifi_aware_disable_request(wifi_aware_h wifi_aware)
+int _wifi_aware_disable_request()
 {
-       wifi_aware_s *aware = (wifi_aware_s *)wifi_aware;
-       return wifi_aware_gdbus_disable(wifi_aware, aware->client_id);
+       return wifi_aware_gdbus_disable(g_wifi_aware->client_id);
 }
 
-int _wifi_aware_session_handle_create(wifi_aware_h wifi_aware,
-               wifi_aware_session_type_e session_type, wifi_aware_session_h *session_handle)
+int _wifi_aware_session_handle_create(wifi_aware_session_type_e session_type,
+               wifi_aware_session_h *session_handle)
 {
        wifi_aware_session_s *session =
                (wifi_aware_session_s *)g_try_malloc0(sizeof(wifi_aware_session_s));
        RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_OUT_OF_MEMORY, "Out of memory");
 
        *session_handle = (wifi_aware_session_h)session;
-       session->wifi_aware_handle = wifi_aware;
        session->session_type = session_type;
 
        return WIFI_AWARE_ERROR_NONE;
@@ -630,7 +621,7 @@ int _wifi_aware_publish_request(wifi_aware_session_h session,
        __session_set_requested(session, true);
 
        ret = wifi_aware_gdbus_publish(session, publish,
-                       __session_get_client_id(session),
+                       __get_client_id(),
                        __publish_request_reply);
 
        if (ret != WIFI_AWARE_ERROR_NONE) {
@@ -661,7 +652,7 @@ int _wifi_aware_update_publish_request(wifi_aware_session_h session,
        __session_set_requested(session, true);
 
        ret = wifi_aware_gdbus_update_publish(session,  publish,
-                       __session_get_client_id(session),
+                       __get_client_id(),
                        __publish_request_reply);
 
        if (ret != WIFI_AWARE_ERROR_NONE) {
@@ -767,7 +758,7 @@ int _wifi_aware_subscribe_request(wifi_aware_session_h session,
        __session_set_requested(session, true);
 
        ret = wifi_aware_gdbus_subscribe(session, subscribe,
-                       __session_get_client_id(session),
+                       __get_client_id(),
                        __subscribe_request_reply);
 
        if (ret != WIFI_AWARE_ERROR_NONE) {
@@ -799,7 +790,7 @@ int _wifi_aware_update_subscribe_request(wifi_aware_session_h session,
        int ret = WIFI_AWARE_ERROR_NONE;
 
        ret = wifi_aware_gdbus_update_subscribe(session, subscribe,
-                       __session_get_client_id(session),
+                       __get_client_id(),
                        __subscribe_request_reply);
 
        if (ret != WIFI_AWARE_ERROR_NONE) {
@@ -820,7 +811,7 @@ static int __wifi_aware_cancel_publish_request(wifi_aware_session_h session)
                        "The publish is not done yet");
 
        __session_deregister_signals(session);
-       return wifi_aware_gdbus_cancel_publish(session, __session_get_client_id(session));
+       return wifi_aware_gdbus_cancel_publish(session, __get_client_id());
 }
 
 static int __wifi_aware_cancel_subscribe_request(wifi_aware_session_h session)
@@ -834,7 +825,7 @@ static int __wifi_aware_cancel_subscribe_request(wifi_aware_session_h session)
 
        __session_deregister_signals(session);
        return wifi_aware_gdbus_cancel_subscribe(session,
-                       __session_get_client_id(session));
+                       __get_client_id());
 }
 
 int _wifi_aware_session_cancel(wifi_aware_session_h session)
@@ -878,11 +869,11 @@ static void __parsing_message_received_event(GVariant *parameters, unsigned int
        g_free(value);
 }
 
-static int __get_peer_handle(wifi_aware_s *aware_handle, unsigned int peer_id, wifi_aware_peer_h *peer)
+static int __get_peer_handle(unsigned int peer_id, wifi_aware_peer_h *peer)
 {
        __WIFI_AWARE_FUNC_ENTER__;
        int ret = WIFI_AWARE_ERROR_NONE;
-       *peer = _wifi_aware_get_peer(aware_handle, peer_id);
+       *peer = _wifi_aware_get_peer(g_wifi_aware->peer_map, peer_id);
        if (*peer != NULL) {
                WIFI_AWARE_LOGI("Peer %u already exists", peer_id);
                return WIFI_AWARE_ERROR_NONE;
@@ -891,7 +882,7 @@ static int __get_peer_handle(wifi_aware_s *aware_handle, unsigned int peer_id, w
        ret = _wifi_aware_peer_create(peer, peer_id);
        RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Fail to create peer");
 
-       ret = _wifi_aware_peer_add(aware_handle, *peer);
+       ret = _wifi_aware_peer_add(g_wifi_aware->peer_map, *peer);
        RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Fail to add peer");
 
        return ret;
@@ -927,8 +918,7 @@ static void __service_discovered_cb(GDBusConnection *connection,
        }
 
        WIFI_AWARE_LOGD("subscribe ID: %u, Peer ID: %u", sub_id, peer_id);
-       if (__get_peer_handle(__session_get_wifi_aware(session),
-                               peer_id, &peer) != WIFI_AWARE_ERROR_NONE) {
+       if (__get_peer_handle(peer_id, &peer) != WIFI_AWARE_ERROR_NONE) {
                WIFI_AWARE_LOGE("Invalid peer %u", peer_id);
                return;
        }
@@ -957,8 +947,7 @@ static void __message_received_cb(GDBusConnection *connection,
                        message, &message_len);
 
        WIFI_AWARE_LOGD("Peer ID: %u", peer_id);
-       if (__get_peer_handle(__session_get_wifi_aware(session),
-                               peer_id, &peer) != WIFI_AWARE_ERROR_NONE) {
+       if (__get_peer_handle(peer_id, &peer) != WIFI_AWARE_ERROR_NONE) {
                WIFI_AWARE_LOGE("Invalid peer %u", peer_id);
                return;
        }
@@ -1083,7 +1072,7 @@ int _wifi_aware_send_message(wifi_aware_session_h session,
        RET_VAL_IF(message == NULL, WIFI_AWARE_ERROR_OUT_OF_MEMORY, "__create_cb_data fails");
        return wifi_aware_gdbus_followup(
                        session,
-                       __session_get_client_id(session),
+                       __get_client_id(),
                        _wifi_aware_peer_get_id(peer),
                        message, len,
                        __send_message_reply,

diff --git a/src/wifi-aware.c b/src/wifi-aware.c
index ff725c6..35eb41d 100644 (file)
--- a/src/wifi-aware.c
+++ b/src/wifi-aware.c
@@ -34,20 +34,13 @@
 #include "wifi-aware-utils.h"
 
 
-API int wifi_aware_initialize(wifi_aware_h *wifi_aware)
+API int wifi_aware_initialize()
 {
        int ret = WIFI_AWARE_ERROR_NONE;
 
        __WIFI_AWARE_FUNC_ENTER__;
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
 
-       RET_VAL_IF(wifi_aware == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER,
-                       "parameter(wifi_aware) is NULL");
-
-       ret = _wifi_aware_handle_create(wifi_aware);
-       RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "_wifi_aware_handle_create failed [%s]",
-                       _wifi_aware_convert_error_type_to_string(ret));
-
        ret = _wifi_aware_init();
        RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "_wifi_aware_init failed [%s]",
                        _wifi_aware_convert_error_type_to_string(ret));
@@ -56,10 +49,11 @@ API int wifi_aware_initialize(wifi_aware_h *wifi_aware)
        return WIFI_AWARE_ERROR_NONE;
 }
 
-API int wifi_aware_deinitialize(wifi_aware_h wifi_aware)
+API int wifi_aware_deinitialize()
 {
        __WIFI_AWARE_FUNC_ENTER__;
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+       RET_VAL_IF(!_wifi_aware_is_initialized(), WIFI_AWARE_ERROR_NOT_INITIALIZED, "Not initialized");
 
        // TODO
 
@@ -67,50 +61,51 @@ API int wifi_aware_deinitialize(wifi_aware_h wifi_aware)
        return WIFI_AWARE_ERROR_NONE;
 }
 
-API int wifi_aware_enable(wifi_aware_h wifi_aware,
-               wifi_aware_enabled_cb callback, void *user_data)
+API int wifi_aware_enable(wifi_aware_enabled_cb callback, void *user_data)
 {
        int ret = WIFI_AWARE_ERROR_NONE;
 
        __WIFI_AWARE_FUNC_ENTER__;
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+       RET_VAL_IF(!_wifi_aware_is_initialized(), WIFI_AWARE_ERROR_NOT_INITIALIZED, "Not initialized");
 
-       _add_enabled_callback(wifi_aware, callback, user_data);
+       _add_enabled_callback(callback, user_data);
 
-       ret = _wifi_aware_enable_request(wifi_aware);
+       ret = _wifi_aware_enable_request();
        RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "_wifi_aware_enable_request");
 
        __WIFI_AWARE_FUNC_EXIT__;
        return WIFI_AWARE_ERROR_NONE;
 }
 
-API int wifi_aware_disable(wifi_aware_h wifi_aware)
+API int wifi_aware_disable()
 {
        int ret = WIFI_AWARE_ERROR_NONE;
 
        __WIFI_AWARE_FUNC_ENTER__;
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+       RET_VAL_IF(!_wifi_aware_is_initialized(), WIFI_AWARE_ERROR_NOT_INITIALIZED, "Not initialized");
 
-       RET_VAL_IF(_wifi_aware_is_enabled(wifi_aware) == 0,
+       RET_VAL_IF(_wifi_aware_is_enabled() == 0,
                        WIFI_AWARE_ERROR_INVALID_OPERATION,
                        "_wifi_aware_is_enabled");
 
-       ret = _wifi_aware_disable_request(wifi_aware);
+       ret = _wifi_aware_disable_request();
        RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "_wifi_aware_disable_request");
 
        __WIFI_AWARE_FUNC_EXIT__;
        return WIFI_AWARE_ERROR_NONE;
 }
 
-API int wifi_aware_session_create(wifi_aware_h wifi_aware,
-               wifi_aware_session_type_e session_type, wifi_aware_session_h *session)
+API int wifi_aware_session_create(wifi_aware_session_type_e session_type, wifi_aware_session_h *session)
 {
        int ret = WIFI_AWARE_ERROR_NONE;
 
        __WIFI_AWARE_FUNC_ENTER__;
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+       RET_VAL_IF(!_wifi_aware_is_initialized(), WIFI_AWARE_ERROR_NOT_INITIALIZED, "Not initialized");
 
-       ret = _wifi_aware_session_handle_create(wifi_aware, session_type, session);
+       ret = _wifi_aware_session_handle_create(session_type, session);
        RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Fail to create session handle");
        WIFI_AWARE_LOGD("session handle: %p", *session);
        WIFI_AWARE_LOGD("session type: %d", session_type);
@@ -125,6 +120,8 @@ API int wifi_aware_session_destroy(wifi_aware_session_h session)
 
        __WIFI_AWARE_FUNC_ENTER__;
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+       RET_VAL_IF(!_wifi_aware_is_initialized(), WIFI_AWARE_ERROR_NOT_INITIALIZED, "Not initialized");
+       RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
 
        ret = _wifi_aware_session_handle_destroy(session);
        RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Fail to destroy session handle");
@@ -278,6 +275,7 @@ API int wifi_aware_session_publish(wifi_aware_session_h session,
        int ret = WIFI_AWARE_ERROR_NONE;
 
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+       RET_VAL_IF(!_wifi_aware_is_initialized(), WIFI_AWARE_ERROR_NOT_INITIALIZED, "Not initialized");
        RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
        RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
 
@@ -296,6 +294,7 @@ API int wifi_aware_session_update_publish(wifi_aware_session_h session,
        int ret = WIFI_AWARE_ERROR_NONE;
 
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+       RET_VAL_IF(!_wifi_aware_is_initialized(), WIFI_AWARE_ERROR_NOT_INITIALIZED, "Not initialized");
        RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
        RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
 
@@ -446,6 +445,7 @@ API int wifi_aware_session_subscribe(wifi_aware_session_h session,
        int ret = WIFI_AWARE_ERROR_NONE;
 
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+       RET_VAL_IF(!_wifi_aware_is_initialized(), WIFI_AWARE_ERROR_NOT_INITIALIZED, "Not initialized");
        RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
        RET_VAL_IF(subscribe == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_h is NULL");
 
@@ -462,6 +462,7 @@ API int wifi_aware_session_stop(wifi_aware_session_h session)
        int ret = WIFI_AWARE_ERROR_NONE;
 
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+       RET_VAL_IF(!_wifi_aware_is_initialized(), WIFI_AWARE_ERROR_NOT_INITIALIZED, "Not initialized");
        RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
 
        ret = _wifi_aware_session_cancel(session);
@@ -479,6 +480,7 @@ API int wifi_aware_session_update_subscribe(wifi_aware_session_h session,
        int ret = WIFI_AWARE_ERROR_NONE;
 
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+       RET_VAL_IF(!_wifi_aware_is_initialized(), WIFI_AWARE_ERROR_NOT_INITIALIZED, "Not initialized");
        RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
        RET_VAL_IF(subscribe == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_h is NULL");
 
@@ -494,6 +496,7 @@ API int wifi_aware_set_service_discovered_cb(wifi_aware_session_h session,
 {
        __WIFI_AWARE_FUNC_ENTER__;
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+       RET_VAL_IF(!_wifi_aware_is_initialized(), WIFI_AWARE_ERROR_NOT_INITIALIZED, "Not initialized");
        RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
 
        _wifi_aware_set_service_discovered_cb(session, callback, user_data);
@@ -507,6 +510,7 @@ API int wifi_aware_unset_service_discovered_cb(wifi_aware_session_h session,
 {
        __WIFI_AWARE_FUNC_ENTER__;
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+       RET_VAL_IF(!_wifi_aware_is_initialized(), WIFI_AWARE_ERROR_NOT_INITIALIZED, "Not initialized");
        RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
 
        _wifi_aware_unset_service_discovered_cb(session);
@@ -522,6 +526,7 @@ API int wifi_aware_send_message(wifi_aware_session_h session,
 {
        __WIFI_AWARE_FUNC_ENTER__;
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+       RET_VAL_IF(!_wifi_aware_is_initialized(), WIFI_AWARE_ERROR_NOT_INITIALIZED, "Not initialized");
        RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
        RET_VAL_IF(peer == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER,
                        "wifi_aware_peer_h is NULL");
@@ -534,6 +539,7 @@ API int wifi_aware_set_message_received_cb(wifi_aware_session_h session,
 {
        __WIFI_AWARE_FUNC_ENTER__;
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+       RET_VAL_IF(!_wifi_aware_is_initialized(), WIFI_AWARE_ERROR_NOT_INITIALIZED, "Not initialized");
        RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
 
        _wifi_aware_set_message_received_cb(session, callback, user_data);
@@ -546,6 +552,7 @@ API int wifi_aware_unset_message_received_cb(wifi_aware_session_h session)
 {
        __WIFI_AWARE_FUNC_ENTER__;
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+       RET_VAL_IF(!_wifi_aware_is_initialized(), WIFI_AWARE_ERROR_NOT_INITIALIZED, "Not initialized");
        RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
 
        _wifi_aware_unset_message_received_cb(session);

diff --git a/test/wifi-aware-test.c b/test/wifi-aware-test.c
index 065d48f..6877b4b 100644 (file)
--- a/test/wifi-aware-test.c
+++ b/test/wifi-aware-test.c
@@ -73,14 +73,6 @@
                } \
        } while (0)
 
-#define RET_IF_HANDLE_IS_NULL()\
-       do {\
-               if (!g_wifi_aware_handle) {\
-                       printf("wifi-aware handle is not created yet\n");\
-                       return;\
-               }\
-       } while (0)
-
 #define RET_IF_SESSION_IS_NULL()\
        do {\
                if (!g_wifi_aware_session) {\
@@ -159,7 +151,6 @@ static char *g_menu_str[] = {
 };
 
 static GMainLoop *g_main_loop_p;
-static wifi_aware_h g_wifi_aware_handle = NULL;
 static wifi_aware_session_h g_wifi_aware_session = NULL;
 static wifi_aware_publish_h g_publish_handle = NULL;
 static wifi_aware_subscribe_h g_subscribe_handle = NULL;
@@ -250,6 +241,10 @@ const char *__print_error(wifi_aware_error_e err)
                return "NOT_SUPPORTED";
        case WIFI_AWARE_ERROR_OPERATION_FAILED:
                return "OPERATION_FAILED";
+       case WIFI_AWARE_ERROR_NOT_INITIALIZED:
+               return "NOT_INITIALIZED";
+       case WIFI_AWARE_ERROR_ALREADY_INITIALIZED:
+               return "ALREADY_INITIALIZED";
        default:
                return "UNKNOWN";
        }
@@ -308,7 +303,7 @@ void test_init()
 
        RET_IF_LOOP_IS_NULL();
 
-       ret = wifi_aware_initialize(&g_wifi_aware_handle);
+       ret = wifi_aware_initialize();
        __print_result(ret, "wifi_aware_initialize");
 }
 
@@ -317,9 +312,8 @@ void test_deinit()
        int ret = 0;
 
        RET_IF_LOOP_IS_NULL();
-       RET_IF_HANDLE_IS_NULL();
 
-       ret = wifi_aware_deinitialize(g_wifi_aware_handle);
+       ret = wifi_aware_deinitialize();
        __print_result(ret, "wifi_aware_deinitialize");
 }
 
@@ -337,9 +331,8 @@ void test_enable()
        int ret = 0;
 
        RET_IF_LOOP_IS_NULL();
-       RET_IF_HANDLE_IS_NULL();
 
-       ret = wifi_aware_enable(g_wifi_aware_handle, __enabled_cb, NULL);
+       ret = wifi_aware_enable(__enabled_cb, NULL);
        __print_result(ret, "wifi_aware_enable");
 }
 
@@ -348,9 +341,8 @@ void test_disable()
        int ret = 0;
 
        RET_IF_LOOP_IS_NULL();
-       RET_IF_HANDLE_IS_NULL();
 
-       ret = wifi_aware_disable(g_wifi_aware_handle);
+       ret = wifi_aware_disable();
        __print_result(ret, "wifi_aware_disable");
 }
 
@@ -460,9 +452,8 @@ void test_publish()
        int ret = 0;
 
        RET_IF_LOOP_IS_NULL();
-       RET_IF_HANDLE_IS_NULL();
 
-       ret = wifi_aware_session_create(g_wifi_aware_handle, WIFI_AWARE_SESSION_PUBLISH, &g_wifi_aware_session);
+       ret = wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_wifi_aware_session);
        RET_IF_SESSION_IS_NULL();
 
        ret = wifi_aware_publish_create(&g_publish_handle);
@@ -482,7 +473,6 @@ void test_cancel_publish()
        int ret = 0;
 
        RET_IF_LOOP_IS_NULL();
-       RET_IF_HANDLE_IS_NULL();
        RET_IF_SESSION_IS_NULL();
 
        if (g_publish_handle == NULL) {
@@ -510,7 +500,6 @@ void test_update_publish()
        size_t len = 0;
 
        RET_IF_LOOP_IS_NULL();
-       RET_IF_HANDLE_IS_NULL();
        RET_IF_SESSION_IS_NULL();
 
        if (g_publish_handle == NULL) {
@@ -602,9 +591,8 @@ void test_subscribe()
        int ret = 0;
 
        RET_IF_LOOP_IS_NULL();
-       RET_IF_HANDLE_IS_NULL();
 
-       ret = wifi_aware_session_create(g_wifi_aware_handle, WIFI_AWARE_SESSION_SUBSCRIBE, &g_wifi_aware_session);
+       ret = wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_wifi_aware_session);
        RET_IF_SESSION_IS_NULL();
 
        ret = wifi_aware_subscribe_create(&g_subscribe_handle);
@@ -627,7 +615,6 @@ void test_cancel_subscribe()
        int ret = 0;
 
        RET_IF_LOOP_IS_NULL();
-       RET_IF_HANDLE_IS_NULL();
        RET_IF_SESSION_IS_NULL();
 
        if (g_subscribe_handle == NULL) {
@@ -658,11 +645,9 @@ void test_specific_info()
        int ret = 0;
 
        RET_IF_LOOP_IS_NULL();
-       RET_IF_HANDLE_IS_NULL();
 
        for (int i = 0; i < sizeof(info_test_data) / sizeof(info_test_data[0]); ++i) {
-               ret = wifi_aware_session_create(g_wifi_aware_handle,
-                               WIFI_AWARE_SESSION_PUBLISH, &info_test_data[i].session);
+               ret = wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &info_test_data[i].session);
                __print_result(ret, "wifi_aware_session_create");
 
                ret = wifi_aware_publish_create(&info_test_data[i].handle);