269 lines
9.7 KiB
Python
Executable File
269 lines
9.7 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""BlueZ GATT transport for the Pi Car Companion Android application."""
|
|
|
|
import json
|
|
import os
|
|
import threading
|
|
import urllib.error
|
|
import urllib.request
|
|
import uuid
|
|
from collections import deque
|
|
|
|
import dbus
|
|
import dbus.exceptions
|
|
import dbus.mainloop.glib
|
|
import dbus.service
|
|
from gi.repository import GLib
|
|
|
|
BLUEZ = "org.bluez"
|
|
DBUS_OM = "org.freedesktop.DBus.ObjectManager"
|
|
DBUS_PROPERTIES = "org.freedesktop.DBus.Properties"
|
|
GATT_MANAGER = "org.bluez.GattManager1"
|
|
GATT_SERVICE = "org.bluez.GattService1"
|
|
GATT_CHARACTERISTIC = "org.bluez.GattCharacteristic1"
|
|
|
|
SERVICE_UUID = "6c7a0001-7c6d-4f74-9bb0-c5a4e5efc001"
|
|
RX_UUID = "6c7a0002-7c6d-4f74-9bb0-c5a4e5efc001"
|
|
TX_UUID = "6c7a0003-7c6d-4f74-9bb0-c5a4e5efc001"
|
|
API_BASE = os.environ.get("MOBILE_API_BASE", "http://127.0.0.1:8787")
|
|
MAX_MESSAGE_BYTES = 64 * 1024
|
|
NOTIFY_CHUNK_BYTES = 180
|
|
|
|
|
|
class InvalidArgs(dbus.exceptions.DBusException):
|
|
_dbus_error_name = "org.freedesktop.DBus.Error.InvalidArgs"
|
|
|
|
|
|
class NotSupported(dbus.exceptions.DBusException):
|
|
_dbus_error_name = "org.bluez.Error.NotSupported"
|
|
|
|
|
|
class Application(dbus.service.Object):
|
|
def __init__(self, bus):
|
|
self.path = "/org/pi_car_companion"
|
|
self.services = []
|
|
super().__init__(bus, self.path)
|
|
|
|
def add_service(self, service):
|
|
self.services.append(service)
|
|
|
|
@dbus.service.method(DBUS_OM, out_signature="a{oa{sa{sv}}}")
|
|
def GetManagedObjects(self):
|
|
objects = {}
|
|
for service in self.services:
|
|
objects[service.path] = service.properties()
|
|
for characteristic in service.characteristics:
|
|
objects[characteristic.path] = characteristic.properties()
|
|
return objects
|
|
|
|
|
|
class Service(dbus.service.Object):
|
|
def __init__(self, bus, index, uuid_value):
|
|
self.path = f"/org/pi_car_companion/service{index}"
|
|
self.uuid = uuid_value
|
|
self.characteristics = []
|
|
super().__init__(bus, self.path)
|
|
|
|
def add_characteristic(self, characteristic):
|
|
self.characteristics.append(characteristic)
|
|
|
|
def properties(self):
|
|
return {GATT_SERVICE: {"UUID": self.uuid, "Primary": dbus.Boolean(True), "Characteristics": dbus.Array([item.path for item in self.characteristics], signature="o")}}
|
|
|
|
@dbus.service.method(DBUS_PROPERTIES, in_signature="s", out_signature="a{sv}")
|
|
def GetAll(self, interface):
|
|
if interface != GATT_SERVICE:
|
|
raise InvalidArgs()
|
|
return self.properties()[GATT_SERVICE]
|
|
|
|
|
|
class Characteristic(dbus.service.Object):
|
|
def __init__(self, bus, index, uuid_value, flags, service):
|
|
self.path = service.path + f"/char{index}"
|
|
self.uuid = uuid_value
|
|
self.flags = flags
|
|
self.service = service
|
|
super().__init__(bus, self.path)
|
|
|
|
def properties(self):
|
|
return {GATT_CHARACTERISTIC: {"Service": dbus.ObjectPath(self.service.path), "UUID": self.uuid, "Flags": dbus.Array(self.flags, signature="s")}}
|
|
|
|
@dbus.service.method(DBUS_PROPERTIES, in_signature="s", out_signature="a{sv}")
|
|
def GetAll(self, interface):
|
|
if interface != GATT_CHARACTERISTIC:
|
|
raise InvalidArgs()
|
|
return self.properties()[GATT_CHARACTERISTIC]
|
|
|
|
@dbus.service.signal(DBUS_PROPERTIES, signature="sa{sv}as")
|
|
def PropertiesChanged(self, interface, changed, invalidated):
|
|
pass
|
|
|
|
|
|
class TxCharacteristic(Characteristic):
|
|
def __init__(self, bus, service):
|
|
super().__init__(bus, 1, TX_UUID, ["indicate"], service)
|
|
self.notifying = False
|
|
self.queue = deque()
|
|
self.sending = False
|
|
|
|
@dbus.service.method(GATT_CHARACTERISTIC)
|
|
def StartNotify(self):
|
|
self.notifying = True
|
|
if self.queue and not self.sending:
|
|
self.sending = True
|
|
GLib.idle_add(self._send_next)
|
|
|
|
@dbus.service.method(GATT_CHARACTERISTIC)
|
|
def StopNotify(self):
|
|
self.notifying = False
|
|
self.queue.clear()
|
|
self.sending = False
|
|
|
|
@dbus.service.method(GATT_CHARACTERISTIC)
|
|
def Confirm(self):
|
|
if self.queue:
|
|
GLib.idle_add(self._send_next)
|
|
else:
|
|
self.sending = False
|
|
|
|
def send(self, message):
|
|
encoded = (json.dumps(message, separators=(",", ":")) + "\n").encode("utf-8")
|
|
for offset in range(0, len(encoded), NOTIFY_CHUNK_BYTES):
|
|
self.queue.append(encoded[offset:offset + NOTIFY_CHUNK_BYTES])
|
|
if not self.sending:
|
|
self.sending = True
|
|
GLib.idle_add(self._send_next)
|
|
|
|
def _send_next(self):
|
|
if not self.notifying or not self.queue:
|
|
self.sending = False
|
|
return False
|
|
chunk = self.queue.popleft()
|
|
value = dbus.Array([dbus.Byte(byte) for byte in chunk], signature="y")
|
|
self.PropertiesChanged(GATT_CHARACTERISTIC, {"Value": value}, [])
|
|
return False
|
|
|
|
|
|
class RxCharacteristic(Characteristic):
|
|
def __init__(self, bus, service, tx):
|
|
super().__init__(bus, 0, RX_UUID, ["write", "write-without-response"], service)
|
|
self.tx = tx
|
|
self.buffer = bytearray()
|
|
|
|
@dbus.service.method(GATT_CHARACTERISTIC, in_signature="aya{sv}")
|
|
def WriteValue(self, value, _options):
|
|
self.buffer.extend(bytes(value))
|
|
if len(self.buffer) > MAX_MESSAGE_BYTES:
|
|
self.buffer.clear()
|
|
self.tx.send({"id": None, "ok": False, "error": {"code": "MESSAGE_TOO_LARGE", "message": "Bluetooth message was too large"}})
|
|
return
|
|
while b"\n" in self.buffer:
|
|
raw, _, remaining = self.buffer.partition(b"\n")
|
|
self.buffer = bytearray(remaining)
|
|
if raw:
|
|
threading.Thread(target=self._handle, args=(bytes(raw),), daemon=True).start()
|
|
|
|
def _handle(self, raw):
|
|
request_id = None
|
|
try:
|
|
message = json.loads(raw.decode("utf-8"))
|
|
request_id = message.get("id")
|
|
operation = message.get("op")
|
|
token = message.get("token")
|
|
payload = message.get("payload") or {}
|
|
method, path, body = route_operation(operation, payload)
|
|
data = call_api(method, path, body, token)
|
|
response = {"id": request_id, "ok": True, "data": data}
|
|
except ProtocolError as error:
|
|
response = {"id": request_id, "ok": False, "error": {"code": error.code, "message": str(error)}}
|
|
except Exception:
|
|
response = {"id": request_id, "ok": False, "error": {"code": "BRIDGE_ERROR", "message": "The Pi Bluetooth bridge could not complete the request"}}
|
|
GLib.idle_add(self.tx.send, response)
|
|
|
|
|
|
class ProtocolError(Exception):
|
|
def __init__(self, code, message):
|
|
super().__init__(message)
|
|
self.code = code
|
|
|
|
|
|
def route_operation(operation, payload):
|
|
if operation == "pair":
|
|
return "POST", "/internal/mobile/pair", payload
|
|
if operation == "snapshot":
|
|
return "GET", "/internal/mobile/snapshot", None
|
|
if operation == "location":
|
|
return "POST", "/internal/mobile/location", payload
|
|
if operation == "launchShortcut":
|
|
shortcut_id = payload.get("id")
|
|
if not isinstance(shortcut_id, int) or shortcut_id < 1:
|
|
raise ProtocolError("INVALID_SHORTCUT", "Shortcut ID was invalid")
|
|
return "POST", f"/internal/mobile/shortcuts/{shortcut_id}/launch", {}
|
|
raise ProtocolError("UNKNOWN_OPERATION", "That Bluetooth operation is not available")
|
|
|
|
|
|
def call_api(method, path, body, token):
|
|
data = None if body is None else json.dumps(body).encode("utf-8")
|
|
headers = {"Accept": "application/json"}
|
|
if data is not None:
|
|
headers["Content-Type"] = "application/json"
|
|
if isinstance(token, str):
|
|
headers["X-Mobile-Token"] = token
|
|
request = urllib.request.Request(API_BASE + path, data=data, headers=headers, method=method)
|
|
try:
|
|
with urllib.request.urlopen(request, timeout=15) as response:
|
|
raw = response.read()
|
|
return json.loads(raw) if raw else {}
|
|
except urllib.error.HTTPError as error:
|
|
try:
|
|
detail = json.loads(error.read())
|
|
api_error = detail.get("error", {})
|
|
raise ProtocolError(api_error.get("code", "REQUEST_FAILED"), api_error.get("message", "The Pi rejected the request"))
|
|
except (ValueError, AttributeError):
|
|
raise ProtocolError("REQUEST_FAILED", "The Pi rejected the request") from error
|
|
except urllib.error.URLError as error:
|
|
raise ProtocolError("PI_SERVICE_UNAVAILABLE", "The Pi companion service is unavailable") from error
|
|
|
|
|
|
def find_adapter(bus):
|
|
objects = dbus.Interface(bus.get_object(BLUEZ, "/"), DBUS_OM).GetManagedObjects()
|
|
for path, interfaces in objects.items():
|
|
if GATT_MANAGER in interfaces:
|
|
return path
|
|
raise RuntimeError("No Bluetooth LE adapter with GATT server support was found")
|
|
|
|
|
|
def main():
|
|
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
|
|
bus = dbus.SystemBus()
|
|
adapter_path = find_adapter(bus)
|
|
adapter = bus.get_object(BLUEZ, adapter_path)
|
|
dbus.Interface(adapter, DBUS_PROPERTIES).Set("org.bluez.Adapter1", "Powered", dbus.Boolean(True))
|
|
application = Application(bus)
|
|
service = Service(bus, 0, SERVICE_UUID)
|
|
tx = TxCharacteristic(bus, service)
|
|
rx = RxCharacteristic(bus, service, tx)
|
|
service.add_characteristic(rx)
|
|
service.add_characteristic(tx)
|
|
application.add_service(service)
|
|
loop = GLib.MainLoop()
|
|
registration_errors = []
|
|
|
|
def registration_failed(error):
|
|
registration_errors.append(error)
|
|
loop.quit()
|
|
|
|
dbus.Interface(adapter, GATT_MANAGER).RegisterApplication(
|
|
application.path,
|
|
{},
|
|
reply_handler=lambda: None,
|
|
error_handler=registration_failed,
|
|
)
|
|
loop.run()
|
|
if registration_errors:
|
|
raise registration_errors[0]
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|