mopidy-dial 0.0.1__py3-none-any.whl

mopidy_dial/__init__.py

@@ -0,0 +1,38 @@
+import logging
+import pathlib
+from importlib.metadata import version
+
+from mopidy import config, ext
+
+__version__ = version("mopidy-dial")
+
+logger = logging.getLogger(__name__)
+
+
+class Extension(ext.Extension):
+    dist_name = "mopidy-dial"
+    ext_name = "dial"
+    version = __version__
+
+    def get_default_config(self):
+        return config.read(pathlib.Path(__file__).parent / "ext.conf")
+
+    def get_config_schema(self):
+        schema = super().get_config_schema()
+        schema["friendly_name"] = config.String()
+        return schema
+
+
+    def setup(self, registry):
+        from .frontend import DialFrontend
+        from .web import DialHandler
+
+        registry.add("frontend", DialFrontend)
+        
+        # Mopidy expects a list of (regexp, handler_class) tuples
+        registry.add("http:app", {
+            "name": self.ext_name, # "dial"
+            "factory": lambda config, core: [
+                (r"/(.*)", DialHandler, {"config": config, "core": core}),
+            ],
+        })

mopidy_dial/ext.conf

@@ -0,0 +1,3 @@
+[dial]
+enabled = true
+friendly_name = Mopidy

mopidy_dial/frontend.py

@@ -0,0 +1,396 @@
+"""
+frontend.py
+-----------
+Mopidy frontend actor. Responsible for:
+  1. Running the SSDP listener/notifier (makes device visible on LAN)
+  2. Creating and managing the Lounge session
+  3. Wiring the DIAL HTTP handler (web.py) to the Lounge session
+  4. Forwarding Mopidy CoreListener events to the active LoungeHandler
+     so that Mopidy-side changes (play/pause/seek/volume) are reported
+     back to the YouTube app in real time.
+"""
+
+import os
+import socket
+import struct
+import threading
+import time
+
+import pykka
+
+from mopidy import core as mopidy_core
+from mopidy_dial import logger
+
+from .lounge_session import LoungeSession
+from .lounge_handler import LoungeHandler
+from .lounge_subscriber import LoungeSubscriber
+from .web import DialHandler
+
+SSDP_ADDR = "239.255.255.250"
+SSDP_PORT = 1900
+SSDP_ST   = "urn:dial-multiscreen-org:service:dial:1"
+
+
+def _local_ip() -> str:
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        s.connect(("8.8.8.8", 80))
+        return s.getsockname()[0]
+    finally:
+        s.close()
+
+
+class DialFrontend(pykka.ThreadingActor, mopidy_core.CoreListener):
+
+    def __init__(self, config, core):
+        super().__init__()
+        self.core = core
+        self.config = config
+        self.local_ip = _local_ip()
+        self.port = config["http"]["port"]
+        self.friendly_name = config.get("dial", {}).get("friendly_name", "Mopidy")
+        self._running = False
+        self._stop_event = threading.Event()
+
+        # One Lounge session (and handler) per sender type, keyed by theme:
+        # "" for the YouTube app, "m" for YouTube Music. CoreListener events
+        # are forwarded to whichever handlers have a remote connected.
+        self._sessions: dict[str, LoungeSession] = {}
+        self._handlers: dict[str, LoungeHandler] = {}
+        self._handler_lock = threading.Lock()
+
+    # ------------------------------------------------------------------
+    # Pykka lifecycle
+    # ------------------------------------------------------------------
+
+    def on_start(self):
+        self._running = True
+        self._session_ready = threading.Event()
+        DialHandler.on_launch = self._on_dial_launch
+        DialHandler.on_pairing_code = self._on_dial_pairing_code
+
+        # SSDP listener starts immediately (must respond to M-SEARCH)
+        threading.Thread(target=self._run_ssdp, daemon=True).start()
+        # NOTIFY thread waits until session is ready before announcing
+        threading.Thread(target=self._run_notify, daemon=True).start()
+        threading.Thread(target=self._start_lounge_session, daemon=True).start()
+
+    def on_stop(self):
+        self._running = False
+        self._stop_event.set()  # wake any threads sleeping on this event
+
+    # ------------------------------------------------------------------
+    # CoreListener — Mopidy → YouTube direction
+    # Each event is forwarded to the active LoungeHandler.
+    # ------------------------------------------------------------------
+
+    def _forward(self, event: str, *args):
+        with self._handler_lock:
+            handlers = [h for h in self._handlers.values() if h.connected]
+            if not handlers:
+                handlers = list(self._handlers.values())
+        for h in handlers:
+            try:
+                getattr(h, event)(*args)
+            except Exception as e:
+                logger.error(f"Error forwarding {event} to handler: {e}", exc_info=True)
+
+    def track_playback_started(self, tl_track):
+        self._forward("on_track_playback_started", tl_track)
+
+    def track_playback_paused(self, tl_track, time_position):
+        self._forward("on_track_playback_paused", tl_track, time_position)
+
+    def track_playback_resumed(self, tl_track, time_position):
+        self._forward("on_track_playback_resumed", tl_track, time_position)
+
+    def track_playback_ended(self, tl_track, time_position):
+        self._forward("on_track_playback_ended", tl_track, time_position)
+
+    def seeked(self, time_position):
+        self._forward("on_seeked", time_position)
+
+    def volume_changed(self, volume):
+        self._forward("on_volume_changed", volume)
+
+    def mute_changed(self, mute):
+        self._forward("on_mute_changed", mute)
+
+    # ------------------------------------------------------------------
+    # DIAL launch callback (called from web.py when app POSTs)
+    # ------------------------------------------------------------------
+
+    def _on_dial_launch(self, lounge_token: str, screen_id: str):
+        """Called when YouTube app POSTs with a loungeToken directly."""
+        logger.info(f"DIAL launch (token flow) — screenId={screen_id!r}")
+        threading.Thread(
+            target=self._run_session,
+            args=(screen_id, lounge_token),
+            daemon=True,
+        ).start()
+
+    def _on_dial_pairing_code(self, pairing_code: str, theme: str = ""):
+        """
+        Called when a sender POSTs a pairingCode to launch the app over DIAL.
+
+        The code is generated by the sender. A real TV registers it with
+        YouTube against its own screen, and the sender then looks the screen
+        up by that code and connects to it. YouTube Music (theme "m") only
+        connects to a screen created with that theme, so register the code on
+        the matching session.
+        """
+        session = self._sessions.get(theme if theme == "m" else "")
+        logger.info(f"DIAL launch — theme={theme!r} pairingCode={pairing_code!r}")
+        if session is None:
+            logger.warning(f"No Lounge session for theme {theme!r} yet")
+            return
+
+        def register():
+            try:
+                session.register_pairing_code(pairing_code)
+            except Exception as e:
+                logger.error(f"Failed to register pairing code: {e}",
+                             exc_info=True)
+
+        threading.Thread(target=register, daemon=True).start()
+
+    # ------------------------------------------------------------------
+    # Lounge session management
+    # ------------------------------------------------------------------
+
+    def _start_lounge_session(self):
+        """
+        Create a persistent lounge session with automatic pairing code refresh.
+        Credentials are only published to DialHandler (and SSDP only fires)
+        after the session is fully bound — preventing the race condition where
+        the Music app polls and receives empty credentials.
+        """
+        while self._running:
+            try:
+                # Persist screen_id so YouTube Music can reconnect after restarts
+                persist_path = os.path.join(
+                    os.path.expanduser("~"), ".config", "mopidy", "dial_screen_id"
+                )
+                session = LoungeSession.create(self.friendly_name,
+                                               persist_path=persist_path)
+
+                # Get + register pairing code BEFORE publishing credentials
+                self._sessions[""] = session
+                self._refresh_pairing_code(session)
+
+                # Bind the lounge session first
+                session.bind()
+                logger.info(f"Lounge session bound — SID={session.sid}")
+
+                # NOW publish credentials — 503 guard will clear on next poll
+                DialHandler.lounge_token = session.lounge_token
+                DialHandler.screen_id    = session.screen_id
+                DialHandler.device_id    = session.device_id
+
+                # Signal SSDP notify thread that it can start broadcasting
+                self._session_ready.set()
+
+                # Start pairing code refresh thread
+                threading.Thread(
+                    target=self._pairing_code_refresher,
+                    args=(session,),
+                    daemon=True,
+                ).start()
+
+                handler = LoungeHandler(session, self.core)
+                with self._handler_lock:
+                    self._handlers[""] = handler
+                threading.Thread(target=self._start_music_session,
+                                 daemon=True).start()
+                self._run_subscriber(session, handler)
+                return
+            except Exception as e:
+                if not self._running or self._stop_event.is_set():
+                    return
+                logger.error(f"Failed to start Lounge session: {e} — retrying in 10s",
+                             exc_info=True)
+                time.sleep(10)
+
+    def _start_music_session(self):
+        """A second screen with theme "m", which YouTube Music connects to."""
+        while self._running:
+            try:
+                persist_path = os.path.join(
+                    os.path.expanduser("~"), ".config", "mopidy",
+                    "dial_screen_id_music"
+                )
+                session = LoungeSession.create(
+                    self.friendly_name, persist_path=persist_path, theme="m")
+                session.bind()
+                logger.info(f"Lounge session (YouTube Music) bound — "
+                            f"SID={session.sid}")
+                self._sessions["m"] = session
+                handler = LoungeHandler(session, self.core)
+                with self._handler_lock:
+                    self._handlers["m"] = handler
+                self._run_subscriber(session, handler)
+                return
+            except Exception as e:
+                if not self._running or self._stop_event.is_set():
+                    return
+                logger.error(f"Failed to start YouTube Music session: {e} — retrying in 10s",
+                             exc_info=True)
+                time.sleep(10)
+
+    def _run_subscriber(self, session: LoungeSession, handler: LoungeHandler):
+        """Listen for events, rebinding when the SID goes stale."""
+        while self._running:
+            try:
+                result = LoungeSubscriber(
+                    session, handler, self._stop_event).run_forever()
+                logger.info(f"Lounge subscriber (theme={session.theme!r}) "
+                            f"exited: {result}")
+                if result == "stopped" or not self._running or self._stop_event.is_set():
+                    return
+                if result != "rebind":
+                    logger.warning(
+                        f"Lounge subscriber (theme={session.theme!r}) "
+                        f"unexpected exit ({result!r}) — rebinding in 5s"
+                    )
+                    time.sleep(5)
+                logger.info(f"Rebinding session (theme={session.theme!r})...")
+                session.bind()
+            except Exception as e:
+                if not self._running or self._stop_event.is_set():
+                    return
+                logger.error(
+                    f"Subscriber/rebind error (theme={session.theme!r}): {e} — retrying in 5s",
+                    exc_info=True,
+                )
+                time.sleep(5)
+
+    def _refresh_pairing_code(self, session: LoungeSession):
+        try:
+            code = session.get_pairing_code()
+            DialHandler.pairing_code = code
+            logger.info(f"YouTube pairing code: {code} "
+                        f"(enter in YouTube → Settings → Watch on TV)")
+        except Exception as e:
+            logger.warning(f"Failed to refresh pairing code: {e}")
+
+    def _pairing_code_refresher(self, session: LoungeSession):
+        """Refresh the pairing code every 4 minutes while running."""
+        while self._running:
+            # Sleep in short intervals so we respond to shutdown quickly
+            for _ in range(240):  # 240 × 1s = 4 minutes
+                if not self._running:
+                    return
+                time.sleep(1)
+            if self._running:
+                self._refresh_pairing_code(session)
+
+    def _run_session(self, screen_id: str, lounge_token: str,
+                     session: LoungeSession = None):
+        handler = None
+        try:
+            if session is None:
+                session = LoungeSession(screen_id, lounge_token,
+                                        self.friendly_name)
+            session.bind()
+            logger.info(f"Lounge session bound — SID={session.sid}")
+
+            handler = LoungeHandler(session, self.core)
+            with self._handler_lock:
+                self._handlers["token"] = handler
+            self._run_subscriber(session, handler)
+        except Exception as e:
+            logger.error(f"Lounge session error: {e}", exc_info=True)
+        finally:
+            with self._handler_lock:
+                self._handlers.pop("token", None)
+
+    # ------------------------------------------------------------------
+    # SSDP
+    # ------------------------------------------------------------------
+
+    def _ssdp_response(self) -> bytes:
+        location = (f"http://{self.local_ip}:{self.port}"
+                    f"/dial/ssdp/device-desc.xml")
+        return (
+            "HTTP/1.1 200 OK\r\n"
+            f"LOCATION: {location}\r\n"
+            "CACHE-CONTROL: max-age=1800\r\n"
+            "CONFIGID.UPNP.ORG: 7337\r\n"
+            "BOOTID.UPNP.ORG: 7337\r\n"
+            f"USN: uuid:{DialHandler.device_uuid}::{SSDP_ST}\r\n"
+            f"ST: {SSDP_ST}\r\n"
+            "\r\n"
+        ).encode()
+
+    def _run_ssdp(self):
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
+                             socket.IPPROTO_UDP)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        try:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+        except AttributeError:
+            pass
+        sock.bind(("", SSDP_PORT))
+        mreq = struct.pack("4sL", socket.inet_aton(SSDP_ADDR),
+                           socket.INADDR_ANY)
+        sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
+        sock.settimeout(1.0)
+        logger.info(f"SSDP listening on {SSDP_ADDR}:{SSDP_PORT}")
+
+        while self._running:
+            try:
+                data, addr = sock.recvfrom(4096)
+                msg = data.decode("utf-8", errors="replace")
+                if "M-SEARCH" in msg and (
+                    SSDP_ST in msg or "ssdp:all" in msg
+                ):
+                    logger.debug(f"SSDP M-SEARCH from {addr[0]}")
+                    time.sleep(0.1)
+                    sock.sendto(self._ssdp_response(), addr)
+            except socket.timeout:
+                continue
+            except Exception as e:
+                if self._running:
+                    logger.error(f"SSDP error: {e}")
+        sock.close()
+
+    def _run_notify(self):
+        location = (f"http://{self.local_ip}:{self.port}"
+                    f"/dial/ssdp/device-desc.xml")
+
+        def packet(nts="ssdp:alive"):
+            return (
+                "NOTIFY * HTTP/1.1\r\n"
+                f"HOST: {SSDP_ADDR}:{SSDP_PORT}\r\n"
+                "CACHE-CONTROL: max-age=1800\r\n"
+                f"LOCATION: {location}\r\n"
+                f"NT: {SSDP_ST}\r\n"
+                f"NTS: {nts}\r\n"
+                f"USN: uuid:{DialHandler.device_uuid}::{SSDP_ST}\r\n"
+                "\r\n"
+            ).encode()
+
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
+                             socket.IPPROTO_UDP)
+        sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
+
+        # Wait until the lounge session is fully bound before announcing.
+        # This prevents apps from discovering us, polling /apps/YouTube,
+        # and reading empty credentials due to a startup race condition.
+        logger.debug("SSDP notify waiting for session to be ready...")
+        self._session_ready.wait(timeout=30)
+        if not self._running:
+            return
+        logger.info("SSDP notify: session ready, starting announcements")
+
+        for _ in range(3):
+            sock.sendto(packet(), (SSDP_ADDR, SSDP_PORT))
+            time.sleep(0.2)
+
+        while self._running:
+            time.sleep(30)
+            if self._running:
+                sock.sendto(packet(), (SSDP_ADDR, SSDP_PORT))
+
+        sock.sendto(packet("ssdp:byebye"), (SSDP_ADDR, SSDP_PORT))
+        sock.close()

mopidy_dial/lounge_commander.py

@@ -0,0 +1,96 @@
+"""
+lounge_commander.py
+-------------------
+Sends commands from the screen back to the YouTube Lounge API.
+All methods take a LoungeSession and use its current state (SID,
+gsessionid, AID, RID) to build the correct request.
+"""
+
+import urllib.request
+import urllib.parse
+from mopidy_dial import logger
+from .lounge_session import LoungeSession, API_BASE
+
+
+class LoungeCommander:
+    def __init__(self, session: LoungeSession):
+        self.session = session
+
+    def send(self, sc: str, params: dict = {}) -> bool:
+        """
+        Send a single screen command (_sc) with optional parameters.
+        Returns True on success, False on failure.
+        """
+        s = self.session
+        with s.send_lock:
+            return self._send_locked(sc, params)
+
+    def _send_locked(self, sc: str, params: dict) -> bool:
+        s = self.session
+        rid = s.rid
+        s.rid += 1  # RIDs are consumed even if the request fails
+        ofs = s.ofs
+        s.ofs += 1
+        query = urllib.parse.urlencode({
+            **s.common_query_params,
+            "RID": rid,
+            "AID": s.aid,
+            "CVER": "1",
+        })
+        url = f"{API_BASE}/bc/bind?{query}"
+
+        body = {"count": "1", "ofs": str(ofs), "req0__sc": sc}
+        for k, v in params.items():
+            body[f"req0_{k}"] = str(v)
+
+        payload = urllib.parse.urlencode(body).encode()
+        headers = {
+            **s.common_headers,
+            "Content-Type": "application/x-www-form-urlencoded",
+        }
+
+        try:
+            req = urllib.request.Request(url, data=payload, headers=headers)
+            resp = urllib.request.urlopen(req, timeout=15)
+            reply = resp.read()
+            logger.debug(f"Sent '{sc}' OK (RID={rid} ofs={ofs}) {params} -> {resp.status} {reply[:120]!r}")
+            return True
+        except Exception as e:
+            logger.warning(f"Failed to send '{sc}' (RID={rid}): {e}")
+            return False
+
+    # --- Convenience wrappers ---
+
+    def now_playing(self, video_id="", list_id="", state="-1",
+                    current_time="0", duration="0", cpn=""):
+        return self.send("nowPlaying", {
+            "videoId": video_id,
+            "listId": list_id,
+            "state": state,
+            "currentTime": current_time,
+            "duration": duration,
+            "cpn": cpn,
+        })
+
+    def state_change(self, state: str, current_time="0", duration="0",
+                     video_id="", cpn=""):
+        params = {"state": state, "currentTime": current_time, "duration": duration}
+        if video_id:
+            params["videoId"] = video_id
+        if cpn:
+            params["cpn"] = cpn
+        return self.send("onStateChange", params)
+
+    def volume_changed(self, volume: int, muted: bool = False):
+        return self.send("onVolumeChanged", {
+            "volume": volume,
+            "muted": str(muted).lower(),
+        })
+
+    def discovery_device_id(self, device_id: str):
+        return self.send("onDiscoveryDeviceIdRetrieved", {
+            "discoveryDeviceId": device_id,
+        })
+
+    def noop(self):
+        return self.send("noop")