Apply changed Dbus methods

Signed-off-by: saerome kim <saerome.kim@samsung.com>

diff --git a/include/mesh_dbus.h b/include/mesh_dbus.h
index 3ad7e52..61e06df 100755 (executable)
--- a/include/mesh_dbus.h
+++ b/include/mesh_dbus.h
@@ -40,13 +40,18 @@ int _mesh_specific_scan(mesh_h handle, const char* ssid, int channel);
 int _mesh_cancel_scan(mesh_h handle);
 int _mesh_get_station_info(mesh_h handle, void *station);
 int _mesh_get_path_info(mesh_h handle, void *mpath_data);
-int _mesh_join(mesh_h handle, const char* ssid);
-int _mesh_is_joined(mesh_h handle, int is_joined);
-int _mesh_disjoin(mesh_h handle);
-int _mesh_load_softap_settings(mesh_h handle, const char* ssid,
+int _mesh_enable_mesh(mesh_h handle);
+int _mesh_disable_mesh(mesh_h handle);
+int _mesh_set_gate(mesh_h handle, bool stp, bool gate_announce);
+int _mesh_unset_gate(mesh_h handle);
+int _mesh_set_softap(mesh_h handle, const char* ssid,
                const char* key, const char* mode,
                int channel, int visibility,
                int max_stations, int security);
+int _mesh_enable_softap(mesh_h handle);
+int _mesh_disable_softap(mesh_h handle);
+int _mesh_is_joined(mesh_h handle, int is_joined);
+int _mesh_disjoin(mesh_h handle);
 int _mesh_start_bridge(mesh_h handle, const char* interface, int mode);
 int _mesh_stop_bridge(mesh_h handle);
 

diff --git a/src/mesh.c b/src/mesh.c
index 24c94c5..718acf9 100755 (executable)
--- a/src/mesh.c
+++ b/src/mesh.c
@@ -178,7 +178,7 @@ EXPORT_API int mesh_get_path_info(mesh_h handle, mesh_path_info_h path)
        return MESH_ERROR_NONE;
 }
 
-EXPORT_API int mesh_join(mesh_h handle, const char* ssid)
+EXPORT_API int mesh_enable_mesh(mesh_h handle, const char* ssid)
 {
        int rv = 0;
        CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
@@ -186,7 +186,7 @@ EXPORT_API int mesh_join(mesh_h handle, const char* ssid)
        RETV_IF(NULL == ssid, MESH_ERROR_INVALID_PARAMETER);
        RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 
-       rv = _mesh_join(handle, ssid);
+       rv = _mesh_enable_mesh(handle);
        if (rv == MESH_ITNL_ERR_IO_ERROR) {
                return MESH_ERROR_IO_ERROR;
        }
@@ -237,7 +237,7 @@ EXPORT_API int mesh_load_softap_settings(mesh_h handle, const char* ssid,
        RETV_IF(NULL == key, MESH_ERROR_INVALID_PARAMETER);
        RETV_IF(NULL == mode, MESH_ERROR_INVALID_PARAMETER);
 
-       rv = _mesh_load_softap_settings(handle, ssid, key, mode, channel,
+       rv = _mesh_set_softap(handle, ssid, key, mode, channel,
                        visibility, max_stations, security);
        if (rv == MESH_ITNL_ERR_IO_ERROR) {
                return MESH_ERROR_IO_ERROR;

diff --git a/src/mesh_dbus.c b/src/mesh_dbus.c
index 3da6a0a..dfca6e2 100755 (executable)
--- a/src/mesh_dbus.c
+++ b/src/mesh_dbus.c
@@ -214,7 +214,7 @@ int _mesh_enable(mesh_h handle, mesh_event_cb event_handler)
                                NULL, &error);
        if (variant) {
                g_variant_get(variant, "(u)", &result);
-               LOGD("Mesh enabled status 0x%x", result);
+               LOGD("enabled status 0x%x", result);
        } else if (error) {
                LOGE("Failed DBus call [%s]", error->message);
                g_error_free(error);
@@ -245,7 +245,7 @@ int _mesh_disable(mesh_h handle)
                                NULL, &error);
        if (variant) {
                g_variant_get(variant, "(u)", &result);
-               LOGD("Mesh disabled status 0x%x", result);
+               LOGD("isabled status 0x%x", result);
        } else if (error) {
                LOGE("Failed DBus call [%s]", error->message);
                g_error_free(error);
@@ -273,7 +273,7 @@ int _mesh_scan(mesh_h handle)
                                NULL, &error);
        if (variant) {
                g_variant_get(variant, "(u)", &result);
-               LOGD("Mesh scan status 0x%x", result);
+               LOGD("scan status 0x%x", result);
        } else if (error) {
                LOGE("Failed DBus call [%s]", error->message);
                g_error_free(error);
@@ -300,7 +300,7 @@ int _mesh_specific_scan(mesh_h handle, const char* ssid, int channel)
                                NULL, &error);
        if (variant) {
                g_variant_get(variant, "(u)", &result);
-               LOGD("Mesh specific scan status 0x%x", result);
+               LOGD("specific_scan status 0x%x", result);
        } else if (error) {
                LOGE("Failed DBus call [%s]", error->message);
                g_error_free(error);
@@ -327,7 +327,7 @@ int _mesh_cancel_scan(mesh_h handle)
                                NULL, &error);
        if (variant) {
                g_variant_get(variant, "(u)", &result);
-               LOGD("Mesh scan canceling status 0x%x", result);
+               LOGD("cancle_scan status 0x%x", result);
        } else if (error) {
                LOGE("Failed DBus call [%s]", error->message);
                g_error_free(error);
@@ -402,6 +402,7 @@ int _mesh_foreach_found_mesh_netwrok(mesh_h handle,
                        g_variant_unref(inner_params);
                }
                g_variant_unref(params);
+               LOGD("get_found_mesh_networks status 0x%x", result);
 
        } else if (error) {
                LOGE("Failed DBus call [%s]", error->message);
@@ -412,6 +413,176 @@ int _mesh_foreach_found_mesh_netwrok(mesh_h handle,
        return MESH_ITNL_ERR_NONE;
 }
 
+int _mesh_enable_mesh(mesh_h handle)
+{
+       GVariant *variant = NULL;
+       unsigned int result;
+       GError *error = NULL;
+       struct mesh_handle *h = handle;
+
+       RETV_IF(NULL == h->dbus_connection, MESH_ITNL_ERR_IO_ERROR);
+       RETV_IF(NULL == _gproxy_mesh_service, MESH_ITNL_ERR_IO_ERROR);
+
+       variant = g_dbus_proxy_call_sync(_gproxy_mesh_service, "enable_mesh",
+                               NULL,
+                               G_DBUS_CALL_FLAGS_NONE,
+                               -1,
+                               NULL, &error);
+       if (variant) {
+               g_variant_get(variant, "(u)", &result);
+               LOGD("enable_mesh status 0x%x", result);
+       } else if (error) {
+               LOGE("Failed DBus call [%s]", error->message);
+               g_error_free(error);
+               return MESH_ITNL_ERR_IO_ERROR;
+       }
+
+       return MESH_ITNL_ERR_NONE;
+}
+
+int _mesh_disable_mesh(mesh_h handle)
+{
+       GVariant *variant = NULL;
+       unsigned int result;
+       GError *error = NULL;
+       struct mesh_handle *h = handle;
+
+       RETV_IF(NULL == h->dbus_connection, MESH_ITNL_ERR_IO_ERROR);
+       RETV_IF(NULL == _gproxy_mesh_service, MESH_ITNL_ERR_IO_ERROR);
+
+       variant = g_dbus_proxy_call_sync(_gproxy_mesh_service, "disable_mesh",
+                               NULL,
+                               G_DBUS_CALL_FLAGS_NONE,
+                               -1,
+                               NULL, &error);
+       if (variant) {
+               g_variant_get(variant, "(u)", &result);
+               LOGD("disable_mesh status 0x%x", result);
+       } else if (error) {
+               LOGE("Failed DBus call [%s]", error->message);
+               g_error_free(error);
+               return MESH_ITNL_ERR_IO_ERROR;
+       }
+
+       return MESH_ITNL_ERR_NONE;
+}
+
+int _mesh_get_joined_mesh_network(mesh_h handle)
+{
+       GVariant *variant = NULL;
+       GError *error = NULL;
+       struct mesh_handle *h = handle;
+
+       RETV_IF(NULL == h->dbus_connection, MESH_ITNL_ERR_IO_ERROR);
+       RETV_IF(NULL == _gproxy_mesh_service, MESH_ITNL_ERR_IO_ERROR);
+
+       variant = g_dbus_proxy_call_sync(_gproxy_mesh_service, "get_joined_mesh_network",
+                               NULL,
+                               G_DBUS_CALL_FLAGS_NONE,
+                               -1,
+                               NULL, &error);
+       if (variant) {
+               gchar *meshid = NULL;
+               gchar *bssid = NULL;
+               int channel, max_speed;
+               unsigned int result;
+
+               g_variant_get(variant, "(ssiiu)", meshid, bssid, &channel, &max_speed, &result);
+               LOGD("get_joined_mesh_network status 0x%x", result);
+       } else if (error) {
+               LOGE("Failed DBus call [%s]", error->message);
+               g_error_free(error);
+               return MESH_ITNL_ERR_IO_ERROR;
+       }
+
+       return MESH_ITNL_ERR_NONE;
+}
+
+int _mesh_set_gate(mesh_h handle, bool stp, bool gate_announce)
+{
+       GVariant *variant = NULL;
+       unsigned int result;
+       GError *error = NULL;
+       struct mesh_handle *h = handle;
+
+       RETV_IF(NULL == h->dbus_connection, MESH_ITNL_ERR_IO_ERROR);
+       RETV_IF(NULL == _gproxy_mesh_service, MESH_ITNL_ERR_IO_ERROR);
+
+       variant = g_dbus_proxy_call_sync(_gproxy_mesh_service, "set_gate",
+                               g_variant_new("(bb)", stp, gate_announce),
+                               G_DBUS_CALL_FLAGS_NONE,
+                               -1,
+                               NULL, &error);
+       if (variant) {
+               g_variant_get(variant, "(u)", &result);
+               LOGD("set_gate status 0x%x", result);
+       } else if (error) {
+               LOGE("Failed DBus call [%s]", error->message);
+               g_error_free(error);
+               return MESH_ITNL_ERR_IO_ERROR;
+       }
+
+       return MESH_ITNL_ERR_NONE;
+}
+
+int _mesh_unset_gate(mesh_h handle)
+{
+       GVariant *variant = NULL;
+       unsigned int result;
+       GError *error = NULL;
+       struct mesh_handle *h = handle;
+
+       RETV_IF(NULL == h->dbus_connection, MESH_ITNL_ERR_IO_ERROR);
+       RETV_IF(NULL == _gproxy_mesh_service, MESH_ITNL_ERR_IO_ERROR);
+
+       variant = g_dbus_proxy_call_sync(_gproxy_mesh_service, "unset_gate",
+                               NULL,
+                               G_DBUS_CALL_FLAGS_NONE,
+                               -1,
+                               NULL, &error);
+       if (variant) {
+               g_variant_get(variant, "(u)", &result);
+               LOGD("unset_gate status 0x%x", result);
+       } else if (error) {
+               LOGE("Failed DBus call [%s]", error->message);
+               g_error_free(error);
+               return MESH_ITNL_ERR_IO_ERROR;
+       }
+
+       return MESH_ITNL_ERR_NONE;
+}
+
+int _mesh_set_softap(mesh_h handle, const char* ssid,
+               const char* key, const char* mode,
+               int channel, int visibility,
+               int max_stations, int security)
+{
+       GVariant *variant = NULL;
+       unsigned int result;
+       GError *error = NULL;
+       struct mesh_handle *h = handle;
+
+       RETV_IF(NULL == h->dbus_connection, MESH_ITNL_ERR_IO_ERROR);
+       RETV_IF(NULL == _gproxy_mesh_service, MESH_ITNL_ERR_IO_ERROR);
+
+       variant = g_dbus_proxy_call_sync(_gproxy_mesh_service, "set_softap",
+                               g_variant_new("(sssiiii)", ssid, key, mode,
+                                       channel, visibility, max_stations, security),
+                               G_DBUS_CALL_FLAGS_NONE,
+                               -1,
+                               NULL, &error);
+       if (variant) {
+               g_variant_get(variant, "(u)", &result);
+               LOGD("set_softap status 0x%x", result);
+       } else if (error) {
+               LOGE("Failed DBus call [%s]", error->message);
+               g_error_free(error);
+               return MESH_ITNL_ERR_IO_ERROR;
+       }
+
+       return MESH_ITNL_ERR_NONE;
+}
+
 struct mesh_station_info_s g_station;
 
 int _mesh_get_station_info(mesh_h handle, void *station)
@@ -540,7 +711,7 @@ int _mesh_get_path_info(mesh_h handle, void* mpath_data)
 
        return MESH_ITNL_ERR_NONE;
 }
-
+#if 1
 int _mesh_join(mesh_h handle, const char* ssid)
 {
        GVariant *variant = NULL;
@@ -623,37 +794,6 @@ int _mesh_disjoin(mesh_h handle)
        return MESH_ITNL_ERR_NONE;
 }
 
-int _mesh_load_softap_settings(mesh_h handle, const char* ssid,
-               const char* key, const char* mode,
-               int channel, int visibility,
-               int max_stations, int security)
-{
-       GVariant *variant = NULL;
-       unsigned int result;
-       GError *error = NULL;
-       struct mesh_handle *h = handle;
-
-       RETV_IF(NULL == h->dbus_connection, MESH_ITNL_ERR_IO_ERROR);
-       RETV_IF(NULL == _gproxy_mesh_service, MESH_ITNL_ERR_IO_ERROR);
-
-       variant = g_dbus_proxy_call_sync(_gproxy_mesh_service, "load_softap_settings",
-                               g_variant_new("(sssiiii)", ssid, key, mode,
-                                       channel, visibility, max_stations, security),
-                               G_DBUS_CALL_FLAGS_NONE,
-                               -1,
-                               NULL, &error);
-       if (variant) {
-               g_variant_get(variant, "(u)", &result);
-               LOGD("Mesh softap setting status 0x%x", result);
-       } else if (error) {
-               LOGE("Failed DBus call [%s]", error->message);
-               g_error_free(error);
-               return MESH_ITNL_ERR_IO_ERROR;
-       }
-
-       return MESH_ITNL_ERR_NONE;
-}
-
 int _mesh_start_bridge(mesh_h handle, const char* interface, int mode)
 {
        GVariant *variant = NULL;
@@ -707,3 +847,4 @@ int _mesh_stop_bridge(mesh_h handle)
 
        return MESH_ITNL_ERR_NONE;
 }
+#endif