Musyx Mobile: Android TV player for Yandex Music
Kotlin, Compose for TV and Media3 port of the desktop Musyx, with device-code sign-in, Home, My Wave, search, collection, detail pages, Now Playing with queue and lyrics, and settings for streaming quality, appearance, font size (small, medium, large) and language. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
commit
46610d95fa
217 files changed
+26144
No files matched your search
@@ -0,0 +1,124 @@
|
||||
//! Read-only check of the discovery endpoints with the signed-in account:
|
||||
//! `cargo run -p musyx --example api_probe`. Prints counts and a few titles.
|
||||
use ym_api::auth::Credentials;
|
||||
use ym_api::{SearchKind, YmClient};
|
||||
|
||||
#[tokio::main(flavor = "current_thread")]
|
||||
async fn main() {
|
||||
let raw = keyring::Entry::new("musyx", "yandex-music")
|
||||
.and_then(|e| e.get_password())
|
||||
.expect("sign in with Musyx first");
|
||||
let credentials: Credentials = serde_json::from_str(&raw).expect("stored credentials");
|
||||
let (client, account) = YmClient::connect(&credentials, ym_api::ContentLanguage::English).await.expect("connect");
|
||||
println!("account: {} (plus: {})", account.login, account.has_plus);
|
||||
|
||||
match client.home().await {
|
||||
Ok(h) => println!(
|
||||
"home: {} personal {:?}, {} chart, {} new releases, {} new playlists",
|
||||
h.personal.len(),
|
||||
h.personal.iter().map(|p| p.playlist.title.as_str()).collect::<Vec<_>>(),
|
||||
h.chart.len(),
|
||||
h.new_releases.len(),
|
||||
h.new_playlists.len()
|
||||
),
|
||||
Err(e) => println!("home: ERROR {e}"),
|
||||
}
|
||||
match client.genres().await {
|
||||
Ok(g) => {
|
||||
println!("genres: {} {:?}", g.len(), g.iter().take(8).map(|g| (&g.id, &g.title)).collect::<Vec<_>>());
|
||||
for genre in g.iter().skip(1).take(4) {
|
||||
match client.tag_playlists(&genre.id).await {
|
||||
Ok(p) => println!("tag {}: {} playlists {:?}", genre.id, p.len(), p.iter().take(2).map(|p| &p.title).collect::<Vec<_>>()),
|
||||
Err(e) => println!("tag {}: ERROR {e}", genre.id),
|
||||
}
|
||||
}
|
||||
}
|
||||
Err(e) => println!("genres: ERROR {e}"),
|
||||
}
|
||||
match client.featured_podcasts().await {
|
||||
Ok(p) => println!("podcasts: {} {:?}", p.len(), p.iter().take(3).map(|a| &a.title).collect::<Vec<_>>()),
|
||||
Err(e) => println!("podcasts: ERROR {e}"),
|
||||
}
|
||||
match client.search("земфира", SearchKind::All, 0).await {
|
||||
Ok(r) => println!(
|
||||
"search: best {:?}, {} tracks ({}), {} albums, {} artists, {} playlists, {} podcasts",
|
||||
r.best.as_ref().map(|b| format!("{b:?}").chars().take(60).collect::<String>()),
|
||||
r.tracks.len(), r.totals.tracks, r.albums.len(), r.artists.len(), r.playlists.len(), r.podcasts.len()
|
||||
),
|
||||
Err(e) => println!("search: ERROR {e}"),
|
||||
}
|
||||
match client.stations().await {
|
||||
Ok(st) => println!("stations: {} {:?}", st.len(), st.iter().take(6).map(|s| (&s.id, &s.name)).collect::<Vec<_>>()),
|
||||
Err(e) => println!("stations: ERROR {e}"),
|
||||
}
|
||||
match client.wave_settings(ym_api::MY_WAVE).await {
|
||||
Ok(s) => println!("wave settings: {s:?}"),
|
||||
Err(e) => println!("wave settings: ERROR {e}"),
|
||||
}
|
||||
match client.wave_start(ym_api::MY_WAVE, None).await {
|
||||
Ok(b) => println!(
|
||||
"wave session {:?} batch {:?}: {:?}",
|
||||
b.session_id,
|
||||
b.batch_id,
|
||||
b.tracks.iter().map(|t| format!("{} — {}", t.artist_line(), t.title)).collect::<Vec<_>>()
|
||||
),
|
||||
Err(e) => println!("wave: ERROR {e}"),
|
||||
}
|
||||
match client.liked_ids().await {
|
||||
Ok(l) => println!(
|
||||
"liked ids: {} albums, {} artists, {} playlists, {} disliked tracks",
|
||||
l.albums.len(), l.artists.len(), l.playlists.len(), l.disliked_tracks.len()
|
||||
),
|
||||
Err(e) => println!("liked ids: ERROR {e}"),
|
||||
}
|
||||
if let Ok(found) = client.search("eminem without me", SearchKind::Tracks, 0).await {
|
||||
for track in found.tracks.iter().take(2) {
|
||||
println!("track {} {} lyrics_available={}", track.id, track.title, track.lyrics_available);
|
||||
match client.lyrics(&track.id).await {
|
||||
Ok(Some(l)) => println!(
|
||||
"lyrics {}: synced={} lines={} first_stamp={:?}",
|
||||
track.id, l.synced, l.lines.len(), l.lines.first().and_then(|x| x.at)
|
||||
),
|
||||
Ok(None) => println!("lyrics {}: none", track.id),
|
||||
Err(e) => println!("lyrics {}: ERROR {e}", track.id),
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Ok(chart) = client.chart().await {
|
||||
for entry in chart.iter().take(3) {
|
||||
println!("chart {} lyrics_available={}", entry.track.id, entry.track.lyrics_available);
|
||||
match client.lyrics(&entry.track.id).await {
|
||||
Ok(Some(l)) => println!(
|
||||
"lyrics {}: synced={} lines={} first_stamp={:?}",
|
||||
entry.track.id, l.synced, l.lines.len(), l.lines.first().and_then(|x| x.at)
|
||||
),
|
||||
Ok(None) => println!("lyrics {}: none", entry.track.id),
|
||||
Err(e) => println!("lyrics {}: ERROR {e}", entry.track.id),
|
||||
}
|
||||
}
|
||||
}
|
||||
match client.recently_played(10).await {
|
||||
Ok(r) => println!("recently played: {} {:?}", r.len(), r.iter().take(3).map(|t| t.full_title()).collect::<Vec<_>>()),
|
||||
Err(e) => println!("recently played: ERROR {e}"),
|
||||
}
|
||||
match client.similar_tracks("85507364").await {
|
||||
Ok(s) => println!("similar: {} {:?}", s.len(), s.iter().take(3).map(|t| format!("{} — {}", t.artist_line(), t.title)).collect::<Vec<_>>()),
|
||||
Err(e) => println!("similar: ERROR {e}"),
|
||||
}
|
||||
match client.artist_clips(675068).await {
|
||||
Ok(c) => println!(
|
||||
"artist clips: {} {:?}",
|
||||
c.len(),
|
||||
c.iter().take(3).map(|c| format!("{} {} — {} ({}s)", c.id, c.artist_line(), c.title, c.duration.as_secs())).collect::<Vec<_>>()
|
||||
),
|
||||
Err(e) => println!("artist clips: ERROR {e}"),
|
||||
}
|
||||
match client.liked_clips().await {
|
||||
Ok(c) => println!("liked clips: {} {:?}", c.len(), c.iter().take(3).map(|c| &c.title).collect::<Vec<_>>()),
|
||||
Err(e) => println!("liked clips: ERROR {e}"),
|
||||
}
|
||||
match client.suggest("зем").await {
|
||||
Ok(s) => println!("suggest: {:?}", s.iter().take(5).collect::<Vec<_>>()),
|
||||
Err(e) => println!("suggest: ERROR {e}"),
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
//! Lists output devices and tries to open each one: `cargo run -p musyx --example audio_probe`.
|
||||
use rodio::DeviceSinkBuilder;
|
||||
use rodio::cpal::traits::{DeviceTrait, HostTrait};
|
||||
|
||||
fn main() {
|
||||
let host = rodio::cpal::default_host();
|
||||
let default = host.default_output_device();
|
||||
println!("default: {:?}", default.as_ref().and_then(|d| d.description().ok()).map(|d| d.name().to_string()));
|
||||
for device in host.output_devices().expect("devices") {
|
||||
let name = device.description().map(|d| d.name().to_string()).unwrap_or_default();
|
||||
let config = device.default_output_config();
|
||||
println!("\n{name}\n default config: {config:?}");
|
||||
match DeviceSinkBuilder::from_device(device.clone()).map(|b| b.open_stream()) {
|
||||
Ok(Ok(_)) => println!(" open (rodio defaults): ok"),
|
||||
Ok(Err(e)) => println!(" open (rodio defaults): {e:?}"),
|
||||
Err(e) => println!(" builder: {e:?}"),
|
||||
}
|
||||
if let Ok(config) = config {
|
||||
let r = DeviceSinkBuilder::default().with_device(device.clone()).with_supported_config(&config).open_stream();
|
||||
println!(" open (device default buffer): {:?}", r.map(|_| "ok"));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
//! Read-only check of lossless streaming with the signed-in account:
|
||||
//! `cargo run -p musyx --example stream_probe [query]`. Asks for FLAC, downloads
|
||||
//! and decrypts it, and decodes the start to show the format.
|
||||
use std::io::Cursor;
|
||||
use std::time::Instant;
|
||||
|
||||
use rodio::Source;
|
||||
use ym_api::auth::Credentials;
|
||||
use ym_api::{SearchKind, YmClient};
|
||||
|
||||
#[tokio::main(flavor = "current_thread")]
|
||||
async fn main() {
|
||||
let raw = keyring::Entry::new("musyx", "yandex-music")
|
||||
.and_then(|e| e.get_password())
|
||||
.expect("sign in with Musyx first");
|
||||
let credentials: Credentials = serde_json::from_str(&raw).expect("stored credentials");
|
||||
let (client, account) = YmClient::connect(&credentials, ym_api::ContentLanguage::English).await.expect("connect");
|
||||
println!("account: {} (plus: {})", account.login, account.has_plus);
|
||||
|
||||
let query = std::env::args().nth(1).unwrap_or_else(|| "земфира хочешь".into());
|
||||
let found = client.search(&query, SearchKind::Tracks, 0).await.expect("search");
|
||||
let track = found.tracks.first().expect("no tracks found");
|
||||
println!("track: {} — {} ({})", track.artist_line(), track.title, track.id);
|
||||
|
||||
let started = Instant::now();
|
||||
let stream = client.lossless_stream(&track.id).await.expect("stream");
|
||||
println!("stream: {stream:?} label={} in {:?}", stream.label(), started.elapsed());
|
||||
let started = Instant::now();
|
||||
let bytes = client.fetch(&stream).await.expect("fetch");
|
||||
println!("fetched {:.1} MB in {:?}, starts with {:?}", bytes.len() as f64 / 1e6, started.elapsed(), String::from_utf8_lossy(&bytes[..12]));
|
||||
|
||||
let decoder = rodio::Decoder::builder()
|
||||
.with_data(Cursor::new(bytes.to_vec()))
|
||||
.with_byte_len(bytes.len() as u64)
|
||||
.with_hint(stream.container())
|
||||
.with_seekable(true)
|
||||
.build()
|
||||
.expect("decode");
|
||||
println!(
|
||||
"decoded: {} Hz, {} ch, duration {:?}",
|
||||
decoder.sample_rate(),
|
||||
decoder.channels(),
|
||||
decoder.total_duration()
|
||||
);
|
||||
let samples = decoder.take(48_000).filter(|s| s.abs() > 0.0).count();
|
||||
println!("non-silent samples in the first 48k: {samples}");
|
||||
}
|
||||
Reference in new issue
Block a user