feat: provide an easy transfer option to the spirc

Author: photovoltex

connect/src/spirc.rs

@@ -4,7 +4,7 @@ use crate::{
         authentication::Credentials,
         dealer::{
             manager::{BoxedStream, BoxedStreamResult, Reply, RequestReply},
-            protocol::{Command, FallbackWrapper, Message, Request},
+            protocol::{Command, FallbackWrapper, Message, Request, TransferOptions},
         },
         session::UserAttributes,
         Error, Session, SpotifyId,
@@ -128,6 +128,7 @@ enum SpircCommand {
     SetPosition(u32),
     SetVolume(u16),
     Activate,
+    Transfer(Option<TransferOptions>),
     Load(LoadRequest),
 }
 
@@ -393,10 +394,19 @@ impl Spirc {
 
     /// Acquires the control as active connect device.
     ///
-    /// Does nothing if we are not the active device.
+    /// Does not [Spirc::transfer] the playback. Does nothing if we are not the active device.
     pub fn activate(&self) -> Result<(), Error> {
         Ok(self.commands.send(SpircCommand::Activate)?)
     }
+
+    /// Acquires the control as active connect device over the transfer flow.
+    ///
+    /// Does nothing if we are not the active device.
+    pub fn transfer(&self, transfer_options: Option<TransferOptions>) -> Result<(), Error> {
+        Ok(self
+            .commands
+            .send(SpircCommand::Transfer(transfer_options))?)
+    }
 }
 
 impl SpircTask {
@@ -617,12 +627,19 @@ impl SpircTask {
                     rx.close()
                 }
             }
+            SpircCommand::Transfer(options) if !self.connect_state.is_active() => {
+                self.session
+                    .spclient()
+                    .transfer(self.session.device_id(), self.session.device_id(), &options)
+                    .await?;
+                return Ok(());
+            }
             SpircCommand::Activate if !self.connect_state.is_active() => {
                 trace!("Received SpircCommand::{:?}", cmd);
                 self.handle_activate();
                 return self.notify().await;
             }
-            SpircCommand::Activate => warn!(
+            SpircCommand::Transfer(..) | SpircCommand::Activate => warn!(
                 "SpircCommand::{:?} will be ignored while already active",
                 cmd
             ),

core/src/dealer/protocol/request.rs

@@ -7,7 +7,7 @@ use crate::{
         transfer_state::TransferState,
     },
 };
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::fmt::{Display, Formatter};
 
@@ -165,12 +165,16 @@ pub struct GenericCommand {
     pub logging_params: LoggingParams,
 }
 
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub struct TransferOptions {
-    pub restore_paused: String,
-    pub restore_position: String,
-    pub restore_track: String,
-    pub retain_session: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub restore_paused: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub restore_position: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub restore_track: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub retain_session: Option<String>,
 }
 
 #[derive(Clone, Debug, Deserialize)]

core/src/spclient.rs

@@ -7,6 +7,7 @@ use crate::config::{os_version, OS};
 use crate::{
     apresolve::SocketAddress,
     config::SessionConfig,
+    dealer::protocol::TransferOptions,
     error::ErrorKind,
     protocol::{
         autoplay_context_request::AutoplayContextRequest,
@@ -882,4 +883,35 @@ impl SpClient {
 
         self.request(&Method::GET, &endpoint, None, None).await
     }
+
+    /// Triggers the transfers of the playback from one device to another
+    ///
+    /// Using the same `device_id` for `from_device_id` and `to_device_id`, initiates the transfer
+    /// from the currently active device.
+    pub async fn transfer(
+        &self,
+        from_device_id: &str,
+        to_device_id: &str,
+        transfer_options: &Option<TransferOptions>,
+    ) -> SpClientResult {
+        let endpoint =
+            format!("/connect-state/v1/connect/transfer/from/{from_device_id}/to/{to_device_id}");
+
+        let transfer_options = transfer_options
+            .as_ref()
+            .map(serde_json::to_string)
+            .transpose()?;
+        let body = transfer_options.map(|op| format!(r#"{{ "transfer_options": {op} }}"#));
+
+        debug!("{body:?}");
+
+        self.request_with_options(
+            &Method::POST,
+            &endpoint,
+            None,
+            body.as_deref().map(|s| s.as_bytes()),
+            &NO_METRICS_AND_SALT,
+        )
+        .await
+    }
 }