yetangitu/librespot
1
0
Fork 0
mirror of https://github.com/librespot-org/librespot.git synced 2025-10-03 01:39:28 +02:00
Code Issues Releases Wiki Activity

Dealer: Rework context retrieval (#1414)

Browse source 
* connect: simplify `handle_command` for SpircCommand

* connect: simplify `handle_player_event`

* connect: `handle_player_event` update log entries

* connect: set `playback_speed` according to player state

* connect: reduce/group state updates by delaying them slightly

* connect: load entire context at once

* connect: use is_playing from connect_state

* connect: move `ResolveContext` in own file

* connect: handle metadata correct

* connect: resolve context rework

- resolved contexts independently, by that we don't block our main loop
- move resolve logic into own file
- polish handling for play and transfer

* connect: rework aftermath

* general logging and comment fixups

* connect: fix incorrect stopping

* connect: always handle player seek event

* connect: adjust behavior

- rename `handle_context` to `handle_next_context`
- disconnect should only pause the playback
- find_next should not exceed queue length

* fix typo and `find_next`

* connect: fixes for context and transfer

- fix context_metadata and restriction incorrect reset
- do some state updates earlier
- add more logging

* revert removal of state setup

* `clear_next_tracks` should never clear queued items

just mimics official client behavior

* connect: make `playing_track` optional and handle it correctly

* connect: adjust finish of context resolving

* connect: set track position when shuffling

* example: adjust to model change

* connect: remove duplicate track

* connect: provide all recently played tracks to autoplay request

- removes previously added workaround

* connect: apply review suggestions

- use drain instead of for with pop
- use for instead of loop
- use or_else instead of match
- use Self::Error instead of the value
- free memory for metadata and restrictions

* connect: impl trait for player context

* connect: fix incorrect playing and paused

* connect: apply options as official clients

* protocol: move trait impls into impl_trait mod
This commit is contained in:
Felix Prillwitz 2025-01-18 16:45:33 +01:00 • committed by GitHub
parent c288cf7106
commit f3bb380851
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
18 changed files with 1004 additions and 734 deletions
Download patch file Download diff file Expand all files Collapse all files

347
connect/src/context_resolver.rs Normal file
View file

@ -0,0 +1,347 @@
use crate::{
core::{Error, Session},
protocol::{
autoplay_context_request::AutoplayContextRequest, context::Context,
transfer_state::TransferState,
},
state::{
context::{ContextType, UpdateContext},
ConnectState,
},
};
use std::cmp::PartialEq;
use std::{
collections::{HashMap, VecDeque},
fmt::{Display, Formatter},
hash::Hash,
time::Duration,
};
use thiserror::Error as ThisError;
use tokio::time::Instant;
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
enum Resolve {
Uri(String),
Context(Context),
}
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub(super) enum ContextAction {
Append,
Replace,
}
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub(super) struct ResolveContext {
resolve: Resolve,
fallback: Option<String>,
update: UpdateContext,
action: ContextAction,
}
impl ResolveContext {
fn append_context(uri: impl Into<String>) -> Self {
Self {
resolve: Resolve::Uri(uri.into()),
fallback: None,
update: UpdateContext::Default,
action: ContextAction::Append,
}
}
pub fn from_uri(
uri: impl Into<String>,
fallback: impl Into<String>,
update: UpdateContext,
action: ContextAction,
) -> Self {
let fallback_uri = fallback.into();
Self {
resolve: Resolve::Uri(uri.into()),
fallback: (!fallback_uri.is_empty()).then_some(fallback_uri),
update,
action,
}
}
pub fn from_context(context: Context, update: UpdateContext, action: ContextAction) -> Self {
Self {
resolve: Resolve::Context(context),
fallback: None,
update,
action,
}
}
/// the uri which should be used to resolve the context, might not be the context uri
fn resolve_uri(&self) -> Option<&str> {
// it's important to call this always, or at least for every ResolveContext
// otherwise we might not even check if we need to fallback and just use the fallback uri
match self.resolve {
Resolve::Uri(ref uri) => ConnectState::valid_resolve_uri(uri),
Resolve::Context(ref ctx) => ConnectState::get_context_uri_from_context(ctx),
}
.or(self.fallback.as_deref())
}
/// the actual context uri
fn context_uri(&self) -> &str {
match self.resolve {
Resolve::Uri(ref uri) => uri,
Resolve::Context(ref ctx) => ctx.uri.as_deref().unwrap_or_default(),
}
}
}
impl Display for ResolveContext {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(
f,
"resolve_uri: <{:?}>, context_uri: <{}>, update: <{:?}>",
self.resolve_uri(),
self.context_uri(),
self.update,
)
}
}
#[derive(Debug, ThisError)]
enum ContextResolverError {
#[error("no next context to resolve")]
NoNext,
#[error("tried appending context with {0} pages")]
UnexpectedPagesSize(usize),
#[error("tried resolving not allowed context: {0:?}")]
NotAllowedContext(String),
}
impl From<ContextResolverError> for Error {
fn from(value: ContextResolverError) -> Self {
Error::failed_precondition(value)
}
}
pub struct ContextResolver {
session: Session,
queue: VecDeque<ResolveContext>,
unavailable_contexts: HashMap<ResolveContext, Instant>,
}
// time after which an unavailable context is retried
const RETRY_UNAVAILABLE: Duration = Duration::from_secs(3600);
impl ContextResolver {
pub fn new(session: Session) -> Self {
Self {
session,
queue: VecDeque::new(),
unavailable_contexts: HashMap::new(),
}
}
pub fn add(&mut self, resolve: ResolveContext) {
let last_try = self
.unavailable_contexts
.get(&resolve)
.map(|i| i.duration_since(Instant::now()));
let last_try = if matches!(last_try, Some(last_try) if last_try > RETRY_UNAVAILABLE) {
let _ = self.unavailable_contexts.remove(&resolve);
debug!(
"context was requested {}s ago, trying again to resolve the requested context",
last_try.expect("checked by condition").as_secs()
);
None
} else {
last_try
};
if last_try.is_some() {
debug!("tried loading unavailable context: {resolve}");
return;
} else if self.queue.contains(&resolve) {
debug!("update for {resolve} is already added");
return;
} else {
trace!(
"added {} to resolver queue",
resolve.resolve_uri().unwrap_or(resolve.context_uri())
)
}
self.queue.push_back(resolve)
}
pub fn add_list(&mut self, resolve: Vec<ResolveContext>) {
for resolve in resolve {
self.add(resolve)
}
}
pub fn remove_used_and_invalid(&mut self) {
if let Some((_, _, remove)) = self.find_next() {
let _ = self.queue.drain(0..remove); // remove invalid
}
self.queue.pop_front(); // remove used
}
pub fn clear(&mut self) {
self.queue = VecDeque::new()
}
fn find_next(&self) -> Option<(&ResolveContext, &str, usize)> {
for idx in 0..self.queue.len() {
let next = self.queue.get(idx)?;
match next.resolve_uri() {
None => {
warn!("skipped {idx} because of invalid resolve_uri: {next}");
continue;
}
Some(uri) => return Some((next, uri, idx)),
}
}
None
}
pub fn has_next(&self) -> bool {
self.find_next().is_some()
}
pub async fn get_next_context(
&self,
recent_track_uri: impl Fn() -> Vec<String>,
) -> Result<Context, Error> {
let (next, resolve_uri, _) = self.find_next().ok_or(ContextResolverError::NoNext)?;
match next.update {
UpdateContext::Default => {
let mut ctx = self.session.spclient().get_context(resolve_uri).await;
if let Ok(ctx) = ctx.as_mut() {
ctx.uri = Some(next.context_uri().to_string());
ctx.url = ctx.uri.as_ref().map(|s| format!("context://{s}"));
}
ctx
}
UpdateContext::Autoplay => {
if resolve_uri.contains("spotify:show:") || resolve_uri.contains("spotify:episode:")
{
// autoplay is not supported for podcasts
Err(ContextResolverError::NotAllowedContext(
resolve_uri.to_string(),
))?
}
let request = AutoplayContextRequest {
context_uri: Some(resolve_uri.to_string()),
recent_track_uri: recent_track_uri(),
..Default::default()
};
self.session.spclient().get_autoplay_context(&request).await
}
}
}
pub fn mark_next_unavailable(&mut self) {
if let Some((next, _, _)) = self.find_next() {
self.unavailable_contexts
.insert(next.clone(), Instant::now());
}
}
pub fn apply_next_context(
&self,
state: &mut ConnectState,
mut context: Context,
) -> Result<Option<Vec<ResolveContext>>, Error> {
let (next, _, _) = self.find_next().ok_or(ContextResolverError::NoNext)?;
let remaining = match next.action {
ContextAction::Append if context.pages.len() == 1 => state
.fill_context_from_page(context.pages.remove(0))
.map(|_| None),
ContextAction::Replace => {
let remaining = state.update_context(context, next.update);
if let Resolve::Context(ref ctx) = next.resolve {
state.merge_context(Some(ctx.clone()));
}
remaining
}
ContextAction::Append => {
warn!("unexpected page size: {context:#?}");
Err(ContextResolverError::UnexpectedPagesSize(context.pages.len()).into())
}
}?;
Ok(remaining.map(|remaining| {
remaining
.into_iter()
.map(ResolveContext::append_context)
.collect::<Vec<_>>()
}))
}
pub fn try_finish(
&self,
state: &mut ConnectState,
transfer_state: &mut Option<TransferState>,
) -> bool {
let (next, _, _) = match self.find_next() {
None => return false,
Some(next) => next,
};
// when there is only one update type, we are the last of our kind, so we should update the state
if self
.queue
.iter()
.filter(|resolve| resolve.update == next.update)
.count()
!= 1
{
return false;
}
match (next.update, state.active_context) {
(UpdateContext::Default, ContextType::Default) | (UpdateContext::Autoplay, _) => {
debug!(
"last item of type <{:?}>, finishing state setup",
next.update
);
}
(UpdateContext::Default, _) => {
debug!("skipped finishing default, because it isn't the active context");
return false;
}
}
let active_ctx = state.get_context(state.active_context);
let res = if let Some(transfer_state) = transfer_state.take() {
state.finish_transfer(transfer_state)
} else if state.shuffling_context() {
state.shuffle()
} else if matches!(active_ctx, Ok(ctx) if ctx.index.track == 0) {
// has context, and context is not touched
// when the index is not zero, the next index was already evaluated elsewhere
let ctx = active_ctx.expect("checked by precondition");
let idx = ConnectState::find_index_in_context(ctx, |t| {
state.current_track(|c| t.uri == c.uri)
})
.ok();
state.reset_playback_to_position(idx)
} else {
state.fill_up_next_tracks()
};
if let Err(why) = res {
error!("setup of state failed: {why}, last used resolve {next:#?}")
}
state.update_restrictions();
state.update_queue_revision();
true
}
}

1
connect/src/lib.rs
View file

@ -5,6 +5,7 @@ use librespot_core as core;
use librespot_playback as playback;
use librespot_protocol as protocol;
mod context_resolver;
mod model;
pub mod spirc;
pub mod state;

155
connect/src/model.rs
View file

@ -1,8 +1,4 @@
use crate::state::ConnectState;
use librespot_core::dealer::protocol::SkipTo;
use librespot_protocol::context::Context;
use std::fmt::{Display, Formatter};
use std::hash::{Hash, Hasher};
#[derive(Debug)]
pub struct SpircLoadCommand {
@ -13,7 +9,11 @@ pub struct SpircLoadCommand {
pub shuffle: bool,
pub repeat: bool,
pub repeat_track: bool,
pub playing_track: PlayingTrack,
/// Decides the starting position in the given context
///
/// ## Remarks:
/// If none is provided and shuffle true, a random track is played, otherwise the first
pub playing_track: Option<PlayingTrack>,
}
#[derive(Debug)]
@ -23,19 +23,20 @@ pub enum PlayingTrack {
Uid(String),
}
impl From<SkipTo> for PlayingTrack {
fn from(value: SkipTo) -> Self {
impl TryFrom<SkipTo> for PlayingTrack {
type Error = ();
fn try_from(value: SkipTo) -> Result<Self, Self::Error> {
// order of checks is important, as the index can be 0, but still has an uid or uri provided,
// so we only use the index as last resort
if let Some(uri) = value.track_uri {
PlayingTrack::Uri(uri)
Ok(PlayingTrack::Uri(uri))
} else if let Some(uid) = value.track_uid {
PlayingTrack::Uid(uid)
Ok(PlayingTrack::Uid(uid))
} else if let Some(index) = value.track_index {
Ok(PlayingTrack::Index(index))
} else {
PlayingTrack::Index(value.track_index.unwrap_or_else(|| {
warn!("SkipTo didn't provided any point to skip to, falling back to index 0");
0
}))
Err(())
}
}
}
@ -58,131 +59,3 @@ pub(super) enum SpircPlayStatus {
preloading_of_next_track_triggered: bool,
},
}
#[derive(Debug, Clone)]
pub(super) struct ResolveContext {
context: Context,
fallback: Option<String>,
autoplay: bool,
/// if `true` updates the entire context, otherwise only fills the context from the next
/// retrieve page, it is usually used when loading the next page of an already established context
///
/// like for example:
/// - playing an artists profile
update: bool,
}
impl ResolveContext {
pub fn from_uri(uri: impl Into<String>, fallback: impl Into<String>, autoplay: bool) -> Self {
let fallback_uri = fallback.into();
Self {
context: Context {
uri: Some(uri.into()),
..Default::default()
},
fallback: (!fallback_uri.is_empty()).then_some(fallback_uri),
autoplay,
update: true,
}
}
pub fn from_context(context: Context, autoplay: bool) -> Self {
Self {
context,
fallback: None,
autoplay,
update: true,
}
}
// expected page_url: hm://artistplaycontext/v1/page/spotify/album/5LFzwirfFwBKXJQGfwmiMY/km_artist
pub fn from_page_url(page_url: String) -> Self {
let split = if let Some(rest) = page_url.strip_prefix("hm://") {
rest.split('/')
} else {
warn!("page_url didn't started with hm://. got page_url: {page_url}");
page_url.split('/')
};
let uri = split
.skip_while(|s| s != &"spotify")
.take(3)
.collect::<Vec<&str>>()
.join(":");
trace!("created an ResolveContext from page_url <{page_url}> as uri <{uri}>");
Self {
context: Context {
uri: Some(uri),
..Default::default()
},
fallback: None,
update: false,
autoplay: false,
}
}
/// the uri which should be used to resolve the context, might not be the context uri
pub fn resolve_uri(&self) -> Option<&String> {
// it's important to call this always, or at least for every ResolveContext
// otherwise we might not even check if we need to fallback and just use the fallback uri
ConnectState::get_context_uri_from_context(&self.context)
.and_then(|s| (!s.is_empty()).then_some(s))
.or(self.fallback.as_ref())
}
/// the actual context uri
pub fn context_uri(&self) -> &str {
self.context.uri.as_deref().unwrap_or_default()
}
pub fn autoplay(&self) -> bool {
self.autoplay
}
pub fn update(&self) -> bool {
self.update
}
}
impl Display for ResolveContext {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(
f,
"resolve_uri: <{:?}>, context_uri: <{:?}>, autoplay: <{}>, update: <{}>",
self.resolve_uri(),
self.context.uri,
self.autoplay,
self.update
)
}
}
impl PartialEq for ResolveContext {
fn eq(&self, other: &Self) -> bool {
let eq_context = self.context_uri() == other.context_uri();
let eq_resolve = self.resolve_uri() == other.resolve_uri();
let eq_autoplay = self.autoplay == other.autoplay;
let eq_update = self.update == other.update;
eq_context && eq_resolve && eq_autoplay && eq_update
}
}
impl Eq for ResolveContext {}
impl Hash for ResolveContext {
fn hash<H: Hasher>(&self, state: &mut H) {
self.context_uri().hash(state);
self.resolve_uri().hash(state);
self.autoplay.hash(state);
self.update.hash(state);
}
}
impl From<ResolveContext> for Context {
fn from(value: ResolveContext) -> Self {
value.context
}
}

780
connect/src/spirc.rs
View file

File diff suppressed because it is too large Load diff

41
connect/src/state.rs
View file

@ -15,7 +15,6 @@ use crate::{
},
protocol::{
connect::{Capabilities, Device, DeviceInfo, MemberType, PutStateReason, PutStateRequest},
context_page::ContextPage,
player::{
ContextIndex, ContextPlayerOptions, PlayOrigin, PlayerState, ProvidedTrack,
Suppressions,
@ -105,19 +104,17 @@ pub struct ConnectState {
unavailable_uri: Vec<String>,
pub active_since: Option<SystemTime>,
active_since: Option<SystemTime>,
queue_count: u64,
// separation is necessary because we could have already loaded
// the autoplay context but are still playing from the default context
/// to update the active context use [switch_active_context](ConnectState::set_active_context)
pub active_context: ContextType,
pub fill_up_context: ContextType,
fill_up_context: ContextType,
/// the context from which we play, is used to top up prev and next tracks
pub context: Option<StateContext>,
/// upcoming contexts, directly provided by the context-resolver
next_contexts: Vec<ContextPage>,
context: Option<StateContext>,
/// a context to keep track of our shuffled context,
/// should be only available when `player.option.shuffling_context` is true
@ -240,6 +237,22 @@ impl ConnectState {
self.request.is_active
}
/// Returns the `is_playing` value as perceived by other connect devices
///
/// see [ConnectState::set_status]
pub fn is_playing(&self) -> bool {
let player = self.player();
player.is_playing && !player.is_paused
}
/// Returns the `is_paused` state value as perceived by other connect devices
///
/// see [ConnectState::set_status]
pub fn is_pause(&self) -> bool {
let player = self.player();
player.is_playing && player.is_paused && player.is_buffering
}
pub fn set_volume(&mut self, volume: u32) {
self.device_mut()
.device_info
@ -297,6 +310,12 @@ impl ConnectState {
| SpircPlayStatus::Stopped
);
if player.is_paused {
player.playback_speed = 0.;
} else {
player.playback_speed = 1.;
}
// desktop and mobile require all 'states' set to true, when we are paused,
// otherwise the play button (desktop) is grayed out or the preview (mobile) can't be opened
player.is_buffering = player.is_paused
@ -349,9 +368,15 @@ impl ConnectState {
}
pub fn reset_playback_to_position(&mut self, new_index: Option<usize>) -> Result<(), Error> {
debug!(
"reset_playback with active ctx <{:?}> fill_up ctx <{:?}>",
self.active_context, self.fill_up_context
);
let new_index = new_index.unwrap_or(0);
self.update_current_index(|i| i.track = new_index as u32);
self.update_context_index(self.active_context, new_index + 1)?;
self.fill_up_context = self.active_context;
if !self.current_track(|t| t.is_queue()) {
self.set_current_track(new_index)?;
@ -360,7 +385,7 @@ impl ConnectState {
self.clear_prev_track();
if new_index > 0 {
let context = self.get_context(&self.active_context)?;
let context = self.get_context(self.active_context)?;
let before_new_track = context.tracks.len() - new_index;
self.player_mut().prev_tracks = context
@ -375,7 +400,7 @@ impl ConnectState {
debug!("has {} prev tracks", self.prev_tracks().len())
}
self.clear_next_tracks(true);
self.clear_next_tracks();
self.fill_up_next_tracks()?;
self.update_restrictions();

280
connect/src/state/context.rs
View file

@ -7,10 +7,15 @@ use crate::{
player::{ContextIndex, ProvidedTrack},
restrictions::Restrictions,
},
state::{metadata::Metadata, provider::Provider, ConnectState, StateError},
state::{
metadata::Metadata,
provider::{IsProvider, Provider},
ConnectState, StateError, SPOTIFY_MAX_NEXT_TRACKS_SIZE,
},
};
use protobuf::MessageField;
use std::collections::HashMap;
use std::ops::Deref;
use uuid::Uuid;
const LOCAL_FILES_IDENTIFIER: &str = "spotify:local-files";
@ -25,7 +30,7 @@ pub struct StateContext {
pub index: ContextIndex,
}
#[derive(Default, Debug, Copy, Clone)]
#[derive(Default, Debug, Copy, Clone, PartialEq)]
pub enum ContextType {
#[default]
Default,
@ -33,57 +38,81 @@ pub enum ContextType {
Autoplay,
}
pub enum LoadNext {
Done,
PageUrl(String),
Empty,
}
#[derive(Debug)]
#[derive(Debug, Hash, Copy, Clone, PartialEq, Eq)]
pub enum UpdateContext {
Default,
Autoplay,
}
impl Deref for UpdateContext {
type Target = ContextType;
fn deref(&self) -> &Self::Target {
match self {
UpdateContext::Default => &ContextType::Default,
UpdateContext::Autoplay => &ContextType::Autoplay,
}
}
}
pub enum ResetContext<'s> {
Completely,
DefaultIndex,
WhenDifferent(&'s str),
}
/// Extracts the spotify uri from a given page_url
///
/// Just extracts "spotify/album/5LFzwirfFwBKXJQGfwmiMY" and replaces the slash's with colon's
///
/// Expected `page_url` should look something like the following:
/// `hm://artistplaycontext/v1/page/spotify/album/5LFzwirfFwBKXJQGfwmiMY/km_artist`
fn page_url_to_uri(page_url: &str) -> String {
let split = if let Some(rest) = page_url.strip_prefix("hm://") {
rest.split('/')
} else {
warn!("page_url didn't start with hm://. got page_url: {page_url}");
page_url.split('/')
};
split
.skip_while(|s| s != &"spotify")
.take(3)
.collect::<Vec<&str>>()
.join(":")
}
impl ConnectState {
pub fn find_index_in_context<F: Fn(&ProvidedTrack) -> bool>(
context: Option<&StateContext>,
ctx: &StateContext,
f: F,
) -> Result<usize, StateError> {
let ctx = context
.as_ref()
.ok_or(StateError::NoContext(ContextType::Default))?;
ctx.tracks
.iter()
.position(f)
.ok_or(StateError::CanNotFindTrackInContext(None, ctx.tracks.len()))
}
pub(super) fn get_context(&self, ty: &ContextType) -> Result<&StateContext, StateError> {
pub fn get_context(&self, ty: ContextType) -> Result<&StateContext, StateError> {
match ty {
ContextType::Default => self.context.as_ref(),
ContextType::Shuffle => self.shuffle_context.as_ref(),
ContextType::Autoplay => self.autoplay_context.as_ref(),
}
.ok_or(StateError::NoContext(*ty))
.ok_or(StateError::NoContext(ty))
}
pub fn context_uri(&self) -> &String {
&self.player().context_uri
}
pub fn reset_context(&mut self, mut reset_as: ResetContext) {
self.set_active_context(ContextType::Default);
self.fill_up_context = ContextType::Default;
fn different_context_uri(&self, uri: &str) -> bool {
// search identifier is always different
self.context_uri() != uri || uri.starts_with(SEARCH_IDENTIFIER)
}
if matches!(reset_as, ResetContext::WhenDifferent(ctx) if self.context_uri() != ctx) {
pub fn reset_context(&mut self, mut reset_as: ResetContext) {
if matches!(reset_as, ResetContext::WhenDifferent(ctx) if self.different_context_uri(ctx)) {
reset_as = ResetContext::Completely
}
self.shuffle_context = None;
@ -92,7 +121,6 @@ impl ConnectState {
ResetContext::Completely => {
self.context = None;
self.autoplay_context = None;
self.next_contexts.clear();
}
ResetContext::WhenDifferent(_) => debug!("context didn't change, no reset"),
ResetContext::DefaultIndex => {
@ -106,28 +134,40 @@ impl ConnectState {
}
}
self.fill_up_context = ContextType::Default;
self.set_active_context(ContextType::Default);
self.update_restrictions()
}
pub fn get_context_uri_from_context(context: &Context) -> Option<&String> {
let context_uri = context.uri.as_ref()?;
if !context_uri.starts_with(SEARCH_IDENTIFIER) {
return Some(context_uri);
pub fn valid_resolve_uri(uri: &str) -> Option<&str> {
if uri.is_empty() || uri.starts_with(SEARCH_IDENTIFIER) {
None
} else {
Some(uri)
}
}
context
.pages
.first()
.and_then(|p| p.tracks.first().and_then(|t| t.uri.as_ref()))
pub fn get_context_uri_from_context(context: &Context) -> Option<&str> {
let uri = context.uri.as_deref().unwrap_or_default();
Self::valid_resolve_uri(uri).or_else(|| {
context
.pages
.first()
.and_then(|p| p.tracks.first().and_then(|t| t.uri.as_deref()))
})
}
pub fn set_active_context(&mut self, new_context: ContextType) {
self.active_context = new_context;
let ctx = match self.get_context(&new_context) {
let player = self.player_mut();
player.context_metadata = Default::default();
player.restrictions = Some(Default::default()).into();
let ctx = match self.get_context(new_context) {
Err(why) => {
debug!("couldn't load context info because: {why}");
warn!("couldn't load context info because: {why}");
return;
}
Ok(ctx) => ctx,
@ -138,9 +178,6 @@ impl ConnectState {
let player = self.player_mut();
player.context_metadata.clear();
player.restrictions.clear();
if let Some(restrictions) = restrictions.take() {
player.restrictions = MessageField::some(restrictions.into());
}
@ -150,24 +187,25 @@ impl ConnectState {
}
}
pub fn update_context(&mut self, mut context: Context, ty: UpdateContext) -> Result<(), Error> {
pub fn update_context(
&mut self,
mut context: Context,
ty: UpdateContext,
) -> Result<Option<Vec<String>>, Error> {
if context.pages.iter().all(|p| p.tracks.is_empty()) {
error!("context didn't have any tracks: {context:#?}");
return Err(StateError::ContextHasNoTracks.into());
Err(StateError::ContextHasNoTracks)?;
} else if matches!(context.uri, Some(ref uri) if uri.starts_with(LOCAL_FILES_IDENTIFIER)) {
return Err(StateError::UnsupportedLocalPlayBack.into());
}
if matches!(ty, UpdateContext::Default) {
self.next_contexts.clear();
Err(StateError::UnsupportedLocalPlayBack)?;
}
let mut next_contexts = Vec::new();
let mut first_page = None;
for page in context.pages {
if first_page.is_none() && !page.tracks.is_empty() {
first_page = Some(page);
} else {
self.next_contexts.push(page)
next_contexts.push(page)
}
}
@ -176,17 +214,8 @@ impl ConnectState {
Some(p) => p,
};
let prev_context = match ty {
UpdateContext::Default => self.context.as_ref(),
UpdateContext::Autoplay => self.autoplay_context.as_ref(),
};
debug!(
"updated context {ty:?} from <{:?}> ({} tracks) to <{:?}> ({} tracks)",
self.context_uri(),
prev_context
.map(|c| c.tracks.len().to_string())
.unwrap_or_else(|| "-".to_string()),
"updated context {ty:?} to <{:?}> ({} tracks)",
context.uri,
page.tracks.len()
);
@ -195,32 +224,32 @@ impl ConnectState {
UpdateContext::Default => {
let mut new_context = self.state_context_from_page(
page,
context.metadata,
context.restrictions.take(),
context.uri.as_deref(),
None,
);
// when we update the same context, we should try to preserve the previous position
// otherwise we might load the entire context twice
if !self.context_uri().contains(SEARCH_IDENTIFIER)
// otherwise we might load the entire context twice, unless it's the search context
if !self.context_uri().starts_with(SEARCH_IDENTIFIER)
&& matches!(context.uri, Some(ref uri) if uri == self.context_uri())
{
match Self::find_index_in_context(Some(&new_context), |t| {
self.current_track(|t| &t.uri) == &t.uri
}) {
Ok(new_pos) => {
debug!("found new index of current track, updating new_context index to {new_pos}");
new_context.index.track = (new_pos + 1) as u32;
if let Some(new_index) = self.find_last_index_in_new_context(&new_context) {
new_context.index.track = match new_index {
Ok(i) => i,
Err(i) => {
self.player_mut().index = MessageField::none();
i
}
};
// enforce reloading the context
if let Some(autoplay_ctx) = self.autoplay_context.as_mut() {
autoplay_ctx.index.track = 0
}
// the track isn't anymore in the context
Err(_) if matches!(self.active_context, ContextType::Default) => {
warn!("current track was removed, setting pos to last known index");
new_context.index.track = self.player().index.track
}
Err(_) => {}
self.clear_next_tracks();
}
// enforce reloading the context
self.clear_next_tracks(true);
}
self.context = Some(new_context);
@ -235,6 +264,7 @@ impl ConnectState {
UpdateContext::Autoplay => {
self.autoplay_context = Some(self.state_context_from_page(
page,
context.metadata,
context.restrictions.take(),
context.uri.as_deref(),
Some(Provider::Autoplay),
@ -242,12 +272,81 @@ impl ConnectState {
}
}
Ok(())
if next_contexts.is_empty() {
return Ok(None);
}
// load remaining contexts
let next_contexts = next_contexts
.into_iter()
.flat_map(|page| {
if !page.tracks.is_empty() {
self.fill_context_from_page(page).ok()?;
None
} else if matches!(page.page_url, Some(ref url) if !url.is_empty()) {
Some(page_url_to_uri(
&page.page_url.expect("checked by precondition"),
))
} else {
warn!("unhandled context page: {page:#?}");
None
}
})
.collect();
Ok(Some(next_contexts))
}
fn find_first_prev_track_index(&self, ctx: &StateContext) -> Option<usize> {
let prev_tracks = self.prev_tracks();
for i in (0..prev_tracks.len()).rev() {
let prev_track = prev_tracks.get(i)?;
if let Ok(idx) = Self::find_index_in_context(ctx, |t| prev_track.uri == t.uri) {
return Some(idx);
}
}
None
}
fn find_last_index_in_new_context(
&self,
new_context: &StateContext,
) -> Option<Result<u32, u32>> {
let ctx = self.context.as_ref()?;
let is_queued_item = self.current_track(|t| t.is_queue() || t.is_from_queue());
let new_index = if ctx.index.track as usize >= SPOTIFY_MAX_NEXT_TRACKS_SIZE {
Some(ctx.index.track as usize - SPOTIFY_MAX_NEXT_TRACKS_SIZE)
} else if is_queued_item {
self.find_first_prev_track_index(new_context)
} else {
Self::find_index_in_context(new_context, |current| {
self.current_track(|t| t.uri == current.uri)
})
.ok()
}
.map(|i| i as u32 + 1);
Some(new_index.ok_or_else(|| {
info!(
"couldn't distinguish index from current or previous tracks in the updated context"
);
let fallback_index = self
.player()
.index
.as_ref()
.map(|i| i.track)
.unwrap_or_default();
info!("falling back to index {fallback_index}");
fallback_index
}))
}
fn state_context_from_page(
&mut self,
page: ContextPage,
metadata: HashMap<String, String>,
restrictions: Option<Restrictions>,
new_context_uri: Option<&str>,
provider: Option<Provider>,
@ -258,8 +357,12 @@ impl ConnectState {
.tracks
.iter()
.flat_map(|track| {
match self.context_to_provided_track(track, Some(new_context_uri), provider.clone())
{
match self.context_to_provided_track(
track,
Some(new_context_uri),
Some(&page.metadata),
provider.clone(),
) {
Ok(t) => Some(t),
Err(why) => {
error!("couldn't convert {track:#?} into ProvidedTrack: {why}");
@ -272,7 +375,7 @@ impl ConnectState {
StateContext {
tracks,
restrictions,
metadata: page.metadata,
metadata,
index: ContextIndex::new(),
}
}
@ -293,12 +396,11 @@ impl ConnectState {
let new_track_uri = new_track.uri.unwrap_or_default();
if let Ok(position) =
Self::find_index_in_context(Some(current_context), |t| t.uri == new_track_uri)
Self::find_index_in_context(current_context, |t| t.uri == new_track_uri)
{
let context_track = current_context.tracks.get_mut(position)?;
for (key, value) in new_track.metadata {
warn!("merging metadata {key} {value}");
context_track.metadata.insert(key, value);
}
@ -334,10 +436,10 @@ impl ConnectState {
&self,
ctx_track: &ContextTrack,
context_uri: Option<&str>,
page_metadata: Option<&HashMap<String, String>>,
provider: Option<Provider>,
) -> Result<ProvidedTrack, Error> {
let id = match (ctx_track.uri.as_ref(), ctx_track.gid.as_ref()) {
(None, None) => Err(StateError::InvalidTrackUri(None))?,
(Some(uri), _) if uri.contains(['?', '%']) => {
Err(StateError::InvalidTrackUri(Some(uri.clone())))?
}
@ -363,7 +465,7 @@ impl ConnectState {
_ => Uuid::new_v4().as_simple().to_string(),
};
let mut metadata = HashMap::new();
let mut metadata = page_metadata.cloned().unwrap_or_default();
for (k, v) in &ctx_track.metadata {
metadata.insert(k.to_string(), v.to_string());
}
@ -389,7 +491,7 @@ impl ConnectState {
}
pub fn fill_context_from_page(&mut self, page: ContextPage) -> Result<(), Error> {
let context = self.state_context_from_page(page, None, None, None);
let context = self.state_context_from_page(page, HashMap::new(), None, None, None);
let ctx = self
.context
.as_mut()
@ -401,26 +503,4 @@ impl ConnectState {
Ok(())
}
pub fn try_load_next_context(&mut self) -> Result<LoadNext, Error> {
let next = match self.next_contexts.first() {
None => return Ok(LoadNext::Empty),
Some(_) => self.next_contexts.remove(0),
};
if next.tracks.is_empty() {
let next_page_url = match next.page_url {
Some(page_url) if !page_url.is_empty() => page_url,
_ => Err(StateError::NoContext(ContextType::Default))?,
};
self.update_current_index(|i| i.page += 1);
return Ok(LoadNext::PageUrl(next_page_url));
}
self.fill_context_from_page(next)?;
self.fill_up_next_tracks()?;
Ok(LoadNext::Done)
}
}

13
connect/src/state/handle.rs
View file

@ -1,5 +1,10 @@
use crate::state::{context::ResetContext, ConnectState};
use librespot_core::{dealer::protocol::SetQueueCommand, Error};
use crate::{
core::{dealer::protocol::SetQueueCommand, Error},
state::{
context::{ContextType, ResetContext},
ConnectState,
},
};
use protobuf::MessageField;
impl ConnectState {
@ -16,7 +21,7 @@ impl ConnectState {
return Ok(());
}
let ctx = self.context.as_ref();
let ctx = self.get_context(ContextType::Default)?;
let current_index =
ConnectState::find_index_in_context(ctx, |c| self.current_track(|t| c.uri == t.uri))?;
@ -52,7 +57,7 @@ impl ConnectState {
self.set_shuffle(false);
self.reset_context(ResetContext::DefaultIndex);
let ctx = self.context.as_ref();
let ctx = self.get_context(ContextType::Default)?;
let current_track = ConnectState::find_index_in_context(ctx, |t| {
self.current_track(|t| &t.uri) == &t.uri
})?;

16
connect/src/state/options.rs
View file

@ -33,6 +33,12 @@ impl ConnectState {
}
}
pub fn reset_options(&mut self) {
self.set_shuffle(false);
self.set_repeat_track(false);
self.set_repeat_context(false);
}
pub fn shuffle(&mut self) -> Result<(), Error> {
if let Some(reason) = self
.player()
@ -47,16 +53,12 @@ impl ConnectState {
}
self.clear_prev_track();
self.clear_next_tracks(true);
self.clear_next_tracks();
let current_uri = self.current_track(|t| &t.uri);
let ctx = self
.context
.as_ref()
.ok_or(StateError::NoContext(ContextType::Default))?;
let current_track = Self::find_index_in_context(Some(ctx), |t| &t.uri == current_uri)?;
let ctx = self.get_context(ContextType::Default)?;
let current_track = Self::find_index_in_context(ctx, |t| &t.uri == current_uri)?;
let mut shuffle_context = ctx.clone();
// we don't need to include the current track, because it is already being played

8
connect/src/state/restrictions.rs
View file

@ -17,14 +17,18 @@ impl ConnectState {
const ENDLESS_CONTEXT: &str = "endless_context";
let prev_tracks_is_empty = self.prev_tracks().is_empty();
let is_paused = self.is_pause();
let is_playing = self.is_playing();
let player = self.player_mut();
if let Some(restrictions) = player.restrictions.as_mut() {
if player.is_playing {
if is_playing {
restrictions.disallow_pausing_reasons.clear();
restrictions.disallow_resuming_reasons = vec!["not_paused".to_string()]
}
if player.is_paused {
if is_paused {
restrictions.disallow_resuming_reasons.clear();
restrictions.disallow_pausing_reasons = vec!["not_playing".to_string()]
}

60
connect/src/state/tracks.rs
View file

@ -1,12 +1,15 @@
use crate::state::{
context::ContextType,
metadata::Metadata,
provider::{IsProvider, Provider},
ConnectState, StateError, SPOTIFY_MAX_NEXT_TRACKS_SIZE, SPOTIFY_MAX_PREV_TRACKS_SIZE,
use crate::{
core::{Error, SpotifyId},
protocol::player::ProvidedTrack,
state::{
context::ContextType,
metadata::Metadata,
provider::{IsProvider, Provider},
ConnectState, StateError, SPOTIFY_MAX_NEXT_TRACKS_SIZE, SPOTIFY_MAX_PREV_TRACKS_SIZE,
},
};
use librespot_core::{Error, SpotifyId};
use librespot_protocol::player::ProvidedTrack;
use protobuf::MessageField;
use rand::Rng;
// identifier used as part of the uid
pub const IDENTIFIER_DELIMITER: &str = "delimiter";
@ -64,8 +67,14 @@ impl<'ct> ConnectState {
&self.player().next_tracks
}
pub fn set_current_track_random(&mut self) -> Result<(), Error> {
let max_tracks = self.get_context(self.active_context)?.tracks.len();
let rng_track = rand::thread_rng().gen_range(0..max_tracks);
self.set_current_track(rng_track)
}
pub fn set_current_track(&mut self, index: usize) -> Result<(), Error> {
let context = self.get_context(&self.active_context)?;
let context = self.get_context(self.active_context)?;
let new_track = context
.tracks
@ -77,8 +86,8 @@ impl<'ct> ConnectState {
debug!(
"set track to: {} at {} of {} tracks",
index,
new_track.uri,
index,
context.tracks.len()
);
@ -132,7 +141,7 @@ impl<'ct> ConnectState {
self.set_active_context(ContextType::Autoplay);
None
} else {
let ctx = self.context.as_ref();
let ctx = self.get_context(ContextType::Default)?;
let new_index = Self::find_index_in_context(ctx, |c| c.uri == new_track.uri);
match new_index {
Ok(new_index) => Some(new_index as u32),
@ -251,12 +260,7 @@ impl<'ct> ConnectState {
self.prev_tracks_mut().clear()
}
pub fn clear_next_tracks(&mut self, keep_queued: bool) {
if !keep_queued {
self.next_tracks_mut().clear();
return;
}
pub fn clear_next_tracks(&mut self) {
// respect queued track and don't throw them out of our next played tracks
let first_non_queued_track = self
.next_tracks()
@ -271,13 +275,13 @@ impl<'ct> ConnectState {
}
}
pub fn fill_up_next_tracks(&mut self) -> Result<(), StateError> {
let ctx = self.get_context(&self.fill_up_context)?;
pub fn fill_up_next_tracks(&mut self) -> Result<(), Error> {
let ctx = self.get_context(self.fill_up_context)?;
let mut new_index = ctx.index.track as usize;
let mut iteration = ctx.index.page;
while self.next_tracks().len() < SPOTIFY_MAX_NEXT_TRACKS_SIZE {
let ctx = self.get_context(&self.fill_up_context)?;
let ctx = self.get_context(self.fill_up_context)?;
let track = match ctx.tracks.get(new_index) {
None if self.repeat_context() => {
let delimiter = Self::new_delimiter(iteration.into());
@ -292,14 +296,14 @@ impl<'ct> ConnectState {
// transition to autoplay as fill up context
self.fill_up_context = ContextType::Autoplay;
new_index = self.get_context(&ContextType::Autoplay)?.index.track as usize;
new_index = self.get_context(ContextType::Autoplay)?.index.track as usize;
// add delimiter to only display the current context
Self::new_delimiter(iteration.into())
}
None if self.autoplay_context.is_some() => {
match self
.get_context(&ContextType::Autoplay)?
.get_context(ContextType::Autoplay)?
.tracks
.get(new_index)
{
@ -324,6 +328,11 @@ impl<'ct> ConnectState {
self.next_tracks_mut().push(track);
}
debug!(
"finished filling up next_tracks ({})",
self.next_tracks().len()
);
self.update_context_index(self.fill_up_context, new_index)?;
// the web-player needs a revision update, otherwise the queue isn't updated in the ui
@ -350,17 +359,14 @@ impl<'ct> ConnectState {
}
}
pub fn prev_autoplay_track_uris(&self) -> Vec<String> {
pub fn recent_track_uris(&self) -> Vec<String> {
let mut prev = self
.prev_tracks()
.iter()
.flat_map(|t| t.is_autoplay().then_some(t.uri.clone()))
.map(|t| t.uri.clone())
.collect::<Vec<_>>();
if self.current_track(|t| t.is_autoplay()) {
prev.push(self.current_track(|t| t.uri.clone()));
}
prev.push(self.current_track(|t| t.uri.clone()));
prev
}

12
connect/src/state/transfer.rs
View file

@ -25,10 +25,12 @@ impl ConnectState {
self.context_to_provided_track(
track,
transfer.current_session.context.uri.as_deref(),
None,
transfer
.queue
.is_playing_queue
.and_then(|b| b.then_some(Provider::Queue)),
.unwrap_or_default()
.then_some(Provider::Queue),
)
}
@ -72,7 +74,8 @@ impl ConnectState {
}
self.clear_prev_track();
self.clear_next_tracks(false);
self.clear_next_tracks();
self.update_queue_revision()
}
/// completes the transfer, loading the queue and updating metadata
@ -91,7 +94,7 @@ impl ConnectState {
self.set_active_context(context_ty);
self.fill_up_context = context_ty;
let ctx = self.get_context(&self.active_context).ok();
let ctx = self.get_context(self.active_context)?;
let current_index = match transfer.current_session.current_uid.as_ref() {
Some(uid) if track.is_queue() => Self::find_index_in_context(ctx, |c| &c.uid == uid)
@ -103,7 +106,7 @@ impl ConnectState {
"active track is <{}> with index {current_index:?} in {:?} context, has {} tracks",
track.uri,
self.active_context,
ctx.map(|c| c.tracks.len()).unwrap_or_default()
ctx.tracks.len()
);
if self.player().track.is_none() {
@ -130,6 +133,7 @@ impl ConnectState {
if let Ok(queued_track) = self.context_to_provided_track(
track,
Some(self.context_uri()),
None,
Some(Provider::Queue),
) {
self.add_to_queue(queued_track, false);

4
core/src/dealer/protocol.rs
View file

@ -174,7 +174,9 @@ fn handle_transfer_encoding(
) -> Result<Vec<u8>, Error> {
let encoding = headers.get("Transfer-Encoding").map(String::as_str);
if let Some(encoding) = encoding {
trace!("message was send with {encoding} encoding ");
trace!("message was sent with {encoding} encoding ");
} else {
trace!("message was sent with no encoding ");
}
if !matches!(encoding, Some("gzip")) {

2
core/src/spclient.rs
View file

@ -813,7 +813,7 @@ impl SpClient {
/// **will** contain the query
/// - artists
/// - returns 2 pages with tracks: 10 most popular tracks and latest/popular album
/// - remaining pages are albums of the artists and are only provided as page_url
/// - remaining pages are artist albums sorted by popularity (only provided as page_url)
/// - search
/// - is massively influenced by the provided query
/// - the query result shown by the search expects no query at all

2
examples/play_connect.rs
View file

@ -84,7 +84,7 @@ async fn main() {
repeat: false,
repeat_track: false,
// the index specifies which track in the context starts playing, in this case the first in the album
playing_track: PlayingTrack::Index(0),
playing_track: PlayingTrack::Index(0).into(),
})
.unwrap();
});

2
protocol/src/impl_trait.rs Normal file
View file

@ -0,0 +1,2 @@
mod context;
mod player;

13
protocol/src/impl_trait/context.rs Normal file
View file

@ -0,0 +1,13 @@
use crate::context::Context;
use protobuf::Message;
use std::hash::{Hash, Hasher};
impl Hash for Context {
fn hash<H: Hasher>(&self, state: &mut H) {
if let Ok(ctx) = self.write_to_bytes() {
ctx.hash(state)
}
}
}
impl Eq for Context {}

0
protocol/src/conversion.rs → protocol/src/impl_trait/player.rs
View file

2
protocol/src/lib.rs
View file

@ -1,6 +1,6 @@
// This file is parsed by build.rs
// Each included module will be compiled from the matching .proto definition.
mod conversion;
mod impl_trait;
include!(concat!(env!("OUT_DIR"), "/mod.rs"));