From 998086bbbe183a19e64e94dd260ccc096ca4b731 Mon Sep 17 00:00:00 2001 From: Cheoleun Moon Date: Mon, 24 Feb 2020 20:09:20 +0900 Subject: [PATCH] Introduce wifi_aware_session_h --- include/wifi-aware.h | 112 ++++++++++------- src/include/wifi-aware-gdbus.h | 19 +-- src/include/wifi-aware-private.h | 27 ++-- src/wifi-aware-gdbus.c | 35 +++--- src/wifi-aware-private.c | 258 ++++++++++++++++++++++++++------------- src/wifi-aware.c | 85 +++++++++---- test/wifi-aware-test.c | 121 +++++++++++------- 7 files changed, 435 insertions(+), 222 deletions(-) diff --git a/include/wifi-aware.h b/include/wifi-aware.h index 3cd8ace..5affab4 100644 --- a/include/wifi-aware.h +++ b/include/wifi-aware.h @@ -117,13 +117,19 @@ typedef enum { 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; @@ -160,13 +166,12 @@ int wifi_aware_deinitialize(wifi_aware_h wifi_aware); /** * @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. @@ -181,12 +186,11 @@ int wifi_aware_publish_destroy(wifi_aware_publish_h publish); /** * @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. @@ -346,16 +350,6 @@ int wifi_aware_subscribe_set_max_distance(wifi_aware_subscribe_h subscribe, int */ 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 @@ -392,109 +386,137 @@ int wifi_aware_enable(wifi_aware_h wifi_aware, 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); @@ -502,26 +524,29 @@ typedef void(*wifi_aware_discovery_result_cb)(wifi_aware_subscribe_h subscribe, /** * @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 @@ -530,31 +555,36 @@ typedef void(*wifi_aware_send_message_result_cb)(wifi_aware_error_e error, void * @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); diff --git a/src/include/wifi-aware-gdbus.h b/src/include/wifi-aware-gdbus.h index 179df74..4f041b5 100644 --- a/src/include/wifi-aware-gdbus.h +++ b/src/include/wifi-aware-gdbus.h @@ -58,14 +58,19 @@ guint wifi_aware_gdbus_register_signal(wifi_aware_signal_e signal, 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 diff --git a/src/include/wifi-aware-private.h b/src/include/wifi-aware-private.h index 6d73c08..5a8f537 100644 --- a/src/include/wifi-aware-private.h +++ b/src/include/wifi-aware-private.h @@ -47,7 +47,10 @@ 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); -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, @@ -59,15 +62,15 @@ void _wifi_aware_publish_set_match_filter(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, @@ -78,18 +81,18 @@ void _wifi_aware_subscribe_set_service_specific_info(wifi_aware_subscribe_h subs 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); diff --git a/src/wifi-aware-gdbus.c b/src/wifi-aware-gdbus.c index c2d6e6f..2db7d77 100644 --- a/src/wifi-aware-gdbus.c +++ b/src/wifi-aware-gdbus.c @@ -404,7 +404,8 @@ int wifi_aware_gdbus_disable(wifi_aware_h wifi_aware, int client_id) 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; @@ -417,7 +418,7 @@ int wifi_aware_gdbus_publish(wifi_aware_publish_h publish, int client_id, GAsync 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"); @@ -434,13 +435,13 @@ static int __handle_cancel_publish_reply(GVariant *reply) 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"); @@ -465,13 +466,14 @@ int wifi_aware_gdbus_cancel_publish(wifi_aware_publish_h publish, int client_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."); @@ -484,7 +486,7 @@ int wifi_aware_gdbus_update_publish(wifi_aware_publish_h publish, int client_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"); @@ -492,7 +494,8 @@ int wifi_aware_gdbus_update_publish(wifi_aware_publish_h publish, int client_id, 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; @@ -505,7 +508,7 @@ int wifi_aware_gdbus_subscribe(wifi_aware_subscribe_h subscribe, int client_id, 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"); @@ -522,13 +525,13 @@ static int __handle_cancel_subscribe_reply(GVariant *reply) 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"); @@ -553,13 +556,14 @@ int wifi_aware_gdbus_cancel_subscribe(wifi_aware_subscribe_h subscribe, int clie 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."); @@ -572,7 +576,7 @@ int wifi_aware_gdbus_update_subscribe(wifi_aware_subscribe_h subscribe, int clie 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"); @@ -580,7 +584,8 @@ int wifi_aware_gdbus_update_subscribe(wifi_aware_subscribe_h subscribe, int clie 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) { diff --git a/src/wifi-aware-private.c b/src/wifi-aware-private.c index ce8d3d6..415dc0e 100644 --- a/src/wifi-aware-private.c +++ b/src/wifi-aware-private.c @@ -53,8 +53,12 @@ enum { 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; @@ -63,7 +67,6 @@ typedef struct { } wifi_aware_publish_s; typedef struct { - wifi_aware_s *aware_handle; uint32_t subscribe_id; wifi_aware_subscribe_request_s req; @@ -76,6 +79,21 @@ 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; + + 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; @@ -166,16 +184,40 @@ bool _wifi_aware_handle_is_valid(wifi_aware_h wifi_aware) 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) @@ -341,6 +383,22 @@ static void __subscribe_request_reply(GObject *src, GAsyncResult *res, gpointer 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)); @@ -417,14 +475,31 @@ int _wifi_aware_disable_request(wifi_aware_h wifi_aware) 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; @@ -500,60 +575,67 @@ wifi_aware_publish_request_s *_wifi_aware_publish_get_request(wifi_aware_publish 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; @@ -616,60 +698,61 @@ void _wifi_aware_subscribe_set_enable_termination_event(wifi_aware_subscribe_h s 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) @@ -714,59 +797,66 @@ static void __service_discovered_cb(GDBusConnection *connection, 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) @@ -797,18 +887,22 @@ static void __send_message_reply(GObject *src, GAsyncResult *res, gpointer user_ } __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, diff --git a/src/wifi-aware.c b/src/wifi-aware.c index bc958e1..00aaa1d 100644 --- a/src/wifi-aware.c +++ b/src/wifi-aware.c @@ -102,14 +102,41 @@ API int wifi_aware_disable(wifi_aware_h wifi_aware) 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); @@ -241,62 +268,65 @@ API int wifi_aware_publish_set_enable_ranging( 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); @@ -421,78 +451,85 @@ API int wifi_aware_subscribe_set_enable_termination_event( 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__; diff --git a/test/wifi-aware-test.c b/test/wifi-aware-test.c index 92dbc19..1e398ef 100644 --- a/test/wifi-aware-test.c +++ b/test/wifi-aware-test.c @@ -81,6 +81,14 @@ }\ } 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" @@ -103,6 +111,10 @@ enum { CMD_ENABLE, CMD_DISABLE, + + CMD_CREATE_SESSION, + CMD_DESTROY_SESSION, + CMD_PUBLISH, CMD_CANCEL_PUBLISH, CMD_UPDATE_PUBLISH, @@ -118,38 +130,45 @@ enum { *****************************************************************************/ 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; @@ -321,6 +340,19 @@ static void __enabled_cb(wifi_aware_error_e error, void *user_data) 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; @@ -343,7 +375,7 @@ void test_disable() __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"); @@ -449,13 +481,14 @@ void test_publish() 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); @@ -468,17 +501,18 @@ void test_cancel_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"); @@ -494,6 +528,7 @@ void test_update_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"); @@ -507,7 +542,7 @@ void test_update_publish() 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"); } @@ -519,7 +554,7 @@ static void __subscribed_cb(wifi_aware_error_e error, wifi_aware_subscribe_h sub 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) @@ -584,8 +619,9 @@ void test_subscribe() 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); @@ -593,7 +629,7 @@ void test_subscribe() __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); @@ -606,13 +642,14 @@ void test_cancel_subscribe() 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"); } @@ -637,7 +674,7 @@ void test_specific_info() 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); @@ -657,7 +694,7 @@ void test_specific_info() 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); } } @@ -669,6 +706,8 @@ test_func g_menu_func[] = { [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, -- 2.7.4