Merge branch by clxxiii into hotfix_librespot_0.7

Author: eladyn

Cargo.lock

@@ -23,7 +23,7 @@ libc = "0.2.82"
 log = "0.4.6"
 serde = { version = "1.0.115", features = ["derive"] }
 sha-1 = "0.10"
-tokio = {version = "1.26.0", features = ["signal", "rt-multi-thread", "process", "io-std"] }
+tokio = {version = "1.44.2", features = ["signal", "rt-multi-thread", "process", "io-std"] }
 tokio-stream = "0.1.7"
 url = "2.2.2"
 librespot-audio = { version = "0.7.1", default-features = false }
@@ -68,7 +68,7 @@ rodio_backend = ["librespot-playback/rodio-backend"]
 rodiojack_backend = ["librespot-playback/rodiojack-backend"]
 
 [package.metadata.deb]
-depends = "$auto, systemd, pulseaudio"
+depends = "$auto"
 features = ["pulseaudio_backend", "dbus_mpris"]
 assets = [
     ["target/release/spotifyd", "usr/bin/", "755"],

Cargo.toml

@@ -673,6 +673,7 @@ pub(crate) fn get_internal_config(config: CliConfig) -> SpotifydConfig {
         .volume_controller
         .unwrap_or(VolumeController::SoftVolume);
 
+    let default_initial_volume = 90;
     let initial_volume: u16 = config
         .shared_config
         .initial_volume
@@ -685,8 +686,7 @@ pub(crate) fn get_internal_config(config: CliConfig) -> SpotifydConfig {
             }
         })
         .map(|volume| (volume as i32 * (u16::MAX as i32) / 100) as u16)
-        .unwrap_or((90_i32 * (u16::MAX as i32) / 100) as u16); // default to 90%
-    warn!("initial_volume: {initial_volume}");
+        .unwrap_or((default_initial_volume * (u16::MAX as i32) / 100) as u16);
 
     let device_name = config
         .shared_config

src/config.rs

@@ -13,7 +13,7 @@ use futures::{
     Future,
     task::{Context, Poll},
 };
-use librespot_connect::{LoadRequest, LoadRequestOptions, Spirc};
+use librespot_connect::{LoadContextOptions, LoadRequest, LoadRequestOptions, Spirc};
 use librespot_core::{Session, SpotifyId, spotify_id::SpotifyItemType};
 use librespot_metadata::audio::AudioItem;
 use librespot_playback::player::PlayerEvent;
@@ -139,33 +139,36 @@ impl Position {
 #[derive(Clone, Copy, Debug)]
 enum RepeatState {
     None,
-    // Track,
+    Track,
     All,
 }
 
 impl RepeatState {
     fn to_mpris(self) -> &'static str {
         match self {
             RepeatState::None => "None",
-            // RepeatState::Track => "Track",
+            RepeatState::Track => "Track",
             RepeatState::All => "Playlist",
         }
     }
-}
 
-impl From<RepeatState> for bool {
-    fn from(repeat: RepeatState) -> Self {
-        match repeat {
-            RepeatState::None => false,
-            RepeatState::All => true,
-        }
+    fn repeat_track(self) -> bool {
+        matches!(self, RepeatState::Track)
+    }
+
+    fn repeat_context(self) -> bool {
+        !matches!(self, RepeatState::None)
     }
 }
 
-impl From<bool> for RepeatState {
-    fn from(repeat: bool) -> Self {
-        if repeat {
-            RepeatState::All
+impl From<(bool, bool)> for RepeatState {
+    fn from((context, track): (bool, bool)) -> Self {
+        if context {
+            if track {
+                RepeatState::Track
+            } else {
+                RepeatState::All
+            }
         } else {
             RepeatState::None
         }
@@ -264,6 +267,7 @@ impl CurrentStateInner {
                 insert_attr(&mut changed, "Metadata", self.to_metadata());
             }
             PlayerEvent::PositionCorrection { position_ms, .. }
+            | PlayerEvent::PositionChanged { position_ms, .. }
             | PlayerEvent::Seeked { position_ms, .. } => {
                 self.update_position(Duration::milliseconds(position_ms as i64));
                 seeked = true;
@@ -272,8 +276,8 @@ impl CurrentStateInner {
                 self.shuffle = shuffle;
                 insert_attr(&mut changed, "Shuffle", self.shuffle);
             }
-            PlayerEvent::RepeatChanged { context: _, track } => {
-                self.repeat = track.into();
+            PlayerEvent::RepeatChanged { context, track } => {
+                self.repeat = (context, track).into();
                 insert_attr(
                     &mut changed,
                     "LoopStatus",
@@ -293,7 +297,6 @@ impl CurrentStateInner {
             | PlayerEvent::SessionConnected { .. }
             | PlayerEvent::SessionDisconnected { .. }
             | PlayerEvent::SessionClientChanged { .. } => (),
-            PlayerEvent::PositionChanged { .. } => (),
         }
 
         (changed, seeked)
@@ -644,8 +647,9 @@ fn register_player_interface(
         });
         let local_spirc = spirc.clone();
         b.method("Stop", (), (), move |_, _, (): ()| {
+            let pause_playback = false;
             local_spirc
-                .disconnect(false)
+                .disconnect(pause_playback)
                 .map_err(|e| MethodErr::failed(&e))
         });
 
@@ -710,23 +714,25 @@ fn register_player_interface(
         let local_state = current_state.clone();
         b.method("OpenUri", ("uri",), (), move |_, _, (uri,): (String,)| {
             let id = SpotifyId::from_uri(&uri).map_err(|e| MethodErr::invalid_arg(&e))?;
-            let CurrentStateInner { shuffle, .. } = *local_state.read()?;
+            let CurrentStateInner {
+                shuffle, repeat, ..
+            } = *local_state.read()?;
 
             let session = session.clone();
 
             let (playing_track_index, context_uri) = Handle::current()
                 .block_on(async move {
                     use librespot_metadata::*;
                     Ok::<_, librespot_core::Error>(match id.item_type {
-                        SpotifyItemType::Album => (0, uri),
-                        SpotifyItemType::Artist => (0, uri),
-                        SpotifyItemType::Playlist => (0, uri),
                         SpotifyItemType::Track => {
                             let track = Track::get(&session, &id).await?;
                             (track.number as u32, track.album.id.to_uri()?)
                         }
-                        SpotifyItemType::Episode => (0, uri),
-                        SpotifyItemType::Show => (0, uri),
+                        SpotifyItemType::Album
+                        | SpotifyItemType::Artist
+                        | SpotifyItemType::Playlist
+                        | SpotifyItemType::Episode
+                        | SpotifyItemType::Show => (0, uri),
                         SpotifyItemType::Local | SpotifyItemType::Unknown => {
                             return Err(librespot_core::Error::unimplemented(
                                 "this type of uri is not supported",
@@ -746,11 +752,11 @@ fn register_player_interface(
                     LoadRequestOptions {
                         start_playing: true,
                         seek_to: 0,
-                        context_options: Some(librespot_connect::LoadContextOptions::Options(
+                        context_options: Some(LoadContextOptions::Options(
                             librespot_connect::Options {
                                 shuffle,
-                                repeat: false,
-                                repeat_track: false,
+                                repeat: repeat.repeat_context(),
+                                repeat_track: repeat.repeat_track(),
                             },
                         )),
                         playing_track: Some(librespot_connect::PlayingTrack::Index(
@@ -769,18 +775,17 @@ fn register_player_interface(
                 Ok(playback_state.to_mpris().to_string())
             });
 
-        // let local_spirc = spirc.clone();
+        let local_spirc = spirc.clone();
         let local_state = current_state.clone();
         b.property("Shuffle")
             .emits_changed_false()
-            .get(move |_, _| Ok(local_state.read()?.shuffle));
-        // TODO: re-enable, once setting shuffle via spirc works
-        // .set(move |_, _, value| {
-        //     local_spirc
-        //         .shuffle(value)
-        //         .map(|_| None)
-        //         .map_err(|err| dbus::MethodErr::failed(&err))
-        // });
+            .get(move |_, _| Ok(local_state.read()?.shuffle))
+            .set(move |_, _, value| {
+                local_spirc
+                    .shuffle(value)
+                    .map(|_| None)
+                    .map_err(|err| dbus::MethodErr::failed(&err))
+            });
 
         b.property("Rate").emits_changed_const().get(|_, _| Ok(1.0));
         b.property("MaximumRate")
@@ -811,20 +816,25 @@ fn register_player_interface(
                 Ok(repeat.to_mpris().to_string())
             })
             .set(move |_, _, value| {
-                let new_repeat = match value.as_str() {
-                    "None" => false,
-                    "Playlist" => true,
+                let repeat = match value.as_str() {
+                    "None" => RepeatState::None,
+                    "Playlist" => RepeatState::All,
+                    "Track" => RepeatState::Track,
                     mode => {
                         return Err(dbus::MethodErr::failed(&format!(
                             "unsupported repeat mode: {mode}"
                         )));
                     }
                 };
+
                 local_spirc
-                    .repeat(new_repeat)
+                    .repeat(repeat.repeat_context())
                     .map_err(|e| MethodErr::failed(&e))?;
-                // TODO: remove, once librespot sends us updates here
-                Ok(Some(value))
+                local_spirc
+                    .repeat_track(repeat.repeat_track())
+                    .map_err(|e| MethodErr::failed(&e))?;
+
+                Ok(None)
             });
 
         let local_state = current_state.clone();

src/dbus_mpris.rs

@@ -125,10 +125,9 @@ impl MainLoop {
                 ConnectConfig {
                     name: self.device_name.clone(),
                     device_type: self.device_type,
-                    is_group: false,
                     initial_volume: self.initial_volume,
                     disable_volume: self.disable_volume,
-                    volume_steps: 64,
+                    ..ConnectConfig::default()
                 },
                 session.clone(),
                 creds.clone(),

src/main_loop.rs

@@ -4,6 +4,7 @@ use color_eyre::{
 };
 use librespot_core::SessionConfig;
 use librespot_core::{Session, authentication::Credentials};
+use librespot_oauth::OAuthClientBuilder;
 use log::info;
 use tokio::runtime::Runtime;
 
@@ -55,18 +56,18 @@ pub(crate) fn run_oauth(mut cli_config: CliConfig, oauth_port: u16) -> eyre::Res
         ..Default::default()
     };
 
-    let client = librespot_oauth::OAuthClientBuilder::new(
+    let oauth_client = OAuthClientBuilder::new(
         &session_config.client_id,
         &format!("http://127.0.0.1:{oauth_port}/login"),
         OAUTH_SCOPES.to_vec(),
     )
     .with_custom_message(r#"<h3 style="color: darkgreen; align: center;">Authentication successful! You can now return to spotifyd.</h3>"#)
     .open_in_browser()
     .build()
-    .wrap_err("token retrieval failed")?;
+    .wrap_err("client creation failed")?;
 
     Runtime::new().unwrap().block_on(async move {
-        let token = client.get_access_token_async().await?;
+        let token = oauth_client.get_access_token_async().await?;
         let creds = Credentials::with_access_token(token.access_token);
 
         let session = Session::new(session_config, Some(cache));

src/oauth.rs

@@ -2,6 +2,7 @@ use crate::error::Error;
 use librespot_metadata::audio::AudioItem;
 use librespot_playback::player::PlayerEvent;
 use log::info;
+
 use std::{collections::HashMap, process::Stdio};
 use tokio::{
     io::{self, AsyncWriteExt},
@@ -179,10 +180,13 @@ pub(crate) fn spawn_program_on_event(
             env.insert("PLAYER_EVENT", "shuffle_changed".to_string());
             env.insert("SHUFFLE", shuffle.to_string());
         }
-        PlayerEvent::RepeatChanged { context: _, track } => {
+        PlayerEvent::RepeatChanged { context, track } => {
             env.insert("PLAYER_EVENT", "repeat_changed".to_string());
-            let val = match track {
-                true => "all",
+            let val = match context {
+                true => match track {
+                    true => "track",
+                    false => "all",
+                },
                 false => "none",
             }
             .to_string();
@@ -197,10 +201,15 @@ pub(crate) fn spawn_program_on_event(
             env.insert("FILTEREXPLICIT", filter.to_string());
         }
         PlayerEvent::PositionChanged {
-            play_request_id: _,
-            track_id: _,
-            position_ms: _,
-        } => todo!(),
+            play_request_id,
+            position_ms,
+            track_id,
+        } => {
+            env.insert("PLAYER_EVENT", "position_changed".to_string());
+            env.insert("TRACK_ID", track_id.to_base62().unwrap());
+            env.insert("POSITION_MS", position_ms.to_string());
+            env.insert("PLAY_REQUEST_ID", play_request_id.to_string());
+        }
     }
     spawn_program(shell, cmd, env)
 }

src/process.rs

@@ -57,9 +57,9 @@ pub(crate) fn initial_state(
             }
             _ => {
                 info!("Using software volume controller.");
-                let soft_mixer = mixer::softmixer::SoftMixer::open(MixerConfig::default())
-                    .expect("softmixer should initialize");
-                Arc::new(soft_mixer)
+                let mixer = mixer::softmixer::SoftMixer::open(MixerConfig::default())
+                    .expect("SoftMixer::open never returns an Error");
+                Arc::new(mixer)
             }
         }
     };