#!/usr/bin/env python3
"""
HAUC (Hearing Aid Unicast Client) — BlueZ D-Bus client
Demonstrates: scan for HA devices, connect, discover HAS service,
read Hearing Aid Features characteristic, enable Active Preset Index notifications
"""
import dbus
import dbus.mainloop.glib
from gi.repository import GLib
import sys

BLUEZ_SERVICE = "org.bluez"
ADAPTER_PATH  = "/org/bluez/hci0"
DBUS_OM_IFACE = "org.freedesktop.DBus.ObjectManager"
DEVICE_IFACE  = "org.bluez.Device1"
GATT_SVC_IFACE = "org.bluez.GattService1"
GATT_CHR_IFACE = "org.bluez.GattCharacteristic1"

# HAS UUIDs (16-bit assigned numbers, full 128-bit form used by BlueZ)
HAS_SERVICE_UUID          = "00001854-0000-1000-8000-00805f9b34fb"
HAS_FEATURES_UUID         = "00002bda-0000-1000-8000-00805f9b34fb"
HAS_CONTROL_POINT_UUID    = "00002bdb-0000-1000-8000-00805f9b34fb"
HAS_ACTIVE_PRESET_IDX_UUID = "00002bdc-0000-1000-8000-00805f9b34fb"

dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
bus   = dbus.SystemBus()
loop  = GLib.MainLoop()

def get_managed_objects():
    om = dbus.Interface(bus.get_object(BLUEZ_SERVICE, "/"), DBUS_OM_IFACE)
    return om.GetManagedObjects()

def find_ha_devices():
    """Return list of (path, props) for devices that advertise HAS UUID."""
    objects = get_managed_objects()
    ha_list = []
    for path, ifaces in objects.items():
        if DEVICE_IFACE not in ifaces:
            continue
        props = ifaces[DEVICE_IFACE]
        uuids = props.get("UUIDs", [])
        if HAS_SERVICE_UUID in uuids:
            ha_list.append((path, props))
    return ha_list

def find_characteristic(device_path, char_uuid):
    """Find a GATT characteristic object path under a device."""
    objects = get_managed_objects()
    for path, ifaces in objects.items():
        if GATT_CHR_IFACE not in ifaces:
            continue
        if not path.startswith(device_path):
            continue
        props = ifaces[GATT_CHR_IFACE]
        if props.get("UUID") == char_uuid:
            return path
    return None

def read_ha_features(device_path):
    """Read Hearing Aid Features characteristic (0x2BDA)."""
    char_path = find_characteristic(device_path, HAS_FEATURES_UUID)
    if not char_path:
        print("  [!] HAS Features characteristic not found")
        return

    char_obj  = bus.get_object(BLUEZ_SERVICE, char_path)
    char_iface = dbus.Interface(char_obj, GATT_CHR_IFACE)

    raw = bytes(char_iface.ReadValue({}))  # returns dbus.Array of dbus.Byte
    features_byte = raw[0]

    ha_type_map = {0: "Monaural", 1: "Binaural", 2: "Banded"}
    ha_type     = ha_type_map.get(features_byte & 0x03, "Reserved")
    preset_sync = bool(features_byte & 0x04)
    independent = bool(features_byte & 0x08)
    dynamic     = bool(features_byte & 0x10)
    writable    = bool(features_byte & 0x20)

    print(f"  HA Type             : {ha_type} (bits[1:0] = {features_byte & 0x03})")
    print(f"  Preset Synchronised : {preset_sync}")
    print(f"  Independent Presets : {independent}")
    print(f"  Dynamic Presets     : {dynamic}")
    print(f"  Writable Presets    : {writable}")

def subscribe_active_preset_index(device_path):
    """Enable notifications on Active Preset Index characteristic (0x2BDC)."""
    char_path = find_characteristic(device_path, HAS_ACTIVE_PRESET_IDX_UUID)
    if not char_path:
        print("  [!] Active Preset Index characteristic not found")
        return

    char_obj   = bus.get_object(BLUEZ_SERVICE, char_path)
    char_iface = dbus.Interface(char_obj, GATT_CHR_IFACE)
    char_props = dbus.Interface(char_obj, "org.freedesktop.DBus.Properties")

    def on_properties_changed(iface, changed, invalidated):
        if "Value" in changed:
            val = bytes(changed["Value"])
            if val:
                print(f"  [NOTIFICATION] Active Preset Index changed → {val[0]}")

    char_obj.connect_to_signal("PropertiesChanged", on_properties_changed,
                               dbus_interface="org.freedesktop.DBus.Properties")
    char_iface.StartNotify()
    print("  [+] Subscribed to Active Preset Index notifications")

def connect_to_ha(device_path):
    """Connect to HA device and perform HAUC service discovery."""
    device_obj   = bus.get_object(BLUEZ_SERVICE, device_path)
    device_iface = dbus.Interface(device_obj, DEVICE_IFACE)

    print(f"\n[HAUC] Connecting to {device_path} ...")
    device_iface.Connect()
    print("[HAUC] Connected. Discovering GATT services ...")

    # BlueZ auto-discovers GATT after connection; give it a moment
    import time; time.sleep(2)

    print("[HAUC] Reading Hearing Aid Features ...")
    read_ha_features(device_path)

    print("[HAUC] Subscribing to Active Preset Index ...")
    subscribe_active_preset_index(device_path)

    print("[HAUC] Ready. Waiting for preset notifications ...\n")
    loop.run()

# ---------- Main ----------
if __name__ == "__main__":
    devices = find_ha_devices()
    if not devices:
        print("[HAUC] No Hearing Aid devices found. Ensure HA is advertising with HAS UUID 0x1854.")
        sys.exit(1)

    print(f"[HAUC] Found {len(devices)} Hearing Aid device(s):")
    for i, (path, props) in enumerate(devices):
        name = props.get("Name", "Unknown")
        addr = props.get("Address", "??:??:??:??:??:??")
        conn = props.get("Connected", False)
        print(f"  [{i}] {name} ({addr}) {'[connected]' if conn else '[not connected]'}")

    # Connect to first available HA
    chosen_path, chosen_props = devices[0]
    if not chosen_props.get("Connected", False):
        connect_to_ha(chosen_path)
    else:
        print(f"[HAUC] Already connected to {chosen_path}")
        read_ha_features(chosen_path)
        subscribe_active_preset_index(chosen_path)
        loop.run()

#!/usr/bin/env python3
"""
HARC (Hearing Aid Remote Controller) — BlueZ D-Bus client
Implements all 9 HAP preset control procedures via HAS Control Point writes.

Prerequisites:
  - HA device already paired and bonded (LE Security Mode 1 Level 2)
  - HAS service discovered and characteristic handles cached
"""
import dbus
import dbus.mainloop.glib
from gi.repository import GLib
import sys, time

BLUEZ_SERVICE      = "org.bluez"
GATT_CHR_IFACE     = "org.bluez.GattCharacteristic1"
DBUS_OM_IFACE      = "org.freedesktop.DBus.ObjectManager"

HAS_CONTROL_POINT_UUID     = "00002bdb-0000-1000-8000-00805f9b34fb"
HAS_ACTIVE_PRESET_IDX_UUID = "00002bdc-0000-1000-8000-00805f9b34fb"

# HAP Control Point op-codes
OP_READ_PRESETS_REQ         = 0x01
OP_READ_PRESET_BY_INDEX     = 0x02
# 0x03 = Preset Changed (server-initiated; client only receives this)
OP_WRITE_PRESET_NAME        = 0x04
OP_SET_ACTIVE_PRESET        = 0x05
OP_SET_NEXT_PRESET          = 0x06
OP_SET_PREVIOUS_PRESET      = 0x07
OP_SET_ACTIVE_SYNC          = 0x08   # Synchronized Locally
OP_SET_NEXT_SYNC            = 0x09   # Synchronized Locally
OP_SET_PREVIOUS_SYNC        = 0x0A   # Synchronized Locally

# HAS ATT Error codes
HAS_ERR = {
    0x80: "Invalid Opcode",
    0x81: "Write Name Not Allowed (read-only preset)",
    0x82: "Sync to Preset Not Supported",
    0x83: "Preset Operation Not Possible",
    0x84: "Preset Index Out of Range",
}

dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
bus  = dbus.SystemBus()
loop = GLib.MainLoop()

# ---- Utility: find characteristic path under a device ----
def find_char(device_path, uuid):
    om = dbus.Interface(bus.get_object(BLUEZ_SERVICE, "/"), DBUS_OM_IFACE)
    for path, ifaces in om.GetManagedObjects().items():
        if GATT_CHR_IFACE not in ifaces:
            continue
        if not path.startswith(device_path):
            continue
        if ifaces[GATT_CHR_IFACE].get("UUID") == uuid:
            return path
    return None

def get_char_iface(device_path, uuid):
    path = find_char(device_path, uuid)
    if not path:
        raise RuntimeError(f"Characteristic {uuid} not found under {device_path}")
    obj = bus.get_object(BLUEZ_SERVICE, path)
    return dbus.Interface(obj, GATT_CHR_IFACE)

# ---- HARC class ----
class HARCClient:
    def __init__(self, device_path):
        self.device_path = device_path
        self.cp_iface    = get_char_iface(device_path, HAS_CONTROL_POINT_UUID)
        self.api_iface   = get_char_iface(device_path, HAS_ACTIVE_PRESET_IDX_UUID)
        self.preset_cache = {}   # index -> {"name": str, "is_available": bool, "is_writable": bool}
        self._subscribe_active_preset_index()
        print(f"[HARC] Initialised for device: {device_path}")

    def _write_cp(self, payload: list):
        """Write a list of bytes to the Control Point characteristic."""
        try:
            self.cp_iface.WriteValue(
                dbus.Array([dbus.Byte(b) for b in payload], signature='y'),
                dbus.Dictionary({}, signature='sv')
            )
        except dbus.DBusException as e:
            code = int(str(e).split("0x")[-1][:2], 16) if "0x" in str(e) else 0
            print(f"  [!] Control Point write failed: {HAS_ERR.get(code, str(e))}")

    def _subscribe_active_preset_index(self):
        api_path = find_char(self.device_path, HAS_ACTIVE_PRESET_IDX_UUID)
        api_obj  = bus.get_object(BLUEZ_SERVICE, api_path)

        def on_change(iface, changed, invalidated):
            if "Value" in changed:
                idx = int(bytes(changed["Value"])[0])
                name = self.preset_cache.get(idx, {}).get("name", "?")
                print(f"  [NOTIFY] Active Preset Index → {idx} ({name})")

        api_obj.connect_to_signal("PropertiesChanged", on_change,
                                  dbus_interface="org.freedesktop.DBus.Properties")
        self.api_iface.StartNotify()
        print("[HARC] Subscribed to Active Preset Index notifications")

    # ---- Procedure 1: Read Presets Request ----
    def read_presets(self, start_index=1, max_count=0xFF):
        """Op-code 0x01: Read all presets starting at start_index."""
        print(f"\n[HARC] Procedure 1 — Read Presets Request (start={start_index}, max={max_count})")
        self._write_cp([OP_READ_PRESETS_REQ, start_index, max_count])
        # Responses arrive as indications on the Control Point → handled via PropertiesChanged

    # ---- Procedure 2: Read Preset by Index ----
    def read_preset_by_index(self, index: int):
        """Op-code 0x02: Read one specific preset."""
        print(f"\n[HARC] Procedure 2 — Read Preset by Index (index={index})")
        self._write_cp([OP_READ_PRESET_BY_INDEX, index])

    # ---- Procedure 4: Write Preset Name ----
    def write_preset_name(self, index: int, name: str):
        """Op-code 0x04: Rename a writable preset. Name max 40 bytes UTF-8."""
        name_bytes = name.encode("utf-8")[:40]
        if len(name_bytes) == 0:
            print("[HARC] Name cannot be empty")
            return
        print(f"\n[HARC] Procedure 4 — Write Preset Name (index={index}, name='{name}')")
        payload = [OP_WRITE_PRESET_NAME, index] + list(name_bytes)
        self._write_cp(payload)

    # ---- Procedure 5: Set Active Preset ----
    def set_active_preset(self, index: int):
        """Op-code 0x05: Activate a specific preset by index."""
        print(f"\n[HARC] Procedure 5 — Set Active Preset (index={index})")
        self._write_cp([OP_SET_ACTIVE_PRESET, index])

    # ---- Procedure 6: Set Next Preset ----
    def set_next_preset(self):
        """Op-code 0x06: Move to the next available preset."""
        print(f"\n[HARC] Procedure 6 — Set Next Preset")
        self._write_cp([OP_SET_NEXT_PRESET])

    # ---- Procedure 7: Set Previous Preset ----
    def set_previous_preset(self):
        """Op-code 0x07: Move to the previous available preset."""
        print(f"\n[HARC] Procedure 7 — Set Previous Preset")
        self._write_cp([OP_SET_PREVIOUS_PRESET])

    # ---- Procedure 8: Set Active Preset — Synchronized Locally ----
    def set_active_preset_sync(self, index: int):
        """Op-code 0x08: Activate preset on BOTH aids in binaural set via HA-to-HA sync."""
        print(f"\n[HARC] Procedure 8 — Set Active Preset (Sync Locally, index={index})")
        self._write_cp([OP_SET_ACTIVE_SYNC, index])

    # ---- Procedure 9a: Set Next Preset — Synchronized Locally ----
    def set_next_preset_sync(self):
        """Op-code 0x09: Advance to next preset on BOTH aids simultaneously."""
        print(f"\n[HARC] Procedure 9a — Set Next Preset (Sync Locally)")
        self._write_cp([OP_SET_NEXT_SYNC])

    # ---- Procedure 9b: Set Previous Preset — Synchronized Locally ----
    def set_previous_preset_sync(self):
        """Op-code 0x0A: Step back to previous preset on BOTH aids simultaneously."""
        print(f"\n[HARC] Procedure 9b — Set Previous Preset (Sync Locally)")
        self._write_cp([OP_SET_PREVIOUS_SYNC])

# ---------- Demo run ----------
if __name__ == "__main__":
    # Replace with your HA device path (find via bluetoothctl: devices)
    HA_DEVICE_PATH = "/org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF"

    harc = HARCClient(HA_DEVICE_PATH)

    # Read all presets first
    harc.read_presets()
    time.sleep(1)

    # Set active preset to index 2
    harc.set_active_preset(2)
    time.sleep(0.5)

    # Advance to next preset
    harc.set_next_preset()
    time.sleep(0.5)

    # For a binaural set with Preset Sync supported:
    harc.set_active_preset_sync(1)   # Both aids switch to preset 1

    # Keep running to receive Active Preset Index notifications
    print("\n[HARC] Running. Press Ctrl-C to exit.")
    loop.run()

#!/usr/bin/env python3
"""
IAC (Immediate Alert Client) — BlueZ D-Bus client
Writes Alert Level values (0x00/0x01/0x02) to the HA's IAS Alert Level characteristic.
Uses Write Without Response (ATT_WRITE_CMD) — no ACK expected.
"""
import dbus
import dbus.mainloop.glib
import sys, time

BLUEZ_SERVICE  = "org.bluez"
DBUS_OM_IFACE  = "org.freedesktop.DBus.ObjectManager"
GATT_CHR_IFACE = "org.bluez.GattCharacteristic1"

IAS_SERVICE_UUID    = "00001802-0000-1000-8000-00805f9b34fb"
ALERT_LEVEL_UUID    = "00002a06-0000-1000-8000-00805f9b34fb"

ALERT_NO    = 0x00
ALERT_MILD  = 0x01
ALERT_HIGH  = 0x02

dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
bus = dbus.SystemBus()

def find_alert_level_char(device_path):
    om = dbus.Interface(bus.get_object(BLUEZ_SERVICE, "/"), DBUS_OM_IFACE)
    for path, ifaces in om.GetManagedObjects().items():
        if GATT_CHR_IFACE not in ifaces:
            continue
        if not path.startswith(device_path):
            continue
        if ifaces[GATT_CHR_IFACE].get("UUID") == ALERT_LEVEL_UUID:
            return path
    return None

def write_alert_level(device_path, level: int):
    """Write Alert Level value using Write Without Response."""
    if level not in (ALERT_NO, ALERT_MILD, ALERT_HIGH):
        raise ValueError(f"Invalid alert level: {level}. Must be 0, 1, or 2.")

    char_path = find_alert_level_char(device_path)
    if not char_path:
        print("[IAC] Alert Level characteristic not found. Is IAS present?")
        return

    char_obj   = bus.get_object(BLUEZ_SERVICE, char_path)
    char_iface = dbus.Interface(char_obj, GATT_CHR_IFACE)

    # type="command" tells BlueZ to use Write Without Response (ATT_WRITE_CMD)
    char_iface.WriteValue(
        dbus.Array([dbus.Byte(level)], signature='y'),
        dbus.Dictionary({"type": dbus.String("command")}, signature='sv')
    )

    level_name = {ALERT_NO: "No Alert", ALERT_MILD: "Mild Alert", ALERT_HIGH: "High Alert"}[level]
    print(f"[IAC] Alert Level written: {level_name} (0x{level:02X})")

# ---------- Demo: simulate incoming call ----------
if __name__ == "__main__":
    HA_DEVICE_PATH = "/org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF"

    print("[IAC] Simulating incoming call ...")
    write_alert_level(HA_DEVICE_PATH, ALERT_HIGH)   # HA rings
    print("[IAC] Waiting 5 seconds (ring duration) ...")
    time.sleep(5)
    write_alert_level(HA_DEVICE_PATH, ALERT_NO)     # Call dismissed / answered
    print("[IAC] Alert cleared.")

#!/usr/bin/env python3
"""
HAP Security Setup — BlueZ pairing agent + encryption check
Registers a Just Works agent (no display/keyboard) for HA devices that do not
have input/output capabilities.  Verifies link encryption before GATT access.
"""
import dbus
import dbus.service
import dbus.mainloop.glib
from gi.repository import GLib

BLUEZ_SERVICE    = "org.bluez"
AGENT_IFACE      = "org.bluez.Agent1"
AGENT_MGR_IFACE  = "org.bluez.AgentManager1"
DEVICE_IFACE     = "org.bluez.Device1"
DBUS_OM_IFACE    = "org.freedesktop.DBus.ObjectManager"

AGENT_PATH       = "/org/embeddedpathashala/hauc_agent"

dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
bus  = dbus.SystemBus()
loop = GLib.MainLoop()

# ---- Pairing Agent ----
class HaNoInputNoOutputAgent(dbus.service.Object):
    """
    Just Works agent — no passkey, no confirmation required.
    Suitable for hearing aids that have no display or keyboard.
    Capability string: "NoInputNoOutput"
    """
    @dbus.service.method(AGENT_IFACE, in_signature="", out_signature="")
    def Release(self):
        print("[Agent] Released")

    @dbus.service.method(AGENT_IFACE, in_signature="os", out_signature="")
    def AuthorizeService(self, device, uuid):
        print(f"[Agent] AuthorizeService {device}: UUID={uuid} → Accepting")

    @dbus.service.method(AGENT_IFACE, in_signature="o", out_signature="")
    def RequestAuthorization(self, device):
        print(f"[Agent] RequestAuthorization from {device} → Accepting")

    @dbus.service.method(AGENT_IFACE, in_signature="ou", out_signature="")
    def RequestConfirmation(self, device, passkey):
        # Just Works: accept any passkey without user confirmation
        print(f"[Agent] RequestConfirmation {device} passkey={passkey:06d} → Auto-accepting")

    @dbus.service.method(AGENT_IFACE, in_signature="o", out_signature="u")
    def RequestPasskey(self, device):
        print(f"[Agent] RequestPasskey from {device} → 000000")
        return dbus.UInt32(0)

    @dbus.service.method(AGENT_IFACE, in_signature="ouq", out_signature="")
    def DisplayPasskey(self, device, passkey, entered):
        print(f"[Agent] DisplayPasskey {device}: {passkey:06d} (entered={entered})")

    @dbus.service.method(AGENT_IFACE, in_signature="os", out_signature="")
    def DisplayPinCode(self, device, pincode):
        print(f"[Agent] DisplayPinCode {device}: {pincode}")

    @dbus.service.method(AGENT_IFACE, in_signature="o", out_signature="s")
    def RequestPinCode(self, device):
        return "0000"

    @dbus.service.method(AGENT_IFACE, in_signature="o", out_signature="")
    def Cancel(self):
        print("[Agent] Pairing cancelled")

def register_agent():
    """Register the Just Works agent as the default agent."""
    agent = HaNoInputNoOutputAgent(bus, AGENT_PATH)
    mgr_obj   = bus.get_object(BLUEZ_SERVICE, "/org/bluez")
    mgr_iface = dbus.Interface(mgr_obj, AGENT_MGR_IFACE)
    mgr_iface.RegisterAgent(AGENT_PATH, "NoInputNoOutput")
    mgr_iface.RequestDefaultAgent(AGENT_PATH)
    print("[Agent] Just Works agent registered as default")
    return agent

def is_link_encrypted(device_path) -> bool:
    """Check whether the current connection to an HA is encrypted."""
    dev_obj   = bus.get_object(BLUEZ_SERVICE, device_path)
    dev_props = dbus.Interface(dev_obj, "org.freedesktop.DBus.Properties")
    try:
        # BluezZ exposes "Trusted", "Paired", "Connected" but not explicit encryption state.
        # A bonded + connected device with ServicesResolved=True has negotiated encryption.
        paired   = dev_props.Get(DEVICE_IFACE, "Paired")
        bonded   = dev_props.Get(DEVICE_IFACE, "Bonded")
        connected = dev_props.Get(DEVICE_IFACE, "Connected")
        resolved = dev_props.Get(DEVICE_IFACE, "ServicesResolved")
        encrypted = paired and bonded and connected and resolved
        print(f"[Security] Paired={paired}, Bonded={bonded}, "
              f"Connected={connected}, ServicesResolved={resolved}")
        print(f"[Security] Link considered {'ENCRYPTED ✅' if encrypted else 'NOT ENCRYPTED ❌'}")
        return bool(encrypted)
    except dbus.DBusException as e:
        print(f"[Security] Could not check encryption status: {e}")
        return False

def pair_and_bond(device_path):
    """Initiate pairing with HA device (creates bond for reconnection)."""
    dev_obj   = bus.get_object(BLUEZ_SERVICE, device_path)
    dev_iface = dbus.Interface(dev_obj, DEVICE_IFACE)
    dev_props = dbus.Interface(dev_obj, "org.freedesktop.DBus.Properties")

    paired = dev_props.Get(DEVICE_IFACE, "Paired")
    if paired:
        print(f"[Security] Device already paired: {device_path}")
        return

    print(f"[Security] Initiating pairing with {device_path} ...")
    try:
        dev_iface.Pair()
        print("[Security] Pairing successful — bond created")
        # Set Trusted so BlueZ auto-accepts reconnection without re-pairing
        dev_props.Set(DEVICE_IFACE, "Trusted", dbus.Boolean(True))
    except dbus.DBusException as e:
        print(f"[Security] Pairing failed: {e}")

# ---------- Main ----------
if __name__ == "__main__":
    HA_DEVICE_PATH = "/org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF"

    agent = register_agent()

    # Connect to the HA (it must already be in the BlueZ device list from scanning)
    dev_obj   = bus.get_object(BLUEZ_SERVICE, HA_DEVICE_PATH)
    dev_iface = dbus.Interface(dev_obj, DEVICE_IFACE)

    print(f"[Security] Connecting to {HA_DEVICE_PATH} ...")
    dev_iface.Connect()

    # Pair if not already done
    pair_and_bond(HA_DEVICE_PATH)

    # Check encryption before any GATT operation
    if is_link_encrypted(HA_DEVICE_PATH):
        print("[Security] Safe to access HAS characteristics")
        # → proceed with HARC preset reads / HAUC CIS setup
    else:
        print("[Security] Aborting GATT access — link not encrypted")

    loop.run()

# 1. Enable LE Audio in BlueZ (requires BlueZ 5.66+)
sudo nano /etc/bluetooth/main.conf

# In [General] section, ensure these are set:
# ControllerMode = le
# ExperimentalFeatures = true

# In [Policy] section:
# AutoEnable = true

# 2. Restart BlueZ
sudo systemctl restart bluetooth

# 3. Verify LE Audio support
btmgmt info | grep -i "le audio\|iso\|2m phy"
# Expected: "LE transport" and "2M PHY" in supported settings

# 4. Create systemd service file
cat > /etc/systemd/system/hap-client.service << 'EOF'
[Unit]
Description=HAP Client Daemon (HAUC + HARC)
After=bluetooth.target
Requires=bluetooth.target

[Service]
Type=simple
User=root
ExecStart=/usr/bin/python3 /opt/hap_client/harc_client.py
Restart=on-failure
RestartSec=5s
Environment=DBUS_SYSTEM_BUS_ADDRESS=unix:path=/run/dbus/system_bus_socket

[Install]
WantedBy=multi-user.target
EOF

# 5. Enable and start
sudo systemctl daemon-reload
sudo systemctl enable hap-client.service
sudo systemctl start  hap-client.service
sudo journalctl -fu hap-client.service   # Follow logs