mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-21 13:55:58 +00:00
Report Android Wi-Fi and cellular connections to Steam
This commit is contained in:
1 parent
ec016f85bc
commit
0816562065
4 files changed
+641
-181
No files matched your search
@@ -0,0 +1,241 @@
|
||||
"""NetworkManager contract and real D-Bus handovers (requires python3-gi and dbus).
|
||||
|
||||
Run on Linux: dbus-run-session -- python3 -m unittest discover -s tools/tests -p test_netmanager.py
|
||||
"""
|
||||
import importlib.machinery
|
||||
import importlib.util
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import unittest
|
||||
|
||||
try:
|
||||
import gi
|
||||
gi.require_version("Gio", "2.0")
|
||||
from gi.repository import Gio, GLib
|
||||
except ImportError:
|
||||
Gio = GLib = None
|
||||
|
||||
SCRIPT = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/bannerlator-netmanager"
|
||||
if Gio:
|
||||
loader = importlib.machinery.SourceFileLoader("netmanager", str(SCRIPT))
|
||||
spec = importlib.util.spec_from_loader(loader.name, loader)
|
||||
nm = importlib.util.module_from_spec(spec)
|
||||
loader.exec_module(nm)
|
||||
|
||||
WIFI = {
|
||||
"connected": True, "transport": "wifi", "interface": "wlan0", "wifiEnabled": True,
|
||||
"validated": True, "captivePortal": False, "metered": False,
|
||||
"ssid": "Test \"Wi-Fi\" ☃", "strength": 73, "frequency": 5180, "bitrate": 866000,
|
||||
"addresses": [{"address": "192.0.2.2", "prefix": 24}, {"address": "2001:db8::2", "prefix": 64}],
|
||||
"gateways": ["192.0.2.1", "2001:db8::1"], "dns": ["192.0.2.1", "2001:db8::1"],
|
||||
}
|
||||
CELLULAR = {
|
||||
"connected": True, "transport": "cellular", "interface": "rmnet_data0", "wifiEnabled": True,
|
||||
"validated": True, "metered": True,
|
||||
"addresses": [{"address": "2001:db8:1::2", "prefix": 64}],
|
||||
"gateways": ["2001:db8:1::1"], "dns": ["2001:db8:1::1"],
|
||||
}
|
||||
OFFLINE = {"connected": False, "transport": "none", "wifiEnabled": True, "metered": None}
|
||||
|
||||
|
||||
@unittest.skipUnless(Gio, "requires PyGObject")
|
||||
class NetworkObjectsTest(unittest.TestCase):
|
||||
def test_wifi_graph(self):
|
||||
found = nm.objects(WIFI)
|
||||
manager = found[nm.ROOT][nm.NAME]
|
||||
device = found[nm.device_path(WIFI)]
|
||||
self.assertEqual(manager["PrimaryConnectionType"].unpack(), "802-11-wireless")
|
||||
self.assertTrue(manager["WirelessEnabled"].unpack())
|
||||
self.assertEqual(device[nm.NAME + ".Device"]["DeviceType"].unpack(), 2)
|
||||
self.assertEqual(device[nm.NAME + ".Device.Wireless"]["ActiveAccessPoint"].unpack(), nm.AP)
|
||||
ap = found[nm.AP][nm.NAME + ".AccessPoint"]
|
||||
self.assertEqual(bytes(ap["Ssid"].unpack()).decode(), WIFI["ssid"])
|
||||
self.assertEqual(ap["Strength"].unpack(), 73)
|
||||
self.assertEqual(manager["Metered"].unpack(), 2)
|
||||
for interfaces in found.values():
|
||||
for values in interfaces.values():
|
||||
for value in values.values():
|
||||
if value.get_type_string() == "o" and value.unpack() != "/":
|
||||
self.assertIn(value.unpack(), found)
|
||||
|
||||
def test_cellular_ipv6_only(self):
|
||||
found = nm.objects(CELLULAR)
|
||||
manager = found[nm.ROOT][nm.NAME]
|
||||
device = found[nm.device_path(CELLULAR)]
|
||||
active = found[nm.ACTIVE][nm.NAME + ".Connection.Active"]
|
||||
self.assertEqual(manager["PrimaryConnectionType"].unpack(), "gsm")
|
||||
self.assertEqual(manager["Metered"].unpack(), 1)
|
||||
self.assertEqual(device[nm.NAME + ".Device"]["DeviceType"].unpack(), 8)
|
||||
self.assertIn(nm.NAME + ".Device.Modem", device)
|
||||
self.assertNotIn(nm.AP, found)
|
||||
self.assertNotIn(nm.IP4, found)
|
||||
self.assertEqual(active["Ip4Config"].unpack(), "/")
|
||||
self.assertEqual(active["Ip6Config"].unpack(), nm.IP6)
|
||||
self.assertTrue(active["Default6"].unpack())
|
||||
self.assertFalse(active["Default"].unpack())
|
||||
self.assertNotEqual(nm.device_path(WIFI), nm.device_path(CELLULAR))
|
||||
|
||||
def test_offline_and_captive_portal(self):
|
||||
offline = nm.objects(OFFLINE)
|
||||
self.assertEqual(offline[nm.ROOT][nm.NAME]["State"].unpack(), 20)
|
||||
self.assertEqual(offline[nm.ROOT][nm.NAME]["ActiveConnections"].unpack(), [])
|
||||
self.assertNotIn(nm.AP, offline)
|
||||
self.assertEqual(nm.connectivity(dict(WIFI, validated=False, captivePortal=True)), 2)
|
||||
self.assertEqual(nm.connectivity(dict(WIFI, validated=False, captivePortal=False)), 3)
|
||||
self.assertEqual(nm.metered(OFFLINE), 0)
|
||||
|
||||
def test_redacted_name_and_wired_vpn(self):
|
||||
redacted = dict(WIFI)
|
||||
del redacted["ssid"]
|
||||
self.assertEqual(nm.connection_name(redacted), "Wi-Fi")
|
||||
self.assertEqual(bytes(nm.settings(redacted)["802-11-wireless"]["ssid"].unpack()), b"Wi-Fi")
|
||||
for transport, kind, device_type in (("ethernet", "802-3-ethernet", 1), ("vpn", "tun", 16)):
|
||||
state = dict(WIFI, transport=transport)
|
||||
found = nm.objects(state)
|
||||
self.assertEqual(found[nm.ROOT][nm.NAME]["PrimaryConnectionType"].unpack(), kind)
|
||||
self.assertEqual(found[nm.device_path(state)][nm.NAME + ".Device"]["DeviceType"].unpack(), device_type)
|
||||
self.assertNotIn(nm.AP, found)
|
||||
|
||||
|
||||
@unittest.skipUnless(Gio and os.environ.get("DBUS_SESSION_BUS_ADDRESS"), "requires dbus-run-session and PyGObject")
|
||||
class NetworkBusTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temp = tempfile.TemporaryDirectory()
|
||||
self.snapshot = Path(self.temp.name) / "network.json"
|
||||
self.write(WIFI)
|
||||
self.bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
|
||||
env = dict(os.environ, DBUS_SYSTEM_BUS_ADDRESS=os.environ["DBUS_SESSION_BUS_ADDRESS"])
|
||||
# Use the production service and only redirect its input file for the fixture.
|
||||
launch = "import runpy,sys; from pathlib import Path; n=runpy.run_path(sys.argv[1]); n['main'].__globals__['SNAPSHOT']=Path(sys.argv[2]); n['main']()"
|
||||
self.process = subprocess.Popen([sys.executable, "-c", launch, str(SCRIPT), str(self.snapshot)], env=env,
|
||||
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
||||
self.await_type("802-11-wireless")
|
||||
|
||||
def tearDown(self):
|
||||
self.process.terminate()
|
||||
_, stderr = self.process.communicate(timeout=5)
|
||||
self.temp.cleanup()
|
||||
self.assertEqual(stderr, b"", stderr.decode())
|
||||
|
||||
def write(self, state):
|
||||
staged = self.snapshot.with_suffix(".staged")
|
||||
staged.write_text(json.dumps(state))
|
||||
staged.replace(self.snapshot)
|
||||
|
||||
def call(self, path, interface, method, parameters=None):
|
||||
return self.bus.call_sync(nm.NAME, path, interface, method, parameters, None,
|
||||
Gio.DBusCallFlags.NONE, 1000, None).unpack()
|
||||
|
||||
def prop(self, path, interface, name):
|
||||
return self.call(path, nm.PROPERTIES, "Get", GLib.Variant("(ss)", (interface, name)))[0]
|
||||
|
||||
def await_type(self, expected):
|
||||
deadline = time.monotonic() + 6
|
||||
while time.monotonic() < deadline:
|
||||
if self.process.poll() is not None:
|
||||
self.fail(self.process.communicate()[1].decode())
|
||||
try:
|
||||
if self.prop(nm.ROOT, nm.NAME, "PrimaryConnectionType") == expected:
|
||||
return
|
||||
except GLib.Error:
|
||||
pass
|
||||
time.sleep(0.05)
|
||||
self.fail("network type did not change to " + expected)
|
||||
|
||||
def test_direct_properties_methods_and_handover(self):
|
||||
signals = []
|
||||
subscription = self.bus.signal_subscribe(
|
||||
nm.NAME, None, None, None, None, Gio.DBusSignalFlags.NONE,
|
||||
lambda bus, sender, path, interface, member, args: signals.append((path, interface, member, args.unpack())))
|
||||
self.addCleanup(self.bus.signal_unsubscribe, subscription)
|
||||
wifi_path = nm.device_path(WIFI)
|
||||
self.assertEqual(self.prop(wifi_path, nm.NAME + ".Device", "DeviceType"), 2)
|
||||
self.assertEqual(self.prop(nm.AP, nm.NAME + ".AccessPoint", "Strength"), 73)
|
||||
self.assertEqual(self.call(wifi_path, nm.NAME + ".Device.Wireless", "GetAccessPoints"), ([nm.AP],))
|
||||
self.assertEqual(self.call(wifi_path, nm.NAME + ".Device.Wireless", "RequestScan", GLib.Variant("(a{sv})", ({},))), ())
|
||||
all_props = self.call(nm.ROOT, nm.PROPERTIES, "GetAll", GLib.Variant("(s)", (nm.NAME,)))[0]
|
||||
self.assertTrue(all_props["WirelessEnabled"])
|
||||
introspection = self.call(wifi_path, "org.freedesktop.DBus.Introspectable", "Introspect")[0]
|
||||
self.assertIn("GetAllAccessPoints", introspection)
|
||||
self.write(dict(WIFI, strength=21, ssid="Other Wi-Fi"))
|
||||
deadline = time.monotonic() + 4
|
||||
while self.prop(nm.AP, nm.NAME + ".AccessPoint", "Strength") != 21 and time.monotonic() < deadline:
|
||||
time.sleep(0.05)
|
||||
self.assertEqual(self.prop(nm.AP, nm.NAME + ".AccessPoint", "Strength"), 21)
|
||||
self.assertEqual(self.call(nm.PROFILE, nm.NAME + ".Settings.Connection", "GetSettings")[0]["connection"]["id"], "Other Wi-Fi")
|
||||
self.write(CELLULAR)
|
||||
self.await_type("gsm")
|
||||
cell_path = nm.device_path(CELLULAR)
|
||||
self.assertEqual(self.call(nm.ROOT, nm.NAME, "GetDevices"), ([cell_path],))
|
||||
self.assertEqual(self.prop(cell_path, nm.NAME + ".Device", "DeviceType"), 8)
|
||||
self.assertEqual(self.prop(nm.ROOT, nm.NAME, "Metered"), 1)
|
||||
managed = self.call(nm.ROOT, nm.OBJECT_MANAGER, "GetManagedObjects")[0]
|
||||
self.assertNotIn(wifi_path, managed)
|
||||
self.assertNotIn(nm.AP, managed)
|
||||
self.assertNotIn(nm.IP4, managed)
|
||||
self.assertIn(nm.IP6, managed)
|
||||
with self.assertRaises(GLib.Error):
|
||||
self.prop(wifi_path, nm.NAME + ".Device", "DeviceType")
|
||||
self.write(OFFLINE)
|
||||
self.await_type("")
|
||||
self.assertEqual(self.call(nm.ROOT, nm.NAME, "CheckConnectivity"), (1,))
|
||||
self.write(WIFI)
|
||||
self.await_type("802-11-wireless")
|
||||
self.assertEqual(self.prop(nm.AP, nm.NAME + ".AccessPoint", "Strength"), 73)
|
||||
context = GLib.MainContext.default()
|
||||
while context.pending():
|
||||
context.iteration(False)
|
||||
self.assertTrue(any(interface == nm.PROPERTIES and member == "PropertiesChanged" and
|
||||
args[1].get("PrimaryConnectionType") == "gsm"
|
||||
for _, interface, member, args in signals))
|
||||
self.assertTrue(any(interface == nm.OBJECT_MANAGER and member == "InterfacesRemoved" and args[0] == wifi_path
|
||||
for _, interface, member, args in signals))
|
||||
self.assertTrue(any(member == "AccessPointAdded" for _, _, member, _ in signals))
|
||||
# A missing/invalid snapshot is a transient input error, never a fake Ethernet handover.
|
||||
self.snapshot.write_text("{")
|
||||
time.sleep(1.2)
|
||||
self.assertEqual(self.prop(nm.ROOT, nm.NAME, "PrimaryConnectionType"), "802-11-wireless")
|
||||
|
||||
def test_libnm_client(self):
|
||||
try:
|
||||
gi.require_version("NM", "1.0")
|
||||
from gi.repository import NM
|
||||
except ValueError:
|
||||
self.skipTest("requires gir1.2-nm-1.0")
|
||||
# libnm is a real consumer of the same API Steam reads. It caches objects by path,
|
||||
# so the handover must replace the Wi-Fi device with a modem rather than mutate its type.
|
||||
previous = os.environ.get("DBUS_SYSTEM_BUS_ADDRESS")
|
||||
os.environ["DBUS_SYSTEM_BUS_ADDRESS"] = os.environ["DBUS_SESSION_BUS_ADDRESS"]
|
||||
try:
|
||||
client = NM.Client.new(None)
|
||||
self.assertTrue(client.get_nm_running())
|
||||
wifi = client.get_devices()[0]
|
||||
self.assertIsInstance(wifi, NM.DeviceWifi)
|
||||
self.assertEqual(wifi.get_active_access_point().get_strength(), 73)
|
||||
self.assertEqual(client.get_primary_connection().get_connection_type(), "802-11-wireless")
|
||||
self.write(CELLULAR)
|
||||
self.await_type("gsm")
|
||||
context = GLib.MainContext.default()
|
||||
deadline = time.monotonic() + 4
|
||||
while time.monotonic() < deadline:
|
||||
while context.pending():
|
||||
context.iteration(False)
|
||||
if client.get_devices() and isinstance(client.get_devices()[0], NM.DeviceModem):
|
||||
break
|
||||
time.sleep(0.05)
|
||||
self.assertIsInstance(client.get_devices()[0], NM.DeviceModem)
|
||||
self.assertEqual(client.get_primary_connection().get_connection_type(), "gsm")
|
||||
finally:
|
||||
if previous is None:
|
||||
os.environ.pop("DBUS_SYSTEM_BUS_ADDRESS", None)
|
||||
else:
|
||||
os.environ["DBUS_SYSTEM_BUS_ADDRESS"] = previous
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user