def _load_profile_from_imsi(self, imsi):
logger.info("Loading profile for imsi %s" % str(imsi))
try:
props = self.manager.get_profile_options_from_imsi(imsi)
self._load_settings(props)
except ProfileNotFoundError:
self.uuid = str(uuid1())
def send_pin(self, pin, cb):
logger.info("Trying authentication with PIN %s" % pin)
self.device.SendPin(pin,
timeout=AUTH_TIMEOUT,
dbus_interface=CRD_INTFACE,
reply_handler=lambda *args: cb(),
error_handler=self._send_pin_eb)
def on_connect_button_toggled(self, widget):
dialmanager = self.model.get_dialer_manager()
if widget.get_active():
# user wants to connect
if not self.model.device:
widget.set_active(False)
show_warning_dialog(
_("No device found"),
_("No device has been found. Insert one and try again."))
return
profiles_model = self.model.preferences_model.profiles_model
if not profiles_model.has_active_profile():
widget.set_active(False)
show_warning_dialog(
_("Profile needed"),
_("You need to create a profile for connecting."))
self.ask_for_new_profile()
return
active_profile = profiles_model.get_active_profile()
dialmanager.ActivateConnection(active_profile.profile_path,
self.model.device_opath,
timeout=40,
reply_handler=self._on_connect_cb,
error_handler=self._on_connect_eb)
self._setup_connection_signals()
def cancel_cb():
self.view.set_disconnected()
self.model.dial_path = None
def stop_connection_attempt():
self._ignore_no_reply = True
dialmanager.StopConnection(self.model.device_opath,
reply_handler=cancel_cb,
error_handler=logger.error)
self.apb = ActivityProgressBar(_("Connecting"), self)
self.apb.set_cancel_cb(stop_connection_attempt)
self.apb.init()
logger.info("Connecting...")
else:
# user wants to disconnect
if not self.model.dial_path:
return
self.apb = ActivityProgressBar(_("Disconnecting"), self,
disable_cancel=True)
dialmanager.DeactivateConnection(self.model.dial_path,
reply_handler=self._on_disconnect_cb,
error_handler=self._on_disconnect_eb)
self.apb.init()
self.model.dial_path = None
def disconnected_cb(self):
"""
org.freedesktop.ModemManager.Dial.Disconnect signal callback
"""
logger.info("Disconnected received")
button = self.parent.view['connect_button']
# block and unblock handler while toggling connect button
button.handler_block(self.parent.cid)
button.set_active(False)
button.handler_unblock(self.parent.cid)
self.close()
def delete(self):
if self.profile:
logger.info("Removing profile %s" % self.profile)
self.manager.remove_profile(self.profile)
self.profile_path = None
self.uuid = None
self.name = ""
while self.sm:
sm = self.sm.pop()
sm.remove()
else:
raise RuntimeError(_("Trying to remove an unsaved profile"))
def _device_removed_cb(self, opath):
logger.info('Device with opath %s removed' % opath)
if self.device_opath:
logger.info('Device path: %s' % self.device_opath)
if opath == self.device_opath:
self.device = None
self.device_opath = None
self.dial_path = None
self.operator = _('Unknown')
self.status = _('No device')
self.tech = '----'
self.rssi = 0
def _on_disconnect_cb(self, *args):
logger.info("Disconnected")
self.model.stop_stats_tracking()
self.view.set_disconnected()
if self.apb:
self.apb.close()
self.apb = None
if self.model.dial_path:
# if dial_path is not None, it means that the connection was
# deactivated externally to wader, either through nm-applet
# or because pppd died or something.
dialmanager = self.model.get_dialer_manager()
dialmanager.DeactivateConnection(self.model.dial_path)
self.model.dial_path = None
def _enable_device_cb(self):
logger.info("Device enabled")
self.pin_required = False
self.puk_required = False
self.puk2_required = False
self.device.connect_to_signal(S.SIG_RSSI, self._rssi_changed_cb)
self.device.connect_to_signal(S.SIG_NETWORK_MODE,
self._network_mode_changed_cb)
self.device.GetSignalQuality(dbus_interface=NET_INTFACE,
reply_handler=self._rssi_changed_cb,
error_handler=lambda m:
logger.warn("Cannot get RSSI %s" % m))
self._start_network_registration()
# delay the profile creation till the device is completely enabled
self._get_config()
def _get_devices_cb(self, opaths):
if len(opaths):
if self.device_opath:
logger.warn("Device %s is already active" % self.device_opath)
return
self.device_opath = opaths[0]
logger.info("Setting up device %s" % self.device_opath)
self.device = self.bus.get_object(WADER_SERVICE, self.device_opath)
self.pin_required = False
self.puk_required = False
self.puk2_required = False
self.total_bytes = self.conf.get('statistics', 'total_bytes', 0)
self.enable_device()
else:
logger.warn("No devices found")
# connecting to signals is safe now
self._connect_to_signals()
def reset_statistics(self):
logger.info("Resetting total bytes")
self.parent.total_bytes = 0
self.conf.set("statistics", "total_bytes", 0)
def property_total_bytes_value_change(self, model, old, new):
if old != new and new != '':
self.view['total_bytes_label'].set_text(bytes_repr(new))
logger.info("Total bytes: %d", new)
def property_tx_bytes_value_change(self, model, old, new):
if old != new:
self.view['tx_bytes_label'].set_text(bytes_repr(new))
logger.info("Bytes tx: %d", new)
def property_profile_value_change(self, model, old, new):
logger.info("A profile has been set for current model %s" % new)
def _on_network_key_needed_cb(self, opath, tag):
logger.info("KeyNeeded received, opath: %s tag: %s" % (opath, tag))
self.ctrl.on_net_password_required(opath, tag)
def send_puk(self, puk, pin, cb):
logger.info("Trying authentication with PUK %s, PIN %s" % (puk, pin))
self.device.SendPuk(puk, pin,
dbus_interface=CRD_INTFACE,
reply_handler=lambda *args: cb(),
error_handler=self._send_puk_eb)
def _device_added_cb(self, opath):
logger.info('Device with opath %s added' % opath)
if not self.device:
self._get_devices_cb([opath])
def _network_mode_changed_cb(self, net_mode):
logger.info("Network mode changed %s" % net_mode)
self.tech = NET_MODE_SIGNALS[net_mode]
def _rssi_changed_cb(self, rssi):
logger.info("RSSI changed %d" % rssi)
self.rssi = rssi
def _on_keyring_key_needed_cb(self, opath):
logger.info("KeyNeeded received")
self.ctrl.on_keyring_password_required(opath)
