"""macOS Now Playing and media keys: the Mac's answer to ``mpris.py``. ``MPNowPlayingInfoCenter`` is what Control Centre's Now Playing tile and the menu-bar widget read (title, artist, album, length, where the song is up to, artwork), and ``MPRemoteCommandCenter`` is where the keyboard's play/pause/next/previous keys, AirPods and the tile's own buttons land. A Mac sends those keys to whichever app last claimed Now Playing, so this is the whole of media-key support there; ``MainWindow.eventFilter``'s in-window keys stay as they are. pyobjc (``pyobjc-framework-MediaPlayer`` + ``-Cocoa``) is a Mac-only dependency, imported inside ``setup``: if it is missing the app logs once and runs without, exactly as Linux does without a session bus. The command handlers may run on a thread of the system's choosing, so they only emit ``_command``; the Player is driven from the GUI thread by the queued slot. The adaptor routes to the same Player methods MPRIS does. """ import logging from PyQt6.QtCore import QObject, pyqtSignal from lintunes import tagging from lintunes.eventlog import log_control log = logging.getLogger(__name__) # The one live instance, so mpris.invalidate_artwork can reach it. _live = None # MPRemoteCommandHandlerStatus / MPNowPlayingPlaybackState STATUS_SUCCESS = 0 STATUS_NO_SUCH_CONTENT = 100 STATE_PLAYING = 1 STATE_PAUSED = 2 STATE_STOPPED = 3 # (MPRemoteCommandCenter accessor, the name the handler emits) COMMANDS = ( ("playCommand", "play"), ("pauseCommand", "pause"), ("togglePlayPauseCommand", "toggle"), ("stopCommand", "stop"), ("nextTrackCommand", "next"), ("previousTrackCommand", "previous"), ("changePlaybackPositionCommand", "seek"), ) def setup(player, main_window): """A live ``MacNowPlaying``, or None when pyobjc isn't installed or the framework refuses (the app carries on either way).""" try: import MediaPlayer # noqa: F401 — pyobjc-framework-MediaPlayer except Exception as e: # noqa: BLE001 — ImportError, or a broken install log.info("Now Playing: pyobjc's MediaPlayer isn't available (%s); " "media keys are off", e) return None try: import AppKit except Exception: # noqa: BLE001 — artwork is optional AppKit = None global _live try: _live = MacNowPlaying(player, main_window, MediaPlayer, AppKit) return _live except Exception as e: # noqa: BLE001 log.info("Now Playing: couldn't register with the system: %s", e) return None class MacNowPlaying(QObject): """Mirrors the Player into the system's Now Playing and routes the remote commands back. ``mp``/``appkit`` are the pyobjc modules, passed in so tests can hand it fakes.""" _command = pyqtSignal(str, float) def __init__(self, player, main_window, mp, appkit=None): super().__init__() self._player = player self._window = main_window self._mp = mp self._appkit = appkit self._handlers = [] # keep the Python callables alive self._art_track = None # whose artwork object we built self._artwork = None self._command.connect(self._run) center = mp.MPRemoteCommandCenter.sharedCommandCenter() for accessor, name in COMMANDS: command = getattr(center, accessor, None) if command is None: continue command = command() handler = self._handler_for(name) self._handlers.append(handler) try: command.setEnabled_(True) command.addTargetWithHandler_(handler) except Exception as e: # noqa: BLE001 log.info("Now Playing: %s unavailable: %s", accessor, e) player.track_changed.connect(lambda _t: self.update()) player.playing_changed.connect(lambda _p: self.update()) # A seek moves the elapsed time; Now Playing extrapolates the rest # from the rate, so a jump is the only position change it needs. self._last_pos = 0 player.position_changed.connect(self._on_position) self.update() # -- commands (any thread) -> GUI thread -- def _handler_for(self, name): def handler(event): seconds = 0.0 if name == "seek": try: seconds = float(event.positionTime()) except Exception: # noqa: BLE001 return STATUS_NO_SUCH_CONTENT self._command.emit(name, seconds) return STATUS_SUCCESS return handler def _run(self, name: str, seconds: float): log_control("nowplaying", name) player = self._player if name == "play": player.play() elif name == "pause": player.pause() elif name == "toggle": player.toggle_play() elif name == "stop": player.stop() elif name == "next": player.next() elif name == "previous": player.previous() elif name == "seek": player.seek(int(seconds * 1000)) self.update() # -- Player -> Now Playing -- def _on_position(self, ms): ms = int(ms) # Normal playback steps a few hundred ms at a time; only a jump # (a seek, a restart) needs telling. if abs(ms - self._last_pos) > 2000: self._last_pos = ms self.update() else: self._last_pos = ms def info(self) -> dict | None: """The nowPlayingInfo dictionary for the current state (None when nothing is loaded).""" mp = self._mp track = self._player.current_track if track is None: return None playing = self._player.is_playing() info = { mp.MPMediaItemPropertyTitle: track.name or "", mp.MPMediaItemPropertyArtist: track.artist or "", mp.MPMediaItemPropertyAlbumTitle: track.album or "", mp.MPNowPlayingInfoPropertyElapsedPlaybackTime: self._player.position_ms() / 1000.0, mp.MPNowPlayingInfoPropertyPlaybackRate: 1.0 if playing else 0.0, } length = track.total_time or self._player.duration_ms() if length: info[mp.MPMediaItemPropertyPlaybackDuration] = length / 1000.0 artwork = self._artwork_for(track) if artwork is not None: info[mp.MPMediaItemPropertyArtwork] = artwork return info def update(self): try: center = self._mp.MPNowPlayingInfoCenter.defaultCenter() info = self.info() center.setNowPlayingInfo_(info) if info is None: state = STATE_STOPPED elif self._player.is_playing(): state = STATE_PLAYING else: state = STATE_PAUSED # macOS only routes the media keys to an app that says it's # playing (or paused), so this matters as much as the info. if hasattr(center, "setPlaybackState_"): center.setPlaybackState_(state) except Exception as e: # noqa: BLE001 — never break playback for this log.info("Now Playing: update failed: %s", e) def _artwork_for(self, track): if self._appkit is None or not track.location: return None if self._art_track == track.track_id: return self._artwork self._art_track = track.track_id self._artwork = None try: data = tagging.read_embedded_artwork(track.location) if not data: return None appkit = self._appkit image = appkit.NSImage.alloc().initWithData_( appkit.NSData.dataWithBytes_length_(data, len(data))) if image is None: return None self._artwork = self._mp.MPMediaItemArtwork.alloc() \ .initWithBoundsSize_requestHandler_( image.size(), lambda _size: image) except Exception as e: # noqa: BLE001 log.info("Now Playing: no artwork for %s: %s", track.location, e) self._artwork = None return self._artwork def invalidate_artwork(self, track=None): """Forget the built artwork (after new art is embedded).""" if track is None or self._art_track == getattr(track, "track_id", None): self._art_track = None self._artwork = None self.update() def invalidate_artwork(track): if _live is not None: _live.invalidate_artwork(track)