533 lines
21 KiB
Python
533 lines
21 KiB
Python
"""The actual behaviour of the panel, on top of the HEOS CLI client.
|
|
|
|
The interesting part is grouping. A HEOS "In-Room Group" (your pair of
|
|
Home 200s) is addressed by a gid and behaves like one speaker -- until
|
|
you merge it into the AVR's group, at which point that gid stops
|
|
existing and its two players are just two members of the AVR's group.
|
|
Two consequences drive most of the code below:
|
|
|
|
* Merging must send EVERY member pid of the pair, not just its leader,
|
|
or the second Home 200 gets left behind.
|
|
* Unmerging must re-issue set_group with the pair's own pids to put
|
|
the pair back together, so we have to remember what they were.
|
|
|
|
Everything, including the AVR's own inputs, goes over the one HEOS
|
|
connection now -- there used to be a second client here for the AVR's
|
|
Denon Telnet port, only for its renamed input list, but HEOS reports
|
|
those same renamed names itself (browse/browse on the AVR's own pid),
|
|
so the Telnet side added a protocol for no remaining benefit.
|
|
"""
|
|
|
|
import json
|
|
import threading
|
|
import time
|
|
from pathlib import Path
|
|
|
|
from heos import HeosClient, HeosError, parse_message
|
|
|
|
MEMBERS_FILE = Path(__file__).with_name("members.json")
|
|
|
|
|
|
def stepped_level(current: int, steps: int, size: int) -> int:
|
|
"""Where the volume lands after `steps` taps of +/-.
|
|
|
|
A tap moves to the next multiple of `size` rather than adding `size`,
|
|
so a level of 23 with a step of 5 goes 23 -> 25 -> 30 on the way up
|
|
and 23 -> 20 -> 15 on the way down. Levels that are already on a
|
|
multiple simply move a whole step.
|
|
"""
|
|
if steps > 0:
|
|
landing = (current // size + steps) * size
|
|
elif steps < 0:
|
|
aligned = current // size * size
|
|
first = current - size if aligned == current else aligned
|
|
landing = first - (-steps - 1) * size
|
|
else:
|
|
return current
|
|
return max(0, min(100, landing))
|
|
|
|
|
|
class TargetError(ValueError):
|
|
"""We cannot find that room on the network right now."""
|
|
|
|
|
|
class Controller:
|
|
def __init__(self, cfg):
|
|
self.cfg = cfg
|
|
self.heos = HeosClient(cfg.HEOS_HOST, cfg.HEOS_PORT)
|
|
self._lock = threading.RLock()
|
|
self._members_file = Path(getattr(cfg, "MEMBERS_FILE", MEMBERS_FILE))
|
|
self._learned = _load_learned(self._members_file)
|
|
self._players = []
|
|
self._groups = []
|
|
self._scanned_at = 0.0
|
|
threading.Thread(target=self._keep_warm, daemon=True).start()
|
|
|
|
def _keep_warm(self):
|
|
"""HEOS hangs up on idle connections; a heartbeat keeps the first
|
|
button press of the evening as quick as the second."""
|
|
while True:
|
|
time.sleep(240)
|
|
try:
|
|
self.heos.heart_beat()
|
|
except HeosError:
|
|
pass
|
|
|
|
# -- network picture -----------------------------------------------
|
|
def scan(self) -> dict:
|
|
"""Re-read every player and group, and remember what the rooms
|
|
are made of while we can see them."""
|
|
with self._lock:
|
|
self._players = self.heos.command("player/get_players").get("payload", [])
|
|
self._groups = self.heos.command("group/get_groups").get("payload", [])
|
|
self._scanned_at = time.monotonic()
|
|
self._learn_members()
|
|
return {"players": self._players, "groups": self._groups}
|
|
|
|
def _fresh(self, max_age: float = 2.0):
|
|
if time.monotonic() - self._scanned_at > max_age:
|
|
self.scan()
|
|
|
|
def _player_pid(self, name: str):
|
|
for player in self._players:
|
|
if player.get("name") == name:
|
|
return player.get("pid")
|
|
return None
|
|
|
|
def _group_named(self, name: str):
|
|
for group in self._groups:
|
|
if group.get("name") == name:
|
|
return group
|
|
return None
|
|
|
|
@staticmethod
|
|
def _ordered_pids(group: dict) -> list:
|
|
"""Member pids with the leader first -- HEOS makes the first pid
|
|
in a set_group call the leader, so the order is not cosmetic."""
|
|
players = group.get("players", [])
|
|
leaders = [p for p in players if p.get("role") == "leader"]
|
|
others = [p for p in players if p.get("role") != "leader"]
|
|
return [p.get("pid") for p in leaders + others]
|
|
|
|
def _learn_members(self):
|
|
"""Record what each room's group is made of whenever we catch it
|
|
standing on its own, so we can rebuild it after a merge."""
|
|
host_pid = self._host_pid()
|
|
changed = False
|
|
for key in self.cfg.ROOM_KEYS:
|
|
if "players" in self.cfg.TARGETS[key]:
|
|
continue # configured by hand, nothing to learn
|
|
group = self._group_named(self.cfg.TARGETS[key]["heos_name"])
|
|
if not group:
|
|
continue
|
|
pids = self._ordered_pids(group)
|
|
if host_pid in pids:
|
|
continue # currently merged with the AVR: not its own shape
|
|
if self._learned.get(key) != pids:
|
|
self._learned[key] = pids
|
|
changed = True
|
|
if changed:
|
|
_save_learned(self._members_file, self._learned)
|
|
|
|
# -- resolving rooms to pids ---------------------------------------
|
|
def _host_pid(self):
|
|
"""The AVR is always a plain player. Resolving it by player name
|
|
matters: once it leads a group, HEOS also reports a *group* under
|
|
the very same name."""
|
|
target = self.cfg.TARGETS[self.cfg.HOST_KEY]
|
|
pid = self._player_pid(target["heos_name"])
|
|
if pid is None:
|
|
raise TargetError(f"No HEOS player named '{target['heos_name']}' (the AVR) was found")
|
|
return pid
|
|
|
|
def member_pids(self, key: str) -> list:
|
|
"""Every player that makes up a room, leader first."""
|
|
if key not in self.cfg.TARGETS:
|
|
raise TargetError(f"Unknown room '{key}'")
|
|
if key == self.cfg.HOST_KEY:
|
|
return [self._host_pid()]
|
|
|
|
target = self.cfg.TARGETS[key]
|
|
name = target["heos_name"]
|
|
|
|
if "players" in target:
|
|
pids = []
|
|
for player_name in target["players"]:
|
|
pid = self._player_pid(player_name)
|
|
if pid is None:
|
|
raise TargetError(f"No HEOS player named '{player_name}' was found")
|
|
pids.append(pid)
|
|
return pids
|
|
|
|
# A group under this name wins over a player under the same name:
|
|
# a stereo pair is usually named after its left-hand speaker.
|
|
host_pid = self._host_pid()
|
|
group = self._group_named(name)
|
|
if group:
|
|
pids = self._ordered_pids(group)
|
|
if host_pid not in pids:
|
|
return pids
|
|
|
|
known = self._learned.get(key)
|
|
if known:
|
|
live = {p.get("pid") for p in self._players}
|
|
if all(pid in live for pid in known):
|
|
return known
|
|
|
|
pid = self._player_pid(name)
|
|
if pid is not None:
|
|
return [pid]
|
|
|
|
raise TargetError(
|
|
f"No HEOS player or group named '{name}' was found. "
|
|
f"Check GET /api/targets for the names HEOS actually reports."
|
|
)
|
|
|
|
# -- volume ---------------------------------------------------------
|
|
def _volume_handles(self, key: str) -> list:
|
|
"""Where volume for this room lives right now, as (scope, id).
|
|
|
|
A room that is its own HEOS group has a single group volume. Once
|
|
it is merged into the AVR's group that gid is gone, and the only
|
|
knobs left are the member players' own volumes.
|
|
"""
|
|
pids = self.member_pids(key)
|
|
if len(pids) > 1:
|
|
wanted = set(pids)
|
|
for group in self._groups:
|
|
if {p.get("pid") for p in group.get("players", [])} == wanted:
|
|
return [("group", group["gid"])]
|
|
return [("player", pid) for pid in pids]
|
|
|
|
@staticmethod
|
|
def _id_param(scope: str) -> str:
|
|
return "pid" if scope == "player" else "gid"
|
|
|
|
def _read_volume(self, scope, obj_id) -> int:
|
|
reply = self.heos.command(f"{scope}/get_volume", **{self._id_param(scope): obj_id})
|
|
return int(parse_message(reply["heos"]["message"]).get("level", -1))
|
|
|
|
def volume(self, key: str) -> int:
|
|
with self._lock:
|
|
self._fresh()
|
|
scope, obj_id = self._volume_handles(key)[0]
|
|
return self._read_volume(scope, obj_id)
|
|
|
|
def set_volume(self, key: str, level: int) -> int:
|
|
level = max(0, min(100, int(level)))
|
|
with self._lock:
|
|
self._fresh()
|
|
for scope, obj_id in self._volume_handles(key):
|
|
self.heos.command(
|
|
f"{scope}/set_volume", **{self._id_param(scope): obj_id}, level=level
|
|
)
|
|
return level
|
|
|
|
def nudge_volume(self, key: str, delta: int) -> int:
|
|
"""Move volume by delta and report where it landed.
|
|
|
|
Absolute rather than HEOS's own volume_up/down, because the UI
|
|
coalesces a fast burst of taps into one call and volume_up caps
|
|
its step at 10.
|
|
"""
|
|
with self._lock:
|
|
self._fresh()
|
|
handles = self._volume_handles(key)
|
|
current = self._read_volume(*handles[0])
|
|
level = max(0, min(100, current + int(delta)))
|
|
for scope, obj_id in handles:
|
|
self.heos.command(
|
|
f"{scope}/set_volume", **{self._id_param(scope): obj_id}, level=level
|
|
)
|
|
return level
|
|
|
|
def step_volume(self, key: str, steps: int) -> int:
|
|
"""Move by whole taps, landing on multiples of VOLUME_STEP.
|
|
|
|
Counted in taps rather than points so the speakers' own level is
|
|
what gets rounded, even when the phone's copy of it is a few
|
|
seconds stale.
|
|
"""
|
|
with self._lock:
|
|
self._fresh()
|
|
handles = self._volume_handles(key)
|
|
level = stepped_level(
|
|
self._read_volume(*handles[0]), int(steps), self.cfg.VOLUME_STEP
|
|
)
|
|
for scope, obj_id in handles:
|
|
self.heos.command(
|
|
f"{scope}/set_volume", **{self._id_param(scope): obj_id}, level=level
|
|
)
|
|
return level
|
|
|
|
def toggle_mute(self, key: str):
|
|
with self._lock:
|
|
self._fresh()
|
|
for scope, obj_id in self._volume_handles(key):
|
|
self.heos.command(f"{scope}/toggle_mute", **{self._id_param(scope): obj_id})
|
|
|
|
# -- grouping --------------------------------------------------------
|
|
def _host_group_pids(self) -> set:
|
|
"""Every pid currently in the AVR's group (empty if it is alone)."""
|
|
host_pid = self._host_pid()
|
|
for group in self._groups:
|
|
pids = {p.get("pid") for p in group.get("players", [])}
|
|
if host_pid in pids and len(pids) > 1:
|
|
return pids
|
|
return set()
|
|
|
|
def joined_keys(self) -> list:
|
|
joined, host_pids = [], self._host_group_pids()
|
|
for key in self.cfg.ROOM_KEYS:
|
|
try:
|
|
if host_pids & set(self.member_pids(key)):
|
|
joined.append(key)
|
|
except TargetError:
|
|
continue
|
|
return joined
|
|
|
|
def group_targets(self, host_key: str, member_keys: list) -> list:
|
|
"""One set_group call: the host's pid first -- that is what makes it
|
|
the leader whose content everyone else plays -- then every member
|
|
pid of every room listed."""
|
|
with self._lock:
|
|
self._fresh()
|
|
pids = list(self.member_pids(host_key))
|
|
for key in member_keys:
|
|
pids.extend(self.member_pids(key))
|
|
self.heos.command("group/set_group", pid=",".join(str(p) for p in pids))
|
|
return pids
|
|
|
|
def ungroup(self, key: str) -> list:
|
|
"""Stand a room back up on its own. For the Home 200 pair this
|
|
re-forms the pair rather than leaving two lone speakers behind."""
|
|
with self._lock:
|
|
self._fresh()
|
|
pids = self.member_pids(key)
|
|
self.heos.command("group/set_group", pid=",".join(str(p) for p in pids))
|
|
return pids
|
|
|
|
def join(self, key: str) -> list:
|
|
"""Add a room to the AVR's group. set_group replaces a group
|
|
wholesale, so the call has to name everyone who is already in it
|
|
as well as the newcomer."""
|
|
with self._lock:
|
|
self.scan()
|
|
wanted = set(self.joined_keys()) | {key}
|
|
self.group_targets(self.cfg.HOST_KEY, [k for k in self.cfg.ROOM_KEYS if k in wanted])
|
|
self.scan()
|
|
self._nudge_avr_input()
|
|
return self.joined_keys()
|
|
|
|
def _nudge_avr_input(self):
|
|
"""A room that has just joined the AVR's group sometimes stays
|
|
silent on it until the AVR's input is reselected -- but that has to
|
|
happen the way the HEOS app does it (browse/play_input, over HEOS
|
|
itself) to actually push audio to the new member. Re-issuing the
|
|
input over the AVR's own Telnet port does not: that just tells the
|
|
AVR which of its jacks to listen to, it says nothing to HEOS about
|
|
who should be streaming it. Best-effort: a join has already
|
|
succeeded by the time this runs, so a HEOS hiccup here should not
|
|
turn it into a failure."""
|
|
try:
|
|
current = self.avr_current_input()
|
|
if current:
|
|
self.play_heos_input(self.cfg.HOST_KEY, current["code"])
|
|
except HeosError:
|
|
pass
|
|
|
|
def leave(self, key: str) -> list:
|
|
"""Remove one room. Deliberately does not rewrite the AVR's group:
|
|
whatever is still joined keeps playing without a hiccup."""
|
|
with self._lock:
|
|
self.scan()
|
|
if key in self.joined_keys():
|
|
self.ungroup(key)
|
|
self.scan()
|
|
return self.joined_keys()
|
|
|
|
def set_membership(self, joined: list) -> list:
|
|
"""Make the AVR's group contain exactly these rooms and no others."""
|
|
with self._lock:
|
|
self.scan()
|
|
wanted = [k for k in self.cfg.ROOM_KEYS if k in joined]
|
|
for key in list(self.joined_keys()):
|
|
if key not in wanted:
|
|
self.ungroup(key)
|
|
if wanted:
|
|
self.group_targets(self.cfg.HOST_KEY, wanted)
|
|
self.scan()
|
|
return self.joined_keys()
|
|
|
|
# -- playback (kept for the original bridge's API) --------------------
|
|
def playback_pid(self, key: str):
|
|
return self.member_pids(key)[0]
|
|
|
|
def play_state(self, key: str, state: str):
|
|
with self._lock:
|
|
self._fresh()
|
|
self.heos.command("player/set_play_state", pid=self.playback_pid(key), state=state)
|
|
|
|
def get_play_state(self, key: str) -> str:
|
|
""""play", "pause" or "stop" for whatever this room is doing."""
|
|
with self._lock:
|
|
self._fresh()
|
|
reply = self.heos.command("player/get_play_state", pid=self.playback_pid(key))
|
|
return parse_message(reply["heos"]["message"]).get("state", "stop")
|
|
|
|
def toggle_play(self, key: str, state: str = None) -> str:
|
|
"""Start or stop a room. With no state, flips whatever it is doing
|
|
now -- read from the speakers rather than trusted from the phone,
|
|
whose copy can be a few seconds old.
|
|
|
|
A room that is grouped shares the AVR's transport, so this stops the
|
|
whole group. That is HEOS's doing, not ours: a group has one thing
|
|
playing, by definition.
|
|
"""
|
|
with self._lock:
|
|
self._fresh()
|
|
if state is None:
|
|
state = "pause" if self.get_play_state(key) == "play" else "play"
|
|
self.heos.command(
|
|
"player/set_play_state", pid=self.playback_pid(key), state=state
|
|
)
|
|
return state
|
|
|
|
def skip(self, key: str, direction: str):
|
|
with self._lock:
|
|
self._fresh()
|
|
command = "play_next" if direction == "next" else "play_previous"
|
|
self.heos.command(f"player/{command}", pid=self.playback_pid(key))
|
|
|
|
def heos_inputs(self, key: str) -> list:
|
|
"""A player's physical inputs, as HEOS itself lists them -- under
|
|
whatever names you gave them in the AVR's own setup menu. HEOS
|
|
carries those renamed labels, not just its generic ids, so this is
|
|
the same list the HEOS app itself shows under Sources."""
|
|
with self._lock:
|
|
self._fresh()
|
|
reply = self.heos.command("browse/browse", sid=self.playback_pid(key))
|
|
return [{"name": i.get("name"), "input_id": i.get("mid")} for i in reply.get("payload", [])]
|
|
|
|
def play_heos_input(self, key: str, input_id: str, source_key: str = None):
|
|
with self._lock:
|
|
self._fresh()
|
|
params = {"pid": self.playback_pid(key), "input": input_id}
|
|
if source_key:
|
|
params["spid"] = self.playback_pid(source_key)
|
|
self.heos.command("browse/play_input", **params)
|
|
|
|
# -- the AVR's inputs, all of it over HEOS ------------------------------
|
|
def avr_connected(self) -> bool:
|
|
with self._lock:
|
|
self._fresh()
|
|
try:
|
|
self._host_pid()
|
|
return True
|
|
except TargetError:
|
|
return False
|
|
|
|
def avr_inputs(self) -> list:
|
|
"""{"code", "name"} pairs for the picker -- heos_inputs()'s shape,
|
|
renamed to match what the UI and /api/avr/* already send and
|
|
expect. Narrowed and ordered by AVR_INPUT_CODES, same as before,
|
|
except the codes it matches are now HEOS's own ("inputs/aux_in_1"),
|
|
not the AVR's Telnet ones ("AUX1")."""
|
|
sources = self.heos_inputs(self.cfg.HOST_KEY)
|
|
codes = getattr(self.cfg, "AVR_INPUT_CODES", None)
|
|
if codes:
|
|
order = {code: i for i, code in enumerate(codes)}
|
|
sources = sorted(
|
|
(s for s in sources if s["input_id"] in order),
|
|
key=lambda s: order[s["input_id"]],
|
|
)
|
|
return [{"code": s["input_id"], "name": s["name"]} for s in sources]
|
|
|
|
def avr_current_input(self):
|
|
"""{"code", "name"} for whatever the AVR is playing right now, or
|
|
None if that is not a local input (or the AVR is unreachable)."""
|
|
with self._lock:
|
|
self._fresh()
|
|
try:
|
|
reply = self.heos.command(
|
|
"player/get_now_playing_media", pid=self._host_pid()
|
|
)
|
|
except (TargetError, HeosError):
|
|
return None
|
|
payload = reply.get("payload") or {}
|
|
mid = payload.get("mid", "")
|
|
if not mid.startswith("inputs/"):
|
|
return None
|
|
return {"code": mid, "name": payload.get("station") or payload.get("song") or mid}
|
|
|
|
def avr_select_input(self, code: str) -> dict:
|
|
self.play_heos_input(self.cfg.HOST_KEY, code)
|
|
name = next((s["name"] for s in self.avr_inputs() if s["code"] == code), code)
|
|
return {"code": code, "name": name}
|
|
|
|
# -- one snapshot for the UI ------------------------------------------
|
|
def state(self) -> dict:
|
|
snapshot = {
|
|
"host": {"key": self.cfg.HOST_KEY, "label": self.cfg.TARGETS[self.cfg.HOST_KEY]["label"]},
|
|
"rooms": [],
|
|
"avr": {"connected": False, "input": None, "inputs": []},
|
|
"heos_ok": True,
|
|
"errors": [],
|
|
}
|
|
|
|
with self._lock:
|
|
try:
|
|
self.scan()
|
|
joined = set(self.joined_keys())
|
|
for key in self.cfg.ROOM_KEYS:
|
|
room = {
|
|
"key": key,
|
|
"label": self.cfg.TARGETS[key]["label"],
|
|
"available": True,
|
|
"grouped": key in joined,
|
|
"volume": None,
|
|
"play_state": None,
|
|
"error": None,
|
|
}
|
|
try:
|
|
scope, obj_id = self._volume_handles(key)[0]
|
|
room["volume"] = self._read_volume(scope, obj_id)
|
|
room["play_state"] = self.get_play_state(key)
|
|
except (TargetError, HeosError, KeyError) as exc:
|
|
room["available"] = False
|
|
room["error"] = str(exc)
|
|
snapshot["rooms"].append(room)
|
|
except (HeosError, TargetError) as exc:
|
|
snapshot["heos_ok"] = False
|
|
snapshot["errors"].append(str(exc))
|
|
snapshot["rooms"] = [
|
|
{"key": key, "label": self.cfg.TARGETS[key]["label"], "available": False,
|
|
"grouped": False, "volume": None, "play_state": None, "error": str(exc)}
|
|
for key in self.cfg.ROOM_KEYS
|
|
]
|
|
|
|
try:
|
|
snapshot["avr"] = {
|
|
"connected": self.avr_connected(),
|
|
"inputs": self.avr_inputs(),
|
|
"input": self.avr_current_input(),
|
|
}
|
|
except (HeosError, TargetError) as exc:
|
|
snapshot["errors"].append(str(exc))
|
|
|
|
return snapshot
|
|
|
|
|
|
def _load_learned(path: Path) -> dict:
|
|
try:
|
|
return json.loads(path.read_text())
|
|
except (OSError, ValueError):
|
|
return {}
|
|
|
|
|
|
def _save_learned(path: Path, data: dict):
|
|
try:
|
|
path.write_text(json.dumps(data, indent=2))
|
|
except OSError:
|
|
pass # a read-only checkout just means we re-learn next time
|