Source code for dbusmock.templates.modemmanager

"""ModemManager mock template

This creates the expected methods and properties of the main
ModemManager object, but no devices. You can specify any property
such as DaemonVersion in "parameters".
"""

# SPDX-License-Identifier: LGPL-3.0-or-later



__author__ = "Guido Günther"



__copyright__ = "2024 The Phosh Developers"


import dbus

from dbusmock import MOCK_IFACE, OBJECT_MANAGER_IFACE, mockobject



BUS_NAME = "org.freedesktop.ModemManager1"



MAIN_OBJ = "/org/freedesktop/ModemManager1"



MAIN_IFACE = "org.freedesktop.ModemManager1"



SYSTEM_BUS = True



IS_OBJECT_MANAGER = False



MODEM_IFACE = "org.freedesktop.ModemManager1.Modem"



MODEM_3GPP_IFACE = "org.freedesktop.ModemManager1.Modem.Modem3gpp"



MODEM_CELL_BROADCAST_IFACE = "org.freedesktop.ModemManager1.Modem.CellBroadcast"



MODEM_VOICE_IFACE = "org.freedesktop.ModemManager1.Modem.Voice"



SIM_IFACE = "org.freedesktop.ModemManager1.Sim"



CBM_IFACE = "org.freedesktop.ModemManager1.Cbm"



SIMPLE_MODEM_PATH = "/org/freedesktop/ModemManager1/Modems/8"





class MMModemMode:
    """
    See
    https://www.freedesktop.org/software/ModemManager/doc/latest/ModemManager/ModemManager-Flags-and-Enumerations.html#MMModemMode
    """



    MODE_NONE = 0



    MODE_CS = 1 << 0



    MODE_2G = 1 << 1



    MODE_3G = 1 << 2



    MODE_4G = 1 << 3



    MODE_5G = 1 << 4






class MMModemState:
    """
    See
    https://www.freedesktop.org/software/ModemManager/doc/latest/ModemManager/ModemManager-Flags-and-Enumerations.html#MMModemState
    """



    STATE_FAILED = -1



    STATE_UNKNOWN = 0



    STATE_INITIALIZING = 1



    STATE_LOCKED = 2



    STATE_DISABLED = 3



    STATE_DISABLING = 4



    STATE_ENABLING = 5



    STATE_ENABLED = 6



    STATE_SEARCHING = 7



    STATE_REGISTERED = 8



    STATE_DISCONNECTING = 9



    STATE_CONNECTING = 10



    STATE_CONNECTED = 11






class MMModemPowerState:
    """
    See
    https://www.freedesktop.org/software/ModemManager/doc/latest/ModemManager/ModemManager-Flags-and-Enumerations.html#MMModemPowerState
    """



    POWER_STATE_UNKNOWN = 0



    POWER_STATE_OFF = 1



    POWER_STATE_LOW = 2



    POWER_STATE_ON = 3






class MMModemAccesssTechnology:
    """
    See
    https://www.freedesktop.org/software/ModemManager/doc/latest/ModemManager/ModemManager-Flags-and-Enumerations.html#MMModemAccessTechnology
    """



    ACCESS_TECHNOLOGY_UNKNOWN = 0



    ACCESS_TECHNOLOGY_POTS = 1 << 0



    ACCESS_TECHNOLOGY_GSM = 1 << 1



    ACCESS_TECHNOLOGY_GSM_COMPACT = 1 << 2



    ACCESS_TECHNOLOGY_GPRS = 1 << 3



    ACCESS_TECHNOLOGY_EDGE = 1 << 4



    ACCESS_TECHNOLOGY_UMTS = 1 << 5



    ACCESS_TECHNOLOGY_HSDPA = 1 << 6



    ACCESS_TECHNOLOGY_HSUPA = 1 << 7



    ACCESS_TECHNOLOGY_HSPA = 1 << 8



    ACCESS_TECHNOLOGY_HSPA_PLUS = 1 << 9



    ACCESS_TECHNOLOGY_1XRTT = 1 << 10



    ACCESS_TECHNOLOGY_EVDO0 = 1 << 11



    ACCESS_TECHNOLOGY_EVDOA = 1 << 12



    ACCESS_TECHNOLOGY_EVDOB = 1 << 13



    ACCESS_TECHNOLOGY_LTE = 1 << 14



    ACCESS_TECHNOLOGY_5GNR = 1 << 15



    ACCESS_TECHNOLOGY_LTE_CAT_M = 1 << 16



    ACCESS_TECHNOLOGY_LTE_NB_IOT = 1 << 17






def load(mock, parameters):
    methods = [
        ("ScanDevices", "", "", ""),
    ]

    props = dbus.Dictionary(
        {
            "Version": parameters.get("DaemonVersion", "1.22"),
        },
        signature="sv",
    )

    mock.AddMethods(MAIN_IFACE, methods)
    mock.AddProperties(MAIN_IFACE, props)

    cond = "k != '/'" if mock.path == "/" else f"k.startswith('{mock.path}/Modems/')"
    code = f"ret = {{dbus.ObjectPath(k): objects[k].props for k in objects.keys() if {cond} }}"
    mock.AddMethod(OBJECT_MANAGER_IFACE, "GetManagedObjects", "", "a{oa{sa{sv}}}", code)





def listCbm(_):
    paths = []
    for path in mockobject.objects:
        if path.startswith("/org/freedesktop/ModemManager1/Cbm/"):
            paths.append(dbus.ObjectPath(path))
    return paths





def deleteCbm(self, cbm_path):
    obj = mockobject.objects.get(cbm_path)
    if obj is None:
        return

    modem_obj = mockobject.objects[SIMPLE_MODEM_PATH]
    self.RemoveObject(cbm_path)
    modem_obj.EmitSignal(
        MODEM_CELL_BROADCAST_IFACE,
        "Deleted",
        "o",
        [
            cbm_path,
        ],
    )





def setChannels(_self, channels):
    modem_obj = mockobject.objects[SIMPLE_MODEM_PATH]

    modem_obj.UpdateProperties(
        MODEM_CELL_BROADCAST_IFACE,
        {
            "Channels": dbus.Array(channels),
        },
    )



@dbus.service.method(MOCK_IFACE, in_signature="", out_signature="ss")


def AddSimpleModem(self):
    """Convenience method to add a simple Modem object

    Please note that this does not set any global properties.

    Returns the new object path.
    """
    modem_path = SIMPLE_MODEM_PATH
    sim_path = "/org/freedesktop/ModemManager1/SIM/2"
    manager = mockobject.objects[MAIN_OBJ]

    modem_props = {
        "State": dbus.Int32(MMModemState.STATE_ENABLED),
        "Model": dbus.String("E1750"),
        "Revision": dbus.String("11.126.08.01.00"),
        "AccessTechnologies": dbus.UInt32(MMModemAccesssTechnology.ACCESS_TECHNOLOGY_LTE),
        "PowerState": dbus.UInt32(MMModemPowerState.POWER_STATE_ON),
        "UnlockRequired": dbus.UInt32(0),
        "UnlockRetries": dbus.Dictionary([], signature="uu"),
        "CurrentModes": dbus.Struct(
            (dbus.UInt32(MMModemMode.MODE_4G), dbus.UInt32(MMModemMode.MODE_4G)), signature="(uu)"
        ),
        "SignalQuality": dbus.Struct(
            (dbus.UInt32(70), dbus.Boolean(True)),
        ),
        "Sim": dbus.ObjectPath(sim_path),
        "SupportedModes": [
            (dbus.UInt32(MMModemMode.MODE_4G), dbus.UInt32(MMModemMode.MODE_4G)),
            (dbus.UInt32(MMModemMode.MODE_3G | MMModemMode.MODE_2G), dbus.UInt32(MMModemMode.MODE_3G)),
        ],
        "SupportedBands": [dbus.UInt32(0)],
    }
    self.AddObject(modem_path, MODEM_IFACE, modem_props, [])

    modem_3gpp_props = {
        "Imei": dbus.String("doesnotmatter"),
        "OperatorName": dbus.String("TheOperator"),
        "OperatorCode": dbus.String("00101"),
        "Pco": dbus.Array([], signature="(ubay)"),
    }
    modem = mockobject.objects[modem_path]
    modem.AddProperties(MODEM_3GPP_IFACE, modem_3gpp_props)

    modem_cell_broadcast_props = {
        "Channels": dbus.Array([], signature="(uu)"),
        "CellBroadcasts": dbus.Array([], signature="o"),
    }
    modem_cell_broadcast_methods = [
        ("List", "", "ao", listCbm),
        ("Delete", "o", "", deleteCbm),
        ("SetChannels", "a(uu)", "", setChannels),
    ]
    modem.AddProperties(MODEM_CELL_BROADCAST_IFACE, modem_cell_broadcast_props)
    modem.AddMethods(MODEM_CELL_BROADCAST_IFACE, modem_cell_broadcast_methods)

    modem_voice_props = {
        "Calls": dbus.Array([], signature="o"),
        "EmergencyOnly": False,
    }

    modem.call_waiting = False
    modem_voice_methods = [
        ("CallWaitingQuery", "", "b", "ret = self.call_waiting"),
        ("CallWaitingSetup", "b", "", "self.call_waiting = args[0]"),
    ]
    modem.AddProperties(MODEM_VOICE_IFACE, modem_voice_props)
    modem.AddMethods(MODEM_VOICE_IFACE, modem_voice_methods)

    manager.EmitSignal(
        OBJECT_MANAGER_IFACE,
        "InterfacesAdded",
        "oa{sa{sv}}",
        [
            dbus.ObjectPath(modem_path),
            {
                MODEM_IFACE: modem_props,
                MODEM_3GPP_IFACE: modem_3gpp_props,
                MODEM_CELL_BROADCAST_IFACE: modem_cell_broadcast_props,
                MODEM_VOICE_IFACE: modem_voice_props,
            },
        ],
    )

    sim_props = {
        "Active": dbus.Boolean(True),
        "Imsi": dbus.String("doesnotmatter"),
        "PreferredNetworks": dbus.Array([], signature="(su)"),
    }
    self.AddObject(sim_path, SIM_IFACE, sim_props, [])

    return (modem_path, sim_path)



@dbus.service.method(MOCK_IFACE, in_signature="uus", out_signature="s")


def AddCbm(self, state, channel, text):
    """Convenience method to add a cell broadcast message

    Returns the new object path.
    """
    n = 1
    while mockobject.objects.get(f"/org/freedesktop/ModemManager1/Cbm/{n}") is not None:
        n += 1
    cbm_path = f"/org/freedesktop/ModemManager1/Cbm/{n}"

    cbm_props = {
        "State": dbus.UInt32(state),
        "Channel": dbus.UInt32(channel),
        "Text": dbus.String(text),
        "MessageCode": dbus.UInt32(0),
        "Update": dbus.UInt32(0),
    }
    self.AddObject(cbm_path, CBM_IFACE, cbm_props, [])

    modem_obj = mockobject.objects[SIMPLE_MODEM_PATH]
    paths = listCbm(self)
    modem_obj.UpdateProperties(
        MODEM_CELL_BROADCAST_IFACE,
        {
            "CellBroadcasts": dbus.Array(paths),
        },
    )

    modem_obj.EmitSignal(
        MODEM_CELL_BROADCAST_IFACE,
        "Added",
        "o",
        [
            dbus.ObjectPath(cbm_path),
        ],
    )

    return cbm_path