typedef void *wifi_aware_h;
/**
- * @brief Handle for Wi-Fi Aware Publish function.
+ * @brief Wi-Fi Aware Session
+ * @since_tizen 6.0
+ */
+typedef void *wifi_aware_session_h;
+
+/**
+ * @brief Handle for Wi-Fi Aware Publish configuration.
* @since_tizen 6.0
*/
typedef void *wifi_aware_publish_h;
/**
- * @brief Handle for Wi-Fi Aware configuration.
+ * @brief Handle for Wi-Fi Aware Subscribe configuration.
* @since_tizen 6.0
*/
typedef void *wifi_aware_subscribe_h;
/**
* @brief Create a Publish request.
* @since_tizen 6.0
- * @param[in] wifi_aware
* @param[out] publish
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
* @see wifi_aware_publish_destroy
*/
-int wifi_aware_publish_create(wifi_aware_h wifi_aware, wifi_aware_publish_h *publish);
+int wifi_aware_publish_create(wifi_aware_publish_h *publish);
/**
* @brief Destroy a Publish request.
/**
* @brief Create a Subscribe request.
* @since_tizen 6.0
- * @param[out] subscribe
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
* @see wifi_aware_subscribe_destroy
*/
-int wifi_aware_subscribe_create(wifi_aware_h wifi_aware, wifi_aware_subscribe_h *subscribe);
+int wifi_aware_subscribe_create(wifi_aware_subscribe_h *subscribe);
/**
* @brief Destroy a Subscribe request.
*/
int wifi_aware_subscribe_set_min_distance(wifi_aware_subscribe_h subscribe, int distance);
-/**
- * @brief TODO (Need decision to add) Set whether notifying a termination of the service or not.
- * @since_tizen 6.0
- * @param[in] subscribe
- * @param[in] enable
- * @return 0 on success, otherwise a negative error value
- * @retval #WIFI_AWARE_ERROR_NONE
- */
-int wifi_aware_subscribe_set_enable_termination_event(wifi_aware_subscribe_h subscribe, bool enable);
-
/**
* @brief
int wifi_aware_disable(wifi_aware_h wifi_aware);
/**
+ * @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
+ */
+int wifi_aware_session_create(wifi_aware_h wifi_aware, 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
+ */
+int wifi_aware_session_destroy(wifi_aware_session_h session);
+
+/**
* @brief This callback delivers the result of a Publish request.
- * If the request is successfully done, @a publish_id is set to the Wi-Fi Aware service.
- * @a publish_id can be used to update or cancel the service.
* @since_tizen 6.0
* @param[in] error
- * @param[in] publish
+ * @param[in] session
* @param[in] user_data
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
- * @see wifi_aware_start_publish()
- * @see wifi_aware_update_publish()
+ * @see wifi_aware_session_publish()
+ * @see wifi_aware_session_update_publish()
*/
typedef void(*wifi_aware_published_cb)(wifi_aware_error_e error,
- wifi_aware_publish_h publish, void *user_data);
+ wifi_aware_session_h session, void *user_data);
/**
* @brief Publish a Wi-Fi Aware service so that neighboring devices can find it.
* @since_tizen 6.0
+ * @param[in] sesssion
* @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_start_publish(wifi_aware_publish_h publish,
- wifi_aware_published_cb callback, void *user_data);
+int wifi_aware_session_publish(wifi_aware_session_h session,
+ wifi_aware_publish_h publish,
+ wifi_aware_published_cb callback,
+ void *user_data);
/**
* @brief Cancel a published Wi-Fi Aware service so that it cannot be found.
* @since_tizen 6.0
- * @param[in] publish
+ * @param[in] sesssion
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-int wifi_aware_cancel_publish(wifi_aware_publish_h publish);
+int wifi_aware_session_stop_publish(wifi_aware_session_h session);
/**
* @brief Update the configuration for a Wi-Fi Aware service that has already been published.
* @since_tizen 6.0
+ * @param[in] sesssion
* @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_update_publish(wifi_aware_publish_h publish,
+int wifi_aware_session_update_publish(wifi_aware_session_h session,
+ wifi_aware_publish_h publish,
wifi_aware_published_cb callback, void *user_data);
/**
* @brief
* @since_tizen 6.0
* @param[in] error
- * @param[in] subscribe
+ * @param[in] session
* @param[in] user_data
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
typedef void(*wifi_aware_subscribed_cb)(wifi_aware_error_e error,
- wifi_aware_subscribe_h subscribe, void *user_data);
+ wifi_aware_session_h session, void *user_data);
/**
* @brief Start to find Wi-Fi Aware services.
* @since_tizen 6.0
+ * @param[in] session
* @param[in] subscribe
* @param[in] callback
* @param[in] user_data
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-int wifi_aware_start_subscribe(wifi_aware_subscribe_h subscribe,
+int wifi_aware_session_subscribe(wifi_aware_session_h,
+ wifi_aware_subscribe_h subscribe,
wifi_aware_subscribed_cb callback, void *user_data);
/**
* @brief Stop finding Wi-Fi Aware services.
* @since_tizen 6.0
- * @param[in] subscribe
+ * @param[in] session
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-int wifi_aware_cancel_subscribe(wifi_aware_subscribe_h subscribe);
+int wifi_aware_session_stop_subscribe(wifi_aware_session_h session);
/**
* @brief Update the configuration for a Wi-Fi Aware service that has already been subscribed.
* @since_tizen 6.0
+ * @param[in] session
* @param[in] subscribe
* @param[in] callback
* @param[in] user_data
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-int wifi_aware_update_subscribe(wifi_aware_subscribe_h subscribe,
+int wifi_aware_session_update_subscribe(wifi_aware_session_h session,
+ wifi_aware_subscribe_h subscribe,
wifi_aware_subscribed_cb callback, void *user_data);
/**
* @brief
* @since_tizen 6.0
+ * @param[in] session
* @param[in] peer
* @param[in] service_specific_info
* @param[in] service_specific_info_len
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-typedef void(*wifi_aware_discovery_result_cb)(wifi_aware_subscribe_h subscribe,
+typedef void(*wifi_aware_discovery_result_cb)(wifi_aware_session_h session,
wifi_aware_peer_h peer,
unsigned char *service_specific_info, size_t service_specific_info_len,
void *user_data);
/**
* @brief
* @since_tizen 6.0
- * @param[in] subscribe
+ * @param[in] session
* @param[in] callback
* @param[in] user_data
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-int wifi_aware_set_discovery_result_cb(wifi_aware_subscribe_h subscribe,
+int wifi_aware_set_discovery_result_cb(wifi_aware_session_h session,
wifi_aware_discovery_result_cb callback, void *user_data);
/**
* @brief
* @since_tizen 6.0
* @param[in] error
+ * @param[in] session
* @param[in] user_data
*/
-typedef void(*wifi_aware_send_message_result_cb)(wifi_aware_error_e error, void *user_data);
+typedef void(*wifi_aware_send_message_result_cb)(wifi_aware_session_h session,
+ wifi_aware_error_e error, void *user_data);
/**
* @brief
* @since_tizen 6.0
+ * @param[in] session
* @param[in] peer
* @param[in] message
* @param[in] len
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-int wifi_aware_send_message(wifi_aware_peer_h peer,
+int wifi_aware_send_message(
+ wifi_aware_session_h session,
+ wifi_aware_peer_h peer,
unsigned char *message, size_t len,
wifi_aware_send_message_result_cb callback, void *user_data);
/**
* @brief
* @since_tizen 6.0
+ * @param[in] session
* @param[in] peer
* @param[in] message
* @param[in] len
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-typedef void(*wifi_aware_received_message_cb)(wifi_aware_peer_h peer,
+typedef void(*wifi_aware_received_message_cb)(
+ wifi_aware_session_h session,
+ wifi_aware_peer_h peer,
unsigned char *message, size_t len, void *user_data);
/**
* @brief TODO: This callback is registered to wifi_aware handle, not publish/subscribe sessions
* @since_tizen 6.0
- * @param[in] wifi_aware
+ * @param[in] session
* @param[in] callback
* @return 0 on success, otherwise a negative error value
* @retval #WIFI_AWARE_ERROR_NONE
*/
-int wifi_aware_set_received_message_cb(wifi_aware_h wifi_aware,
+int wifi_aware_set_received_message_cb(wifi_aware_session_h session,
wifi_aware_received_message_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_disable(wifi_aware_h wifi_aware, int client_id);
-int wifi_aware_gdbus_publish(wifi_aware_publish_h publish, int client_id, GAsyncReadyCallback cb);
-int wifi_aware_gdbus_cancel_publish(wifi_aware_publish_h publish, int client_id);
-int wifi_aware_gdbus_update_publish(wifi_aware_publish_h publish, int client_id, GAsyncReadyCallback cb);
-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_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);
+int wifi_aware_gdbus_update_publish(wifi_aware_session_h session,
+ wifi_aware_publish_h publish, int client_id, GAsyncReadyCallback cb);
+int wifi_aware_gdbus_subscribe(wifi_aware_session_h session,
+ wifi_aware_subscribe_h subscribe, int client_id, GAsyncReadyCallback cb);
+int wifi_aware_gdbus_cancel_subscribe(wifi_aware_session_h session, int client_id);
+int wifi_aware_gdbus_update_subscribe(wifi_aware_session_h session,
+ wifi_aware_subscribe_h subscribe, int client_id, GAsyncReadyCallback cb);
-int wifi_aware_gdbus_followup(int client_id, unsigned int peer_id,
+int wifi_aware_gdbus_followup(wifi_aware_session_h session,
+ int client_id, unsigned int peer_id,
unsigned char *message, size_t len,
GAsyncReadyCallback cb, void *user_data);
#ifdef __cplusplus
int _wifi_aware_is_enabled(wifi_aware_h wifi_aware);
int _wifi_aware_disable_request(wifi_aware_h wifi_aware);
-int _wifi_aware_publish_handle_create(wifi_aware_h wifi_aware, wifi_aware_publish_h *publish);
+int _wifi_aware_session_handle_create(wifi_aware_h wifi_aware, 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);
void _wifi_aware_publish_request_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,
unsigned char *match_filter, size_t len);
void _wifi_aware_publish_set_enable_termination_event(wifi_aware_publish_h publish, bool enable);
void _wifi_aware_publish_set_enable_ranging(wifi_aware_publish_h publish, bool enable);
-int _wifi_aware_publish_request(wifi_aware_publish_h publish,
+int _wifi_aware_publish_request(wifi_aware_session_h session, wifi_aware_publish_h publish,
wifi_aware_published_cb callback, void *user_data);
-int _wifi_aware_cancel_publish_request(wifi_aware_publish_h publish);
-int _wifi_aware_update_publish_request(wifi_aware_publish_h publish,
+int _wifi_aware_cancel_publish_request(wifi_aware_session_h session);
+int _wifi_aware_update_publish_request(wifi_aware_session_h session, wifi_aware_publish_h publish,
wifi_aware_published_cb callback, void *user_data);
wifi_aware_publish_request_s *_wifi_aware_publish_get_request(wifi_aware_publish_h publish_handle);
-unsigned int _wifi_aware_publish_get_id(wifi_aware_publish_h publish);
+unsigned int _wifi_aware_session_get_publish_id(wifi_aware_session_h session);
-int _wifi_aware_subscribe_handle_create(wifi_aware_h wifi_aware, wifi_aware_subscribe_h *subscribe);
+int _wifi_aware_subscribe_handle_create(wifi_aware_publish_h *publish);
void _wifi_aware_subscribe_set_default_values(wifi_aware_subscribe_h subscribe);
void _wifi_aware_subscribe_set_ttl(wifi_aware_subscribe_h subscribe, unsigned short ttl);
void _wifi_aware_subscribe_set_type(wifi_aware_subscribe_h subscribe,
void _wifi_aware_subscribe_set_match_filter(wifi_aware_subscribe_h subscribe,
unsigned char *match_filter, size_t len);
void _wifi_aware_subscribe_set_enable_termination_event(wifi_aware_subscribe_h subscribe, bool enable);
-int _wifi_aware_subscribe_request(wifi_aware_subscribe_h subscribe,
+int _wifi_aware_subscribe_request(wifi_aware_session_h session, wifi_aware_subscribe_h subscribe,
wifi_aware_subscribed_cb callback, void *user_data);
-int _wifi_aware_cancel_subscribe_request(wifi_aware_subscribe_h subscribe);
-int _wifi_aware_update_subscribe_request(wifi_aware_subscribe_h subscribe,
+int _wifi_aware_cancel_subscribe_request(wifi_aware_session_h session);
+int _wifi_aware_update_subscribe_request(wifi_aware_session_h session, wifi_aware_subscribe_h subscribe,
wifi_aware_subscribed_cb callback, void *user_data);
wifi_aware_subscribe_request_s *_wifi_aware_subscribe_get_request(wifi_aware_subscribe_h subscribe_handle);
-unsigned int _wifi_aware_subscribe_get_id(wifi_aware_subscribe_h subscribe);
+unsigned int _wifi_aware_session_get_subscribe_id(wifi_aware_session_h session);
-void _wifi_aware_set_discovery_result_cb(wifi_aware_subscribe_h subscribe,
+void _wifi_aware_set_discovery_result_cb(wifi_aware_session_h session,
wifi_aware_discovery_result_cb callback, void *user_data);
-int _wifi_aware_send_message(wifi_aware_peer_h peer,
+int _wifi_aware_send_message(wifi_aware_session_h session, wifi_aware_peer_h peer,
unsigned char *message, size_t len,
wifi_aware_send_message_result_cb callback, void *user_data);
return ret;
}
-int wifi_aware_gdbus_publish(wifi_aware_publish_h publish, int client_id, GAsyncReadyCallback cb)
+int wifi_aware_gdbus_publish(wifi_aware_session_h session, wifi_aware_publish_h publish,
+ int client_id, GAsyncReadyCallback cb)
{
__WIFI_AWARE_FUNC_ENTER__;
GVariant *params = NULL;
ret = __wifi_aware_dbus_method_call_async(
WIFI_AWARE_DISCOVERY_INTERFACE,
WIFI_AWARE_DISCOVERY_PATH,
- "Publish", params, cb, publish);
+ "Publish", params, cb, session);
RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Publish failed");
return error;
}
-int wifi_aware_gdbus_cancel_publish(wifi_aware_publish_h publish, int client_id)
+int wifi_aware_gdbus_cancel_publish(wifi_aware_session_h session, int client_id)
{
__WIFI_AWARE_FUNC_ENTER__;
GVariant *params = NULL;
GVariant *reply = NULL;
int ret = WIFI_AWARE_ERROR_NONE;
- unsigned int pub_id = _wifi_aware_publish_get_id(publish);
+ unsigned int pub_id = _wifi_aware_session_get_publish_id(session);
if (pub_id == 0) {
WIFI_AWARE_LOGE("Invalid Publish Id");
return ret;
}
-int wifi_aware_gdbus_update_publish(wifi_aware_publish_h publish, int client_id, GAsyncReadyCallback cb)
+int wifi_aware_gdbus_update_publish(wifi_aware_session_h session,
+ 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);
- unsigned int pub_id = _wifi_aware_publish_get_id(publish);
+ unsigned int pub_id = _wifi_aware_session_get_publish_id(session);
if (pub_id == 0) {
WIFI_AWARE_LOGE("Invalid Publish Id.");
ret = __wifi_aware_dbus_method_call_async(
WIFI_AWARE_DISCOVERY_INTERFACE,
WIFI_AWARE_DISCOVERY_PATH,
- "UpdatePublish", params, cb, publish);
+ "UpdatePublish", params, cb, session);
RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "UpdatePublish failed");
return ret;
}
-int wifi_aware_gdbus_subscribe(wifi_aware_subscribe_h subscribe, int client_id, GAsyncReadyCallback cb)
+int wifi_aware_gdbus_subscribe(wifi_aware_session_h session,
+ wifi_aware_subscribe_h subscribe, int client_id, GAsyncReadyCallback cb)
{
__WIFI_AWARE_FUNC_ENTER__;
GVariant *params = NULL;
ret = __wifi_aware_dbus_method_call_async(
WIFI_AWARE_DISCOVERY_INTERFACE,
WIFI_AWARE_DISCOVERY_PATH,
- "Subscribe", params, cb, subscribe);
+ "Subscribe", params, cb, session);
RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Subscribe failed");
return error;
}
-int wifi_aware_gdbus_cancel_subscribe(wifi_aware_subscribe_h subscribe, int client_id)
+int wifi_aware_gdbus_cancel_subscribe(wifi_aware_session_h session, int client_id)
{
__WIFI_AWARE_FUNC_ENTER__;
GVariant *params = NULL;
GVariant *reply = NULL;
int ret = WIFI_AWARE_ERROR_NONE;
- unsigned int sub_id = _wifi_aware_subscribe_get_id(subscribe);
+ unsigned int sub_id = _wifi_aware_session_get_subscribe_id(session);
if (sub_id == 0) {
WIFI_AWARE_LOGE("Invalid Subscribe Id");
return ret;
}
-int wifi_aware_gdbus_update_subscribe(wifi_aware_subscribe_h subscribe, int client_id, GAsyncReadyCallback cb)
+int wifi_aware_gdbus_update_subscribe(wifi_aware_session_h session,
+ wifi_aware_subscribe_h subscribe, int client_id, GAsyncReadyCallback cb)
{
__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);
- unsigned int sub_id = _wifi_aware_subscribe_get_id(subscribe);
+ unsigned int sub_id = _wifi_aware_session_get_subscribe_id(session);
if (sub_id == 0) {
WIFI_AWARE_LOGE("Invalid Publish Id.");
ret = __wifi_aware_dbus_method_call_async(
WIFI_AWARE_DISCOVERY_INTERFACE,
WIFI_AWARE_DISCOVERY_PATH,
- "UpdateSubscribe", params, cb, subscribe);
+ "UpdateSubscribe", params, cb, session);
RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "UpdateSubscribe failed");
return ret;
}
-int wifi_aware_gdbus_followup(int client_id, unsigned int peer_id,
+int wifi_aware_gdbus_followup(wifi_aware_session_h session,
+ int client_id, unsigned int peer_id,
unsigned char *message, size_t len,
GAsyncReadyCallback cb, void *user_data)
{
NAN_ERROR_UNKNOWN,
} nan_manager_error_e;
+typedef enum {
+ WIFI_AWARE_PUBLISH = 0,
+ WIFI_AWARE_SUBSCRIBE,
+} wifi_aware_session_type_e;
+
typedef struct {
- wifi_aware_s *aware_handle;
uint32_t publish_id;
wifi_aware_publish_request_s req;
} wifi_aware_publish_s;
typedef struct {
- wifi_aware_s *aware_handle;
uint32_t subscribe_id;
wifi_aware_subscribe_request_s req;
} 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;
+
+ wifi_aware_send_message_result_cb send_cb;
+ void *send_cb_data;
+
+ wifi_aware_received_message_cb received_cb;
+ void *received_cb_data;
+ guint receivec_signal_id;
+} wifi_aware_session_s;
+
+typedef struct {
+ wifi_aware_session_h session;
wifi_aware_send_message_result_cb callback;
void *user_data;
} wifi_aware_message_s;
return true;
}
-static int __get_client_id_with_publish(wifi_aware_publish_h publish)
+static int __session_get_client_id(wifi_aware_session_h session_handle)
{
- wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
- return handle->aware_handle->client_id;
+ wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle;
+ return session->wifi_aware_handle->client_id;
}
-static int __get_client_id_with_subscribe(wifi_aware_subscribe_h subscribe)
+static int __is_publish_session(wifi_aware_session_h session_handle)
{
- wifi_aware_subscribe_s *handle = (wifi_aware_subscribe_s *)subscribe;
- return handle->aware_handle->client_id;
+ wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle;
+ return session->session_type == WIFI_AWARE_PUBLISH;
+}
+
+static int __is_subscribe_session(wifi_aware_session_h session_handle)
+{
+ wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle;
+ return session->session_type == WIFI_AWARE_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;
+ return session->publish_config;
+}
+
+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 __enable_request_reply(GObject *src, GAsyncResult *res, gpointer user_data)
subscribe);
}
+unsigned int _wifi_aware_session_get_publish_id(wifi_aware_session_h session)
+{
+ RET_VAL_IF(session == NULL, 0, "wifi_aware_session_h is NULL");
+ RET_VAL_IF(!__is_publish_session(session), 0,
+ "This session is not for Publish");
+ return __session_get_publish_config(session)->publish_id;
+}
+
+unsigned int _wifi_aware_session_get_subscribe_id(wifi_aware_session_h session)
+{
+ RET_VAL_IF(session == NULL, 0, "wifi_aware_session_h is NULL");
+ RET_VAL_IF(!__is_subscribe_session(session), 0,
+ "This session is not for Subscribe");
+ return __session_get_subscribe_config(session)->subscribe_id;
+}
+
int _wifi_aware_handle_create(wifi_aware_h *wifi_aware)
{
wifi_aware_s *aware = (wifi_aware_s *)g_try_malloc0(sizeof(wifi_aware_s));
return wifi_aware_gdbus_disable(wifi_aware, aware->client_id);
}
-int _wifi_aware_publish_handle_create(wifi_aware_h wifi_aware, wifi_aware_publish_h *publish)
+int _wifi_aware_session_handle_create(wifi_aware_h wifi_aware, 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 = session;
+ session->wifi_aware_handle = wifi_aware;
+
+ return WIFI_AWARE_ERROR_NONE;
+}
+
+int _wifi_aware_session_handle_destroy(wifi_aware_session_h session_handle)
+{
+ // TODO
+ g_free(session_handle);
+ return WIFI_AWARE_ERROR_NONE;
+}
+
+int _wifi_aware_publish_handle_create(wifi_aware_publish_h *publish)
{
- wifi_aware_s *handle = (wifi_aware_s *)wifi_aware;
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");
- pub_handle->aware_handle = handle;
*publish = (wifi_aware_publish_h)pub_handle;
return WIFI_AWARE_ERROR_NONE;
return &(handle->req);
}
-unsigned int _wifi_aware_publish_get_id(wifi_aware_publish_h publish)
+static void __session_set_publish_config(wifi_aware_session_h session_handle,
+ wifi_aware_publish_h publish)
{
- 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;
+ wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle;
+ session->publish_config = (wifi_aware_publish_s *)publish;
}
-int _wifi_aware_publish_request(wifi_aware_publish_h publish,
+int _wifi_aware_publish_request(wifi_aware_session_h session,
+ wifi_aware_publish_h publish,
wifi_aware_published_cb callback, void *user_data)
{
+ 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");
+ RET_VAL_IF(!__is_publish_session(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
+ "This session is not for Publish");
+ __session_set_publish_config(session, publish);
__add_published_callback(publish, callback, user_data);
- return wifi_aware_gdbus_publish(publish,
- __get_client_id_with_publish(publish),
+ return wifi_aware_gdbus_publish(session, publish,
+ __session_get_client_id(session),
__publish_request_reply);
}
-int _wifi_aware_cancel_publish_request(wifi_aware_publish_h publish)
+int _wifi_aware_cancel_publish_request(wifi_aware_session_h session)
{
- RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
-
- if (!__is_published(publish)) {
- WIFI_AWARE_LOGE("The publish is not done yet");
- return WIFI_AWARE_ERROR_INVALID_OPERATION;
- }
+ RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
+ RET_VAL_IF(!__is_publish_session(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
+ "This session is not for Publish");
+ RET_VAL_IF(!__is_published(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
+ "The publish is not done yet");
- return wifi_aware_gdbus_cancel_publish(publish,
- __get_client_id_with_publish(publish));
+ return wifi_aware_gdbus_cancel_publish(session, __session_get_client_id(session));
}
-int _wifi_aware_update_publish_request(wifi_aware_publish_h publish,
+int _wifi_aware_update_publish_request(wifi_aware_session_h session,
+ wifi_aware_publish_h publish,
wifi_aware_published_cb callback, void *user_data)
{
+ 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");
+ RET_VAL_IF(!__is_publish_session(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
+ "This session is not for Publish");
+ RET_VAL_IF(!__is_published(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
+ "The publish is not done yet");
+ __session_set_publish_config(session, publish);
__add_published_callback(publish, callback, user_data);
- return wifi_aware_gdbus_update_publish(publish,
- __get_client_id_with_publish(publish),
+ return wifi_aware_gdbus_update_publish(session, publish,
+ __session_get_client_id(session),
__publish_request_reply);
}
-int _wifi_aware_subscribe_handle_create(wifi_aware_h wifi_aware, wifi_aware_subscribe_h *subscribe)
+int _wifi_aware_subscribe_handle_create(wifi_aware_subscribe_h *subscribe)
{
- wifi_aware_s *handle = (wifi_aware_s *)wifi_aware;
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");
- sub_handle->aware_handle = handle;
*subscribe = (wifi_aware_subscribe_h)sub_handle;
return WIFI_AWARE_ERROR_NONE;
handle->req.enable_termination_event = enable;
}
-unsigned int _wifi_aware_subscribe_get_id(wifi_aware_subscribe_h subscribe)
+static void __session_set_subscribe_config(wifi_aware_session_h session_handle,
+ wifi_aware_subscribe_h subscribe)
{
- 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;
+ wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle;
+ session->subscribe_config = (wifi_aware_subscribe_s *)subscribe;
}
-int _wifi_aware_subscribe_request(wifi_aware_subscribe_h subscribe,
+int _wifi_aware_subscribe_request(wifi_aware_session_h session,
+ wifi_aware_subscribe_h subscribe,
wifi_aware_subscribed_cb callback, void *user_data)
{
+ 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");
+ RET_VAL_IF(!__is_subscribe_session(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
+ "This session is not for Subscribe");
+ __session_set_subscribe_config(session, subscribe);
__add_subscribed_callback(subscribe, callback, user_data);
- return wifi_aware_gdbus_subscribe(subscribe,
- __get_client_id_with_subscribe(subscribe),
+ return wifi_aware_gdbus_subscribe(session, subscribe,
+ __session_get_client_id(session),
__subscribe_request_reply);
}
-int _wifi_aware_cancel_subscribe_request(wifi_aware_subscribe_h subscribe)
+int _wifi_aware_cancel_subscribe_request(wifi_aware_session_h session)
{
- RET_VAL_IF(subscribe == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_h is NULL");
-
- if (!__is_subscribed(subscribe)) {
- WIFI_AWARE_LOGE("The subscribe is not done yet");
- return WIFI_AWARE_ERROR_INVALID_OPERATION;
- }
+ RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
+ RET_VAL_IF(!__is_subscribe_session(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
+ "This session is not for Subscribe");
+ RET_VAL_IF(!__is_subscribed(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
+ "The subscribe is not done yet");
- return wifi_aware_gdbus_cancel_subscribe(subscribe,
- __get_client_id_with_subscribe(subscribe));
+ return wifi_aware_gdbus_cancel_subscribe(session,
+ __session_get_client_id(session));
}
-int _wifi_aware_update_subscribe_request(wifi_aware_subscribe_h subscribe,
+int _wifi_aware_update_subscribe_request(wifi_aware_session_h session,
+ wifi_aware_subscribe_h subscribe,
wifi_aware_subscribed_cb callback, void *user_data)
{
+ 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");
+ RET_VAL_IF(!__is_subscribe_session(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
+ "This session is not for Subscribe");
+ RET_VAL_IF(!__is_subscribed(session), WIFI_AWARE_ERROR_INVALID_OPERATION,
+ "The subscribe is not done yet");
+ __session_set_subscribe_config(session, subscribe);
__add_subscribed_callback(subscribe, callback, user_data);
- return wifi_aware_gdbus_update_subscribe(subscribe,
- __get_client_id_with_subscribe(subscribe),
+ return wifi_aware_gdbus_update_subscribe(session, subscribe,
+ __session_get_client_id(session),
__subscribe_request_reply);
}
-/*
-void _mac_address_changed(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
-{
- __WIFI_AWARE_FUNC_ENTER__;
- WIFI_AWARE_LOGD("MAC Address is changed");
-}
-*/
-
static void __parsing_service_discovered_event(GVariant *parameters,
unsigned int *sub_id, unsigned int *peer_id,
unsigned char *specific_info, size_t *specific_info_len)
unsigned char specific_info[WIFI_AWARE_MAX_SERVICE_SPECIFIC_INFO_LEN];
size_t specific_info_len = 0;
- wifi_aware_subscribe_s *handle = (wifi_aware_subscribe_s *)user_data;
+ 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(handle == NULL, "wifi_aware_subscribe_h is NULL");
+ 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,
&sub_id, &peer_id,
specific_info, &specific_info_len);
- if (sub_id == 0 || handle->subscribe_id != sub_id) {
- WIFI_AWARE_LOGE("Invalid subscribe ID (%u:%u)", handle->subscribe_id, sub_id);
+ if (sub_id == 0 || subscribe_config->subscribe_id != sub_id) {
+ WIFI_AWARE_LOGE("Invalid subscribe ID (%u:%u)", subscribe_config->subscribe_id, sub_id);
return;
}
WIFI_AWARE_LOGD("subscribe ID: %u, Peer ID: %u", sub_id, peer_id);
- if (__handle_new_peer(handle->aware_handle, peer_id, &peer) != WIFI_AWARE_ERROR_NONE) {
+ if (__handle_new_peer(__session_get_wifi_aware(session),
+ peer_id, &peer) != WIFI_AWARE_ERROR_NONE) {
WIFI_AWARE_LOGE("Invalid peer %u", peer_id);
return;
}
- if (handle->discovered_cb)
- handle->discovered_cb(handle, peer,
+ if (subscribe_config->discovered_cb)
+ subscribe_config->discovered_cb(session, peer,
specific_info, specific_info_len,
- handle->discovered_cb_data);
+ subscribe_config->discovered_cb_data);
}
-void _wifi_aware_set_discovery_result_cb(wifi_aware_subscribe_h subscribe,
+void _wifi_aware_set_discovery_result_cb(wifi_aware_session_h session,
wifi_aware_discovery_result_cb callback, void *user_data)
{
__WIFI_AWARE_FUNC_ENTER__;
+ RET_IF(!__is_subscribe_session(session), "This session is not for Subscribe");
- wifi_aware_subscribe_s *handle = (wifi_aware_subscribe_s *)subscribe;
- handle->discovered_cb = callback;
- handle->discovered_cb_data = user_data;
- handle->discovered_signal_id =
+ wifi_aware_subscribe_s *config = __session_get_subscribe_config(session);
+ config->discovered_cb = callback;
+ config->discovered_cb_data = user_data;
+ config->discovered_signal_id =
wifi_aware_gdbus_register_signal(SERVICE_DISCOVERED_SIGNAL,
- __service_discovered_cb, handle);
+ __service_discovered_cb, session);
}
-wifi_aware_message_s *__create_message_data(wifi_aware_send_message_result_cb cb, void *user_data)
+wifi_aware_message_s *__create_message_data(wifi_aware_session_h session,
+ 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->session = session;
result->callback = cb;
result->user_data = user_data;
+ return result;
}
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);
+ message->callback(message->session, error, message->user_data);
}
static void __send_message_reply(GObject *src, GAsyncResult *res, gpointer user_data)
}
__wifi_aware_followup_invoke_callback(message, error);
+ g_free(message);
}
-int _wifi_aware_send_message(wifi_aware_peer_h peer,
+int _wifi_aware_send_message(wifi_aware_session_h session,
+ 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__;
+ RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
- wifi_aware_message_s *message_data = __create_message_data(callback, user_data);
+ wifi_aware_message_s *message_data = __create_message_data(session, 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),
+ session,
+ __session_get_client_id(session),
_wifi_aware_peer_get_id(peer),
message, len,
__send_message_reply,
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_publish_create(wifi_aware_h wifi_aware, wifi_aware_publish_h *publish)
+API int wifi_aware_session_create(wifi_aware_h wifi_aware, wifi_aware_session_h *session)
{
int ret = WIFI_AWARE_ERROR_NONE;
__WIFI_AWARE_FUNC_ENTER__;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
- ret = _wifi_aware_publish_handle_create(wifi_aware, publish);
+ ret = _wifi_aware_session_handle_create(wifi_aware, session);
+ RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Fail to create session handle");
+ WIFI_AWARE_LOGD("session handle: %p", *session);
+
+ __WIFI_AWARE_FUNC_EXIT__;
+ return WIFI_AWARE_ERROR_NONE;
+}
+
+API int wifi_aware_session_destroy(wifi_aware_session_h session)
+{
+ int ret = WIFI_AWARE_ERROR_NONE;
+
+ __WIFI_AWARE_FUNC_ENTER__;
+ CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+
+ ret = _wifi_aware_session_handle_destroy(session);
+ RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Fail to destroy session handle");
+ return WIFI_AWARE_ERROR_NONE;
+}
+
+API int wifi_aware_publish_create(wifi_aware_publish_h *publish)
+{
+ int ret = WIFI_AWARE_ERROR_NONE;
+
+ __WIFI_AWARE_FUNC_ENTER__;
+ CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+
+ ret = _wifi_aware_publish_handle_create(publish);
RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Fail to create publish handle");
WIFI_AWARE_LOGD("publish handle: %p", *publish);
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_start_publish(wifi_aware_publish_h publish,
+API int wifi_aware_session_publish(wifi_aware_session_h session,
+ wifi_aware_publish_h publish,
wifi_aware_published_cb callback, void *user_data)
{
__WIFI_AWARE_FUNC_ENTER__;
int ret = WIFI_AWARE_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+ 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");
- ret = _wifi_aware_publish_request(publish, callback, user_data);
+ ret = _wifi_aware_publish_request(session, publish, callback, user_data);
RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "_wifi_aware_publish_request");
__WIFI_AWARE_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_cancel_publish(wifi_aware_publish_h publish)
+API int wifi_aware_cancel_publish(wifi_aware_session_h session)
{
__WIFI_AWARE_FUNC_ENTER__;
int ret = WIFI_AWARE_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
- RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
+ RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
- ret = _wifi_aware_cancel_publish_request(publish);
+ ret = _wifi_aware_cancel_publish_request(session);
RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "_wifi_aware_cancel_publish_request");
__WIFI_AWARE_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_update_publish(wifi_aware_publish_h publish,
+API int wifi_aware_session_update_publish(wifi_aware_session_h session,
+ wifi_aware_publish_h publish,
wifi_aware_published_cb callback, void *user_data)
{
__WIFI_AWARE_FUNC_ENTER__;
int ret = WIFI_AWARE_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+ 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");
- ret = _wifi_aware_update_publish_request(publish, callback, user_data);
+ ret = _wifi_aware_update_publish_request(session, publish, callback, user_data);
RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "_wifi_aware_update_publish_request");
__WIFI_AWARE_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_subscribe_create(wifi_aware_h wifi_aware,
- wifi_aware_subscribe_h *subscribe)
+API int wifi_aware_subscribe_create(wifi_aware_subscribe_h *subscribe)
{
int ret = WIFI_AWARE_ERROR_NONE;
__WIFI_AWARE_FUNC_ENTER__;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
- ret = _wifi_aware_subscribe_handle_create(wifi_aware, subscribe);
+ ret = _wifi_aware_subscribe_handle_create(subscribe);
RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Fail to create subscribe handle");
WIFI_AWARE_LOGD("subscribe handle: %p", *subscribe);
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_start_subscribe(wifi_aware_subscribe_h subscribe,
+API int wifi_aware_session_subscribe(wifi_aware_session_h session,
+ wifi_aware_subscribe_h subscribe,
wifi_aware_subscribed_cb callback, void *user_data)
{
__WIFI_AWARE_FUNC_ENTER__;
int ret = WIFI_AWARE_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+ 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");
- ret = _wifi_aware_subscribe_request(subscribe, callback, user_data);
+ ret = _wifi_aware_subscribe_request(session, subscribe, callback, user_data);
RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "_wifi_aware_subscribe_request");
__WIFI_AWARE_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_cancel_subscribe(wifi_aware_subscribe_h subscribe)
+API int wifi_aware_cancel_subscribe(wifi_aware_session_h session)
{
__WIFI_AWARE_FUNC_ENTER__;
int ret = WIFI_AWARE_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+ RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
- ret = _wifi_aware_cancel_subscribe_request(subscribe);
+ ret = _wifi_aware_cancel_subscribe_request(session);
RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "_wifi_aware_cancel_subscribe_request");
__WIFI_AWARE_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_update_subscribe(wifi_aware_subscribe_h subscribe,
+API int wifi_aware_session_update_subscribe(wifi_aware_session_h session,
+ wifi_aware_subscribe_h subscribe,
wifi_aware_subscribed_cb callback, void *user_data)
{
__WIFI_AWARE_FUNC_ENTER__;
int ret = WIFI_AWARE_ERROR_NONE;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+ 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");
- ret = _wifi_aware_update_subscribe_request(subscribe, callback, user_data);
+ ret = _wifi_aware_update_subscribe_request(session, subscribe, callback, user_data);
RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "_wifi_aware_update_subscribe_request");
__WIFI_AWARE_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_set_discovery_result_cb(wifi_aware_subscribe_h subscribe,
+API int wifi_aware_set_discovery_result_cb(wifi_aware_session_h session,
wifi_aware_discovery_result_cb callback, void *user_data)
{
__WIFI_AWARE_FUNC_ENTER__;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+ RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL");
- _wifi_aware_set_discovery_result_cb(subscribe, callback, user_data);
+ _wifi_aware_set_discovery_result_cb(session, callback, user_data);
__WIFI_AWARE_FUNC_EXIT__;
return WIFI_AWARE_ERROR_NONE;
}
-API int wifi_aware_send_message(wifi_aware_peer_h peer,
+API int wifi_aware_send_message(wifi_aware_session_h session,
+ 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__;
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
-
+ 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");
- return _wifi_aware_send_message(peer, message, len, callback, user_data);
+ return _wifi_aware_send_message(session, peer, message, len, callback, user_data);
}
-API int wifi_aware_set_received_message_cb(wifi_aware_h wifi_aware,
+API int wifi_aware_set_received_message_cb(wifi_aware_session_h session,
wifi_aware_received_message_cb callback, void *user_data)
{
__WIFI_AWARE_FUNC_ENTER__;
}\
} while (0)
+#define RET_IF_SESSION_IS_NULL()\
+ do {\
+ if (!g_wifi_aware_session) {\
+ printf("wifi-aware-session handle is not created yet\n");\
+ return;\
+ }\
+ } while (0)
+
#define SERVICE_NAME "CtsVerifierTestService"
#define MATCH_FILTER "bytes used for matching"
#define PUB_SSI "Extra bytes in the publisher discovery"
CMD_ENABLE,
CMD_DISABLE,
+
+ CMD_CREATE_SESSION,
+ CMD_DESTROY_SESSION,
+
CMD_PUBLISH,
CMD_CANCEL_PUBLISH,
CMD_UPDATE_PUBLISH,
*****************************************************************************/
static char *g_menu_str[] = {
- [CMD_QUIT]
- = "QUIT",
- [CMD_FULL_MENU]
- = "FULL_MENU",
- [CMD_INITIALIZE]
- = "INITIALIZE",
- [CMD_DEINITIALIZE]
- = "DEINITIALIZE",
-
- [CMD_ENABLE]
- = "ENABLE",
- [CMD_DISABLE]
- = "DISABLE",
-
- [CMD_PUBLISH]
- = "PUBLISH",
- [CMD_CANCEL_PUBLISH]
- = "CANCEL PUBLISH",
- [CMD_UPDATE_PUBLISH]
- = "UPDATE PUBLISH",
- [CMD_SUBSCRIBE]
- = "SUBSCRIBE",
- [CMD_CANCEL_SUBSCRIBE]
- = "CANCEL SUBSCRIBE",
- [CMD_TEST_SPECIFIC_INFO]
- = "TEST SPECIFIC INFO",
-
- [CMD_INVALID]
- = NULL, };
+ [CMD_QUIT]
+ = "QUIT",
+ [CMD_FULL_MENU]
+ = "FULL_MENU",
+ [CMD_INITIALIZE]
+ = "INITIALIZE",
+ [CMD_DEINITIALIZE]
+ = "DEINITIALIZE",
+
+ [CMD_ENABLE]
+ = "ENABLE",
+ [CMD_DISABLE]
+ = "DISABLE",
+
+ [CMD_CREATE_SESSION]
+ = "CREATE_SESSION",
+ [CMD_DESTROY_SESSION]
+ = "DESTROY_SESSION",
+
+ [CMD_PUBLISH]
+ = "PUBLISH",
+ [CMD_CANCEL_PUBLISH]
+ = "CANCEL PUBLISH",
+ [CMD_UPDATE_PUBLISH]
+ = "UPDATE PUBLISH",
+ [CMD_SUBSCRIBE]
+ = "SUBSCRIBE",
+ [CMD_CANCEL_SUBSCRIBE]
+ = "CANCEL SUBSCRIBE",
+ [CMD_TEST_SPECIFIC_INFO]
+ = "TEST SPECIFIC INFO",
+
+ [CMD_INVALID]
+ = NULL,
+};
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;
printf("Wi-Fi Aware is not enabled. Error: %s\n", __print_error(error));
}
+void test_create_session()
+{
+ int ret = 0;
+ RET_IF_LOOP_IS_NULL();
+ RET_IF_HANDLE_IS_NULL();
+ ret = wifi_aware_session_create(g_wifi_aware_handle, g_wifi_aware_session);
+ __print_result(ret, "wifi_aware_session_create");
+}
+
+void test_destroy_session()
+{
+}
+
void test_enable()
{
int ret = 0;
__print_result(ret, "wifi_aware_disable");
}
-static void __published_cb(wifi_aware_error_e error, wifi_aware_publish_h publish, void *user_data)
+static void __published_cb(wifi_aware_error_e error, wifi_aware_session_h session, void *user_data)
{
if (error == WIFI_AWARE_ERROR_NONE)
printf("Publish Request is success. Publish ID: [*]\n");
RET_IF_LOOP_IS_NULL();
RET_IF_HANDLE_IS_NULL();
+ RET_IF_SESSION_IS_NULL();
- ret = wifi_aware_publish_create(g_wifi_aware_handle, &g_publish_handle);
+ ret = wifi_aware_publish_create(&g_publish_handle);
__print_result(ret, "wifi_aware_publish_create");
__set_publish_config(g_publish_handle);
- ret = wifi_aware_start_publish(g_publish_handle, __published_cb, NULL);
+ ret = wifi_aware_session_publish(g_wifi_aware_session, g_publish_handle, __published_cb, NULL);
__print_result(ret, "wifi_aware_publish");
//ret = wifi_aware_publish_destroy(publish);
RET_IF_LOOP_IS_NULL();
RET_IF_HANDLE_IS_NULL();
+ RET_IF_SESSION_IS_NULL();
if (g_publish_handle == NULL) {
printf("publish should be done\n");
return;
}
- ret = wifi_aware_cancel_publish(g_publish_handle);
+ ret = wifi_aware_session_stop_publish(g_wifi_aware_session);
__print_result(ret, "wifi_aware_cancel_publish");
}
-static void __updated_publish_cb(wifi_aware_error_e error, wifi_aware_publish_h publish, void *user_data)
+static void __updated_publish_cb(wifi_aware_error_e error, wifi_aware_session_h session, void *user_data)
{
if (error == WIFI_AWARE_ERROR_NONE)
printf("Update Publish Request is success. Publish ID: [*]\n");
RET_IF_LOOP_IS_NULL();
RET_IF_HANDLE_IS_NULL();
+ RET_IF_SESSION_IS_NULL();
if (g_publish_handle == NULL) {
printf("publish should be done\n");
if (ret != WIFI_AWARE_ERROR_NONE)
return;
- ret = wifi_aware_update_publish(g_publish_handle, __updated_publish_cb, NULL);
+ ret = wifi_aware_session_update_publish(g_wifi_aware_session, g_publish_handle, __updated_publish_cb, NULL);
__print_result(ret, "wifi_aware_update_publish");
}
printf("Subscirbe Request fails. Error: %s\n", __print_error(error));
}
-static void __discovery_result_cb(wifi_aware_subscribe_h subscribe,
+static void __discovery_result_cb(wifi_aware_session_h session,
wifi_aware_peer_h peer,
unsigned char *service_specific_info, size_t service_specific_info_len,
void *user_data)
RET_IF_LOOP_IS_NULL();
RET_IF_HANDLE_IS_NULL();
+ RET_IF_SESSION_IS_NULL();
- ret = wifi_aware_subscribe_create(g_wifi_aware_handle, &g_subscribe_handle);
+ ret = wifi_aware_subscribe_create(&g_subscribe_handle);
__print_result(ret, "wifi_aware_subscribe_create");
ret = wifi_aware_set_discovery_result_cb(g_subscribe_handle, __discovery_result_cb, NULL);
__set_subscribe_config(g_subscribe_handle);
- ret = wifi_aware_start_subscribe(g_subscribe_handle, __subscribed_cb, NULL);
+ ret = wifi_aware_session_subscribe(g_wifi_aware_session, g_subscribe_handle, __subscribed_cb, NULL);
__print_result(ret, "wifi_aware_subscribe");
ret = wifi_aware_subscribe_destroy(g_subscribe_handle);
RET_IF_LOOP_IS_NULL();
RET_IF_HANDLE_IS_NULL();
+ RET_IF_SESSION_IS_NULL();
if (g_subscribe_handle == NULL) {
printf("subscribe should be done\n");
return;
}
- ret = wifi_aware_cancel_subscribe(g_subscribe_handle);
+ ret = wifi_aware_session_stop_subscribe(g_wifi_aware_session);
__print_result(ret, "wifi_aware_cancel_subscribe");
}
RET_IF_HANDLE_IS_NULL();
for (int i = 0; i < sizeof(info_test_data) / sizeof(info_test_data[0]); ++i) {
- ret = wifi_aware_publish_create(g_wifi_aware_handle, &info_test_data[i].handle);
+ ret = wifi_aware_publish_create(&info_test_data[i].handle);
__print_result(ret, "wifi_aware_publish_create");
ret = wifi_aware_publish_set_type(info_test_data[i].handle, WIFI_AWARE_PUBLISH_TYPE_UNSOLICITED);
if (ret != WIFI_AWARE_ERROR_NONE)
return;
- ret = wifi_aware_start_publish(info_test_data[i].handle, __published_cb, NULL);
+ ret = wifi_aware_session_publish(g_wifi_aware_session, info_test_data[i].handle, __published_cb, NULL);
}
}
[CMD_DEINITIALIZE] = test_deinit,
[CMD_ENABLE] = test_enable,
[CMD_DISABLE] = test_disable,
+ [CMD_CREATE_SESSION] = test_create_session,
+ [CMD_DESTROY_SESSION] = test_destroy_session,
[CMD_PUBLISH] = test_publish,
[CMD_CANCEL_PUBLISH] = test_cancel_publish,
[CMD_UPDATE_PUBLISH] = test_update_publish,
projects / platform / core / api / wifi-aware.git / commitdiff