From: Cheoleun Moon Date: Tue, 25 Feb 2020 04:36:20 +0000 (+0900) Subject: Fix bugs X-Git-Tag: submit/tizen/20200403.050222~2^2~56^2~4 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=4f597cc5446201ac5f38c2274c16dd97271a49b6;p=platform%2Fcore%2Fapi%2Fwifi-aware.git Fix bugs --- diff --git a/include/wifi-aware.h b/include/wifi-aware.h index 5affab4..fe9d184 100644 --- a/include/wifi-aware.h +++ b/include/wifi-aware.h @@ -96,16 +96,20 @@ typedef enum { WIFI_AWARE_ERROR_OPERATION_FAILED = TIZEN_ERROR_WIFI_AWARE|0x03, } wifi_aware_error_e; +typedef enum { + WIFI_AWARE_SESSION_PUBLISH = 0, + WIFI_AWARE_SESSION_SUBSCRIBE, +} wifi_aware_session_type_e; typedef enum { - WIFI_AWARE_PUBLISH_TYPE_UNSOLICITED,/**< Unsolicited type */ + WIFI_AWARE_PUBLISH_TYPE_UNSOLICITED = 0,/**< Unsolicited type */ WIFI_AWARE_PUBLISH_TYPE_SOLICITED, /**< Solicited type */ // TODO: // WIFI_AWARE_PUBLISH_TYPE_UNSOLICITED_SOLICITED } wifi_aware_publish_type_e; typedef enum { - WIFI_AWARE_SUBSCRIBE_TYPE_PASSIVE, /**< Passive type */ + WIFI_AWARE_SUBSCRIBE_TYPE_PASSIVE = 0, /**< Passive type */ WIFI_AWARE_SUBSCRIBE_TYPE_ACTIVE, /**< Active type */ } wifi_aware_subscribe_type_e; @@ -389,11 +393,13 @@ int wifi_aware_disable(wifi_aware_h wifi_aware); * @brief * @since_tizen 6.0 * @param[in] wifi_aware + * @param[in] session_type * @param[in] session * @return 0 on success, otherwise a negative error value * @retval #WIFI_AWARE_ERROR_NONE */ -int wifi_aware_session_create(wifi_aware_h wifi_aware, wifi_aware_session_h *session); +int wifi_aware_session_create(wifi_aware_h wifi_aware, wifi_aware_session_type_e session_type, + wifi_aware_session_h *session); /** * @brief @@ -408,16 +414,16 @@ int wifi_aware_session_destroy(wifi_aware_session_h session); /** * @brief This callback delivers the result of a Publish request. * @since_tizen 6.0 - * @param[in] error * @param[in] session + * @param[in] error * @param[in] user_data * @return 0 on success, otherwise a negative error value * @retval #WIFI_AWARE_ERROR_NONE * @see wifi_aware_session_publish() * @see wifi_aware_session_update_publish() */ -typedef void(*wifi_aware_published_cb)(wifi_aware_error_e error, - wifi_aware_session_h session, void *user_data); +typedef void(*wifi_aware_published_cb)(wifi_aware_session_h session, + wifi_aware_error_e error, void *user_data); /** * @brief Publish a Wi-Fi Aware service so that neighboring devices can find it. @@ -435,15 +441,6 @@ int wifi_aware_session_publish(wifi_aware_session_h session, void *user_data); /** - * @brief Cancel a published Wi-Fi Aware service so that it cannot be found. - * @since_tizen 6.0 - * @param[in] sesssion - * @return 0 on success, otherwise a negative error value - * @retval #WIFI_AWARE_ERROR_NONE - */ -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 @@ -460,14 +457,14 @@ int wifi_aware_session_update_publish(wifi_aware_session_h session, /** * @brief * @since_tizen 6.0 - * @param[in] error * @param[in] session + * @param[in] error * @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_session_h session, void *user_data); +typedef void(*wifi_aware_subscribed_cb)(wifi_aware_session_h session, + wifi_aware_error_e error, void *user_data); /** * @brief Start to find Wi-Fi Aware services. @@ -484,13 +481,13 @@ int wifi_aware_session_subscribe(wifi_aware_session_h, wifi_aware_subscribed_cb callback, void *user_data); /** - * @brief Stop finding Wi-Fi Aware services. + * @brief Stop a Wi-Fi Aware session. The function of the session, Publish or Subscribe, will be cancelled. * @since_tizen 6.0 * @param[in] session * @return 0 on success, otherwise a negative error value * @retval #WIFI_AWARE_ERROR_NONE */ -int wifi_aware_session_stop_subscribe(wifi_aware_session_h session); +int wifi_aware_session_stop(wifi_aware_session_h session); /** * @brief Update the configuration for a Wi-Fi Aware service that has already been subscribed. diff --git a/src/include/wifi-aware-private.h b/src/include/wifi-aware-private.h index 5a8f537..f99fd76 100644 --- a/src/include/wifi-aware-private.h +++ b/src/include/wifi-aware-private.h @@ -47,7 +47,8 @@ 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_session_handle_create(wifi_aware_h wifi_aware, wifi_aware_session_h *session_handle); +int _wifi_aware_session_handle_create(wifi_aware_h wifi_aware, + wifi_aware_session_type_e session_type, wifi_aware_session_h *session_handle); int _wifi_aware_session_handle_destroy(wifi_aware_session_h session_handle); int _wifi_aware_publish_handle_create(wifi_aware_publish_h *publish); @@ -64,7 +65,6 @@ void _wifi_aware_publish_set_enable_termination_event(wifi_aware_publish_h publi void _wifi_aware_publish_set_enable_ranging(wifi_aware_publish_h publish, bool enable); 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_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); @@ -83,12 +83,13 @@ void _wifi_aware_subscribe_set_match_filter(wifi_aware_subscribe_h subscribe, void _wifi_aware_subscribe_set_enable_termination_event(wifi_aware_subscribe_h subscribe, bool enable); 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_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_session_get_subscribe_id(wifi_aware_session_h session); +int _wifi_aware_session_cancel(wifi_aware_session_h session); + void _wifi_aware_set_discovery_result_cb(wifi_aware_session_h session, wifi_aware_discovery_result_cb callback, void *user_data); diff --git a/src/wifi-aware-private.c b/src/wifi-aware-private.c index 415dc0e..49b28b8 100644 --- a/src/wifi-aware-private.c +++ b/src/wifi-aware-private.c @@ -53,29 +53,14 @@ enum { NAN_ERROR_UNKNOWN, } nan_manager_error_e; -typedef enum { - WIFI_AWARE_PUBLISH = 0, - WIFI_AWARE_SUBSCRIBE, -} wifi_aware_session_type_e; - typedef struct { uint32_t publish_id; wifi_aware_publish_request_s req; - - wifi_aware_published_cb published_cb; - void *published_cb_data; } wifi_aware_publish_s; typedef struct { uint32_t subscribe_id; wifi_aware_subscribe_request_s req; - - wifi_aware_subscribed_cb subscribed_cb; - void *subscribed_cb_data; - - wifi_aware_discovery_result_cb discovered_cb; - void *discovered_cb_data; - guint discovered_signal_id; } wifi_aware_subscribe_s; typedef struct { @@ -83,13 +68,24 @@ typedef struct { wifi_aware_session_type_e session_type; wifi_aware_publish_s *publish_config; wifi_aware_subscribe_s *subscribe_config; + bool is_requested; + + wifi_aware_published_cb published_cb; + void *published_cb_data; + + wifi_aware_subscribed_cb subscribed_cb; + void *subscribed_cb_data; + + wifi_aware_discovery_result_cb discovered_cb; + void *discovered_cb_data; + guint discovered_signal_id; 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; + guint received_signal_id; } wifi_aware_session_s; typedef struct { @@ -184,6 +180,18 @@ bool _wifi_aware_handle_is_valid(wifi_aware_h wifi_aware) return true; } +static void __session_set_requested(wifi_aware_session_h session_handle) +{ + wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle; + session->is_requested = true; +} + +static bool __session_is_requested(wifi_aware_session_h session_handle) +{ + wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle; + return session->is_requested; +} + static int __session_get_client_id(wifi_aware_session_h session_handle) { wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle; @@ -193,13 +201,13 @@ static int __session_get_client_id(wifi_aware_session_h session_handle) static int __is_publish_session(wifi_aware_session_h session_handle) { wifi_aware_session_s *session = (wifi_aware_session_s *)session_handle; - return session->session_type == WIFI_AWARE_PUBLISH; + return session->session_type == WIFI_AWARE_SESSION_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; + return session->session_type == WIFI_AWARE_SESSION_SUBSCRIBE; } static wifi_aware_s *__session_get_wifi_aware(wifi_aware_session_h session_handle) @@ -248,10 +256,10 @@ static void __enable_request_reply(GObject *src, GAsyncResult *res, gpointer use aware->enabled_cb(error, aware->enabled_cb_data); } -static void __add_published_callback(wifi_aware_publish_h publish, +static void __session_add_published_callback(wifi_aware_session_h session, wifi_aware_published_cb callback, void *user_data) { - wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish; + wifi_aware_session_s *handle = (wifi_aware_session_s *)session; handle->published_cb = callback; handle->published_cb_data = user_data; } @@ -270,13 +278,26 @@ static void __wifi_aware_publish_set_id(wifi_aware_publish_h publish, unsigned i handle->publish_id = publish_id; } -static void __wifi_aware_publish_invoke_callback(wifi_aware_error_e error, wifi_aware_publish_h publish) +static void __wifi_aware_publish_invoke_callback(wifi_aware_session_h session, + wifi_aware_error_e error) { - RET_IF(publish == NULL, "wifi_aware_publish_h is NULL"); + RET_IF(session == NULL, "Session is NULL"); + wifi_aware_session_s *handle = (wifi_aware_session_s *)session; - wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish; if (handle->published_cb) - handle->published_cb(error, publish, handle->published_cb_data); + handle->published_cb(session, error, handle->published_cb_data); +} + +static void __wifi_aware_discovered_cb(wifi_aware_session_h session, wifi_aware_peer_h peer, + unsigned char *specific_info, size_t specific_info_len) +{ + RET_IF(session == NULL, "Session is NULL"); + wifi_aware_session_s *handle = (wifi_aware_session_s *)session; + + if (handle->discovered_cb) + handle->discovered_cb(session, peer, + specific_info, specific_info_len, + handle->discovered_cb_data); } static void __publish_request_reply(GObject *src, GAsyncResult *res, gpointer user_data) @@ -284,12 +305,14 @@ static void __publish_request_reply(GObject *src, GAsyncResult *res, gpointer us GDBusConnection *conn = NULL; GError *dbus_error = NULL; GVariant *reply = NULL; - wifi_aware_publish_h publish = (wifi_aware_publish_h)user_data; + wifi_aware_session_h session = (wifi_aware_session_h)user_data; + wifi_aware_publish_s *publish_config = NULL; wifi_aware_error_e error = WIFI_AWARE_ERROR_NONE; int nan_error = 0; - unsigned int publish_id = -1; + unsigned int publish_id = 0; WIFI_AWARE_LOGI("Reply for Publish Request"); + RET_IF(session == NULL, "Session is NULL"); conn = G_DBUS_CONNECTION(src); reply = g_dbus_connection_call_finish(conn, res, &dbus_error); @@ -306,16 +329,15 @@ static void __publish_request_reply(GObject *src, GAsyncResult *res, gpointer us error = _wifi_aware_convert_nan_manager_error(nan_error); } - __wifi_aware_publish_set_id(publish, publish_id); - __wifi_aware_publish_invoke_callback( - error, - publish); + publish_config = __session_get_publish_config(session); + __wifi_aware_publish_set_id(publish_config, publish_id); + __wifi_aware_publish_invoke_callback(session, error); } -static void __add_subscribed_callback(wifi_aware_subscribe_h subscribe, +static void __session_add_subscribed_callback(wifi_aware_session_h session, wifi_aware_subscribed_cb callback, void *user_data) { - wifi_aware_subscribe_s *handle = (wifi_aware_subscribe_s *)subscribe; + wifi_aware_session_s *handle = (wifi_aware_session_s *)session; handle->subscribed_cb = callback; handle->subscribed_cb_data = user_data; } @@ -327,13 +349,13 @@ static int __is_subscribed(wifi_aware_subscribe_h subscribe) return handle->subscribe_id > 0; } -static void __wifi_aware_subscribe_invoke_callback(wifi_aware_error_e error, wifi_aware_subscribe_h subscribe) +static void __wifi_aware_subscribe_invoke_callback(wifi_aware_session_h session, wifi_aware_error_e error) { - RET_IF(subscribe == NULL, "wifi_aware_subscribe_h is NULL"); + RET_IF(session == NULL, "Session is NULL"); + wifi_aware_session_s *handle = (wifi_aware_session_s *)session; - wifi_aware_subscribe_s *handle = (wifi_aware_subscribe_s *)subscribe; if (handle->subscribed_cb) - handle->subscribed_cb(error, subscribe, handle->subscribed_cb_data); + handle->subscribed_cb(session, error, handle->subscribed_cb_data); } static void __wifi_aware_subscribe_set_id(wifi_aware_subscribe_h subscribe, unsigned int subscribe_id) @@ -355,12 +377,14 @@ static void __subscribe_request_reply(GObject *src, GAsyncResult *res, gpointer GDBusConnection *conn = NULL; GError *dbus_error = NULL; GVariant *reply = NULL; - wifi_aware_subscribe_h subscribe = (wifi_aware_subscribe_h)user_data; + wifi_aware_session_h session = (wifi_aware_session_h)user_data; + wifi_aware_subscribe_s *subscribe_config = NULL; wifi_aware_error_e error = WIFI_AWARE_ERROR_NONE; int nan_error = 0; - unsigned int subscribe_id = -1; + unsigned int subscribe_id = 0; WIFI_AWARE_LOGI("Reply for Subscribe Request"); + RET_IF(session == NULL, "Session is NULL"); conn = G_DBUS_CONNECTION(src); reply = g_dbus_connection_call_finish(conn, res, &dbus_error); @@ -377,10 +401,9 @@ static void __subscribe_request_reply(GObject *src, GAsyncResult *res, gpointer error = _wifi_aware_convert_nan_manager_error(nan_error); } - __wifi_aware_subscribe_set_id(subscribe, subscribe_id); - __wifi_aware_subscribe_invoke_callback( - error, - subscribe); + subscribe_config = __session_get_subscribe_config(session); + __wifi_aware_subscribe_set_id(subscribe_config, subscribe_id); + __wifi_aware_subscribe_invoke_callback(session, error); } unsigned int _wifi_aware_session_get_publish_id(wifi_aware_session_h session) @@ -475,14 +498,25 @@ int _wifi_aware_disable_request(wifi_aware_h wifi_aware) return wifi_aware_gdbus_disable(wifi_aware, aware->client_id); } -int _wifi_aware_session_handle_create(wifi_aware_h wifi_aware, wifi_aware_session_h *session_handle) +int _wifi_aware_session_handle_create(wifi_aware_h wifi_aware, + wifi_aware_session_type_e session_type, wifi_aware_session_h *session_handle) { wifi_aware_session_s *session = (wifi_aware_session_s *)g_try_malloc0(sizeof(wifi_aware_session_s)); RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_OUT_OF_MEMORY, "Out of memory"); - *session_handle = session; + *session_handle = (wifi_aware_session_h)session; session->wifi_aware_handle = wifi_aware; + session->session_type = session_type; + session->publish_config = NULL; + session->subscribe_config = NULL; + session->is_requested = false; + + session->send_cb = NULL; + session->send_cb_data = NULL; + session->received_cb = NULL; + session->received_cb_data = NULL; + session->received_signal_id = 0; return WIFI_AWARE_ERROR_NONE; } @@ -590,26 +624,18 @@ int _wifi_aware_publish_request(wifi_aware_session_h session, 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(__session_is_requested(session), WIFI_AWARE_ERROR_INVALID_OPERATION, + "Already requested"); __session_set_publish_config(session, publish); - __add_published_callback(publish, callback, user_data); + __session_set_requested(session); + __session_add_published_callback(session, callback, user_data); return wifi_aware_gdbus_publish(session, publish, __session_get_client_id(session), __publish_request_reply); } -int _wifi_aware_cancel_publish_request(wifi_aware_session_h session) -{ - 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(session, __session_get_client_id(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) @@ -622,7 +648,7 @@ int _wifi_aware_update_publish_request(wifi_aware_session_h session, "The publish is not done yet"); __session_set_publish_config(session, publish); - __add_published_callback(publish, callback, user_data); + __session_add_published_callback(session, callback, user_data); return wifi_aware_gdbus_update_publish(session, publish, __session_get_client_id(session), @@ -713,44 +739,73 @@ int _wifi_aware_subscribe_request(wifi_aware_session_h session, 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(__session_is_requested(session), WIFI_AWARE_ERROR_INVALID_OPERATION, + "Already requested"); __session_set_subscribe_config(session, subscribe); - __add_subscribed_callback(subscribe, callback, user_data); + __session_set_requested(session); + __session_add_subscribed_callback(session, callback, user_data); return wifi_aware_gdbus_subscribe(session, subscribe, __session_get_client_id(session), __subscribe_request_reply); } -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) { 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"); - return wifi_aware_gdbus_cancel_subscribe(session, - __session_get_client_id(session)); + __session_set_subscribe_config(session, subscribe); + __session_add_subscribed_callback(session, callback, user_data); + + return wifi_aware_gdbus_update_subscribe(session, subscribe, + __session_get_client_id(session), + __subscribe_request_reply); } -int _wifi_aware_update_subscribe_request(wifi_aware_session_h session, - wifi_aware_subscribe_h subscribe, - wifi_aware_subscribed_cb callback, void *user_data) +static int __wifi_aware_cancel_publish_request(wifi_aware_session_h session) +{ + 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(session, __session_get_client_id(session)); +} + +static int __wifi_aware_cancel_subscribe_request(wifi_aware_session_h session) { 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_cancel_subscribe(session, + __session_get_client_id(session)); +} - return wifi_aware_gdbus_update_subscribe(session, subscribe, - __session_get_client_id(session), - __subscribe_request_reply); +int _wifi_aware_session_cancel(wifi_aware_session_h session) +{ + RET_VAL_IF(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL"); + if (__is_publish_session(session)) { + WIFI_AWARE_LOGD("Stop publish session"); + return __wifi_aware_cancel_publish_request(session); + } + if (__is_subscribe_session(session)) { + WIFI_AWARE_LOGD("Stop subscribe session"); + return __wifi_aware_cancel_subscribe_request(session); + } + WIFI_AWARE_LOGE("Invalid session"); + return WIFI_AWARE_ERROR_INVALID_OPERATION; } static void __parsing_service_discovered_event(GVariant *parameters, @@ -820,10 +875,7 @@ static void __service_discovered_cb(GDBusConnection *connection, return; } - if (subscribe_config->discovered_cb) - subscribe_config->discovered_cb(session, peer, - specific_info, specific_info_len, - subscribe_config->discovered_cb_data); + __wifi_aware_discovered_cb(session, peer, specific_info, specific_info_len); } void _wifi_aware_set_discovery_result_cb(wifi_aware_session_h session, @@ -832,10 +884,10 @@ void _wifi_aware_set_discovery_result_cb(wifi_aware_session_h session, __WIFI_AWARE_FUNC_ENTER__; RET_IF(!__is_subscribe_session(session), "This session is not for Subscribe"); - 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_session_s *handle = (wifi_aware_session_s *)session; + handle->discovered_cb = callback; + handle->discovered_cb_data = user_data; + handle->discovered_signal_id = wifi_aware_gdbus_register_signal(SERVICE_DISCOVERED_SIGNAL, __service_discovered_cb, session); } diff --git a/src/wifi-aware.c b/src/wifi-aware.c index 00aaa1d..bdfc886 100644 --- a/src/wifi-aware.c +++ b/src/wifi-aware.c @@ -102,16 +102,18 @@ API int wifi_aware_disable(wifi_aware_h wifi_aware) return WIFI_AWARE_ERROR_NONE; } -API int wifi_aware_session_create(wifi_aware_h wifi_aware, wifi_aware_session_h *session) +API int wifi_aware_session_create(wifi_aware_h wifi_aware, + wifi_aware_session_type_e session_type, wifi_aware_session_h *session) { int ret = WIFI_AWARE_ERROR_NONE; __WIFI_AWARE_FUNC_ENTER__; CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE); - ret = _wifi_aware_session_handle_create(wifi_aware, session); + ret = _wifi_aware_session_handle_create(wifi_aware, session_type, session); RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Fail to create session handle"); WIFI_AWARE_LOGD("session handle: %p", *session); + WIFI_AWARE_LOGD("session type: %d", session_type); __WIFI_AWARE_FUNC_EXIT__; return WIFI_AWARE_ERROR_NONE; @@ -286,21 +288,6 @@ API int wifi_aware_session_publish(wifi_aware_session_h session, return WIFI_AWARE_ERROR_NONE; } -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(session == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_h is NULL"); - - 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_session_update_publish(wifi_aware_session_h session, wifi_aware_publish_h publish, wifi_aware_published_cb callback, void *user_data) @@ -469,7 +456,7 @@ API int wifi_aware_session_subscribe(wifi_aware_session_h session, return WIFI_AWARE_ERROR_NONE; } -API int wifi_aware_cancel_subscribe(wifi_aware_session_h session) +API int wifi_aware_session_stop(wifi_aware_session_h session) { __WIFI_AWARE_FUNC_ENTER__; int ret = WIFI_AWARE_ERROR_NONE; @@ -477,7 +464,8 @@ API int wifi_aware_cancel_subscribe(wifi_aware_session_h session) 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(session); + ret = _wifi_aware_session_cancel(session); + //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__; diff --git a/test/wifi-aware-test.c b/test/wifi-aware-test.c index 1e398ef..9fb0179 100644 --- a/test/wifi-aware-test.c +++ b/test/wifi-aware-test.c @@ -112,9 +112,6 @@ enum { CMD_ENABLE, CMD_DISABLE, - CMD_CREATE_SESSION, - CMD_DESTROY_SESSION, - CMD_PUBLISH, CMD_CANCEL_PUBLISH, CMD_UPDATE_PUBLISH, @@ -144,11 +141,6 @@ static char *g_menu_str[] = { [CMD_DISABLE] = "DISABLE", - [CMD_CREATE_SESSION] - = "CREATE_SESSION", - [CMD_DESTROY_SESSION] - = "DESTROY_SESSION", - [CMD_PUBLISH] = "PUBLISH", [CMD_CANCEL_PUBLISH] @@ -340,19 +332,6 @@ 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; @@ -375,7 +354,8 @@ void test_disable() __print_result(ret, "wifi_aware_disable"); } -static void __published_cb(wifi_aware_error_e error, wifi_aware_session_h session, void *user_data) +static void __published_cb(wifi_aware_session_h session, + wifi_aware_error_e error, void *user_data) { if (error == WIFI_AWARE_ERROR_NONE) printf("Publish Request is success. Publish ID: [*]\n"); @@ -481,6 +461,8 @@ void test_publish() RET_IF_LOOP_IS_NULL(); RET_IF_HANDLE_IS_NULL(); + + ret = wifi_aware_session_create(g_wifi_aware_handle, WIFI_AWARE_SESSION_PUBLISH, &g_wifi_aware_session); RET_IF_SESSION_IS_NULL(); ret = wifi_aware_publish_create(&g_publish_handle); @@ -508,11 +490,12 @@ void test_cancel_publish() return; } - ret = wifi_aware_session_stop_publish(g_wifi_aware_session); + ret = wifi_aware_session_stop(g_wifi_aware_session); __print_result(ret, "wifi_aware_cancel_publish"); } -static void __updated_publish_cb(wifi_aware_error_e error, wifi_aware_session_h session, void *user_data) +static void __updated_publish_cb(wifi_aware_session_h session, + wifi_aware_error_e error, void *user_data) { if (error == WIFI_AWARE_ERROR_NONE) printf("Update Publish Request is success. Publish ID: [*]\n"); @@ -546,7 +529,8 @@ void test_update_publish() __print_result(ret, "wifi_aware_update_publish"); } -static void __subscribed_cb(wifi_aware_error_e error, wifi_aware_subscribe_h subscribe, void *user_data) +static void __subscribed_cb(wifi_aware_session_h session, + wifi_aware_error_e error, void *user_data) { if (error == WIFI_AWARE_ERROR_NONE) printf("Subscribe Request is success. Subscirbe ID: [*]\n"); @@ -619,12 +603,14 @@ void test_subscribe() RET_IF_LOOP_IS_NULL(); RET_IF_HANDLE_IS_NULL(); + + ret = wifi_aware_session_create(g_wifi_aware_handle, WIFI_AWARE_SESSION_SUBSCRIBE, &g_wifi_aware_session); RET_IF_SESSION_IS_NULL(); 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); + ret = wifi_aware_set_discovery_result_cb(g_wifi_aware_session, __discovery_result_cb, NULL); __print_result(ret, "wifi_aware_set_discovery_result_cb"); __set_subscribe_config(g_subscribe_handle); @@ -649,21 +635,22 @@ void test_cancel_subscribe() return; } - ret = wifi_aware_session_stop_subscribe(g_wifi_aware_session); + ret = wifi_aware_session_stop(g_wifi_aware_session); __print_result(ret, "wifi_aware_cancel_subscribe"); } static struct { + wifi_aware_session_h session; wifi_aware_publish_h handle; char service_name[MAX_SERVICE_NAME_LEN + 1]; unsigned char info[MAX_SPECIFIC_INFO_LEN]; size_t len; } info_test_data[] = { - { NULL, "SPECIFIC_INFO_TEST_1", {1, 2, 3, 4, 5}, 5 }, - { NULL, "SPECIFIC_INFO_TEST_2", {'A', 'B', 'C', '\0'}, 4 }, - { NULL, "SPECIFIC_INFO_TEST_3", {0, 0, 0, 0, 0, 0, 0}, 7 }, - { NULL, "SPECIFIC_INFO_TEST_4", {1, 2, 3, 4, 5}, 3 }, - { NULL, "SPECIFIC_INFO_TEST_5", {1, 2, 3, 4, 5}, 7 }, + { NULL, NULL, "SPECIFIC_INFO_TEST_1", {1, 2, 3, 4, 5}, 5 }, + { NULL, NULL, "SPECIFIC_INFO_TEST_2", {'A', 'B', 'C', '\0'}, 4 }, + { NULL, NULL, "SPECIFIC_INFO_TEST_3", {0, 0, 0, 0, 0, 0, 0}, 7 }, + { NULL, NULL, "SPECIFIC_INFO_TEST_4", {1, 2, 3, 4, 5}, 3 }, + { NULL, NULL, "SPECIFIC_INFO_TEST_5", {1, 2, 3, 4, 5}, 7 }, }; void test_specific_info() @@ -674,6 +661,10 @@ 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_session_create(g_wifi_aware_handle, + WIFI_AWARE_SESSION_PUBLISH, &info_test_data[i].session); + __print_result(ret, "wifi_aware_session_create"); + ret = wifi_aware_publish_create(&info_test_data[i].handle); __print_result(ret, "wifi_aware_publish_create"); @@ -694,7 +685,8 @@ void test_specific_info() if (ret != WIFI_AWARE_ERROR_NONE) return; - ret = wifi_aware_session_publish(g_wifi_aware_session, info_test_data[i].handle, __published_cb, NULL); + ret = wifi_aware_session_publish(info_test_data[i].session, info_test_data[i].handle, __published_cb, NULL); + __print_result(ret, "wifi_aware_session_publish"); } } @@ -706,8 +698,6 @@ 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,