add clap and change structures for easier integration

Author: tsanona

Cargo.lock

@@ -168,7 +168,6 @@ env_logger = { version = "0.11.2", default-features = false, features = [
     "auto-color",
 ] }
 futures-util = { version = "0.3", default-features = false }
-getopts = "0.2"
 log = "0.4"
 sha1 = "0.10"
 sysinfo = { version = "0.36", default-features = false, features = ["system"] }
@@ -181,6 +180,12 @@ tokio = { version = "1", features = [
     "process",
 ] }
 url = "2.2"
+clap = { version = "4.5.54", features = ["derive"] }
+clap-verbosity-flag = "3.0.4"
+serde = { version = "1.0.228", features = ["derive"]}
+
+[build-dependencies]
+cfg_aliases = "0.2.1"
 
 [package.metadata.deb]
 maintainer = "Librespot Organization <[email protected]>"

Cargo.toml

@@ -0,0 +1,7 @@
+use cfg_aliases::cfg_aliases;
+
+fn main() {
+    cfg_aliases! {
+        discovery: { any(feature = "with-libmdns", feature = "with-dns-sd", feature = "with-avahi") }
+    }
+}

build.rs

@@ -95,16 +95,25 @@ pub struct ConnectConfig {
 impl Default for ConnectConfig {
     fn default() -> Self {
         Self {
-            name: "librespot".to_string(),
-            device_type: DeviceType::Speaker,
+            name: ConnectConfig::DEFAULT_NAME.to_string(),
+            device_type: DeviceType::default(),
             is_group: false,
-            initial_volume: u16::MAX / 2,
+            initial_volume: ConnectConfig::DEFAULT_INITIAL_VOLUME,
             disable_volume: false,
-            volume_steps: 64,
+            volume_steps: ConnectConfig::DEFAULT_VOLUME_STEPS,
         }
     }
 }
 
+impl ConnectConfig {
+    /// Default name
+    pub const DEFAULT_NAME: &str = "librespot";
+    /// Default initial_volume
+    pub const DEFAULT_INITIAL_VOLUME: u16 = u16::MAX / 2;
+    /// Default volume_steps
+    pub const DEFAULT_VOLUME_STEPS: u16 = 64;
+}
+
 #[derive(Default, Debug)]
 pub(super) struct ConnectState {
     /// the entire state that is updated to the remote server

connect/src/state.rs

@@ -108,6 +108,7 @@ tokio-tungstenite = { version = "0.28", default-features = false }
 tokio-util = { version = "0.7", default-features = false }
 url = "2"
 uuid = { version = "1", default-features = false, features = ["v4"] }
+clap = { version = "4.5.54", default-features = false }
 
 [build-dependencies]
 rand = { version = "0.9", default-features = false, features = ["thread_rng"] }

core/Cargo.toml

@@ -1,6 +1,8 @@
-use std::{fmt, path::PathBuf, str::FromStr};
+use std::path::PathBuf;
 
+use clap::ValueEnum;
 use librespot_protocol::devices::DeviceType as ProtoDeviceType;
+use serde::{Deserialize, Serialize};
 use url::Url;
 
 pub(crate) const KEYMASTER_CLIENT_ID: &str = "65b708073fc0480ea92a077233ca87bd";
@@ -31,15 +33,21 @@ pub struct SessionConfig {
     pub autoplay: Option<bool>,
 }
 
+impl Default for SessionConfig {
+    fn default() -> Self {
+        Self::default_for_os(OS)
+    }
+}
+
 impl SessionConfig {
     pub(crate) fn default_for_os(os: &str) -> Self {
-        let device_id = uuid::Uuid::new_v4().as_hyphenated().to_string();
         let client_id = match os {
             "android" => ANDROID_CLIENT_ID,
             "ios" => IOS_CLIENT_ID,
             _ => KEYMASTER_CLIENT_ID,
         }
         .to_owned();
+        let device_id = uuid::Uuid::new_v4().as_hyphenated().to_string();
 
         Self {
             client_id,
@@ -52,13 +60,21 @@ impl SessionConfig {
     }
 }
 
-impl Default for SessionConfig {
-    fn default() -> Self {
-        Self::default_for_os(OS)
-    }
-}
-
-#[derive(Clone, Copy, Debug, Hash, PartialOrd, Ord, PartialEq, Eq, Default)]
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Hash,
+    PartialOrd,
+    Ord,
+    PartialEq,
+    Eq,
+    Default,
+    ValueEnum,
+    Serialize,
+    Deserialize,
+)]
+#[clap(rename_all = "lower")]
 pub enum DeviceType {
     Unknown = 0,
     Computer = 1,
@@ -81,67 +97,9 @@ pub enum DeviceType {
     Observer = 102,
 }
 
-impl FromStr for DeviceType {
-    type Err = ();
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        use self::DeviceType::*;
-        match s.to_lowercase().as_ref() {
-            "computer" => Ok(Computer),
-            "tablet" => Ok(Tablet),
-            "smartphone" => Ok(Smartphone),
-            "speaker" => Ok(Speaker),
-            "tv" => Ok(Tv),
-            "avr" => Ok(Avr),
-            "stb" => Ok(Stb),
-            "audiodongle" => Ok(AudioDongle),
-            "gameconsole" => Ok(GameConsole),
-            "castaudio" => Ok(CastAudio),
-            "castvideo" => Ok(CastVideo),
-            "automobile" => Ok(Automobile),
-            "smartwatch" => Ok(Smartwatch),
-            "chromebook" => Ok(Chromebook),
-            "carthing" => Ok(CarThing),
-            _ => Err(()),
-        }
-    }
-}
-
-impl From<&DeviceType> for &str {
-    fn from(d: &DeviceType) -> &'static str {
-        use self::DeviceType::*;
-        match d {
-            Unknown => "Unknown",
-            Computer => "Computer",
-            Tablet => "Tablet",
-            Smartphone => "Smartphone",
-            Speaker => "Speaker",
-            Tv => "TV",
-            Avr => "AVR",
-            Stb => "STB",
-            AudioDongle => "AudioDongle",
-            GameConsole => "GameConsole",
-            CastAudio => "CastAudio",
-            CastVideo => "CastVideo",
-            Automobile => "Automobile",
-            Smartwatch => "Smartwatch",
-            Chromebook => "Chromebook",
-            UnknownSpotify => "UnknownSpotify",
-            CarThing => "CarThing",
-            Observer => "Observer",
-        }
-    }
-}
-
-impl From<DeviceType> for &str {
-    fn from(d: DeviceType) -> &'static str {
-        (&d).into()
-    }
-}
-
-impl fmt::Display for DeviceType {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let str: &str = self.into();
-        f.write_str(str)
+impl From<DeviceType> for String {
+    fn from(value: DeviceType) -> Self {
+        format!("{value:?}")
     }
 }
 

core/src/config.rs

@@ -98,7 +98,7 @@ struct SessionData {
 }
 
 struct SessionInternal {
-    config: SessionConfig,
+    config: Arc<SessionConfig>,
     data: RwLock<SessionData>,
 
     http_client: HttpClient,
@@ -117,20 +117,14 @@ struct SessionInternal {
     handle: tokio::runtime::Handle,
 }
 
-/// A shared reference to a Spotify session.
-///
-/// After instantiating, you need to login via [Session::connect].
-/// You can either implement the whole playback logic yourself by using
-/// this structs interface directly or hand it to a
-/// `Player`.
-///
-/// *Note*: [Session] instances cannot yet be reused once invalidated. After
-/// an unexpectedly closed connection, you'll need to create a new [Session].
-#[derive(Clone)]
-pub struct Session(Arc<SessionInternal>);
+impl Drop for SessionInternal {
+    fn drop(&mut self) {
+        debug!("drop Session");
+    }
+}
 
-impl Session {
-    pub fn new(config: SessionConfig, cache: Option<Cache>) -> Self {
+impl SessionInternal {
+    pub fn new(config: Arc<SessionConfig>, cache: Option<Arc<Cache>>) -> Self {
         let http_client = HttpClient::new(config.proxy.as_ref());
 
         debug!("new Session");
@@ -142,12 +136,12 @@ impl Session {
             ..SessionData::default()
         };
 
-        Self(Arc::new(SessionInternal {
+        Self {
             config,
             data: RwLock::new(session_data),
             http_client,
             tx_connection: OnceLock::new(),
-            cache: cache.map(Arc::new),
+            cache,
             apresolver: OnceLock::new(),
             audio_key: OnceLock::new(),
             channel: OnceLock::new(),
@@ -157,7 +151,35 @@ impl Session {
             token_provider: OnceLock::new(),
             login5: OnceLock::new(),
             handle: tokio::runtime::Handle::current(),
-        }))
+        }
+    }
+}
+
+/// A shared reference to a Spotify session.
+///
+/// After instantiating, you need to login via [Session::connect].
+/// You can either implement the whole playback logic yourself by using
+/// this structs interface directly or hand it to a
+/// `Player`.
+///
+/// *Note*: [Session] instances cannot yet be reused once invalidated. After
+/// an unexpectedly closed connection, you'll need to create a new [Session].
+#[derive(Clone)]
+pub struct Session(Arc<SessionInternal>);
+
+impl Session {
+    pub fn new(config: SessionConfig, cache: Option<Cache>) -> Self {
+        Self(Arc::new(SessionInternal::new(
+            Arc::new(config),
+            cache.map(Arc::new),
+        )))
+    }
+
+    pub fn renew(&self) -> Session {
+        Self(Arc::new(SessionInternal::new(
+            self.0.config.clone(),
+            self.0.cache.clone(),
+        )))
     }
 
     async fn connect_inner(
@@ -661,12 +683,6 @@ impl SessionWeak {
     }
 }
 
-impl Drop for SessionInternal {
-    fn drop(&mut self) {
-        debug!("drop Session");
-    }
-}
-
 #[derive(Clone, Copy, Default, Debug, PartialEq)]
 enum KeepAliveState {
     #[default]

core/src/session.rs

@@ -176,7 +176,7 @@ impl SpClient {
 
         let client_data = request.mut_client_data();
 
-        client_data.client_version = spotify_semantic_version();
+        client_data.client_version = spotify_semantic_version().to_string();
 
         // Current state of affairs: keymaster ID works on all tested platforms, but may be phased out,
         // so it seems a good idea to mimick the real clients. `self.session().client_id()` returns the

core/src/spclient.rs

@@ -40,14 +40,25 @@ pub const FALLBACK_USER_AGENT: &str = "Spotify/124200290 Linux/0 (librespot)";
 
 pub fn spotify_version() -> String {
     match crate::config::OS {
-        "android" | "ios" => SPOTIFY_MOBILE_VERSION.to_owned(),
-        _ => SPOTIFY_VERSION.to_string(),
+        "android" | "ios" => SPOTIFY_MOBILE_VERSION.to_string(),
+        _ => format!("{SPOTIFY_VERSION}"),
     }
 }
 
-pub fn spotify_semantic_version() -> String {
+pub fn spotify_semantic_version() -> &'static str {
     match crate::config::OS {
-        "android" | "ios" => SPOTIFY_MOBILE_VERSION.to_owned(),
-        _ => SPOTIFY_SEMANTIC_VERSION.to_string(),
+        "android" | "ios" => SPOTIFY_MOBILE_VERSION,
+        _ => SPOTIFY_SEMANTIC_VERSION,
     }
 }
+
+pub fn libresport_version() -> String {
+    #[cfg(debug_assertions)]
+    const BUILD_PROFILE: &str = "debug";
+    #[cfg(not(debug_assertions))]
+    const BUILD_PROFILE: &str = "release";
+
+    format!(
+        "librespot {SEMVER} {SHA_SHORT} (Built on {BUILD_DATE}, Build ID: {BUILD_ID}, Profile: {BUILD_PROFILE})"
+    )
+}

core/src/version.rs

@@ -8,12 +8,20 @@ description = "The discovery logic for librespot"
 repository.workspace = true
 edition.workspace = true
 
+[[example]]
+name = "discovery_group"
+required-features = ["default"]
+
+[[example]]
+name = "discovery"
+required-features = ["default"]
+
 [features]
 # Refer to the workspace Cargo.toml for the list of features
 default = ["with-libmdns", "native-tls"]
 
 # Discovery backends
-with-avahi = ["dep:serde", "dep:zbus", "futures-util/async-await-macro"]
+with-avahi = ["dep:zbus", "futures-util/async-await-macro"]
 with-dns-sd = ["dep:dns-sd"]
 with-libmdns = ["dep:libmdns"]
 
@@ -46,7 +54,7 @@ log = "0.4"
 rand = { version = "0.9", default-features = false, features = ["thread_rng"] }
 serde = { version = "1", default-features = false, features = [
     "derive",
-], optional = true }
+]}
 serde_repr = "0.1"
 serde_json = "1.0"
 sha1 = "0.10"
@@ -55,11 +63,16 @@ tokio = { version = "1", features = ["sync", "rt"] }
 zbus = { version = "5", default-features = false, features = [
     "tokio",
 ], optional = true }
+clap = { version = "4.5.54", default-features = false }
+enum-assoc = "1.2.4"
 
 [dev-dependencies]
 futures = "0.3"
 hex = "0.4"
 tokio = { version = "1", features = ["macros", "rt"] }
 
+[build-dependencies]
+cfg_aliases = "0.2.1"
+
 [lints]
 workspace = true