v0.60.0: cliairplay fallback; rounded playlist frame; empty art is a button on hover; no black in the art window
AirPlay: when LinTunes' own sender can't connect (or airplay_backend is "cli"), Music Assistant's cliairplay is downloaded once, refused unless its SHA-256 matches the pinned one, and streamed through. The playlist list gets the panels' 8 px corners. The empty album-art panel pops up as a plain button under the cursor and sinks darker while held. The big art window keeps the art's shape after a resize and paints the art to cover, so it never shows a background.
This commit is contained in:
@@ -198,6 +198,16 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal
|
||||
(right: previous/next style, wrapping) — hit-tested on release. No
|
||||
double-click. Both big windows (visualizer, album art) close on a click
|
||||
or Esc.
|
||||
The playlist list's frame is a `sidebar.RoundedFrame` (Round 91): the
|
||||
panels' 8 px corners, painted *over* the list by a mouse-transparent
|
||||
overlay (window color outside the curve, then Fusion's own frame line,
|
||||
`frame_color`), since a mask would be jagged. The empty art panel is a
|
||||
button (click = download art) that only looks like one under the
|
||||
cursor: embossed in the Library button's face on hover, sunk and darker
|
||||
while held. The big art window has **no background**: it is snapped
|
||||
back to the art's shape after a resize (`art_window.reshaped`, the
|
||||
dimension the user dragged leads) and paints the art to *cover*, so a
|
||||
shape it can't take (maximized) crops a sliver instead of showing a bar.
|
||||
The library search box filters the sidebar too (Round 89):
|
||||
`LibraryView.search_changed` → `PlaylistTree.set_filter`, same rule as
|
||||
the songs (every word, case-folded, in the name); a folder shows when its
|
||||
@@ -873,7 +883,16 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal
|
||||
the WiiM. `use_compat`: config.json's `airplay_protocol` "auto" = the
|
||||
native sender for everything but Apple's own hardware (a HomePod is
|
||||
AirPlay 2 only), "1" = native everywhere, "2" = pyatv's AirPlay 2;
|
||||
`airplay_latency_ms` overrides the 2 s. `airplay_debug` puts pyatv's and
|
||||
`airplay_latency_ms` overrides the 2 s. **cliairplay is the fallback**
|
||||
(Round 91, trav's go-ahead): when the native sender can't connect, or
|
||||
config.json's `airplay_backend` is `"cli"` (`"native"` = never fall
|
||||
back), `cli.ensure_binary` downloads Music Assistant's pinned release
|
||||
into `$XDG_DATA_HOME/lintunes/bin/` once and **refuses it unless its
|
||||
SHA-256 matches** the one pinned in `cli.py` — then `CliAirPlaySink`
|
||||
runs ffmpeg → cliairplay per stretch of playback (commands on a fifo,
|
||||
`[STATUS]` lines back on stderr; `started at_unix_ms` / `playing
|
||||
elapsed_ms` give the position). Bumping its version means new pinned
|
||||
hashes from that release's SHA256SUMS. `airplay_debug` puts pyatv's and
|
||||
`lintunes.airplay.raop`'s loggers at DEBUG (every RTSP request); every
|
||||
stream's start, first audio and outcome are logged at INFO under
|
||||
`lintunes.airplay`, and the chosen sender in the control log.
|
||||
|
||||
@@ -1,3 +1,3 @@
|
||||
"""LinTunes — iTunes-style music library manager and player for Linux."""
|
||||
|
||||
__version__ = "0.59.0"
|
||||
__version__ = "0.60.0"
|
||||
|
||||
@@ -0,0 +1,217 @@
|
||||
"""cliairplay: Music Assistant's AirPlay sender, run as a helper process.
|
||||
|
||||
pyatv's own stream is accepted by a WiiM (Linkplay) speaker — every request
|
||||
answered 200, timing exchanged, volume set — and nothing comes out, in AirPlay
|
||||
1 and 2 alike (Round 88). cliairplay, the same speaker, plays. So it streams
|
||||
for LinTunes wherever it runs, and pyatv stays for discovery (and as the
|
||||
fallback where the helper can't be had).
|
||||
|
||||
The binary is never committed or pip-installed: it is downloaded once, from
|
||||
the release pinned here, and checked against the release's SHA-256 before it
|
||||
is ever run (the yt-dlp/fpcalc "runtime tool" rule, minus the package
|
||||
manager, since no distribution ships it). GPL-3.0, and run as a separate
|
||||
process — LinTunes only talks to it: audio as raw PCM on stdin, commands on a
|
||||
named pipe, `[STATUS]` lines back on stderr.
|
||||
|
||||
Everything here is pure or plain file/network I/O, no Qt.
|
||||
"""
|
||||
|
||||
import contextlib
|
||||
import hashlib
|
||||
import os
|
||||
import platform
|
||||
import re
|
||||
import secrets
|
||||
import tempfile
|
||||
import urllib.request
|
||||
from pathlib import Path
|
||||
|
||||
VERSION = "0.5.4"
|
||||
_RELEASE = ("https://github.com/music-assistant/airplay-cli/releases/download/"
|
||||
f"v{VERSION}/")
|
||||
# From the release's SHA256SUMS.
|
||||
_SHA256 = {
|
||||
"x86_64": "1ac56a15fb548f07a1dae94be16d4bea308420a0ec0cd04238023e44345fc1c9",
|
||||
"aarch64": "1ce9160a8a9abb1b2263dfbf5ed59551dd1205b2336a024e9e33c903c201a310",
|
||||
}
|
||||
_ARCH_ALIASES = {"amd64": "x86_64", "arm64": "aarch64"}
|
||||
|
||||
DOWNLOAD_TIMEOUT_S = 60
|
||||
|
||||
|
||||
class CliUnavailable(RuntimeError):
|
||||
"""The helper can't be had here (platform, network, checksum)."""
|
||||
|
||||
|
||||
def _arch() -> str | None:
|
||||
if platform.system() != "Linux":
|
||||
return None
|
||||
machine = platform.machine().lower()
|
||||
machine = _ARCH_ALIASES.get(machine, machine)
|
||||
return machine if machine in _SHA256 else None
|
||||
|
||||
|
||||
def binary_dir() -> Path:
|
||||
"""Machine-local: a binary for this CPU, never the synced data dir."""
|
||||
base = os.environ.get("XDG_DATA_HOME") or os.path.expanduser(
|
||||
"~/.local/share")
|
||||
return Path(base) / "lintunes" / "bin"
|
||||
|
||||
|
||||
def binary_path() -> Path | None:
|
||||
arch = _arch()
|
||||
if arch is None:
|
||||
return None
|
||||
return binary_dir() / f"cliairplay-{VERSION}-{arch}"
|
||||
|
||||
|
||||
def supported() -> bool:
|
||||
return _arch() is not None
|
||||
|
||||
|
||||
def installed() -> Path | None:
|
||||
"""The verified binary, if it's already on disk."""
|
||||
path = binary_path()
|
||||
if path is not None and path.is_file() and os.access(path, os.X_OK):
|
||||
return path
|
||||
return None
|
||||
|
||||
|
||||
def _sha256(data: bytes) -> str:
|
||||
return hashlib.sha256(data).hexdigest()
|
||||
|
||||
|
||||
def ensure_binary(fetch=None) -> Path:
|
||||
"""The helper's path, downloading and verifying it first if needed.
|
||||
|
||||
Blocking (a few MB): callers run it off the GUI thread. `fetch(url)`
|
||||
returns the bytes; it's injectable so tests never touch the network.
|
||||
"""
|
||||
path = installed()
|
||||
if path is not None:
|
||||
return path
|
||||
arch = _arch()
|
||||
if arch is None:
|
||||
raise CliUnavailable(
|
||||
f"no AirPlay helper for {platform.system()} {platform.machine()}")
|
||||
fetch = fetch or _fetch
|
||||
name = f"cliairplay-linux-{arch}"
|
||||
try:
|
||||
data = fetch(_RELEASE + name)
|
||||
except Exception as e: # noqa: BLE001 — reported, not raised raw
|
||||
raise CliUnavailable(f"couldn't download the AirPlay helper ({e})")
|
||||
if _sha256(data) != _SHA256[arch]:
|
||||
raise CliUnavailable("the downloaded AirPlay helper failed its checksum")
|
||||
path = binary_path()
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
fd, tmp = tempfile.mkstemp(dir=path.parent, prefix=".cliairplay-")
|
||||
try:
|
||||
with os.fdopen(fd, "wb") as out:
|
||||
out.write(data)
|
||||
os.chmod(tmp, 0o755)
|
||||
os.replace(tmp, path)
|
||||
except BaseException:
|
||||
with contextlib.suppress(OSError):
|
||||
os.unlink(tmp)
|
||||
raise
|
||||
return path
|
||||
|
||||
|
||||
def _fetch(url: str) -> bytes:
|
||||
with urllib.request.urlopen(url, timeout=DOWNLOAD_TIMEOUT_S) as response:
|
||||
return response.read()
|
||||
|
||||
|
||||
# ---- the command line ----
|
||||
|
||||
# RAOP TXT keys the binary takes as their own flags (Music Assistant's set).
|
||||
_RAOP_FLAGS = ("et", "md", "am", "pk", "pw", "cn")
|
||||
|
||||
|
||||
def txt_blob(properties: dict) -> str:
|
||||
"""The `_airplay._tcp` TXT as cliairplay's --txt: space-separated
|
||||
key=value, skipping pairs with whitespace (the binary splits on spaces)."""
|
||||
pairs = []
|
||||
for key, value in (properties or {}).items():
|
||||
if value is None:
|
||||
continue
|
||||
key, value = str(key), str(value)
|
||||
if any(c.isspace() for c in key + value):
|
||||
continue
|
||||
pairs.append(f"{key}={value}")
|
||||
return " ".join(pairs)
|
||||
|
||||
|
||||
def protocol_arg(choice: str) -> str:
|
||||
"""config.json's `airplay_protocol` → cliairplay's --protocol. "auto"
|
||||
lets the binary pick from the TXT, as Music Assistant does."""
|
||||
return {"1": "airplay2-compat", "2": "airplay2"}.get(choice, "auto")
|
||||
|
||||
|
||||
def build_args(binary: str, host: str, port: int, raop: dict, airplay: dict,
|
||||
pipe: str, volume: float, choice: str = "auto",
|
||||
name: str = "") -> list[str]:
|
||||
"""argv for one stream. `raop`/`airplay` are the TXT properties of the
|
||||
device's _raop._tcp and _airplay._tcp services ({} when absent)."""
|
||||
args = [binary, "--protocol", protocol_arg(choice),
|
||||
"--dacp", secrets.token_hex(8).upper(),
|
||||
"--activeremote", str(secrets.randbelow(2**32)),
|
||||
"--cmdpipe", pipe,
|
||||
"--samplerate", "44100", "--bitdepth", "16",
|
||||
"--port", str(port),
|
||||
"--volume", str(round(max(0.0, min(100.0, volume)))),
|
||||
"--debug", "1"]
|
||||
for key in _RAOP_FLAGS:
|
||||
value = (raop or {}).get(key)
|
||||
if value:
|
||||
args += [f"--{key}", str(value)]
|
||||
# Some receivers (the WiiM) advertise their AirPlay 2 feature bits only on
|
||||
# _raop's `ft`; route selection reads them from --txt either way.
|
||||
txt = dict(airplay or {})
|
||||
if not (txt.get("features") or txt.get("ft")) and (raop or {}).get("ft"):
|
||||
txt["ft"] = raop["ft"]
|
||||
blob = txt_blob(txt)
|
||||
if blob:
|
||||
args += ["--txt", blob]
|
||||
if name and airplay:
|
||||
args += ["--name", name]
|
||||
return args + [host]
|
||||
|
||||
|
||||
# ---- what it says ----
|
||||
|
||||
_STATUS = re.compile(r"^\[STATUS\]\s+(\w+)\s*(.*)$")
|
||||
_FIELD = re.compile(r'(\w+)=("([^"]*)"|\S+)')
|
||||
|
||||
|
||||
def parse_status(line: str) -> tuple[str, dict] | None:
|
||||
"""`[STATUS] playing elapsed_ms=1203` → ("playing", {"elapsed_ms": "1203"}).
|
||||
Anything that isn't a status line is None."""
|
||||
match = _STATUS.match(line.strip())
|
||||
if match is None:
|
||||
return None
|
||||
fields = {}
|
||||
for key, raw, quoted in _FIELD.findall(match.group(2)):
|
||||
fields[key] = quoted if raw.startswith('"') else raw
|
||||
return match.group(1), fields
|
||||
|
||||
|
||||
def metadata_command(title: str, artist: str, album: str, duration_s: int,
|
||||
artwork_file: str | None = None) -> str:
|
||||
"""Now-playing for the receiver. Newlines would end a field early."""
|
||||
def clean(value):
|
||||
return " ".join(str(value or "").split())
|
||||
lines = [f"TITLE={clean(title)}", f"ARTIST={clean(artist)}",
|
||||
f"ALBUM={clean(album)}", f"DURATION={max(0, int(duration_s))}"]
|
||||
if artwork_file:
|
||||
lines.append(f"ARTWORKFILE={artwork_file}")
|
||||
lines.append("ACTION=SENDMETA")
|
||||
return "\n".join(lines) + "\n"
|
||||
|
||||
|
||||
def start_command(at_unix_ms: int) -> str:
|
||||
return f"START_UNIX_MS={int(at_unix_ms)}\nACTION=START\n"
|
||||
|
||||
|
||||
def volume_command(percent: float) -> str:
|
||||
return f"VOLUME={round(max(0.0, min(100.0, percent)))}\n"
|
||||
@@ -0,0 +1,453 @@
|
||||
"""The Player sink that plays through an AirPlay speaker via cliairplay.
|
||||
|
||||
Same contract as sink.AirPlaySink — one stream per stretch of playback, a
|
||||
generation per stream so a replaced one can't advance the queue — but each
|
||||
stream is two processes: ffmpeg decoding the song from the position (s16le
|
||||
on its stdout) straight into cliairplay's stdin, and cliairplay talking to
|
||||
the speaker. A daemon thread per stream owns both, writes the command pipe
|
||||
and reads `[STATUS]` lines; what it learns comes back as Qt signals.
|
||||
|
||||
What the statuses mean (measured against shairport-sync, and the WiiM):
|
||||
`connected` → send the now-playing and START; `started at_unix_ms=` is when
|
||||
the first sample is *heard*, and `playing elapsed_ms=` (about once a second)
|
||||
how far the listener is since then — so position needs no latency guess.
|
||||
`eof` comes when the song has played out (stopping right then cut nothing),
|
||||
and the binary then holds the session until told ACTION=STOP.
|
||||
"""
|
||||
|
||||
import logging
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import threading
|
||||
import time
|
||||
|
||||
from PyQt6.QtCore import QTimer, pyqtSignal
|
||||
from PyQt6.QtMultimedia import QAudio
|
||||
|
||||
from lintunes import tagging
|
||||
from lintunes.airplay import cli
|
||||
from lintunes.airplay.sink import (
|
||||
DECODE_ERROR, DROPPED, FAILED, FINISHED, jpeg_artwork)
|
||||
from lintunes.airplay.support import (
|
||||
can_stream, ffmpeg_command, level_to_percent, unstreamable_reason)
|
||||
from lintunes.player import PlaybackSink
|
||||
|
||||
log = logging.getLogger("lintunes.airplay")
|
||||
|
||||
CONNECT_TIMEOUT_S = 15.0
|
||||
STOP_GRACE_S = 1.0
|
||||
START_LEAD_MS = 300
|
||||
|
||||
|
||||
def now_ms() -> int:
|
||||
return int(time.time() * 1000)
|
||||
|
||||
|
||||
class CliStream:
|
||||
"""One song from one position, on its own thread. Never touches Qt:
|
||||
`report(kind, fields)` and `ended(outcome, detail)` are called from the
|
||||
thread and must be thread-safe (the sink passes signal emits)."""
|
||||
|
||||
def __init__(self, binary, target: dict, path: str, start_ms: int,
|
||||
volume: float, metadata: str, report, ended, workdir: str):
|
||||
self.binary = str(binary)
|
||||
self.target = target
|
||||
self.path = path
|
||||
self.start_ms = start_ms
|
||||
self.volume = volume
|
||||
self.metadata = metadata
|
||||
self._report = report
|
||||
self._ended = ended
|
||||
self._workdir = workdir
|
||||
self._stop = threading.Event()
|
||||
self._connected = threading.Event()
|
||||
self._eof = threading.Event()
|
||||
self._lock = threading.Lock()
|
||||
self._pipe = None # the command pipe, once open
|
||||
self._error = ""
|
||||
self._last_line = ""
|
||||
self.thread = threading.Thread(target=self._run, daemon=True,
|
||||
name="airplay-stream")
|
||||
|
||||
def start(self):
|
||||
self.thread.start()
|
||||
|
||||
def stop(self):
|
||||
"""Ask the stream to end; returns at once (the thread tears down)."""
|
||||
self._stop.set()
|
||||
|
||||
def send(self, command: str):
|
||||
"""A command for the binary; dropped if the pipe isn't open yet."""
|
||||
with self._lock:
|
||||
if self._pipe is None:
|
||||
return False
|
||||
try:
|
||||
os.write(self._pipe, command.encode())
|
||||
return True
|
||||
except OSError:
|
||||
return False
|
||||
|
||||
# ---- the thread ----
|
||||
|
||||
def _run(self):
|
||||
fifo = os.path.join(self._workdir, f"cmd-{id(self)}.pipe")
|
||||
decoder = player = None
|
||||
try:
|
||||
os.mkfifo(fifo)
|
||||
decoder = subprocess.Popen(
|
||||
ffmpeg_command(self.path, self.start_ms, 44100, 2, 2,
|
||||
big_endian=False),
|
||||
stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE)
|
||||
t = self.target
|
||||
player = subprocess.Popen(
|
||||
cli.build_args(self.binary, t["host"], t["port"], t["raop"],
|
||||
t["airplay"], fifo, self.volume,
|
||||
t.get("choice", "auto"), t.get("name", "")),
|
||||
stdin=decoder.stdout, stdout=subprocess.DEVNULL,
|
||||
stderr=subprocess.PIPE, text=True, errors="replace")
|
||||
decoder.stdout.close() # the binary holds the only read end
|
||||
reader = threading.Thread(target=self._read, args=(player,),
|
||||
daemon=True)
|
||||
reader.start()
|
||||
outcome, detail = self._drive(player, decoder, fifo)
|
||||
except Exception as e: # noqa: BLE001 — reported, never raised
|
||||
outcome, detail = FAILED, str(e) or type(e).__name__
|
||||
finally:
|
||||
self._teardown(player, decoder, fifo)
|
||||
self._ended(outcome, detail)
|
||||
|
||||
def _drive(self, player, decoder, fifo):
|
||||
deadline = time.monotonic() + CONNECT_TIMEOUT_S
|
||||
while not self._connected.wait(0.05):
|
||||
if self._stop.is_set():
|
||||
return None, ""
|
||||
if player.poll() is not None:
|
||||
return FAILED, self._error or self._last_line or "it closed"
|
||||
if time.monotonic() > deadline:
|
||||
return FAILED, "it didn't answer"
|
||||
self._open_pipe(fifo, player)
|
||||
if self.metadata:
|
||||
self.send(self.metadata)
|
||||
self.send(cli.start_command(now_ms() + START_LEAD_MS))
|
||||
while not self._stop.is_set():
|
||||
if self._eof.wait(0.1):
|
||||
code = decoder.wait()
|
||||
if code != 0 and not self._heard_any:
|
||||
message = decoder.stderr.read().decode(
|
||||
errors="replace").strip().splitlines()
|
||||
return DECODE_ERROR, (message[-1] if message
|
||||
else f"ffmpeg exited with {code}")
|
||||
return FINISHED, ""
|
||||
if player.poll() is not None:
|
||||
return DROPPED, self._error or self._last_line
|
||||
return None, ""
|
||||
|
||||
_heard_any = False
|
||||
|
||||
def _open_pipe(self, fifo, player):
|
||||
"""The binary opens its end once connected; never block on it."""
|
||||
while not self._stop.is_set() and player.poll() is None:
|
||||
try:
|
||||
fd = os.open(fifo, os.O_WRONLY | os.O_NONBLOCK)
|
||||
except OSError:
|
||||
time.sleep(0.02)
|
||||
continue
|
||||
os.set_blocking(fd, True)
|
||||
with self._lock:
|
||||
self._pipe = fd
|
||||
return
|
||||
|
||||
def _read(self, player):
|
||||
for line in player.stderr:
|
||||
line = line.rstrip()
|
||||
if not line:
|
||||
continue
|
||||
parsed = cli.parse_status(line)
|
||||
if parsed is None:
|
||||
if "rror" in line:
|
||||
self._last_line = line
|
||||
continue
|
||||
kind, fields = parsed
|
||||
if kind == "connected":
|
||||
self._connected.set()
|
||||
elif kind == "eof":
|
||||
self._eof.set()
|
||||
elif kind == "playing":
|
||||
self._heard_any = True
|
||||
elif kind == "error":
|
||||
self._error = fields.get("detail") or fields.get("code", "")
|
||||
if kind in ("started", "playing", "connected", "error"):
|
||||
self._report(kind, fields)
|
||||
|
||||
def _teardown(self, player, decoder, fifo):
|
||||
if player is not None and player.poll() is None:
|
||||
self.send("ACTION=STOP\n")
|
||||
try:
|
||||
player.wait(STOP_GRACE_S)
|
||||
except subprocess.TimeoutExpired:
|
||||
player.terminate()
|
||||
try:
|
||||
player.wait(STOP_GRACE_S)
|
||||
except subprocess.TimeoutExpired:
|
||||
player.kill()
|
||||
if decoder is not None and decoder.poll() is None:
|
||||
decoder.kill()
|
||||
with self._lock:
|
||||
fd, self._pipe = self._pipe, None
|
||||
if fd is not None:
|
||||
try:
|
||||
os.close(fd)
|
||||
except OSError:
|
||||
pass
|
||||
try:
|
||||
os.unlink(fifo)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
|
||||
class CliAirPlaySink(PlaybackSink):
|
||||
"""Streams to an AirPlay receiver through cliairplay."""
|
||||
|
||||
provides_pcm = False
|
||||
glyph = "airplay"
|
||||
listen_src = "airplay"
|
||||
|
||||
POLL_MS = 250
|
||||
VOLUME_COALESCE_MS = 120
|
||||
STOP_TIMEOUT_S = 3.0
|
||||
|
||||
_status = pyqtSignal(int, str, object) # generation, kind, fields
|
||||
_stream_ended = pyqtSignal(int, str, str) # generation, outcome, detail
|
||||
|
||||
stream_class = CliStream # tests swap in a fake
|
||||
|
||||
def __init__(self, binary, target: dict, name: str, parent=None):
|
||||
super().__init__(parent)
|
||||
self._binary = binary
|
||||
self._target = dict(target, name=name)
|
||||
self.name = name or "AirPlay"
|
||||
self._workdir = tempfile.mkdtemp(prefix="lintunes-airplay-")
|
||||
self._track = None
|
||||
self._metadata = ""
|
||||
self._stream: CliStream | None = None
|
||||
self._generation = 0
|
||||
self._playing = False
|
||||
self._start_ms = 0
|
||||
self._anchor_ms: int | None = None # unix ms when start_ms is heard
|
||||
self._position_ms = 0
|
||||
self._duration_ms = 0
|
||||
self._percent = 0.0
|
||||
self._first_logged = False
|
||||
self._shutdown_done = False
|
||||
self._dying = False
|
||||
|
||||
self._status.connect(self._on_status)
|
||||
self._stream_ended.connect(self._on_stream_ended)
|
||||
self._poll = QTimer(self)
|
||||
self._poll.setInterval(self.POLL_MS)
|
||||
self._poll.timeout.connect(self._on_poll)
|
||||
self._volume_timer = QTimer(self)
|
||||
self._volume_timer.setSingleShot(True)
|
||||
self._volume_timer.setInterval(self.VOLUME_COALESCE_MS)
|
||||
self._volume_timer.timeout.connect(self._flush_volume)
|
||||
|
||||
# ---- PlaybackSink ----
|
||||
|
||||
def can_play(self, track) -> bool:
|
||||
return can_stream(track.location, track.kind)
|
||||
|
||||
def unplayable_reason(self, track) -> str:
|
||||
return unstreamable_reason(track.location, track.kind)
|
||||
|
||||
def load(self, track, autoplay: bool, start_ms: int):
|
||||
self._track = track
|
||||
self._duration_ms = track.total_time or 0
|
||||
self._metadata = cli.metadata_command(
|
||||
track.name, track.artist, track.album, self._duration_ms // 1000,
|
||||
self._artwork_file(track))
|
||||
self.duration_changed.emit(self._duration_ms)
|
||||
self._set_position(max(0, start_ms))
|
||||
if autoplay:
|
||||
self._start_stream(self._position_ms)
|
||||
else:
|
||||
self._halt_stream()
|
||||
self._set_playing(False)
|
||||
|
||||
def _artwork_file(self, track) -> str | None:
|
||||
try:
|
||||
data = jpeg_artwork(tagging.read_embedded_artwork(track.location))
|
||||
except Exception: # noqa: BLE001 — art is never worth a failure
|
||||
return None
|
||||
if not data:
|
||||
return None
|
||||
path = os.path.join(self._workdir, "cover.jpg")
|
||||
try:
|
||||
with open(path, "wb") as out:
|
||||
out.write(data)
|
||||
except OSError:
|
||||
return None
|
||||
return path
|
||||
|
||||
def play(self):
|
||||
if self._track is None or self._playing:
|
||||
return
|
||||
self._start_stream(self._position_ms)
|
||||
|
||||
def pause(self):
|
||||
self._freeze_position()
|
||||
self._halt_stream()
|
||||
self._set_playing(False)
|
||||
|
||||
def stop(self):
|
||||
self._freeze_position()
|
||||
self._halt_stream()
|
||||
self._set_playing(False)
|
||||
|
||||
def seek(self, position_ms: int):
|
||||
target = max(0, position_ms)
|
||||
if self._playing:
|
||||
self._start_stream(target)
|
||||
else:
|
||||
self._set_position(target)
|
||||
|
||||
def position_ms(self) -> int:
|
||||
return self._position_ms
|
||||
|
||||
def duration_ms(self) -> int:
|
||||
return self._duration_ms
|
||||
|
||||
def is_playing(self) -> bool:
|
||||
return self._playing
|
||||
|
||||
def set_volume(self, level: float):
|
||||
level = max(0.0, min(1.0, float(level)))
|
||||
linear = QAudio.convertVolume(
|
||||
level, QAudio.VolumeScale.LogarithmicVolumeScale,
|
||||
QAudio.VolumeScale.LinearVolumeScale)
|
||||
# cliairplay's 0–100 is pyatv's: linear across -30..0 dB.
|
||||
self._percent = level_to_percent(linear)
|
||||
self._volume_timer.start()
|
||||
|
||||
def shutdown(self):
|
||||
if self._shutdown_done:
|
||||
return
|
||||
self._shutdown_done = True
|
||||
self._poll.stop()
|
||||
self._volume_timer.stop()
|
||||
self._generation += 1
|
||||
stream, self._stream = self._stream, None
|
||||
if stream is not None:
|
||||
stream.stop()
|
||||
stream.thread.join(self.STOP_TIMEOUT_S)
|
||||
shutil.rmtree(self._workdir, ignore_errors=True)
|
||||
|
||||
# ---- streams ----
|
||||
|
||||
def _start_stream(self, start_ms: int):
|
||||
if self._shutdown_done or self._dying or self._track is None:
|
||||
return
|
||||
self._generation += 1
|
||||
generation = self._generation
|
||||
if self._stream is not None:
|
||||
self._stream.stop()
|
||||
log.info("stream %d: %s from %d ms (cliairplay)", generation,
|
||||
self._track.name or self._track.location, start_ms)
|
||||
self._start_ms = start_ms
|
||||
self._anchor_ms = None
|
||||
self._first_logged = False
|
||||
self._stream = self.stream_class(
|
||||
self._binary, self._target, self._track.location, start_ms,
|
||||
self._percent, self._metadata,
|
||||
lambda kind, fields: self._status.emit(generation, kind, fields),
|
||||
lambda outcome, detail: self._stream_ended.emit(
|
||||
generation, outcome or "", detail or ""),
|
||||
self._workdir)
|
||||
self._set_position(start_ms)
|
||||
self._set_playing(True)
|
||||
self._poll.start()
|
||||
self._stream.start()
|
||||
|
||||
def _halt_stream(self):
|
||||
self._generation += 1
|
||||
self._poll.stop()
|
||||
stream, self._stream = self._stream, None
|
||||
if stream is not None:
|
||||
stream.stop()
|
||||
|
||||
def _freeze_position(self):
|
||||
if self._stream is not None:
|
||||
self._set_position(self._heard())
|
||||
|
||||
def _heard(self) -> int:
|
||||
if self._anchor_ms is None:
|
||||
return self._start_ms
|
||||
played = max(0, now_ms() - self._anchor_ms)
|
||||
position = self._start_ms + played
|
||||
if self._duration_ms:
|
||||
position = min(position, self._duration_ms)
|
||||
return position
|
||||
|
||||
def _on_status(self, generation: int, kind: str, fields: dict):
|
||||
if generation != self._generation:
|
||||
return
|
||||
if kind == "started":
|
||||
try:
|
||||
self._anchor_ms = int(fields.get("at_unix_ms", 0)) or None
|
||||
except ValueError:
|
||||
self._anchor_ms = None
|
||||
elif kind == "playing":
|
||||
try:
|
||||
self._anchor_ms = now_ms() - int(fields.get("elapsed_ms", 0))
|
||||
except ValueError:
|
||||
pass
|
||||
if not self._first_logged:
|
||||
self._first_logged = True
|
||||
log.info("stream %d: playing", generation)
|
||||
|
||||
def _on_poll(self):
|
||||
if self._stream is not None:
|
||||
self._set_position(self._heard())
|
||||
|
||||
def _on_stream_ended(self, generation: int, outcome: str, detail: str):
|
||||
if outcome:
|
||||
log.info("stream %d ended: %s %s", generation, outcome, detail)
|
||||
if (generation != self._generation or self._shutdown_done
|
||||
or not outcome):
|
||||
return
|
||||
self._stream = None
|
||||
self._poll.stop()
|
||||
if outcome == FINISHED:
|
||||
self._set_position(self._duration_ms or self._position_ms)
|
||||
self._set_playing(False)
|
||||
self.ended.emit()
|
||||
elif outcome == DECODE_ERROR:
|
||||
self._set_playing(False)
|
||||
self.error.emit(f"it couldn't be decoded ({detail})")
|
||||
elif outcome == DROPPED:
|
||||
self._fail(f"{self.name} stopped playing — something else may "
|
||||
"have taken it over.")
|
||||
else:
|
||||
self._fail(f"Lost {self.name} ({detail}).")
|
||||
|
||||
def _fail(self, reason: str):
|
||||
if self._dying:
|
||||
return
|
||||
self._dying = True
|
||||
self._poll.stop()
|
||||
self.unavailable.emit(reason)
|
||||
|
||||
def _flush_volume(self):
|
||||
if self._stream is not None:
|
||||
self._stream.send(cli.volume_command(self._percent))
|
||||
|
||||
def _set_playing(self, playing: bool):
|
||||
if playing != self._playing:
|
||||
self._playing = playing
|
||||
self.state_changed.emit(playing)
|
||||
|
||||
def _set_position(self, position_ms: int):
|
||||
self._position_ms = position_ms
|
||||
self.position_changed.emit(position_ms)
|
||||
@@ -121,19 +121,33 @@ class AirPlayController(QObject):
|
||||
from lintunes.airplay.stream import install_shim
|
||||
install_shim()
|
||||
if compat and raop is not None:
|
||||
# LinTunes' own RAOP sender (raop.py): what third-party speakers
|
||||
# play. pyatv only found the device.
|
||||
from lintunes.airplay.raop import (
|
||||
DEFAULT_LATENCY_MS, NativeDevice, RaopClient)
|
||||
latency = config.get("airplay_latency_ms") or DEFAULT_LATENCY_MS
|
||||
backend = str(config.get("airplay_backend") or "auto").lower()
|
||||
if backend != "cli":
|
||||
try:
|
||||
return await self._connect_native(conf, device, raop,
|
||||
model, choice, config)
|
||||
except (ConnectionError, OSError, asyncio.TimeoutError) as e:
|
||||
native_error = str(e) or type(e).__name__
|
||||
log_control("airplay", "native failed",
|
||||
f"{device.name}: {native_error}")
|
||||
if backend == "native":
|
||||
raise
|
||||
from lintunes.airplay import cli
|
||||
if not cli.supported():
|
||||
raise ConnectionError(
|
||||
"LinTunes' AirPlay sender couldn't connect, and "
|
||||
"cliairplay isn't available for this computer")
|
||||
# Downloaded once, verified against its pinned SHA-256 before it
|
||||
# ever runs (cli.ensure_binary); blocking, so off the loop.
|
||||
binary = await loop.run_in_executor(None, cli.ensure_binary)
|
||||
airplay = conf.get_service(Protocol.AirPlay)
|
||||
log_control("airplay", "protocol",
|
||||
f"{device.name} ({model}): native RAOP, "
|
||||
f"{latency} ms buffer (airplay_protocol={choice})")
|
||||
native = NativeDevice(RaopClient(
|
||||
str(conf.address), raop.port, dict(raop.properties),
|
||||
latency_ms=int(latency)))
|
||||
await asyncio.wait_for(native.connect(), CONNECT_TIMEOUT_S)
|
||||
return native
|
||||
f"{device.name} ({model}): cliairplay {cli.VERSION}")
|
||||
return {"cli": binary, "target": {
|
||||
"host": str(conf.address), "port": raop.port,
|
||||
"raop": dict(raop.properties),
|
||||
"airplay": dict(airplay.properties) if airplay else {},
|
||||
"choice": "auto"}}
|
||||
settings.protocols.raop.protocol_version = (
|
||||
{"2": AirPlayVersion.V2}.get(choice, AirPlayVersion.Auto))
|
||||
if raop is not None:
|
||||
@@ -146,18 +160,40 @@ class AirPlayController(QObject):
|
||||
pyatv.connect(raop_only(conf), loop, storage=storage),
|
||||
CONNECT_TIMEOUT_S)
|
||||
|
||||
@staticmethod
|
||||
async def _connect_native(conf, device, raop, model, choice, config):
|
||||
"""LinTunes' own RAOP sender (raop.py): what third-party speakers
|
||||
play. pyatv only found the device."""
|
||||
import asyncio
|
||||
from lintunes.airplay.raop import (
|
||||
DEFAULT_LATENCY_MS, NativeDevice, RaopClient)
|
||||
latency = config.get("airplay_latency_ms") or DEFAULT_LATENCY_MS
|
||||
log_control("airplay", "protocol",
|
||||
f"{device.name} ({model}): native RAOP, "
|
||||
f"{latency} ms buffer (airplay_protocol={choice})")
|
||||
native = NativeDevice(RaopClient(
|
||||
str(conf.address), raop.port, dict(raop.properties),
|
||||
latency_ms=int(latency)))
|
||||
await asyncio.wait_for(native.connect(), CONNECT_TIMEOUT_S)
|
||||
return native
|
||||
|
||||
def _on_connect_result(self, result: dict, attempt: int):
|
||||
if attempt != self._attempt:
|
||||
atv = result.get("atv")
|
||||
if atv is not None:
|
||||
via_cli = isinstance(atv, dict)
|
||||
if attempt != self._attempt:
|
||||
if atv is not None and not via_cli:
|
||||
self._loop.submit(self._close(atv))
|
||||
return
|
||||
if "error" in result:
|
||||
self.failed.emit(f"Couldn't connect: {result['error']}")
|
||||
return
|
||||
if via_cli:
|
||||
from lintunes.airplay.cli_sink import CliAirPlaySink
|
||||
self._sink = CliAirPlaySink(atv["cli"], atv["target"],
|
||||
result["name"], self)
|
||||
else:
|
||||
from lintunes.airplay.sink import AirPlaySink
|
||||
self._sink = AirPlaySink(result["atv"], self._loop, result["name"],
|
||||
self)
|
||||
self._sink = AirPlaySink(atv, self._loop, result["name"], self)
|
||||
# Deferred a turn, as in CastController: Player's own fallback slot
|
||||
# disconnects this signal mid-emission.
|
||||
self._sink.unavailable.connect(
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
from PyQt6.QtWidgets import QWidget, QApplication
|
||||
from PyQt6.QtCore import Qt, QSize
|
||||
from PyQt6.QtCore import Qt, QSize, QTimer
|
||||
from PyQt6.QtGui import QPainter, QPixmap
|
||||
|
||||
# Height left free for the window's own title bar. On Wayland the frame size
|
||||
@@ -22,6 +22,31 @@ def fit_size(art: QSize, available: QSize,
|
||||
return art.scaled(room, Qt.AspectRatioMode.KeepAspectRatio)
|
||||
|
||||
|
||||
def reshaped(art: QSize, area: QSize, previous: QSize | None,
|
||||
available: QSize | None = None) -> QSize:
|
||||
"""The content size with the art's shape nearest ``area``.
|
||||
|
||||
The dimension that changed more since ``previous`` is the one the user
|
||||
meant (dragging a side edge sets the width), and the other follows; the
|
||||
result stays within ``available``.
|
||||
"""
|
||||
if art.isEmpty() or area.isEmpty():
|
||||
return area
|
||||
aspect = art.width() / art.height()
|
||||
width_led = True
|
||||
if previous is not None and not previous.isEmpty():
|
||||
width_led = (abs(area.width() - previous.width()) / previous.width()
|
||||
>= abs(area.height() - previous.height()) / previous.height())
|
||||
if width_led:
|
||||
size = QSize(area.width(), max(1, round(area.width() / aspect)))
|
||||
else:
|
||||
size = QSize(max(1, round(area.height() * aspect)), area.height())
|
||||
if available is not None and not available.isEmpty() and (
|
||||
size.width() > available.width() or size.height() > available.height()):
|
||||
size = art.scaled(available, Qt.AspectRatioMode.KeepAspectRatio)
|
||||
return size
|
||||
|
||||
|
||||
def _aspect(pixmap: QPixmap | None) -> float | None:
|
||||
if pixmap is None or pixmap.isNull() or pixmap.height() == 0:
|
||||
return None
|
||||
@@ -32,7 +57,14 @@ class ArtWindow(QWidget):
|
||||
"""Non-modal window showing the current track's album art as large as
|
||||
possible. Just an album art window — closing it has no side effects.
|
||||
A click anywhere on the art (or Esc) closes it, like the big
|
||||
visualizer."""
|
||||
visualizer.
|
||||
|
||||
Never any background: the window keeps the art's shape (a resize is
|
||||
snapped back to it once the drag pauses), and the art is painted to
|
||||
*cover* the area, so even mid-drag or when the window can't be
|
||||
reshaped (maximized) there is a sliver cropped, never a bar."""
|
||||
|
||||
RESHAPE_DELAY_MS = 150
|
||||
|
||||
def __init__(self, parent=None):
|
||||
super().__init__(parent, Qt.WindowType.Window)
|
||||
@@ -40,6 +72,11 @@ class ArtWindow(QWidget):
|
||||
self.setMinimumSize(120, 120)
|
||||
self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, False)
|
||||
self.setToolTip("Click to close")
|
||||
self._settled: QSize | None = None
|
||||
self._reshape = QTimer(self)
|
||||
self._reshape.setSingleShot(True)
|
||||
self._reshape.setInterval(self.RESHAPE_DELAY_MS)
|
||||
self._reshape.timeout.connect(self._snap_to_art)
|
||||
|
||||
def show_artwork(self, pixmap: QPixmap | None, title: str, screen=None):
|
||||
"""Open (or re-raise) the window, sized to the art on ``screen``."""
|
||||
@@ -57,7 +94,7 @@ class ArtWindow(QWidget):
|
||||
self._pixmap = pixmap
|
||||
if reshape:
|
||||
# A track change brought a different shape of cover: re-fit, or
|
||||
# the new art would sit between black bars.
|
||||
# the new art would be cropped.
|
||||
self.fit_to_screen()
|
||||
self.update()
|
||||
|
||||
@@ -71,20 +108,48 @@ class ArtWindow(QWidget):
|
||||
size = fit_size(self._pixmap.size(), geo.size())
|
||||
# The app-drawn title bar (gui/titlebar.py) sits inside the window.
|
||||
margins = self.contentsMargins()
|
||||
self.resize(size.width(), size.height() + margins.top())
|
||||
self._settled = size
|
||||
self.resize(size.width() + margins.left() + margins.right(),
|
||||
size.height() + margins.top() + margins.bottom())
|
||||
# Wayland ignores move() (the compositor places the window); X11
|
||||
# honors it.
|
||||
self.move(geo.x() + (geo.width() - size.width()) // 2,
|
||||
geo.y() + (geo.height() - size.height()) // 2)
|
||||
|
||||
def resizeEvent(self, event):
|
||||
super().resizeEvent(event)
|
||||
self._reshape.start()
|
||||
|
||||
def _snap_to_art(self):
|
||||
if (self._pixmap is None or self._pixmap.isNull()
|
||||
or self.isMaximized() or self.isFullScreen()):
|
||||
return
|
||||
area = self.contentsRect().size()
|
||||
screen = self.screen() or QApplication.primaryScreen()
|
||||
room = None
|
||||
if screen is not None:
|
||||
geo = screen.availableGeometry().size()
|
||||
margins = self.contentsMargins()
|
||||
room = QSize(geo.width() - margins.left() - margins.right(),
|
||||
geo.height() - margins.top() - margins.bottom())
|
||||
size = reshaped(self._pixmap.size(), area, self._settled, room)
|
||||
self._settled = size
|
||||
if abs(size.width() - area.width()) > 1 or abs(
|
||||
size.height() - area.height()) > 1:
|
||||
margins = self.contentsMargins()
|
||||
self.resize(size.width() + margins.left() + margins.right(),
|
||||
size.height() + margins.top() + margins.bottom())
|
||||
|
||||
def paintEvent(self, event):
|
||||
painter = QPainter(self)
|
||||
area = self.contentsRect()
|
||||
painter.fillRect(area, Qt.GlobalColor.black)
|
||||
if self._pixmap is None or self._pixmap.isNull():
|
||||
return
|
||||
painter = QPainter(self)
|
||||
area = self.contentsRect()
|
||||
painter.setClipRect(area)
|
||||
# Cover, not fit: the window has the art's shape, so this crops at
|
||||
# most a rounding pixel — and never leaves a bar.
|
||||
scaled = self._pixmap.scaled(
|
||||
area.size(), Qt.AspectRatioMode.KeepAspectRatio,
|
||||
area.size(), Qt.AspectRatioMode.KeepAspectRatioByExpanding,
|
||||
Qt.TransformationMode.SmoothTransformation)
|
||||
x = area.x() + (area.width() - scaled.width()) // 2
|
||||
y = area.y() + (area.height() - scaled.height()) // 2
|
||||
|
||||
+102
-5
@@ -5,7 +5,7 @@ from PyQt6.QtWidgets import (
|
||||
QFrame,
|
||||
)
|
||||
from PyQt6.QtCore import Qt, QTimer, QPoint, QRectF, pyqtSignal
|
||||
from PyQt6.QtGui import QBrush, QPainter, QPalette, QPixmap
|
||||
from PyQt6.QtGui import QBrush, QColor, QPainter, QPalette, QPixmap
|
||||
|
||||
from lintunes.models import PlaylistType
|
||||
from lintunes import tagging, theme
|
||||
@@ -77,18 +77,16 @@ class SidebarPanel(QWidget):
|
||||
top.header_owner = self
|
||||
|
||||
# The playlists in their frame; the album art panel sits below it.
|
||||
group = QFrame()
|
||||
group = RoundedFrame(NO_ART_RADIUS)
|
||||
self._lists = QStackedWidget()
|
||||
self.tree = PlaylistTree(manager)
|
||||
self._lists.addWidget(self.tree)
|
||||
self.friend_list = FriendPlaylistList()
|
||||
self._lists.addWidget(self.friend_list)
|
||||
group.setFrameShape(self.tree.frameShape())
|
||||
group.setFrameShadow(self.tree.frameShadow())
|
||||
for view in (self.tree, self.friend_list):
|
||||
view.setFrameShape(QFrame.Shape.NoFrame)
|
||||
inner = QVBoxLayout(group)
|
||||
inner.setContentsMargins(0, 0, 0, 0)
|
||||
inner.setContentsMargins(1, 1, 1, 1)
|
||||
inner.setSpacing(0)
|
||||
inner.addWidget(self._lists, stretch=1)
|
||||
self.art = SidebarArt(player)
|
||||
@@ -259,6 +257,58 @@ NO_ART_GAP = 6
|
||||
NO_ART_RADIUS = 8
|
||||
|
||||
|
||||
def frame_color(palette) -> QColor:
|
||||
"""Fusion's own frame line (its outline, lightened as PE_Frame does), so
|
||||
a frame drawn here matches the ones the style draws."""
|
||||
return palette.color(QPalette.ColorRole.Window).darker(140).lighter(108)
|
||||
|
||||
|
||||
class RoundedFrame(QFrame):
|
||||
"""A list's frame with rounded corners: the panels' radius, not Fusion's
|
||||
square one. The list fills it edge to edge, so the corners are painted
|
||||
*over* it by a mouse-transparent overlay — window color outside the
|
||||
curve, then the frame line — which keeps them antialiased where a mask
|
||||
would be jagged."""
|
||||
|
||||
def __init__(self, radius: float, parent=None):
|
||||
super().__init__(parent)
|
||||
self.setFrameShape(QFrame.Shape.NoFrame)
|
||||
self._overlay = _FrameOverlay(self, radius)
|
||||
|
||||
def resizeEvent(self, event):
|
||||
super().resizeEvent(event)
|
||||
self._overlay.setGeometry(self.rect())
|
||||
self._overlay.raise_()
|
||||
|
||||
def childEvent(self, event):
|
||||
super().childEvent(event)
|
||||
overlay = getattr(self, "_overlay", None)
|
||||
if overlay is not None and event.added():
|
||||
overlay.raise_()
|
||||
|
||||
|
||||
class _FrameOverlay(QWidget):
|
||||
def __init__(self, parent, radius: float):
|
||||
super().__init__(parent)
|
||||
self.radius = radius
|
||||
self.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents)
|
||||
self.setAttribute(Qt.WidgetAttribute.WA_NoSystemBackground)
|
||||
|
||||
def paintEvent(self, event):
|
||||
from PyQt6.QtGui import QPainterPath, QPen
|
||||
painter = QPainter(self)
|
||||
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
|
||||
rect = QRectF(self.rect()).adjusted(0.5, 0.5, -0.5, -0.5)
|
||||
curve = QPainterPath()
|
||||
curve.addRoundedRect(rect, self.radius, self.radius)
|
||||
outside = QPainterPath()
|
||||
outside.addRect(QRectF(self.rect()))
|
||||
painter.fillPath(outside.subtracted(curve),
|
||||
self.palette().color(QPalette.ColorRole.Window))
|
||||
painter.setPen(QPen(frame_color(self.palette()), 1))
|
||||
painter.drawPath(curve)
|
||||
|
||||
|
||||
class SidebarArt(QWidget):
|
||||
"""Square album art pinned to the sidebar bottom: a panel set into the
|
||||
window below the playlist list's frame, like the visualizer, with the
|
||||
@@ -275,6 +325,8 @@ class SidebarArt(QWidget):
|
||||
self._pixmap: QPixmap | None = None
|
||||
self._track = None
|
||||
self._art_window = ArtWindow()
|
||||
self._hovered = False
|
||||
self._held = False
|
||||
player.track_changed.connect(self.set_track)
|
||||
|
||||
def set_track(self, track):
|
||||
@@ -324,7 +376,39 @@ class SidebarArt(QWidget):
|
||||
self._fit_height()
|
||||
super().resizeEvent(event)
|
||||
|
||||
def _is_button(self) -> bool:
|
||||
"""Empty with a track to fetch art for: the panel is a button (a
|
||||
click downloads art), though it only looks like one under the
|
||||
cursor."""
|
||||
return self._track is not None and not self.has_art()
|
||||
|
||||
def enterEvent(self, event):
|
||||
self._hovered = True
|
||||
self.update()
|
||||
super().enterEvent(event)
|
||||
|
||||
def leaveEvent(self, event):
|
||||
self._hovered = False
|
||||
self.update()
|
||||
super().leaveEvent(event)
|
||||
|
||||
def mousePressEvent(self, event):
|
||||
if event.button() == Qt.MouseButton.LeftButton:
|
||||
self._held = True
|
||||
self.update()
|
||||
super().mousePressEvent(event)
|
||||
|
||||
def mouseMoveEvent(self, event):
|
||||
# Held and dragged off: no longer pressed, as a button lets go.
|
||||
inside = self.rect().contains(event.position().toPoint())
|
||||
if inside != self._hovered:
|
||||
self._hovered = inside
|
||||
self.update()
|
||||
super().mouseMoveEvent(event)
|
||||
|
||||
def mouseReleaseEvent(self, event):
|
||||
self._held = False
|
||||
self.update()
|
||||
# A click is a release that lands on the art. Opening on press would
|
||||
# also fire when a drag merely starts here.
|
||||
if (event.button() == Qt.MouseButton.LeftButton
|
||||
@@ -344,6 +428,19 @@ class SidebarArt(QWidget):
|
||||
painter = QPainter(self)
|
||||
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
|
||||
rect = QRectF(self.rect()).adjusted(0.5, NO_ART_GAP + 0.5, -0.5, -0.5)
|
||||
if self._is_button() and self._hovered:
|
||||
# Pops up as a plain button under the cursor (no glyph): the
|
||||
# Library button's face, hover-darkened, and sunk while held.
|
||||
face = self.palette().alternateBase().color()
|
||||
if self._held:
|
||||
theme.paint_deboss(painter, rect,
|
||||
face.darker(theme.PRESSED_DARKER),
|
||||
NO_ART_RADIUS, like=CONTROL_HEIGHT)
|
||||
else:
|
||||
theme.paint_emboss(painter, rect,
|
||||
face.darker(theme.HOVER_DARKER),
|
||||
NO_ART_RADIUS, like=CONTROL_HEIGHT)
|
||||
return
|
||||
theme.paint_deboss(painter, rect,
|
||||
self.palette().alternateBase().color(),
|
||||
NO_ART_RADIUS, like=CONTROL_HEIGHT)
|
||||
|
||||
@@ -0,0 +1,202 @@
|
||||
"""Round 91: the playlist frame's rounded corners, the empty art panel as a
|
||||
button under the cursor, an art window with no background, and cliairplay
|
||||
as the fallback AirPlay sender."""
|
||||
|
||||
import asyncio
|
||||
import hashlib
|
||||
from types import SimpleNamespace
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
import pytest
|
||||
from PyQt6.QtCore import QEvent, QPointF, QSize, Qt
|
||||
from PyQt6.QtGui import QColor, QEnterEvent, QMouseEvent, QPixmap
|
||||
from PyQt6.QtWidgets import QLabel
|
||||
|
||||
from tests.test_round49 import _FakePlayer
|
||||
|
||||
|
||||
# ---- the playlist frame ----
|
||||
|
||||
class TestRoundedFrame:
|
||||
def test_corners_are_window_color_and_clicks_reach_the_list(self, qapp):
|
||||
from lintunes.gui.sidebar import RoundedFrame, frame_color
|
||||
frame = RoundedFrame(8)
|
||||
inside = QLabel(frame)
|
||||
inside.setAutoFillBackground(True)
|
||||
palette = inside.palette()
|
||||
palette.setColor(inside.backgroundRole(), QColor("red"))
|
||||
inside.setPalette(palette)
|
||||
inside.setGeometry(0, 0, 100, 100)
|
||||
frame.resize(100, 100)
|
||||
frame.show()
|
||||
qapp.processEvents()
|
||||
image = frame.grab().toImage()
|
||||
window = frame.palette().color(frame.backgroundRole())
|
||||
assert QColor(image.pixel(0, 0)) == QColor(window.name())
|
||||
assert QColor(image.pixel(50, 50)) == QColor("red")
|
||||
edge = QColor(image.pixel(50, 0))
|
||||
assert abs(edge.red() - frame_color(frame.palette()).red()) < 12
|
||||
assert frame._overlay.testAttribute(
|
||||
Qt.WidgetAttribute.WA_TransparentForMouseEvents)
|
||||
frame.close()
|
||||
|
||||
|
||||
# ---- the empty art panel ----
|
||||
|
||||
def _event(kind, button=Qt.MouseButton.LeftButton, x=50, y=50):
|
||||
return QMouseEvent(kind, QPointF(x, y), QPointF(x, y), button, button,
|
||||
Qt.KeyboardModifier.NoModifier)
|
||||
|
||||
|
||||
class TestEmptyArtButton:
|
||||
def _art(self, track=True):
|
||||
from lintunes.gui.sidebar import SidebarArt
|
||||
art = SidebarArt(_FakePlayer())
|
||||
art.resize(100, 106)
|
||||
art._track = SimpleNamespace(track_id=1) if track else None
|
||||
return art
|
||||
|
||||
def _middle(self, art):
|
||||
return art.grab().toImage().pixelColor(50, 60)
|
||||
|
||||
def test_pops_up_on_hover_and_sinks_while_held(self, qapp):
|
||||
art = self._art()
|
||||
resting = self._middle(art)
|
||||
art.enterEvent(QEnterEvent(QPointF(50, 50), QPointF(50, 50), QPointF(50, 50)))
|
||||
hovered = self._middle(art)
|
||||
art.mousePressEvent(_event(QEvent.Type.MouseButtonPress))
|
||||
held = self._middle(art)
|
||||
assert hovered != resting and held != hovered
|
||||
assert held.lightness() < hovered.lightness()
|
||||
art.mouseReleaseEvent(_event(QEvent.Type.MouseButtonRelease))
|
||||
assert self._middle(art) == hovered
|
||||
art.leaveEvent(QEvent(QEvent.Type.Leave))
|
||||
assert self._middle(art) == resting
|
||||
|
||||
def test_no_track_or_real_art_is_never_a_button(self, qapp):
|
||||
art = self._art(track=False)
|
||||
resting = self._middle(art)
|
||||
art.enterEvent(QEnterEvent(QPointF(50, 50), QPointF(50, 50), QPointF(50, 50)))
|
||||
assert self._middle(art) == resting
|
||||
assert not art._is_button()
|
||||
art._track = SimpleNamespace(track_id=1)
|
||||
art._pixmap = QPixmap(10, 10)
|
||||
assert not art._is_button()
|
||||
|
||||
|
||||
# ---- the big art window ----
|
||||
|
||||
class TestArtShape:
|
||||
def test_the_dimension_that_moved_leads(self):
|
||||
from lintunes.gui.art_window import reshaped
|
||||
art = QSize(500, 500)
|
||||
assert reshaped(art, QSize(700, 520), QSize(500, 500)) == QSize(700, 700)
|
||||
assert reshaped(art, QSize(510, 300), QSize(500, 500)) == QSize(300, 300)
|
||||
assert reshaped(QSize(200, 100), QSize(400, 400), None) == QSize(400, 200)
|
||||
|
||||
def test_stays_on_the_screen(self):
|
||||
from lintunes.gui.art_window import reshaped
|
||||
assert reshaped(QSize(500, 500), QSize(1500, 900), QSize(500, 500),
|
||||
QSize(1920, 1000)) == QSize(1000, 1000)
|
||||
|
||||
def test_never_paints_a_background(self, qapp):
|
||||
from lintunes.gui.art_window import ArtWindow
|
||||
window = ArtWindow()
|
||||
art = QPixmap(100, 100)
|
||||
art.fill(QColor("red"))
|
||||
window._pixmap = art
|
||||
window.resize(300, 200) # the wrong shape, before the snap
|
||||
image = window.grab().toImage()
|
||||
for x, y in ((0, 0), (299, 199), (5, 100), (295, 100)):
|
||||
assert image.pixelColor(x, y) == QColor("red")
|
||||
|
||||
|
||||
# ---- cliairplay ----
|
||||
|
||||
class TestCliBinary:
|
||||
def test_a_checksum_mismatch_is_never_installed(self, tmp_path, monkeypatch):
|
||||
from lintunes.airplay import cli
|
||||
monkeypatch.setenv("XDG_DATA_HOME", str(tmp_path))
|
||||
monkeypatch.setattr(cli, "_arch", lambda: "x86_64")
|
||||
with pytest.raises(cli.CliUnavailable):
|
||||
cli.ensure_binary(fetch=lambda url: b"not the binary")
|
||||
assert not any(tmp_path.rglob("cliairplay-*"))
|
||||
|
||||
def test_a_matching_download_is_installed_executable(self, tmp_path,
|
||||
monkeypatch):
|
||||
from lintunes.airplay import cli
|
||||
data = b"pretend binary"
|
||||
monkeypatch.setenv("XDG_DATA_HOME", str(tmp_path))
|
||||
monkeypatch.setattr(cli, "_arch", lambda: "x86_64")
|
||||
monkeypatch.setitem(cli._SHA256, "x86_64",
|
||||
hashlib.sha256(data).hexdigest())
|
||||
urls = []
|
||||
path = cli.ensure_binary(fetch=lambda url: urls.append(url) or data)
|
||||
assert path.read_bytes() == data and cli.installed() == path
|
||||
assert urls == [cli._RELEASE + "cliairplay-linux-x86_64"]
|
||||
assert cli.ensure_binary(fetch=lambda url: 1 / 0) == path # cached
|
||||
|
||||
def test_status_lines(self):
|
||||
from lintunes.airplay import cli
|
||||
assert cli.parse_status("[STATUS] playing elapsed_ms=1203") == (
|
||||
"playing", {"elapsed_ms": "1203"})
|
||||
assert cli.parse_status('[STATUS] error code=x detail="a b"') == (
|
||||
"error", {"code": "x", "detail": "a b"})
|
||||
assert cli.parse_status("[12:00] something") is None
|
||||
|
||||
def test_args_carry_the_raop_txt(self):
|
||||
from lintunes.airplay import cli
|
||||
args = cli.build_args("/bin/cli", "10.0.0.9", 7000,
|
||||
{"et": "0,4", "md": "0,1,2", "ft": "0x1,0x2"},
|
||||
{}, "/tmp/p", 50)
|
||||
assert args[0] == "/bin/cli" and args[-1] == "10.0.0.9"
|
||||
assert args[args.index("--et") + 1] == "0,4"
|
||||
assert args[args.index("--txt") + 1] == "ft=0x1,0x2"
|
||||
assert args[args.index("--volume") + 1] == "50"
|
||||
|
||||
|
||||
class TestFallback:
|
||||
def _controller(self):
|
||||
from lintunes.airplay.controller import AirPlayController
|
||||
controller = AirPlayController(MagicMock())
|
||||
return controller
|
||||
|
||||
def _conf(self):
|
||||
from pyatv.const import Protocol
|
||||
raop = SimpleNamespace(port=7000, properties={"am": "WiiM"},
|
||||
protocol=Protocol.RAOP)
|
||||
conf = MagicMock(address="10.0.0.9")
|
||||
conf.get_service = lambda p: raop if p == Protocol.RAOP else None
|
||||
return conf
|
||||
|
||||
def _connect(self, controller, config, native):
|
||||
from lintunes.airplay import cli, controller as module
|
||||
device = SimpleNamespace(name="tiat", host="10.0.0.9", uuid="x")
|
||||
with patch.object(module, "load_config", return_value=config), \
|
||||
patch.object(type(controller), "_connect_native", native), \
|
||||
patch.object(cli, "supported", return_value=True), \
|
||||
patch.object(cli, "ensure_binary", return_value="/bin/cli"):
|
||||
return asyncio.run(controller._connect(self._conf(), device))
|
||||
|
||||
def test_a_native_failure_falls_back_to_cliairplay(self, qapp):
|
||||
async def native(*args):
|
||||
raise ConnectionError("refused")
|
||||
result = self._connect(self._controller(), {}, native)
|
||||
assert result["cli"] == "/bin/cli"
|
||||
assert result["target"]["host"] == "10.0.0.9"
|
||||
assert result["target"]["port"] == 7000
|
||||
|
||||
def test_native_when_it_connects_and_cli_when_asked(self, qapp):
|
||||
async def native(*args):
|
||||
return "native device"
|
||||
controller = self._controller()
|
||||
assert self._connect(controller, {}, native) == "native device"
|
||||
assert "cli" in self._connect(controller, {"airplay_backend": "cli"},
|
||||
native)
|
||||
|
||||
def test_native_only_reports_the_failure(self, qapp):
|
||||
async def native(*args):
|
||||
raise ConnectionError("refused")
|
||||
with pytest.raises(ConnectionError):
|
||||
self._connect(self._controller(), {"airplay_backend": "native"},
|
||||
native)
|
||||
Reference in New Issue
Block a user