Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.
fix(subtitles): resolve moviebox captions across dubs and render selection dialog
Samir Hossainsa116baa49897
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 43c8fc0..19028e8 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -18,6 +18,18 @@- Added documentation build integrity validation step in CI hygiene pipeline (`.github/workflows/ci.yml`).### Fixed+- **Accurate Playback & Download Preparation Notifications**:+ - Replaced misleading "Fetching subtitles" toast notifications during stream and episode download preparation with accurate stream preparation notices (`Preparing <filename>...` and `Resolving episode stream...`), eliminating false subtitle retrieval messages when streams rely on embedded subtitles or contain no external captions.+ - Clarified external subtitle download failure status to `External subtitle unavailable; playing stream directly.` to prevent ambiguity when video containers carry built-in subtitles.+ - Standardized download mirror error notice to `No downloadable mirrors were found for this release.` and normalized notification title casing.+- **MovieBox Subtitle Resolution & Multi-Language Track Extraction**:+ - Resolved full multi-language subtitle availability (English, Bengali, Arabic, Filipino, Hindi, Indonesian, Urdu) on MovieBox by linking genuine upload `resourceId` identifiers to releases instead of internal CDN transcoding stream IDs, and aggregating captions across audio dub siblings in `MovieBoxService::get_ext_captions`.+ - Filtered out 34-byte dummy placeholder caption files returned by transcoding endpoints and deduplicated subtitle tracks by language and download URL.+ - Added automatic fallback to subject resources in `MovieBoxService::get_ext_captions` when a stream ID does not directly attach captions.+ - Added `in_id` language code mapping to `sanitize_language_label` for localized Indonesian subtitle display.+ - Registered `draw_subtitle_picker` in `App::draw`, restoring the visual "Subtitles" modal picker overlay during stream playback and download preparation when external captions exist.+ - Tightened modal picker vertical height calculation in `picker_layout`, eliminating blank gap lines between the last list item and the bottom divider for short lists.+ - Replaced synthetic non-numeric resource ID generation in `get_selected_resource_id` with direct `Release.resource_id` resolution, preventing HTTP 400 parameter parsing errors against the `/wefeed-mobile-bff/subject-api/get-ext-captions` endpoint.- **Termux Android Player Exit Code 126 & Intent Bridge Resolution**:- Eliminated `Player Error: Crash code: 126 (/system/bin/am[11]: /data/data/com.termux/files/usr/bin/cmd: Permission denied)` crash in Termux on Android 10+ by prioritizing native Termux openers (`termux-open`, `termux-open-url`, `termux-am`) and strictly avoiding unprivileged `/system/bin/am` shell script calls.- Preserved `LD_PRELOAD` for Termux applet compatibility while prepending system paths (`/system/bin:/system/xbin`) for system command invocations.diff --git a/docs/providers.md b/docs/providers.mdindex b49ccc1..137cbfc 100644--- a/docs/providers.md+++ b/docs/providers.md@@ -34,7 +34,7 @@ in `providers/mod.rs` give every client a shared, strictly-typed async trait shaAll internal state (`AppState`), UI screens (`details.rs`, `home.rs`), and the action event bus transport native Rust structs directly:- `CatalogItem` / `SearchResult` for search results and discover catalogs.- `MediaDetails` (with `Vec<Season>` and `Vec<AudioTrackOption>`) for media metadata.-- `Release` (with `Vec<SourceMirror>`) for streams.+- `Release` (with `Vec<SourceMirror>` and optional `resource_id`) for streams.- `SubtitleOption` for external subtitles.Disk caching in `src/cache.rs` uses high-performance portable binary serialization via `rmp-serde` (MessagePack) with a 4-byte magic signature (`MBC1`) and versioned TTL envelope (`CacheEnvelope<T>`), eliminating all runtime JSON parsing and string allocation bottlenecks.diff --git a/src/providers/addons/adapter.rs b/src/providers/addons/adapter.rsindex 89bc2f6..3fb4736 100644--- a/src/providers/addons/adapter.rs+++ b/src/providers/addons/adapter.rs@@ -591,6 +591,7 @@ pub fn stream_item_to_release(headers,direct_file: true,}],+ resource_id: None,})}diff --git a/src/providers/bdix/circleftp/client.rs b/src/providers/bdix/circleftp/client.rsindex 03b6267..13a7294 100644--- a/src/providers/bdix/circleftp/client.rs+++ b/src/providers/bdix/circleftp/client.rs@@ -286,6 +286,7 @@ impl CircleFtpClient {headers: Vec::new(),direct_file: true,}],+ resource_id: None,});}}@@ -321,6 +322,7 @@ impl CircleFtpClient {headers: Vec::new(),direct_file: true,}],+ resource_id: None,});}}diff --git a/src/providers/bdix/dhakaflix/client.rs b/src/providers/bdix/dhakaflix/client.rsindex 2331338..28a2f36 100644--- a/src/providers/bdix/dhakaflix/client.rs+++ b/src/providers/bdix/dhakaflix/client.rs@@ -434,6 +434,7 @@ impl DhakaFlixClient {headers: vec![],direct_file: true,}],+ resource_id: None,});}}diff --git a/src/providers/fourkhdhub/client.rs b/src/providers/fourkhdhub/client.rsindex 16d2eef..25a9b1c 100644--- a/src/providers/fourkhdhub/client.rs+++ b/src/providers/fourkhdhub/client.rs@@ -328,6 +328,7 @@ mod tests {season: None,episode: None,mirrors: Vec::new(),+ resource_id: None,};assert!(client.resolve_release(&release).await.is_err());}diff --git a/src/providers/fourkhdhub/parser.rs b/src/providers/fourkhdhub/parser.rsindex ad98744..0ffbcad 100644--- a/src/providers/fourkhdhub/parser.rs+++ b/src/providers/fourkhdhub/parser.rs@@ -209,6 +209,7 @@ pub fn parse_releases(episode: parsed_episode.map(|value| value.1),filename: filename.clone(),mirrors: Vec::new(),+ resource_id: None,});for mirror in mirrors {if !releasediff --git a/src/providers/models.rs b/src/providers/models.rsindex d042290..4dfb20f 100644--- a/src/providers/models.rs+++ b/src/providers/models.rs@@ -224,6 +224,8 @@ pub struct Release {pub season: Option<usize>,pub episode: Option<usize>,pub mirrors: Vec<SourceMirror>,+ #[serde(default)]+ pub resource_id: Option<String>,}impl Release {pub fn is_multi_resolution(&self) -> bool {diff --git a/src/providers/moviebox/adapt.rs b/src/providers/moviebox/adapt.rsindex 006f878..9d7842a 100644--- a/src/providers/moviebox/adapt.rs+++ b/src/providers/moviebox/adapt.rs@@ -4,23 +4,50 @@ use crate::providers::models::{};use base64::Engine;pub fn captions_json_to_options(payload: &serde_json::Value) -> Vec<SubtitleOption> {- let Some(captions) = payload.get("extCaptions").and_then(|c| c.as_array()) else {+ let Some(captions) = payload+ .get("extCaptions")+ .or_else(|| payload.get("data").and_then(|d| d.get("extCaptions")))+ .and_then(|c| c.as_array())+ else {return Vec::new();};+ let mut seen_urls = std::collections::HashSet::new();captions.iter().filter_map(|cap| {let url = cap.get("url").and_then(|u| u.as_str())?;- if url.is_empty() {+ if url.is_empty() || url.contains("aa348f2541d13ffe") {return None;}- let name = cap+ let size = cap+ .get("size")+ .and_then(|s| {+ if let Some(n) = s.as_u64() {+ Some(n)+ } else if let Some(n) = s.as_i64() {+ Some(n as u64)+ } else {+ s.as_str().and_then(|str_val| str_val.parse::<u64>().ok())+ }+ })+ .unwrap_or(0);+ if size > 0 && size <= 50 {+ return None;+ }+ let raw_name = cap.get("lanName").and_then(|n| n.as_str())- .unwrap_or("Unknown")- .to_string();+ .filter(|s| !s.trim().is_empty())+ .or_else(|| cap.get("lan").and_then(|l| l.as_str()))+ .unwrap_or("Unknown");+ if raw_name.eq_ignore_ascii_case("in") && (size == 0 || size <= 100) {+ return None;+ }+ if !seen_urls.insert(url.to_string()) {+ return None;+ }Some(SubtitleOption {- name,+ name: raw_name.to_string(),url: url.to_string(),})})@@ -477,6 +504,18 @@ pub fn moviebox_resource_item_to_release(item: &serde_json::Value) -> Release {v.as_str().and_then(|s| s.parse().ok())}});+ let resource_id = item+ .get("resourceId")+ .or_else(|| item.get("id"))+ .and_then(|v| {+ if let Some(num) = v.as_i64() {+ Some(num.to_string())+ } else if let Some(num) = v.as_u64() {+ Some(num.to_string())+ } else {+ v.as_str().map(|s| s.to_string())+ }+ });let mut mirrors = Vec::new();let resource_link = item@@ -511,6 +550,7 @@ pub fn moviebox_resource_item_to_release(item: &serde_json::Value) -> Release {season,episode,mirrors,+ resource_id,}}@@ -593,6 +633,15 @@ pub fn moviebox_play_info_json_to_releases(let mut releases = Vec::new();for stream in streams {+ let stream_id = stream.get("id").and_then(|v| {+ if let Some(n) = v.as_i64() {+ Some(n.to_string())+ } else if let Some(n) = v.as_u64() {+ Some(n.to_string())+ } else {+ v.as_str().map(|s| s.to_string())+ }+ });let format_type = stream.get("format").and_then(|f| f.as_str())@@ -702,6 +751,7 @@ pub fn moviebox_play_info_json_to_releases(season: if season > 0 { Some(season) } else { None },episode: if episode > 0 { Some(episode) } else { None },mirrors: vec![mirror],+ resource_id: stream_id,});}@@ -1097,4 +1147,132 @@ mod tests {Some("https://cdn.example.com/legitimate_movie.mp4"));}++ #[test]+ fn test_captions_json_to_options_wrapper_and_language_fallback() {+ let wrapped_payload = json!({+ "code": 0,+ "data": {+ "extCaptions": [+ {+ "id": "1",+ "lan": "en",+ "lanName": "English",+ "size": "1000",+ "url": "https://example.com/en.srt"+ },+ {+ "id": "2",+ "lan": "es",+ "lanName": "",+ "size": "1200",+ "url": "https://example.com/es.srt"+ },+ {+ "id": "3",+ "lan": "",+ "lanName": "",+ "url": ""+ },+ {+ "id": "4",+ "lan": "en",+ "lanName": "IN",+ "size": "34",+ "url": "https://pacdn.aoneroom.com/other/2024/09/18/aa348f2541d13ffe1a8ea6f9e14f3ed5.srt"+ }+ ]+ }+ });++ let options = captions_json_to_options(&wrapped_payload);+ assert_eq!(options.len(), 2);+ assert_eq!(options[0].name, "English");+ assert_eq!(options[0].url, "https://example.com/en.srt");+ assert_eq!(options[1].name, "es");+ assert_eq!(options[1].url, "https://example.com/es.srt");++ let unwrapped_payload = json!({+ "extCaptions": [+ {+ "id": "10",+ "lan": "fr",+ "lanName": "French",+ "size": "500",+ "url": "https://example.com/fr.srt"+ },+ {+ "id": "11",+ "lan": "fr",+ "lanName": "French Duplicate",+ "size": "500",+ "url": "https://example.com/fr.srt"+ }+ ]+ });+ let unwrapped_options = captions_json_to_options(&unwrapped_payload);+ assert_eq!(unwrapped_options.len(), 1);+ assert_eq!(unwrapped_options[0].name, "French");+ }++ #[test]+ fn test_moviebox_play_info_preserves_numeric_and_string_resource_id() {+ let payload = json!({+ "code": 0,+ "data": {+ "title": "Movie Title",+ "streams": [+ {+ "id": 167282974499786072_i64,+ "format": "MP4",+ "codecName": "hevc",+ "resolutions": "1080",+ "url": "https://cdn.example.com/stream1.mp4",+ "signCookie": ""+ },+ {+ "id": "9026715103487476952",+ "format": "MP4",+ "codecName": "h264",+ "resolutions": "720",+ "url": "https://cdn.example.com/stream2.mp4",+ "signCookie": ""+ }+ ]+ }+ });++ let releases = moviebox_play_info_json_to_releases(&payload, 0, 0, "TestAgent/1.0");+ assert_eq!(releases.len(), 2);+ assert_eq!(+ releases[0].resource_id.as_deref(),+ Some("167282974499786072")+ );+ assert_eq!(+ releases[1].resource_id.as_deref(),+ Some("9026715103487476952")+ );+ }++ #[test]+ fn test_moviebox_resource_item_preserves_resource_id() {+ let item_numeric = json!({+ "resourceId": 6065869889208832296_i64,+ "title": "Test Release",+ "url": "https://example.com/file.mkv"+ });+ let release_numeric = moviebox_resource_item_to_release(&item_numeric);+ assert_eq!(+ release_numeric.resource_id.as_deref(),+ Some("6065869889208832296")+ );++ let item_str = json!({+ "id": "1234567890",+ "title": "Test Release 2",+ "url": "https://example.com/file2.mkv"+ });+ let release_str = moviebox_resource_item_to_release(&item_str);+ assert_eq!(release_str.resource_id.as_deref(), Some("1234567890"));+ }}diff --git a/src/providers/moviebox/mod.rs b/src/providers/moviebox/mod.rsindex 785edd5..313d1f1 100644--- a/src/providers/moviebox/mod.rs+++ b/src/providers/moviebox/mod.rs@@ -61,13 +61,41 @@ impl crate::providers::ReleaseProvider for client::MovieBoxClient {season: usize,episode: usize,) -> Result<Vec<crate::providers::models::Release>, ProviderError> {- let json = self- .get_play_info(id, season, episode)- .await- .map_err(ProviderError::from)?;- let releases =+ let (play_info_res, resources_res) = tokio::join!(+ self.get_play_info(id, season, episode),+ self.get_resources(id, season, episode, 1, None, 5)+ );++ let upload_resource_id = resources_res.ok().and_then(|val| {+ val.get("list")+ .or_else(|| val.get("data").and_then(|d| d.get("list")))+ .and_then(|l| l.as_array())+ .and_then(|arr| arr.first())+ .and_then(|item| {+ item.get("resourceId")+ .or_else(|| item.get("id"))+ .and_then(|v| {+ if let Some(n) = v.as_i64() {+ Some(n.to_string())+ } else if let Some(n) = v.as_u64() {+ Some(n.to_string())+ } else {+ v.as_str().map(|s| s.to_string())+ }+ })+ })+ });++ let json = play_info_res.map_err(ProviderError::from)?;+ let mut releases =adapt::moviebox_play_info_json_to_releases(&json, season, episode, self.user_agent());+if !releases.is_empty() {+ if let Some(upload_id) = upload_resource_id {+ for rel in &mut releases {+ rel.resource_id = Some(upload_id.clone());+ }+ }return Ok(releases);}diff --git a/src/service.rs b/src/service.rsindex 5d4861b..64fbf78 100644--- a/src/service.rs+++ b/src/service.rs@@ -194,15 +194,84 @@ impl MovieBoxService {&self,subject_id: &str,resource_id: &str,+ sibling_ids: &[String],) -> Result<Vec<crate::providers::models::SubtitleOption>, String> {- let payload = self- .client- .get_ext_captions(subject_id, resource_id)- .await- .map_err(|e| e.to_string())?;- Ok(crate::providers::moviebox::adapt::captions_json_to_options(- &payload,- ))+ let mut all_captions = Vec::new();+ let mut seen_urls = std::collections::HashSet::new();++ let mut append_captions = |opts: Vec<crate::providers::models::SubtitleOption>| {+ for opt in opts {+ if seen_urls.insert(opt.url.clone()) {+ all_captions.push(opt);+ }+ }+ };++ if let Ok(payload) = self.client.get_ext_captions(subject_id, resource_id).await {+ append_captions(crate::providers::moviebox::adapt::captions_json_to_options(+ &payload,+ ));+ }++ let mut subjects_to_check = vec![subject_id.to_string()];+ for sib in sibling_ids {+ if !sib.is_empty() && !subjects_to_check.contains(sib) && subjects_to_check.len() < 5 {+ subjects_to_check.push(sib.clone());+ }+ }++ for sid in &subjects_to_check {+ if let Ok((items, _)) = self.client.fetch_resource_page(sid, 0, 1).await {+ for item in items {+ let item_rid =+ item.get("resourceId")+ .or_else(|| item.get("id"))+ .and_then(|v| {+ if let Some(n) = v.as_i64() {+ Some(n.to_string())+ } else if let Some(n) = v.as_u64() {+ Some(n.to_string())+ } else {+ v.as_str().map(|s| s.to_string())+ }+ });+ if let Some(rid) = item_rid {+ if sid != subject_id || rid != resource_id {+ if let Ok(res_payload) = self.client.get_ext_captions(sid, &rid).await {+ append_captions(+ crate::providers::moviebox::adapt::captions_json_to_options(+ &res_payload,+ ),+ );+ }+ }+ }+ }+ }+ }++ let mut deduplicated: Vec<crate::providers::models::SubtitleOption> = Vec::new();+ let mut seen_languages = std::collections::HashSet::new();+ for sub in all_captions {+ let sanitized_lang = crate::tui::text::sanitize_language_label(&sub.name);+ if seen_languages.insert(sanitized_lang) {+ deduplicated.push(sub);+ }+ }++ deduplicated.sort_by(|a, b| {+ let clean_a = crate::tui::text::sanitize_language_label(&a.name);+ let clean_b = crate::tui::text::sanitize_language_label(&b.name);+ if clean_a.eq_ignore_ascii_case("english") {+ std::cmp::Ordering::Less+ } else if clean_b.eq_ignore_ascii_case("english") {+ std::cmp::Ordering::Greater+ } else {+ clean_a.cmp(&clean_b)+ }+ });++ Ok(deduplicated)}pub async fn fetch_poster_bytes(&self, url: &str) -> Option<Vec<u8>> {diff --git a/src/tui/app/download.rs b/src/tui/app/download.rsindex a10e8bd..703a519 100644--- a/src/tui/app/download.rs+++ b/src/tui/app/download.rs@@ -298,13 +298,13 @@ impl App {self.state.notify(NotificationKind::Error,"Download unavailable",- "No playable mirrors were found for this release.",+ "No downloadable mirrors were found for this release.",);return None;};self.state.notify(NotificationKind::Info,- "Preparing Download",+ "Preparing download",format!("Resolving {} from {}...",first_mirror.label,@@ -401,12 +401,28 @@ impl App {self.state.notify(NotificationKind::Info,"Preparing download",- "Fetching subtitles.",+ "Resolving episode stream...",);let service = self.service.clone();let sender = self.action_sender.clone();+ let sibling_ids: Vec<String> = self+ .state+ .selected_details+ .as_ref()+ .map(|d| {+ let mut ids = vec![d.id.value.clone()];+ ids.extend(d.dubs.iter().map(|dub| dub.subject_id.clone()));+ ids.retain(|s| !s.is_empty());+ ids.sort();+ ids.dedup();+ ids+ })+ .unwrap_or_default();tokio::spawn(async move {- if let Ok(res) = service.get_ext_captions(&subject_id, &rid).await {+ if let Ok(res) = service+ .get_ext_captions(&subject_id, &rid, &sibling_ids)+ .await+ {sender.send(Action::ShowDownloadSubtitlePopup(res)).ok();} else {sender.send(Action::DownloadStream(None)).ok();@@ -733,3 +749,73 @@ fn is_media_already_downloaded(target_dir: &std::path::Path, base_name: &str) ->}false}++#[cfg(test)]+mod tests {+ use crate::providers::models::{ProviderKind, Release, SourceMirror};+ use crate::tui::action::Action;+ use crate::tui::app::App;+ use crate::tui::overlay::NotificationKind;+ use crate::tui::state::Screen;++ #[tokio::test]+ async fn test_confirm_download_episode_emits_resolving_stream_notification() {+ let mut app = App::new();+ app.state.active_screen = Screen::Details;+ app.state.selected_resources = vec![Release {+ provider: ProviderKind::MovieBox,+ filename: "Episode.mkv".to_string(),+ quality: Some("1080p".to_string()),+ codec: Some("hevc".to_string()),+ language: None,+ size_bytes: Some(1024),+ season: Some(1),+ episode: Some(1),+ mirrors: vec![SourceMirror {+ label: "Direct".to_string(),+ resolver_url: "https://example.com/stream.mp4".to_string(),+ headers: vec![],+ direct_file: true,+ }],+ resource_id: Some("98765".to_string()),+ }];+ app.state.resource_list_state.select(Some(0));++ app.handle_download(Action::ConfirmDownloadEpisode).await;++ let notif = app.state.notifications.back().expect("notification posted");+ assert_eq!(notif.kind, NotificationKind::Info);+ assert_eq!(notif.title, "Preparing download");+ assert_eq!(notif.message, "Resolving episode stream...");+ }++ #[tokio::test]+ async fn test_download_stream_missing_mirror_reports_downloadable_error() {+ let mut app = App::new();+ app.state.active_provider = ProviderKind::FourKHdHub;+ app.state.active_screen = Screen::Details;+ app.state.selected_resources = vec![Release {+ provider: ProviderKind::FourKHdHub,+ filename: "Unavailable.mkv".to_string(),+ quality: Some("1080p".to_string()),+ codec: Some("hevc".to_string()),+ language: None,+ size_bytes: Some(1024),+ season: None,+ episode: None,+ mirrors: vec![],+ resource_id: None,+ }];+ app.state.resource_list_state.select(Some(0));++ app.handle_download(Action::DownloadStream(None)).await;++ let notif = app.state.notifications.back().expect("notification posted");+ assert_eq!(notif.kind, NotificationKind::Error);+ assert_eq!(notif.title, "Download unavailable");+ assert_eq!(+ notif.message,+ "No downloadable mirrors were found for this release."+ );+ }+}diff --git a/src/tui/app/mouse.rs b/src/tui/app/mouse.rsindex 209e147..b9863d7 100644--- a/src/tui/app/mouse.rs+++ b/src/tui/app/mouse.rs@@ -1300,6 +1300,7 @@ mod tests {season: None,episode: None,mirrors: vec![],+ resource_id: None,}];app.state.resource_list_state.select(Some(0));diff --git a/src/tui/app/navigation.rs b/src/tui/app/navigation.rsindex 5c250e9..d3308d4 100644--- a/src/tui/app/navigation.rs+++ b/src/tui/app/navigation.rs@@ -327,17 +327,7 @@ impl App {}pub(super) fn get_selected_resource_id(&self) -> Option<String> {- let release = self.get_selected_release()?;- let idx = self.state.resource_list_state.selected().unwrap_or(0);- Some(format!(- "{}-{idx}",- release- .provider- .label()- .to_lowercase()- .replace(' ', "-")- .replace(['(', ')'], "")- ))+ self.get_selected_release().and_then(|r| r.resource_id)}pub(super) fn get_selected_release(&self) -> Option<Release> {diff --git a/src/tui/app/playback.rs b/src/tui/app/playback.rsindex 5f0e304..4a99b72 100644--- a/src/tui/app/playback.rs+++ b/src/tui/app/playback.rs@@ -342,7 +342,7 @@ impl App {crate::logging::sanitize_url(&url));let _ = sender.send(Action::SetStatus(- "Subtitles unavailable; playing without subtitles.".to_string(),+ "External subtitle unavailable; playing stream directly.".to_string(),));}}@@ -607,12 +607,25 @@ impl App {self.state.notify(NotificationKind::Info,"Preparing playback",- format!("Fetching subtitles for {}...", release.filename),+ format!("Preparing {}...", release.filename),);self.state.pending_playback_source = Some(direct_source.clone());let service = self.service.clone();let sender = self.action_sender.clone();let source_clone = direct_source.clone();+ let sibling_ids: Vec<String> = self+ .state+ .selected_details+ .as_ref()+ .map(|d| {+ let mut ids = vec![d.id.value.clone()];+ ids.extend(d.dubs.iter().map(|dub| dub.subject_id.clone()));+ ids.retain(|s| !s.is_empty());+ ids.sort();+ ids.dedup();+ ids+ })+ .unwrap_or_default();tokio::spawn(async move {let cached = tokio::task::spawn_blocking({let subject_id = subject_id.clone();@@ -630,7 +643,7 @@ impl App {}let result = tokio::time::timeout(std::time::Duration::from_secs(15),- service.get_ext_captions(&subject_id, &rid),+ service.get_ext_captions(&subject_id, &rid, &sibling_ids),).await;match result {@@ -886,6 +899,120 @@ mod tests {assert_eq!(app.state.subtitle_list.len(), 3);}+ #[tokio::test]+ async fn test_get_selected_resource_id_resolution() {+ let mut app = crate::tui::app::App::new();+ assert_eq!(app.get_selected_resource_id(), None);++ app.state.selected_resources = vec![+ crate::providers::models::Release {+ provider: crate::providers::models::ProviderKind::MovieBox,+ filename: "Movie.1080p.mkv".to_string(),+ quality: Some("1080p".to_string()),+ codec: Some("hevc".to_string()),+ language: None,+ size_bytes: Some(1024),+ season: None,+ episode: None,+ mirrors: vec![],+ resource_id: Some("167282974499786072".to_string()),+ },+ crate::providers::models::Release {+ provider: crate::providers::models::ProviderKind::MovieBox,+ filename: "Movie.720p.mkv".to_string(),+ quality: Some("720p".to_string()),+ codec: Some("h264".to_string()),+ language: None,+ size_bytes: Some(512),+ season: None,+ episode: None,+ mirrors: vec![],+ resource_id: None,+ },+ ];++ app.state.resource_list_state.select(Some(0));+ assert_eq!(+ app.get_selected_resource_id().as_deref(),+ Some("167282974499786072")+ );++ app.state.resource_list_state.select(Some(1));+ assert_eq!(app.get_selected_resource_id(), None);+ }++ #[tokio::test]+ async fn test_play_stream_notifies_preparing_playback_accurately() {+ let mut app = crate::tui::app::App::new();+ app.state.active_provider = crate::providers::models::ProviderKind::MovieBox;+ app.state.active_screen = crate::tui::state::Screen::Details;+ app.state.selected_resources = vec![crate::providers::models::Release {+ provider: crate::providers::models::ProviderKind::MovieBox,+ filename: "Movie.1080p.mkv".to_string(),+ quality: Some("1080p".to_string()),+ codec: Some("hevc".to_string()),+ language: None,+ size_bytes: Some(1024),+ season: None,+ episode: None,+ mirrors: vec![crate::providers::models::SourceMirror {+ label: "Direct".to_string(),+ resolver_url: "https://example.com/video.mp4".to_string(),+ headers: vec![],+ direct_file: true,+ }],+ resource_id: Some("12345".to_string()),+ }];+ app.state.resource_list_state.select(Some(0));++ app.handle_playback(crate::tui::action::Action::PlayStream)+ .await;++ let notif = app.state.notifications.back().expect("notification posted");+ assert_eq!(notif.title, "Preparing playback");+ assert_eq!(notif.message, "Preparing Movie.1080p.mkv...");+ }++ #[test]+ fn test_subtitle_popup_renders_in_app_draw() {+ let backend = ratatui::backend::TestBackend::new(80, 24);+ let mut terminal = ratatui::Terminal::new(backend).unwrap();+ let mut app = crate::tui::app::App::new();++ app.state.subtitle_popup = true;+ app.state.subtitle_list = vec![+ ("None".to_string(), String::new()),+ (+ "English".to_string(),+ "https://example.com/en.srt".to_string(),+ ),+ ];+ app.state.subtitle_list_state.select(Some(0));++ terminal.draw(|frame| app.draw(frame)).unwrap();++ let buffer = terminal.backend().buffer();+ let content = buffer+ .content()+ .iter()+ .map(|c| c.symbol())+ .collect::<String>();++ assert!(content.contains("Subtitles"));+ assert!(content.contains("No subtitles"));+ assert!(content.contains("English"));+ assert!(content.contains("Use"));++ let items = vec!["No subtitles".to_string(), "English".to_string()];+ let popup_layout = crate::tui::overlay::picker_layout(+ ratatui::layout::Rect::new(0, 0, 80, 24),+ &items,+ "Use",+ 32,+ );+ assert_eq!(popup_layout.height, 6);+ }+#[tokio::test]async fn test_playback_resolving_lock_resets_on_incompatible_player() {let mut app = crate::tui::app::App::new();diff --git a/src/tui/app/requests.rs b/src/tui/app/requests.rsindex ad1c806..b2af95e 100644--- a/src/tui/app/requests.rs+++ b/src/tui/app/requests.rs@@ -1828,9 +1828,25 @@ impl App {let service = self.service.clone();let sender = self.action_sender.clone();let pref = self.state.season_subtitle_preference.clone();+ let sibling_ids: Vec<String> = self+ .state+ .selected_details+ .as_ref()+ .map(|d| {+ let mut ids = vec![d.id.value.clone()];+ ids.extend(d.dubs.iter().map(|dub| dub.subject_id.clone()));+ ids.retain(|s| !s.is_empty());+ ids.sort();+ ids.dedup();+ ids+ })+ .unwrap_or_default();tokio::spawn(async move {- if let Ok(res) = service.get_ext_captions(&subject_id, &rid).await {+ if let Ok(res) = service+ .get_ext_captions(&subject_id, &rid, &sibling_ids)+ .await+ {if pref.is_none() {sender.send(Action::ShowDownloadSubtitlePopup(res)).ok();} else if let Some(pref_lang) = pref.flatten() {diff --git a/src/tui/app/run.rs b/src/tui/app/run.rsindex f99d35c..55e2b9f 100644--- a/src/tui/app/run.rs+++ b/src/tui/app/run.rs@@ -536,6 +536,7 @@ impl App {self.draw_settings_modal(frame, area);self.draw_theme_picker(frame, area);self.draw_player_picker(frame, area);+ self.draw_subtitle_picker(frame, area);self.draw_update_modal(frame, area);self.draw_updating_modal(frame, area);crate::tui::overlay::notifications(@@ -766,6 +767,40 @@ impl App {);}}+ fn draw_subtitle_picker(&mut self, frame: &mut Frame, area: Rect) {+ if self.state.subtitle_popup || self.state.is_download_subtitle_popup {+ let items = self+ .state+ .subtitle_list+ .iter()+ .map(|(name, _)| {+ if name == "None" {+ "No subtitles".to_string()+ } else {+ crate::tui::text::sanitize_language_label(name)+ }+ })+ .collect::<Vec<_>>();+ let confirm_label = if self.state.is_download_subtitle_popup {+ "Download"+ } else {+ "Use"+ };+ crate::tui::overlay::picker(+ frame,+ area,+ &items,+ &mut self.state.subtitle_list_state,+ crate::tui::overlay::PickerSpec {+ title: "Subtitles",+ confirm_label,+ minimum_width: 32,+ },+ &self.theme,+ self.state.basic_terminal,+ );+ }+ }fn draw_update_modal(&self, frame: &mut Frame, area: Rect) {if self.state.input_mode == crate::tui::state::InputMode::Editing {diff --git a/src/tui/overlay.rs b/src/tui/overlay.rsindex 27362d7..7141a02 100644--- a/src/tui/overlay.rs+++ b/src/tui/overlay.rs@@ -41,7 +41,7 @@ pub fn picker_layout(centered(area,content_width as u16,- (visible_rows as u16 + 4).max(7),+ (visible_rows as u16 + 4).max(5),minimum_width,64,)@@ -828,10 +828,14 @@ mod tests {assert!(content.contains("Popular Movies"));}#[test]- fn test_picker_layout_minimum_height_clamped_to_seven() {+ fn test_picker_layout_height_tight_fit() {let area = Rect::new(0, 0, 80, 24);- let items = vec!["Single Item".to_string()];- let layout = picker_layout(area, &items, "Open", 20);- assert!(layout.height >= 7);+ let items_single = vec!["Single Item".to_string()];+ let layout_single = picker_layout(area, &items_single, "Open", 20);+ assert_eq!(layout_single.height, 5);++ let items_two = vec!["Item 1".to_string(), "Item 2".to_string()];+ let layout_two = picker_layout(area, &items_two, "Use", 20);+ assert_eq!(layout_two.height, 6);}}diff --git a/src/tui/screens/details.rs b/src/tui/screens/details.rsindex 05a91f8..cb4c39e 100644--- a/src/tui/screens/details.rs+++ b/src/tui/screens/details.rs@@ -1930,6 +1930,7 @@ mod tests {headers: vec![],direct_file: false,}],+ resource_id: None,},Release {provider: ProviderKind::MovieBox,@@ -1946,6 +1947,7 @@ mod tests {headers: vec![],direct_file: false,}],+ resource_id: None,},Release {provider: ProviderKind::MovieBox,@@ -1962,6 +1964,7 @@ mod tests {headers: vec![],direct_file: false,}],+ resource_id: None,},],details_pane: crate::tui::state::DetailsPane::Streams,@@ -2032,6 +2035,7 @@ mod tests {season: None,episode: None,mirrors: vec![],+ resource_id: None,},Release {provider: ProviderKind::MovieBox,@@ -2043,6 +2047,7 @@ mod tests {season: None,episode: None,mirrors: vec![],+ resource_id: None,},],details_pane: crate::tui::state::DetailsPane::Streams,diff --git a/src/tui/text.rs b/src/tui/text.rsindex a75a900..933bd8c 100644--- a/src/tui/text.rs+++ b/src/tui/text.rs@@ -367,7 +367,7 @@ pub fn sanitize_language_label(name: &str) -> String {"বাংলা" | "Bengali" | "ben" | "bn" => "Bengali".to_string(),"हिन्दी" | "हिंदी" | "Hindi" | "hin" | "hi" => "Hindi".to_string(),"Filipino" | "Tagalog" | "fil" | "tl" => "Filipino".to_string(),- "Indonesian" | "ind" | "id" => "Indonesian".to_string(),+ "Indonesian" | "ind" | "id" | "in_id" => "Indonesian".to_string(),"English" | "eng" | "en" => "English".to_string(),"Español" | "Spanish" | "spa" | "es" => "Spanish".to_string(),"Français" | "French" | "fra" | "fre" | "fr" => "French".to_string(),diff --git a/tests/live_stream_verification.rs b/tests/live_stream_verification.rsindex e53cecf..515896b 100644--- a/tests/live_stream_verification.rs+++ b/tests/live_stream_verification.rs@@ -370,3 +370,50 @@ async fn test_live_fourkhdhub_game_of_thrones_resolution() {}}}++#[tokio::test]+#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]+async fn test_live_moviebox_captions_end_to_end() {+ let service = moviebox_tui::service::MovieBoxService::new();+ service.client.init().await.expect("client init successful");++ let releases = service+ .client+ .episode_streams("4179386086617137184", 0, 0)+ .await+ .expect("fetch movie streams");+ assert!(!releases.is_empty(), "releases should not be empty");++ let release = &releases[0];+ let resource_id = release+ .resource_id+ .as_deref()+ .expect("moviebox release must include resource_id");+ assert!(!resource_id.is_empty());++ let sibling_ids = vec!["3264772588333157424".to_string()];+ let captions = service+ .get_ext_captions("4179386086617137184", resource_id, &sibling_ids)+ .await+ .expect("fetch captions");+ assert!(+ captions.len() >= 5,+ "should return aggregated subtitles across dub siblings, got {}",+ captions.len()+ );+ assert!(+ captions+ .iter()+ .all(|c| !c.url.is_empty() && !c.url.contains("aa348f2541d13ffe"))+ );+ assert!(+ captions+ .iter()+ .any(|c| c.name.eq_ignore_ascii_case("English"))+ );+ assert!(+ captions+ .iter()+ .any(|c| c.name.contains("বাংলা") || c.name.eq_ignore_ascii_case("Bengali"))+ );+}diff --git a/tests/tui_acceptance.rs b/tests/tui_acceptance.rsindex 4a365e8..ed43728 100644--- a/tests/tui_acceptance.rs+++ b/tests/tui_acceptance.rs@@ -39,6 +39,38 @@ async fn test_season_download_remembers_explicit_no_subtitle_choice() {assert_eq!(app.state().season_subtitle_preference, Some(None));}+#[tokio::test]+async fn test_download_subtitle_popup_renders_in_app_draw() {+ let backend = TestBackend::new(100, 30);+ let mut terminal = Terminal::new(backend).unwrap();+ let mut app = App::new();++ app.state_mut().is_download_subtitle_popup = true;+ app.state_mut().subtitle_list = vec![+ ("None".to_string(), String::new()),+ (+ "English".to_string(),+ "https://example.com/en.srt".to_string(),+ ),+ ];+ app.state_mut().subtitle_list_state.select(Some(0));++ terminal.draw(|frame| app.draw(frame)).unwrap();++ let content = terminal+ .backend()+ .buffer()+ .content()+ .iter()+ .map(|c| c.symbol())+ .collect::<String>();++ assert!(content.contains("Subtitles"));+ assert!(content.contains("No subtitles"));+ assert!(content.contains("English"));+ assert!(content.contains("Download"));+}+#[tokio::test]async fn test_tui_startup_and_home_screen_rendering() {let backend = TestBackend::new(100, 30);