Skip to content

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.md
index 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.md
index 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 sha
All 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 !release
diff --git a/src/providers/models.rs b/src/providers/models.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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);