feat: Use Spirc for player logic

**Heavily WIP, only compiles so far.**

The idea is to use librespot `Spirc` instead of handling the player logic within
ncspot. This should reduce complexity a bit, but also allows us to integrate
with Spotify Connect, which in turn would enable ncspot to be controlled via
Spotify Apps.

Author: hrkfdn

Cargo.lock

@@ -52,6 +52,7 @@ fern = "0.7"
 futures = "0.3"
 ioctl-rs = {version = "0.2", optional = true}
 libc = "0.2.175"
+librespot-connect = "0.7.0"
 librespot-core = "0.7.0"
 librespot-oauth = "0.7.0"
 librespot-playback = {version = "0.7.0", default-features = false, features = ["native-tls"]}

Cargo.toml

@@ -243,7 +243,7 @@ impl Spotify {
             ..Default::default()
         };
 
-        let session = Self::create_session(&cfg, credentials)
+        let session = Self::create_session(&cfg, credentials.clone())
             .await
             .expect("Could not create session");
         user_tx.map(|tx| tx.send(session.username()));
@@ -265,12 +265,13 @@ impl Spotify {
 
         let mut worker = Worker::new(
             events.clone(),
+            credentials,
             player_events,
             commands,
             session,
             player,
             mixer,
-        );
+        ).await;
         debug!("worker thread ready.");
         worker.run_loop().await;
 

src/spotify.rs

@@ -3,11 +3,13 @@ use crate::model::playable::Playable;
 use crate::queue::QueueEvent;
 use crate::spotify::PlayerEvent;
 use futures::Future;
+use librespot_connect::{ConnectConfig, LoadRequest, LoadRequestOptions, Spirc};
 use librespot_core::session::Session;
 use librespot_core::spotify_id::SpotifyId;
 use librespot_core::token::Token;
 use librespot_playback::mixer::Mixer;
 use librespot_playback::player::{Player, PlayerEvent as LibrespotPlayerEvent};
+use librespot_protocol::credentials;
 use log::{debug, error, info, warn};
 use std::sync::Arc;
 use std::sync::mpsc::Sender;
@@ -41,31 +43,37 @@ pub struct Worker {
     events: EventManager,
     player_events: UnboundedReceiverStream<LibrespotPlayerEvent>,
     commands: UnboundedReceiverStream<WorkerCommand>,
-    session: Session,
-    player: Arc<Player>,
     token_task: Pin<Box<dyn Future<Output = ()> + Send>>,
     player_status: PlayerStatus,
-    mixer: Arc<dyn Mixer>,
+    session: Session,
+    spirc: Spirc,
+    spirc_task: Pin<Box<dyn Future<Output = ()> + Send>>,
 }
 
 impl Worker {
-    pub(crate) fn new(
+    pub(crate) async fn new(
         events: EventManager,
+        credentials: librespot_core::authentication::Credentials,
         player_events: mpsc::UnboundedReceiver<LibrespotPlayerEvent>,
         commands: mpsc::UnboundedReceiver<WorkerCommand>,
         session: Session,
         player: Arc<Player>,
         mixer: Arc<dyn Mixer>,
     ) -> Self {
+        let config = ConnectConfig {
+            name: "ncspot".to_string(),
+            ..Default::default()
+        };
+        let spirc = Spirc::new(config, session.clone(), credentials, player, mixer).await.expect("Spirc should be initialized");
         Self {
             events,
             player_events: UnboundedReceiverStream::new(player_events),
             commands: UnboundedReceiverStream::new(commands),
-            player,
-            session,
             token_task: Box::pin(futures::future::pending()),
             player_status: PlayerStatus::Stopped,
-            mixer,
+            session,
+            spirc: spirc.0,
+            spirc_task: Box::pin(spirc.1),
         }
     }
 
@@ -105,7 +113,14 @@ impl Worker {
                                     warn!("track is not playable");
                                     self.events.send(Event::Player(PlayerEvent::FinishedTrack));
                                 } else {
-                                    self.player.load(id, start_playing, position_ms);
+                                    let options = LoadRequestOptions {
+                                        start_playing,
+                                        seek_to: position_ms,
+                                        context_options: None,
+                                        playing_track: None,
+                                    };
+                                    let req = LoadRequest::from_tracks(vec![id.to_uri().expect("uri")], options);
+                                    self.spirc.load(req);
                                 }
                             }
                             Err(e) => {
@@ -115,32 +130,31 @@ impl Worker {
                         }
                     }
                     Some(WorkerCommand::Play) => {
-                        self.player.play();
+                        self.spirc.play();
                     }
                     Some(WorkerCommand::Pause) => {
-                        self.player.pause();
+                        self.spirc.pause();
                     }
                     Some(WorkerCommand::Stop) => {
-                        self.player.stop();
+                        todo!("stop spirc");
                     }
                     Some(WorkerCommand::Seek(pos)) => {
-                        self.player.seek(pos);
+                        self.spirc.set_position_ms(pos);
                     }
                     Some(WorkerCommand::SetVolume(volume)) => {
-                        self.mixer.set_volume(volume);
+                        self.spirc.set_volume(volume);
                     }
                     Some(WorkerCommand::RequestToken(sender)) => {
                         self.token_task = Box::pin(Self::get_token(self.session.clone(), sender));
                     }
                     Some(WorkerCommand::Preload(playable)) => {
                         if let Ok(id) = SpotifyId::from_uri(&playable.uri()) {
                             debug!("Preloading {id:?}");
-                            self.player.preload(id);
+                            // self.player.preload(id);
                         }
                     }
                     Some(WorkerCommand::Shutdown) => {
-                        self.player.stop();
-                        self.session.shutdown();
+                        self.spirc.shutdown();
                     }
                     None => info!("empty stream")
                 },
@@ -197,6 +211,9 @@ impl Worker {
                         break
                     },
                 },
+                _ = self.spirc_task.as_mut() => {
+                    info!("spirc task tick");
+                },
                 // Update animated parts of the UI (e.g. statusbar during playback).
                 _ = ui_refresh.tick() => {
                     if !matches!(self.player_status, PlayerStatus::Stopped) {
@@ -215,6 +232,6 @@ impl Worker {
 impl Drop for Worker {
     fn drop(&mut self) {
         debug!("Worker thread is shutting down, stopping player");
-        self.player.stop();
+        self.spirc.shutdown();
     }
 }