def _ShouldStartStateMachine(self): state = self._modem.Get(mm1_constants.I_MODEM, 'State') # Return success if already enabled. if state >= mm1_constants.MM_MODEM_STATE_ENABLED: logging.info('Modem is already enabled. Nothing to do.') if self.return_cb: self.return_cb() return False if self._modem.enable_step and self._modem.enable_step != self: # There is already an enable operation in progress. # Note: ModemManager currently returns "WrongState" for this case. # The API suggests that "InProgress" should be returned, so that's # what we do here. logging.error('There is already an ongoing enable operation') if state == mm1_constants.MM_MODEM_STATE_ENABLING: message = 'Modem enable already in progress.' else: message = 'Modem enable has already been initiated' \ ', ignoring.' raise pm_errors.MMCoreError(pm_errors.MMCoreError.IN_PROGRESS, message) elif self._modem.enable_step is None: # There is no enable operation going on, cancelled or otherwise. if state != mm1_constants.MM_MODEM_STATE_DISABLED: message = 'Modem cannot be enabled if not in the DISABLED' \ ' state.' logging.error(message) raise pm_errors.MMCoreError(pm_errors.MMCoreError.WRONG_STATE, message) logging.info('Starting Enable') self._modem.enable_step = self return True
def _ShouldStartStateMachine(self): if self._modem.cdma_activate_step and \ self._modem.cdma_activate_step != self: # There is already an activate operation in progress. logging.error('There is already an ongoing activate operation.') raise pm_errors.MMCoreError(pm_errors.MMCoreError.IN_PROGRESS, "Activation already in progress.") if self._modem.cdma_activate_step is None: # There is no activate operation going on, cancelled or otherwise. state = self._modem.Get(mm1_constants.I_MODEM_CDMA, 'ActivationState') if (state != mm1_constants.MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED ): message = "Modem is not in state 'NOT_ACTIVATED'." logging.error(message) raise pm_errors.MMCoreError(pm_errors.MMCoreError.WRONG_STATE, message) state = self._modem.Get(mm1_constants.I_MODEM, 'State') if state != mm1_constants.MM_MODEM_STATE_REGISTERED: message = 'Modem cannot be activated if not in the ' \ 'REGISTERED state.' logging.error(message) raise pm_errors.MMCoreError(pm_errors.MMCoreError.WRONG_STATE, message) self._modem.cdma_activate_step = self return True
def _ShouldStartStateMachine(self): if self._modem.register_step and self._modem.register_step != self: # There is already an ongoing register operation. message = 'Register operation already in progress.' logging.info(message) error = pm_errors.MMCoreError(pm_errors.MMCoreError.IN_PROGRESS, message) if self._raise_cb: self._raise_cb(error) else: raise error elif self._modem.register_step is None: # There is no register operation going on, canceled or otherwise. state = self._modem.Get(mm1_constants.I_MODEM, 'State') if state != mm1_constants.MM_MODEM_STATE_ENABLED: message = 'Cannot initiate register while in state %d, ' \ 'state needs to be ENABLED.' % state error = pm_errors.MMCoreError( pm_errors.MMCoreError.WRONG_STATE, message) if self._raise_cb: self._raise_cb(error) else: raise error logging.info('Starting Register.') self._modem.register_step = self return True
def ActivateBearer(self, bearer_path): """ Activates a data bearer by setting its 'Connected' property to True. This request may fail if the modem does not support additional active bearers, if too many bearers are already active, if the requested bearer doesn't exist, or if the requested bearer is already active. @param bearer_path: DBus path of the bearer to activate. """ logging.info('ActivateBearer: %s', bearer_path) bearer = self.bearers.get(bearer_path, None) if bearer is None: message = 'Could not find bearer with path "%s"' % bearer_path logging.info(message) raise pm_errors.MMCoreError(pm_errors.MMCoreError.NOT_FOUND, message) max_active_bearers = self.Get(mm1_constants.I_MODEM, 'MaxActiveBearers') if len(self.active_bearers) >= max_active_bearers: message = ('Cannot activate bearer: maximum active bearer count ' 'reached.') logging.info(message) raise pm_errors.MMCoreError(pm_errors.MMCoreError.TOO_MANY, message) if bearer.IsActive(): message = 'Bearer with path "%s" already active.', bearer_path logging.info(message) raise pm_errors.MMCoreError(pm_errors.MMCoreError.CONNECTED, message) self.active_bearers[bearer_path] = bearer bearer.Connect()
def _ShouldStartStateMachine(self): if self._modem.disable_step and self._modem.disable_step != self: # There is already a disable operation in progress. message = 'Modem disable already in progress.' logging.info(message) raise pm_errors.MMCoreError(pm_errors.MMCoreError.IN_PROGRESS, message) elif self._modem.disable_step is None: # There is no disable operation going in, cancelled or otherwise. state = self._modem.Get(mm1_constants.I_MODEM, 'State') if state == mm1_constants.MM_MODEM_STATE_DISABLED: # The reason we're not raising an error here is that # shill will make multiple successive calls to disable # but WON'T check for raised errors, which causes # problems. Treat this particular case as success. logging.info('Already in a disabled state. Ignoring.') if self.return_cb: self.return_cb() return False invalid_states = [ mm1_constants.MM_MODEM_STATE_FAILED, mm1_constants.MM_MODEM_STATE_UNKNOWN, mm1_constants.MM_MODEM_STATE_INITIALIZING, mm1_constants.MM_MODEM_STATE_LOCKED ] if state in invalid_states: raise pm_errors.MMCoreError( pm_errors.MMCoreError.WRONG_STATE, ('Modem disable cannot be initiated while in state' ' %u.') % state) if self._modem.connect_step: logging.info('There is an ongoing Connect, canceling it.') self._modem.connect_step.Cancel() if self._modem.register_step: logging.info('There is an ongoing Register, canceling it.') self._modem.register_step.Cancel() if self._modem.enable_step: # This needs to be done here, because the case where an enable # cycle has been initiated but it hasn't triggered any state # transitions yet would not be detected in a state handler. logging.info('There is an ongoing Enable, canceling it.') logging.info('This should bring the modem to a disabled state.' ' DisableMachine will not start.') self._modem.enable_step.Cancel() assert self._modem.Get(mm1_constants.I_MODEM, 'State') == \ mm1_constants.MM_MODEM_STATE_DISABLED if self._modem.Get(mm1_constants.I_MODEM, 'State') == \ mm1_constants.MM_MODEM_STATE_DISABLED: if self.return_cb: self.return_cb() return False logging.info('Starting Disable.') self._modem.disable_step = self return True
def _ShouldStartStateMachine(self): if (self._modem.disconnect_step and # There is already a disconnect operation in progress. self._modem.disconnect_step != self): message = 'There is already an ongoing disconnect operation.' logging.error(message) self.raise_cb( pm_errors.MMCoreError(pm_errors.MMCoreError.IN_PROGRESS, message)) return False elif self._modem.disconnect_step is None: # There is no disconnect operation going on, canceled or otherwise. state = self._modem.Get(mm1_constants.I_MODEM, 'State') if state != mm1_constants.MM_MODEM_STATE_CONNECTED: message = 'Modem cannot be disconnected when not connected.' logging.error(message) self.raise_cb( pm_errors.MMCoreError(pm_errors.MMCoreError.WRONG_STATE, message)) return False if self.bearer_path == mm1_constants.ROOT_PATH: logging.info('All bearers will be disconnected.') elif not (self.bearer_path in self._modem.bearers): message = ('Bearer with path "%s" not found' % self.bearer_path) logging.error(message) self.raise_cb( pm_errors.MMCoreError(pm_errors.MMCoreError.NOT_FOUND, message)) return False elif not (self.bearer_path in self._modem.active_bearers): message = ('No active bearer with path ' + self.bearer_path + ' found, current active bearers are ' + str(self._modem.active_bearers)) logging.error(message) self.raise_cb( pm_errors.MMCoreError(pm_errors.MMCoreError.NOT_FOUND, message)) return False assert not self._modem.IsPendingConnect() assert not self._modem.IsPendingEnable() assert not self._modem.IsPendingRegister() logging.info('Starting Disconnect.') self._modem.disconnect_step = self return True
def CreateBearer(self, properties): """ Creates a new packet data bearer using the given characteristics. This request may fail if the modem does not support additional bearers, if too many bearers are already defined, or if properties are invalid. @param properties: A dictionary containing the properties to assign to the bearer after creating it. The allowed property values are contained in modem.ALLOWED_PROPERTIES. @returns: On success, the object path of the newly created bearer. """ logging.info('CreateBearer') maxbearers = self.Get(mm1_constants.I_MODEM, 'MaxBearers') if len(self.bearers) == maxbearers: raise pm_errors.MMCoreError( pm_errors.MMCoreError.TOO_MANY, ('Maximum number of bearers reached. Cannot create new ' 'bearer.')) else: self.ValidateBearerProperties(properties) bearer_obj = bearer.Bearer(self.bus, properties) logging.info('Created bearer with path "%s".', bearer_obj.path) self.bearers[bearer_obj.path] = bearer_obj self._UpdateBearersProperty() return bearer_obj.path
def SendPuk(self, puk, pin): """ Sends the PUK and a new PIN to unlock the SIM card. @param puk: A string containing the PUK code. @param pin: A string containing the PIN code. """ if self._lock_type != mm1_constants.MM_MODEM_LOCK_SIM_PUK: logging.info('No PUK lock in place. Nothing to do.') return lock_data = self._lock_data.get(self._lock_type, None) if not lock_data: raise pm_errors.MMCoreError( pm_errors.MMCoreError.FAILED, 'Current lock type does not match the SIM locks in place.') if lock_data['retries'] == 0: raise SimFailureError() self._CheckCode(puk, lock_data, None, SimFailureError()) logging.info('Entered correct PUK.') self._ResetRetries(mm1_constants.MM_MODEM_LOCK_SIM_PIN) self._ResetRetries(mm1_constants.MM_MODEM_LOCK_SIM_PUK) self._lock_data[mm1_constants.MM_MODEM_LOCK_SIM_PIN]['code'] = pin self._lock_type = mm1_constants.MM_MODEM_LOCK_NONE self._modem.UpdateLockStatus() self._modem.Expose3GPPProperties() self._UpdateProperties()
def SyncScan(self): """ The synchronous implementation of |Scan| for this class. """ state = self.Get(mm1_constants.I_MODEM, 'State') if state < mm1_constants.MM_MODEM_STATE_ENABLED: raise pm_errors.MMCoreError( pm_errors.MMCoreError.WRONG_STATE, 'Modem not enabled, cannot scan for networks.') sim_path = self.Get(mm1_constants.I_MODEM, 'Sim') if not self.sim: assert sim_path == mm1_constants.ROOT_PATH raise pm_errors.MMMobileEquipmentError( pm_errors.MMMobileEquipmentError.SIM_NOT_INSERTED, 'Cannot scan for networks because no SIM is inserted.') assert sim_path != mm1_constants.ROOT_PATH # TODO(armansito): check here for SIM lock? scanned = [network.ToScanDictionary() for network in self.roaming_networks] # get home network sim_props = self.sim.GetAll(mm1_constants.I_SIM) scanned.append({ 'status': dbus.types.UInt32( mm1_constants.MM_MODEM_3GPP_NETWORK_AVAILABILITY_AVAILABLE), 'operator-long': sim_props['OperatorName'], 'operator-short': sim_props['OperatorName'], 'operator-code': sim_props['OperatorIdentifier'], 'access-technology': dbus.types.UInt32(self.sim.access_technology) }) self._scanned_networks = ( {network['operator-code']: network for network in scanned}) return scanned
def SendPin(self, pin): """ Sends the PIN to unlock the SIM card. @param pin: A string containing the PIN code. """ if not self.locked: logging.info('SIM is not locked. Nothing to do.') return if self._lock_type == mm1_constants.MM_MODEM_LOCK_SIM_PUK: if self._lock_data[self._lock_type]['retries'] == 0: raise SimFailureError() else: raise SimPukError() lock_data = self._lock_data.get(self._lock_type, None) if not lock_data: raise pm_errors.MMCoreError( pm_errors.MMCoreError.FAILED, 'Current lock type does not match the SIM lock capabilities.') self._CheckCode(pin, lock_data, mm1_constants.MM_MODEM_LOCK_SIM_PUK, SimPukError()) logging.info('Entered correct PIN.') self._ResetRetries(mm1_constants.MM_MODEM_LOCK_SIM_PIN) self._lock_type = mm1_constants.MM_MODEM_LOCK_NONE self._modem.UpdateLockStatus() self._modem.Expose3GPPProperties() self._UpdateProperties()
def Register(self, operator_id, return_cb=None, raise_cb=None): """ Request registration with a given modem network. @param operator_id: The operator ID to register. An empty string can be used to register to the home network. @param return_cb: Async success callback. @param raise_cb: Async error callback. """ logging.info('Modem3gpp.Register: %s', operator_id) # Check if we're already registered with the given network. if (self.Get(mm1_constants.I_MODEM_3GPP, 'OperatorCode') == operator_id or ((not operator_id and self.Get(mm1_constants.I_MODEM, 'State') >= mm1_constants.MM_MODEM_STATE_REGISTERED))): message = 'Already registered.' logging.info(message) raise pm_errors.MMCoreError(pm_errors.MMCoreError.FAILED, message) if (self.Get(mm1_constants.I_MODEM, 'State') < mm1_constants.MM_MODEM_STATE_ENABLED): message = 'Cannot register the modem if not enabled.' logging.info(message) raise pm_errors.MMCoreError(pm_errors.MMCoreError.FAILED, message) self.CancelAllStateMachines() def _Reregister(): if (self.Get(mm1_constants.I_MODEM, 'State') == mm1_constants.MM_MODEM_STATE_REGISTERED): self.UnregisterWithNetwork() self.RegisterWithNetwork(operator_id, return_cb, raise_cb) if (self.Get(mm1_constants.I_MODEM, 'State') == mm1_constants.MM_MODEM_STATE_CONNECTED): self.Disconnect(mm1_constants.ROOT_PATH, _Reregister, raise_cb) else: _Reregister()
def _ShouldStartStateMachine(self): if self._modem.connect_step and self._modem.connect_step != self: # There is already a connect operation in progress. message = 'There is already an ongoing connect operation.' logging.error(message) self.raise_cb( pm_errors.MMCoreError(pm_errors.MMCoreError.IN_PROGRESS, message)) return False elif self._modem.connect_step is None: # There is no connect operation going on, cancelled or otherwise. if self._modem.IsPendingDisable(): message = 'Modem is currently being disabled. Ignoring ' \ 'connect.' logging.error(message) self.raise_cb( pm_errors.MMCoreError(pm_errors.MMCoreError.WRONG_STATE, message)) return False state = self._modem.Get(mm1_constants.I_MODEM, 'State') if state == mm1_constants.MM_MODEM_STATE_CONNECTED: message = 'Modem is already connected.' logging.error(message) self.raise_cb( pm_errors.MMCoreError(pm_errors.MMCoreError.CONNECTED, message)) return False if state == mm1_constants.MM_MODEM_STATE_DISCONNECTING: assert self._modem.IsPendingDisconnect() message = 'Cannot connect while disconnecting.' logging.error(message) self.raise_cb( pm_errors.MMCoreError(pm_errors.MMCoreError.WRONG_STATE, message)) return False logging.info('Starting Connect.') self._modem.connect_step = self return True
def Cancel(self): """ Overriden from superclass. """ logging.info('EnableMachine: Canceling enable.') super(EnableMachine, self).Cancel() state = self._modem.Get(mm1_constants.I_MODEM, 'State') reason = mm1_constants.MM_MODEM_STATE_CHANGE_REASON_USER_REQUESTED if state == mm1_constants.MM_MODEM_STATE_ENABLING: logging.info('EnableMachine: Setting state to DISABLED.') self._modem.ChangeState(mm1_constants.MM_MODEM_STATE_DISABLED, reason) self._modem.enable_step = None if self.raise_cb: self.raise_cb( pm_errors.MMCoreError(pm_errors.MMCoreError.CANCELLED, 'Operation cancelled'))
def ValidateBearerProperties(self, properties): """ The default implementation makes sure that all keys in properties are one of the allowed bearer properties. Subclasses can override this method to provide CDMA/3GPP specific checks. @param properties: The dictionary of properties and values to validate. @raises: MMCoreError, if one or more properties are invalid. """ for key in properties.iterkeys(): if key not in ALLOWED_BEARER_PROPERTIES: raise pm_errors.MMCoreError( pm_errors.MMCoreError.INVALID_ARGS, 'Invalid property "%s", not creating bearer.' % key)
def DeactivateBearer(self, bearer_path): """ Deactivates data bearer by setting its 'Connected' property to False. This request may fail if the modem with the requested path doesn't exist, or if the bearer is not active. @param bearer_path: DBus path of the bearer to activate. """ logging.info('DeactivateBearer: %s', bearer_path) bearer = self.bearers.get(bearer_path, None) if bearer is None: raise pm_errors.MMCoreError( pm_errors.MMCoreError.NOT_FOUND, 'Could not find bearer with path "%s".' % bearer_path) if not bearer.IsActive(): assert bearer_path not in self.active_bearers raise pm_errors.MMCoreError( pm_errors.MMCoreError.WRONG_STATE, 'Bearer with path "%s" is not active.' % bearer_path) assert bearer_path in self.active_bearers bearer.Disconnect() self.active_bearers.pop(bearer_path)
def SetPowerState(self, power_state): """ Sets the power state of the modem. This action can only be run when the modem is in the MM_MODEM_STATE_DISABLED state. @param power_state: Specifies the desired power state as a MMModemPowerState value. @raises: MMCoreError if state is not DISABLED. """ if (self.Get(mm1_constants.I_MODEM, 'State') != mm1_constants.MM_MODEM_STATE_DISABLED): raise pm_errors.MMCoreError( pm_errors.MMCoreError.WRONG_STATE, 'Cannot set the power state if modem is not DISABLED.') self.SetUInt32(mm1_constants.I_MODEM, 'PowerState', power_state)
def SetCurrentCapabilities(self, capabilities): """ Set the capabilities of the device. A restart of the modem may be required. @param capabilities: Bitmask of MMModemCapability values, to specify the capabilities to use. """ supported = self.Get(mm1_constants.I_MODEM, 'SupportedCapabilities') if not capabilities in supported: raise pm_errors.MMCoreError( pm_errors.MMCoreError.FAILED, 'Given capabilities not supported: ' + capabilities) self.SetUInt32(mm1_constants.I_MODEM, 'CurrentCapabilities', capabilities)
def SetCurrentModes(self, modes): """ Sets the access technologies (eg 2G/3G/4G preference) the device is currently allowed to use when connecting to a network. @param modes: Specifies all the modes allowed in the modem as a bitmask of MMModemModem values. @param preferred: Specific MMModemMode preferred among the ones allowed, if any. """ allowed = self.Get(mm1_constants.I_MODEM, 'SupportedModes') if not modes in allowed: raise pm_errors.MMCoreError(pm_errors.MMCoreError.FAILED, 'Mode not supported: ' + repr(modes)) self.Set(mm1_constants.I_MODEM, 'CurrentModes', modes)
def _HandleSearchingState(self): logging.info('RegisterMachine: Modem is SEARCHING.') if not self._networks: logging.info('RegisterMachine: Scan returned no networks.') logging.info('RegisterMachine: Setting state to ENABLED.') self._modem.ChangeState( mm1_constants.MM_MODEM_STATE_ENABLED, mm1_constants.MM_MODEM_STATE_CHANGE_REASON_UNKNOWN) # TODO(armansito): Figure out the correct registration # state to transition to when no network is present. logging.info('RegisterMachine: Setting registration state ' 'to IDLE.') self._modem.SetRegistrationState( mm1_constants.MM_MODEM_3GPP_REGISTRATION_STATE_IDLE) self._modem.register_step = None if self._raise_cb: self._raise_cb( pm_errors.MMMobileEquipmentError( pm_errors.MMMobileEquipmentError.NO_NETWORK, 'No networks were found to register.')) return False # Pick the last network in the list. Roaming networks will come before # the home network which makes the last item in the list the home # network. if self._operator_code: if not self._operator_code in self._modem.scanned_networks: if self._raise_cb: self._raise_cb( pm_errors.MMCoreError( pm_errors.MMCoreError.FAILED, "Unknown network: " + self._operator_code)) return False network = self._modem.scanned_networks[self._operator_code] else: network = self._networks[-1] logging.info('RegisterMachine: Registering to network: ' + str(network)) self._modem.SetRegistered(network['operator-code'], network['operator-long']) # The previous call should have set the state to REGISTERED. self._modem.register_step = None if self._return_cb: self._return_cb() return False
def Cancel(self): """ Overriden from superclass. """ logging.info('RegisterMachine: Canceling register.') super(RegisterMachine, self).Cancel() state = self._modem.Get(mm1_constants.I_MODEM, 'State') reason = mm1_constants.MM_MODEM_STATE_CHANGE_REASON_USER_REQUESTED if state == mm1_constants.MM_MODEM_STATE_SEARCHING: logging.info('RegisterMachine: Setting state to ENABLED.') self._modem.ChangeState(mm1_constants.MM_MODEM_STATE_ENABLED, reason) self._modem.SetRegistrationState( mm1_constants.MM_MODEM_3GPP_REGISTRATION_STATE_IDLE) self._modem.register_step = None if self._raise_cb: self._raise_cb( pm_errors.MMCoreError(pm_errors.MMCoreError.CANCELLED, 'Cancelled'))
def _HandleDisabledState(self): logging.info('ConnectMachine: Modem is DISABLED.') assert not self._modem.IsPendingEnable() if self.enable_initiated: message = 'ConnectMachine: Failed to enable modem.' logging.error(message) self.Cancel() self._modem.connect_step = None self.raise_cb( pm_errors.MMCoreError(pm_errors.MMCoreError.FAILED, message)) return False else: logging.info('ConnectMachine: Initiating Enable.') self.enable_initiated = True self._modem.Enable(True) # state machine will spin until modem gets enabled, # or if enable fails return True
def _HandleEnabledState(self): logging.info('ConnectMachine: Modem is ENABLED.') # Check to see if a register is going on, if not, # start register if self.register_initiated: message = 'ConnectMachine: Failed to register.' logging.error(message) self.Cancel() self._modem.connect_step = None self.raise_cb( pm_errors.MMCoreError(pm_errors.MMCoreError.FAILED, message)) return False else: logging.info('ConnectMachine: Waiting for Register.') if not self._modem.IsPendingRegister(): self._modem.RegisterWithNetwork("", self._return_cb, self._raise_cb) self.register_initiated = True return True
def Cancel(self, message='Activation canceled.'): """ Cancel the CdmaActivateMachine. """ logging.info('CdmaActivateMachine: Canceling activate.') super(CdmaActivateMachine, self).Cancel() state = self._modem.Get(mm1_constants.I_MODEM_CDMA, 'ActivationState') # If activated, return success. if state == mm1_constants.MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED: logging.info('CdmaActivateMachine: Already activated. ' 'Returning success.') if self._return_cb: self._return_cb() return self._modem.ChangeActivationState( mm1_constants.MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED, pm_errors.MMCdmaActivationError.UNKNOWN) self._modem.cdma_activate_step = None if self._raise_cb: self._raise_cb( pm_errors.MMCoreError(pm_errors.MMCoreError.CANCELLED, message))
def _HandleRegisteredState(self): logging.info('ConnectCdmaMachine: Modem is REGISTERED.') assert not self._modem.IsPendingDisconnect() assert not self._modem.IsPendingEnable() assert not self._modem.IsPendingDisable() assert not self._modem.IsPendingRegister() # Check here that the network is activated. The UI should prevent # connecting to an unactivated service, but for tests, we want to be # sure that connect fails. network = self._modem.GetHomeNetwork() if not network.activated: logging.info('ConnectCdmaMachine: Service is not activated. Cannot' ' connect.') self.raise_cb( pm_errors.MMCoreError(pm_errors.MMCoreError.FAILED, 'Service not activated.')) return False logging.info('ConnectCdmaMachine: Setting state to CONNECTING.') reason = mm1_constants.MM_MODEM_STATE_CHANGE_REASON_USER_REQUESTED self._modem.ChangeState(mm1_constants.MM_MODEM_STATE_CONNECTING, reason) return True
def Reset(self): """ Clears non-persistent configuration and state, and returns the device to a newly-powered-on state. As a result of this operation, the modem will be removed from its current path and will be exposed on an incremented path. It will be enabled afterwards. """ logging.info('Resetting modem.') if self.resetting: raise pm_errors.MMCoreError(pm_errors.MMCoreError.IN_PROGRESS, 'Reset already in progress.') self.resetting = True self.CancelAllStateMachines() def _ResetFunc(): # Disappear. manager = self.manager if manager: manager.Remove(self) if self.sim: manager.Remove(self.sim) self.ClearBearers() # Reappear. def _DelayedReappear(): self.IncrementPath() # Reset to defaults. if self.sim: self.sim.Reset() self._properties = self._InitializeProperties() if self.sim: self.Set(mm1_constants.I_MODEM, 'Sim', dbus.types.ObjectPath(self.sim.path)) self.UpdateLockStatus() if manager: manager.Add(self) self.resetting = False def _DelayedEnable(): state = self.Get(mm1_constants.I_MODEM, 'State') if not self.IsPendingEnable() and \ state == mm1_constants.MM_MODEM_STATE_DISABLED: self.Enable(True) return False gobject.timeout_add(1000, _DelayedEnable) return False gobject.timeout_add(2000, _DelayedReappear) def _ErrorCallback(error): raise error if (self.Get(mm1_constants.I_MODEM, 'State') == mm1_constants.MM_MODEM_STATE_CONNECTED): self.Disconnect('/', _ResetFunc, _ErrorCallback) else: gobject.idle_add(_ResetFunc)