feat: Use Spirc for player logic

**Heavily WIP, only does basic playback 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

@@ -163,10 +163,7 @@ impl Spotify {
 
     /// Create a [Session] that respects the user configuration in `cfg` and with the given
     /// credentials.
-    async fn create_session(
-        cfg: &config::Config,
-        credentials: Credentials,
-    ) -> Result<Session, librespot_core::Error> {
+    async fn create_session(cfg: &config::Config) -> Session {
         let librespot_cache_path = config::cache_path("librespot");
         let audio_cache_path = match cfg.values().audio_cache {
             Some(false) => None,
@@ -183,8 +180,7 @@ impl Spotify {
         .expect("Could not create cache");
         debug!("opening spotify session");
         let session_config = Self::session_config(cfg);
-        let session = Session::new(session_config, Some(cache));
-        session.connect(credentials, true).await.map(|_| session)
+        Session::new(session_config, Some(cache))
     }
 
     /// Create and initialize the requested audio backend.
@@ -243,9 +239,7 @@ impl Spotify {
             ..Default::default()
         };
 
-        let session = Self::create_session(&cfg, credentials)
-            .await
-            .expect("Could not create session");
+        let session = Self::create_session(&cfg).await;
         user_tx.map(|tx| tx.send(session.username()));
 
         let mixer_factory_opt = librespot_playback::mixer::find(Some(SoftMixer::NAME));
@@ -265,12 +259,14 @@ 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,39 @@ 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_task) = 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_task: Box::pin(spirc_task),
         }
     }
 
@@ -98,14 +108,22 @@ impl Worker {
             tokio::select! {
                 cmd = self.commands.next() => match cmd {
                     Some(WorkerCommand::Load(playable, start_playing, position_ms)) => {
+                        self.spirc.activate();
                         match SpotifyId::from_uri(&playable.uri()) {
                             Ok(id) => {
                                 info!("player loading track: {id:?}");
                                 if !id.is_playable() {
                                     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 +133,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 +214,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 +235,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();
     }
 }