| # Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import connect_machine |
| import dbus |
| import dbus.types |
| import disconnect_machine |
| import gobject |
| import logging |
| import mm1 |
| import modem |
| import pseudomodem |
| import register_machine |
| |
| class Modem3gpp(modem.Modem): |
| """ |
| Pseudomodem implementation of the |
| org.freedesktop.ModemManager1.Modem.Modem3gpp and |
| org.freedesktop.ModemManager1.Modem.Simple interfaces. This class provides |
| access to specific actions that may be performed in modems with 3GPP |
| capabilities. |
| |
| """ |
| |
| class GsmNetwork(object): |
| def __init__(self, |
| operator_long, |
| operator_short, |
| operator_code, |
| status, |
| access_technology): |
| self.status = status |
| self.operator_long = operator_long |
| self.operator_short = operator_short |
| self.operator_code = operator_code |
| self.access_technology = access_technology |
| |
| def _InitializeProperties(self): |
| ip = modem.Modem._InitializeProperties(self) |
| ip[mm1.I_MODEM_3GPP] = { |
| 'Imei' : '00112342342', |
| 'RegistrationState' : ( |
| dbus.types.UInt32(mm1.MM_MODEM_3GPP_REGISTRATION_STATE_IDLE)), |
| 'OperatorCode' : '', |
| 'OperatorName' : '', |
| 'EnabledFacilityLocks' : ( |
| dbus.types.UInt32(mm1.MM_MODEM_3GPP_FACILITY_NONE)) |
| } |
| |
| props = ip[mm1.I_MODEM] |
| props['ModemCapabilities'] = dbus.types.UInt32( |
| mm1.MM_MODEM_CAPABILITY_GSM_UMTS | mm1.MM_MODEM_CAPABILITY_LTE) |
| props['CurrentCapabilities'] = dbus.types.UInt32( |
| mm1.MM_MODEM_CAPABILITY_GSM_UMTS | mm1.MM_MODEM_CAPABILITY_LTE) |
| props['MaxBearers'] = dbus.types.UInt32(3) |
| props['MaxActiveBearers'] = dbus.types.UInt32(2) |
| props['EquipmentIdentifier'] = ip[mm1.I_MODEM_3GPP]['Imei'] |
| props['AccessTechnologies'] = dbus.types.UInt32(( |
| mm1.MM_MODEM_ACCESS_TECHNOLOGY_GSM | |
| mm1.MM_MODEM_ACCESS_TECHNOLOGY_UMTS)) |
| props['SupportedModes'] = dbus.types.UInt32(mm1.MM_MODEM_MODE_ANY) |
| props['AllowedModes'] = props['SupportedModes'] |
| props['PreferredMode'] = dbus.types.UInt32(mm1.MM_MODEM_MODE_NONE) |
| props['SupportedBands'] = [ |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_EGSM), |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_DCS), |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_PCS), |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_G850), |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_U2100), |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_U1800), |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_U17IV), |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_U800), |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_U850) |
| ] |
| props['Bands'] = [ |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_EGSM), |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_DCS), |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_PCS), |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_G850), |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_U2100), |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_U800), |
| dbus.types.UInt32(mm1.MM_MODEM_BAND_U850) |
| ] |
| return ip |
| |
| def SetRegistrationState(self, state): |
| self.SetUInt32( |
| mm1.I_MODEM_3GPP, 'RegistrationState', dbus.types.UInt32(state)) |
| |
| @dbus.service.method(mm1.I_MODEM_3GPP, in_signature='s') |
| def Register(self, operator_id, *args): |
| """ |
| Request registration with a given modem network. |
| |
| Args: |
| operator_id -- The operator ID to register. An empty string can be |
| used to register to the home network. |
| *args -- Args can optionally contain an operator name. |
| |
| """ |
| logging.info('Modem3gpp.Register: %s', operator_id) |
| if operator_id: |
| assert self.sim |
| assert self.Get(mm1.I_MODEM, 'Sim') != mm1.ROOT_PATH |
| if operator_id == self.sim.Get(mm1.I_SIM, 'OperatorIdentifier'): |
| state = mm1.MM_MODEM_3GPP_REGISTRATION_STATE_HOME |
| else: |
| state = mm1.MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING |
| else: |
| state = mm1.MM_MODEM_3GPP_REGISTRATION_STATE_HOME |
| |
| logging.info('Modem3gpp.Register: Setting registration state to %s.', |
| mm1.RegistrationStateToString(state)) |
| self.SetRegistrationState(state) |
| logging.info('Modem3gpp.Register: Setting state to REGISTERED.') |
| self.ChangeState(mm1.MM_MODEM_STATE_REGISTERED, |
| mm1.MM_MODEM_STATE_CHANGE_REASON_USER_REQUESTED) |
| self.Set(mm1.I_MODEM_3GPP, 'OperatorCode', operator_id) |
| if args: |
| self.Set(mm1.I_MODEM_3GPP, 'OperatorName', args[0]) |
| |
| @dbus.service.method(mm1.I_MODEM_3GPP, out_signature='aa{sv}') |
| def Scan(self): |
| """ |
| Scan for available networks. |
| |
| Returns: |
| An array of dictionaries with each array element describing a |
| mobile network found in the scan. See the ModemManager reference |
| manual for the list of keys that may be included in the returned |
| dictionary. |
| |
| """ |
| state = self.Get(mm1.I_MODEM, 'State') |
| if state < mm1.MM_MODEM_STATE_ENABLED: |
| raise mm1.MMCoreError(mm1.MMCoreError.WRONG_STATE, |
| 'Modem not enabled, cannot scan for networks.') |
| |
| sim_path = self.Get(mm1.I_MODEM, 'Sim') |
| if not self.sim: |
| assert sim_path == mm1.ROOT_PATH |
| raise mm1.MMMobileEquipmentError( |
| mm1.MMMobileEquipmentError.SIM_NOT_INSERTED, |
| 'Cannot scan for networks because no SIM is inserted.') |
| assert sim_path != mm1.ROOT_PATH |
| |
| # TODO(armansito): check here for SIM lock? |
| |
| scanned = [network.__dict__ for network in self.roaming_networks] |
| |
| # get home network |
| sim_props = self.sim.GetAll(mm1.I_SIM) |
| scanned.append({ |
| 'status': mm1.MM_MODEM_3GPP_NETWORK_AVAILABILITY_AVAILABLE, |
| 'operator-long': sim_props['OperatorName'], |
| 'operator-short': sim_props['OperatorName'], |
| 'operator-code': sim_props['OperatorIdentifier'], |
| 'access-technology': self.sim.access_technology |
| }) |
| return scanned |
| |
| def RegisterWithNetwork(self): |
| register_machine.RegisterMachine(self).Step() |
| |
| def UnregisterWithNetwork(self): |
| logging.info('Modem3gpp.UnregisterWithHomeNetwork') |
| logging.info('Setting registration state to IDLE.') |
| self.SetRegistrationState(mm1.MM_MODEM_3GPP_REGISTRATION_STATE_IDLE) |
| logging.info('Setting state to ENABLED.') |
| self.ChangeState(mm1.MM_MODEM_STATE_ENABLED, |
| mm1.MM_MODEM_STATE_CHANGE_REASON_USER_REQUESTED) |
| self.Set(mm1.I_MODEM_3GPP, 'OperatorName', '') |
| self.Set(mm1.I_MODEM_3GPP, 'OperatorCode', '') |
| |
| def Connect(self, properties, return_cb, raise_cb): |
| logging.info('Connect') |
| connect_machine.ConnectMachine( |
| self, properties, return_cb, raise_cb).Step() |
| |
| def Disconnect(self, bearer_path, return_cb, raise_cb, *return_cb_args): |
| logging.info('Disconnect: %s' % bearer_path) |
| disconnect_machine.DisconnectMachine( |
| self, bearer_path, return_cb, raise_cb, return_cb_args).Step() |
| |
| def GetStatus(self): |
| modem_props = self.GetAll(mm1.I_MODEM) |
| m3gpp_props = self.GetAll(mm1.I_MODEM_3GPP) |
| retval = {} |
| retval['state'] = modem_props['State'] |
| if retval['state'] == mm1.MM_MODEM_STATE_REGISTERED: |
| retval['signal-quality'] = modem_props['SignalQuality'][0] |
| retval['bands'] = modem_props['Bands'] |
| retval['access-technology'] = self.sim.access_technology |
| retval['m3gpp-registration-state'] = \ |
| m3gpp_props['RegistrationState'] |
| retval['m3gpp-operator-code'] = m3gpp_props['OperatorCode'] |
| retval['m3gpp-operator-name'] = m3gpp_props['OperatorName'] |
| return retval |
| # TODO(armansito): implement |
| # org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd, if needed |
| # (in a separate class?) |
