From 419350822f82e578b96c6ddc79e2579fc7c9e8ec Mon Sep 17 00:00:00 2001 From: Kuba Orlik Date: Fri, 6 Nov 2026 14:10:29 +0100 Subject: [PATCH] Add kodi with passthrough. Reconfigure xing-wei remap so it handles volume changes when kodi is open via home assistant instead of over pulseaudio --- env.example | 3 +- kodi-with-passthrough.sh | 45 ++++ .../__pycache__/ha_volume.cpython-314.pyc | Bin 0 -> 11723 bytes xing-wei-remap/ha_volume.py | 202 ++++++++++++++++++ xing-wei-remap/remap.py | 195 +++++++++++++---- 5 files changed, 405 insertions(+), 40 deletions(-) create mode 100755 kodi-with-passthrough.sh create mode 100644 xing-wei-remap/__pycache__/ha_volume.cpython-314.pyc create mode 100644 xing-wei-remap/ha_volume.py diff --git a/env.example b/env.example index 1549c89..324e8f6 100644 --- a/env.example +++ b/env.example @@ -1 +1,2 @@ -export SUSPEND_SECRET=some-password \ No newline at end of file +export SUSPEND_SECRET=some-password +export HASS_TOKEN=12312312312 \ No newline at end of file diff --git a/kodi-with-passthrough.sh b/kodi-with-passthrough.sh new file mode 100755 index 0000000..8bb313e --- /dev/null +++ b/kodi-with-passthrough.sh @@ -0,0 +1,45 @@ +#!/usr/bin/env bash +set -euo pipefail + +CARD="alsa_card.pci-0000_03_00.1" +CARD_SUFFIX="${CARD#alsa_card.}" +STEREO_PROFILE="output:hdmi-stereo-extra3" +SURROUND_PROFILE="output:hdmi-surround71-extra3" + +echo "Switching ONKYO to 7.1..." +pactl set-card-profile "$CARD" "$SURROUND_PROFILE" + +sleep 2 + +echo "Switching ONKYO to stereo..." +pactl set-card-profile "$CARD" "$STEREO_PROFILE" + +echo "Clearing default sink configuration..." +wpctl clear-default + +sleep 3 + +echo "Launching Kodi..." +flatpak run tv.kodi.Kodi & +KODI_PID=$! + +trap 'kill "$KODI_PID" 2>/dev/null || true; wait "$KODI_PID" 2>/dev/null || true' INT TERM + +wait "$KODI_PID" || true + +echo "Kodi exited. Restoring 7.1 profile and default sink..." +pactl set-card-profile "$CARD" "$SURROUND_PROFILE" + +# Give PipeWire a moment to expose the sink for the new profile +sleep 1 + +SINK="alsa_output.${CARD_SUFFIX}.hdmi-surround71-extra3" +if pactl list short sinks | awk '{print $2}' | grep -qx "$SINK"; then + pactl set-default-sink "$SINK" + echo "Default sink set to: $SINK" +else + echo "Warning: sink '$SINK' not found; listing available sinks:" >&2 + pactl list short sinks >&2 +fi + +echo "Done." diff --git a/xing-wei-remap/__pycache__/ha_volume.cpython-314.pyc b/xing-wei-remap/__pycache__/ha_volume.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..92d26a6fe370f5ec69410386aa040294bc6fa6ef GIT binary patch literal 11723 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 literal 0 HcmV?d00001 diff --git a/xing-wei-remap/ha_volume.py b/xing-wei-remap/ha_volume.py new file mode 100644 index 0000000..5e5396a --- /dev/null +++ b/xing-wei-remap/ha_volume.py @@ -0,0 +1,202 @@ +# ha_volume.py +"""Adjust a Home Assistant media_player volume by a signed delta. + +Usable both as a CLI tool and as an importable module. + + from ha_volume import adjust_volume + adjust_volume(5) # +5 percentage points on default entity + adjust_volume(-5, entity="media_player.kitchen") + old, new = adjust_volume(5) # get the before/after levels back + +Reads HASS_TOKEN from ../env (auto-discovered relative to this file), then +falls back to $HASS_TOKEN / $HASS_URL / $HASS_ENTITY. + +Stdlib only: urllib, json, argparse, pathlib, os, sys. +""" +from __future__ import annotations + +import argparse +import json +import os +import sys +import urllib.error +import urllib.request +from pathlib import Path + +DEFAULT_ENTITY = "media_player.tx_nr7100" +DEFAULT_URL = "http://192.168.1.90:8123" + + +class HAError(RuntimeError): + """Raised for any Home Assistant API / config failure.""" + + +# --------------------------------------------------------------------------- # +# Config discovery +# --------------------------------------------------------------------------- # + +def load_env(path: Path) -> dict[str, str]: + """Parse a simple shell-style env file (supports `export ` and quotes).""" + env: dict[str, str] = {} + if not path.is_file(): + return env + for raw in path.read_text().splitlines(): + line = raw.strip() + if not line or line.startswith("#"): + continue + if line.startswith("export "): + line = line[len("export "):].lstrip() + if "=" not in line: + continue + key, _, val = line.partition("=") + key, val = key.strip(), val.strip() + if len(val) >= 2 and val[0] == val[-1] and val[0] in ("'", '"'): + val = val[1:-1] + env[key] = val + return env + + +def find_env_file(start: Path | None = None) -> Path | None: + """Search for `../env` relative to *start* (defaults to this file's dir).""" + here = (start or Path(__file__)).resolve().parent + for cand in (here / ".." / "env", Path.cwd() / ".." / "env", Path.cwd() / "env"): + if cand.is_file(): + return cand.resolve() + return None + + +def _resolve( + *, + entity: str | None, + url: str | None, + token: str | None, + env_file: Path | str | None, +) -> tuple[str, str, str]: + """Fill in entity / url / token from args, env file, then process env.""" + env_path = Path(env_file).expanduser() if env_file else find_env_file() + env = load_env(env_path) if env_path else {} + + tok = token or env.get("HASS_TOKEN") or os.environ.get("HASS_TOKEN") + if not tok: + where = env_path or "" + raise HAError(f"HASS_TOKEN not in {where} or $HASS_TOKEN") + + ent = entity or env.get("HASS_ENTITY") or os.environ.get("HASS_ENTITY") or DEFAULT_ENTITY + base = (url or env.get("HASS_URL") or os.environ.get("HASS_URL") or DEFAULT_URL).rstrip("/") + return ent, base, tok + + +# --------------------------------------------------------------------------- # +# HTTP +# --------------------------------------------------------------------------- # + +def _request(url: str, token: str, *, method: str = "GET", payload=None): + data = json.dumps(payload).encode() if payload is not None else None + headers = {"Authorization": f"Bearer {token}"} + if data is not None: + headers["Content-Type"] = "application/json" + req = urllib.request.Request(url, data=data, headers=headers, method=method) + try: + with urllib.request.urlopen(req, timeout=10) as resp: + raw = resp.read() + except urllib.error.HTTPError as e: + raise HAError(f"{method} {url} -> {e.code} {e.reason}") from e + except urllib.error.URLError as e: + raise HAError(f"cannot reach {url}: {e.reason}") from e + return json.loads(raw) if raw else None + + +# --------------------------------------------------------------------------- # +# Public API +# --------------------------------------------------------------------------- # + +def get_volume( + entity: str | None = None, + *, + url: str | None = None, + token: str | None = None, + env_file: Path | str | None = None, +) -> float: + """Return the current volume_level (0.0-1.0) for *entity*.""" + ent, base, tok = _resolve(entity=entity, url=url, token=token, env_file=env_file) + state = _request(f"{base}/api/states/{ent}", tok) + try: + return float(state["attributes"]["volume_level"]) + except (KeyError, TypeError, ValueError) as e: + raise HAError( + f"{ent} has no volume_level (state={state.get('state')!r})" + ) from e + + +def set_volume( + level: float, + entity: str | None = None, + *, + url: str | None = None, + token: str | None = None, + env_file: Path | str | None = None, +) -> None: + """Set volume_level (0.0-1.0), clamped to range.""" + ent, base, tok = _resolve(entity=entity, url=url, token=token, env_file=env_file) + level = max(0.0, min(1.0, float(level))) + _request(f"{base}/api/services/media_player/volume_set", tok, method="POST", payload={ + "entity_id": ent, + "volume_level": round(level, 3), + }) + + +def adjust_volume( + delta: int, + entity: str | None = None, + *, + url: str | None = None, + token: str | None = None, + env_file: Path | str | None = None, +) -> tuple[float, float]: + """Add *delta* percentage points to *entity*'s volume; returns (old, new).""" + ent, base, tok = _resolve(entity=entity, url=url, token=token, env_file=env_file) + current = float(_request(f"{base}/api/states/{ent}", tok)["attributes"]["volume_level"]) + new = max(0.0, min(1.0, current + delta / 100.0)) + if abs(new - current) < 1e-9: + return current, current + _request(f"{base}/api/services/media_player/volume_set", tok, method="POST", payload={ + "entity_id": ent, + "volume_level": round(new, 3), + }) + return current, new + + +# --------------------------------------------------------------------------- # +# CLI +# --------------------------------------------------------------------------- # + +def main(argv: list[str] | None = None) -> int: + ap = argparse.ArgumentParser( + description="Add a signed delta (percentage points) to a HA media_player volume." + ) + ap.add_argument("delta", type=int, help="integer delta, e.g. 5 or -5") + ap.add_argument("--entity", default=None, help=f"default: {DEFAULT_ENTITY}") + ap.add_argument("--url", default=None, help=f"default: {DEFAULT_URL}") + ap.add_argument("--env-file", default=None, help="path to env file (default: auto)") + args = ap.parse_args(argv) + + try: + old, new = adjust_volume( + args.delta, + entity=args.entity, + url=args.url, + env_file=args.env_file, + ) + except HAError as e: + print(f"error: {e}", file=sys.stderr) + return 1 + + if abs(new - old) < 1e-9: + print(f"volume already at {old:.2f} ({args.delta:+d} requested)") + else: + print(f"volume: {old:.2f} -> {new:.2f} ({args.delta:+d})") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/xing-wei-remap/remap.py b/xing-wei-remap/remap.py index c30b307..16e28b7 100755 --- a/xing-wei-remap/remap.py +++ b/xing-wei-remap/remap.py @@ -5,21 +5,36 @@ import os import evdev from evdev import ecodes, UInput +from ha_volume import adjust_volume, HAError + DEVICE_NAME = "XING WEI 2.4G USB USB Composite Device Consumer Control" +# HID consumer scancodes carried in MSC_SCAN.value for the volume keys. +VOLUP_SCAN = 0xC00E9 # -> KEY_VOLUMEUP +VOLDOWN_SCAN = 0xC00EA # -> KEY_VOLUMEDOWN + +# How much to change HA volume_level per keypress, in percentage points. +VOLUME_STEP = 2 + +# Bidirectional maps between EV_KEY codes and MSC_SCAN values +SCAN_TO_KEY = { + VOLUP_SCAN: ecodes.KEY_VOLUMEUP, + VOLDOWN_SCAN: ecodes.KEY_VOLUMEDOWN, +} +KEY_TO_SCAN = {v: k for k, v in SCAN_TO_KEY.items()} +SCAN_TO_DIR = {VOLUP_SCAN: "up", VOLDOWN_SCAN: "down"} + def kodi_running(): for pid in os.listdir("/proc"): if not pid.isdigit(): continue - try: with open(f"/proc/{pid}/comm") as f: if f.read().strip() in ("kodi", "kodi.bin"): return True except (OSError, PermissionError): pass - return False @@ -28,87 +43,186 @@ def find_device(): for path in evdev.list_devices(): try: dev = evdev.InputDevice(path) - if dev.name == DEVICE_NAME: if ecodes.KEY_BACK in dev.capabilities().get(ecodes.EV_KEY, []): print(f"Found device: {path}", flush=True) return dev - dev.close() - except (OSError, PermissionError): pass - - print("Waiting for device...", flush=True) + print("Waiting for XING WEI device...", flush=True) time.sleep(2) def run(): while True: dev = find_device() - ui = None + + passthrough = None + remapper = None + + # Remember which key was used for the current BACK press. + back_key = None + + # Per-scancode state for volume keys while the device is grabbed. + # "intercepting" -> we swallowed the press; swallow the release too. + # "passthrough" -> we forwarded the press; forward the release too. + # Entry present -> key currently held (press is in progress). + # Entry absent -> key is released. + vol_state = {} try: - # Create a clean virtual keyboard - ui = UInput( + passthrough = UInput.from_device( + dev, + name="XING WEI Passthrough", + vendor=0x1915, + product=0x1025, + version=0x0201 + ) + + remapper = UInput( events={ ecodes.EV_KEY: [ ecodes.KEY_ESC, ecodes.KEY_BACKSPACE, ecodes.KEY_LEFTSHIFT, ecodes.KEY_TAB, - ] + [ - key for key in dev.capabilities().get(ecodes.EV_KEY, []) - if key not in ( - ecodes.KEY_BACK, - ecodes.KEY_HOMEPAGE, - ) ] }, - name="XING WEI Remapped Keyboard", + name="XING WEI Remapped Keys", bustype=0x03, vendor=0x1915, - product=0x1025, + product=0x1026, version=0x0201 ) dev.grab() print("Device grabbed successfully!", flush=True) + print("Created: XING WEI Passthrough", flush=True) + print("Created: XING WEI Remapped Keys", flush=True) print("BACK: ESC / BACKSPACE (Kodi)", flush=True) print("HOME: SHIFT + TAB", flush=True) + print(f"VOL UP/DOWN: HA volume {VOLUME_STEP:+d}/{-VOLUME_STEP:+d} (Kodi)", + flush=True) for event in dev.read_loop(): - if event.type == ecodes.EV_KEY: - + # ------------------------------------------------------------------ + # MSC_SCAN: runs *before* the matching EV_KEY in each batch. We use + # it to decide (and remember) whether to intercept this press. + # ------------------------------------------------------------------ + if event.type == ecodes.EV_MSC and event.code == ecodes.MSC_SCAN: + + scan = event.value + if scan in SCAN_TO_KEY: + state = vol_state.get(scan) + + if state == "intercepting": + # Release scan of an intercepted key: keep suppressed. + continue + + if state == "passthrough": + # Release scan of a passed-through key: forward it. + passthrough.write_event(event) + continue + + # New press. Decide now based on Kodi; remember the + # decision so the release cannot flip mid-press. + if kodi_running(): + vol_state[scan] = "intercepting" + continue + else: + vol_state[scan] = "passthrough" + passthrough.write_event(event) + continue + + # Non-volume scan: forward as before. + passthrough.write_event(event) + + # ------------------------------------------------------------------ + # EV_KEY + # ------------------------------------------------------------------ + elif event.type == ecodes.EV_KEY: + + scan = KEY_TO_SCAN.get(event.code) + state = vol_state.get(scan) if scan is not None else None + + # ---- Volume key that we're intercepting (Kodi is running) ---- + if state == "intercepting": + if event.value == 1: + delta = VOLUME_STEP if SCAN_TO_DIR[scan] == "up" else -VOLUME_STEP + try: + adjust_volume(delta) + except HAError as e: + print(f"volume adjust failed: {e}", flush=True) + except Exception as e: + print(f"volume adjust error: {e!r}", flush=True) + elif event.value == 0: + # Release completes the pair; clear state. + del vol_state[scan] + # Suppress either way. + continue + + # ---- Volume key we're passing through ---- + if state == "passthrough": + passthrough.write_event(event) + if event.value == 0: + del vol_state[scan] + continue + + # ---- BACK -> ESC / BACKSPACE ---- if event.code == ecodes.KEY_BACK: - key = ( - ecodes.KEY_BACKSPACE - if kodi_running() - else ecodes.KEY_ESC + + if event.value == 1: + back_key = ( + ecodes.KEY_BACKSPACE + if kodi_running() + else ecodes.KEY_ESC + ) + elif back_key is None: + back_key = ( + ecodes.KEY_BACKSPACE + if kodi_running() + else ecodes.KEY_ESC + ) + + remapper.write( + ecodes.EV_KEY, + back_key, + event.value ) - ui.write(ecodes.EV_KEY, key, event.value) - ui.syn() + if event.value == 0: + back_key = None + # ---- HOME -> SHIFT + TAB ---- elif event.code == ecodes.KEY_HOMEPAGE: if event.value == 1: - ui.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 1) - ui.write(ecodes.EV_KEY, ecodes.KEY_TAB, 1) - ui.syn() - - ui.write(ecodes.EV_KEY, ecodes.KEY_TAB, 0) - ui.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 0) - ui.syn() + remapper.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 1) + remapper.write(ecodes.EV_KEY, ecodes.KEY_TAB, 1) + remapper.write(ecodes.EV_KEY, ecodes.KEY_TAB, 0) + remapper.write(ecodes.EV_KEY, ecodes.KEY_LEFTSHIFT, 0) + remapper.syn() + # ---- Everything else goes to passthrough ---- else: - ui.write_event(event) - + passthrough.write_event(event) + + # ------------------------------------------------------------------ + # SYN + # ------------------------------------------------------------------ + elif event.type == ecodes.EV_SYN: + passthrough.write_event(event) + if event.code == ecodes.SYN_REPORT: + remapper.syn() + + # ------------------------------------------------------------------ + # Anything else (REL, ABS, etc.) + # ------------------------------------------------------------------ else: - # Ignore non-key events from the consumer-control device - pass + passthrough.write_event(event) except (OSError, IOError) as e: print(f"Device error: {e}", flush=True) @@ -121,8 +235,11 @@ def run(): pass dev.close() - if ui: - ui.close() + if passthrough: + passthrough.close() + + if remapper: + remapper.close() print("Reconnecting in 2 seconds...", flush=True) time.sleep(2)