Merge branch 'main' of github.com:igfarm/roFrame

igfarm · igfarm · commit b26970fc350d · 2025-03-14T13:35:04.000-04:00
diff --git a/app.py b/app.py
@@ -4,7 +4,7 @@
 import zoneinfo
 import time
 from threading import Event
-import asyncio 
+import asyncio
 import logging
 
 from flask import Flask, render_template, jsonify, send_from_directory
@@ -21,9 +21,7 @@
 myRoonApi = None
 
 app = Flask(__name__)
-socketio = SocketIO(
-    app, cors_allowed_origins="*"
-)
+socketio = SocketIO(app, cors_allowed_origins="*")
 thread = None
 thread_stop_event = Event()
 
@@ -34,13 +32,16 @@
 display_off_hour = int(os.getenv("DISPLAY_OFF_HOUR", 23))
 display_control = os.getenv("DISPLAY_CONTROL", "off")
 slideshow_enabled = os.getenv("SLIDESHOW", "on") == "on"
-slideshow_folder = os.getenv("SLIDESHOW_FOLDER", os.path.join(app.root_path, "./pictures"))
+slideshow_folder = os.getenv(
+    "SLIDESHOW_FOLDER", os.path.join(app.root_path, "./pictures")
+)
 slideshow_transition_seconds = int(os.getenv("SLIDESHOW_TRANSITION_SECONDS", 15))
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+
 def getRoonApi():
     global myRoonApi
     if myRoonApi is None:
@@ -63,7 +64,8 @@ def background_thread():
     """
     while not thread_stop_event.is_set():
         myRoonApi = getRoonApi()
-        state = myRoonApi.get_zone_state()
+        album = myRoonApi.get_zone_data()
+        state = album.get("state")
         if state == "playing":
             display(True)
         else:
@@ -79,12 +81,14 @@ def background_thread():
 @app.route("/")
 def index():
     images = []
-    art_images = ["data:image/gif;base64,R0lGODdhAQABAIABAAAAAAAAACwAAAAAAQABAAACAkwBADs="]
+    art_images = []
     if slideshow_enabled:
         images = os.listdir(slideshow_folder)
         image_extensions = {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff"}
         images = [
-            img for img in images if os.path.splitext(img)[1].lower() in image_extensions
+            img
+            for img in images
+            if os.path.splitext(img)[1].lower() in image_extensions
         ]
         if not images:
             art_images = [generate_mondrian() for _ in range(10)]
@@ -130,29 +134,20 @@ def handle_disconnect():
 def trigger_album_update():
     logger.info("trigger_album_update")
     myRoonApi = getRoonApi()
-    copy = myRoonApi.get_copy()
-    state = myRoonApi.get_zone_state()
-    message = {
-        "name": name,
-        "album_cover_url": myRoonApi.get_image_url(image_size=image_size),
-        "state": state,
-        "image_size": image_size,
-        "album_title": copy["title"],
-        "album_artist": copy["artist"],
-        "album_track": copy["track"],
-    }
-    asyncio.run(notify_clients(message))  # Use asyncio.run to await the coroutine
-
-    if state == "playing":
+    album = myRoonApi.get_zone_data()
+    asyncio.run(notify_clients(album))  # Use asyncio.run to await the coroutine
+
+    if album["state"] == "playing":
         display(True)
 
 
 async def notify_clients(message):
     logger.info("notify_clients")
     logger.info(message)
     socketio.emit("album_update", message)
-    if "state" in message and message["state"] == "playing":
+    if message.get("state") == "playing":
         display(True)
 
+
 if __name__ == "__main__":
     socketio.run(app, debug=True, port=port, host="0.0.0.0", allow_unsafe_werkzeug=True)
diff --git a/myroonapi.py b/myroonapi.py
@@ -9,13 +9,18 @@
 
 class MyRoonApi:
 
+    BLACK_PIXEL = (
+        "data:image/gif;base64,R0lGODdhAQABAIABAAAAAAAAACwAAAAAAQABAAACAkwBADs="
+    )
+
     def __init__(self) -> None:
         self.zone_name = os.environ.get("ROON_ZONE", None)
         self.core_id_fname = os.environ.get("ROON_CORE_ID_FNAME", "roon_core_id.txt")
         self.token_fname = os.environ.get("ROON_TOKEN_FNAME", "roon_token.txt")
         self.clients = set()
         self.notify_clients: Optional[Callable[[Dict[str, Any]], None]] = None
         self.logger = logging.getLogger(__name__)
+        self.image_size = os.environ.get("IMAGE_SIZE", 600)
 
         if self.zone_name is None:
             raise Exception(
@@ -52,10 +57,14 @@ def register(self) -> None:
         self.__save_credentials(api.core_id, api.token)
         api.stop()
 
-    def connect(self, notify_clients: Optional[Callable[[Dict[str, Any]], None]] = None) -> None:
+    def connect(
+        self, notify_clients: Optional[Callable[[Dict[str, Any]], None]] = None
+    ) -> None:
         self.roonapi = None
 
-        if not os.path.exists(self.core_id_fname) or not os.path.exists(self.token_fname):
+        if not os.path.exists(self.core_id_fname) or not os.path.exists(
+            self.token_fname
+        ):
             self.logger.info("Please authorise first using discovery.py")
             exit()
 
@@ -72,55 +81,47 @@ def connect(self, notify_clients: Optional[Callable[[Dict[str, Any]], None]] = N
 
             self.logger.info(server)
             self.roonapi = RoonApi(self.appinfo, token, server[0], server[1], True)
-
             self.notify_clients = notify_clients
-            self.roonapi.register_queue_callback(self.__queue_callback, self.get_zone_id())
+
+            album = self.get_zone_data()
+
+            self.roonapi.register_queue_callback(
+                self.__queue_callback, album["zone_id"]
+            )
             self.roonapi.register_state_callback(self.__state_callback)
         except OSError:
             self.logger.info("Please authorise first using discovery.py")
             exit()
 
-    def get_zone_id(self) -> Optional[str]:
+    def get_zone_data(self) -> Optional[str]:
         roonapi = self.__get_roonapi()
         for zone_id, zone_info in roonapi.zones.items():
             if zone_info["display_name"] == self.zone_name:
-                return zone_id
-        return None
-
-    def get_zone_state(self) -> Optional[str]:
-        roonapi = self.__get_roonapi()
-        zone_id = self.get_zone_id()
-        if zone_id:
-            return roonapi.zones[zone_id]["state"]
-        return None
-
-    def get_image_url(self, image_size: int = 600) -> str:
-        # start with a single pixel gif
-        image_url = "data:image/gif;base64,R0lGODdhAQABAIABAAAAAAAAACwAAAAAAQABAAACAkwBADs="
-        if self.get_zone_state() in ["playing", "paused"]:
-            roonapi = self.__get_roonapi()
-            zone_id = self.get_zone_id()
-            if zone_id:
-                zone = roonapi.zones[zone_id]
-                if "now_playing" in zone:
-                    image_key = zone["now_playing"]["image_key"]
-                    image_url = roonapi.get_image(image_key, width=image_size, height=image_size)
-        return image_url
-
-    def get_copy(self) -> Dict[str, str]:
-        if self.get_zone_state() == "playing":
-            roonapi = self.__get_roonapi()
-            zone_id = self.get_zone_id()
-            if zone_id:
                 zone = roonapi.zones[zone_id]
+                # pprint(zone )
+                data = {
+                    "state": zone["state"],
+                    "zone_id": zone_id,
+                    "url": self.BLACK_PIXEL,
+                    "artist": "",
+                    "title": "",
+                    "track": "",
+                }
                 if "now_playing" in zone:
-                    lines = zone["now_playing"]["three_line"]
-                    return {
-                        "artist": lines["line2"],
-                        "title": lines["line3"],
-                        "track": lines["line1"],
-                    }
-        return {"artist": "", "title": "", "track": ""}
+                    data.update(self.__get_album_data(zone["now_playing"]))
+                return data
+        return None
+
+    def __get_album_data(self, now_playing) -> Dict[str, Any]:
+        return {
+            "image_size": self.image_size,
+            "artist": now_playing["three_line"]["line2"],
+            "title": now_playing["three_line"]["line3"],
+            "track": now_playing["three_line"]["line1"],
+            "url": self.roonapi.get_image(
+                now_playing["image_key"], width=self.image_size, height=self.image_size
+            ),
+        }
 
     def __save_credentials(self, core_id: str, token: str) -> None:
         with open(self.core_id_fname, "w") as f:
@@ -130,18 +131,9 @@ def __save_credentials(self, core_id: str, token: str) -> None:
 
     def __state_callback(self, event: str, changed_items: Any) -> None:
         if event == "zones_changed":
-            state = self.get_zone_state()
-            copy = self.get_copy()
-            url = self.get_image_url()
-            evdata = {
-                "album_artist": copy["artist"],
-                "album_title": copy["title"],
-                "album_track": copy["track"],
-                "album_cover_url": url,
-                "state": state,
-            }
+            data = self.get_zone_data()
             if self.notify_clients:
-                asyncio.run(self.notify_clients(evdata))
+                asyncio.run(self.notify_clients(data))
 
     def __get_roonapi(self) -> RoonApi:
         if self.roonapi is None:
@@ -161,14 +153,5 @@ def __queue_callback(self, data: Dict[str, Any]) -> None:
         self.logger.info("queue_callback")
         album = self.__extract_album(data)
         if album and self.notify_clients:
-            img = self.roonapi.get_image(album["image_key"], width=600, height=600)
-            evdata = {
-                "album_artist": album["three_line"]["line2"],
-                "album_title": album["three_line"]["line3"],
-                "album_track": album["three_line"]["line1"],
-                "album_cover_url": img,
-                "state": self.get_zone_state(),
-            }
+            evdata = self.__get_album_data(album)
             asyncio.run(self.notify_clients(evdata))
-
-
diff --git a/templates/index.html b/templates/index.html
@@ -74,7 +74,7 @@
         socket.on('album_update', function(data) {
             console.log('Album update received:', data)
 
-            if (data.album_cover_url !== undefined) {
+            if (data.url !== undefined) {
                 console.log("updating album");
 
                 if (data.state === 'playing') {
@@ -83,10 +83,10 @@
                     document.getElementById('album_track').style.fontSize = '1px';
 
                     document.getElementById('album_info').classList.remove('d-none');
-                    document.getElementById('album_img').src = data.album_cover_url;
-                    document.getElementById('album_artist').innerText = data.album_artist;
-                    document.getElementById('album_title').innerText = data.album_title;
-                    document.getElementById('album_track').innerText = data.album_track;
+                    document.getElementById('album_img').src = data.url;
+                    document.getElementById('album_artist').innerText = data.artist;
+                    document.getElementById('album_title').innerText = data.title;
+                    document.getElementById('album_track').innerText = data.track;
 
                     let size = getFonteSize(document.getElementById('album_artist').innerText, 40, 80);
                     document.getElementById('album_artist').style.fontSize = size + 'px';
