Remove useless struct

diff --git a/src/include/wifi-aware-private.h b/src/include/wifi-aware-private.h
index 12ed62b..3a85dd4 100644 (file)
--- a/src/include/wifi-aware-private.h
+++ b/src/include/wifi-aware-private.h
@@ -44,7 +44,7 @@ wifi_aware_session_type_e _wifi_aware_session_get_type(wifi_aware_session_h sess
 uint16_t _wifi_aware_session_get_pub_sub_id(wifi_aware_session_h session);
 
 int _wifi_aware_publish_handle_create(wifi_aware_publish_h *publish);
-void _wifi_aware_publish_request_set_default_values(wifi_aware_publish_h publish);
+void _wifi_aware_publish_set_default_values(wifi_aware_publish_h publish);
 void _wifi_aware_publish_set_ttl(wifi_aware_publish_h publish, unsigned short ttl);
 void _wifi_aware_publish_set_type(wifi_aware_publish_h publish,
                wifi_aware_publish_type_e publish_type);

diff --git a/src/wifi-aware-gdbus.c b/src/wifi-aware-gdbus.c
index 6908cf4..ebdd2e2 100644 (file)
--- a/src/wifi-aware-gdbus.c
+++ b/src/wifi-aware-gdbus.c
@@ -429,7 +429,7 @@ int wifi_aware_gdbus_publish(wifi_aware_session_h session, wifi_aware_publish_h
        __WIFI_AWARE_FUNC_ENTER__;
        GVariant *params = NULL;
        int ret = WIFI_AWARE_ERROR_NONE;
-       wifi_aware_publish_request_s *req = _wifi_aware_publish_get_request(publish);
+       wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)publish;
 
        params = __create_publish_request_param(client_id, req);
        DBUS_DEBUG_VARIANT(params);
@@ -491,7 +491,7 @@ int wifi_aware_gdbus_update_publish(wifi_aware_session_h session,
        __WIFI_AWARE_FUNC_ENTER__;
        GVariant *params = NULL;
        int ret = WIFI_AWARE_ERROR_NONE;
-       wifi_aware_publish_request_s *req = _wifi_aware_publish_get_request(publish);
+       wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)publish;
        uint16_t pub_id = _wifi_aware_session_get_publish_id(session);
 
        if (pub_id == 0) {
@@ -519,7 +519,7 @@ int wifi_aware_gdbus_subscribe(wifi_aware_session_h session,
        __WIFI_AWARE_FUNC_ENTER__;
        GVariant *params = NULL;
        int ret = WIFI_AWARE_ERROR_NONE;
-       wifi_aware_subscribe_request_s *req = _wifi_aware_subscribe_get_request(subscribe);
+       wifi_aware_subscribe_request_s *req = (wifi_aware_subscribe_request_s *)subscribe;
 
        params = __create_subscribe_request_param(client_id, req);
        DBUS_DEBUG_VARIANT(params);
@@ -581,7 +581,7 @@ int wifi_aware_gdbus_update_subscribe(wifi_aware_session_h session,
        __WIFI_AWARE_FUNC_ENTER__;
        GVariant *params = NULL;
        int ret = WIFI_AWARE_ERROR_NONE;
-       wifi_aware_subscribe_request_s *req = _wifi_aware_subscribe_get_request(subscribe);
+       wifi_aware_subscribe_request_s *req = (wifi_aware_subscribe_request_s *)subscribe;
        uint16_t sub_id = _wifi_aware_session_get_subscribe_id(session);
 
        if (sub_id == 0) {

diff --git a/src/wifi-aware-private.c b/src/wifi-aware-private.c
index f591df4..e6e4193 100644 (file)
--- a/src/wifi-aware-private.c
+++ b/src/wifi-aware-private.c
@@ -26,6 +26,7 @@
 
 #include <glib.h>
 
+#include "wifi-aware.h"
 #include "wifi-aware-gdbus.h"
 #include "wifi-aware-log.h"
 #include "wifi-aware-peer.h"
@@ -61,18 +62,10 @@ typedef struct {
 } wifi_aware_s;
 
 typedef struct {
-    wifi_aware_publish_request_s req;
-} wifi_aware_publish_s;
-
-typedef struct {
-    wifi_aware_subscribe_request_s req;
-} wifi_aware_subscribe_s;
-
-typedef struct {
        uint16_t pub_sub_id;
        wifi_aware_session_type_e session_type;
-       wifi_aware_publish_s *publish_config;
-       wifi_aware_subscribe_s *subscribe_config;
+    wifi_aware_publish_h publish_config;
+    wifi_aware_subscribe_h subscribe_config;
        bool is_requested;
 
        wifi_aware_published_cb published_cb;
@@ -212,12 +205,6 @@ static int __is_subscribe_session(wifi_aware_session_h session_handle)
        return session->session_type == WIFI_AWARE_SESSION_SUBSCRIBE;
 }
 
-static wifi_aware_subscribe_s *__session_get_subscribe_config(wifi_aware_session_h session_handle)
-{
-       wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle;
-       return session->subscribe_config;
-}
-
 static void __session_deregister_signals(wifi_aware_session_h session)
 {
        _wifi_aware_unset_service_discovered_cb(session);
@@ -367,14 +354,6 @@ static void __wifi_aware_subscribe_invoke_callback(wifi_aware_session_h session,
                handle->subscribed_cb(session, error, handle->subscribed_cb_data);
 }
 
-wifi_aware_subscribe_request_s *_wifi_aware_subscribe_get_request(wifi_aware_subscribe_h subscribe)
-{
-       RET_VAL_IF(subscribe == NULL, NULL, "wifi_aware_subscribe_h is NULL");
-
-       wifi_aware_subscribe_s *handle = (wifi_aware_subscribe_s *)subscribe;
-       return &(handle->req);
-}
-
 static void __subscribe_request_reply(GObject *src, GAsyncResult *res, gpointer user_data)
 {
        wifi_aware_session_h session = (wifi_aware_session_h)user_data;
@@ -536,89 +515,79 @@ void _wifi_aware_session_handle_destroy(wifi_aware_session_h session_handle)
 
 int _wifi_aware_publish_handle_create(wifi_aware_publish_h *publish)
 {
-       wifi_aware_publish_s *pub_handle =
-               (wifi_aware_publish_s *)g_try_malloc0(sizeof(wifi_aware_publish_s));
-       RET_VAL_IF(pub_handle == NULL, WIFI_AWARE_ERROR_OUT_OF_MEMORY, "Out of memory");
+       wifi_aware_publish_request_s *req =
+               (wifi_aware_publish_request_s *)g_try_malloc0(sizeof(wifi_aware_publish_request_s));
+       RET_VAL_IF(req == NULL, WIFI_AWARE_ERROR_OUT_OF_MEMORY, "Out of memory");
 
-       *publish = (wifi_aware_publish_h)pub_handle;
+       *publish = (wifi_aware_publish_h)req;
 
        return WIFI_AWARE_ERROR_NONE;
 }
 
-void _wifi_aware_publish_request_set_default_values(wifi_aware_publish_h publish)
+void _wifi_aware_publish_set_default_values(wifi_aware_publish_h publish)
 {
-    wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
-       handle->req.ttl = 0;
-       handle->req.publish_type = WIFI_AWARE_PUBLISH_TYPE_UNSOLICITED;
-       //memset(req->specific_info[WIFI_AWARE_MAX_SERVICE_SPECIFIC_INFO_LEN], 0, WIFI_AWARE_MAX_SERVICE_SPECIFIC_INFO_LEN);
-       handle->req.specific_info_len = 0;
-       //memset(req->match_filter[WIFI_AWARE_MAX_MATCH_FILTER_LEN], 0, WIFI_AWARE_MAX_MATCH_FILTER_LEN);
-       handle->req.match_filter_len = 0;
-       handle->req.enable_termination_event = false;
-       handle->req.enable_ranging = false;
+    wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)publish;
+       req->ttl = 0;
+       req->publish_type = WIFI_AWARE_PUBLISH_TYPE_UNSOLICITED;
+       req->specific_info_len = 0;
+       req->match_filter_len = 0;
+       req->enable_termination_event = false;
+       req->enable_ranging = false;
 }
 
 void _wifi_aware_publish_set_ttl(wifi_aware_publish_h publish, unsigned short ttl)
 {
-       wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
-       handle->req.ttl = ttl;
+       wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)publish;
+       req->ttl = ttl;
 }
 
 void _wifi_aware_publish_set_type(wifi_aware_publish_h publish,
                wifi_aware_publish_type_e publish_type)
 {
-       wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
-       handle->req.publish_type = publish_type;
+       wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)publish;
+       req->publish_type = publish_type;
 
 }
 
 void _wifi_aware_publish_set_service_name(wifi_aware_publish_h publish, const char *service_name)
 {
-       wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
-       strncpy(handle->req.service_name, service_name, WIFI_AWARE_MAX_SERVICE_NAME_LEN);
+       wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)publish;
+       strncpy(req->service_name, service_name, WIFI_AWARE_MAX_SERVICE_NAME_LEN);
 }
 
 void _wifi_aware_publish_set_service_specific_info(wifi_aware_publish_h publish,
                unsigned char *service_specific_info, size_t len)
 {
-       wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
-       memcpy(handle->req.specific_info, service_specific_info, len);
-       handle->req.specific_info_len = len;
+       wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)publish;
+       memcpy(req->specific_info, service_specific_info, len);
+       req->specific_info_len = len;
 }
 
 void _wifi_aware_publish_set_match_filter(wifi_aware_publish_h publish,
                unsigned char *match_filter, size_t len)
 {
-       wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
-       memcpy(handle->req.match_filter, match_filter, len);
-       handle->req.match_filter_len = len;
+       wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)publish;
+       memcpy(req->match_filter, match_filter, len);
+       req->match_filter_len = len;
 }
 
 void _wifi_aware_publish_set_enable_termination_event(wifi_aware_publish_h publish, bool enable)
 {
-       wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
-       handle->req.enable_termination_event = enable;
+       wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)publish;
+       req->enable_termination_event = enable;
 }
 
 void _wifi_aware_publish_set_enable_ranging(wifi_aware_publish_h publish, bool enable)
 {
-       wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
-       handle->req.enable_ranging = enable;
-}
-
-wifi_aware_publish_request_s *_wifi_aware_publish_get_request(wifi_aware_publish_h publish)
-{
-       RET_VAL_IF(publish == NULL, NULL, "wifi_aware_publish_h is NULL");
-
-       wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
-       return &(handle->req);
+       wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)publish;
+       req->enable_ranging = enable;
 }
 
 static void __session_set_publish_config(wifi_aware_session_h session_handle,
                wifi_aware_publish_h publish)
 {
        wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle;
-       session->publish_config = (wifi_aware_publish_s *)publish;
+       session->publish_config = publish;
 }
 
 int _wifi_aware_publish_request(wifi_aware_session_h session,
@@ -684,11 +653,11 @@ int _wifi_aware_update_publish_request(wifi_aware_session_h session,
 
 int _wifi_aware_subscribe_handle_create(wifi_aware_subscribe_h *subscribe)
 {
-       wifi_aware_subscribe_s *sub_handle =
-               (wifi_aware_subscribe_s *)g_try_malloc0(sizeof(wifi_aware_subscribe_s));
-       RET_VAL_IF(sub_handle == NULL, WIFI_AWARE_ERROR_OUT_OF_MEMORY, "Out of memory");
+       wifi_aware_subscribe_request_s *req =
+               (wifi_aware_subscribe_request_s *)g_try_malloc0(sizeof(wifi_aware_subscribe_request_s));
+       RET_VAL_IF(req == NULL, WIFI_AWARE_ERROR_OUT_OF_MEMORY, "Out of memory");
 
-       *subscribe = (wifi_aware_subscribe_h)sub_handle;
+       *subscribe = (wifi_aware_subscribe_h)req;
 
        return WIFI_AWARE_ERROR_NONE;
 }
@@ -696,64 +665,64 @@ int _wifi_aware_subscribe_handle_create(wifi_aware_subscribe_h *subscribe)
 void _wifi_aware_subscribe_set_default_values(
                wifi_aware_subscribe_h subscribe)
 {
-    wifi_aware_subscribe_s *handle = (wifi_aware_subscribe_s *)subscribe;
-       handle->req.ttl = 0;
-       handle->req.subscribe_type = WIFI_AWARE_SUBSCRIBE_TYPE_PASSIVE;
+    wifi_aware_subscribe_request_s *req = (wifi_aware_subscribe_request_s *)subscribe;
+       req->ttl = 0;
+       req->subscribe_type = WIFI_AWARE_SUBSCRIBE_TYPE_PASSIVE;
        //memset(req->specific_info[WIFI_AWARE_MAX_SERVICE_SPECIFIC_INFO_LEN], 0, WIFI_AWARE_MAX_SERVICE_SPECIFIC_INFO_LEN);
-       handle->req.specific_info_len = 0;
+       req->specific_info_len = 0;
        //memset(req->match_filter[WIFI_AWARE_MAX_MATCH_FILTER_LEN], 0, WIFI_AWARE_MAX_MATCH_FILTER_LEN);
-       handle->req.match_filter_len = 0;
-       handle->req.enable_termination_event = false;
+       req->match_filter_len = 0;
+       req->enable_termination_event = false;
 }
 
 void _wifi_aware_subscribe_set_ttl(wifi_aware_subscribe_h subscribe, unsigned short ttl)
 {
-       wifi_aware_subscribe_s *handle = (wifi_aware_subscribe_s *)subscribe;
-       handle->req.ttl = ttl;
+       wifi_aware_subscribe_request_s *req = (wifi_aware_subscribe_request_s *)subscribe;
+       req->ttl = ttl;
 }
 
 void _wifi_aware_subscribe_set_type(wifi_aware_subscribe_h subscribe,
                wifi_aware_subscribe_type_e subscribe_type)
 {
-       wifi_aware_subscribe_s *handle = (wifi_aware_subscribe_s *)subscribe;
-       handle->req.subscribe_type = subscribe_type;
+       wifi_aware_subscribe_request_s *req = (wifi_aware_subscribe_request_s *)subscribe;
+       req->subscribe_type = subscribe_type;
 
 }
 
 void _wifi_aware_subscribe_set_service_name(wifi_aware_subscribe_h subscribe, const char *service_name)
 {
-       wifi_aware_subscribe_s *handle = (wifi_aware_subscribe_s *)subscribe;
-       strncpy(handle->req.service_name, service_name, WIFI_AWARE_MAX_SERVICE_NAME_LEN);
+       wifi_aware_subscribe_request_s *req = (wifi_aware_subscribe_request_s *)subscribe;
+       strncpy(req->service_name, service_name, WIFI_AWARE_MAX_SERVICE_NAME_LEN);
 }
 
 void _wifi_aware_subscribe_set_service_specific_info(wifi_aware_subscribe_h subscribe,
                unsigned char *service_specific_info, size_t len)
 {
-       wifi_aware_subscribe_s *handle = (wifi_aware_subscribe_s *)subscribe;
-       memcpy(handle->req.specific_info, service_specific_info, len);
-       handle->req.specific_info_len = len;
+       wifi_aware_subscribe_request_s *req = (wifi_aware_subscribe_request_s *)subscribe;
+       memcpy(req->specific_info, service_specific_info, len);
+       req->specific_info_len = len;
 
 }
 
 void _wifi_aware_subscribe_set_match_filter(wifi_aware_subscribe_h subscribe,
                unsigned char *match_filter, size_t len)
 {
-       wifi_aware_subscribe_s *handle = (wifi_aware_subscribe_s *)subscribe;
-       memcpy(handle->req.match_filter, match_filter, len);
-       handle->req.match_filter_len = len;
+       wifi_aware_subscribe_request_s *req = (wifi_aware_subscribe_request_s *)subscribe;
+       memcpy(req->match_filter, match_filter, len);
+       req->match_filter_len = len;
 }
 
 void _wifi_aware_subscribe_set_enable_termination_event(wifi_aware_subscribe_h subscribe, bool enable)
 {
-       wifi_aware_subscribe_s *handle = (wifi_aware_subscribe_s *)subscribe;
-       handle->req.enable_termination_event = enable;
+       wifi_aware_subscribe_request_s *req = (wifi_aware_subscribe_request_s *)subscribe;
+       req->enable_termination_event = enable;
 }
 
 static void __session_set_subscribe_config(wifi_aware_session_h session_handle,
                wifi_aware_subscribe_h subscribe)
 {
        wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle;
-       session->subscribe_config = (wifi_aware_subscribe_s *)subscribe;
+       session->subscribe_config = subscribe;
 }
 
 int _wifi_aware_subscribe_request(wifi_aware_session_h session,
@@ -920,9 +889,7 @@ static void __service_discovered_cb(GDBusConnection *connection,
 
        wifi_aware_session_h session = (wifi_aware_session_h)user_data;
        wifi_aware_peer_h peer = NULL;
-       wifi_aware_subscribe_s *subscribe_config = __session_get_subscribe_config(session); 
 
-       RET_IF(subscribe_config == NULL, "wifi_aware_subscribe_h is NULL");
        RET_IF(!__is_subscribe_session(session), "This session is not for Subscribe");
 
        __parsing_service_discovered_event(parameters,

diff --git a/src/wifi-aware.c b/src/wifi-aware.c
index 8290935..695d104 100644 (file)
--- a/src/wifi-aware.c
+++ b/src/wifi-aware.c
@@ -140,7 +140,7 @@ API int wifi_aware_publish_create(wifi_aware_publish_h *publish)
        RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Fail to create publish handle");
        WIFI_AWARE_LOGD("publish handle: %p", *publish);
 
-       _wifi_aware_publish_request_set_default_values(*publish);
+       _wifi_aware_publish_set_default_values(*publish);
 
        __WIFI_AWARE_FUNC_EXIT__;
        return WIFI_AWARE_ERROR_NONE;