Files
lintunes/lintunes/gui/cast_dialog.py
T
travandClaude Opus 5 087c4bf103 v0.4.0: cast to a Chromecast from the Connections menu
The Device menu becomes Connections, with "Connect to Chromecast…" beside
the Rabbit sync. It opens a dialog that spins while it searches and lists
devices as they appear; picking one hands playback over, puts a small cast
glyph under the volume slider, and clicking that glyph disconnects.

Media-receiver model: lintunes serves the original file over the LAN on an
ephemeral port and the Chromecast decodes it itself. Bit-exact — no
transcode, no second lossy encode — and the device buffers for itself. The
cost is that lintunes is a remote control while connected: no local PCM, so
the visualizer shows the cast glyph instead of bars, and transport actions
land with about a second of round trip.

Player now walks its queue through a swappable PlaybackSink. It keeps
owning the queue, shuffle walk, start/stop times and the play-count and
scrobble bookkeeping, so casting counts plays and scrobbles exactly like
local playback. set_sink() carries track, position and playing-state both
ways, so connecting and disconnecting pick up mid-song. LocalSink stays in
player.py because the Player tests stub Qt Multimedia in that namespace.

The URL carries an opaque random token, never a path, so there is nothing
to traverse with; only the last few played tracks stay resolvable and the
whole map dies with the session. Range and HEAD are implemented because
the device seeks by re-requesting ranges and won't report a duration
without them.

Failure handling, verified against a real device: a dropped socket gets a
15s grace period, since pychromecast retries on its own and a Wi-Fi blip
heals itself. A real loss, another app taking the device, or a network
change falls back to local playback still playing, at the same position —
the sink reports the state lintunes last asked for rather than the IDLE
status a dying connection pushes just before it goes. Quitting stops the
device instead of leaving it fetching from a server that just died. The
~119 Apple Lossless / AIFF / protected-AAC tracks are skipped with a
status-bar message; the other 21,000+ MP3 and AAC files cast natively.

New dependency: pychromecast>=14.0.10, imported lazily so the app still
launches where it isn't installed (the menu item then explains the
install), and python_requires raised to >=3.11 to match its floor.

NOTE: the other machine needs `pip install -e .` before casting appears.

tests/test_round29.py: 67 tests; 440 pass overall.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-13 21:49:53 -04:00

130 lines
4.7 KiB
Python

"""The "Connect to Chromecast…" picker.
Searching starts when the dialog opens and stops when it closes, whichever way
it closes. Connecting is not awaited here — the dialog's job ends at "which
device", and CastController reports the outcome on the status bar.
"""
from PyQt6.QtCore import Qt, QTimer
from PyQt6.QtWidgets import (
QDialog, QDialogButtonBox, QHBoxLayout, QLabel, QListWidget,
QListWidgetItem, QVBoxLayout)
from lintunes.gui.spinner import Spinner
# How long to look before admitting there's nothing there. Searching carries on
# regardless — a speaker that wakes up later still shows up.
EMPTY_AFTER_MS = 12_000
class ChromecastDialog(QDialog):
"""Lists Chromecasts as they're discovered; returns the one picked."""
def __init__(self, discovery, parent=None):
super().__init__(parent)
self._discovery = discovery
self._selected = None
self.setWindowTitle("Connect to Chromecast")
self.setMinimumWidth(340)
layout = QVBoxLayout(self)
header = QHBoxLayout()
self._spinner = Spinner()
header.addWidget(self._spinner)
self._status = QLabel("Searching for Chromecasts…")
header.addWidget(self._status, stretch=1)
layout.addLayout(header)
self._list = QListWidget()
self._list.setAlternatingRowColors(True)
self._list.itemSelectionChanged.connect(self._on_selection_changed)
self._list.itemDoubleClicked.connect(lambda _: self._on_connect())
layout.addWidget(self._list, stretch=1)
self._buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Cancel)
self._connect_button = self._buttons.addButton(
"Connect", QDialogButtonBox.ButtonRole.AcceptRole)
self._connect_button.setEnabled(False)
self._connect_button.setDefault(True)
self._buttons.rejected.connect(self.reject)
self._connect_button.clicked.connect(self._on_connect)
layout.addWidget(self._buttons)
discovery.device_found.connect(self._on_found)
discovery.device_lost.connect(self._on_lost)
discovery.failed.connect(self._on_failed)
self._empty_timer = QTimer(self)
self._empty_timer.setSingleShot(True)
self._empty_timer.setInterval(EMPTY_AFTER_MS)
self._empty_timer.timeout.connect(self._on_empty_timeout)
self._empty_timer.start()
# Anything discovery already knows about (it may still be running from
# a previous open) should be on screen before the first new callback.
for device in discovery.devices():
self._on_found(device)
discovery.start()
@property
def selected_device(self):
return self._selected
# ---- discovery ----
def _on_found(self, device):
for row in range(self._list.count()):
existing = self._list.item(row).data(Qt.ItemDataRole.UserRole)
if existing.uuid == device.uuid:
return
label = device.name
if device.model:
label = f"{device.name} · {device.model}"
item = QListWidgetItem(label)
item.setData(Qt.ItemDataRole.UserRole, device)
self._list.addItem(item)
self._status.setText("Select a Chromecast to connect to.")
if self._list.count() == 1:
self._list.setCurrentRow(0)
def _on_lost(self, device):
for row in range(self._list.count()):
if self._list.item(row).data(
Qt.ItemDataRole.UserRole).uuid == device.uuid:
self._list.takeItem(row)
break
if self._list.count() == 0:
self._status.setText("Searching for Chromecasts…")
def _on_failed(self, message: str):
self._spinner.hide()
self._status.setText(message)
self._empty_timer.stop()
def _on_empty_timeout(self):
if self._list.count() == 0:
# The spinner keeps turning: discovery is still running, and a
# device that comes online in a minute will still appear.
self._status.setText("No Chromecasts found on this network yet.")
# ---- selection ----
def _on_selection_changed(self):
self._connect_button.setEnabled(self._list.currentItem() is not None)
def _on_connect(self):
item = self._list.currentItem()
if item is None:
return
self._selected = item.data(Qt.ItemDataRole.UserRole)
self.accept()
def done(self, result):
# The single exit funnel — accept, reject, Esc and the window's close
# button all land here, so discovery can't be left running.
self._empty_timer.stop()
self._spinner.stop()
self._discovery.stop()
super().done(result)