Make the volume handler multithreaded and event based on the spotify side, combine both prior volumes into a more authoritative "shared volume" that is checked against as the authority for what is true or what should become true

Author: SteveMicroNova

streams/spotify_volume_handler.py

@@ -2,6 +2,11 @@
 import argparse
 from time import sleep
 import requests
+import websockets
+from spot_connect_meta import Event
+import json
+import asyncio
+import threading
 
 
 class SpotifyData:
@@ -10,27 +15,39 @@ def __init__(self, api_port, debug=False):
     self.api_port: int = api_port
     self.debug = debug
 
-    self.status: dict = self.get_status()
-    self.last_volume: int = self.get_volume()
+    self.volume: int = None
 
-  def get_status(self):
-    self.status = requests.get(f"http://localhost:{self.api_port}/status", timeout=5).json()
+    threading.Thread(target=self.run_async_watch, daemon=True).start()
+
+  def run_async_watch(self):
+    asyncio.run(self.watch_vol())
 
-  def get_volume(self):  # Not terribly useful, but it's nice to have parity with the AmpliPiData object
-    if self.status:
-      if self.debug:
-        print(f"Got Spotify volume: {self.status['volume']}")
-      return self.status["volume"]
+  async def watch_vol(self):
+    try:
+      # Connect to the websocket and listen for state changes
+      async with websockets.connect(f"ws://localhost:{self.api_port}/events", open_timeout=5) as websocket:
+        while True:
+          print("Watching volume!")
+          try:
+            msg = await websocket.recv()
+            event = Event.from_json(json.loads(msg))
+            if event.event_type == "volume":
+              self.volume = event.data.value
+
+          except Exception as e:
+            print(f"Error: {e}")
+            return
+    except Exception as e:
+      print(f"Error: {e}")
+      return
 
 
 class AmpliPiData:
 
   def __init__(self, source_id, debug=False):
     self.source_id = source_id
     self.debug = debug
-
-    self.status: dict = self.get_status()
-    self.last_volume: float = self.get_volume()
+    self.status: dict = None
 
     self.connected_zones: list = []
 
@@ -40,12 +57,12 @@ def get_status(self):
     self.connected_zones = [zone for zone in self.status["zones"] if zone["source_id"] == self.source_id]
 
   def get_volume(self):
+    if not self.status:
+      self.get_status()
+
     if self.connected_zones:
       total_vol_f = sum([zone["vol_f"] for zone in self.connected_zones])
-      avg_vol = total_vol_f / len(self.connected_zones)
-      if self.debug:
-        print(f"Got AmpliPi volume: {avg_vol}")
-      return avg_vol
+      return round(total_vol_f / len(self.connected_zones), 3)  # Round down to 2 decimals
 
 
 class SpotifyVolumeHandler:
@@ -54,54 +71,45 @@ def __init__(self, port, debug=False):
     self.amplipi = AmpliPiData(port - 3679, debug)
     self.spotify = SpotifyData(port, debug)
     self.debug: bool = debug
+    self.shared_volume = self.amplipi.get_volume()
 
-  def update_amplipi_volume(self, volume):
+  def update_amplipi_volume(self, amplipi_volume):
     """Update AmpliPi's volume via the Spotify client volume slider"""
-    delta = float((volume - self.spotify.last_volume) / 100)
+    delta = float((self.spotify.volume / 100) - amplipi_volume)
     requests.patch("http://localhost/api/zones", json={"zones": [zone["id"] for zone in self.amplipi.connected_zones], "update": {"vol_delta_f": delta, "mute": False}}, timeout=5)
-    self.spotify.last_volume = volume
+    self.shared_volume = self.spotify.volume / 100
 
-  def update_spotify_volume(self, volume):
+  def update_spotify_volume(self, amplipi_volume):
     """Update the Spotify client's volume slider position based on the averaged volume of all connected zones in AmpliPi"""
     if self.debug:
-      print(f"Spotify vol updated: {volume}")
+      print(f"Spotify vol updated: {amplipi_volume}")
     url = f"http://localhost:{self.spotify.api_port}"
-    new_vol = int(volume * 100)
-    print(f"vol: {volume}, last_vol: {self.amplipi.last_volume}")
+    new_vol = int(amplipi_volume * 100)
     requests.post(url + '/player/volume', json={"volume": new_vol}, timeout=5)
-    self.amplipi.last_volume = volume
-    self.spotify.last_volume = new_vol
-
-  def get_statuses(self):
-    self.amplipi.get_status()
-    if self.amplipi.last_volume is None:
-      self.amplipi.last_volume = self.amplipi.get_volume()
-
-    self.spotify.get_status()
-    if self.spotify.last_volume is None:
-      self.spotify.last_volume = self.spotify.get_volume()
+    self.shared_volume = amplipi_volume
 
   def handle_volumes(self):
     while True:
       try:
-        self.get_statuses()
+        self.amplipi.get_status()
         amplipi_volume = self.amplipi.get_volume()
-        spotify_volume = self.spotify.get_volume()
 
         if self.debug:
-          print(f"amplipi: {amplipi_volume}, last: {self.amplipi.last_volume}")
-          print(f"spotify: {spotify_volume}, last: {self.spotify.last_volume}")
+          print(f"amplipi: {amplipi_volume}, spotify: {self.spotify.volume}, shared: {self.shared_volume}")
           print("\n\n\n")
-        if spotify_volume != self.spotify.last_volume:
+
+        if self.spotify.volume is None:  # Useful for getting spotify's initial state (by forcibly setting it)
+          self.update_spotify_volume(amplipi_volume)
+        elif self.spotify.volume != (self.shared_volume * 100):
           if self.debug:
-            print("Updating spotify vol...")
-          self.update_amplipi_volume(spotify_volume)
-        elif amplipi_volume != self.amplipi.last_volume or int(amplipi_volume * 100) != spotify_volume:
+            print("Updating AmpliPi vol...")
+          self.update_amplipi_volume(amplipi_volume)
+        elif amplipi_volume != self.shared_volume or (int(amplipi_volume * 100) != self.spotify.volume):
           if self.debug:
-            print("Updating amplipi vol...")
+            print("Updating Spotify vol...")
           self.update_spotify_volume(amplipi_volume)
       except Exception as e:
-        print(f"ERROR: {e}")
+        print(f"Error: {e}")
       sleep(2)
 
 
@@ -114,13 +122,14 @@ def handle_volumes(self):
 
   args = parser.parse_args()
 
+  handler = SpotifyVolumeHandler(args.port, args.debug)
   while (True):
     try:
-      SpotifyVolumeHandler(args.port, args.debug).handle_volumes()
+      handler.handle_volumes()
     except (KeyboardInterrupt, SystemExit):
       print("Exiting...")
       break
     except Exception as e:
-      print(f"Error: {e}")
+      print(f"Error 139: {e}")
       sleep(5)
       continue