Merge lp:~kvalo/indicator-network/libconnman-control-technology into lp:~indicator-applet-developers/indicator-network/indicator-network

[Kalle Valo]

[Mikkel Kamstrup Erlandsen (kamstrup)]

Looks good

review: Approve

=== modified file 'src/libconnman/Connman-1.0.vapi'
--- src/libconnman/Connman-1.0.vapi	2011-02-21 15:25:04 +0000
+++ src/libconnman/Connman-1.0.vapi	2011-02-22 14:03:59 +0000
@@ -26,6 +26,8 @@
 		[CCode (has_construct_function = false)]
 		public Manager ();
 		public async void connect_service (Connman.ServiceType type, Connman.ServiceMode mode, Connman.ServiceSecurity security, [CCode (array_length = false)] uint8[] ssid, uint ssid_len, GLib.Cancellable? cancellable) throws GLib.Error;
+        public async void disable_technology (Connman.TechnologyType type, GLib.Cancellable? cancellable) throws GLib.Error;
+        public async void enable_technology (Connman.TechnologyType type, GLib.Cancellable? cancellable) throws GLib.Error;
 		public Connman.Service get_default_service ();
 		[CCode (array_length = false, array_null_terminated = true)]
 		public unowned Connman.Service[] get_services ();
@@ -34,8 +36,11 @@
         public Connman.TechnologyState get_cellular_state ();
         public Connman.TechnologyState get_ethernet_state ();
         public Connman.TechnologyState get_wifi_state ();
+        public bool get_offline_mode ();
+        public void set_offline_mode (bool mode);
 		public bool get_connected ();
 		public bool connected { get; }
+        public bool offline_mode { get; set; }
 		public Connman.Service default_service { get; }
 		public signal void service_added (Connman.Service object);
 		public signal void service_removed (string object);
@@ -166,6 +171,14 @@
         ENABLED,
         CONNECTED
     }
+    [CCode (cprefix = "CONNMAN_TECHNOLOGY_TYPE_", cheader_filename = "connman-manager.h")]
+    public enum TechnologyType {
+        UNKNOWN,
+        ETHERNET,
+        WIFI,
+        BLUETOOTH,
+        CELLULAR
+    }
 	[CCode (cheader_filename = "connman-service.h")]
 	public const string MANAGER_PATH;
 	[CCode (cheader_filename = "connman-service.h")]
@@ -179,6 +192,8 @@
 	[CCode (cheader_filename = "connman-service.h")]
 	public const string PROPERTY_NAME;
 	[CCode (cheader_filename = "connman-service.h")]
+    public const string PROPERTY_OFFLINE_MODE;
+	[CCode (cheader_filename = "connman-service.h")]
 	public const string PROPERTY_PASSPHRASE;
 	[CCode (cheader_filename = "connman-service.h")]
 	public const string PROPERTY_SECURITY;
 
=== modified file 'src/libconnman/connman-manager.c'
--- src/libconnman/connman-manager.c	2011-02-21 16:00:36 +0000
+++ src/libconnman/connman-manager.c	2011-02-22 14:03:59 +0000
@@ -67,16 +67,10 @@
   ConnmanTechnologyState ethernet_state;
   ConnmanTechnologyState cellular_state;
   ConnmanTechnologyState bluetooth_state;
+
+  gboolean offline_mode;
 };
 
-typedef enum {
-  CONNMAN_TECHNOLOGY_TYPE_UNKNOWN,
-  CONNMAN_TECHNOLOGY_TYPE_ETHERNET,
-  CONNMAN_TECHNOLOGY_TYPE_WIFI,
-  CONNMAN_TECHNOLOGY_TYPE_BLUETOOTH,
-  CONNMAN_TECHNOLOGY_TYPE_CELLULAR,
-} ConnmanTechnologyType;
-
 struct technology_type_string
 {
   const gchar *str;
@@ -128,8 +122,145 @@
   PROP_ETHERNET_STATE,
   PROP_CELLULAR_STATE,
   PROP_BLUETOOTH_STATE,
+  PROP_OFFLINE_MODE,
 };
 
+static const gchar *technology_type2str(ConnmanTechnologyType type)
+{
+  const struct technology_type_string *s;
+  guint i;
+
+  for (i = 0; i < G_N_ELEMENTS(technology_type_map); i++) {
+    s = &technology_type_map[i];
+    if (s->type == type)
+      return s->str;
+  }
+
+  g_warning("%s(): unknown technology type %d", __func__, type);
+
+  return "unknown";
+}
+
+static void enable_technology_cb(GObject *object, GAsyncResult *res,
+				 gpointer user_data)
+{
+  GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT(user_data);
+  GDBusProxy *proxy = G_DBUS_PROXY(object);
+  GError *error = NULL;
+
+  g_dbus_proxy_call_finish(proxy, res, &error);
+
+  if (error != NULL) {
+    g_simple_async_result_set_from_error(simple, error);
+    g_error_free(error);
+    goto out;
+  }
+
+ out:
+  g_simple_async_result_complete(simple);
+  g_object_unref(simple);
+}
+
+void connman_manager_enable_technology(ConnmanManager *self,
+				       ConnmanTechnologyType type,
+				       GCancellable *cancellable,
+				       GAsyncReadyCallback callback,
+				       gpointer user_data)
+{
+  ConnmanManagerPrivate *priv = GET_PRIVATE(self);
+  GSimpleAsyncResult *simple;
+  GVariant *parameters;
+  const gchar *s;
+
+  g_return_if_fail(CONNMAN_IS_MANAGER(self));
+  g_return_if_fail(priv != NULL);
+
+  simple = g_simple_async_result_new(G_OBJECT(self), callback,
+				     user_data,
+				     connman_manager_enable_technology);
+
+  s = technology_type2str(type);
+  parameters = g_variant_new("(s)", s);
+
+  /* FIXME: cancel the call on dispose */
+  g_dbus_proxy_call(priv->proxy, "EnableTechnology", parameters,
+  		    G_DBUS_CALL_FLAGS_NONE, CONNECT_TIMEOUT, cancellable,
+  		    enable_technology_cb, simple);
+}
+
+void connman_manager_enable_technology_finish(ConnmanManager *self,
+					      GAsyncResult *res,
+					      GError **error)
+{
+  GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT(res);
+
+  g_return_if_fail(CONNMAN_IS_MANAGER(self));
+  g_return_if_fail(g_simple_async_result_get_source_tag(simple) ==
+		   connman_manager_enable_technology);
+
+  g_simple_async_result_propagate_error(simple, error);
+}
+
+static void disable_technology_cb(GObject *object, GAsyncResult *res,
+				 gpointer user_data)
+{
+  GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT(user_data);
+  GDBusProxy *proxy = G_DBUS_PROXY(object);
+  GError *error = NULL;
+
+  g_dbus_proxy_call_finish(proxy, res, &error);
+
+  if (error != NULL) {
+    g_simple_async_result_set_from_error(simple, error);
+    g_error_free(error);
+    goto out;
+  }
+
+ out:
+  g_simple_async_result_complete(simple);
+  g_object_unref(simple);
+}
+
+void connman_manager_disable_technology(ConnmanManager *self,
+				       ConnmanTechnologyType type,
+				       GCancellable *cancellable,
+				       GAsyncReadyCallback callback,
+				       gpointer user_data)
+{
+  ConnmanManagerPrivate *priv = GET_PRIVATE(self);
+  GSimpleAsyncResult *simple;
+  GVariant *parameters;
+  const gchar *s;
+
+  g_return_if_fail(CONNMAN_IS_MANAGER(self));
+  g_return_if_fail(priv != NULL);
+
+  simple = g_simple_async_result_new(G_OBJECT(self), callback,
+				     user_data,
+				     connman_manager_disable_technology);
+
+  s = technology_type2str(type);
+  parameters = g_variant_new("(s)", s);
+
+  /* FIXME: cancel the call on dispose */
+  g_dbus_proxy_call(priv->proxy, "DisableTechnology", parameters,
+  		    G_DBUS_CALL_FLAGS_NONE, CONNECT_TIMEOUT, cancellable,
+  		    disable_technology_cb, simple);
+}
+
+void connman_manager_disable_technology_finish(ConnmanManager *self,
+					       GAsyncResult *res,
+					       GError **error)
+{
+  GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT(res);
+
+  g_return_if_fail(CONNMAN_IS_MANAGER(self));
+  g_return_if_fail(g_simple_async_result_get_source_tag(simple) ==
+		   connman_manager_disable_technology);
+
+  g_simple_async_result_propagate_error(simple, error);
+}
+
 static void connect_service_cb(GObject *object, GAsyncResult *res,
 			       gpointer user_data)
 {
@@ -370,6 +501,26 @@
   return priv->bluetooth_state;
 }
 
+gboolean connman_manager_get_offline_mode(ConnmanManager *self)
+{
+  ConnmanManagerPrivate *priv = GET_PRIVATE(self);
+
+  g_return_val_if_fail(CONNMAN_IS_MANAGER(self), FALSE);
+  g_return_val_if_fail(priv != NULL, FALSE);
+
+  return priv->offline_mode;
+}
+
+void connman_manager_set_offline_mode(ConnmanManager *self, gboolean mode)
+{
+  ConnmanManagerPrivate *priv = GET_PRIVATE(self);
+
+  g_return_if_fail(CONNMAN_IS_MANAGER(self));
+  g_return_if_fail(priv != NULL);
+
+  g_object_set(self, "offline-mode", mode, NULL);
+}
+
 static void update_default_service(ConnmanManager *self)
 {
   ConnmanManagerPrivate *priv = GET_PRIVATE(self);
@@ -987,6 +1138,22 @@
   g_variant_unref(variant);
 }
 
+static void offline_mode_updated(ConnmanManager *self, GVariant *value)
+{
+  ConnmanManagerPrivate *priv = GET_PRIVATE(self);
+  gboolean mode;
+
+  mode = g_variant_get_boolean(value);
+
+  if (priv->offline_mode == mode)
+    return;
+
+  priv->offline_mode = mode;
+  g_object_notify(G_OBJECT(self), "offline-mode");
+
+  g_variant_unref(value);
+}
+
 static void update_property(ConnmanManager *self, const gchar *property,
 			    GVariant *variant)
 {
@@ -994,6 +1161,8 @@
     update_services(self, variant);
   } else if (g_strcmp0(property, CONNMAN_PROPERTY_TECHNOLOGIES) == 0) {
     technologies_updated(self, variant);
+  } else if (g_strcmp0(property, CONNMAN_PROPERTY_OFFLINE_MODE) == 0) {
+    offline_mode_updated(self, variant);
   } else {
     /* unknown property */
     g_variant_unref(variant);
@@ -1177,6 +1346,52 @@
 				    NULL);
 }
 
+static void set_dbus_property_cb(GObject *object,
+				 GAsyncResult *res,
+				 gpointer user_data)
+{
+  ConnmanManager *self = CONNMAN_MANAGER(user_data);
+  GDBusProxy *proxy = G_DBUS_PROXY(object);
+  GError *error = NULL;
+
+  g_dbus_proxy_call_finish(proxy, res, &error);
+
+  if (error != NULL) {
+    g_warning("ConnmanManager SetProperty() failed: %s", error->message);
+    g_error_free(error);
+  }
+
+  /* trick to avoid destroying self during async call */
+  g_object_unref(self);
+}
+
+static void set_dbus_property(ConnmanManager *self,
+			      const gchar *property,
+			      GVariant *value)
+{
+  ConnmanManagerPrivate *priv = GET_PRIVATE(self);
+  GVariant *parameters;
+
+  g_return_if_fail(CONNMAN_IS_MANAGER(self));
+  g_return_if_fail(priv != NULL);
+
+  parameters = g_variant_new("(sv)", property, value);
+
+  g_dbus_proxy_call(priv->proxy, "SetProperty", parameters,
+  		    G_DBUS_CALL_FLAGS_NONE, -1, NULL,
+  		    set_dbus_property_cb, g_object_ref(self));
+}
+
+static void update_offline_mode(ConnmanManager *self)
+{
+  ConnmanManagerPrivate *priv = GET_PRIVATE(self);
+  GVariant *value;
+
+  value = g_variant_new("b", priv->offline_mode);
+
+  set_dbus_property(self, "OfflineMode", value);
+}
+
 static void set_property(GObject *object, guint property_id,
 			 const GValue *value, GParamSpec *pspec)
 {
@@ -1204,6 +1419,10 @@
   case PROP_BLUETOOTH_STATE:
     priv->bluetooth_state = g_value_get_uint(value);
     break;
+  case PROP_OFFLINE_MODE:
+    priv->offline_mode = g_value_get_boolean(value);
+    update_offline_mode(self);
+    break;
   default:
     /* We don't have any other property... */
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
@@ -1236,6 +1455,9 @@
   case PROP_BLUETOOTH_STATE:
     g_value_set_uint(value, priv->bluetooth_state);
     break;
+  case PROP_OFFLINE_MODE:
+    g_value_set_boolean(value, priv->offline_mode);
+    break;
   default:
     /* We don't have any other property... */
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
@@ -1366,6 +1588,12 @@
 			    CONNMAN_TECHNOLOGY_STATE_UNKNOWN,
 			    G_PARAM_READABLE);
   g_object_class_install_property(gobject_class, PROP_BLUETOOTH_STATE, pspec);
+
+  pspec = g_param_spec_boolean("offline-mode",
+			       "ConnmanManager's offline mode property",
+			       "Set offline mode", FALSE,
+			       G_PARAM_READWRITE);
+  g_object_class_install_property(gobject_class, PROP_OFFLINE_MODE, pspec);
 }
 
 static void connman_manager_init(ConnmanManager *self)
 
=== modified file 'src/libconnman/connman-manager.h'
--- src/libconnman/connman-manager.h	2011-02-21 15:25:04 +0000
+++ src/libconnman/connman-manager.h	2011-02-22 14:03:59 +0000
@@ -54,6 +54,14 @@
 } ConnmanManagerClass;
 
 typedef enum {
+  CONNMAN_TECHNOLOGY_TYPE_UNKNOWN,
+  CONNMAN_TECHNOLOGY_TYPE_ETHERNET,
+  CONNMAN_TECHNOLOGY_TYPE_WIFI,
+  CONNMAN_TECHNOLOGY_TYPE_BLUETOOTH,
+  CONNMAN_TECHNOLOGY_TYPE_CELLULAR,
+} ConnmanTechnologyType;
+
+typedef enum {
   CONNMAN_TECHNOLOGY_STATE_UNKNOWN,
   CONNMAN_TECHNOLOGY_STATE_UNAVAILABLE,
   CONNMAN_TECHNOLOGY_STATE_AVAILABLE,
@@ -64,6 +72,22 @@
 
 GType connman_manager_get_type(void);
 
+void connman_manager_enable_technology(ConnmanManager *self,
+				       ConnmanTechnologyType type,
+				       GCancellable *cancellable,
+				       GAsyncReadyCallback callback,
+				       gpointer user_data);
+void connman_manager_enable_technology_finish(ConnmanManager *self,
+					      GAsyncResult *res,
+					      GError **error);
+void connman_manager_disable_technology(ConnmanManager *self,
+					ConnmanTechnologyType type,
+					GCancellable *cancellable,
+					GAsyncReadyCallback callback,
+					gpointer user_data);
+void connman_manager_disable_technology_finish(ConnmanManager *self,
+					       GAsyncResult *res,
+					       GError **error);
 void connman_manager_connect_service(ConnmanManager *self,
 				     ConnmanServiceType type,
 				     ConnmanServiceMode mode,
@@ -85,6 +109,8 @@
 ConnmanTechnologyState connman_manager_get_ethernet_state(ConnmanManager *self);
 ConnmanTechnologyState connman_manager_get_cellular_state(ConnmanManager *self);
 ConnmanTechnologyState connman_manager_get_bluetooth_state(ConnmanManager *self);
+gboolean connman_manager_get_offline_mode(ConnmanManager *self);
+void connman_manager_set_offline_mode(ConnmanManager *self, gboolean mode);
 ConnmanManager *connman_manager_new(void);
 
 #endif
 
=== modified file 'src/libconnman/connman.h'
--- src/libconnman/connman.h	2011-02-21 15:25:04 +0000
+++ src/libconnman/connman.h	2011-02-22 14:03:59 +0000
@@ -75,6 +75,7 @@
 #define CONNMAN_PROPERTY_IPV4			"IPv4"
 #define CONNMAN_PROPERTY_IPV4_CONFIGURATION	"IPv4.Configuration"
 #define CONNMAN_PROPERTY_TECHNOLOGIES		"Technologies"
+#define CONNMAN_PROPERTY_OFFLINE_MODE		"OfflineMode"
 
 #define CONNMAN_TECHNOLOGY_PROPERTY_STATE	"State"
 #define CONNMAN_TECHNOLOGY_PROPERTY_TYPE	"Type"
 
=== modified file 'tests/libconnman-vala/libconnman-vala.vala'
--- tests/libconnman-vala/libconnman-vala.vala	2011-02-21 16:01:54 +0000
+++ tests/libconnman-vala/libconnman-vala.vala	2011-02-22 14:03:59 +0000
@@ -260,6 +260,75 @@
     stdout.printf("  bluetooth %d\n", manager.get_bluetooth_state());
 }
 
+static Connman.TechnologyType str2tech(string s)
+{
+    switch (s) {
+    case "wifi":
+        return Connman.TechnologyType.WIFI;
+    case "ethernet":
+        return Connman.TechnologyType.ETHERNET;
+    case "cellular":
+        return Connman.TechnologyType.CELLULAR;
+    case "bluetooth":
+        return Connman.TechnologyType.BLUETOOTH;
+    default:
+        stdout.printf("Unknown tech: %s\n", s);
+        return Connman.TechnologyType.UNKNOWN;
+    }
+}
+
+static void enable(string[] args) {
+
+	if (args.length != 1) {
+		stdout.printf("Invalid number of arguments for enable: %d\n",
+                      args.length);
+		return;
+	}
+
+	var tech = str2tech(args[0]);
+
+    manager.enable_technology(tech, null);
+}
+
+static void disable(string[] args) {
+
+	if (args.length != 1) {
+		stdout.printf("Invalid number of arguments for enable: %d\n",
+                      args.length);
+		return;
+	}
+
+	var tech = str2tech(args[0]);
+
+    manager.disable_technology(tech, null);
+}
+
+static void offline(string[] args) {
+
+	if (args.length != 1) {
+		stdout.printf("Invalid number of arguments for offline: %d\n",
+                      args.length);
+		return;
+	}
+
+    var mode = args[0];
+    bool value;
+
+    switch (mode) {
+    case "on":
+        value = true;
+        break;
+    case "off":
+        value = false;
+        break;
+    default:
+        stdout.printf("Unknown mode for offline: %s\n", mode);
+        return;
+    }
+
+    manager.offline_mode = value;
+}
+
 static bool cmd_handler() {
 	var line = cmd_queue.pop();
 	var tokens = line.split(" ");
@@ -296,6 +365,15 @@
 	case "tech":
 		tech(args);
 		break;
+	case "enable":
+		enable(args);
+		break;
+	case "disable":
+		disable(args);
+		break;
+	case "offline":
+		offline(args);
+		break;
 	default:
 		stdout.printf("Unknown command: %s\n", cmd);
 		break;
@@ -363,6 +441,11 @@
                           manager.get_bluetooth_state());
     });
 
+	manager.notify["offline-mode"].connect((s, p) => {
+			stdout.printf("offline-mode %s\n",
+                          manager.offline_mode ? "on" : "off");
+    });
+
 	loop.run();
 
 	return 0;