Enorme refactoring de PMO control step 2

pmocontrol/src/queue/music_queue.rs

@@ -1,9 +1,8 @@
-use crate::RendererInfo;
-use crate::control_point::openhome_queue::OpenHomeQueue;
 use crate::errors::ControlPointError;
-use crate::openhome_playlist::OpenHomePlaylistSnapshot;
-use crate::queue::backend::{PlaybackItem, QueueBackend, QueueSnapshot};
-use crate::queue::interne::InternalQueue;
+use crate::queue::{
+    EnqueueMode, InternalQueue, OpenHomeQueue, QueueBackend, QueueFromRendererInfo,
+};
+use crate::{PlaybackItem, QueueSnapshot, RendererInfo};
 
 #[derive(Debug, Clone)]
 pub enum MusicQueue {
@@ -12,39 +11,65 @@ pub enum MusicQueue {
 }
 
 impl MusicQueue {
-
+    /// Creates a queue appropriate for the given renderer.
+    /// This is the factory method used by QueueFromRendererInfo trait.
     pub fn from_renderer_info(info: &RendererInfo) -> Result<MusicQueue, ControlPointError> {
         if info.capabilities().has_oh_playlist() {
-
-            Ok(MusicQueue::OpenHome(OpenHomeQueue::from_renderer_info(info)?))   
+            Ok(MusicQueue::OpenHome(OpenHomeQueue::from_renderer_info(
+                info,
+            )?))
         } else {
-            Ok(MusicQueue::Internal(InternalQueue::from_renderer_info(info)?))
-        }
-    }
-
-    pub fn openhome_playlist_snapshot(&self) -> Result<OpenHomePlaylistSnapshot, ControlPointError> {
-        match self {
-            MusicQueue::OpenHome(queue) => queue.openhome_playlist_snapshot(),
-            _ => Err(ControlPointError::QueueError(format!(
-                "OpenHome playlist snapshot is only available for OpenHome queues"
-            ))),
-        }
-    }
-
-    pub fn replace_with_attached_playlist(
-        &mut self,
-        items: Vec<PlaybackItem>,
-        current_index: Option<usize>,
-    ) -> Result<(), ControlPointError> {
-        match self {
-            MusicQueue::OpenHome(queue) => queue.replace_entire_playlist(items, current_index),
-            MusicQueue::Internal(queue) => queue.replace_queue(items, current_index),
+            Ok(MusicQueue::Internal(InternalQueue::from_renderer_info(
+                info,
+            )?))
         }
     }
 }
 
-
 impl QueueBackend for MusicQueue {
+    // Primitives
+    fn len(&self) -> Result<usize, ControlPointError> {
+        match self {
+            MusicQueue::Internal(q) => q.len(),
+            MusicQueue::OpenHome(q) => q.len(),
+        }
+    }
+
+    fn track_ids(&self) -> Result<Vec<u32>, ControlPointError> {
+        match self {
+            MusicQueue::Internal(q) => q.track_ids(),
+            MusicQueue::OpenHome(q) => q.track_ids(),
+        }
+    }
+
+    fn id_to_position(&self, id: u32) -> Result<usize, ControlPointError> {
+        match self {
+            MusicQueue::Internal(q) => q.id_to_position(id),
+            MusicQueue::OpenHome(q) => q.id_to_position(id),
+        }
+    }
+
+    fn position_to_id(&self, id: usize) -> Result<u32, ControlPointError> {
+        match self {
+            MusicQueue::Internal(q) => q.position_to_id(id),
+            MusicQueue::OpenHome(q) => q.position_to_id(id),
+        }
+    }
+
+    fn current_track(&self) -> Result<Option<u32>, ControlPointError> {
+        match self {
+            MusicQueue::Internal(q) => q.current_track(),
+            MusicQueue::OpenHome(q) => q.current_track(),
+        }
+    }
+
+    fn current_index(&self) -> Result<Option<usize>, ControlPointError> {
+        match self {
+            MusicQueue::Internal(q) => q.current_index(),
+            MusicQueue::OpenHome(q) => q.current_index(),
+        }
+    }
+
     fn queue_snapshot(&self) -> Result<QueueSnapshot, ControlPointError> {
         match self {
             MusicQueue::Internal(q) => q.queue_snapshot(),
@@ -70,6 +95,13 @@ impl QueueBackend for MusicQueue {
         }
     }
 
+    fn sync_queue(&mut self, items: Vec<PlaybackItem>) -> Result<(), ControlPointError> {
+        match self {
+            MusicQueue::Internal(q) => q.sync_queue(items),
+            MusicQueue::OpenHome(q) => q.sync_queue(items),
+        }
+    }
+
     fn get_item(&self, index: usize) -> Result<Option<PlaybackItem>, ControlPointError> {
         match self {
             MusicQueue::Internal(q) => q.get_item(index),
@@ -83,4 +115,75 @@ impl QueueBackend for MusicQueue {
             MusicQueue::OpenHome(q) => q.replace_item(index, item),
         }
     }
+
+    fn enqueue_items(
+        &mut self,
+        items: Vec<PlaybackItem>,
+        mode: EnqueueMode,
+    ) -> Result<(), ControlPointError> {
+        match self {
+            MusicQueue::Internal(q) => q.enqueue_items(items, mode),
+            MusicQueue::OpenHome(q) => q.enqueue_items(items, mode),
+        }
+    }
+
+    // Optimized helpers
+    fn clear_queue(&mut self) -> Result<(), ControlPointError> {
+        match self {
+            MusicQueue::Internal(q) => q.clear_queue(),
+            MusicQueue::OpenHome(q) => q.clear_queue(),
+        }
+    }
+
+    fn is_empty(&self) -> Result<bool, ControlPointError> {
+        match self {
+            MusicQueue::Internal(q) => q.is_empty(),
+            MusicQueue::OpenHome(q) => q.is_empty(),
+        }
+    }
+
+    fn upcoming_len(&self) -> Result<usize, ControlPointError> {
+        match self {
+            MusicQueue::Internal(q) => q.upcoming_len(),
+            MusicQueue::OpenHome(q) => q.upcoming_len(),
+        }
+    }
+
+    fn upcoming_items(&self) -> Result<Vec<PlaybackItem>, ControlPointError> {
+        match self {
+            MusicQueue::Internal(q) => q.upcoming_items(),
+            MusicQueue::OpenHome(q) => q.upcoming_items(),
+        }
+    }
+
+    fn peek_current(&self) -> Result<Option<(PlaybackItem, usize)>, ControlPointError> {
+        match self {
+            MusicQueue::Internal(q) => q.peek_current(),
+            MusicQueue::OpenHome(q) => q.peek_current(),
+        }
+    }
+
+    fn dequeue_next(&mut self) -> Result<Option<(PlaybackItem, usize)>, ControlPointError> {
+        match self {
+            MusicQueue::Internal(q) => q.dequeue_next(),
+            MusicQueue::OpenHome(q) => q.dequeue_next(),
+        }
+    }
+
+    fn append_or_init_index(&mut self, items: Vec<PlaybackItem>) -> Result<(), ControlPointError> {
+        match self {
+            MusicQueue::Internal(q) => q.append_or_init_index(items),
+            MusicQueue::OpenHome(q) => q.append_or_init_index(items),
+        }
+    }
+}
+
+impl QueueFromRendererInfo for MusicQueue {
+    fn from_renderer_info(renderer: &RendererInfo) -> Result<Self, ControlPointError> {
+        MusicQueue::from_renderer_info(renderer)
+    }
+
+    fn to_backend(self) -> MusicQueue {
+        self
+    }
 }