#![allow(clippy::unused_io_amount)]
#[macro_use]
extern crate log;
#[macro_use]
extern crate async_trait;
pub mod cover;
use std::collections::HashMap;
use std::string::FromUtf8Error;
use librespot_core::mercury::MercuryError;
use librespot_core::session::Session;
use librespot_core::spotify_id::{FileId, SpotifyAudioType, SpotifyId, SpotifyIdError};
use librespot_protocol as protocol;
use protobuf::Message;
pub use crate::protocol::metadata::AudioFile_Format as FileFormat;
fn countrylist_contains(list: &str, country: &str) -> bool {
list.chunks(2).any(|cc| cc == country)
}
fn parse_restrictions<'s, I>(restrictions: I, country: &str, catalogue: &str) -> bool
where
I: IntoIterator<Item = &'s protocol::metadata::Restriction>,
{
let mut forbidden = "".to_string();
let mut has_forbidden = false;
let mut allowed = "".to_string();
let mut has_allowed = false;
let rs = restrictions
.into_iter()
.filter(|r| r.get_catalogue_str().contains(&catalogue.to_owned()));
for r in rs {
if r.has_countries_forbidden() {
forbidden.push_str(r.get_countries_forbidden());
has_forbidden = true;
}
if r.has_countries_allowed() {
allowed.push_str(r.get_countries_allowed());
has_allowed = true;
}
}
(has_forbidden || has_allowed)
&& (!has_forbidden || !countrylist_contains(forbidden.as_str(), country))
&& (!has_allowed || countrylist_contains(allowed.as_str(), country))
}
#[derive(Debug, Clone)]
pub struct AudioItem {
pub id: SpotifyId,
pub uri: String,
pub files: HashMap<FileFormat, FileId>,
pub name: String,
pub duration: i32,
pub available: bool,
pub alternatives: Option<Vec<SpotifyId>>,
}
impl AudioItem {
pub async fn get_audio_item(session: &Session, id: SpotifyId) -> Result<Self, MercuryError> {
match id.audio_type {
SpotifyAudioType::Track => Track::get_audio_item(session, id).await,
SpotifyAudioType::Podcast => Episode::get_audio_item(session, id).await,
SpotifyAudioType::NonPlayable => Err(MercuryError),
}
}
}
#[async_trait]
trait AudioFiles {
async fn get_audio_item(session: &Session, id: SpotifyId) -> Result<AudioItem, MercuryError>;
}
#[async_trait]
impl AudioFiles for Track {
async fn get_audio_item(session: &Session, id: SpotifyId) -> Result<AudioItem, MercuryError> {
match id.to_base62() {
Err(e) => {
warn!("Invalid Track SpotifyId: {}", e);
Err(MercuryError)
}
Ok(uri) => {
let item = Self::get(session, id).await?;
Ok(AudioItem {
id,
uri: format!("spotify:track:{}", uri),
files: item.files,
name: item.name,
duration: item.duration,
available: item.available,
alternatives: Some(item.alternatives),
})
}
}
}
}
#[async_trait]
impl AudioFiles for Episode {
async fn get_audio_item(session: &Session, id: SpotifyId) -> Result<AudioItem, MercuryError> {
match id.to_base62() {
Err(e) => {
warn!("Invalid Episode SpotifyId: {}", e);
Err(MercuryError)
}
Ok(uri) => {
let item = Self::get(session, id).await?;
Ok(AudioItem {
id,
uri: format!("spotify:episode:{}", uri),
files: item.files,
name: item.name,
duration: item.duration,
available: item.available,
alternatives: None,
})
}
}
}
}
#[async_trait]
pub trait Metadata: Send + Sized + 'static {
type Message: protobuf::Message;
fn request_url(id: SpotifyId) -> Result<String, FromUtf8Error>;
fn parse(msg: &Self::Message, session: &Session) -> Result<Self, SpotifyIdError>;
async fn get(session: &Session, id: SpotifyId) -> Result<Self, MercuryError> {
match Self::request_url(id) {
Err(e) => {
warn!("Invalid SpotifyId: {}", e);
Err(MercuryError)
}
Ok(uri) => {
let response = session.mercury().get(uri).await?;
match response.payload.first() {
None => {
warn!("Empty payload");
Err(MercuryError)
}
Some(data) => match Self::Message::parse_from_bytes(data) {
Err(e) => {
warn!("Error parsing message from bytes: {}", e);
Err(MercuryError)
}
Ok(msg) => match Self::parse(&msg, session) {
Err(e) => {
warn!("Error parsing message: {:?}", e);
Err(MercuryError)
}
Ok(parsed_msg) => Ok(parsed_msg),
},
},
}
}
}
}
}
#[derive(Debug, Clone)]
pub struct Track {
pub id: SpotifyId,
pub name: String,
pub duration: i32,
pub album: SpotifyId,
pub artists: Vec<SpotifyId>,
pub files: HashMap<FileFormat, FileId>,
pub alternatives: Vec<SpotifyId>,
pub available: bool,
}
#[derive(Debug, Clone)]
pub struct Album {
pub id: SpotifyId,
pub name: String,
pub artists: Vec<SpotifyId>,
pub tracks: Vec<SpotifyId>,
pub covers: Vec<FileId>,
}
#[derive(Debug, Clone)]
pub struct Episode {
pub id: SpotifyId,
pub name: String,
pub external_url: String,
pub duration: i32,
pub language: String,
pub show: SpotifyId,
pub files: HashMap<FileFormat, FileId>,
pub covers: Vec<FileId>,
pub available: bool,
pub explicit: bool,
}
#[derive(Debug, Clone)]
pub struct Show {
pub id: SpotifyId,
pub name: String,
pub publisher: String,
pub episodes: Vec<SpotifyId>,
pub covers: Vec<FileId>,
}
#[derive(Debug, Clone)]
pub struct Playlist {
pub revision: Vec<u8>,
pub user: String,
pub name: String,
pub tracks: Vec<SpotifyId>,
}
#[derive(Debug, Clone)]
pub struct Artist {
pub id: SpotifyId,
pub name: String,
pub top_tracks: Vec<SpotifyId>,
}
impl Metadata for Track {
type Message = protocol::metadata::Track;
fn request_url(id: SpotifyId) -> Result<String, FromUtf8Error> {
let id = id.to_base16()?;
Ok(format!("hm://metadata/3/track/{}", id))
}
fn parse(msg: &Self::Message, session: &Session) -> Result<Self, SpotifyIdError> {
let country = session.country();
let artists = msg
.get_artist()
.iter()
.filter_map(|artist| {
if artist.has_gid() {
SpotifyId::from_raw(artist.get_gid()).ok()
} else {
None
}
})
.collect();
let files = msg
.get_file()
.iter()
.filter_map(|file| {
if file.has_file_id() {
let mut dst = [0u8; 20];
dst.clone_from_slice(file.get_file_id());
Some((file.get_format(), FileId(dst)))
} else {
None
}
})
.collect();
Ok(Track {
id: SpotifyId::from_raw(msg.get_gid())?,
name: msg.get_name().to_owned(),
duration: msg.get_duration(),
album: SpotifyId::from_raw(msg.get_album().get_gid())?,
artists,
files,
alternatives: msg
.get_alternative()
.iter()
.filter_map(|alt| SpotifyId::from_raw(alt.get_gid()).ok())
.collect(),
available: parse_restrictions(msg.get_restriction(), &country, "premium"),
})
}
}
impl Metadata for Album {
type Message = protocol::metadata::Album;
fn request_url(id: SpotifyId) -> Result<String, FromUtf8Error> {
let id = id.to_base16()?;
Ok(format!("hm://metadata/3/album/{}", id))
}
fn parse(msg: &Self::Message, _: &Session) -> Result<Self, SpotifyIdError> {
let artists = msg
.get_artist()
.iter()
.filter_map(|artist| {
if artist.has_gid() {
SpotifyId::from_raw(artist.get_gid()).ok()
} else {
None
}
})
.collect();
let tracks = msg
.get_disc()
.iter()
.flat_map(|disc| disc.get_track())
.filter_map(|track| {
if track.has_gid() {
SpotifyId::from_raw(track.get_gid()).ok()
} else {
None
}
})
.collect();
let covers = msg
.get_cover_group()
.get_image()
.iter()
.filter_map(|image| {
if image.has_file_id() {
let mut dst = [0u8; 20];
dst.clone_from_slice(image.get_file_id());
Some(FileId(dst))
} else {
None
}
})
.collect();
Ok(Album {
id: SpotifyId::from_raw(msg.get_gid())?,
name: msg.get_name().to_owned(),
artists,
tracks,
covers,
})
}
}
impl Metadata for Playlist {
type Message = protocol::playlist4changes::SelectedListContent;
fn request_url(id: SpotifyId) -> Result<String, FromUtf8Error> {
let id = id.to_base62()?;
Ok(format!("hm://playlist/v2/playlist/{}", id))
}
fn parse(msg: &Self::Message, _: &Session) -> Result<Self, SpotifyIdError> {
let tracks = msg
.get_contents()
.get_items()
.iter()
.filter_map(|item| {
let uri_split = item.get_uri().split(':');
let uri_parts: Vec<&str> = uri_split.collect();
SpotifyId::from_base62(uri_parts[2]).ok()
})
.collect::<Vec<_>>();
if tracks.len() != msg.get_length() as usize {
warn!(
"Got {} tracks, but the playlist should contain {} tracks.",
tracks.len(),
msg.get_length()
);
}
Ok(Playlist {
revision: msg.get_revision().to_vec(),
name: msg.get_attributes().get_name().to_owned(),
tracks,
user: msg.get_owner_username().to_string(),
})
}
}
impl Metadata for Artist {
type Message = protocol::metadata::Artist;
fn request_url(id: SpotifyId) -> Result<String, FromUtf8Error> {
let id = id.to_base16()?;
Ok(format!("hm://metadata/3/artist/{}", id))
}
fn parse(msg: &Self::Message, session: &Session) -> Result<Self, SpotifyIdError> {
let country = session.country();
let top_tracks: Vec<SpotifyId> = match msg
.get_top_track()
.iter()
.find(|tt| !tt.has_country() || countrylist_contains(tt.get_country(), &country))
{
Some(tracks) => tracks
.get_track()
.iter()
.filter_map(|track| {
if track.has_gid() {
SpotifyId::from_raw(track.get_gid()).ok()
} else {
None
}
})
.collect(),
None => Vec::new(),
};
Ok(Artist {
id: SpotifyId::from_raw(msg.get_gid())?,
name: msg.get_name().to_owned(),
top_tracks,
})
}
}
impl Metadata for Episode {
type Message = protocol::metadata::Episode;
fn request_url(id: SpotifyId) -> Result<String, FromUtf8Error> {
let id = id.to_base16()?;
Ok(format!("hm://metadata/3/episode/{}", id))
}
fn parse(msg: &Self::Message, session: &Session) -> Result<Self, SpotifyIdError> {
let country = session.country();
let files = msg
.get_file()
.iter()
.filter(|file| file.has_file_id())
.map(|file| {
let mut dst = [0u8; 20];
dst.clone_from_slice(file.get_file_id());
(file.get_format(), FileId(dst))
})
.collect();
let covers = msg
.get_covers()
.get_image()
.iter()
.filter(|image| image.has_file_id())
.map(|image| {
let mut dst = [0u8; 20];
dst.clone_from_slice(image.get_file_id());
FileId(dst)
})
.collect();
Ok(Episode {
id: SpotifyId::from_raw(msg.get_gid()).unwrap(),
name: msg.get_name().to_owned(),
external_url: msg.get_external_url().to_owned(),
duration: msg.get_duration().to_owned(),
language: msg.get_language().to_owned(),
show: SpotifyId::from_raw(msg.get_show().get_gid()).unwrap(),
covers,
files,
available: parse_restrictions(msg.get_restriction(), &country, "premium"),
explicit: msg.get_explicit().to_owned(),
})
}
}
impl Metadata for Show {
type Message = protocol::metadata::Show;
fn request_url(id: SpotifyId) -> Result<String, FromUtf8Error> {
let id = id.to_base16()?;
Ok(format!("hm://metadata/3/show/{}", id))
}
fn parse(msg: &Self::Message, _: &Session) -> Result<Self, SpotifyIdError> {
let episodes = msg
.get_episode()
.iter()
.filter_map(|episode| {
if episode.has_gid() {
SpotifyId::from_raw(episode.get_gid()).ok()
} else {
None
}
})
.collect();
let covers = msg
.get_covers()
.get_image()
.iter()
.filter(|image| image.has_file_id())
.map(|image| {
let mut dst = [0u8; 20];
dst.clone_from_slice(image.get_file_id());
FileId(dst)
})
.collect();
Ok(Show {
id: SpotifyId::from_raw(msg.get_gid()).unwrap(),
name: msg.get_name().to_owned(),
publisher: msg.get_publisher().to_owned(),
episodes,
covers,
})
}
}
struct StrChunks<'s>(&'s str, usize);
trait StrChunksExt {
fn chunks(&self, size: usize) -> StrChunks;
}
impl StrChunksExt for str {
fn chunks(&self, size: usize) -> StrChunks {
StrChunks(self, size)
}
}
impl<'s> Iterator for StrChunks<'s> {
type Item = &'s str;
fn next(&mut self) -> Option<&'s str> {
let &mut StrChunks(data, size) = self;
if data.is_empty() {
None
} else {
let ret = Some(&data[..size]);
self.0 = &data[size..];
ret
}
}
}