cleanup new_session API

Author: aome510

spotify_player/src/cli/handlers.rs

@@ -153,8 +153,9 @@ fn try_connect_to_client(socket: &UdpSocket, configs: &config::Configs) -> Resul
             let rt = tokio::runtime::Runtime::new()?;
 
             // create a Spotify API client
-            // TODO: figure out how to create session for CLI use case
             let client = client::Client::new(auth_config);
+            rt.block_on(client.new_session(None, false))
+                .context("new session")?;
 
             // create a client socket for handling CLI commands
             let client_socket = rt.block_on(tokio::net::UdpSocket::bind(("127.0.0.1", port)))?;

spotify_player/src/client/mod.rs

@@ -8,8 +8,6 @@ use std::io::Write;
 
 use anyhow::Context as _;
 use anyhow::Result;
-use librespot_core::authentication::Credentials;
-use librespot_core::session::Session;
 use reqwest::StatusCode;
 use rspotify::{
     http::Query,
@@ -81,30 +79,46 @@ impl Client {
     }
 
     /// Create a new client session
-    pub async fn new_session(&self, state: &SharedState, reauth: bool) -> Result<()> {
+    pub async fn new_session(&self, state: Option<&SharedState>, reauth: bool) -> Result<()> {
         let session = self.auth_config.new_session();
         let creds = auth::get_creds(&self.auth_config, reauth)
             .await
             .context("get credentials")?;
         *self.session.lock().await = Some(session.clone());
 
+        #[allow(unused_mut)]
+        let mut connected = false;
+
         #[cfg(feature = "streaming")]
-        if state.is_streaming_enabled() {
-            self.new_streaming_connection(state.clone(), session, creds)
+        if let Some(state) = state {
+            if state.is_streaming_enabled() {
+                self.new_streaming_connection(state.clone(), session.clone(), creds.clone())
+                    .await
+                    .context("new streaming connection")?;
+                connected = true;
+            }
+        }
+
+        if !connected {
+            // if session is not connected (triggered by `new_streaming_connection`), connect to the session
+            session
+                .connect(creds, true)
                 .await
-                .context("new streaming connection")?;
+                .context("connect to a session")?;
         }
 
         tracing::info!("Used a new session for Spotify client.");
 
         self.refresh_token().await.context("refresh auth token")?;
 
-        // reset the application's caches
-        state.data.write().caches = MemoryCaches::new();
+        if let Some(state) = state {
+            // reset the application's caches
+            state.data.write().caches = MemoryCaches::new();
 
-        self.initialize_playback(state)
-            .await
-            .context("initialize playback")?;
+            self.initialize_playback(state)
+                .await
+                .context("initialize playback")?;
+        }
 
         Ok(())
     }
@@ -113,7 +127,7 @@ impl Client {
     pub async fn check_valid_session(&self, state: &SharedState) -> Result<()> {
         if self.session().await.is_invalid() {
             tracing::info!("Client's current session is invalid, creating a new session...");
-            self.new_session(state, false)
+            self.new_session(Some(state), false)
                 .await
                 .context("create new client session")?;
         }
@@ -125,8 +139,8 @@ impl Client {
     pub async fn new_streaming_connection(
         &self,
         state: SharedState,
-        session: Session,
-        creds: Credentials,
+        session: librespot_core::Session,
+        creds: librespot_core::authentication::Credentials,
     ) -> Result<()> {
         let new_conn =
             crate::streaming::new_connection(self.clone(), state, session, creds).await?;
@@ -290,7 +304,7 @@ impl Client {
             }
             #[cfg(feature = "streaming")]
             ClientRequest::RestartIntegratedClient => {
-                self.new_session(state, false).await?;
+                self.new_session(Some(state), false).await?;
             }
             ClientRequest::GetCurrentUser => {
                 let user = self.current_user().await?;

spotify_player/src/main.rs

@@ -74,12 +74,6 @@ fn init_logging(cache_folder: &std::path::Path) -> Result<()> {
 
 #[tokio::main]
 async fn start_app(state: &state::SharedState) -> Result<()> {
-    // librespot depends on hyper-rustls which requires a crypto provider to be set up.
-    // TODO: see if this can be fixed upstream
-    rustls::crypto::aws_lc_rs::default_provider()
-        .install_default()
-        .unwrap();
-
     let configs = config::get_config();
 
     if !state.is_daemon {
@@ -126,7 +120,7 @@ async fn start_app(state: &state::SharedState) -> Result<()> {
     let auth_config = auth::AuthConfig::new(configs)?;
     let client = client::Client::new(auth_config);
     client
-        .new_session(state, true)
+        .new_session(Some(state), true)
         .await
         .context("initialize new Spotify session")?;
 
@@ -228,6 +222,12 @@ async fn start_app(state: &state::SharedState) -> Result<()> {
 }
 
 fn main() -> Result<()> {
+    // librespot depends on hyper-rustls which requires a crypto provider to be set up.
+    // TODO: see if this can be fixed upstream
+    rustls::crypto::aws_lc_rs::default_provider()
+        .install_default()
+        .unwrap();
+
     // parse command line arguments
     let args = cli::init_cli()?.get_matches();