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] wifi_aware
+ * @param[in] publish_id
+ * @return 0 on success, otherwise a negative error value
+ * @retval #WIFI_AWARE_ERROR_NONE
+ */
+int wifi_aware_cancel_publish(wifi_aware_h wifi_aware,
+ unsigned int publish_id);
+
+/**
* @brief Update the configuration for a Wi-Fi Aware service that has already been published.
* @since_tizen 6.0
* @param[in] wifi_aware
unsigned int subscribe_id, void *user_data);
/**
- * @brief
+ * @brief Start to find Wi-Fi Aware services with configuration.
* @since_tizen 6.0
* @param[in] wifi_aware
* @param[in] config
int wifi_aware_subscribe(wifi_aware_h wifi_aware, wifi_aware_subscribe_config_h config,
wifi_aware_subscribed_cb callback, void *user_data);
+/**
+ * @brief Stop finding Wi-Fi Aware services.
+ * @since_tizen 6.0
+ * @param[in] wifi_aware
+ * @param[in] subscribe_id
+ * @return 0 on success, otherwise a negative error value
+ * @retval #WIFI_AWARE_ERROR_NONE
+ */
+int wifi_aware_cancel_subscribe(wifi_aware_h wifi_aware,
+ unsigned int subscribe_id);
/**
* @brief
wifi_aware_enable_request_s *req, GAsyncReadyCallback cb);
int wifi_aware_gdbus_publish(wifi_aware_h wifi_aware, int client_id,
wifi_aware_publish_request_s *req, GAsyncReadyCallback cb);
+int wifi_aware_gdbus_cancel_publish(wifi_aware_h wifi_aware, int client_id,
+ unsigned int pub_id);
int wifi_aware_gdbus_subscribe(wifi_aware_h wifi_aware, int client_id,
wifi_aware_subscribe_request_s *req, GAsyncReadyCallback cb);
+int wifi_aware_gdbus_cancel_subscribe(wifi_aware_h wifi_aware, int client_id,
+ unsigned int sub_id);
#ifdef __cplusplus
}
#endif
int _wifi_aware_enable_request(wifi_aware_h wifi_aware);
int _wifi_aware_publish_request(wifi_aware_h wifi_aware,
wifi_aware_publish_config_h config);
+int _wifi_aware_cancel_publish_request(wifi_aware_h wifi_aware, unsigned int pub_id);
int _wifi_aware_subscribe_request(wifi_aware_h wifi_aware,
wifi_aware_subscribe_config_h config);
+int _wifi_aware_cancel_subscribe_request(wifi_aware_h wifi_aware, unsigned int sub_id);
void _set_discovery_result_cb(wifi_aware_h wifi_aware,
wifi_aware_discovery_result_cb callback, void *user_data);
}
};
-static int __wifi_aware_error_string_to_enum(const char *error)
-{
- /*
- if (NULL != strstr(error, "NoReply"))
- return WIFI_AWARE_ERROR_COMMUNICATION_FAILED;
- else if (NULL != strstr(error, "PermissionDenied"))
- return WIFI_AWARE_ERROR_PERMISSION_DENIED;
- else if (NULL != strstr(error, "MEM_ERR"))
- return WIFI_AWARE_ERROR_OUT_OF_MEMORY;
- else if (NULL != strstr(error, "INVALID_PARAM"))
- return WIFI_AWARE_ERROR_INVALID_PARAMETER;
- else if (NULL != strstr(error, "OPER_FAILED"))
- return WIFI_AWARE_ERROR_OPERATION_FAILED;
- else if (NULL != strstr(error, "NO_SERVICE"))
- return WIFI_AWARE_ERROR_SERVICE_NOT_FOUND;
- else if (NULL != strstr(error, "NO_SESSION"))
- return WIFI_AWARE_ERROR_SESSION_NOT_FOUND;
- else
- */
- return WIFI_AWARE_ERROR_OPERATION_FAILED;
-}
-
static void __gdbus_signal_cb(GDBusConnection *connection,
const gchar *sender, const gchar *object_path,
const gchar *interface, const gchar *signal,
}
+static int __wifi_aware_dbus_method_call_sync(const char *interface_name,
+ const char *object_path,
+ const char *method, GVariant *params, GVariant **reply)
+{
+ GError *error = NULL;
+
+ if (gdbus_data.connection == NULL) {
+ WIFI_AWARE_LOGE("GDBusconnection is NULL");
+ return WIFI_AWARE_ERROR_OPERATION_FAILED;
+ }
+
+ *reply = g_dbus_connection_call_sync(gdbus_data.connection,
+ WIFI_AWARE_INTERFACE,
+ object_path,
+ interface_name,
+ method,
+ params,
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+
+ if (*reply == NULL) {
+ if (error == NULL)
+ WIFI_AWARE_LOGE("g_dbus_connection_call_sync failed: unknown error");
+ else
+ WIFI_AWARE_LOGE("g_dbus_connection_call_sync failed: [%d:%s]",
+ error->code, error->message);
+
+ return WIFI_AWARE_ERROR_OPERATION_FAILED;
+ }
+ return WIFI_AWARE_ERROR_NONE;
+}
+
static void __print_enable_request(wifi_aware_enable_request_s *req)
{
WIFI_AWARE_LOGI("master_pref: %x\n", req->master_pref);
return params;
}
+static GVariant *__create_cancel_publish_request_param(int client_id, unsigned int pub_id)
+{
+ return g_variant_new("(iu)", client_id, pub_id);
+}
+
static GVariant *__create_subscribe_request_param(int client_id, wifi_aware_subscribe_request_s *req)
{
GVariantBuilder *builder = NULL;
return params;
}
+static GVariant *__create_cancel_subscribe_request_param(int client_id, unsigned int sub_id)
+{
+ return g_variant_new("(iu)", client_id, sub_id);
+}
+
int wifi_aware_gdbus_enable(wifi_aware_h wifi_aware,
wifi_aware_enable_request_s *req, GAsyncReadyCallback cb)
{
WIFI_AWARE_DISCOVERY_INTERFACE,
WIFI_AWARE_DISCOVERY_PATH,
"Publish", params, cb, wifi_aware);
- if (ret != WIFI_AWARE_ERROR_NONE) {
- WIFI_AWARE_LOGE("wifi_aware_dbus_method_call_async() failed");
- __WIFI_AWARE_FUNC_EXIT__;
- return ret;
- }
+
+ RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Publish failed");
+
+ __WIFI_AWARE_FUNC_EXIT__;
+ return ret;
+}
+
+static int __handle_cancel_publish_reply(GVariant *reply)
+{
+ __WIFI_AWARE_FUNC_ENTER__;
+ int error;
+ g_variant_get(reply, "(i)", &error);
+ WIFI_AWARE_LOGI("Reply for CancelPublish %d", error);
+ return error;
+}
+
+int wifi_aware_gdbus_cancel_publish(wifi_aware_h wifi_aware, int client_id,
+ unsigned int pub_id)
+{
+ __WIFI_AWARE_FUNC_ENTER__;
+ GVariant *params = NULL;
+ GVariant *reply = NULL;
+ int ret = WIFI_AWARE_ERROR_NONE;
+
+ params = __create_cancel_publish_request_param(client_id, pub_id);
+ DBUS_DEBUG_VARIANT(params);
+
+ ret = __wifi_aware_dbus_method_call_sync(
+ WIFI_AWARE_DISCOVERY_INTERFACE,
+ WIFI_AWARE_DISCOVERY_PATH,
+ "CancelPublish",
+ params, &reply);
+
+ RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "CancelPublish failed");
+
+ ret = __handle_cancel_publish_reply(reply);
+ g_variant_unref(reply);
__WIFI_AWARE_FUNC_EXIT__;
return ret;
WIFI_AWARE_DISCOVERY_INTERFACE,
WIFI_AWARE_DISCOVERY_PATH,
"Subscribe", params, cb, wifi_aware);
- if (ret != WIFI_AWARE_ERROR_NONE) {
- WIFI_AWARE_LOGE("wifi_aware_dbus_method_call_async() failed");
- __WIFI_AWARE_FUNC_EXIT__;
- return ret;
- }
+
+ RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Subscribe failed");
+
+ __WIFI_AWARE_FUNC_EXIT__;
+ return ret;
+}
+
+static int __handle_cancel_subscribe_reply(GVariant *reply)
+{
+ __WIFI_AWARE_FUNC_ENTER__;
+ int error;
+ g_variant_get(reply, "(i)", &error);
+ WIFI_AWARE_LOGI("Reply for CancelSubscribe %d", error);
+ return error;
+}
+
+int wifi_aware_gdbus_cancel_subscribe(wifi_aware_h wifi_aware, int client_id,
+ unsigned int sub_id)
+{
+ __WIFI_AWARE_FUNC_ENTER__;
+ GVariant *params = NULL;
+ GVariant *reply = NULL;
+ int ret = WIFI_AWARE_ERROR_NONE;
+
+ params = __create_cancel_subscribe_request_param(client_id, sub_id);
+ DBUS_DEBUG_VARIANT(params);
+
+ ret = __wifi_aware_dbus_method_call_sync(
+ WIFI_AWARE_DISCOVERY_INTERFACE,
+ WIFI_AWARE_DISCOVERY_PATH,
+ "CancelSubscribe",
+ params, &reply);
+
+ RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "CancelSubscribe failed");
+
+ ret = __handle_cancel_subscribe_reply(reply);
+ g_variant_unref(reply);
__WIFI_AWARE_FUNC_EXIT__;
return ret;
req, __publish_request_reply);
}
+int _wifi_aware_cancel_publish_request(wifi_aware_h wifi_aware,
+ unsigned int pub_id)
+{
+ wifi_aware_s *aware = (wifi_aware_s *)wifi_aware;
+ return wifi_aware_gdbus_cancel_publish(wifi_aware, aware->client_id, pub_id);
+}
+
int _wifi_aware_subscribe_request(wifi_aware_h wifi_aware,
wifi_aware_subscribe_config_h config)
{
req, __subscribe_request_reply);
}
+int _wifi_aware_cancel_subscribe_request(wifi_aware_h wifi_aware,
+ unsigned int sub_id)
+{
+ wifi_aware_s *aware = (wifi_aware_s *)wifi_aware;
+ return wifi_aware_gdbus_cancel_subscribe(wifi_aware, aware->client_id, sub_id);
+}
+
void _set_discovery_result_cb(wifi_aware_h wifi_aware,
wifi_aware_discovery_result_cb callback, void *user_data)
{
__WIFI_AWARE_FUNC_ENTER__;
+
wifi_aware_s *aware = (wifi_aware_s *)wifi_aware;
aware->discovered_cb = callback;
for (list = __wifi_aware_handle_list; list; list = list->next) {
wifi_aware_s *aware = (wifi_aware_s *)list;
if (aware->discovered_cb)
- aware->discovered_cb(sub_id, peer,
- specific_info, specific_info_len,
- match_filters, match_filters_len,
- aware->discovered_cb_data);
+ aware->discovered_cb(sub_id, peer, specific_info, specific_info_len,
+ match_filters, match_filters_len, aware->discovered_cb_data);
}
}
return WIFI_AWARE_ERROR_NONE;
}
+API int wifi_aware_cancel_publish(wifi_aware_h wifi_aware,
+ unsigned int publish_id)
+{
+ __WIFI_AWARE_FUNC_ENTER__;
+ int ret = WIFI_AWARE_ERROR_NONE;
+
+ CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+ RET_ERR_IF_HANDLE_IS_NOT_VALID_OR_NOT_INITIALIZED(wifi_aware);
+
+ ret = _wifi_aware_cancel_publish_request(wifi_aware, publish_id);
+ 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_h wifi_aware,
unsigned int publish_id,
wifi_aware_publish_config_h config,
return WIFI_AWARE_ERROR_NONE;
}
+API int wifi_aware_cancel_subscribe(wifi_aware_h wifi_aware,
+ unsigned int subscribe_id)
+{
+ __WIFI_AWARE_FUNC_ENTER__;
+ int ret = WIFI_AWARE_ERROR_NONE;
+
+ CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_WIFI_AWARE);
+ RET_ERR_IF_HANDLE_IS_NOT_VALID_OR_NOT_INITIALIZED(wifi_aware);
+
+ ret = _wifi_aware_cancel_subscribe_request(wifi_aware, subscribe_id);
+ 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_set_discovery_result_cb(wifi_aware_h wifi_aware,
wifi_aware_discovery_result_cb callback, void *user_data)
{
CMD_ENABLE,
CMD_PUBLISH,
+ CMD_CANCEL_PUBLISH,
CMD_SUBSCRIBE,
+ CMD_CANCEL_SUBSCRIBE,
CMD_INVALID,
};
= "ENABLE",
[CMD_PUBLISH]
= "PUBLISH",
+ [CMD_CANCEL_PUBLISH]
+ = "CANCEL PUBLISH",
[CMD_SUBSCRIBE]
= "SUBSCRIBE",
+ [CMD_CANCEL_SUBSCRIBE]
+ = "CANCEL SUBSCRIBE",
[CMD_INVALID]
= NULL, };
static GMainLoop *g_main_loop_p;
static wifi_aware_h g_wifi_aware_handle;
+static unsigned int g_pub_id;
+static unsigned int g_sub_id;
/*****************************************************************************
* Local Functions Definition
static void __published_cb(wifi_aware_error_e error, unsigned int publish_id, void *user_data)
{
+ g_pub_id = publish_id;
if (error == WIFI_AWARE_ERROR_NONE)
printf("Publish Request is success. Publish ID: %u\n", publish_id);
else
__print_result(ret, "wifi_aware_publish_config_destroy");
}
+void test_cancel_publish()
+{
+ int ret = 0;
+
+ RET_IF_LOOP_IS_NULL();
+ RET_IF_HANDLE_IS_NULL();
+
+ if (g_pub_id < 1) {
+ printf("publish should be done\n");
+ return;
+ }
+
+ ret = wifi_aware_cancel_publish(g_wifi_aware_handle, g_pub_id);
+ __print_result(ret, "wifi_aware_cancel_publish");
+}
+
static void __subscribed_cb(wifi_aware_error_e error, unsigned int subscribe_id, void *user_data)
{
+ g_sub_id = subscribe_id;
+
if (error == WIFI_AWARE_ERROR_NONE)
printf("Subscribe Request is success. Subscirbe ID: %u\n", subscribe_id);
else
__print_result(ret, "wifi_aware_subscribe_config_destroy");
}
+void test_cancel_subscribe()
+{
+ int ret = 0;
+
+ RET_IF_LOOP_IS_NULL();
+ RET_IF_HANDLE_IS_NULL();
+
+ if (g_sub_id < 1) {
+ printf("subscribe should be done\n");
+ return;
+ }
+
+ ret = wifi_aware_cancel_subscribe(g_wifi_aware_handle, g_sub_id);
+ __print_result(ret, "wifi_aware_cancel_subscribe");
+}
+
typedef void (*test_func)(void);
test_func g_menu_func[] = {
[CMD_QUIT] = test_quit,
[CMD_DEINITIALIZE] = test_deinit,
[CMD_ENABLE] = test_enable,
[CMD_PUBLISH] = test_publish,
+ [CMD_CANCEL_PUBLISH] = test_cancel_publish,
[CMD_SUBSCRIBE] = test_subscribe,
+ [CMD_CANCEL_SUBSCRIBE] = test_cancel_subscribe,
[CMD_INVALID] = NULL,
};
projects / platform / core / api / wifi-aware.git / commitdiff