dtourolle
fecd6022fe
Master allocated DR-224 and UT-211 while this branch was in flight — the third collision on this work. Everything here moves up by one: DR-224..236 become DR-225..237, UT-211..213 become UT-212..214. UR-079, UR-080 and IR-033 were still free and are unchanged. Mechanical, and matched on each row's own text rather than on its number, so a row cannot be shifted twice or the wrong one caught. Master's DR-224 (the background-audio toggle) and UT-211 are untouched.
605 lines
19 KiB
Rust
605 lines
19 KiB
Rust
use serde::{Deserialize, Serialize};
|
|
use std::path::PathBuf;
|
|
|
|
/// Context for the current queue - where did the queue items come from?
|
|
/// This is used for remote playback transfer to send album/playlist context.
|
|
#[derive(specta::Type, Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
|
|
#[serde(tag = "type", rename_all = "lowercase")]
|
|
pub enum QueueContext {
|
|
/// Playing from a specific album
|
|
Album {
|
|
album_id: String,
|
|
album_name: String,
|
|
},
|
|
/// Playing from a specific playlist
|
|
Playlist {
|
|
playlist_id: String,
|
|
playlist_name: String,
|
|
},
|
|
/// Custom queue (search results, manual queue, etc.)
|
|
/// Will create a temporary playlist on remote transfer
|
|
#[default]
|
|
Custom,
|
|
}
|
|
|
|
/// Represents a subtitle track
|
|
///
|
|
/// 🔴 **Do not add `#[serde(rename_all = "camelCase")]` here.** This is the one
|
|
/// struct in the player that deliberately keeps snake_case on the wire, because
|
|
/// the *same* serialization feeds two consumers that both spell `mime_type`:
|
|
///
|
|
/// * the JNI boundary — `player/android/mod.rs` serializes `MediaItem::subtitles`
|
|
/// with `serde_json` and hands the string to `JellyTauPlayer.loadWithMetadata`,
|
|
/// whose parser reads `url`, `language`, `label` and `optString("mime_type")`;
|
|
/// * the IPC boundary — `PlayItemRequest::subtitles` deserializes this same type
|
|
/// from the frontend, and the generated binding (`SubtitleTrack` in
|
|
/// `bindings.ts`) therefore also declares `mime_type`.
|
|
///
|
|
/// Renaming would not break the build and would not fail the IPC: Kotlin's
|
|
/// `optString` would just fall back to its default MIME type for every track, so
|
|
/// the failure would be silent. UT-146 asserts the serialized keys.
|
|
///
|
|
/// TRACES: UR-020 | IR-016, JA-008 | UT-146
|
|
#[derive(specta::Type, Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub struct SubtitleTrack {
|
|
/// Stream index in the media source
|
|
pub index: i32,
|
|
/// Subtitle URL
|
|
pub url: String,
|
|
/// Language code (e.g., "eng", "spa")
|
|
pub language: Option<String>,
|
|
/// Display title
|
|
pub label: Option<String>,
|
|
/// MIME type (e.g., "text/vtt", "application/x-subrip").
|
|
/// Snake_case on purpose — see the note on the struct.
|
|
pub mime_type: String,
|
|
}
|
|
|
|
/// Represents a media item that can be played
|
|
///
|
|
/// TRACES: UR-003, UR-004 | DR-002
|
|
#[derive(specta::Type, Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
#[specta(rename = "PlayerMediaItem")]
|
|
pub struct MediaItem {
|
|
/// Unique identifier
|
|
pub id: String,
|
|
/// Display title
|
|
pub title: String,
|
|
/// Name (alias for title - for frontend compatibility)
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub name: Option<String>,
|
|
/// Artist name(s) for audio
|
|
pub artist: Option<String>,
|
|
/// Album name for audio
|
|
pub album: Option<String>,
|
|
/// Album name (alias - for frontend compatibility)
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub album_name: Option<String>,
|
|
/// Album ID (Jellyfin ID) for remote transfer context
|
|
#[serde(default)]
|
|
pub album_id: Option<String>,
|
|
/// Artist items with IDs for clickable links
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub artist_items: Option<Vec<crate::repository::types::ArtistItem>>,
|
|
/// Artists as array of strings (fallback when artist_items not available)
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub artists: Option<Vec<String>>,
|
|
/// Primary image tag for artwork.
|
|
///
|
|
/// Legacy Jellyfin name; being replaced by `image_id` (same value). Dual-carried
|
|
/// while the frontend migrates (docs/specs/frontend-domain-model.md).
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub primary_image_tag: Option<String>,
|
|
/// Neutral image identifier the frontend resolves to a URL — replaces
|
|
/// `primary_image_tag`.
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub image_id: Option<String>,
|
|
/// Item type (Audio, Movie, Episode, etc.)
|
|
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
|
|
pub item_type: Option<String>,
|
|
/// Playlist ID (Jellyfin ID) for remote transfer context
|
|
#[serde(default)]
|
|
pub playlist_id: Option<String>,
|
|
/// Duration in seconds
|
|
pub duration: Option<f64>,
|
|
/// URL or path to artwork image
|
|
pub artwork_url: Option<String>,
|
|
/// Type of media
|
|
pub media_type: MediaType,
|
|
/// Source of the media
|
|
pub source: MediaSource,
|
|
/// Video codec (e.g., "h264", "hevc") for video media
|
|
#[serde(default)]
|
|
pub video_codec: Option<String>,
|
|
/// Whether the video requires server-side transcoding
|
|
#[serde(default)]
|
|
pub needs_transcoding: bool,
|
|
/// How this item's stream is fetched, as the backend decided it.
|
|
///
|
|
/// Carried on the queue item so a later seek/reload does not have to guess.
|
|
/// `None` for items queued by a path that never negotiated (audio tracks,
|
|
/// direct URLs) and for anything queued before this field existed, where the
|
|
/// caller falls back to `needs_transcoding` — every transcode this app
|
|
/// requests is HLS (DR-140), so that fallback is exact rather than a guess.
|
|
///
|
|
/// TRACES: UR-003, UR-004, UR-079 | DR-225, DR-230
|
|
#[serde(default)]
|
|
pub transport: Option<crate::repository::Transport>,
|
|
|
|
/// Video width in pixels
|
|
#[serde(default)]
|
|
pub video_width: Option<u32>,
|
|
/// Video height in pixels
|
|
#[serde(default)]
|
|
pub video_height: Option<u32>,
|
|
/// Available subtitle tracks
|
|
#[serde(default)]
|
|
pub subtitles: Vec<SubtitleTrack>,
|
|
/// Series ID (for TV show episodes) - used for series audio preferences
|
|
#[serde(default)]
|
|
pub series_id: Option<String>,
|
|
/// Server ID - used for series audio preferences
|
|
#[serde(default)]
|
|
pub server_id: Option<String>,
|
|
}
|
|
|
|
#[derive(specta::Type, Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(rename_all = "lowercase")]
|
|
pub enum MediaType {
|
|
Audio,
|
|
Video,
|
|
}
|
|
|
|
/// TRACES: UR-002, UR-003, UR-004, UR-011 | DR-003
|
|
#[derive(specta::Type, Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
#[serde(tag = "type", rename_all = "lowercase")]
|
|
#[specta(rename = "PlayerMediaSource")]
|
|
pub enum MediaSource {
|
|
/// Streaming from Jellyfin server
|
|
Remote {
|
|
stream_url: String,
|
|
jellyfin_item_id: String,
|
|
},
|
|
/// Downloaded/cached locally
|
|
Local {
|
|
file_path: PathBuf,
|
|
/// Original Jellyfin ID for sync-back
|
|
jellyfin_item_id: Option<String>,
|
|
},
|
|
/// Direct URL (e.g., channel plugins)
|
|
DirectUrl { url: String },
|
|
}
|
|
|
|
impl MediaItem {
|
|
/// Get the Jellyfin item ID if available
|
|
pub fn jellyfin_id(&self) -> Option<&str> {
|
|
match &self.source {
|
|
MediaSource::Remote {
|
|
jellyfin_item_id, ..
|
|
} => Some(jellyfin_item_id),
|
|
MediaSource::Local {
|
|
jellyfin_item_id, ..
|
|
} => jellyfin_item_id.as_deref(),
|
|
MediaSource::DirectUrl { .. } => None,
|
|
}
|
|
}
|
|
|
|
/// Get the playback URL or file path
|
|
///
|
|
/// Only available on Android where ExoPlayer needs direct URL access
|
|
#[cfg(target_os = "android")]
|
|
pub fn playback_url(&self) -> String {
|
|
match &self.source {
|
|
MediaSource::Remote { stream_url, .. } => stream_url.clone(),
|
|
MediaSource::Local { file_path, .. } => file_path.to_string_lossy().to_string(),
|
|
MediaSource::DirectUrl { url } => url.clone(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use std::path::PathBuf;
|
|
|
|
#[test]
|
|
fn test_queue_context_album() {
|
|
let context = QueueContext::Album {
|
|
album_id: "album-123".to_string(),
|
|
album_name: "Test Album".to_string(),
|
|
};
|
|
|
|
assert!(matches!(context, QueueContext::Album { .. }));
|
|
}
|
|
|
|
#[test]
|
|
fn test_queue_context_playlist() {
|
|
let context = QueueContext::Playlist {
|
|
playlist_id: "playlist-456".to_string(),
|
|
playlist_name: "Test Playlist".to_string(),
|
|
};
|
|
|
|
assert!(matches!(context, QueueContext::Playlist { .. }));
|
|
}
|
|
|
|
#[test]
|
|
fn test_queue_context_custom() {
|
|
let context = QueueContext::Custom;
|
|
assert!(matches!(context, QueueContext::Custom));
|
|
}
|
|
|
|
#[test]
|
|
fn test_queue_context_serialization() {
|
|
let context = QueueContext::Album {
|
|
album_id: "alb-001".to_string(),
|
|
album_name: "Album 001".to_string(),
|
|
};
|
|
|
|
let json = serde_json::to_string(&context);
|
|
assert!(json.is_ok());
|
|
let serialized = json.unwrap();
|
|
assert!(serialized.contains("album"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_queue_context_default() {
|
|
let context = QueueContext::default();
|
|
assert!(matches!(context, QueueContext::Custom));
|
|
}
|
|
|
|
#[test]
|
|
fn test_queue_context_clone() {
|
|
let context = QueueContext::Album {
|
|
album_id: "clone-alb".to_string(),
|
|
album_name: "Clone Album".to_string(),
|
|
};
|
|
|
|
let cloned = context.clone();
|
|
assert_eq!(context, cloned);
|
|
}
|
|
|
|
#[test]
|
|
fn test_subtitle_track_creation() {
|
|
let track = SubtitleTrack {
|
|
index: 0,
|
|
url: "https://example.com/subs.vtt".to_string(),
|
|
language: Some("eng".to_string()),
|
|
label: Some("English".to_string()),
|
|
mime_type: "text/vtt".to_string(),
|
|
};
|
|
|
|
assert_eq!(track.index, 0);
|
|
assert_eq!(track.language, Some("eng".to_string()));
|
|
}
|
|
|
|
#[test]
|
|
fn test_subtitle_track_without_language() {
|
|
let track = SubtitleTrack {
|
|
index: 1,
|
|
url: "https://example.com/subs.srt".to_string(),
|
|
language: None,
|
|
label: Some("Subtitles".to_string()),
|
|
mime_type: "application/x-subrip".to_string(),
|
|
};
|
|
|
|
assert!(track.language.is_none());
|
|
assert!(track.label.is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn test_subtitle_track_serialization() {
|
|
let track = SubtitleTrack {
|
|
index: 0,
|
|
url: "url.vtt".to_string(),
|
|
language: Some("eng".to_string()),
|
|
label: None,
|
|
mime_type: "text/vtt".to_string(),
|
|
};
|
|
|
|
let json = serde_json::to_string(&track);
|
|
assert!(json.is_ok());
|
|
let serialized = json.unwrap();
|
|
assert!(serialized.contains("0"));
|
|
assert!(serialized.contains("eng"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_media_type_audio() {
|
|
let media_type = MediaType::Audio;
|
|
let json = serde_json::to_string(&media_type).unwrap();
|
|
assert!(json.contains("audio"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_media_type_video() {
|
|
let media_type = MediaType::Video;
|
|
let json = serde_json::to_string(&media_type).unwrap();
|
|
assert!(json.contains("video"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_media_source_remote() {
|
|
let source = MediaSource::Remote {
|
|
stream_url: "https://server.com/video.mp4".to_string(),
|
|
jellyfin_item_id: "item-123".to_string(),
|
|
};
|
|
|
|
assert!(matches!(source, MediaSource::Remote { .. }));
|
|
}
|
|
|
|
#[test]
|
|
fn test_media_source_local() {
|
|
let source = MediaSource::Local {
|
|
file_path: PathBuf::from("/path/to/video.mp4"),
|
|
jellyfin_item_id: Some("item-456".to_string()),
|
|
};
|
|
|
|
assert!(matches!(source, MediaSource::Local { .. }));
|
|
}
|
|
|
|
#[test]
|
|
fn test_media_source_local_without_jellyfin_id() {
|
|
let source = MediaSource::Local {
|
|
file_path: PathBuf::from("/downloads/audio.mp3"),
|
|
jellyfin_item_id: None,
|
|
};
|
|
|
|
assert!(matches!(source, MediaSource::Local { .. }));
|
|
}
|
|
|
|
#[test]
|
|
fn test_media_source_direct_url() {
|
|
let source = MediaSource::DirectUrl {
|
|
url: "https://external.com/stream".to_string(),
|
|
};
|
|
|
|
assert!(matches!(source, MediaSource::DirectUrl { .. }));
|
|
}
|
|
|
|
#[test]
|
|
fn test_media_source_serialization() {
|
|
let source = MediaSource::DirectUrl {
|
|
url: "https://example.com/stream".to_string(),
|
|
};
|
|
|
|
let json = serde_json::to_string(&source);
|
|
assert!(json.is_ok());
|
|
let serialized = json.unwrap();
|
|
assert!(serialized.contains("directurl"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_media_item_creation_minimal() {
|
|
let item = MediaItem {
|
|
// Audio and direct-URL items never negotiate a transport.
|
|
transport: None,
|
|
id: "item-1".to_string(),
|
|
title: "Test Item".to_string(),
|
|
name: None,
|
|
artist: None,
|
|
album: None,
|
|
album_name: None,
|
|
album_id: None,
|
|
artist_items: None,
|
|
artists: None,
|
|
primary_image_tag: None,
|
|
image_id: None,
|
|
item_type: None,
|
|
playlist_id: None,
|
|
duration: None,
|
|
artwork_url: None,
|
|
media_type: MediaType::Video,
|
|
source: MediaSource::DirectUrl {
|
|
url: "https://example.com/video".to_string(),
|
|
},
|
|
video_codec: None,
|
|
needs_transcoding: false,
|
|
video_width: None,
|
|
video_height: None,
|
|
subtitles: vec![],
|
|
series_id: None,
|
|
server_id: None,
|
|
};
|
|
|
|
assert_eq!(item.id, "item-1");
|
|
assert_eq!(item.title, "Test Item");
|
|
assert!(!item.needs_transcoding);
|
|
}
|
|
|
|
#[test]
|
|
fn test_media_item_jellyfin_id() {
|
|
let item = MediaItem {
|
|
// Audio and direct-URL items never negotiate a transport.
|
|
transport: None,
|
|
id: "item-2".to_string(),
|
|
title: "Test".to_string(),
|
|
name: None,
|
|
artist: None,
|
|
album: None,
|
|
album_name: None,
|
|
album_id: None,
|
|
artist_items: None,
|
|
artists: None,
|
|
primary_image_tag: None,
|
|
image_id: None,
|
|
item_type: None,
|
|
playlist_id: None,
|
|
duration: None,
|
|
artwork_url: None,
|
|
media_type: MediaType::Audio,
|
|
source: MediaSource::Remote {
|
|
stream_url: "https://server/stream".to_string(),
|
|
jellyfin_item_id: "jf-id-123".to_string(),
|
|
},
|
|
video_codec: None,
|
|
needs_transcoding: false,
|
|
video_width: None,
|
|
video_height: None,
|
|
subtitles: vec![],
|
|
series_id: None,
|
|
server_id: None,
|
|
};
|
|
|
|
assert_eq!(item.jellyfin_id(), Some("jf-id-123"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_media_item_jellyfin_id_local() {
|
|
let item = MediaItem {
|
|
// Audio and direct-URL items never negotiate a transport.
|
|
transport: None,
|
|
id: "item-3".to_string(),
|
|
title: "Local".to_string(),
|
|
name: None,
|
|
artist: None,
|
|
album: None,
|
|
album_name: None,
|
|
album_id: None,
|
|
artist_items: None,
|
|
artists: None,
|
|
primary_image_tag: None,
|
|
image_id: None,
|
|
item_type: None,
|
|
playlist_id: None,
|
|
duration: None,
|
|
artwork_url: None,
|
|
media_type: MediaType::Video,
|
|
source: MediaSource::Local {
|
|
file_path: PathBuf::from("/local/video.mp4"),
|
|
jellyfin_item_id: Some("jf-local".to_string()),
|
|
},
|
|
video_codec: None,
|
|
needs_transcoding: false,
|
|
video_width: None,
|
|
video_height: None,
|
|
subtitles: vec![],
|
|
series_id: None,
|
|
server_id: None,
|
|
};
|
|
|
|
assert_eq!(item.jellyfin_id(), Some("jf-local"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_media_item_jellyfin_id_direct_url() {
|
|
let item = MediaItem {
|
|
// Audio and direct-URL items never negotiate a transport.
|
|
transport: None,
|
|
id: "item-4".to_string(),
|
|
title: "Direct".to_string(),
|
|
name: None,
|
|
artist: None,
|
|
album: None,
|
|
album_name: None,
|
|
album_id: None,
|
|
artist_items: None,
|
|
artists: None,
|
|
primary_image_tag: None,
|
|
image_id: None,
|
|
item_type: None,
|
|
playlist_id: None,
|
|
duration: None,
|
|
artwork_url: None,
|
|
media_type: MediaType::Video,
|
|
source: MediaSource::DirectUrl {
|
|
url: "https://external.com/media".to_string(),
|
|
},
|
|
video_codec: None,
|
|
needs_transcoding: false,
|
|
video_width: None,
|
|
video_height: None,
|
|
subtitles: vec![],
|
|
series_id: None,
|
|
server_id: None,
|
|
};
|
|
|
|
assert_eq!(item.jellyfin_id(), None);
|
|
}
|
|
|
|
#[test]
|
|
fn test_media_item_with_subtitles() {
|
|
let sub = SubtitleTrack {
|
|
index: 0,
|
|
url: "subs.vtt".to_string(),
|
|
language: Some("eng".to_string()),
|
|
label: Some("English".to_string()),
|
|
mime_type: "text/vtt".to_string(),
|
|
};
|
|
|
|
let item = MediaItem {
|
|
// Audio and direct-URL items never negotiate a transport.
|
|
transport: None,
|
|
id: "item-subs".to_string(),
|
|
title: "With Subs".to_string(),
|
|
name: None,
|
|
artist: None,
|
|
album: None,
|
|
album_name: None,
|
|
album_id: None,
|
|
artist_items: None,
|
|
artists: None,
|
|
primary_image_tag: None,
|
|
image_id: None,
|
|
item_type: None,
|
|
playlist_id: None,
|
|
duration: None,
|
|
artwork_url: None,
|
|
media_type: MediaType::Video,
|
|
source: MediaSource::DirectUrl {
|
|
url: "video.mp4".to_string(),
|
|
},
|
|
video_codec: None,
|
|
needs_transcoding: false,
|
|
video_width: None,
|
|
video_height: None,
|
|
subtitles: vec![sub],
|
|
series_id: None,
|
|
server_id: None,
|
|
};
|
|
|
|
assert_eq!(item.subtitles.len(), 1);
|
|
assert_eq!(item.subtitles[0].language, Some("eng".to_string()));
|
|
}
|
|
|
|
#[test]
|
|
fn test_media_item_serialization() {
|
|
let item = MediaItem {
|
|
// Audio and direct-URL items never negotiate a transport.
|
|
transport: None,
|
|
id: "serial-item".to_string(),
|
|
title: "Serial Test".to_string(),
|
|
name: Some("Name".to_string()),
|
|
artist: None,
|
|
album: None,
|
|
album_name: None,
|
|
album_id: None,
|
|
artist_items: None,
|
|
artists: None,
|
|
primary_image_tag: None,
|
|
image_id: None,
|
|
item_type: Some("Movie".to_string()),
|
|
playlist_id: None,
|
|
duration: Some(120.0),
|
|
artwork_url: None,
|
|
media_type: MediaType::Video,
|
|
source: MediaSource::DirectUrl {
|
|
url: "https://example.com/movie.mp4".to_string(),
|
|
},
|
|
video_codec: Some("h264".to_string()),
|
|
needs_transcoding: false,
|
|
video_width: Some(1920),
|
|
video_height: Some(1080),
|
|
subtitles: vec![],
|
|
series_id: None,
|
|
server_id: None,
|
|
};
|
|
|
|
let json = serde_json::to_string(&item);
|
|
assert!(json.is_ok());
|
|
let serialized = json.unwrap();
|
|
assert!(serialized.contains("serial-item"));
|
|
assert!(serialized.contains("Serial Test"));
|
|
}
|
|
}
|