From 17e147e12210a7153d75eaf2ec003909c4a8e603 Mon Sep 17 00:00:00 2001 From: tch Date: Thu, 17 Dec 2009 10:45:15 -0300 Subject: [PATCH] gsm connection support, control panel section and device icon --- data/icons/module-modemconfiguration.svg | 1272 ++++++++++++++++++++ .../cpsection/modemconfiguration/__init__.py | 22 + extensions/cpsection/modemconfiguration/model.py | 43 + extensions/cpsection/modemconfiguration/view.py | 142 +++ extensions/deviceicon/network.py | 170 +++- src/jarabe/desktop/meshbox.py | 10 +- src/jarabe/model/network.py | 189 +++- 7 files changed, 1825 insertions(+), 23 deletions(-) create mode 100644 data/icons/module-modemconfiguration.svg create mode 100644 extensions/cpsection/modemconfiguration/__init__.py create mode 100644 extensions/cpsection/modemconfiguration/model.py create mode 100644 extensions/cpsection/modemconfiguration/view.py diff --git a/data/icons/module-modemconfiguration.svg b/data/icons/module-modemconfiguration.svg new file mode 100644 index 0000000..b62a12e --- /dev/null +++ b/data/icons/module-modemconfiguration.svg @@ -0,0 +1,1272 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + Workgroup + + + Jakub Steiner + + + http://jimmac.musichall.cz + + + + lan + workgroup + network + peer + + + + + Garrett LeSage + + + + + + + + + + + + + + + + + + + + + + + www + + diff --git a/extensions/cpsection/modemconfiguration/__init__.py b/extensions/cpsection/modemconfiguration/__init__.py new file mode 100644 index 0000000..b0703e2 --- /dev/null +++ b/extensions/cpsection/modemconfiguration/__init__.py @@ -0,0 +1,22 @@ +# Copyright (C) 2009 Martin Abente +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 US + +from gettext import gettext as _ + +CLASS = 'ModemConfiguration' +ICON = 'module-modemconfiguration' +TITLE = _('Modem Configuration') + diff --git a/extensions/cpsection/modemconfiguration/model.py b/extensions/cpsection/modemconfiguration/model.py new file mode 100644 index 0000000..d06db75 --- /dev/null +++ b/extensions/cpsection/modemconfiguration/model.py @@ -0,0 +1,43 @@ +# Copyright (C) 2009 Martin Abente +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 US + +from jarabe.model.network import StorageGsm + +storage = StorageGsm() + +def get_username(): + return storage.get_username() + +def get_password(): + return storage.get_password() + +def get_number(): + return storage.get_number() + +def get_apn(): + return storage.get_apn() + +def set_username(username): + storage.set_username(username) + +def set_password(password): + storage.set_password(password) + +def set_number(number): + storage.set_number(number) + +def set_apn(apn): + storage.set_apn(apn) diff --git a/extensions/cpsection/modemconfiguration/view.py b/extensions/cpsection/modemconfiguration/view.py new file mode 100644 index 0000000..3033463 --- /dev/null +++ b/extensions/cpsection/modemconfiguration/view.py @@ -0,0 +1,142 @@ +# Copyright (C) 2009 Martin Abente +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# 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 gtk +import gobject + +from sugar.graphics import style + +from jarabe.controlpanel.sectionview import SectionView + +APPLY_TIMEOUT = 1000 + +_LABEL = 0 +_MODEL_GET = 1 +_MODEL_SET = 2 + +_ATTRIBUTES = { + 'username' : [_('Username'), 'get_username', 'set_username'], + 'password' : [_('Password'), 'get_password', 'set_password'], + 'number' : [_('Number'), 'get_number', 'set_number'], + 'apn' : [_('Apn'), 'get_apn', 'set_apn'] +} + +class MyEntry(gtk.Entry): + def __init__(self, model, attr_name): + gtk.Entry.__init__(self, 25) + + self.sid = 0 + self.is_valid = True + self.get_method = getattr(model, _ATTRIBUTES[attr_name][_MODEL_GET]) + self.set_method = getattr(model, _ATTRIBUTES[attr_name][_MODEL_SET]) + self.set_width_chars(25) + +class ModemConfiguration(SectionView): + def __init__(self, model, alerts=None): + SectionView.__init__(self) + + self._model = model + self.restart_alerts = alerts + self._username_sid = 0 + self._username_valid = True + self._password_valid = True + self._number_valid = True + self._apn_valid = True + + self.set_border_width(style.DEFAULT_SPACING) + self.set_spacing(style.DEFAULT_SPACING) + self._group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL) + + self._username_entry = self._setup_field("username") + self._password_entry = self._setup_field('password') + self._number_entry = self._setup_field('number') + self._apn_entry = self._setup_field('apn') + + self.setup() + + def _setup_field(self, attr_name): + box = gtk.HBox(spacing=style.DEFAULT_SPACING) + + label = gtk.Label(_ATTRIBUTES[attr_name][_LABEL] + ':') + label.modify_fg(gtk.STATE_NORMAL, style.COLOR_SELECTION_GREY.get_gdk_color()) + box.pack_start(label) + + entry = MyEntry(self._model, attr_name) + box.pack_start(entry, False) + box.show_all() + + self.pack_start(box, False) + return entry + + def setup(self): + self._username_entry.set_text(self._model.get_username()) + self._password_entry.set_text(self._model.get_password()) + self._number_entry.set_text(self._model.get_number()) + self._apn_entry.set_text(self._model.get_apn()) + + self._username_valid = True + self._password_valid = True + self._number_valid = True + self._apn_valid = True + self.needs_restart = False + + self._username_change_handler = self._username_entry.connect( \ + 'changed', self.__changed_cb) + self._password_change_handler = self._password_entry.connect( \ + 'changed', self.__changed_cb) + self._number_change_handler = self._number_entry.connect( \ + 'changed', self.__changed_cb) + self._apn_change_handler = self._apn_entry.connect( \ + 'changed', self.__changed_cb) + + def undo(self): + self._username_entry.disconnect(self._username_change_handler) + self._password_entry.disconnect(self._password_change_handler) + self._number_entry.disconnect(self._number_change_handler) + self._apn_entry.disconnect(self._apn_change_handler) + 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: + self.props.is_valid = True + else: + self.props.is_valid = False + + def __changed_cb(self, widget, data=None): + if widget.sid: + gobject.source_remove(widget.sid) + widget.sid = gobject.timeout_add(APPLY_TIMEOUT, + self.__timeout_cb, widget) + + def __timeout_cb(self, widget): + widget.sid = 0 + + if widget.get_text() == widget.get_method(): + return False + try: + widget.set_method(widget.get_text()) + except ValueError, detail: + widget.is_valid = False + else: + widget.is_valid = True + self.needs_restart = True + self._validate() + return False + diff --git a/extensions/deviceicon/network.py b/extensions/deviceicon/network.py index dd1a70c..3a9b27f 100644 --- a/extensions/deviceicon/network.py +++ b/extensions/deviceicon/network.py @@ -1,6 +1,6 @@ # # Copyright (C) 2008 One Laptop Per Child -# Copyright (C) 2009 Tomeu Vizoso, Simon Schampijer +# Copyright (C) 2009 Tomeu Vizoso, Simon Schampijer, Martin Abente # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -63,6 +63,22 @@ _NM_DEVICE_STATE_IP_CONFIG = 7 _NM_DEVICE_STATE_ACTIVATED = 8 _NM_DEVICE_STATE_FAILED = 9 +_GSM_STATE_NOT_READY = 0 +_GSM_STATE_DISCONNECTED = 1 +_GSM_STATE_CONNECTING = 2 +_GSM_STATE_CONNECTED = 3 + +_GSM_SIGNAL = 0 +_GSM_LABEL = 1 +_GSM_TEXT = 2 + +_GSM_STATES = { + _GSM_STATE_NOT_READY : ['gsm-idle', '...', _('Please wait...')], + _GSM_STATE_DISCONNECTED : ['gsm-connect', _('Connect'), _('Disconnected')], + _GSM_STATE_CONNECTING : ['gsm-disconnect', _('Cancel'), _('Connecting...')], + _GSM_STATE_CONNECTED : ['gsm-disconnect', _('Disconnect'), _('Connected')] +} + def frequency_to_channel(frequency): ftoc = { 2412: 1, 2417: 2, 2422: 3, 2427: 4, 2432: 5, 2437: 6, 2442: 7, 2447: 8, @@ -201,6 +217,38 @@ class WiredPalette(Palette): ip_address_text = "" self._ip_address_label.set_text(ip_address_text) +class GsmPalette(Palette): + __gtype_name__ = 'SugarGsmPalette' + + __gsignals__ = { + 'gsm-connect' : (gobject.SIGNAL_RUN_FIRST, + gobject.TYPE_NONE, ([])), + 'gsm-disconnect' : (gobject.SIGNAL_RUN_FIRST, + gobject.TYPE_NONE, ([])), + 'gsm-idle' : (gobject.SIGNAL_RUN_FIRST, + gobject.TYPE_NONE, ([])), + } + + def __init__(self): + Palette.__init__(self, label=_('GSM Device')) + + self._current_signal = _GSM_STATES[_GSM_STATE_NOT_READY][_GSM_SIGNAL] + self._toggle_state_item = gtk.MenuItem(_GSM_STATES[_GSM_STATE_NOT_READY][_GSM_LABEL]) + self._toggle_state_item.connect('activate', self._toggle_state_cb) + self.menu.append(self._toggle_state_item) + self._toggle_state_item.show() + + self.props.secondary_text = _GSM_STATES[_GSM_STATE_NOT_READY][_GSM_TEXT] + + def set_state(self, state): + + if state in _GSM_STATES: + self._current_signal = _GSM_STATES[state][_GSM_SIGNAL] + self._toggle_state_item.get_child().set_label(_GSM_STATES[state][_GSM_LABEL]) + self.props.secondary_text = _GSM_STATES[state][_GSM_TEXT] + + def _toggle_state_cb(self, menuitem): + self.emit(self._current_signal) class WirelessDeviceView(ToolButton): @@ -414,11 +462,11 @@ class WirelessDeviceView(ToolButton): color = client.get_string('/desktop/sugar/user/color') connection_name = _('%s\'s network %s') % (nick, color) - connection = network.find_connection(connection_name) + connection = network.find_connection_by_ssid(connection_name) if connection is None: settings = Settings() settings.connection.id = 'Auto ' + connection_name - settings.connection.uuid = unique_id() + uuid = settings.connection.uuid = unique_id() settings.connection.type = '802-11-wireless' settings.wireless.ssid = dbus.ByteArray(connection_name) settings.wireless.band = 'bg' @@ -426,7 +474,7 @@ class WirelessDeviceView(ToolButton): settings.ip4_config = IP4Config() settings.ip4_config.method = 'link-local' - connection = network.add_connection(connection_name, settings) + connection = network.add_connection(uuid, settings) obj = self._bus.get_object(_NM_SERVICE, _NM_PATH) netmgr = dbus.Interface(obj, _NM_IFACE) @@ -461,6 +509,103 @@ class WiredDeviceView(TrayIcon): self._palette.set_group_id('frame') self._palette.set_connected(speed, address) +class GsmDeviceView(TrayIcon): + + _ICON_NAME = 'gsm-device' + FRAME_POSITION_RELATIVE = 303 + + def __init__(self, device): + client = gconf.client_get_default() + color = xocolor.XoColor(client.get_string('/desktop/sugar/user/color')) + + TrayIcon.__init__(self, icon_name=self._ICON_NAME, xo_color=color) + + self._bus = dbus.SystemBus() + self._device = device + + self.set_palette_invoker(FrameWidgetInvoker(self)) + self._palette = GsmPalette() + self.set_palette(self._palette) + self._palette.set_group_id('frame') + + props = dbus.Interface(self._device, 'org.freedesktop.DBus.Properties') + props.GetAll(_NM_DEVICE_IFACE, byte_arrays=True, + reply_handler=self.__current_state_check_cb, + error_handler=self.__current_state_check_error_cb) + + self._palette.connect('gsm-connect', self.__gsm_connect_cb) + self._palette.connect('gsm-disconnect', self.__gsm_disconnect_cb) + self._palette.connect('gsm-idle', self.__gsm_idle_cb) + + self._bus.add_signal_receiver(self.__state_changed_cb, + signal_name='StateChanged', + path=self._device.object_path, + dbus_interface=_NM_DEVICE_IFACE) + + def __gsm_connect_cb(self, palette, data=None): + + try: + 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, + '/') + except Exception, detail: + logging.error('Could not connect to gsm connection, %s', detail) + + def __gsm_disconnect_cb(self, palette, data=None): + + obj = self._bus.get_object(_NM_SERVICE, _NM_PATH) + netmgr = dbus.Interface(obj, _NM_IFACE) + netmgr_props = dbus.Interface(netmgr, 'org.freedesktop.DBus.Properties') + active_connections_o = netmgr_props.Get(_NM_IFACE, 'ActiveConnections') + + for conn_o in active_connections_o: + obj = self._bus.get_object(_NM_IFACE, conn_o) + props = dbus.Interface(obj, 'org.freedesktop.DBus.Properties') + devices = props.Get(_NM_ACTIVE_CONN_IFACE, 'Devices') + if self._device.object_path in devices: + netmgr.DeactivateConnection(conn_o) + break + + def __gsm_idle_cb(self, palette, data=None): + pass + + def __state_changed_cb(self, new_state, old_state, reason): + self.__update_state(int(new_state)) + + def __current_state_check_cb(self, properties): + self.__update_state(int(properties['State'])) + + def __current_state_check_error_cb(self, err): + logging.error('Error getting gsm state %', err) + + def __update_state(self, state): + gsm_state = None + + if state is network.DEVICE_STATE_ACTIVATED: + gsm_state = _GSM_STATE_CONNECTED + + elif state is network.DEVICE_STATE_DISCONNECTED: + gsm_state = _GSM_STATE_DISCONNECTED + + elif state in [network.DEVICE_STATE_UNMANAGED, _NM_DEVICE_STATE_UNAVAILABLE, _NM_DEVICE_STATE_UNKNOWN]: + gsm_state = _GSM_STATE_NOT_READY + + elif state in [_NM_DEVICE_STATE_PREPARE, _NM_DEVICE_STATE_CONFIG, _NM_DEVICE_STATE_IP_CONFIG]: + gsm_state = _GSM_STATE_CONNECTING + + self._palette.set_state(gsm_state) + + 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) class WirelessDeviceObserver(object): def __init__(self, device, tray): @@ -526,6 +671,20 @@ class WiredDeviceObserver(object): del self._device_view self._device_view = None +class GsmDeviceObserver(object): + def __init__(self, device, tray): + self._device = device + self._device_view = None + self._tray = tray + + self._device_view = GsmDeviceView(device) + self._tray.add_device(self._device_view) + + def disconnect(self): + self._device_view.disconnect() + self._tray.remove_device(self._device_view) + del self._device_view + self._device_view = None class NetworkManagerObserver(object): def __init__(self, tray): @@ -569,6 +728,9 @@ class NetworkManagerObserver(object): elif device_type == network.DEVICE_TYPE_802_11_WIRELESS: device = WirelessDeviceObserver(nm_device, self._tray) self._devices[device_op] = device + elif device_type == network.DEVICE_TYPE_GSM_MODEM: + device = GsmDeviceObserver(nm_device, self._tray) + self._devices[device_op] = device def __device_added_cb(self, device_op): self._check_device(device_op) diff --git a/src/jarabe/desktop/meshbox.py b/src/jarabe/desktop/meshbox.py index 2c58fe6..8d953a0 100644 --- a/src/jarabe/desktop/meshbox.py +++ b/src/jarabe/desktop/meshbox.py @@ -111,7 +111,7 @@ class WirelessNetworkView(CanvasPulsingIcon): self.set_palette(self._palette) self._palette_icon.props.xo_color = self._color - if network.find_connection(self._name) is not None: + if network.find_connection_by_ssid(self._name) is not None: self.props.badge_name = "emblem-favorite" self._palette_icon.props.badge_name = "emblem-favorite" elif initial_ap.flags == network.NM_802_11_AP_FLAGS_PRIVACY: @@ -213,7 +213,7 @@ class WirelessNetworkView(CanvasPulsingIcon): state = network.DEVICE_STATE_UNKNOWN if state == network.DEVICE_STATE_ACTIVATED: - connection = network.find_connection(self._name) + connection = network.find_connection_by_ssid(self._name) if connection: if self._mode == network.NM_802_11_MODE_INFRA: connection.set_connected() @@ -330,11 +330,11 @@ class WirelessNetworkView(CanvasPulsingIcon): self._connect() def _connect(self): - connection = network.find_connection(self._name) + connection = network.find_connection_by_ssid(self._name) if connection is None: settings = Settings() settings.connection.id = 'Auto ' + self._name - settings.connection.uuid = unique_id() + uuid = settings.connection.uuid = unique_id() settings.connection.type = '802-11-wireless' settings.wireless.ssid = self._name @@ -352,7 +352,7 @@ class WirelessNetworkView(CanvasPulsingIcon): if wireless_security is not None: settings.wireless.security = '802-11-wireless-security' - connection = network.add_connection(self._name, settings) + connection = network.add_connection(uuid, settings) obj = self._bus.get_object(_NM_SERVICE, _NM_PATH) netmgr = dbus.Interface(obj, _NM_IFACE) diff --git a/src/jarabe/model/network.py b/src/jarabe/model/network.py index 10b73ab..00031ce 100644 --- a/src/jarabe/model/network.py +++ b/src/jarabe/model/network.py @@ -1,5 +1,5 @@ # Copyright (C) 2008 Red Hat, Inc. -# Copyright (C) 2009 Tomeu Vizoso, Simon Schampijer +# Copyright (C) 2009 Tomeu Vizoso, Simon Schampijer, Martin Abente # Copyright (C) 2009 One Laptop per Child # # This program is free software; you can redistribute it and/or modify @@ -23,12 +23,15 @@ import time import dbus import gobject import ConfigParser +import gconf from sugar import dispatch from sugar import env +from sugar.util import unique_id DEVICE_TYPE_802_3_ETHERNET = 1 DEVICE_TYPE_802_11_WIRELESS = 2 +DEVICE_TYPE_GSM_MODEM = 3 DEVICE_STATE_UNKNOWN = 0 DEVICE_STATE_UNMANAGED = 1 @@ -41,6 +44,9 @@ DEVICE_STATE_IP_CONFIG = 7 DEVICE_STATE_ACTIVATED = 8 DEVICE_STATE_FAILED = 9 +NM_CONNECTION_TYPE_802_11_WIRELESS = '802-11-wireless' +NM_CONNECTION_TYPE_GSM = 'gsm' + NM_ACTIVE_CONNECTION_STATE_UNKNOWN = 0 NM_ACTIVE_CONNECTION_STATE_ACTIVATING = 1 NM_ACTIVE_CONNECTION_STATE_ACTIVATED = 2 @@ -80,6 +86,11 @@ NM_CONNECTION_IFACE = 'org.freedesktop.NetworkManagerSettings.Connection' NM_SECRETS_IFACE = 'org.freedesktop.NetworkManagerSettings.Connection.Secrets' NM_ACCESSPOINT_IFACE = 'org.freedesktop.NetworkManager.AccessPoint' +GSM_USERNAME_PATH = '/sugar/nm/gsm/username' +GSM_PASSWORD_PATH = '/sugar/nm/gsm/password' +GSM_NUMBER_PATH = '/sugar/nm/gsm/number' +GSM_APN_PATH = '/sugar/nm/gsm/apn' + _nm_settings = None _conn_counter = 0 @@ -146,6 +157,44 @@ class IP4Config(object): ip4_config['method'] = self.method return ip4_config +class Serial(object): + def __init__(self): + self.baud = None + + def get_dict(self): + serial = {} + + if self.baud is not None: + serial['baud'] = self.baud + + return serial + +class Ppp(object): + def __init__(self): + pass + + def get_dict(self): + ppp = {} + return ppp + +class Gsm(object): + def __init__(self): + self.apn = None + self.number = None + self.username = None + + def get_dict(self): + gsm = {} + + if self.apn is not None: + gsm['apn'] = self.apn + if self.number is not None: + gsm['number'] = self.number + if self.username is not None: + gsm['username'] = self.username + + return gsm + class Settings(object): def __init__(self): self.connection = Connection() @@ -189,6 +238,35 @@ class Secrets(object): return settings +class SettingsGsm(object): + def __init__(self): + self.connection = Connection() + self.ip4_config = IP4Config() + self.serial = Serial() + self.ppp = Ppp() + self.gsm = Gsm() + + def get_dict(self): + settings = {} + + settings['connection'] = self.connection.get_dict() + settings['serial'] = self.serial.get_dict() + settings['ppp'] = self.ppp.get_dict() + settings['gsm'] = self.gsm.get_dict() + settings['ipv4'] = self.ip4_config.get_dict() + + return settings + +class SecretsGsm(object): + def __init__(self): + self.password = None + + def get_dict(self): + secrets = {} + if self.password is not None: + secrets['password'] = self.password + return { 'gsm' : secrets } + class NMSettings(dbus.service.Object): def __init__(self): bus = dbus.SystemBus() @@ -207,8 +285,8 @@ class NMSettings(dbus.service.Object): def NewConnection(self, connection_path): pass - def add_connection(self, ssid, conn): - self.connections[ssid] = conn + def add_connection(self, uuid, conn): + self.connections[uuid] = conn conn.secrets_request.connect(self.__secrets_request_cb) self.NewConnection(conn.path) @@ -248,11 +326,13 @@ class NMSettingsConnection(dbus.service.Object): if not self._settings.connection.autoconnect: self._settings.connection.autoconnect = True self._settings.connection.timestamp = int(time.time()) - self.save() + if self._settings.connection.type == NM_CONNECTION_TYPE_802_11_WIRELESS: + self.save() def set_secrets(self, secrets): self._secrets = secrets - self.save() + if self._settings.connection.type == NM_CONNECTION_TYPE_802_11_WIRELESS: + self.save() def get_settings(self): return self._settings @@ -441,6 +521,38 @@ class AccessPoint(gobject.GObject): path=self.model.object_path, dbus_interface=NM_ACCESSPOINT_IFACE) +class StorageGsm(object): + def __init__(self): + self.client = gconf.client_get_default() + + def get_username(self): + return self.verified(self.client.get_string(GSM_USERNAME_PATH)) + + def get_password(self): + return self.verified(self.client.get_string(GSM_PASSWORD_PATH)) + + def get_number(self): + return self.verified(self.client.get_string(GSM_NUMBER_PATH)) + + def get_apn(self): + return self.verified(self.client.get_string(GSM_APN_PATH)) + + def set_username(self, username): + self.client.set_string(GSM_USERNAME_PATH, username) + + def set_password(self, password): + self.client.set_string(GSM_PASSWORD_PATH, password) + + def set_number(self, number): + self.client.set_string(GSM_NUMBER_PATH, number) + + def set_apn(self, apn): + self.client.set_string(GSM_APN_PATH, apn) + + def verified(self, value): + if value is None: + return '' + return value def get_settings(): global _nm_settings @@ -452,24 +564,28 @@ def get_settings(): load_connections() return _nm_settings -def find_connection(ssid): +def find_connection_by_ssid(ssid): connections = get_settings().connections - if ssid in connections: - return connections[ssid] - else: - return None -def add_connection(ssid, settings, secrets=None): + for conn_index in connections: + connection = connections[conn_index] + if connection._settings.connection.type == NM_CONNECTION_TYPE_802_11_WIRELESS: + if connection._settings.wireless.ssid == ssid: + return connection + + return None + +def add_connection(uuid, settings, secrets=None): global _conn_counter path = NM_SETTINGS_PATH + '/' + str(_conn_counter) _conn_counter += 1 conn = NMSettingsConnection(path, settings, secrets) - _nm_settings.add_connection(ssid, conn) + _nm_settings.add_connection(uuid, conn) return conn -def load_connections(): +def load_wifi_connections(): profile_path = env.get_profile_path() config_path = os.path.join(profile_path, 'nm', 'connections.cfg') @@ -534,4 +650,49 @@ def load_connections(): except ConfigParser.Error: logging.exception('Error reading section') else: - add_connection(ssid, settings, secrets) + add_connection(uuid, settings, secrets) + +def load_gsm_connection(): + storage = StorageGsm() + settings = SettingsGsm() + secrets = SecretsGsm() + + try: + settings.gsm.username = storage.get_username() + settings.gsm.number = storage.get_number() + settings.gsm.apn = storage.get_apn() + password = storage.get_password() + + except ValueError: + logging.error("While loading gsm connection from settings") + + else: + if password != '': + secrets.password = password + + settings.connection.id = 'gsm' + settings.connection.type = NM_CONNECTION_TYPE_GSM + uuid = settings.connection.uuid = unique_id() + settings.connection.autoconnect = False + settings.ip4_config.method = 'auto' + settings.serial.baud = 115200 + + try: + add_connection(uuid, settings, secrets) + except Exception: + logging.error("While adding the gsm connection") + + +def load_connections(): + load_wifi_connections() + load_gsm_connection() + +def find_gsm_connection(): + connections = get_settings().connections + + for conn_index in connections: + connection = connections[conn_index] + if connection._settings.connection.type == NM_CONNECTION_TYPE_GSM: + return connection + + return None -- 1.6.0.4