typedef void *wifi_aware_h;
/**
+ * @brief Handle for Wi-Fi Aware Publish function.
+ * @since_tizen 6.0
+ */
+typedef void *wifi_aware_publish_h;
+
+/**
* @brief Handle for Wi-Fi Aware configuration.
* @since_tizen 6.0
*/
-typedef void *wifi_aware_publish_config_h;
typedef void *wifi_aware_subscribe_config_h;
/**
* @param[out] config
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
- * @see wifi_aware_publish_config_destroy
+ * @see wifi_aware_publish_destroy
*/
-int wifi_aware_publish_config_create(wifi_aware_publish_config_h *config);
+int wifi_aware_publish_create(wifi_aware_publish_h *publish);
/**
* @brief Destroy a configuration for Publish request.
* @param[in] config
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
- * @see wifi_aware_publish_config_create
+ * @see wifi_aware_publish_create
*/
-int wifi_aware_publish_config_destroy(wifi_aware_publish_config_h config);
+int wifi_aware_publish_destroy(wifi_aware_publish_h publish);
/**
* @brief Create a configuration for Subscribe request.
/**
* @brief
* @since_tizen 6.0
- * @param[in] config
+ * @param[in] publish
* @param[in] ttl
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-int wifi_aware_publish_config_set_ttl(wifi_aware_publish_config_h config, unsigned short ttl);
+int wifi_aware_publish_set_ttl(wifi_aware_publish_h publish, unsigned short ttl);
/**
* @brief Set the type of the service as solicited or unsolicited.
* @since_tizen 6.0
- * @param[in] config
+ * @param[in] publish
* @param[in] publish_type
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-int wifi_aware_publish_config_set_type(wifi_aware_publish_config_h config, wifi_aware_publish_type_e publish_type);
+int wifi_aware_publish_set_type(wifi_aware_publish_h publish, wifi_aware_publish_type_e publish_type);
/**
* @brief Set the name of the service.
* @since_tizen 6.0
- * @param[in] config
+ * @param[in] publish
* @param[in] service_name. It should be a null-terminated string.
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-int wifi_aware_publish_config_set_service_name(wifi_aware_publish_config_h config, unsigned char *service_name, size_t len);
+int wifi_aware_publish_set_service_name(wifi_aware_publish_h publish, unsigned char *service_name, size_t len);
/**
* @brief Set the specific information for the service.
* @since_tizen 6.0
- * @param[in] config
+ * @param[in] publish
* @param[in] service_specific_info
* @param[in] len
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-int wifi_aware_publish_config_set_service_specific_info(wifi_aware_publish_config_h config, unsigned char *service_specific_info, size_t len);
+int wifi_aware_publish_set_service_specific_info(wifi_aware_publish_h publish, unsigned char *service_specific_info, size_t len);
/**
* @brief Set the match filter of the service. It is used to decide whether accepting a subscribe request or not.
* @since_tizen 6.0
- * @param[in] config
+ * @param[in] publish
* @param[in] match_filter An ordered sequence of <length, value> pairs
* @param[in] len
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-int wifi_aware_publish_config_set_match_filter(wifi_aware_publish_config_h config, unsigned char *match_filter, size_t len);
+int wifi_aware_publish_set_match_filter(wifi_aware_publish_h publish, unsigned char *match_filter, size_t len);
/**
* @brief TODO (Need decision to add) Set whether notifying a termination of the service or not.
* @since_tizen 6.0
- * @param[in] config
+ * @param[in] publish
* @param[in] enable
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-int wifi_aware_publish_config_set_enable_termination_event(wifi_aware_publish_config_h config, bool enable);
+int wifi_aware_publish_set_enable_termination_event(wifi_aware_publish_h publish, bool enable);
/**
* @brief Set whether the ranging function is supported or not.
* @since_tizen 6.0
- * @param[in] config
+ * @param[in] publish
* @param[in] enable
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-int wifi_aware_publish_config_set_enable_ranging(wifi_aware_publish_config_h config, bool enable);
+int wifi_aware_publish_set_enable_ranging(wifi_aware_publish_h publish, bool enable);
* @brief Publish a Wi-Fi Aware service so that neighboring devices can find it.
* @since_tizen 6.0
* @param[in] wifi_aware
- * @param[in] config
+ * @param[in] publish
* @param[in] callback
* @param[in] user_data
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-int wifi_aware_publish(wifi_aware_h wifi_aware,
- wifi_aware_publish_config_h config,
+int wifi_aware_start_publish(wifi_aware_h wifi_aware,
+ wifi_aware_publish_h publish,
wifi_aware_published_cb callback, void *user_data);
/**
// If so, should the callback provide a parameter to indicate the command type?
int wifi_aware_update_publish(wifi_aware_h wifi_aware,
unsigned int publish_id,
- wifi_aware_publish_config_h config,
+ wifi_aware_publish_h publish,
wifi_aware_published_cb callback, void *user_data);
/**
int wifi_aware_gdbus_enable(wifi_aware_h wifi_aware,
wifi_aware_enable_request_s *req, GAsyncReadyCallback cb);
-int wifi_aware_gdbus_publish(wifi_aware_h wifi_aware, int client_id,
- wifi_aware_publish_request_s *req, GAsyncReadyCallback cb);
+int wifi_aware_gdbus_publish(wifi_aware_publish_h publish, int client_id, GAsyncReadyCallback cb);
int wifi_aware_gdbus_cancel_publish(wifi_aware_h wifi_aware, int client_id,
unsigned int pub_id);
int wifi_aware_gdbus_subscribe(wifi_aware_h wifi_aware, int client_id,
int _wifi_aware_init();
void _add_enabled_callback(wifi_aware_h wifi_aware,
wifi_aware_enabled_cb callback, void *user_data);
-void _add_published_callback(wifi_aware_h wifi_aware,
- wifi_aware_published_cb callback, void *user_data);
void _add_subscribed_callback(wifi_aware_h wifi_aware,
wifi_aware_subscribed_cb, void *user_data);
int _wifi_aware_enable_request(wifi_aware_h wifi_aware);
int _wifi_aware_publish_request(wifi_aware_h wifi_aware,
- wifi_aware_publish_config_h config);
+ wifi_aware_publish_h publish);
int _wifi_aware_cancel_publish_request(wifi_aware_h wifi_aware, unsigned int pub_id);
int _wifi_aware_subscribe_request(wifi_aware_h wifi_aware,
wifi_aware_subscribe_config_h config);
--- /dev/null
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+#ifndef __TIZEN_NET_WIFI_AWARE_PUBLISH_PRIVATE_H__
+#define __TIZEN_NET_WIFI_AWARE_PUBLISH_PRIVATE_H__
+
+#include <tizen.h>
+#include <gio/gio.h>
+
+#include "wifi-aware.h"
+#include "wifi-aware-log.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+wifi_aware_publish_request_s *_wifi_aware_publish_get_request(wifi_aware_publish_h publish_handle);
+void _wifi_aware_publish_set_id(wifi_aware_publish_h publish_handle, unsigned int publish_id);
+void _wifi_aware_publish_invoke_callback(wifi_aware_error_e error, wifi_aware_publish_h publish_handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __TIZEN_NET_WIFI_AWARE_PUBLISH_PRIVATE_H__ */
return ret;
}
-int wifi_aware_gdbus_publish(wifi_aware_h wifi_aware, int client_id,
- wifi_aware_publish_request_s *req, GAsyncReadyCallback cb)
+int wifi_aware_gdbus_publish(wifi_aware_publish_h publish, int client_id, GAsyncReadyCallback cb)
{
__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);
params = __create_publish_request_param(client_id, req);
DBUS_DEBUG_VARIANT(params);
ret = __wifi_aware_dbus_method_call_async(
WIFI_AWARE_DISCOVERY_INTERFACE,
WIFI_AWARE_DISCOVERY_PATH,
- "Publish", params, cb, wifi_aware);
+ "Publish", params, cb, publish);
RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Publish failed");
#include "wifi-aware-log.h"
#include "wifi-aware-peer.h"
#include "wifi-aware-private.h"
+#include "wifi-aware-publish-private.h"
#include "wifi-aware-utils.h"
typedef struct {
GDBusConnection *conn = NULL;
GError *dbus_error = NULL;
GVariant *reply = NULL;
- wifi_aware_s *aware = (wifi_aware_s *)user_data;
+ wifi_aware_publish_h publish = (wifi_aware_publish_h)user_data;
wifi_aware_error_e error = WIFI_AWARE_ERROR_NONE;
unsigned int publish_id = -1;
conn = G_DBUS_CONNECTION(src);
reply = g_dbus_connection_call_finish(conn, res, &dbus_error);
+ if (reply == NULL) {
+ WIFI_AWARE_LOGE("reply is NULL");
+ return;
+ }
if (dbus_error != NULL) {
WIFI_AWARE_LOGE("Publish Request failure %s", dbus_error->message);
g_error_free(dbus_error);
}
else {
- g_variant_get(reply, "(ui)", &publish_id);
- WIFI_AWARE_LOGI("Publish ID: %u", publish_id);
+ g_variant_get(reply, "(ui)", &publish_id, &error);
+ WIFI_AWARE_LOGI("Publish ID: %u error: %d", publish_id, error);
}
- if (aware->published_cb)
- aware->published_cb(error, publish_id, aware->published_cb_data);
+ _wifi_aware_publish_set_id(publish, publish_id);
+ _wifi_aware_publish_invoke_callback(error, publish);
}
static void __subscribe_request_reply(GObject *src, GAsyncResult *res, gpointer user_data)
aware->enabled_cb_data = user_data;
}
-void _add_published_callback(wifi_aware_h wifi_aware,
- wifi_aware_published_cb callback, void *user_data)
-{
- wifi_aware_s *aware = (wifi_aware_s *)wifi_aware;
- aware->published_cb = callback;
- aware->published_cb_data = user_data;
-}
-
void _add_subscribed_callback(wifi_aware_h wifi_aware,
wifi_aware_subscribed_cb callback, void *user_data)
{
}
int _wifi_aware_publish_request(wifi_aware_h wifi_aware,
- wifi_aware_publish_config_h config)
+ wifi_aware_publish_h publish)
{
wifi_aware_s *aware = (wifi_aware_s *)wifi_aware;
- wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)config;
- return wifi_aware_gdbus_publish(wifi_aware, aware->client_id,
- req, __publish_request_reply);
+ return wifi_aware_gdbus_publish(publish, aware->client_id, __publish_request_reply);
}
int _wifi_aware_cancel_publish_request(wifi_aware_h wifi_aware,
#include "wifi-aware-private.h"
#include "wifi-aware-utils.h"
+typedef struct {
+ wifi_aware_publish_request_s req;
-static void __wifi_aware_publish_request_set_default_values(wifi_aware_publish_request_s *req)
+ wifi_aware_published_cb published_cb;
+ void *published_cb_data;
+} wifi_aware_publish_s;
+
+static void __add_published_callback(wifi_aware_publish_h publish,
+ wifi_aware_published_cb callback, void *user_data)
+{
+ wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
+ handle->published_cb = callback;
+ handle->published_cb_data = user_data;
+}
+
+static void _wifi_aware_publish_request_set_default_values(wifi_aware_publish_request_s *req)
{
req->ttl = 0;
req->publish_type = WIFI_AWARE_PUBLISH_TYPE_UNSOLICITED;
req->enable_ranging = false;
}
-API int wifi_aware_publish_config_create(wifi_aware_publish_config_h *config)
+wifi_aware_publish_request_s *_wifi_aware_publish_get_request(wifi_aware_publish_h publish)
+{
+ RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
+
+ wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
+ return &handle->req;
+}
+
+void _wifi_aware_publish_invoke_callback(wifi_aware_error_e error, wifi_aware_publish_h publish)
+{
+ RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
+
+ wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
+ if (handle->published_cb)
+ handle->published_cb(error, publish, handle->published_cb_data);
+}
+
+void _wifi_aware_publish_set_id(wifi_aware_publish_h publish, unsigned int publish_id)
+{
+ RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
+
+ wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
+ handle->req.publish_id = publish_id;
+}
+
+API int wifi_aware_publish_create(wifi_aware_publish_h *publish)
{
__WIFI_AWARE_FUNC_ENTER__;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
- 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");
+ wifi_aware_publish_s *handle =
+ (wifi_aware_publish_s *)g_try_malloc0(sizeof(wifi_aware_publish_s));
+ RET_VAL_IF(handle == NULL, WIFI_AWARE_ERROR_OUT_OF_MEMORY, "Out of memory");
- __wifi_aware_publish_request_set_default_values(req);
+ _wifi_aware_publish_request_set_default_values(&handle->req);
- *config = (wifi_aware_publish_config_h)req;
+ *publish = (wifi_aware_publish_h)handle;
__WIFI_AWARE_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_publish_config_destroy(wifi_aware_publish_config_h config)
+API int wifi_aware_publish_destroy(wifi_aware_publish_h publish)
{
__WIFI_AWARE_FUNC_ENTER__;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
- RET_VAL_IF(config == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_config_h is NULL");
+ RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
- g_free(config);
+ g_free(publish);
__WIFI_AWARE_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_publish_config_set_ttl(wifi_aware_publish_config_h config,
- unsigned short ttl)
+API int wifi_aware_publish_set_ttl(wifi_aware_publish_h publish, unsigned short ttl)
{
__WIFI_AWARE_FUNC_ENTER__;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
- RET_VAL_IF(config == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_config_h is NULL");
+ RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
- wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)config;
- req->ttl = ttl;
+ wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
+ handle->req.ttl = ttl;
__WIFI_AWARE_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_publish_config_set_type(wifi_aware_publish_config_h config,
+API int wifi_aware_publish_set_type(wifi_aware_publish_h publish,
wifi_aware_publish_type_e publish_type)
{
__WIFI_AWARE_FUNC_ENTER__;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
- RET_VAL_IF(config == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_config_h is NULL");
+ RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
- wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)config;
- req->publish_type = publish_type;
+ wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
+ handle->req.publish_type = publish_type;
__WIFI_AWARE_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_publish_config_set_service_name(wifi_aware_publish_config_h config,
+API int wifi_aware_publish_set_service_name(wifi_aware_publish_h publish,
unsigned char *service_name, size_t len)
{
__WIFI_AWARE_FUNC_ENTER__;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
- RET_VAL_IF(config == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_config_h is NULL");
+ RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
- wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)config;
- memcpy(req->service_name, service_name, len);
- req->service_name_len = len;
+ wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
+ memcpy(handle->req.service_name, service_name, len);
+ handle->req.service_name_len = len;
__WIFI_AWARE_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_publish_config_set_service_specific_info(wifi_aware_publish_config_h config,
+API int wifi_aware_publish_set_service_specific_info(wifi_aware_publish_h publish,
unsigned char *service_specific_info, size_t len)
{
__WIFI_AWARE_FUNC_ENTER__;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
- RET_VAL_IF(config == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_config_h is NULL");
+ RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
- wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)config;
- memcpy(req->specific_info, service_specific_info, len);
- req->specific_info_len = 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_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_publish_config_set_match_filter(wifi_aware_publish_config_h config,
+API int wifi_aware_publish_set_match_filter(wifi_aware_publish_h publish,
unsigned char *match_filter, size_t len)
{
__WIFI_AWARE_FUNC_ENTER__;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
- RET_VAL_IF(config == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_config_h is NULL");
+ RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
- wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)config;
- memcpy(req->match_filter, match_filter, len);
- req->match_filter_len = 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_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_publish_config_set_enable_termination_event(
- wifi_aware_publish_config_h config,
+API int wifi_aware_publish_set_enable_termination_event(
+ wifi_aware_publish_h publish,
bool enable)
{
__WIFI_AWARE_FUNC_ENTER__;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
- RET_VAL_IF(config == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_config_h is NULL");
+ RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
- wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)config;
- req->enable_termination_event = enable;
+ wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
+ handle->req.enable_termination_event = enable;
__WIFI_AWARE_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_publish_config_set_enable_ranging(
- wifi_aware_publish_config_h config,
+API int wifi_aware_publish_set_enable_ranging(
+ wifi_aware_publish_h publish,
bool enable)
{
__WIFI_AWARE_FUNC_ENTER__;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
- RET_VAL_IF(config == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_config_h is NULL");
+ RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
- wifi_aware_publish_request_s *req = (wifi_aware_publish_request_s *)config;
- req->enable_ranging = enable;
+ wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
+ handle->req.enable_ranging = enable;
__WIFI_AWARE_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
API int wifi_aware_publish(wifi_aware_h wifi_aware,
- wifi_aware_publish_config_h config,
+ wifi_aware_publish_h publish,
wifi_aware_published_cb callback, void *user_data)
{
__WIFI_AWARE_FUNC_ENTER__;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
RET_ERR_IF_HANDLE_IS_NOT_VALID_OR_NOT_INITIALIZED(wifi_aware);
- RET_VAL_IF(config == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_config_h is NULL");
+ RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
- _add_published_callback(wifi_aware, callback, user_data);
+ __add_published_callback(publish, callback, user_data);
- ret = _wifi_aware_publish_request(wifi_aware, config);
+ ret = _wifi_aware_publish_request(wifi_aware, publish);
RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "_wifi_aware_publish_request");
__WIFI_AWARE_FUNC_EXIT__;
API int wifi_aware_update_publish(wifi_aware_h wifi_aware,
unsigned int publish_id,
- wifi_aware_publish_config_h config,
+ wifi_aware_publish_h publish,
wifi_aware_published_cb callback, void *user_data)
{
__WIFI_AWARE_FUNC_ENTER__;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
RET_ERR_IF_HANDLE_IS_NOT_VALID_OR_NOT_INITIALIZED(wifi_aware);
- RET_VAL_IF(config == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_config_h is NULL");
+ RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
__WIFI_AWARE_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
printf("Subscribe Request fails. Error: %s\n", __print_error(error));
}
-static void __set_publish_config(wifi_aware_publish_config_h config)
+static void __set_publish_config(wifi_aware_publish_h config)
{
int ret = 0;
int publish_type = 0;
if (ret < 0)
return;
- ret = wifi_aware_publish_config_set_type(config,
+ ret = wifi_aware_publish_set_type(config,
publish_type ? WIFI_AWARE_PUBLISH_TYPE_UNSOLICITED
: WIFI_AWARE_PUBLISH_TYPE_SOLICITED);
if (ret != WIFI_AWARE_ERROR_NONE)
len = strlen(SERVICE_NAME);
memcpy(service_name, SERVICE_NAME, len);
- ret = wifi_aware_publish_config_set_service_name(config,
+ ret = wifi_aware_publish_set_service_name(config,
service_name, len);
if (ret != WIFI_AWARE_ERROR_NONE)
return;
len = strlen(PUB_SSI);
memcpy(specific_info, PUB_SSI, len);
- ret = wifi_aware_publish_config_set_service_specific_info(config,
+ ret = wifi_aware_publish_set_service_specific_info(config,
specific_info, len);
if (ret != WIFI_AWARE_ERROR_NONE)
return;
len = strlen(MATCH_FILTER);
memcpy(match_filter, MATCH_FILTER, len);
- ret = wifi_aware_publish_config_set_match_filter(config,
+ ret = wifi_aware_publish_set_match_filter(config,
match_filter, len);
if (ret != WIFI_AWARE_ERROR_NONE)
return;
void test_publish()
{
int ret = 0;
- wifi_aware_publish_config_h config = NULL;
+ wifi_aware_publish_h config = NULL;
RET_IF_LOOP_IS_NULL();
RET_IF_HANDLE_IS_NULL();
- ret = wifi_aware_publish_config_create(&config);
- __print_result(ret, "wifi_aware_publish_config_create");
+ ret = wifi_aware_publish_create(&config);
+ __print_result(ret, "wifi_aware_publish_create");
__set_publish_config(config);
ret = wifi_aware_publish(g_wifi_aware_handle, config, __published_cb, NULL);
__print_result(ret, "wifi_aware_publish");
- ret = wifi_aware_publish_config_destroy(config);
- __print_result(ret, "wifi_aware_publish_config_destroy");
+ ret = wifi_aware_publish_destroy(config);
+ __print_result(ret, "wifi_aware_publish_destroy");
}
void test_cancel_publish()
projects / platform / core / api / wifi-aware.git / commitdiff