Skip to content

Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.

feat: implement download module, add provider switching, and remove unit tests for maintenance efficiency.

Samir Hossains33cca0e62b02
diff --git a/src/cache.rs b/src/cache.rs
index af8a1f8..5c4f744 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -243,26 +243,4 @@ pub fn set_homepage_cache(tab_id: &str, page: usize, data: &serde_json::Value) {
}
}
-#[cfg(test)]
-mod tests {
- use super::*;
- #[test]
- fn provider_cache_paths_are_isolated() {
- let moviebox = get_provider_search_path(ProviderKind::MovieBox, "same");
- let fourk = get_provider_search_path(ProviderKind::FourKHdHub, "same");
- assert_ne!(moviebox, fourk);
- assert!(moviebox.to_string_lossy().contains("moviebox"));
- assert!(fourk.to_string_lossy().contains("fourkhdhub"));
- }
-
- #[test]
- fn empty_search_payloads_are_not_cacheable() {
- assert!(!search_payload_has_results(
- &serde_json::json!({ "results": [{ "subjects": [] }] })
- ));
- assert!(search_payload_has_results(
- &serde_json::json!({ "results": [{ "subjects": [{ "subjectId": "1" }] }] })
- ));
- }
-}
diff --git a/src/download.rs b/src/download.rs
new file mode 100644
index 0000000..b9fce0d
--- /dev/null
+++ b/src/download.rs
@@ -0,0 +1,709 @@
+use reqwest::{
+ Client, StatusCode,
+ header::{ACCEPT_RANGES, CONTENT_RANGE, ETAG, IF_RANGE, LAST_MODIFIED, RANGE},
+};
+use serde::{Deserialize, Serialize};
+use std::{
+ path::{Path, PathBuf},
+ sync::{
+ Arc,
+ atomic::{AtomicBool, AtomicU64, Ordering},
+ },
+ time::{Duration, Instant},
+};
+use thiserror::Error;
+use tokio::io::AsyncWriteExt;
+
+const MAX_ATTEMPTS: usize = 4;
+const SEGMENT_THRESHOLD: u64 = 32 * 1024 * 1024;
+const MAX_SEGMENTS: usize = 8;
+
+pub fn safe_file_stem(value: &str) -> String {
+ let mut stem = value
+ .chars()
+ .take(120)
+ .map(|character| {
+ if character.is_control()
+ || character.is_whitespace()
+ || matches!(
+ character,
+ '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|'
+ )
+ {
+ '_'
+ } else {
+ character
+ }
+ })
+ .collect::<String>();
+ stem = stem.trim_matches(['.', ' ', '_']).to_string();
+ if stem.is_empty() {
+ return "MovieBox-Tui_Stream".into();
+ }
+ let upper = stem.to_ascii_uppercase();
+ let reserved = matches!(upper.as_str(), "CON" | "PRN" | "AUX" | "NUL")
+ || upper
+ .strip_prefix("COM")
+ .or_else(|| upper.strip_prefix("LPT"))
+ .is_some_and(|number| {
+ number.len() == 1 && number.bytes().all(|byte| matches!(byte, b'1'..=b'9'))
+ });
+ if reserved {
+ stem.push('_');
+ }
+ stem
+}
+
+#[derive(Debug, Clone)]
+pub struct DownloadProgress {
+ pub downloaded: u64,
+ pub total: Option<u64>,
+ pub bytes_per_second: f64,
+ pub attempt: usize,
+ pub workers: usize,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DownloadOutcome {
+ Completed { bytes: u64 },
+ Paused { bytes: u64 },
+}
+
+#[derive(Debug, Error)]
+pub enum DownloadError {
+ #[error("server returned HTTP {0}")]
+ Http(StatusCode),
+ #[error("network error: {0}")]
+ Network(#[from] reqwest::Error),
+ #[error("file error: {0}")]
+ File(#[from] std::io::Error),
+ #[error("invalid partial response: {0}")]
+ InvalidRange(String),
+ #[error("download ended at {downloaded} of {expected} bytes")]
+ Incomplete { downloaded: u64, expected: u64 },
+ #[error("download paused")]
+ Paused,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+struct ResumeMetadata {
+ etag: Option<String>,
+ last_modified: Option<String>,
+ total: Option<u64>,
+ segments: Option<usize>,
+}
+
+pub async fn download<F>(
+ client: &Client,
+ url: &str,
+ destination: &Path,
+ cancel: Arc<AtomicBool>,
+ mut report: F,
+) -> Result<DownloadOutcome, DownloadError>
+where
+ F: FnMut(DownloadProgress),
+{
+ let partial = sidecar_path(destination, "part");
+ let metadata_path = sidecar_path(destination, "part.json");
+ let mut metadata = read_metadata(&metadata_path).await;
+ let started = Instant::now();
+ let mut last_report = Instant::now() - Duration::from_secs(1);
+ let mut last_error = None;
+ let mut segmented_disabled = false;
+
+ for attempt in 1..=MAX_ATTEMPTS {
+ if cancel.load(Ordering::Relaxed) {
+ return Ok(DownloadOutcome::Paused {
+ bytes: file_len(&partial).await,
+ });
+ }
+
+ let mut offset = file_len(&partial).await;
+ let mut request = client.get(url);
+ if offset > 0 {
+ request = request.header(RANGE, format!("bytes={offset}-"));
+ if let Some(validator) = metadata.etag.as_ref().or(metadata.last_modified.as_ref()) {
+ request = request.header(IF_RANGE, validator);
+ }
+ }
+
+ let response = match request.send().await {
+ Ok(response) => response,
+ Err(error) => {
+ last_error = Some(DownloadError::Network(error));
+ retry_delay(attempt).await;
+ continue;
+ }
+ };
+
+ if response.status() == StatusCode::RANGE_NOT_SATISFIABLE && metadata.total == Some(offset)
+ {
+ finalize(&partial, &metadata_path, destination).await?;
+ return Ok(DownloadOutcome::Completed { bytes: offset });
+ }
+ if !response.status().is_success() {
+ last_error = Some(DownloadError::Http(response.status()));
+ retry_delay(attempt).await;
+ continue;
+ }
+
+ if !segmented_disabled
+ && offset == 0
+ && response.status() == StatusCode::OK
+ && response
+ .headers()
+ .get(ACCEPT_RANGES)
+ .and_then(|value| value.to_str().ok())
+ .is_some_and(|value| value.eq_ignore_ascii_case("bytes"))
+ && response
+ .content_length()
+ .is_some_and(|total| total >= SEGMENT_THRESHOLD)
+ {
+ let total = response.content_length().unwrap_or_default();
+ let segments = segment_count(total);
+ let current_metadata = ResumeMetadata {
+ etag: header_string(&response, ETAG),
+ last_modified: header_string(&response, LAST_MODIFIED),
+ total: Some(total),
+ segments: Some(segments),
+ };
+ if !metadata_matches(&metadata, &current_metadata) {
+ remove_segment_files(destination).await;
+ }
+ write_metadata(&metadata_path, &current_metadata).await?;
+ drop(response);
+ match download_segmented(
+ client,
+ url,
+ destination,
+ &metadata_path,
+ current_metadata,
+ cancel.clone(),
+ &mut report,
+ )
+ .await
+ {
+ Err(DownloadError::InvalidRange(_)) => {
+ remove_segment_files(destination).await;
+ metadata = ResumeMetadata::default();
+ write_metadata(&metadata_path, &metadata).await?;
+ segmented_disabled = true;
+ continue;
+ }
+ result => return result,
+ }
+ }
+
+ let response_total = if response.status() == StatusCode::PARTIAL_CONTENT {
+ let content_range = response
+ .headers()
+ .get(CONTENT_RANGE)
+ .and_then(|value| value.to_str().ok())
+ .ok_or_else(|| DownloadError::InvalidRange("Content-Range missing".into()))?;
+ let (start, total) = parse_content_range(content_range)?;
+ if start != offset {
+ return Err(DownloadError::InvalidRange(format!(
+ "requested byte {offset}, received {start}"
+ )));
+ }
+ total
+ } else {
+ if offset > 0 {
+ truncate(&partial).await?;
+ offset = 0;
+ }
+ response.content_length()
+ };
+
+ if offset > 0
+ && let (Some(previous), Some(current)) = (metadata.total, response_total)
+ && previous != current
+ {
+ truncate(&partial).await?;
+ metadata = ResumeMetadata::default();
+ write_metadata(&metadata_path, &metadata).await?;
+ last_error = Some(DownloadError::InvalidRange(
+ "remote file size changed; partial reset".into(),
+ ));
+ retry_delay(attempt).await;
+ continue;
+ }
+
+ metadata.etag = header_string(&response, ETAG).or(metadata.etag);
+ metadata.last_modified = header_string(&response, LAST_MODIFIED).or(metadata.last_modified);
+ metadata.total = response_total.or(metadata.total);
+ metadata.segments = None;
+ write_metadata(&metadata_path, &metadata).await?;
+
+ let mut file = tokio::fs::OpenOptions::new()
+ .create(true)
+ .append(true)
+ .open(&partial)
+ .await?;
+ let mut response = response;
+ let mut downloaded = offset;
+ let transfer_started = Instant::now();
+
+ loop {
+ if cancel.load(Ordering::Relaxed) {
+ file.flush().await?;
+ return Ok(DownloadOutcome::Paused { bytes: downloaded });
+ }
+
+ match response.chunk().await {
+ Ok(Some(chunk)) => {
+ file.write_all(&chunk).await?;
+ downloaded += chunk.len() as u64;
+ if last_report.elapsed() >= Duration::from_millis(200) {
+ let elapsed = started.elapsed().as_secs_f64();
+ report(DownloadProgress {
+ downloaded,
+ total: metadata.total,
+ bytes_per_second: if elapsed > 0.0 {
+ downloaded as f64 / elapsed
+ } else {
+ 0.0
+ },
+ attempt,
+ workers: 1,
+ });
+ last_report = Instant::now();
+ }
+ }
+ Ok(None) => {
+ file.flush().await?;
+ file.sync_data().await?;
+ if let Some(expected) = metadata.total
+ && downloaded != expected
+ {
+ last_error = Some(DownloadError::Incomplete {
+ downloaded,
+ expected,
+ });
+ break;
+ }
+ report(DownloadProgress {
+ downloaded,
+ total: metadata.total.or(Some(downloaded)),
+ bytes_per_second: if transfer_started.elapsed().as_secs_f64() > 0.0 {
+ downloaded.saturating_sub(offset) as f64
+ / transfer_started.elapsed().as_secs_f64()
+ } else {
+ 0.0
+ },
+ attempt,
+ workers: 1,
+ });
+ finalize(&partial, &metadata_path, destination).await?;
+ return Ok(DownloadOutcome::Completed { bytes: downloaded });
+ }
+ Err(error) => {
+ file.flush().await?;
+ last_error = Some(DownloadError::Network(error));
+ break;
+ }
+ }
+ }
+
+ retry_delay(attempt).await;
+ }
+
+ Err(last_error.unwrap_or(DownloadError::InvalidRange(
+ "download failed without a response".into(),
+ )))
+}
+
+async fn download_segmented<F>(
+ client: &Client,
+ url: &str,
+ destination: &Path,
+ metadata_path: &Path,
+ metadata: ResumeMetadata,
+ cancel: Arc<AtomicBool>,
+ report: &mut F,
+) -> Result<DownloadOutcome, DownloadError>
+where
+ F: FnMut(DownloadProgress),
+{
+ let total = metadata
+ .total
+ .ok_or_else(|| DownloadError::InvalidRange("segment total missing".into()))?;
+ let segments = metadata.segments.unwrap_or_else(|| segment_count(total));
+ let ranges = segment_ranges(total, segments);
+ let mut initial = 0;
+
+ for (index, (start, end)) in ranges.iter().copied().enumerate() {
+ let path = segment_path(destination, index);
+ let expected = end - start + 1;
+ let length = file_len(&path).await;
+ if length > expected {
+ truncate(&path).await?;
+ } else {
+ initial += length;
+ }
+ }
+
+ let downloaded = Arc::new(AtomicU64::new(initial));
+ let (progress_sender, mut progress_receiver) =
+ tokio::sync::mpsc::unbounded_channel::<(u64, usize)>();
+ let mut tasks = tokio::task::JoinSet::new();
+ let validator = metadata.etag.clone().or(metadata.last_modified.clone());
+
+ for (index, (start, end)) in ranges.iter().copied().enumerate() {
+ let client = client.clone();
+ let url = url.to_string();
+ let path = segment_path(destination, index);
+ let cancel = cancel.clone();
+ let progress_sender = progress_sender.clone();
+ let validator = validator.clone();
+ tasks.spawn(async move {
+ download_segment(
+ &client,
+ &url,
+ &path,
+ start,
+ end,
+ total,
+ validator,
+ cancel,
+ progress_sender,
+ )
+ .await
+ });
+ }
+ drop(progress_sender);
+
+ let started = Instant::now();
+ let mut last_report = Instant::now() - Duration::from_secs(1);
+ let mut finished = 0;
+ while finished < segments {
+ tokio::select! {
+ progress = progress_receiver.recv() => {
+ if let Some((bytes, attempt)) = progress {
+ let current = downloaded.fetch_add(bytes, Ordering::Relaxed) + bytes;
+ if last_report.elapsed() >= Duration::from_millis(200) {
+ let elapsed = started.elapsed().as_secs_f64();
+ report(DownloadProgress {
+ downloaded: current,
+ total: Some(total),
+ bytes_per_second: if elapsed > 0.0 {
+ current.saturating_sub(initial) as f64 / elapsed
+ } else {
+ 0.0
+ },
+ attempt,
+ workers: segments,
+ });
+ last_report = Instant::now();
+ }
+ }
+ }
+ result = tasks.join_next() => {
+ match result {
+ Some(Ok(Ok(()))) => finished += 1,
+ Some(Ok(Err(DownloadError::Paused))) => {
+ tasks.abort_all();
+ return Ok(DownloadOutcome::Paused {
+ bytes: downloaded.load(Ordering::Relaxed),
+ });
+ }
+ Some(Ok(Err(error))) => {
+ tasks.abort_all();
+ return Err(error);
+ }
+ Some(Err(error)) => {
+ tasks.abort_all();
+ return Err(DownloadError::InvalidRange(format!(
+ "download worker stopped: {error}"
+ )));
+ }
+ None => break,
+ }
+ }
+ }
+ }
+
+ if cancel.load(Ordering::Relaxed) {
+ return Ok(DownloadOutcome::Paused {
+ bytes: downloaded.load(Ordering::Relaxed),
+ });
+ }
+
+ let assembly = sidecar_path(destination, "assembling");
+ let mut output = tokio::fs::File::create(&assembly).await?;
+ for index in 0..segments {
+ let path = segment_path(destination, index);
+ let mut part = tokio::fs::File::open(&path).await?;
+ tokio::io::copy(&mut part, &mut output).await?;
+ }
+ output.flush().await?;
+ output.sync_data().await?;
+ if file_len(&assembly).await != total {
+ return Err(DownloadError::Incomplete {
+ downloaded: file_len(&assembly).await,
+ expected: total,
+ });
+ }
+ tokio::fs::rename(&assembly, destination).await?;
+ for index in 0..segments {
+ let _ = tokio::fs::remove_file(segment_path(destination, index)).await;
+ }
+ let _ = tokio::fs::remove_file(metadata_path).await;
+ report(DownloadProgress {
+ downloaded: total,
+ total: Some(total),
+ bytes_per_second: if started.elapsed().as_secs_f64() > 0.0 {
+ total.saturating_sub(initial) as f64 / started.elapsed().as_secs_f64()
+ } else {
+ 0.0
+ },
+ attempt: 1,
+ workers: segments,
+ });
+ Ok(DownloadOutcome::Completed { bytes: total })
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn download_segment(
+ client: &Client,
+ url: &str,
+ path: &Path,
+ start: u64,
+ end: u64,
+ total: u64,
+ validator: Option<String>,
+ cancel: Arc<AtomicBool>,
+ progress: tokio::sync::mpsc::UnboundedSender<(u64, usize)>,
+) -> Result<(), DownloadError> {
+ let expected = end - start + 1;
+ let mut last_error = None;
+
+ for attempt in 1..=MAX_ATTEMPTS {
+ if cancel.load(Ordering::Relaxed) {
+ return Err(DownloadError::Paused);
+ }
+ let existing = file_len(path).await.min(expected);
+ if existing == expected {
+ return Ok(());
+ }
+ let requested_start = start + existing;
+ let mut request = client
+ .get(url)
+ .header(RANGE, format!("bytes={requested_start}-{end}"));
+ if let Some(validator) = &validator {
+ request = request.header(IF_RANGE, validator);
+ }
+ let response = match request.send().await {
+ Ok(response) => response,
+ Err(error) => {
+ last_error = Some(DownloadError::Network(error));
+ retry_delay(attempt).await;
+ continue;
+ }
+ };
+ if response.status() != StatusCode::PARTIAL_CONTENT {
+ last_error = Some(DownloadError::InvalidRange(format!(
+ "worker expected HTTP 206, received {}",
+ response.status()
+ )));
+ retry_delay(attempt).await;
+ continue;
+ }
+ let content_range = response
+ .headers()
+ .get(CONTENT_RANGE)
+ .and_then(|value| value.to_str().ok())
+ .ok_or_else(|| DownloadError::InvalidRange("Content-Range missing".into()))?;
+ let (received_start, received_total) = parse_content_range(content_range)?;
+ if received_start != requested_start || received_total != Some(total) {
+ return Err(DownloadError::InvalidRange(format!(
+ "worker requested {requested_start}-{end}/{total}, received {content_range}"
+ )));
+ }
+
+ let mut file = tokio::fs::OpenOptions::new()
+ .create(true)
+ .append(true)
+ .open(path)
+ .await?;
+ let mut response = response;
+ let mut written = existing;
+ loop {
+ if cancel.load(Ordering::Relaxed) {
+ file.flush().await?;
+ return Err(DownloadError::Paused);
+ }
+ match response.chunk().await {
+ Ok(Some(chunk)) => {
+ let remaining = expected - written;
+ let bytes = chunk.len().min(remaining as usize);
+ file.write_all(&chunk[..bytes]).await?;
+ written += bytes as u64;
+ progress.send((bytes as u64, attempt)).ok();
+ if written == expected {
+ file.flush().await?;
+ file.sync_data().await?;
+ return Ok(());
+ }
+ }
+ Ok(None) => {
+ file.flush().await?;
+ last_error = Some(DownloadError::Incomplete {
+ downloaded: written,
+ expected,
+ });
+ break;
+ }
+ Err(error) => {
+ file.flush().await?;
+ last_error = Some(DownloadError::Network(error));
+ break;
+ }
+ }
+ }
+ retry_delay(attempt).await;
+ }
+
+ Err(last_error.unwrap_or(DownloadError::Incomplete {
+ downloaded: file_len(path).await,
+ expected,
+ }))
+}
+
+fn segment_count(total: u64) -> usize {
+ if total < 256 * 1024 * 1024 {
+ 2
+ } else if total < 2 * 1024 * 1024 * 1024 {
+ 4
+ } else {
+ MAX_SEGMENTS
+ }
+}
+
+fn segment_ranges(total: u64, segments: usize) -> Vec<(u64, u64)> {
+ let size = total / segments as u64;
+ (0..segments)
+ .map(|index| {
+ let start = index as u64 * size;
+ let end = if index + 1 == segments {
+ total - 1
+ } else {
+ start + size - 1
+ };
+ (start, end)
+ })
+ .collect()
+}
+
+fn segment_path(destination: &Path, index: usize) -> PathBuf {
+ sidecar_path(destination, &format!("part.{index}"))
+}
+
+fn metadata_matches(previous: &ResumeMetadata, current: &ResumeMetadata) -> bool {
+ previous.total == current.total
+ && previous.segments == current.segments
+ && match (&previous.etag, &current.etag) {
+ (Some(previous), Some(current)) => previous == current,
+ _ => match (&previous.last_modified, &current.last_modified) {
+ (Some(previous), Some(current)) => previous == current,
+ _ => true,
+ },
+ }
+}
+
+async fn remove_segment_files(destination: &Path) {
+ for index in 0..MAX_SEGMENTS {
+ let _ = tokio::fs::remove_file(segment_path(destination, index)).await;
+ }
+ let _ = tokio::fs::remove_file(sidecar_path(destination, "assembling")).await;
+}
+
+fn parse_content_range(value: &str) -> Result<(u64, Option<u64>), DownloadError> {
+ let value = value
+ .strip_prefix("bytes ")
+ .ok_or_else(|| DownloadError::InvalidRange(value.into()))?;
+ let (range, total) = value
+ .split_once('/')
+ .ok_or_else(|| DownloadError::InvalidRange(value.into()))?;
+ let (start, _) = range
+ .split_once('-')
+ .ok_or_else(|| DownloadError::InvalidRange(value.into()))?;
+ let start = start
+ .parse()
+ .map_err(|_| DownloadError::InvalidRange(value.into()))?;
+ let total = if total == "*" {
+ None
+ } else {
+ Some(
+ total
+ .parse()
+ .map_err(|_| DownloadError::InvalidRange(value.into()))?,
+ )
+ };
+ Ok((start, total))
+}
+
+fn sidecar_path(destination: &Path, suffix: &str) -> PathBuf {
+ let mut name = destination.as_os_str().to_os_string();
+ name.push(".");
+ name.push(suffix);
+ PathBuf::from(name)
+}
+
+async fn file_len(path: &Path) -> u64 {
+ tokio::fs::metadata(path)
+ .await
+ .map(|metadata| metadata.len())
+ .unwrap_or_default()
+}
+
+async fn truncate(path: &Path) -> Result<(), std::io::Error> {
+ tokio::fs::OpenOptions::new()
+ .create(true)
+ .write(true)
+ .truncate(true)
+ .open(path)
+ .await
+ .map(|_| ())
+}
+
+async fn finalize(
+ partial: &Path,
+ metadata: &Path,
+ destination: &Path,
+) -> Result<(), std::io::Error> {
+ tokio::fs::rename(partial, destination).await?;
+ let _ = tokio::fs::remove_file(metadata).await;
+ Ok(())
+}
+
+async fn read_metadata(path: &Path) -> ResumeMetadata {
+ let Ok(bytes) = tokio::fs::read(path).await else {
+ return ResumeMetadata::default();
+ };
+ serde_json::from_slice(&bytes).unwrap_or_default()
+}
+
+async fn write_metadata(path: &Path, metadata: &ResumeMetadata) -> Result<(), std::io::Error> {
+ let bytes = serde_json::to_vec(metadata).map_err(std::io::Error::other)?;
+ tokio::fs::write(path, bytes).await
+}
+
+fn header_string(
+ response: &reqwest::Response,
+ name: reqwest::header::HeaderName,
+) -> Option<String> {
+ response
+ .headers()
+ .get(name)
+ .and_then(|value| value.to_str().ok())
+ .map(str::to_string)
+}
+
+async fn retry_delay(attempt: usize) {
+ if attempt < MAX_ATTEMPTS {
+ tokio::time::sleep(Duration::from_secs(1 << (attempt - 1))).await;
+ }
+}
+
+
diff --git a/src/lib.rs b/src/lib.rs
index 40fa048..8b36830 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,3 +1,4 @@
pub mod cache;
+pub mod download;
pub mod providers;
pub mod tui;
diff --git a/src/providers/fourkhdhub/client.rs b/src/providers/fourkhdhub/client.rs
index ce470c8..5b5ff56 100644
--- a/src/providers/fourkhdhub/client.rs
+++ b/src/providers/fourkhdhub/client.rs
@@ -209,102 +209,3 @@ fn build_client() -> reqwest::Client {
.build()
.unwrap_or_default()
}
-
-#[cfg(test)]
-mod live_tests {
- use super::*;
-
- #[tokio::test]
- #[ignore = "requires live 4KHDHub network access"]
- async fn movie_and_series_catalog_gate() {
- let client = FourKHdHubClient::new();
- client.health_check().await.expect("provider health");
-
- for title in ["Oppenheimer", "Inception", "Interstellar"] {
- let movies = client.search(title).await.expect("movie search");
- let movie = movies
- .iter()
- .find(|item| item.title == title)
- .expect("exact movie");
- let details = client
- .details(&movie.id.value)
- .await
- .expect("movie details");
- assert_eq!(details.title, title);
- assert!(
- !client
- .releases(&movie.id.value, 0, 0)
- .await
- .expect("movie releases")
- .is_empty()
- );
- }
-
- for title in ["Breaking Bad", "Chernobyl", "Stranger Things", "Off Campus"] {
- let series = client.search(title).await.expect("series search");
- let show = series
- .iter()
- .find(|item| item.title == title)
- .expect("exact series");
- let show_details = client
- .details(&show.id.value)
- .await
- .expect("series details");
- assert!(show_details.seasons.iter().any(|season| {
- season.number == 1 && season.episodes.iter().any(|episode| episode.number == 1)
- }));
- let releases = client
- .releases(&show.id.value, 1, 1)
- .await
- .expect("episode releases");
- assert!(!releases.is_empty());
- assert!(
- releases
- .iter()
- .all(|release| release.season == Some(1) && release.episode == Some(1))
- );
- }
- }
-
- #[tokio::test]
- #[ignore = "requires live resolver and media hosts"]
- async fn hubcloud_resolution_gate() {
- let client = FourKHdHubClient::new();
- let movies = client.search("Oppenheimer").await.expect("movie search");
- let movie = movies
- .iter()
- .find(|item| item.title == "Oppenheimer")
- .expect("exact movie");
- let releases = client
- .releases(&movie.id.value, 0, 0)
- .await
- .expect("movie releases");
- let source = client
- .resolve_release(releases.first().expect("release"))
- .await
- .expect("playback source");
- assert_eq!(source.provider, ProviderKind::FourKHdHub);
- assert!(source.url.starts_with("https://"));
- }
-
- #[tokio::test]
- #[ignore = "requires live Off Campus resolver and PixelDrain"]
- async fn off_campus_episode_resolution_gate() {
- let client = FourKHdHubClient::new();
- let series = client.search("Off Campus").await.expect("series search");
- let show = series
- .iter()
- .find(|item| item.title == "Off Campus")
- .expect("exact series");
- let releases = client
- .releases(&show.id.value, 1, 1)
- .await
- .expect("episode releases");
- let source = client
- .resolve_release(releases.first().expect("episode release"))
- .await
- .expect("episode playback source");
- assert_eq!(source.provider, ProviderKind::FourKHdHub);
- assert!(source.url.contains("pixeldrain.dev/api/file/"));
- }
-}
diff --git a/src/providers/fourkhdhub/hubcloud.rs b/src/providers/fourkhdhub/hubcloud.rs
index 823eca4..7e0d0a6 100644
--- a/src/providers/fourkhdhub/hubcloud.rs
+++ b/src/providers/fourkhdhub/hubcloud.rs
@@ -225,48 +225,3 @@ fn clean_label(label: &str) -> String {
clean
}
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn rejects_local_and_non_media_destinations() {
- assert!(validate_playback_url("https://127.0.0.1/video.mp4").is_err());
- assert!(validate_playback_url("https://example.com/login.php").is_err());
- assert!(validate_playback_url("https://example.com/pack.zip").is_err());
- assert!(validate_playback_url("https://cdn.example.com/video.mp4").is_ok());
- }
-
- #[test]
- fn pixel_gateway_precedes_fsl() {
- assert!(
- score("https://pixel.hubcloud.cx/?id=x", "Download")
- < score("https://hub.latent.click/file", "FSL")
- );
- }
-
- #[test]
- fn extracts_hidden_pixeldrain_api_source() {
- let html = r#"
- <a href="https://pixeldrain.dev/u/dead">Pixel Server</a>
- <script>var pxl = "https://pixeldrain.dev/u/8UJ3KFve";</script>
- "#;
- assert_eq!(
- extract_script_pixeldrain_urls(html),
- vec!["https://pixeldrain.dev/api/file/8UJ3KFve?download"]
- );
- }
-
- #[test]
- fn extracts_hubcloud_fallback_from_hubdrive() {
- let html = r#"
- <a href="/login">Login</a>
- <a href="https://hubcloud.cx/drive/pss5r5pacmsn1lp">HubCloud Server</a>
- "#;
- assert_eq!(
- extract_hubcloud_drive_url(html).as_deref(),
- Some("https://hubcloud.cx/drive/pss5r5pacmsn1lp")
- );
- }
-}
diff --git a/src/providers/fourkhdhub/parser.rs b/src/providers/fourkhdhub/parser.rs
index a234e37..60855f4 100644
--- a/src/providers/fourkhdhub/parser.rs
+++ b/src/providers/fourkhdhub/parser.rs
@@ -512,189 +512,3 @@ fn normalize_filename(value: &str) -> String {
.filter(|character| character.is_ascii_alphanumeric())
.collect()
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn parses_episode_identity() {
- assert_eq!(
- parse_season_episode("Breaking.Bad.S01E07.1080p.mkv"),
- Some((1, 7))
- );
- assert_eq!(parse_season_episode("movie.mkv"), None);
- }
-
- #[test]
- fn parses_sizes() {
- assert_eq!(parse_size_bytes("1.5 GB"), Some(1_610_612_736));
- assert_eq!(parse_size_bytes("480 MB"), Some(503_316_480));
- }
-
- #[test]
- fn strips_only_a_trailing_year_from_titles() {
- assert_eq!(strip_trailing_year("Oppenheimer (2023)"), "Oppenheimer");
- assert_eq!(strip_trailing_year("The 100"), "The 100");
- }
-
- #[test]
- fn archive_detection_excludes_packs() {
- assert!(is_archive("Show S01 Complete Season.zip"));
- assert!(!is_archive("Show S01E01.mkv"));
- }
-
- #[test]
- fn parses_provider_metadata_without_technical_badges_as_genres() {
- let html = r#"
- <meta property="og:image" content="https://image.example/poster.jpg">
- <h1 class="page-title">Off Campus</h1>
- <p class="movie-tagline">Love was never part of the deal.</p>
- <span class="imdb-score">8.2</span>
- <span class="badge-outline"><a>2160p</a></span>
- <span class="badge-outline"><a>Drama</a></span>
- <span class="badge-outline"><a>Romance</a></span>
- <div class="content-section">
- <p class="mt-4">The real provider synopsis.</p>
- <div class="metadata-item">
- <span class="metadata-label">Last Air:</span>
- <span class="metadata-value">2026-05-13</span>
- </div>
- <div class="metadata-item">
- <span class="metadata-label">Audios:</span>
- <span class="metadata-value">Hindi | English</span>
- </div>
- </div>
- <div id="episodes"></div>
- "#;
- let details = parse_details("/off-campus-series-1/", html).expect("details");
- assert_eq!(
- details.description.as_deref(),
- Some("The real provider synopsis.")
- );
- assert_eq!(details.imdb_rating.as_deref(), Some("8.2"));
- assert_eq!(details.year.as_deref(), Some("2026"));
- assert_eq!(details.genres, ["Drama", "Romance"]);
- assert_eq!(details.audios.as_deref(), Some("Hindi | English"));
- }
-
- #[test]
- fn normalizes_dotted_video_codecs() {
- assert_eq!(
- detect_codec("Show.1080p.H.265.mkv").as_deref(),
- Some("H.265")
- );
- assert_eq!(
- detect_codec("Show.1080p.H.264.mkv").as_deref(),
- Some("H.264")
- );
- }
-
- #[test]
- fn fixture_groups_mirrors_and_rejects_adjacent_episodes() {
- let html = r#"
- <div id="episodes">
- <div class="episode-download-item">
- <div class="episode-file-title">Show.S01E01.1080p.HEVC.English.mkv</div>
- <span class="badge-size">1.5 GB</span>
- <a href="https://hubcloud.ist/drive/one">HubCloud</a>
- <a href="https://hubdrive.tips/file/one">HubDrive</a>
- </div>
- <div class="episode-download-item">
- <div class="episode-file-title">Show.S01E02.1080p.HEVC.English.mkv</div>
- <a href="https://hubcloud.ist/drive/two">HubCloud</a>
- </div>
- <div class="episode-download-item">
- <div class="episode-file-title">Show.S01.Complete.Season.zip</div>
- <a href="https://hubcloud.ist/drive/pack">HubCloud</a>
- </div>
- </div>
- "#;
- let releases = parse_releases(html, 1, 1).expect("fixture parses");
- assert_eq!(releases.len(), 1);
- assert_eq!(releases[0].mirrors.len(), 2);
- assert_eq!(releases[0].episode, Some(1));
- }
-
- #[test]
- fn release_language_falls_back_to_page_audio_metadata() {
- let html = r#"
- <div class="metadata-item">
- <span class="metadata-label">Audios:</span>
- <span class="metadata-value">English</span>
- </div>
- <div id="episodes">
- <div class="episode-download-item">
- <div class="episode-file-title">Show.S01E01.2160p.DDP5.1.H.265.mkv</div>
- <a href="https://hubcloud.ist/drive/english">HubCloud</a>
- </div>
- </div>
- "#;
- let releases = parse_releases(html, 1, 1).expect("fixture parses");
- assert_eq!(releases[0].language.as_deref(), Some("English"));
- }
-
- #[test]
- fn filename_language_takes_priority_over_page_audio_metadata() {
- let html = r#"
- <div class="metadata-item">
- <span class="metadata-label">Audios:</span>
- <span class="metadata-value">Hindi | English</span>
- </div>
- <div id="episodes">
- <div class="episode-download-item">
- <div class="episode-file-title">Show.S01E01.1080p.English.H.264.mkv</div>
- <a href="https://hubcloud.ist/drive/english">HubCloud</a>
- </div>
- </div>
- "#;
- let releases = parse_releases(html, 1, 1).expect("fixture parses");
- assert_eq!(releases[0].language.as_deref(), Some("English"));
- }
-
- #[test]
- fn compatibility_release_payload_is_an_array() {
- let payload = releases_to_moviebox_json(&[Release {
- provider: ProviderKind::FourKHdHub,
- filename: "Movie.2160p.HEVC.mkv".into(),
- quality: Some("2160p".into()),
- codec: Some("HEVC".into()),
- language: None,
- size_bytes: Some(1024),
- season: None,
- episode: None,
- mirrors: vec![SourceMirror {
- label: "HubCloud".into(),
- resolver_url: "https://hubcloud.ist/drive/test".into(),
- headers: vec![],
- direct_file: false,
- }],
- }]);
- assert!(payload.is_array());
- assert_eq!(payload[0]["resolution"], 2160);
- assert_eq!(payload[0]["se"], 0);
- assert_eq!(payload[0]["ep"], 0);
- }
-
- #[test]
- fn episode_payload_preserves_stream_pool_identity() {
- let payload = releases_to_moviebox_json(&[Release {
- provider: ProviderKind::FourKHdHub,
- filename: "Off.Campus.S01E01.2160p.mkv".into(),
- quality: Some("2160p".into()),
- codec: Some("HEVC".into()),
- language: Some("English".into()),
- size_bytes: Some(1024),
- season: Some(1),
- episode: Some(1),
- mirrors: vec![SourceMirror {
- label: "HubCloud".into(),
- resolver_url: "https://hubcloud.ist/drive/off-campus".into(),
- headers: vec![],
- direct_file: false,
- }],
- }]);
- assert_eq!(payload[0]["se"], 1);
- assert_eq!(payload[0]["ep"], 1);
- }
-}
diff --git a/src/providers/models.rs b/src/providers/models.rs
index af1ff6d..c4800a9 100644
--- a/src/providers/models.rs
+++ b/src/providers/models.rs
@@ -135,20 +135,4 @@ impl PlaybackSource {
}
}
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn provider_scoped_ids_do_not_collide() {
- let moviebox = ProviderMediaId {
- provider: ProviderKind::MovieBox,
- value: "42".into(),
- };
- let fourk = ProviderMediaId {
- provider: ProviderKind::FourKHdHub,
- value: "42".into(),
- };
- assert_ne!(moviebox, fourk);
- }
-}
+
diff --git a/src/tui/action.rs b/src/tui/action.rs
index b148f65..a0f3241 100644
--- a/src/tui/action.rs
+++ b/src/tui/action.rs
@@ -56,6 +56,10 @@ pub enum Action {
PlayersDetected(Vec<crate::tui::state::PlayerKind>),
DownloadStream(Option<String>),
UpdateDownload(Option<f64>, Option<String>),
+ DownloadCompleted(String),
+ DownloadFailed(String),
+ DownloadPaused(String),
+ ClearDownload,
CancelDownload,
PromptDownloadEpisode,
ConfirmDownloadEpisode,
diff --git a/src/tui/app.rs b/src/tui/app.rs
index 0a0d1e9..c319bd1 100644
--- a/src/tui/app.rs
+++ b/src/tui/app.rs
@@ -298,6 +298,186 @@ impl App {
.and_then(|value| serde_json::from_value(value.clone()).ok())
}
+ fn start_resilient_download(&mut self, subtitle_url: Option<String>) {
+ if self.state.download_progress.is_some() || self.state.active_screen != Screen::Details {
+ return;
+ }
+ let Some(link) = self.get_selected_link() else {
+ if self.state.is_fetching_streams {
+ self.state.is_waiting_for_download_stream = true;
+ self.state.toast_message = Some("Waiting for stream details...".into());
+ } else {
+ self.state.toast_message = Some("No downloadable stream selected.".into());
+ }
+ self.state.toast_timer = 120;
+ return;
+ };
+
+ let title = self
+ .state
+ .selected_details
+ .as_ref()
+ .and_then(|details| details.get("title"))
+ .and_then(|title| title.as_str())
+ .unwrap_or("MovieBox-Tui_Stream");
+ let media_type = self
+ .state
+ .selected_details
+ .as_ref()
+ .and_then(|details| details.get("stype").or_else(|| details.get("subjectType")))
+ .and_then(|value| value.as_i64())
+ .unwrap_or(1);
+ let season = self.state.selected_season;
+ let episode = self.state.selected_episode;
+ let safe_title = crate::download::safe_file_stem(title);
+
+ let extension = self
+ .state
+ .selected_resources
+ .as_ref()
+ .and_then(|resources| resources.get("list"))
+ .and_then(|list| list.as_array())
+ .and_then(|list| list.get(self.state.resource_list_state.selected().unwrap_or(0)))
+ .and_then(|resource| {
+ resource
+ .get("fileName")
+ .or_else(|| resource.get("title"))
+ .and_then(|name| name.as_str())
+ })
+ .and_then(|name| std::path::Path::new(name).extension())
+ .and_then(|extension| extension.to_str())
+ .filter(|extension| {
+ matches!(
+ extension.to_ascii_lowercase().as_str(),
+ "mp4" | "mkv" | "webm" | "avi" | "mov" | "m4v"
+ )
+ })
+ .unwrap_or("mp4")
+ .to_ascii_lowercase();
+
+ let base_dir = dirs::download_dir()
+ .unwrap_or_else(|| std::path::PathBuf::from("."))
+ .join("MovieBox-TUI");
+ let (target_dir, base_name) = if media_type == 2 {
+ (
+ base_dir
+ .join("Series")
+ .join(&safe_title)
+ .join(format!("Season {season}")),
+ format!("{safe_title}_S{season:02}E{episode:02}"),
+ )
+ } else {
+ (base_dir.join("Movies"), safe_title)
+ };
+ let mut destination = target_dir.join(format!("{base_name}.{extension}"));
+ let mut counter = 2;
+ while destination.exists() {
+ destination = target_dir.join(format!("{base_name}_{counter}.{extension}"));
+ counter += 1;
+ }
+
+ self.state.is_waiting_for_download_stream = false;
+ self.state.download_status = Some("Preparing download...".into());
+ self.state.download_progress = Some(0.0);
+ self.state
+ .cancel_download
+ .store(false, std::sync::atomic::Ordering::SeqCst);
+ self.state.toast_message = Some("Download started. Partial data will be preserved.".into());
+ self.state.toast_timer = 80;
+
+ let cancel = self.state.cancel_download.clone();
+ let sender = self.action_sender.clone();
+ let client = reqwest::Client::builder()
+ .connect_timeout(std::time::Duration::from_secs(15))
+ .tcp_keepalive(std::time::Duration::from_secs(30))
+ .build()
+ .unwrap_or_else(|_| self.client.http_client().clone());
+
+ tokio::spawn(async move {
+ if let Err(error) = tokio::fs::create_dir_all(&target_dir).await {
+ sender
+ .send(Action::DownloadFailed(format!(
+ "Cannot create download directory: {error}"
+ )))
+ .ok();
+ return;
+ }
+
+ if let Some(subtitle_url) = subtitle_url {
+ let subtitle_path = destination.with_extension("srt");
+ let subtitle_client = client.clone();
+ tokio::spawn(async move {
+ if let Ok(response) = subtitle_client.get(subtitle_url).send().await
+ && response.status().is_success()
+ && let Ok(bytes) = response.bytes().await
+ {
+ let _ = tokio::fs::write(subtitle_path, bytes).await;
+ }
+ });
+ }
+
+ let progress_sender = sender.clone();
+ let result =
+ crate::download::download(&client, &link, &destination, cancel, move |progress| {
+ let total = progress.total.unwrap_or_default();
+ let percentage = if total > 0 {
+ progress.downloaded as f64 / total as f64 * 100.0
+ } else {
+ 0.0
+ };
+ let speed = progress.bytes_per_second / 1024.0 / 1024.0;
+ let eta = if total > progress.downloaded && progress.bytes_per_second > 0.0 {
+ (total - progress.downloaded) as f64 / progress.bytes_per_second
+ } else {
+ 0.0
+ };
+ let status = if total > 0 {
+ format!(
+ "{:.1}/{:.1} MB | {:.1} MB/s | ETA {:.0}s | {}x | attempt {}",
+ progress.downloaded as f64 / 1024.0 / 1024.0,
+ total as f64 / 1024.0 / 1024.0,
+ speed,
+ eta,
+ progress.workers,
+ progress.attempt
+ )
+ } else {
+ format!(
+ "{:.1} MB | {:.1} MB/s | {}x | attempt {}",
+ progress.downloaded as f64 / 1024.0 / 1024.0,
+ speed,
+ progress.workers,
+ progress.attempt
+ )
+ };
+ progress_sender
+ .send(Action::UpdateDownload(Some(percentage), Some(status)))
+ .ok();
+ })
+ .await;
+
+ match result {
+ Ok(crate::download::DownloadOutcome::Completed { .. }) => {
+ sender
+ .send(Action::DownloadCompleted(
+ destination.to_string_lossy().into_owned(),
+ ))
+ .ok();
+ }
+ Ok(crate::download::DownloadOutcome::Paused { .. }) => {
+ sender
+ .send(Action::DownloadPaused(
+ destination.to_string_lossy().into_owned(),
+ ))
+ .ok();
+ }
+ Err(error) => {
+ sender.send(Action::DownloadFailed(error.to_string())).ok();
+ }
+ }
+ });
+ }
+
pub async fn run<B: ratatui::backend::Backend>(
&mut self,
terminal: &mut ratatui::Terminal<B>,
@@ -2958,610 +3138,9 @@ impl App {
}
}
Action::DownloadStream(subtitle_url) => {
- if self.state.download_progress.is_some() {
- return None;
- }
- if self.state.active_screen == Screen::Details {
- let link_opt = self.get_selected_link();
- let title = self
- .state
- .selected_details
- .as_ref()
- .and_then(|d| d.get("title"))
- .and_then(|t| t.as_str())
- .unwrap_or("MovieBox-Tui_Stream")
- .to_string();
- let stype = self
- .state
- .selected_details
- .as_ref()
- .and_then(|d| d.get("stype").or_else(|| d.get("subjectType")))
- .and_then(|v| v.as_i64())
- .unwrap_or(1);
- let season = self.state.selected_season;
- let episode = self.state.selected_episode;
-
- let mut sanitized_title = title.replace(" ", "_");
- for c in &['/', '\\', ':', '*', '?', '"', '<', '>', '|'] {
- sanitized_title = sanitized_title.replace(*c, "_");
- }
-
- if let Some(link) = link_opt {
- self.state.is_waiting_for_download_stream = false;
- self.state.toast_message = Some(format!(
- "{} Starting native download...",
- if self.state.basic_terminal {
- "[OK]"
- } else {
- "✓"
- }
- ));
- self.state.toast_timer = 40;
- self.state.download_status = Some("Connecting...".to_string());
- self.state.download_progress = Some(0.0);
- self.state
- .cancel_download
- .store(false, std::sync::atomic::Ordering::SeqCst);
-
- let cancel_token = self.state.cancel_download.clone();
- let sender = self.action_sender.clone();
- let client = reqwest::Client::builder()
- .connect_timeout(std::time::Duration::from_secs(10))
- .tcp_keepalive(std::time::Duration::from_secs(30))
- .build()
- .unwrap_or_else(|_| self.client.http_client().clone());
- tokio::spawn(async move {
- let head_res = client.head(&link).send().await;
- let (total_size, supports_ranges, ext) = match head_res {
- Ok(r) => {
- let size = r.content_length().unwrap_or(0);
- let ranges = r
- .headers()
- .get(reqwest::header::ACCEPT_RANGES)
- .and_then(|v| v.to_str().ok())
- .unwrap_or("")
- == "bytes";
- let ext = r
- .headers()
- .get(reqwest::header::CONTENT_DISPOSITION)
- .and_then(|v| v.to_str().ok())
- .and_then(|s| s.split('.').next_back())
- .unwrap_or("mp4")
- .to_string();
- (size, ranges, ext)
- }
- Err(e) => {
- sender
- .send(Action::UpdateDownload(
- None,
- Some(format!("Head Error: {}", e)),
- ))
- .ok();
- tokio::time::sleep(std::time::Duration::from_secs(3)).await;
- sender.send(Action::UpdateDownload(None, None)).ok();
- return;
- }
- };
-
- let base_dir = dirs::download_dir()
- .unwrap_or_else(|| std::path::PathBuf::from("."))
- .join("MovieBox-TUI");
-
- let (target_dir, base_filename) = if stype == 2 {
- let dir = base_dir
- .join("Series")
- .join(&sanitized_title)
- .join(format!("Season {}", season));
- let fname =
- format!("{}_S{:02}E{:02}", sanitized_title, season, episode);
- (dir, fname)
- } else {
- let dir = base_dir.join("Movies");
- (dir, sanitized_title.clone())
- };
-
- std::fs::create_dir_all(&target_dir).ok();
-
- let mut filename = format!("{}.{}", base_filename, ext);
- let mut filepath = target_dir.join(&filename);
-
- let mut counter = 2;
- while filepath.exists() {
- filename = format!("{}_{}.{}", base_filename, counter, ext);
- filepath = target_dir.join(&filename);
- counter += 1;
- }
-
- if let Some(sub_url) = subtitle_url {
- let sub_ext = sub_url.split('.').next_back().unwrap_or("srt");
- let sub_ext = if sub_ext.len() <= 4 { sub_ext } else { "srt" };
-
- let mut sub_filename = filename.clone();
- if let Some(dot_idx) = sub_filename.rfind('.') {
- sub_filename.truncate(dot_idx);
- }
- sub_filename.push_str(&format!(".{}", sub_ext));
-
- let sub_target = target_dir.join(&sub_filename);
- let sub_client = client.clone();
- tokio::spawn(async move {
- if let Ok(res) = sub_client.get(&sub_url).send().await {
- if let Ok(bytes) = res.bytes().await {
- let _ = tokio::fs::write(sub_target, bytes).await;
- }
- }
- });
- }
-
- if supports_ranges && total_size > 5 * 1024 * 1024 {
- let num_connections = 16;
- let chunk_size = total_size / num_connections;
- let mut handles = vec![];
-
- let downloaded_total =
- std::sync::Arc::new(std::sync::atomic::AtomicU64::new(0));
- let start_time = std::time::Instant::now();
-
- let ui_downloaded = downloaded_total.clone();
- let ui_sender = sender.clone();
- let ui_cancel = cancel_token.clone();
- let ui_handle = tokio::spawn(async move {
- loop {
- tokio::time::sleep(std::time::Duration::from_millis(200))
- .await;
- if ui_cancel.load(std::sync::atomic::Ordering::Relaxed) {
- break;
- }
-
- let current_dl = ui_downloaded
- .load(std::sync::atomic::Ordering::Relaxed);
- let progress = (current_dl as f64 / total_size as f64)
- .clamp(0.0, 1.0)
- * 100.0;
- let elapsed = start_time.elapsed().as_secs_f64();
- let speed_bps = if elapsed > 0.0 {
- current_dl as f64 / elapsed
- } else {
- 0.0
- };
- let speed_mbps = speed_bps / 1024.0 / 1024.0;
- let remaining_bytes =
- total_size.saturating_sub(current_dl) as f64;
- let eta_secs = if speed_bps > 0.0 {
- remaining_bytes / speed_bps
- } else {
- 0.0
- };
-
- let status = format!(
- "{:.1} MB / {:.1} MB | {:.1} MB/s | ETA: {:.0}s [16x]",
- current_dl as f64 / 1024.0 / 1024.0,
- total_size as f64 / 1024.0 / 1024.0,
- speed_mbps,
- eta_secs
- );
- ui_sender
- .send(Action::UpdateDownload(
- Some(progress),
- Some(status),
- ))
- .ok();
- if current_dl >= total_size {
- break;
- }
- }
- });
-
- let mut temp_files = vec![];
- for i in 0..num_connections {
- let start = i * chunk_size;
- let end = if i == num_connections - 1 {
- total_size - 1
- } else {
- start + chunk_size - 1
- };
-
- let part_filepath =
- filepath.with_extension(format!("part{}", i));
- temp_files.push(part_filepath.clone());
-
- let client_clone = client.clone();
- let link_clone = link.clone();
- let dl_total = downloaded_total.clone();
- let c_token = cancel_token.clone();
-
- handles.push(tokio::spawn(async move {
- let file_res =
- tokio::fs::File::create(&part_filepath).await;
- if file_res.is_err() {
- return Err(());
- }
- let mut file = tokio::io::BufWriter::with_capacity(
- 128 * 1024,
- file_res.unwrap(),
- );
-
- let req = client_clone
- .get(&link_clone)
- .header(
- reqwest::header::RANGE,
- format!("bytes={}-{}", start, end),
- )
- .send()
- .await;
- if req.is_err() {
- return Err(());
- }
- let mut res = req.unwrap();
-
- use tokio::io::AsyncWriteExt;
- let expected_size = end - start + 1;
- let mut part_downloaded = 0;
- loop {
- match res.chunk().await {
- Ok(Some(chunk)) => {
- if c_token
- .load(std::sync::atomic::Ordering::Relaxed)
- {
- return Err(());
- }
-
- let chunk_to_write = if part_downloaded
- + chunk.len() as u64
- > expected_size
- {
- &chunk[..(expected_size - part_downloaded)
- as usize]
- } else {
- &chunk[..]
- };
-
- if file.write_all(chunk_to_write).await.is_err()
- {
- return Err(());
- }
- dl_total.fetch_add(
- chunk_to_write.len() as u64,
- std::sync::atomic::Ordering::Relaxed,
- );
- part_downloaded += chunk_to_write.len() as u64;
-
- if part_downloaded >= expected_size {
- break;
- }
- }
- Ok(None) => break,
- Err(_) => return Err(()),
- }
- }
-
- if part_downloaded < expected_size {
- return Err(());
- }
- let _ = file.flush().await;
- Ok(())
- }));
- }
-
- let mut any_err = false;
- for h in handles {
- if let Ok(res) = h.await {
- if res.is_err() {
- any_err = true;
- }
- } else {
- any_err = true;
- }
- }
- ui_handle.abort();
-
- if cancel_token.load(std::sync::atomic::Ordering::Relaxed) {
- for file in temp_files {
- let _ = tokio::fs::remove_file(file).await;
- }
- let _ = tokio::fs::remove_file(&filepath).await;
- sender
- .send(Action::UpdateDownload(
- None,
- Some("Download Cancelled".to_string()),
- ))
- .ok();
- tokio::time::sleep(std::time::Duration::from_secs(3)).await;
- sender.send(Action::UpdateDownload(None, None)).ok();
- return;
- }
-
- if any_err {
- for tmp in &temp_files {
- let _ = tokio::fs::remove_file(tmp).await;
- }
- sender
- .send(Action::UpdateDownload(
- None,
- Some("Failed to download parts".to_string()),
- ))
- .ok();
- tokio::time::sleep(std::time::Duration::from_secs(3)).await;
- sender.send(Action::UpdateDownload(None, None)).ok();
- return;
- }
-
- sender
- .send(Action::UpdateDownload(
- Some(100.0),
- Some("Merging parts...".to_string()),
- ))
- .ok();
- if let Ok(final_file) = tokio::fs::File::create(&filepath).await {
- use tokio::io::AsyncWriteExt;
- let mut final_buf = tokio::io::BufWriter::with_capacity(
- 1024 * 1024,
- final_file,
- );
- let mut merge_ok = true;
- for tmp in &temp_files {
- if let Ok(mut part_file) = tokio::fs::File::open(tmp).await
- {
- if tokio::io::copy(&mut part_file, &mut final_buf)
- .await
- .is_err()
- {
- merge_ok = false;
- break;
- }
- } else {
- merge_ok = false;
- break;
- }
- }
- let _ = final_buf.flush().await;
- for tmp in &temp_files {
- let _ = tokio::fs::remove_file(tmp).await;
- }
-
- if merge_ok {
- sender
- .send(Action::UpdateDownload(
- Some(100.0),
- Some("Completed!".to_string()),
- ))
- .ok();
- } else {
- let _ = tokio::fs::remove_file(&filepath).await;
- sender
- .send(Action::UpdateDownload(
- None,
- Some("Failed to merge parts".to_string()),
- ))
- .ok();
- }
- }
- tokio::time::sleep(std::time::Duration::from_secs(3)).await;
- sender.send(Action::UpdateDownload(None, None)).ok();
- } else {
- match client.get(&link).send().await {
- Ok(mut response) => {
- if !response.status().is_success() {
- sender
- .send(Action::UpdateDownload(
- None,
- Some(format!(
- "Error: Status {}",
- response.status()
- )),
- ))
- .ok();
- return;
- }
- let mut downloaded: u64 = 0;
- if let Ok(file) = tokio::fs::File::create(&filepath).await {
- use tokio::io::AsyncWriteExt;
- let mut buf_writer =
- tokio::io::BufWriter::with_capacity(
- 1024 * 1024,
- file,
- );
- let start_time = std::time::Instant::now();
- let mut last_ui_update = std::time::Instant::now();
-
- sender
- .send(Action::UpdateDownload(
- None,
- Some(format!("Downloading to {}", filename)),
- ))
- .ok();
- loop {
- match response.chunk().await {
- Ok(Some(chunk)) => {
- if cancel_token.load(
- std::sync::atomic::Ordering::Relaxed,
- ) {
- let _ =
- tokio::fs::remove_file(&filepath)
- .await;
- sender
- .send(Action::UpdateDownload(
- None,
- Some(
- "Download Cancelled"
- .to_string(),
- ),
- ))
- .ok();
- tokio::time::sleep(
- std::time::Duration::from_secs(2),
- )
- .await;
- sender
- .send(Action::UpdateDownload(
- None, None,
- ))
- .ok();
- return;
- }
- if buf_writer
- .write_all(&chunk)
- .await
- .is_err()
- {
- sender
- .send(Action::UpdateDownload(
- None,
- Some(
- "File write error!"
- .to_string(),
- ),
- ))
- .ok();
- return;
- }
- downloaded += chunk.len() as u64;
-
- let now = std::time::Instant::now();
- if now
- .duration_since(last_ui_update)
- .as_millis()
- > 200
- {
- last_ui_update = now;
- let progress = if total_size > 0 {
- (downloaded as f64
- / total_size as f64)
- * 100.0
- } else {
- 0.0
- };
-
- let elapsed = now
- .duration_since(start_time)
- .as_secs_f64();
- let speed_bps = if elapsed > 0.0 {
- downloaded as f64 / elapsed
- } else {
- 0.0
- };
- let speed_mbps =
- speed_bps / 1024.0 / 1024.0;
-
- let remaining_bytes = total_size
- .saturating_sub(downloaded)
- as f64;
- let eta_secs = if speed_bps > 0.0 {
- remaining_bytes / speed_bps
- } else {
- 0.0
- };
-
- let status = format!(
- "{:.1} MB / {:.1} MB | {:.1} MB/s | ETA: {:.0}s [1x]",
- downloaded as f64 / 1024.0 / 1024.0,
- total_size as f64 / 1024.0 / 1024.0,
- speed_mbps,
- eta_secs
- );
- sender
- .send(Action::UpdateDownload(
- Some(progress),
- Some(status),
- ))
- .ok();
- }
- }
- Ok(None) => break,
- Err(e) => {
- let _ =
- tokio::fs::remove_file(&filepath).await;
- sender
- .send(Action::UpdateDownload(
- None,
- Some(format!(
- "Stream Error: {}",
- e
- )),
- ))
- .ok();
- tokio::time::sleep(
- std::time::Duration::from_secs(3),
- )
- .await;
- sender
- .send(Action::UpdateDownload(
- None, None,
- ))
- .ok();
- return;
- }
- }
- }
-
- if total_size > 0 && downloaded != total_size {
- let _ = tokio::fs::remove_file(&filepath).await;
- sender
- .send(Action::UpdateDownload(
- None,
- Some("Incomplete download".to_string()),
- ))
- .ok();
- tokio::time::sleep(std::time::Duration::from_secs(
- 3,
- ))
- .await;
- sender
- .send(Action::UpdateDownload(None, None))
- .ok();
- return;
- }
- let _ = buf_writer.flush().await;
- sender
- .send(Action::UpdateDownload(
- Some(100.0),
- Some("Completed!".to_string()),
- ))
- .ok();
- tokio::time::sleep(std::time::Duration::from_secs(3))
- .await;
- sender.send(Action::UpdateDownload(None, None)).ok();
- } else {
- sender
- .send(Action::UpdateDownload(
- None,
- Some("Failed to create file".to_string()),
- ))
- .ok();
- tokio::time::sleep(std::time::Duration::from_secs(3))
- .await;
- sender.send(Action::UpdateDownload(None, None)).ok();
- }
- }
- Err(e) => {
- sender
- .send(Action::UpdateDownload(
- None,
- Some(format!("Network Error: {}", e)),
- ))
- .ok();
- tokio::time::sleep(std::time::Duration::from_secs(3)).await;
- sender.send(Action::UpdateDownload(None, None)).ok();
- }
- }
- }
- });
- } else if self.state.is_fetching_streams {
- self.state.toast_message =
- Some("Waiting for streams to load...".to_string());
- self.state.toast_timer = 60;
- self.state.is_waiting_for_download_stream = true;
- } else {
- self.state.toast_message =
- Some("No streams available to download.".to_string());
- self.state.toast_timer = 60;
- if self.state.download_queue_total > 0 {
- self.action_sender.send(Action::ProcessDownloadQueue).ok();
- }
- }
- }
+ self.start_resilient_download(subtitle_url);
+ return None;
}
-
Action::PromptDownloadEpisode => {
if self.state.active_provider != ProviderKind::MovieBox {
self.state.status_message =
@@ -4412,9 +3991,52 @@ impl App {
self.state.download_status = stat;
self.state.dirty = true;
}
-
- if prog.is_none() && !self.state.download_queue.is_empty() {
+ }
+ Action::DownloadCompleted(path) => {
+ self.state.download_progress = Some(100.0);
+ self.state.download_status = Some("Completed".into());
+ self.state.toast_message = Some(format!("Downloaded to {path}"));
+ self.state.toast_timer = 120;
+ let sender = self.action_sender.clone();
+ tokio::spawn(async move {
+ tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+ sender.send(Action::ClearDownload).ok();
+ });
+ }
+ Action::DownloadFailed(error) => {
+ self.state.download_progress = None;
+ self.state.download_status = None;
+ self.state.download_queue.clear();
+ self.state.download_queue_total = 0;
+ self.state.toast_message =
+ Some(format!("Download failed; partial preserved: {error}"));
+ self.state.toast_timer = 240;
+ self.state.status_message =
+ format!("Download failed; retry to resume. Reason: {error}");
+ self.state.status_timer = 240;
+ }
+ Action::DownloadPaused(path) => {
+ self.state.download_progress = None;
+ self.state.download_status = None;
+ self.state.download_queue.clear();
+ self.state.download_queue_total = 0;
+ self.state.toast_message = Some(format!(
+ "Download paused. Start again to resume: {path}.part"
+ ));
+ self.state.toast_timer = 240;
+ }
+ Action::ClearDownload => {
+ self.state.download_progress = None;
+ self.state.download_status = None;
+ if !self.state.download_queue.is_empty() {
self.action_sender.send(Action::ProcessDownloadQueue).ok();
+ } else if self.state.download_queue_total > 0 {
+ self.state.toast_message = Some(format!(
+ "Season download complete! ({} files)",
+ self.state.download_queue_total
+ ));
+ self.state.toast_timer = 120;
+ self.state.download_queue_total = 0;
}
}
Action::CancelDownload => {