Multi Player Support

src/jukebox/components/player/backends/mpd/interfacing_mpd.py

@@ -5,6 +5,7 @@
 import logging
 import os.path
 import re
+from pathlib import Path
 from typing import Optional
 
 import jukebox.plugs as plugin
@@ -13,6 +14,7 @@
 
 from mpd.asyncio import MPDClient
 from components.player.backends import BackendPlayer
+from components.player.core.coverart_cache_manager import CoverartCacheManager
 from jukebox import publishing
 
 logger = logging.getLogger('jb.mpd')
@@ -36,6 +38,7 @@ def __init__(self, event_loop):
         self.loop = event_loop
         self.host = cfg.setndefault('playermpd', 'host', value='localhost')
         self.port = cfg.setndefault('playermpd', 'port', value='6600')
+        self.coverart_cache_manager = CoverartCacheManager()
         self._flavors = {'folder': self.get_files,
                          'file': self.get_track,
                          'album': self.get_album_from_uri,
@@ -45,7 +48,7 @@ def __init__(self, event_loop):
         # TODO: If connect fails on first try this is non recoverable
         self.connect()
         # Start the status listener in an endless loop in the event loop
-        asyncio.run_coroutine_threadsafe(self._status_listener(), self.loop)
+        # asyncio.run_coroutine_threadsafe(self._status_listener(), self.loop)
 
     # ------------------------------------------------------------------------------------------------------
     # Bring calls to client functions from the synchronous part into the async domain
@@ -92,21 +95,28 @@ async def _status_listener(self):
             # logger.debug("MPD: Idle change in", subsystem)
             s = await self.client.status()
             # logger.debug(f"MPD: New Status: {s.result()}")
-            print(f"MPD: New Status: {type(s)} // {s}")
+            #print(f"MPD: New Status: {type(s)} // {s}")
             # Now, do something with it ...
             publishing.get_publisher().send('playerstatus', s)
 
+
     async def _status(self):
         return await self.client.status()
 
     @plugin.tag
     def status(self):
         """Refresh the current MPD status (by a manual, sync trigger)"""
+        # Example
+        # Status: {'volume': '40', 'repeat': '0', 'random': '0', 'single': '0', 'consume': '0', 'partition': 'default',
+        # 'playlist': '94', 'playlistlength': '22', 'mixrampdb': '0.000000', 'state': 'play', 'song': '0',
+        # 'songid': '71', 'time': '1:126', 'elapsed': '1.108', 'bitrate': '96', 'duration': '125.988',
+        # 'audio': '44100:24:2', 'nextsong': '1', 'nextsongid': '72'}
         f = asyncio.run_coroutine_threadsafe(self._status(), self.loop).result()
-        print(f"Status: {f}")
+        # print(f"Status: {f}")
         # Put it into unified structure and notify global player control
         # ToDo: propagate to core player
-        publishing.get_publisher().send('playerstatus', f)
+        # publishing.get_publisher().send('playerstatus', f)
+        return f
 
     # -----------------------------------------------------
     # Stuff that controls current playback (i.e. moves around in the current playlist, termed "the queue")
@@ -295,7 +305,10 @@ def get_album_from_uri(self, uri: str):
         return self.get_album_tracks(album_artist=p.group(4), album=p.group(3))
 
     def get_single_coverart(self, song_url):
-        pass
+        mp3_file_path = Path(get_music_library_path(), song_url).expanduser()
+        cache_filename = self.coverart_cache_manager.get_cache_filename(mp3_file_path)
+
+        return cache_filename
 
     def get_album_coverart(self):
         pass

src/jukebox/components/player/core/__init__.py

@@ -19,6 +19,8 @@
 from typing import Dict, Callable, Optional, Any
 
 import jukebox.plugs as plugin
+from components.player.core.player_status import PlayerStatus
+from jukebox import multitimer
 
 logger = logging.getLogger('jb.player')
 
@@ -29,12 +31,23 @@ class PlayerCtrl:
     def __init__(self):
         self._backends: Dict[str, Any] = {}
         self._active = None
+        self.player_status = None
+        self.status_poll_interval = 0.25
+        self.status_thread = multitimer.GenericEndlessTimerClass('player.timer_status',
+                                                                 self.status_poll_interval, self._status_poll)
+        self.status_thread.start()
+
+    def _status_poll(self):
+        ret_status = self._active.status()
+        if ret_status.get('state') == 'play':
+            self.player_status.update(playing=True, elapsed=ret_status.get('elapsed', '0.0'), duration=ret_status.get('duration', '0.0') )
 
     def register(self, name: str, backend):
         self._backends[name] = backend
         # For now simply default to first registered backend
         if self._active is None:
             self._active = self._backends.values().__iter__().__next__()
+            self.player_status.update(player=name)
 
     @plugin.tag
     def get_active(self):
@@ -64,6 +77,7 @@ def play_uri(self, uri, check_second_swipe=False, **kwargs):
         if inst is None:
             raise KeyError(f"URI player type unknown: '{player_type}'. Available backends are: {self._backends.keys()}.")
         self._active = self._backends.get(player_type)
+        self.player_status.update(player=player_type)
         self._active.play_uri(uri, **kwargs)
 
     def _is_second_swipe(self):
@@ -106,22 +120,30 @@ def prev(self):
     @plugin.tag
     def play(self):
         self._active.play()
+        self.player_status.update(playing=True)
 
     @plugin.tag
     def play_single(self, uri):
         self.play_uri(uri)
+        self.player_status.update(playing=True)
 
     @plugin.tag
     def play_album(self, albumartist, album):
         self._active.play_album(albumartist, album)
+        self.player_status.update(playing=True)
 
     @plugin.tag
     def play_folder(self, folder, recursive):
         self._active.play_folder(folder, recursive)
+        self.player_status.update(playing=True)
 
     @plugin.tag
     def toggle(self):
         self._active.toggle()
+        if self.player_status.get_value('playing') is False:
+            self.player_status.update(playing=True)
+        else:
+            self.player_status.update(playing=False)
 
     @plugin.tag
     def shuffle(self, option='toggle'):
@@ -133,12 +155,14 @@ def shuffle(self, option='toggle'):
     @plugin.tag
     def pause(self):
         self._active.pause()
+        self.player_status.update(playing=False)
 
     @plugin.tag
     def stop(self):
         # Save current state for resume functionality
         self._save_state()
         self._active.stop()
+        self.player_status.update(playing=False)
 
     @plugin.tag
     def get_queue(self):

src/jukebox/components/player/core/coverart_cache_manager.py

@@ -0,0 +1,90 @@
+from mutagen.mp3 import MP3
+from mutagen.id3 import ID3, APIC
+from pathlib import Path
+import hashlib
+import logging
+from queue import Queue
+from threading import Thread
+import jukebox.cfghandler
+
+COVER_PREFIX = 'cover'
+NO_COVER_ART_EXTENSION = 'no-art'
+NO_CACHE = ''
+CACHE_PENDING = 'CACHE_PENDING'
+
+logger = logging.getLogger('jb.CoverartCacheManager')
+cfg = jukebox.cfghandler.get_handler('jukebox')
+
+
+class CoverartCacheManager:
+    def __init__(self):
+        coverart_cache_path = cfg.setndefault('webapp', 'coverart_cache_path', value='../../src/webapp/build/cover-cache')
+        self.cache_folder_path = Path(coverart_cache_path).expanduser()
+        self.write_queue = Queue()
+        self.worker_thread = Thread(target=self.process_write_requests)
+        self.worker_thread.daemon = True  # Ensure the thread closes with the program
+        self.worker_thread.start()
+
+    def generate_cache_key(self, base_filename: str) -> str:
+        return f"{COVER_PREFIX}-{hashlib.sha256(base_filename.encode()).hexdigest()}"
+
+    def get_cache_filename(self, mp3_file_path: str) -> str:
+        base_filename = Path(mp3_file_path).stem
+        cache_key = self.generate_cache_key(base_filename)
+
+        for path in self.cache_folder_path.iterdir():
+            if path.stem == cache_key:
+                if path.suffix == f".{NO_COVER_ART_EXTENSION}":
+                    return NO_CACHE
+                return path.name
+
+        self.save_to_cache(mp3_file_path)
+        return CACHE_PENDING
+
+    def save_to_cache(self, mp3_file_path: str):
+        self.write_queue.put(mp3_file_path)
+
+    def _save_to_cache(self, mp3_file_path: str):
+        base_filename = Path(mp3_file_path).stem
+        cache_key = self.generate_cache_key(base_filename)
+        file_extension, data = self._extract_album_art(mp3_file_path)
+
+        cache_filename = f"{cache_key}.{file_extension}"
+        full_path = self.cache_folder_path / cache_filename  # Works due to Pathlib
+
+        with full_path.open('wb') as file:
+            file.write(data)
+            logger.debug(f"Created file: {cache_filename}")
+
+        return cache_filename
+
+    def _extract_album_art(self, mp3_file_path: str) -> tuple:
+        try:
+            audio_file = MP3(mp3_file_path, ID3=ID3)
+        except Exception as e:
+            logger.error(f"Error reading MP3 file {mp3_file_path}: {e}")
+            return (NO_COVER_ART_EXTENSION, b'')
+
+        for tag in audio_file.tags.values():
+            if isinstance(tag, APIC):
+                mime_type = tag.mime
+                file_extension = 'jpg' if mime_type == 'image/jpeg' else mime_type.split('/')[-1]
+                return (file_extension, tag.data)
+
+        return (NO_COVER_ART_EXTENSION, b'')
+
+    def process_write_requests(self):
+        while True:
+            mp3_file_path = self.write_queue.get()
+            try:
+                self._save_to_cache(mp3_file_path)
+            except Exception as e:
+                logger.error(f"Error processing write request: {e}")
+            self.write_queue.task_done()
+
+    def flush_cache(self):
+        for path in self.cache_folder_path.iterdir():
+            if path.is_file():
+                path.unlink()
+                logger.debug(f"Deleted cached file: {path.name}")
+        logger.info("Cache flushed successfully.")

src/jukebox/components/player/core/player_status.py

@@ -1,7 +1,7 @@
 import logging
 
 import jukebox.plugs as plugin
-from jukebox import publishing
+from jukebox import publishing, multitimer
 
 logger = logging.getLogger('jb.player')
 
@@ -33,6 +33,9 @@ def update(self, **kwargs):
 
         self.publish()
 
+    def get_value(self, key):
+        return self.STATUS.get(key)
+
     def publish(self):
         logger.debug(f'Published: {self._player_status}')
         return publishing.get_publisher().send(

src/jukebox/components/player/plugin/__init__.py

@@ -69,7 +69,7 @@ def initialize():
     player_arbiter = PlayerCtrl()
 
     player_status = PlayerStatus()
-    player_status.publish()
+    player_arbiter.player_status = player_status
 
     # ToDo: remove player_content
     # player_content = PlayerData()