feat:spotifyd_integration (#13)

* feat:spotifyd_integration

* feat:spotifyd_integration

Author: JarbasAl

ovos_media_plugin_spotify/__init__.py

@@ -4,6 +4,7 @@
 from ovos_utils.log import LOG
 
 from ovos_media_plugin_spotify.spotify_client import SpotifyClient
+from ovos_media_plugin_spotify.spotifyd import SpotifydHooks
 
 
 class SpotifyOCPAudioService(AudioPlayerBackend):
@@ -15,8 +16,12 @@ def __init__(self, config, bus=None):
         super().__init__(config, bus)
         self.spotify = SpotifyClient()
         self._paused = False
-        self.ts = 0
+        self._last_sync_ts = 0
         self.device_name = self.config.get("identifier")  # device name in spotify
+        self.hooks = SpotifydHooks(bus=self.bus,
+                                   track_start_callback=self.on_track_start,
+                                   track_end_callback=self.on_track_end,
+                                   track_error_callback=self.on_track_error)
 
     @property
     def device(self):
@@ -32,24 +37,30 @@ def supported_uris(self):
             return []
         return ['spotify']
 
-    def on_track_start(self):
-        self.ts = time.time()
+    def on_track_start(self, uri: str = ""):
+        self._now_playing = uri or self._now_playing
+        self._last_sync_ts = time.time()
         # Indicate to audio service which track is being played
         if self._track_start_callback:
             self._track_start_callback(self._now_playing)
 
-    def on_track_end(self):
+    def on_track_end(self, uri: str = ""):
+        if not uri:
+            self.hooks.reset_metadata()
         self._paused = False
-        self.ts = 0
+        self._last_sync_ts = 0
         if self._track_start_callback:
             self._track_start_callback(None)
 
-    def on_track_error(self):
+    def on_track_error(self, uri: str = ""):
+        if not uri:
+            self.hooks.reset_metadata()
         self._paused = False
-        self.ts = 0
+        self._last_sync_ts = 0
         self.ocp_error()
 
     def play(self):
+        self.hooks.preload_uri(self._now_playing)
         self.on_track_start()
         try:
             self.spotify.play([self._now_playing],
@@ -60,7 +71,7 @@ def play(self):
 
     def _wait_until_finished(self):
         # pool spotify to see when the player becomes inactive
-        while self.ts > 0:
+        while self._last_sync_ts > 0:
             time.sleep(2)
             for d in self.spotify.devices:
                 if d["name"] == self.device_name and not d["is_active"]:
@@ -98,17 +109,13 @@ def get_track_length(self) -> int:
         """
         getting the duration of the audio in milliseconds
         """
-        # we only can estimate how much we already played as a minimum value
-        return self.get_track_position()
+        return self.hooks.get_track_length()
 
     def get_track_position(self) -> int:
         """
         get current position in milliseconds
         """
-        # approximate given timestamp of playback start
-        if self.ts:
-            return int((time.time() - self.ts) * 1000)
-        return 0
+        return self.hooks.get_track_position()
 
     def set_track_position(self, milliseconds):
         """

ovos_media_plugin_spotify/audio.py

@@ -4,6 +4,7 @@
 from ovos_utils.log import LOG
 
 from ovos_media_plugin_spotify.spotify_client import SpotifyClient
+from ovos_media_plugin_spotify.spotifyd import SpotifydHooks
 
 
 class SpotifyAudioService(AudioBackend):
@@ -15,8 +16,12 @@ def __init__(self, config, bus, name='spotify'):
         super().__init__(config, bus, name)
         self.spotify = SpotifyClient()
         self._paused = False
-        self.ts = 0
+        self._last_sync_ts = 0
         self.device_name = self.config.get("identifier")  # device name in spotify
+        self.hooks = SpotifydHooks(bus=self.bus,
+                                   track_start_callback=self.on_track_start,
+                                   track_end_callback=self.on_track_end,
+                                   track_error_callback=self.on_track_error)
 
     @property
     def device(self):
@@ -32,25 +37,31 @@ def supported_uris(self):
             return []
         return ['spotify']
 
-    def on_track_start(self):
-        self.ts = time.time()
+    def on_track_start(self, uri: str = ""):
+        self._now_playing = uri or self._now_playing
+        self._last_sync_ts = time.time()
         # Indicate to audio service which track is being played
         if self._track_start_callback:
             # TODO why is it None sometimes?
             if self._now_playing:
                 self._track_start_callback(self._now_playing)
 
-    def on_track_end(self):
+    def on_track_end(self, uri: str = ""):
+        if not uri:
+            self.hooks.reset_metadata()
         self._paused = False
-        self.ts = 0
+        self._last_sync_ts = 0
         if self._track_start_callback:
             self._track_start_callback(None)
 
-    def on_track_error(self):
+    def on_track_error(self, uri: str = ""):
+        if not uri:
+            self.hooks.reset_metadata()
         self._paused = False
-        self.ts = 0
+        self._last_sync_ts = 0
 
     def play(self, repeat=False):
+        self.hooks.preload_uri(self._now_playing)
         self.on_track_start()
         try:
             self.spotify.play([self._now_playing],
@@ -61,7 +72,7 @@ def play(self, repeat=False):
 
     def _wait_until_finished(self):
         # pool spotify to see when the player becomes inactive
-        while self.ts > 0:
+        while self._last_sync_ts > 0:
             time.sleep(2)
             for d in self.spotify.devices:
                 if d["name"] == self.device_name and not d["is_active"]:
@@ -106,17 +117,13 @@ def get_track_length(self) -> int:
         """
         getting the duration of the audio in milliseconds
         """
-        # we only can estimate how much we already played as a minimum value
-        return self.get_track_position()
+        return self.hooks.get_track_length()
 
     def get_track_position(self) -> int:
         """
         get current position in milliseconds
         """
-        # approximate given timestamp of playback start
-        if self.ts:
-            return int((time.time() - self.ts) * 1000)
-        return 0
+        return self.hooks.get_track_position()
 
     def set_track_position(self, milliseconds):
         """

ovos_media_plugin_spotify/spotifyd.py

@@ -0,0 +1,122 @@
+import time
+
+from ovos_bus_client.message import Message
+
+
+class SpotifydHooks:
+    def __init__(self, bus,
+                 track_start_callback=None,
+                 track_end_callback=None,
+                 track_error_callback=None):
+        self.current_uri = None
+        self._last_sync_ts = 0
+        self._track_len = 0
+        self._track_pos = 0
+        self.bus = bus
+
+        self.track_start_callback = track_start_callback
+        self.track_end_callback = track_end_callback
+        self.track_error_callback = track_error_callback
+
+        self.bus.on("spotifyd.start", self.on_spotify_start)
+        self.bus.on("spotifyd.play", self.on_spotify_play)
+        self.bus.on("spotifyd.pause", self.on_spotify_pause)
+        self.bus.on("spotifyd.stop", self.on_spotify_stop)
+        self.bus.on("spotifyd.load", self.on_spotify_load)
+        self.bus.on("spotifyd.end_of_track", self.on_spotify_end)
+        self.bus.on("spotifyd.change", self.on_spotify_change)
+        self.bus.on("spotifyd.preloading", self.on_spotify_preloading)
+
+    def reset_metadata(self):
+        self.current_uri = None
+        self._last_sync_ts = 0
+        self._track_len = 0
+        self._track_pos = 0
+
+    def preload_uri(self, uri: str):
+        self.reset_metadata()
+        self.current_uri = uri
+        self._last_sync_ts = time.time()
+
+    def get_track_length(self) -> int:
+        """
+        getting the duration of the audio in milliseconds
+        """
+        return self._track_len or self.get_track_position()
+
+    def get_track_position(self) -> int:
+        """
+        get current position in milliseconds
+        """
+        pos = self._track_pos or 0
+        if self._last_sync_ts:  # add the elapsed time since last update of self._track_pos
+            pos += (time.time() - self._last_sync_ts) * 1000
+        if not self._track_len:
+            self._track_len = pos
+        return min(pos, self._track_len)
+
+    ##################
+    # spotifyd hooks
+    def on_spotify_start(self, message: Message):
+        self._last_sync_ts = time.time()
+        self.current_uri = "spotify:track:" + message.data["track_id"]
+        self._track_pos = message.data["position"]  # milliseconds
+        self.bus.emit(message.forward("ovos.common_play.media.state",
+                                      {"state": 2}))  # loading media
+
+    def on_spotify_play(self, message: Message):
+        self._last_sync_ts = time.time()
+        self.current_uri = "spotify:track:" + message.data["track_id"]
+        self._track_len = message.data["duration"]  # milliseconds
+        self._track_pos = message.data["position"]  # milliseconds
+        self.bus.emit(message.forward("ovos.common_play.player.state",
+                                      {"state": 1}))  # playing
+        self.bus.emit(message.forward("ovos.common_play.media.state",
+                                      {"state": 6}))  # buffered media
+        if self.track_start_callback is not None:
+            self.track_start_callback(self.current_uri)
+
+    def on_spotify_stop(self, message: Message):
+        self.current_uri = None
+        self._track_len = 0
+        self._track_pos = 0
+        self._last_sync_ts = 0
+        self.bus.emit(message.forward("ovos.common_play.media.state",
+                                      {"state": 1}))  # no media
+        self.bus.emit(message.forward("ovos.common_play.player.state",
+                                      {"state": 0}))  # stopped
+
+    def on_spotify_pause(self, message: Message):
+        self.current_uri = "spotify:track:" + message.data["track_id"]
+        self._track_len = message.data["duration"]  # milliseconds
+        self._track_pos = message.data["position"]  # milliseconds
+        self._last_sync_ts = 0
+        self.bus.emit(message.forward("ovos.common_play.player.state",
+                                      {"state": 2}))  # paused
+
+    def on_spotify_load(self, message: Message):
+        self._last_sync_ts = time.time()
+        self._track_pos = message.data["position"]  # milliseconds
+        self.current_uri = "spotify:track:" + message.data["track_id"]
+
+    def on_spotify_preloading(self, message: Message):
+        # when track is about to end we get info about next song
+        # we could show a "coming up next" popup
+        pass
+
+    def on_spotify_end(self, message: Message):
+        self._track_pos = self._track_len
+        self.bus.emit(message.forward("ovos.common_play.player.state",
+                                      {"state": 2}))  # paused
+        self.bus.emit(message.forward("ovos.common_play.media.state",
+                                      {"state": 7}))  # end of media
+        if self.track_end_callback is not None:
+            self.track_end_callback(self.current_uri)
+
+    def on_spotify_change(self, message: Message):
+        self.current_uri = "spotify:track:" + message.data["track_id"]
+        self._last_sync_ts = time.time()
+        self.bus.emit(message.forward("ovos.common_play.player.state",
+                                      {"state": 2}))  # paused
+        self.bus.emit(message.forward("ovos.common_play.media.state",
+                                      {"state": 2}))  # loading media