Implement update publish

diff --git a/include/wifi-aware.h b/include/wifi-aware.h
index 990c6a1..a5d8bf8 100644 (file)
--- a/include/wifi-aware.h
+++ b/include/wifi-aware.h
@@ -387,14 +387,15 @@ int wifi_aware_enable(wifi_aware_h wifi_aware,
  *        @a publish_id can be used to update or cancel the service.
  * @since_tizen 6.0
  * @param[in] error
- * @param[in] publish_id
+ * @param[in] publish
  * @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()
  */
 typedef void(*wifi_aware_published_cb)(wifi_aware_error_e error,
-               unsigned int publish_id, void *user_data);
+               wifi_aware_publish_h publish, void *user_data);
 
 /**
  * @brief Publish a Wi-Fi Aware service so that neighboring devices can find it.
@@ -425,16 +426,13 @@ int wifi_aware_cancel_publish(wifi_aware_h wifi_aware, wifi_aware_publish_h publ
  * @since_tizen 6.0
  * @param[in] wifi_aware
  * @param[in] publish_id
- * @param[in] config
+ * @param[in] publish
  * @param[in] callback
  * @param[in] user_data
  * @return     0 on success, otherwise a negative error value
  * @retval     #WIFI_AWARE_ERROR_NONE
  */
-// TODO: Can the same type of callback as that of wifi_aware_publish() be used?
-// If so, should the callback provide a parameter to indicate the command type?
 int wifi_aware_update_publish(wifi_aware_h wifi_aware,
-               unsigned int publish_id,
                wifi_aware_publish_h publish,
                wifi_aware_published_cb callback, void *user_data);
 

diff --git a/src/include/wifi-aware-config.h b/src/include/wifi-aware-config.h
index 3d6a014..f19da86 100644 (file)
--- a/src/include/wifi-aware-config.h
+++ b/src/include/wifi-aware-config.h
@@ -38,7 +38,6 @@ typedef struct {
 
 
 typedef struct {
-       uint32_t publish_id;    // Get it from return value of Publish dbus method call
        uint16_t ttl;
        uint8_t publish_type;
        uint8_t service_name[WIFI_AWARE_MAX_SERVICE_NAME_LEN];

diff --git a/src/include/wifi-aware-gdbus.h b/src/include/wifi-aware-gdbus.h
index e2b555a..ce61025 100644 (file)
--- a/src/include/wifi-aware-gdbus.h
+++ b/src/include/wifi-aware-gdbus.h
@@ -53,6 +53,7 @@ int wifi_aware_gdbus_enable(wifi_aware_h wifi_aware,
                wifi_aware_enable_request_s *req, GAsyncReadyCallback cb);
 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_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,

diff --git a/src/include/wifi-aware-private.h b/src/include/wifi-aware-private.h
index 8e339ad..4641bbe 100644 (file)
--- a/src/include/wifi-aware-private.h
+++ b/src/include/wifi-aware-private.h
@@ -43,6 +43,7 @@ int _wifi_aware_enable_request(wifi_aware_h wifi_aware);
 int _wifi_aware_publish_request(wifi_aware_h wifi_aware,
                wifi_aware_publish_h publish);
 int _wifi_aware_cancel_publish_request(wifi_aware_h wifi_aware, wifi_aware_publish_h publish);
+int _wifi_aware_update_publish_request(wifi_aware_h wifi_aware, wifi_aware_publish_h publish);
 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);

diff --git a/src/include/wifi-aware-publish-private.h b/src/include/wifi-aware-publish-private.h
index 7502e9f..30e328f 100644 (file)
--- a/src/include/wifi-aware-publish-private.h
+++ b/src/include/wifi-aware-publish-private.h
@@ -28,6 +28,7 @@ extern "C" {
 #endif
 
 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);
 void _wifi_aware_publish_set_id(wifi_aware_publish_h publish_handle, unsigned int publish_id);
 void _wifi_aware_publish_invoke_callback(wifi_aware_error_e error, wifi_aware_publish_h publish_handle);
 

diff --git a/src/include/wifi-aware-utils.h b/src/include/wifi-aware-utils.h
index 3771938..2ac5ef2 100644 (file)
--- a/src/include/wifi-aware-utils.h
+++ b/src/include/wifi-aware-utils.h
@@ -56,6 +56,13 @@ extern "C" {
     } while (0)
 */
 
+#define RET_IF(expr, val, fmt, arg...) do { \
+               if (expr) { \
+                       WIFI_AWARE_LOGE(fmt, ##arg); \
+                       return; \
+               } \
+       } while (0)
+
 #define RET_VAL_IF(expr, val, fmt, arg...) do { \
                if (expr) { \
                        WIFI_AWARE_LOGE(fmt, ##arg); \

diff --git a/src/wifi-aware-gdbus.c b/src/wifi-aware-gdbus.c
index 33ab55f..a3a0ba3 100644 (file)
--- a/src/wifi-aware-gdbus.c
+++ b/src/wifi-aware-gdbus.c
@@ -267,6 +267,29 @@ static GVariant *__create_cancel_publish_request_param(int client_id, unsigned i
        return g_variant_new("(iu)", client_id, pub_id);
 }
 
+static GVariant *__create_update_publish_request_param(int client_id,
+               unsigned int pub_id, wifi_aware_publish_request_s *req)
+{
+       GVariantBuilder *builder = NULL;
+       GVariant *params = NULL;
+
+       builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+       g_variant_builder_add(builder, "{sv}", "ttl", g_variant_new("q", req->ttl));
+       g_variant_builder_add(builder, "{sv}", "publish_type", g_variant_new("y", req->publish_type));
+       g_variant_builder_add(builder, "{sv}", "service_name", g_variant_new("s", req->service_name));
+       g_variant_builder_add(builder, "{sv}", "service_name_len", g_variant_new("q", req->service_name_len));
+       g_variant_builder_add(builder, "{sv}", "specific_info", g_variant_new("s", req->specific_info));
+       g_variant_builder_add(builder, "{sv}", "specific_info_len", g_variant_new("q", req->specific_info_len));
+       g_variant_builder_add(builder, "{sv}", "match_filter", g_variant_new("s", req->match_filter));
+       g_variant_builder_add(builder, "{sv}", "match_filter_len", g_variant_new("q", req->match_filter_len));
+       g_variant_builder_add(builder, "{sv}", "enable_termination_event", g_variant_new("b", req->enable_termination_event));
+       g_variant_builder_add(builder, "{sv}", "enable_ranging", g_variant_new("b", req->enable_ranging));
+
+       params = g_variant_new("(iua{sv})", client_id, pub_id, builder);
+       g_variant_builder_unref(builder);
+       return params;
+}
+
 static GVariant *__create_subscribe_request_param(int client_id, wifi_aware_subscribe_request_s *req)
 {
        GVariantBuilder *builder = NULL;
@@ -358,8 +381,14 @@ int wifi_aware_gdbus_cancel_publish(wifi_aware_publish_h publish, int client_id)
        GVariant *reply = 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);
+
+       if (pub_id == 0) {
+               WIFI_AWARE_LOGE("Invalid Publish Id.");
+               return WIFI_AWARE_ERROR_INVALID_PARAMETER;
+       }
        
-       params = __create_cancel_publish_request_param(client_id, req->publish_id);
+       params = __create_cancel_publish_request_param(client_id, pub_id);
        DBUS_DEBUG_VARIANT(params);
 
        ret = __wifi_aware_dbus_method_call_sync(
@@ -377,6 +406,33 @@ 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)
+{
+       __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);
+
+       if (pub_id == 0) {
+               WIFI_AWARE_LOGE("Invalid Publish Id.");
+               return WIFI_AWARE_ERROR_INVALID_PARAMETER;
+       }
+
+       params = __create_update_publish_request_param(client_id, pub_id, req);
+       DBUS_DEBUG_VARIANT(params);
+
+       ret = __wifi_aware_dbus_method_call_async(
+                       WIFI_AWARE_DISCOVERY_INTERFACE,
+                       WIFI_AWARE_DISCOVERY_PATH,
+                       "UpdatePublish", params, cb, publish);
+
+       RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "Publish failed");
+
+       __WIFI_AWARE_FUNC_EXIT__;
+       return ret;
+}
+
 int wifi_aware_gdbus_subscribe(wifi_aware_h wifi_aware, int client_id,
                wifi_aware_subscribe_request_s *req, GAsyncReadyCallback cb)
 {

diff --git a/src/wifi-aware-private.c b/src/wifi-aware-private.c
index b6d8a05..df23d5c 100644 (file)
--- a/src/wifi-aware-private.c
+++ b/src/wifi-aware-private.c
@@ -330,6 +330,13 @@ int _wifi_aware_cancel_publish_request(wifi_aware_h wifi_aware,
        return wifi_aware_gdbus_cancel_publish(publish, aware->client_id);
 }
 
+int _wifi_aware_update_publish_request(wifi_aware_h wifi_aware,
+               wifi_aware_publish_h publish)
+{
+       wifi_aware_s *aware = (wifi_aware_s *)wifi_aware;
+       return wifi_aware_gdbus_update_publish(publish, aware->client_id, __publish_request_reply);
+}
+
 int _wifi_aware_subscribe_request(wifi_aware_h wifi_aware,
                wifi_aware_subscribe_config_h config)
 {

diff --git a/src/wifi-aware-publish.c b/src/wifi-aware-publish.c
index 855f6bd..5f30a59 100644 (file)
--- a/src/wifi-aware-publish.c
+++ b/src/wifi-aware-publish.c
@@ -35,6 +35,7 @@
 #include "wifi-aware-utils.h"
 
 typedef struct {
+    uint32_t publish_id;
     wifi_aware_publish_request_s req;
 
     wifi_aware_published_cb published_cb;
@@ -65,12 +66,20 @@ static void _wifi_aware_publish_request_set_default_values(wifi_aware_publish_re
 
 wifi_aware_publish_request_s *_wifi_aware_publish_get_request(wifi_aware_publish_h publish)
 {
-       RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
+       RET_VAL_IF(publish == NULL, NULL, "wifi_aware_publish_h is NULL");
 
        wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
        return &(handle->req);
 }
 
+unsigned int _wifi_aware_publish_get_id(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;
+}
+
 void _wifi_aware_publish_invoke_callback(wifi_aware_error_e error, wifi_aware_publish_h publish)
 {
        RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
@@ -82,10 +91,9 @@ void _wifi_aware_publish_invoke_callback(wifi_aware_error_e error, wifi_aware_pu
 
 void _wifi_aware_publish_set_id(wifi_aware_publish_h publish, unsigned int publish_id)
 {
-       RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
-
+       RET_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
        wifi_aware_publish_s *handle = (wifi_aware_publish_s *)publish;
-       handle->req.publish_id = publish_id;
+       handle->publish_id = publish_id;
 }
 
 API int wifi_aware_publish_create(wifi_aware_publish_h *publish)
@@ -256,15 +264,21 @@ API int wifi_aware_cancel_publish(wifi_aware_h wifi_aware, wifi_aware_publish_h
 }
 
 API int wifi_aware_update_publish(wifi_aware_h wifi_aware,
-               unsigned int publish_id,
                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_ERR_IF_HANDLE_IS_NOT_VALID_OR_NOT_INITIALIZED(wifi_aware);
        RET_VAL_IF(publish == NULL, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_h is NULL");
 
+       __add_published_callback(publish, callback, user_data);
+
+       ret = _wifi_aware_update_publish_request(wifi_aware, publish);
+       RET_VAL_IF(ret != WIFI_AWARE_ERROR_NONE, ret, "_wifi_aware_update_publish_request");
+
        __WIFI_AWARE_FUNC_EXIT__;
        return WIFI_AWARE_ERROR_NONE;
 }