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 {
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 {
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;
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)
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;
}
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)
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);
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;
}
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)
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);
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)
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;
}
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)
"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),
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,
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,
__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);
}
CMD_ENABLE,
CMD_DISABLE,
- CMD_CREATE_SESSION,
- CMD_DESTROY_SESSION,
-
CMD_PUBLISH,
CMD_CANCEL_PUBLISH,
CMD_UPDATE_PUBLISH,
[CMD_DISABLE]
= "DISABLE",
- [CMD_CREATE_SESSION]
- = "CREATE_SESSION",
- [CMD_DESTROY_SESSION]
- = "DESTROY_SESSION",
-
[CMD_PUBLISH]
= "PUBLISH",
[CMD_CANCEL_PUBLISH]
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_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");
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);
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");
__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");
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);
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()
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");
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");
}
}
[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