Add placeholders for request and stream testing

Cargo.lock

@@ -133,6 +133,7 @@ dependencies = [
  "flume",
  "ratatui",
  "tokio",
+ "tokio-stream",
  "tonic",
 ]
 

cbd-tui/Cargo.toml

@@ -11,4 +11,5 @@ crabidy-core = { path = "../crabidy-core" }
 flume = "0.10.14"
 ratatui = "0.20.1"
 tokio = { version = "1", features = ["full"] }
+tokio-stream = "0.1"
 tonic = "0.9"

cbd-tui/src/main.rs

@@ -1,5 +1,6 @@
 use crabidy_core::proto::crabidy::{
-    crabidy_service_client::CrabidyServiceClient, GetLibraryNodeRequest,
+    crabidy_service_client::CrabidyServiceClient, get_queue_updates_response::QueueUpdateResult,
+    GetLibraryNodeRequest, GetQueueUpdatesRequest, LibraryNode, LibraryNodeState,
 };
 
 use crossterm::{
@@ -22,9 +23,9 @@ use std::{
     time::{Duration, Instant},
     vec,
 };
-use tonic::Request;
-
 use tokio::task;
+use tokio_stream::StreamExt;
+use tonic::Request;
 
 struct StatefulList<T> {
     state: ListState,
@@ -84,45 +85,16 @@ impl<T> StatefulList<T> {
     }
 }
 
-struct ListNode {
-    name: String,
-    children: Option<Vec<ListNode>>,
-}
-
 struct App {
-    library: StatefulList<ListNode>,
+    library: StatefulList<LibraryNode>,
-    queue: StatefulList<ListNode>,
+    queue: StatefulList<LibraryNode>,
 }
 
 impl App {
     fn new() -> App {
         let mut library = StatefulList::default();
-        library.items.push(ListNode {
-            name: "Tidal".to_owned(),
-            children: None,
-        });
-        library.items.push(ListNode {
-            name: "YouTube".to_owned(),
-            children: None,
-        });
         library.focus();
         let mut queue = StatefulList::default();
-        queue.items.push(ListNode {
-            name: "GLaDOS - Still Alive".to_owned(),
-            children: None,
-        });
-        queue.items.push(ListNode {
-            name: "Floppotron - Star Wars Theme".to_owned(),
-            children: None,
-        });
-        queue.items.push(ListNode {
-            name: "Starcop - Starcop".to_owned(),
-            children: None,
-        });
-        queue.items.push(ListNode {
-            name: "Efence - Airglow".to_owned(),
-            children: None,
-        });
         App { library, queue }
     }
 
@@ -140,6 +112,7 @@ impl App {
 enum Message {
     Quit,
     LibraryData(String),
+    QueueData(String),
 }
 
 #[tokio::main]
@@ -153,11 +126,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let mut client = CrabidyServiceClient::connect("http://[::1]:50051").await?;
 
-    let request = Request::new(GetLibraryNodeRequest {
+    let get_library_node_request = Request::new(GetLibraryNodeRequest {
         uuid: "/".to_string(),
     });
 
-    let response = client.get_library_node(request).await?;
+    let response = client.get_library_node(get_library_node_request).await?;
 
     if let Some(node) = response.into_inner().node {
         node.children.iter().for_each(|c| {
@@ -165,7 +138,20 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         })
     }
 
+    let get_queue_updates_request = Request::new(GetQueueUpdatesRequest { timestamp: 0 });
+
+    let mut queue_update_stream = client
+        .get_queue_updates(get_queue_updates_request)
+        .await?
+        .into_inner();
+
     loop {
+        while let Some(Ok(resp)) = queue_update_stream.next().await {
+            if let Some(QueueUpdateResult::PositionChange(pos)) = resp.queue_update_result {
+                tx.send(Message::QueueData(pos.timestamp.to_string()));
+            }
+        }
+
         match rx.recv() {
             Ok(Message::Quit) => {
                 break;
@@ -192,12 +178,33 @@ fn run_ui(tx: Sender<Message>, rx: Receiver<Message>) {
 
     loop {
         for message in rx.try_iter() {
-            if let Message::LibraryData(title) = message {
+            match message {
-                app.library.items.push(ListNode {
+                Message::LibraryData(title) => {
-                    name: title,
+                    // FIXME: this is obviously bullshit
-                    children: None,
+                    app.library.items.push(LibraryNode {
+                        uuid: title.clone(),
+                        name: title.clone(),
+                        children: Vec::new(),
+                        is_queable: false,
+                        parent: None,
+                        state: LibraryNodeState::Done.into(),
+                        tracks: Vec::new(),
                     });
                 }
+                Message::QueueData(random_no) => {
+                    // FIXME: this is obviously bullshit
+                    app.queue.items.push(LibraryNode {
+                        uuid: random_no.clone(),
+                        name: random_no.clone(),
+                        children: Vec::new(),
+                        is_queable: false,
+                        parent: None,
+                        state: LibraryNodeState::Done.into(),
+                        tracks: Vec::new(),
+                    });
+                }
+                _ => {}
+            }
         }
 
         terminal.draw(|f| ui(f, &mut app)).unwrap();

crabidy-server/src/main.rs

@@ -1,14 +1,15 @@
-use anyhow::{Error, Result};
+use anyhow::Error;
 use async_trait::async_trait;
 use crabidy_core::proto::crabidy::{
     crabidy_service_server::{CrabidyService, CrabidyServiceServer},
+    get_queue_updates_response::QueueUpdateResult,
     AppendNodeRequest, AppendNodeResponse, AppendTrackRequest, AppendTrackResponse,
     GetActiveTrackRequest, GetActiveTrackResponse, GetLibraryNodeRequest, GetLibraryNodeResponse,
     GetQueueRequest, GetQueueResponse, GetQueueUpdatesRequest, GetQueueUpdatesResponse,
     GetTrackRequest, GetTrackResponse, GetTrackUpdatesRequest, GetTrackUpdatesResponse,
     LibraryNode, LibraryNodeState, Queue, QueueLibraryNodeRequest, QueueLibraryNodeResponse,
-    QueueTrackRequest, QueueTrackResponse, RemoveTracksRequest, RemoveTracksResponse,
+    QueuePositionChange, QueueTrackRequest, QueueTrackResponse, RemoveTracksRequest,
-    ReplaceWithNodeRequest, ReplaceWithNodeResponse, ReplaceWithTrackRequest,
+    RemoveTracksResponse, ReplaceWithNodeRequest, ReplaceWithNodeResponse, ReplaceWithTrackRequest,
     ReplaceWithTrackResponse, SaveQueueRequest, SaveQueueResponse, SetCurrentTrackRequest,
     SetCurrentTrackResponse, StopRequest, StopResponse, TogglePlayRequest, TogglePlayResponse,
     TrackPlayState,
@@ -17,7 +18,7 @@ use crabidy_core::{ProviderClient, ProviderError};
 use gstreamer_play::{Play, PlayMessage, PlayState, PlayVideoRenderer};
 // use once_cell::sync::OnceCell;
 use std::{collections::HashMap, fs, pin::Pin, sync::RwLock};
-use tonic::{codegen::futures_core::Stream, transport::Server, Request, Response, Status};
+use tonic::{codegen::futures_core::Stream, transport::Server, Request, Response, Result, Status};
 
 // static CHANNEL: OnceCell<flume::Sender<Input>> = OnceCell::new();
 // static ORCHESTRATOR_CHANNEL: OnceCell<flume::Sender<OrchestratorMessage>> = OnceCell::new();
@@ -224,7 +225,20 @@ impl CrabidyService for AppState {
         &self,
         request: tonic::Request<GetQueueUpdatesRequest>,
     ) -> std::result::Result<tonic::Response<Self::GetQueueUpdatesStream>, tonic::Status> {
-        let queue_vec: Vec<Result<GetQueueUpdatesResponse, Status>> = vec![];
+        let queue_vec: Vec<Result<GetQueueUpdatesResponse, Status>> = vec![
+            Ok(GetQueueUpdatesResponse {
+                queue_update_result: Some(QueueUpdateResult::PositionChange(QueuePositionChange {
+                    timestamp: 12345,
+                    new_position: 42,
+                })),
+            }),
+            Ok(GetQueueUpdatesResponse {
+                queue_update_result: Some(QueueUpdateResult::PositionChange(QueuePositionChange {
+                    timestamp: 6666,
+                    new_position: 11,
+                })),
+            }),
+        ];
         let output_stream = futures::stream::iter(queue_vec.into_iter());
         Ok(Response::new(output_stream))
     }