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);
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);
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);
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);
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);
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);
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)
return MESH_ITNL_ERR_NONE;
}
-
+#if 1
int _mesh_join(mesh_h handle, const char* ssid)
{
GVariant *variant = NULL;
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;
return MESH_ITNL_ERR_NONE;
}
+#endif