Simple NetworkManager-0.9 port

Adapt sugar to NetworkManager-0.9 API changes.

The major change here is the removal of the user-level connections
mechanism; instead of storing connection information in Sugar,
NetworkManager now Manages our Networks for us.

However, some level of interfacing/monitoring NM is now needed,
implemented with the Connections and Connection classes in
jarabe.model.network.

If found, connections in sugar's connections.cfg are automatically
migrated, and then connections.cfg is deleted. Similarly, if modem
connection details are found in gconf, they are migrated into NM
and then the gconf keys are unset.

The existing network code is far from perfect and actually quite messy.
In this port I've tried not to make fundamental changes to improve this,
in order to keep task complexity down and aid review.
In the medium term I do plan to improve this code, by moving it to
use gobject-introspection on libnm, and rewriting/restructuring at the
same time. By letting libnm do most of the work for us, this layer can
be greatly simplified. However, libnm and gobject-introspection
improvements are needed first, which I will continue to work on.

Modem PUK configuration has been removed as NetworkManager no longer
has configuration for this. It hasn't been used (and was marked
deprecated) throughout the NM-0.8 release series.

4 files changed, 198 insertions, 309 deletions

diff --git a/extensions/cpsection/modemconfiguration/model.py b/extensions/cpsection/modemconfiguration/model.py
index 1e83c44..969b5d9 100755
--- a/extensions/cpsection/modemconfiguration/model.py
+++ b/extensions/cpsection/modemconfiguration/model.py
@@ -14,68 +14,87 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  US
 
-import gconf
+import logging
 
-from jarabe.model.network import GSM_USERNAME_PATH, GSM_PASSWORD_PATH, \
-                                 GSM_NUMBER_PATH, GSM_APN_PATH, GSM_PIN_PATH, \
-                                 GSM_PUK_PATH
+import dbus
+import gtk
 
+from jarabe.model import network
 
-def get_username():
-    client = gconf.client_get_default()
-    return client.get_string(GSM_USERNAME_PATH) or ''
 
+def get_connection():
+    return network.find_gsm_connection()
 
-def get_password():
-    client = gconf.client_get_default()
-    return client.get_string(GSM_PASSWORD_PATH) or ''
 
+def get_modem_settings():
+    modem_settings = {}
+    connection = get_connection()
+    if not connection:
+        return modem_settings
 
-def get_number():
-    client = gconf.client_get_default()
-    return client.get_string(GSM_NUMBER_PATH) or ''
+    settings = connection.get_settings('gsm')
+    for setting in ('username', 'number', 'apn'):
+        modem_settings[setting] = settings.get(setting, '')
 
+    # use mutable container for nested function control variable
+    secrets_call_done = [False]
 
-def get_apn():
-    client = gconf.client_get_default()
-    return client.get_string(GSM_APN_PATH) or ''
+    def _secrets_cb(secrets):
+        secrets_call_done[0] = True
+        if not secrets or not 'gsm' in secrets:
+            return
 
+        gsm_secrets = secrets['gsm']
+        modem_settings['password'] = gsm_secrets.get('password', '')
+        modem_settings['pin'] = gsm_secrets.get('pin', '')
 
-def get_pin():
-    client = gconf.client_get_default()
-    return client.get_string(GSM_PIN_PATH) or ''
+    def _secrets_err_cb(err):
+        secrets_call_done[0] = True
+        if isinstance(err, dbus.exceptions.DBusException) and \
+                err.get_dbus_name() == network.NM_AGENT_MANAGER_ERR_NO_SECRETS:
+            logging.debug('No GSM secrets present')
+        else:
+            logging.error('Error retrieving GSM secrets: %s', err)
 
+    # must be called asynchronously as this re-enters the GTK main loop
+    connection.get_secrets('gsm', _secrets_cb, _secrets_err_cb)
 
-def get_puk():
-    client = gconf.client_get_default()
-    return client.get_string(GSM_PUK_PATH) or ''
+    # wait til asynchronous execution completes
+    while not secrets_call_done[0]:
+        gtk.main_iteration()
 
+    return modem_settings
 
-def set_username(username):
-    client = gconf.client_get_default()
-    client.set_string(GSM_USERNAME_PATH, username)
 
+def _set_or_clear(_dict, key, value):
+    """Update a dictionary value for a specific key. If value is None or
+    zero-length, but the key is present in the dictionary, delete that
+    dictionary entry."""
+    if value:
+        _dict[key] = value
+        return
 
-def set_password(password):
-    client = gconf.client_get_default()
-    client.set_string(GSM_PASSWORD_PATH, password)
+    if key in _dict:
+        del _dict[key]
 
 
-def set_number(number):
-    client = gconf.client_get_default()
-    client.set_string(GSM_NUMBER_PATH, number)
+def set_modem_settings(modem_settings):
+    username = modem_settings.get('username', '')
+    password = modem_settings.get('password', '')
+    number = modem_settings.get('number', '')
+    apn = modem_settings.get('apn', '')
+    pin = modem_settings.get('pin', '')
 
+    connection = get_connection()
+    if not connection:
+        network.create_gsm_connection(username, password, number, apn, pin)
+        return
 
-def set_apn(apn):
-    client = gconf.client_get_default()
-    client.set_string(GSM_APN_PATH, apn)
-
-
-def set_pin(pin):
-    client = gconf.client_get_default()
-    client.set_string(GSM_PIN_PATH, pin)
-
-
-def set_puk(puk):
-    client = gconf.client_get_default()
-    client.set_string(GSM_PUK_PATH, puk)
+    settings = connection.get_settings()
+    gsm_settings = settings['gsm']
+    _set_or_clear(gsm_settings, 'username', username)
+    _set_or_clear(gsm_settings, 'password', password)
+    _set_or_clear(gsm_settings, 'number', number)
+    _set_or_clear(gsm_settings, 'apn', apn)
+    _set_or_clear(gsm_settings, 'pin', pin)
+    connection.update_settings(settings)
diff --git a/extensions/cpsection/modemconfiguration/view.py b/extensions/cpsection/modemconfiguration/view.py
index c31edba..4ce6c0d 100644
--- a/extensions/cpsection/modemconfiguration/view.py
+++ b/extensions/cpsection/modemconfiguration/view.py
@@ -14,9 +14,8 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  US
 
-import os
-import logging
 from gettext import gettext as _
+import logging
 
 import gtk
 import gobject
@@ -35,10 +34,6 @@ class EntryWithLabel(gtk.HBox):
     def __init__(self, label_text):
         gtk.HBox.__init__(self, spacing=style.DEFAULT_SPACING)
 
-        self._timeout_sid = 0
-        self._changed_handler = None
-        self._is_valid = True
-
         self.label = gtk.Label(label_text)
         self.label.modify_fg(gtk.STATE_NORMAL,
                         style.COLOR_SELECTION_GREY.get_gdk_color())
@@ -47,118 +42,14 @@ class EntryWithLabel(gtk.HBox):
         self.label.show()
 
         self._entry = gtk.Entry(25)
-        self._entry.connect('changed', self.__entry_changed_cb)
         self._entry.set_width_chars(25)
         self.pack_start(self._entry, expand=False)
         self._entry.show()
 
-    def __entry_changed_cb(self, widget, data=None):
-        if self._timeout_sid:
-            gobject.source_remove(self._timeout_sid)
-        self._timeout_sid = gobject.timeout_add(APPLY_TIMEOUT,
-                                                self.__timeout_cb)
-
-    def __timeout_cb(self):
-        self._timeout_sid = 0
-
-        if self._entry.get_text() == self.get_value():
-            return False
-
-        try:
-            self.set_value(self._entry.get_text())
-        except ValueError:
-            self._is_valid = False
-        else:
-            self._is_valid = True
-
-        self.notify('is-valid')
-
-        return False
-
-    def set_text_from_model(self):
-        self._entry.set_text(self.get_value())
-
-    def get_value(self):
-        raise NotImplementedError
-
-    def set_value(self):
-        raise NotImplementedError
-
-    def _get_is_valid(self):
-        return self._is_valid
-    is_valid = gobject.property(type=bool, getter=_get_is_valid, default=True)
-
-
-class UsernameEntry(EntryWithLabel):
-    def __init__(self, model):
-        EntryWithLabel.__init__(self, _('Username:'))
-        self._model = model
-
-    def get_value(self):
-        return self._model.get_username()
-
-    def set_value(self, username):
-        self._model.set_username(username)
-
-
-class PasswordEntry(EntryWithLabel):
-    def __init__(self, model):
-        EntryWithLabel.__init__(self, _('Password:'))
-        self._model = model
-
-    def get_value(self):
-        return self._model.get_password()
-
-    def set_value(self, password):
-        self._model.set_password(password)
-
-
-class NumberEntry(EntryWithLabel):
-    def __init__(self, model):
-        EntryWithLabel.__init__(self, _('Number:'))
-        self._model = model
-
-    def get_value(self):
-        return self._model.get_number()
-
-    def set_value(self, number):
-        self._model.set_number(number)
-
-
-class ApnEntry(EntryWithLabel):
-    def __init__(self, model):
-        EntryWithLabel.__init__(self, _('Access Point Name (APN):'))
-        self._model = model
-
-    def get_value(self):
-        return self._model.get_apn()
-
-    def set_value(self, apn):
-        self._model.set_apn(apn)
-
-
-class PinEntry(EntryWithLabel):
-    def __init__(self, model):
-        EntryWithLabel.__init__(self, _('Personal Identity Number (PIN):'))
-        self._model = model
-
-    def get_value(self):
-        return self._model.get_pin()
-
-    def set_value(self, pin):
-        self._model.set_pin(pin)
-
-
-class PukEntry(EntryWithLabel):
-    def __init__(self, model):
-        EntryWithLabel.__init__(self, _('Personal Unblocking Key (PUK):'))
-        self._model = model
+    def get_entry(self):
+        return self._entry
 
-    def get_value(self):
-        return self._model.get_puk()
-
-    def set_value(self, puk):
-        self._model.set_puk(puk)
+    entry = gobject.property(type=object, getter=get_entry)
 
 
 class ModemConfiguration(SectionView):
@@ -167,6 +58,7 @@ class ModemConfiguration(SectionView):
 
         self._model = model
         self.restart_alerts = alerts
+        self._timeout_sid = 0
 
         self.set_border_width(style.DEFAULT_SPACING)
         self.set_spacing(style.DEFAULT_SPACING)
@@ -182,75 +74,71 @@ class ModemConfiguration(SectionView):
         self.pack_start(self._text, False)
         self._text.show()
 
-        self._username_entry = UsernameEntry(model)
-        self._username_entry.connect('notify::is-valid',
-                                     self.__notify_is_valid_cb)
+        self._username_entry = EntryWithLabel(_('Username:'))
+        self._username_entry.entry.connect('changed', self.__entry_changed_cb)
         self._group.add_widget(self._username_entry.label)
         self.pack_start(self._username_entry, expand=False)
         self._username_entry.show()
 
-        self._password_entry = PasswordEntry(model)
-        self._password_entry.connect('notify::is-valid',
-                                     self.__notify_is_valid_cb)
+        self._password_entry = EntryWithLabel(_('Password:'))
+        self._password_entry.entry.connect('changed', self.__entry_changed_cb)
         self._group.add_widget(self._password_entry.label)
         self.pack_start(self._password_entry, expand=False)
         self._password_entry.show()
 
-        self._number_entry = NumberEntry(model)
-        self._number_entry.connect('notify::is-valid',
-                                   self.__notify_is_valid_cb)
+        self._number_entry = EntryWithLabel(_('Number:'))
+        self._number_entry.entry.connect('changed', self.__entry_changed_cb)
         self._group.add_widget(self._number_entry.label)
         self.pack_start(self._number_entry, expand=False)
         self._number_entry.show()
 
-        self._apn_entry = ApnEntry(model)
-        self._apn_entry.connect('notify::is-valid',
-                                self.__notify_is_valid_cb)
+        self._apn_entry = EntryWithLabel(_('Access Point Name (APN):'))
+        self._apn_entry.entry.connect('changed', self.__entry_changed_cb)
         self._group.add_widget(self._apn_entry.label)
         self.pack_start(self._apn_entry, expand=False)
         self._apn_entry.show()
 
-        self._pin_entry = PinEntry(model)
-        self._pin_entry.connect('notify::is-valid',
-                                self.__notify_is_valid_cb)
+        self._pin_entry = EntryWithLabel(_('Personal Identity Number (PIN):'))
+        self._pin_entry.entry.connect('changed', self.__entry_changed_cb)
         self._group.add_widget(self._pin_entry.label)
         self.pack_start(self._pin_entry, expand=False)
         self._pin_entry.show()
 
-        self._puk_entry = PukEntry(model)
-        self._puk_entry.connect('notify::is-valid',
-                                self.__notify_is_valid_cb)
-        self._group.add_widget(self._puk_entry.label)
-        self.pack_start(self._puk_entry, expand=False)
-        self._puk_entry.show()
-
         self.setup()
 
-    def setup(self):
-        self._username_entry.set_text_from_model()
-        self._password_entry.set_text_from_model()
-        self._number_entry.set_text_from_model()
-        self._apn_entry.set_text_from_model()
-        self._pin_entry.set_text_from_model()
-        self._puk_entry.set_text_from_model()
-
-        self.needs_restart = False
-
     def undo(self):
         self._model.undo()
 
-    def _validate(self):
-        if self._username_entry.is_valid and \
-            self._password_entry.is_valid and \
-                self._number_entry.is_valid and \
-                    self._apn_entry.is_valid and \
-                        self._pin_entry.is_valid and \
-                            self._puk_entry.is_valid:
-                                self.props.is_valid = True
-        else:
-            self.props.is_valid = False
+    def _populate_entry(self, entrywithlabel, text):
+        """Populate an entry with text, without triggering its 'changed'
+        handler."""
+        entry = entrywithlabel.entry
+        entry.handler_block_by_func(self.__entry_changed_cb)
+        entry.set_text(text)
+        entry.handler_unblock_by_func(self.__entry_changed_cb)
+
+    def setup(self):
+        settings = self._model.get_modem_settings()
+        self._populate_entry(self._username_entry,
+            settings.get('username', ''))
+        self._populate_entry(self._number_entry, settings.get('number', ''))
+        self._populate_entry(self._apn_entry, settings.get('apn', ''))
+        self._populate_entry(self._password_entry,
+            settings.get('password', ''))
+        self._populate_entry(self._pin_entry, settings.get('pin', ''))
+
+    def __entry_changed_cb(self, widget, data=None):
+        if self._timeout_sid:
+            gobject.source_remove(self._timeout_sid)
+        self._timeout_sid = gobject.timeout_add(APPLY_TIMEOUT,
+                                                self.__timeout_cb)
 
-    def __notify_is_valid_cb(self, entry, pspec):
-        if entry.is_valid:
-            self.needs_restart = True
-        self._validate()
+    def __timeout_cb(self):
+        self._timeout_sid = 0
+        settings = {}
+        settings['username'] = self._username_entry.entry.get_text()
+        settings['password'] = self._password_entry.entry.get_text()
+        settings['number'] = self._number_entry.entry.get_text()
+        settings['apn'] = self._apn_entry.entry.get_text()
+        settings['pin'] = self._pin_entry.entry.get_text()
+        self._model.set_modem_settings(settings)
diff --git a/extensions/cpsection/network/model.py b/extensions/cpsection/network/model.py
index 916ce8c..4ddab35 100644
--- a/extensions/cpsection/network/model.py
+++ b/extensions/cpsection/network/model.py
@@ -15,6 +15,8 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #
 
+import logging
+
 import dbus
 from gettext import gettext as _
 import gconf
@@ -112,11 +114,21 @@ def clear_registration():
 def clear_networks():
     """Clear saved passwords and network configurations.
     """
-    network.clear_wifi_connections()
+    try:
+        connections = network.get_connections()
+    except dbus.DBusException:
+        logging.debug('NetworkManager not available')
+        return
+    connections.clear()
 
 
 def have_networks():
-    return network.have_wifi_connections()
+    try:
+        connections = network.get_connections()
+        return len(connections.get_list()) > 0
+    except dbus.DBusException:
+        logging.debug('NetworkManager not available')
+        return False
 
 
 def get_publish_information():
diff --git a/extensions/deviceicon/network.py b/extensions/deviceicon/network.py
index 789ea13..213fa41 100644
--- a/extensions/deviceicon/network.py
+++ b/extensions/deviceicon/network.py
@@ -48,17 +48,6 @@ from jarabe.view.pulsingicon import PulsingIcon
 
 IP_ADDRESS_TEXT_TEMPLATE = _('IP address: %s')
 
-_NM_SERVICE = 'org.freedesktop.NetworkManager'
-_NM_IFACE = 'org.freedesktop.NetworkManager'
-_NM_PATH = '/org/freedesktop/NetworkManager'
-_NM_DEVICE_IFACE = 'org.freedesktop.NetworkManager.Device'
-_NM_WIRED_IFACE = 'org.freedesktop.NetworkManager.Device.Wired'
-_NM_WIRELESS_IFACE = 'org.freedesktop.NetworkManager.Device.Wireless'
-_NM_SERIAL_IFACE = 'org.freedesktop.NetworkManager.Device.Serial'
-_NM_OLPC_MESH_IFACE = 'org.freedesktop.NetworkManager.Device.OlpcMesh'
-_NM_ACCESSPOINT_IFACE = 'org.freedesktop.NetworkManager.AccessPoint'
-_NM_ACTIVE_CONN_IFACE = 'org.freedesktop.NetworkManager.Connection.Active'
-
 _GSM_STATE_NOT_READY = 0
 _GSM_STATE_DISCONNECTED = 1
 _GSM_STATE_CONNECTING = 2
@@ -413,24 +402,24 @@ class WirelessDeviceView(ToolButton):
 
         self._device_props = dbus.Interface(self._device,
                                             dbus.PROPERTIES_IFACE)
-        self._device_props.GetAll(_NM_DEVICE_IFACE, byte_arrays=True,
+        self._device_props.GetAll(network.NM_DEVICE_IFACE, byte_arrays=True,
                               reply_handler=self.__get_device_props_reply_cb,
                               error_handler=self.__get_device_props_error_cb)
 
-        self._device_props.Get(_NM_WIRELESS_IFACE, 'ActiveAccessPoint',
+        self._device_props.Get(network.NM_WIRELESS_IFACE, 'ActiveAccessPoint',
                                reply_handler=self.__get_active_ap_reply_cb,
                                error_handler=self.__get_active_ap_error_cb)
 
         self._bus.add_signal_receiver(self.__state_changed_cb,
                                       signal_name='StateChanged',
                                       path=self._device.object_path,
-                                      dbus_interface=_NM_DEVICE_IFACE)
+                                      dbus_interface=network.NM_DEVICE_IFACE)
 
     def disconnect(self):
         self._bus.remove_signal_receiver(self.__state_changed_cb,
                                          signal_name='StateChanged',
                                          path=self._device.object_path,
-                                         dbus_interface=_NM_DEVICE_IFACE)
+                                         dbus_interface=network.NM_DEVICE_IFACE)
 
     def __get_device_props_reply_cb(self, properties):
         if 'State' in properties:
@@ -447,22 +436,22 @@ class WirelessDeviceView(ToolButton):
                     self.__ap_properties_changed_cb,
                     signal_name='PropertiesChanged',
                     path=self._active_ap_op,
-                    dbus_interface=_NM_ACCESSPOINT_IFACE)
+                    dbus_interface=network.NM_ACCESSPOINT_IFACE)
             if active_ap_op == '/':
                 self._active_ap_op = None
                 return
             self._active_ap_op = active_ap_op
-            active_ap = self._bus.get_object(_NM_SERVICE, active_ap_op)
+            active_ap = self._bus.get_object(network.NM_SERVICE, active_ap_op)
             props = dbus.Interface(active_ap, dbus.PROPERTIES_IFACE)
 
-            props.GetAll(_NM_ACCESSPOINT_IFACE, byte_arrays=True,
+            props.GetAll(network.NM_ACCESSPOINT_IFACE, byte_arrays=True,
                          reply_handler=self.__get_all_ap_props_reply_cb,
                          error_handler=self.__get_all_ap_props_error_cb)
 
             self._bus.add_signal_receiver(self.__ap_properties_changed_cb,
                                           signal_name='PropertiesChanged',
                                           path=self._active_ap_op,
-                                          dbus_interface=_NM_ACCESSPOINT_IFACE)
+                                          dbus_interface=network.NM_ACCESSPOINT_IFACE)
 
     def __get_active_ap_error_cb(self, err):
         logging.error('Error getting the active access point: %s', err)
@@ -470,7 +459,7 @@ class WirelessDeviceView(ToolButton):
     def __state_changed_cb(self, new_state, old_state, reason):
         self._device_state = new_state
         self._update_state()
-        self._device_props.Get(_NM_WIRELESS_IFACE, 'ActiveAccessPoint',
+        self._device_props.Get(network.NM_WIRELESS_IFACE, 'ActiveAccessPoint',
                                reply_handler=self.__get_active_ap_reply_cb,
                                error_handler=self.__get_active_ap_error_cb)
 
@@ -528,11 +517,11 @@ class WirelessDeviceView(ToolButton):
         if self._active_ap_op is not None:
             state = self._device_state
         else:
-            state = network.DEVICE_STATE_UNKNOWN
+            state = network.NM_DEVICE_STATE_UNKNOWN
 
         if self._mode != network.NM_802_11_MODE_ADHOC and \
                 network.is_sugar_adhoc_network(self._name) == False:
-            if state == network.DEVICE_STATE_ACTIVATED:
+            if state == network.NM_DEVICE_STATE_ACTIVATED:
                 icon_name = '%s-connected' % 'network-wireless'
             else:
                 icon_name = 'network-wireless'
@@ -542,21 +531,19 @@ class WirelessDeviceView(ToolButton):
                 self._icon.props.icon_name = icon_name
         else:
             channel = network.frequency_to_channel(self._frequency)
-            if state == network.DEVICE_STATE_ACTIVATED:
+            if state == network.NM_DEVICE_STATE_ACTIVATED:
                 self._icon.props.icon_name = 'network-adhoc-%s-connected' \
                         % channel
             else:
                 self._icon.props.icon_name = 'network-adhoc-%s' % channel
             self._icon.props.base_color = profile.get_color()
 
-        if state == network.DEVICE_STATE_PREPARE or \
-           state == network.DEVICE_STATE_CONFIG or \
-           state == network.DEVICE_STATE_NEED_AUTH or \
-           state == network.DEVICE_STATE_IP_CONFIG:
+        if (state >= network.NM_DEVICE_STATE_PREPARE) and \
+           (state <= network.NM_DEVICE_STATE_IP_CONFIG):
             self._palette.set_connecting()
             self._icon.props.pulsing = True
-        elif state == network.DEVICE_STATE_ACTIVATED:
-            address = self._device_props.Get(_NM_DEVICE_IFACE, 'Ip4Address')
+        elif state == network.NM_DEVICE_STATE_ACTIVATED:
+            address = self._device_props.Get(network.NM_DEVICE_IFACE, 'Ip4Address')
             self._palette.set_connected_with_frequency(self._frequency,
                                                        address)
             self._icon.props.pulsing = False
@@ -571,11 +558,6 @@ class WirelessDeviceView(ToolButton):
         self._icon.props.base_color = self._color
 
     def __deactivate_connection_cb(self, palette, data=None):
-        if self._mode == network.NM_802_11_MODE_INFRA:
-            connection = network.find_connection_by_ssid(self._name)
-            if connection:
-                connection.disable_autoconnect()
-
         network.disconnect_access_points([self._active_ap_op])
 
     def __activate_reply_cb(self, connection):
@@ -620,20 +602,20 @@ class OlpcMeshDeviceView(ToolButton):
 
         self._device_props = dbus.Interface(self._device,
                                             dbus.PROPERTIES_IFACE)
-        self._device_props.Get(_NM_OLPC_MESH_IFACE, 'ActiveChannel',
+        self._device_props.Get(network.NM_OLPC_MESH_IFACE, 'ActiveChannel',
                             reply_handler=self.__get_active_channel_reply_cb,
                             error_handler=self.__get_active_channel_error_cb)
 
         self._bus.add_signal_receiver(self.__wireless_properties_changed_cb,
                                       signal_name='PropertiesChanged',
                                       path=device.object_path,
-                                      dbus_interface=_NM_OLPC_MESH_IFACE)
+                                      dbus_interface=network.NM_OLPC_MESH_IFACE)
 
     def disconnect(self):
         self._bus.remove_signal_receiver(self.__wireless_properties_changed_cb,
                                          signal_name='PropertiesChanged',
                                          path=self._device.object_path,
-                                         dbus_interface=_NM_OLPC_MESH_IFACE)
+                                         dbus_interface=network.NM_OLPC_MESH_IFACE)
 
     def __get_active_channel_reply_cb(self, channel):
         self._channel = channel
@@ -659,16 +641,14 @@ class OlpcMeshDeviceView(ToolButton):
     def _update(self):
         state = self._device_state
 
-        if state in [network.DEVICE_STATE_PREPARE,
-                     network.DEVICE_STATE_CONFIG,
-                     network.DEVICE_STATE_NEED_AUTH,
-                     network.DEVICE_STATE_IP_CONFIG]:
+        if (state >= network.NM_DEVICE_STATE_PREPARE) and \
+           (state <= network.NM_DEVICE_STATE_IP_CONFIG):
             self._icon.props.base_color = self._inactive_color
             self._icon.props.pulse_color = profile.get_color()
             self._palette.set_connecting()
             self._icon.props.pulsing = True
-        elif state == network.DEVICE_STATE_ACTIVATED:
-            address = self._device_props.Get(_NM_DEVICE_IFACE, 'Ip4Address')
+        elif state == network.NM_DEVICE_STATE_ACTIVATED:
+            address = self._device_props.Get(network.NM_DEVICE_IFACE, 'Ip4Address')
             self._palette.set_connected_with_channel(self._channel, address)
             self._icon.props.base_color = profile.get_color()
             self._icon.props.pulsing = False
@@ -679,23 +659,23 @@ class OlpcMeshDeviceView(ToolButton):
         self._update()
 
     def __deactivate_connection(self, palette, data=None):
-        obj = self._bus.get_object(_NM_SERVICE, _NM_PATH)
-        netmgr = dbus.Interface(obj, _NM_IFACE)
+        obj = self._bus.get_object(network.NM_SERVICE, network.NM_PATH)
+        netmgr = dbus.Interface(obj, network.NM_IFACE)
         netmgr_props = dbus.Interface(netmgr, dbus.PROPERTIES_IFACE)
-        active_connections_o = netmgr_props.Get(_NM_IFACE,
+        active_connections_o = netmgr_props.Get(network.NM_IFACE,
                                                 'ActiveConnections')
 
         for conn_o in active_connections_o:
             # The connection path for a mesh connection is the device itself.
-            obj = self._bus.get_object(_NM_IFACE, conn_o)
+            obj = self._bus.get_object(network.NM_IFACE, conn_o)
             props = dbus.Interface(obj, dbus.PROPERTIES_IFACE)
-            ap_op = props.Get(_NM_ACTIVE_CONN_IFACE, 'SpecificObject')
+            ap_op = props.Get(network.NM_ACTIVE_CONN_IFACE, 'SpecificObject')
 
             try:
-                obj = self._bus.get_object(_NM_IFACE, ap_op)
+                obj = self._bus.get_object(network.NM_IFACE, ap_op)
                 props = dbus.Interface(obj, dbus.PROPERTIES_IFACE)
-                device_type = props.Get(_NM_DEVICE_IFACE, 'DeviceType')
-                if device_type == network.DEVICE_TYPE_802_11_OLPC_MESH:
+                device_type = props.Get(network.NM_DEVICE_IFACE, 'DeviceType')
+                if device_type == network.NM_DEVICE_TYPE_OLPC_MESH:
                     netmgr.DeactivateConnection(conn_o)
                     break
             except dbus.exceptions.DBusException:
@@ -742,11 +722,11 @@ class GsmDeviceView(TrayIcon):
         self._bus.add_signal_receiver(self.__state_changed_cb,
                                       signal_name='StateChanged',
                                       path=self._device.object_path,
-                                      dbus_interface=_NM_DEVICE_IFACE)
+                                      dbus_interface=network.NM_DEVICE_IFACE)
         self._bus.add_signal_receiver(self.__ppp_stats_changed_cb,
                                       signal_name='PppStats',
                                       path=self._device.object_path,
-                                      dbus_interface=_NM_SERIAL_IFACE)
+                                      dbus_interface=network.NM_MODEM_IFACE)
 
     def create_palette(self):
         palette = GsmPalette()
@@ -758,7 +738,7 @@ class GsmDeviceView(TrayIcon):
         self._palette = palette
 
         props = dbus.Interface(self._device, dbus.PROPERTIES_IFACE)
-        props.GetAll(_NM_DEVICE_IFACE, byte_arrays=True,
+        props.GetAll(network.NM_DEVICE_IFACE, byte_arrays=True,
                      reply_handler=self.__current_state_check_cb,
                      error_handler=self.__current_state_check_error_cb)
 
@@ -767,14 +747,9 @@ class GsmDeviceView(TrayIcon):
     def __gsm_connect_cb(self, palette, data=None):
         connection = network.find_gsm_connection()
         if connection is not None:
-            obj = self._bus.get_object(_NM_SERVICE, _NM_PATH)
-            netmgr = dbus.Interface(obj, _NM_IFACE)
-            netmgr.ActivateConnection(network.SETTINGS_SERVICE,
-                                        connection.path,
-                                        self._device.object_path,
-                                        '/',
-                                        reply_handler=self.__connect_cb,
-                                        error_handler=self.__connect_error_cb)
+            connection.activate(self._device.object_path,
+                                reply_handler=self.__connect_cb,
+                                error_handler=self.__connect_error_cb)
         else:
             self._palette.add_alert(_('No GSM connection available.'), \
                                         _('Create a connection in the ' \
@@ -788,15 +763,15 @@ class GsmDeviceView(TrayIcon):
         raise RuntimeError('Error when connecting to gsm device, %s' % error)
 
     def __gsm_disconnect_cb(self, palette, data=None):
-        obj = self._bus.get_object(_NM_SERVICE, _NM_PATH)
-        netmgr = dbus.Interface(obj, _NM_IFACE)
+        obj = self._bus.get_object(network.NM_SERVICE, network.NM_PATH)
+        netmgr = dbus.Interface(obj, network.NM_IFACE)
         netmgr_props = dbus.Interface(netmgr, dbus.PROPERTIES_IFACE)
-        active_connections_o = netmgr_props.Get(_NM_IFACE, 'ActiveConnections')
+        active_connections_o = netmgr_props.Get(network.NM_IFACE, 'ActiveConnections')
 
         for conn_o in active_connections_o:
-            obj = self._bus.get_object(_NM_IFACE, conn_o)
+            obj = self._bus.get_object(network.NM_IFACE, conn_o)
             props = dbus.Interface(obj, dbus.PROPERTIES_IFACE)
-            devices = props.Get(_NM_ACTIVE_CONN_IFACE, 'Devices')
+            devices = props.Get(network.NM_ACTIVE_CONN_IFACE, 'Devices')
             if self._device.object_path in devices:
                 netmgr.DeactivateConnection(
                         conn_o,
@@ -824,13 +799,12 @@ class GsmDeviceView(TrayIcon):
     def _update_state(self, state, old_state, reason):
         gsm_state = None
 
-        if state is network.DEVICE_STATE_ACTIVATED:
+        if state is network.NM_DEVICE_STATE_ACTIVATED:
             gsm_state = _GSM_STATE_CONNECTED
             connection = network.find_gsm_connection()
             if connection is not None:
-                connection.set_connected()
                 self._connection_timestamp = time.time() - \
-                        connection.get_settings().connection.timestamp
+                        connection.get_settings('connection')['timestamp']
                 self._connection_time_handler = gobject.timeout_add_seconds( \
                         1, self.__connection_timecount_cb)
                 self._palette.update_connection_time()
@@ -838,7 +812,7 @@ class GsmDeviceView(TrayIcon):
                 if self._palette is not None:
                     self._palette.connection_info_box.show()
 
-        elif state is network.DEVICE_STATE_DISCONNECTED:
+        elif state is network.NM_DEVICE_STATE_DISCONNECTED:
             gsm_state = _GSM_STATE_DISCONNECTED
             self._connection_timestamp = 0
             if self._connection_time_handler is not None:
@@ -846,18 +820,16 @@ class GsmDeviceView(TrayIcon):
             if self._palette is not None:
                 self._palette.connection_info_box.hide()
 
-        elif state in [network.DEVICE_STATE_UNMANAGED,
-                       network.DEVICE_STATE_UNAVAILABLE,
-                       network.DEVICE_STATE_UNKNOWN]:
+        elif state in [network.NM_DEVICE_STATE_UNMANAGED,
+                       network.NM_DEVICE_STATE_UNAVAILABLE,
+                       network.NM_DEVICE_STATE_UNKNOWN]:
             gsm_state = _GSM_STATE_NOT_READY
 
-        elif state in [network.DEVICE_STATE_PREPARE,
-                       network.DEVICE_STATE_CONFIG,
-                       network.DEVICE_STATE_IP_CONFIG,
-                       network.DEVICE_STATE_NEED_AUTH]:
+        elif (state >= network.NM_DEVICE_STATE_PREPARE) and \
+             (state <= network.NM_DEVICE_STATE_IP_CONFIG):
             gsm_state = _GSM_STATE_CONNECTING
 
-        elif state == network.DEVICE_STATE_FAILED:
+        elif state == network.NM_DEVICE_STATE_FAILED:
             gsm_state = _GSM_STATE_FAILED
 
         if self._palette is not None:
@@ -867,7 +839,7 @@ class GsmDeviceView(TrayIcon):
         self._bus.remove_signal_receiver(self.__state_changed_cb,
                                          signal_name='StateChanged',
                                          path=self._device.object_path,
-                                         dbus_interface=_NM_DEVICE_IFACE)
+                                         dbus_interface=network.NM_DEVICE_IFACE)
 
     def __ppp_stats_changed_cb(self, in_bytes, out_bytes):
         self._palette.update_stats(in_bytes, out_bytes)
@@ -903,14 +875,14 @@ class MeshDeviceObserver(object):
         self._tray = tray
 
         props = dbus.Interface(self._device, dbus.PROPERTIES_IFACE)
-        props.GetAll(_NM_DEVICE_IFACE, byte_arrays=True,
+        props.GetAll(network.NM_DEVICE_IFACE, byte_arrays=True,
                      reply_handler=self.__get_device_props_reply_cb,
                      error_handler=self.__get_device_props_error_cb)
 
         self._bus.add_signal_receiver(self.__state_changed_cb,
                                       signal_name='StateChanged',
                                       path=self._device.object_path,
-                                      dbus_interface=_NM_DEVICE_IFACE)
+                                      dbus_interface=network.NM_DEVICE_IFACE)
 
     def _remove_device_view(self):
         self._device_view.disconnect()
@@ -924,7 +896,7 @@ class MeshDeviceObserver(object):
         self._bus.remove_signal_receiver(self.__state_changed_cb,
                                          signal_name='StateChanged',
                                          path=self._device.object_path,
-                                         dbus_interface=_NM_DEVICE_IFACE)
+                                         dbus_interface=network.NM_DEVICE_IFACE)
 
     def __get_device_props_reply_cb(self, properties):
         if 'State' in properties:
@@ -937,10 +909,8 @@ class MeshDeviceObserver(object):
         self._update_state(new_state)
 
     def _update_state(self, state):
-        if state in (network.DEVICE_STATE_PREPARE, network.DEVICE_STATE_CONFIG,
-                     network.DEVICE_STATE_NEED_AUTH,
-                     network.DEVICE_STATE_IP_CONFIG,
-                     network.DEVICE_STATE_ACTIVATED):
+        if (state >= network.NM_DEVICE_STATE_PREPARE) and \
+           (state <= network.NM_DEVICE_STATE_ACTIVATED):
             if self._device_view is not None:
                 self._device_view.update_state(state)
                 return
@@ -961,20 +931,20 @@ class WiredDeviceObserver(object):
         self._tray = tray
 
         props = dbus.Interface(self._device, dbus.PROPERTIES_IFACE)
-        props.GetAll(_NM_DEVICE_IFACE, byte_arrays=True,
+        props.GetAll(network.NM_DEVICE_IFACE, byte_arrays=True,
                      reply_handler=self.__get_device_props_reply_cb,
                      error_handler=self.__get_device_props_error_cb)
 
         self._bus.add_signal_receiver(self.__state_changed_cb,
                                       signal_name='StateChanged',
                                       path=self._device.object_path,
-                                      dbus_interface=_NM_DEVICE_IFACE)
+                                      dbus_interface=network.NM_DEVICE_IFACE)
 
     def disconnect(self):
         self._bus.remove_signal_receiver(self.__state_changed_cb,
                                          signal_name='StateChanged',
                                          path=self._device.object_path,
-                                         dbus_interface=_NM_DEVICE_IFACE)
+                                         dbus_interface=network.NM_DEVICE_IFACE)
 
     def __get_device_props_reply_cb(self, properties):
         if 'State' in properties:
@@ -987,10 +957,10 @@ class WiredDeviceObserver(object):
         self._update_state(new_state)
 
     def _update_state(self, state):
-        if state == network.DEVICE_STATE_ACTIVATED:
+        if state == network.NM_DEVICE_STATE_ACTIVATED:
             props = dbus.Interface(self._device, dbus.PROPERTIES_IFACE)
-            address = props.Get(_NM_DEVICE_IFACE, 'Ip4Address')
-            speed = props.Get(_NM_WIRED_IFACE, 'Speed')
+            address = props.Get(network.NM_DEVICE_IFACE, 'Ip4Address')
+            speed = props.Get(network.NM_WIRED_IFACE, 'Speed')
             self._device_view = WiredDeviceView(speed, address)
             self._tray.add_device(self._device_view)
         else:
@@ -1023,10 +993,10 @@ class NetworkManagerObserver(object):
         self._tray = tray
 
         try:
-            obj = self._bus.get_object(_NM_SERVICE, _NM_PATH)
-            self._netmgr = dbus.Interface(obj, _NM_IFACE)
+            obj = self._bus.get_object(network.NM_SERVICE, network.NM_PATH)
+            self._netmgr = dbus.Interface(obj, network.NM_IFACE)
         except dbus.DBusException:
-            logging.error('%s service not available', _NM_SERVICE)
+            logging.error('%s service not available', network.NM_SERVICE)
             return
 
         self._netmgr.GetDevices(reply_handler=self.__get_devices_reply_cb,
@@ -1034,10 +1004,10 @@ class NetworkManagerObserver(object):
 
         self._bus.add_signal_receiver(self.__device_added_cb,
                                       signal_name='DeviceAdded',
-                                      dbus_interface=_NM_IFACE)
+                                      dbus_interface=network.NM_IFACE)
         self._bus.add_signal_receiver(self.__device_removed_cb,
                                       signal_name='DeviceRemoved',
-                                      dbus_interface=_NM_IFACE)
+                                      dbus_interface=network.NM_IFACE)
 
     def __get_devices_reply_cb(self, devices):
         for device_op in devices:
@@ -1047,20 +1017,20 @@ class NetworkManagerObserver(object):
         logging.error('Failed to get devices: %s', err)
 
     def _check_device(self, device_op):
-        nm_device = self._bus.get_object(_NM_SERVICE, device_op)
+        nm_device = self._bus.get_object(network.NM_SERVICE, device_op)
         props = dbus.Interface(nm_device, dbus.PROPERTIES_IFACE)
 
-        device_type = props.Get(_NM_DEVICE_IFACE, 'DeviceType')
-        if device_type == network.DEVICE_TYPE_802_3_ETHERNET:
+        device_type = props.Get(network.NM_DEVICE_IFACE, 'DeviceType')
+        if device_type == network.NM_DEVICE_TYPE_ETHERNET:
             device = WiredDeviceObserver(nm_device, self._tray)
             self._devices[device_op] = device
-        elif device_type == network.DEVICE_TYPE_802_11_WIRELESS:
+        elif device_type == network.NM_DEVICE_TYPE_WIFI:
             device = WirelessDeviceObserver(nm_device, self._tray)
             self._devices[device_op] = device
-        elif device_type == network.DEVICE_TYPE_802_11_OLPC_MESH:
+        elif device_type == network.NM_DEVICE_TYPE_OLPC_MESH:
             device = MeshDeviceObserver(nm_device, self._tray)
             self._devices[device_op] = device
-        elif device_type == network.DEVICE_TYPE_GSM_MODEM:
+        elif device_type == network.NM_DEVICE_TYPE_MODEM:
             device = GsmDeviceObserver(nm_device, self._tray)
             self._devices[device_op] = device