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>
130 lines
4.7 KiB
Python
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)
|