mirror of
https://github.com/tapframe/NuvioStreaming.git
synced 2026-04-25 02:23:11 +00:00
741 lines
30 KiB
TypeScript
741 lines
30 KiB
TypeScript
import React, { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
|
|
import { AppState } from 'react-native';
|
|
import * as FileSystem from 'expo-file-system/legacy';
|
|
import { mmkvStorage } from '../services/mmkvStorage';
|
|
import { notificationService } from '../services/notificationService';
|
|
|
|
export type DownloadStatus = 'downloading' | 'completed' | 'paused' | 'error' | 'queued';
|
|
|
|
export interface DownloadItem {
|
|
id: string; // unique id for this download (content id + episode if any)
|
|
contentId: string; // base id (e.g., tt0903747 for series, tt0499549 for movies)
|
|
type: 'movie' | 'series';
|
|
title: string; // movie title or show name
|
|
providerName?: string;
|
|
season?: number;
|
|
episode?: number;
|
|
episodeTitle?: string;
|
|
quality?: string;
|
|
size?: number; // total bytes if known
|
|
downloadedBytes: number;
|
|
totalBytes: number;
|
|
progress: number; // 0-100
|
|
status: DownloadStatus;
|
|
speedBps?: number;
|
|
etaSeconds?: number;
|
|
posterUrl?: string | null;
|
|
sourceUrl: string; // stream url
|
|
headers?: Record<string, string>;
|
|
fileUri?: string; // local file uri once downloading/finished
|
|
createdAt: number;
|
|
updatedAt: number;
|
|
// Additional metadata for progress tracking
|
|
imdbId?: string; // IMDb ID for better tracking
|
|
tmdbId?: number; // TMDB ID if available
|
|
// CRITICAL: Resume data for proper pause/resume across sessions
|
|
resumeData?: string; // The string which allows the API to resume a paused download
|
|
}
|
|
|
|
type StartDownloadInput = {
|
|
id: string; // Base content ID (e.g., tt0903747)
|
|
type: 'movie' | 'series';
|
|
title: string;
|
|
providerName?: string;
|
|
season?: number;
|
|
episode?: number;
|
|
episodeTitle?: string;
|
|
quality?: string;
|
|
posterUrl?: string | null;
|
|
url: string;
|
|
headers?: Record<string, string>;
|
|
// Additional metadata for progress tracking
|
|
imdbId?: string;
|
|
tmdbId?: number;
|
|
};
|
|
|
|
type DownloadsContextValue = {
|
|
downloads: DownloadItem[];
|
|
startDownload: (input: StartDownloadInput) => Promise<void>;
|
|
pauseDownload: (id: string) => Promise<void>;
|
|
resumeDownload: (id: string) => Promise<void>;
|
|
cancelDownload: (id: string) => Promise<void>;
|
|
removeDownload: (id: string) => Promise<void>;
|
|
isDownloadingUrl: (url: string) => boolean;
|
|
};
|
|
|
|
const DownloadsContext = createContext<DownloadsContextValue | undefined>(undefined);
|
|
|
|
const STORAGE_KEY = 'downloads_state_v1';
|
|
|
|
function sanitizeFilename(name: string): string {
|
|
return name.replace(/[^a-z0-9\-_.()\s]/gi, '_').slice(0, 120).trim();
|
|
}
|
|
|
|
async function getExtensionFromHeaders(url: string, headers?: Record<string, string>): Promise<string | null> {
|
|
try {
|
|
const response = await fetch(url, { method: 'HEAD', headers });
|
|
const contentType = response.headers.get('content-type');
|
|
|
|
if (contentType) {
|
|
// Map common content types to extensions
|
|
if (contentType.includes('video/mp4')) return 'mp4';
|
|
if (contentType.includes('video/x-matroska')) return 'mkv';
|
|
if (contentType.includes('video/avi')) return 'avi';
|
|
if (contentType.includes('video/quicktime')) return 'mov';
|
|
if (contentType.includes('video/webm')) return 'webm';
|
|
if (contentType.includes('video/x-flv')) return 'flv';
|
|
if (contentType.includes('video/x-ms-wmv')) return 'wmv';
|
|
if (contentType.includes('video/x-m4v')) return 'm4v';
|
|
}
|
|
} catch (error) {
|
|
console.warn('[DownloadsContext] Could not get content-type from HEAD request', error);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function isDownloadableUrl(url: string): boolean {
|
|
if (!url) return false;
|
|
|
|
const lower = url.toLowerCase();
|
|
|
|
// Check for streaming formats that should NOT be downloadable (only m3u8 and DASH)
|
|
const streamingFormats = [
|
|
'.m3u8', // HLS streaming
|
|
'.mpd', // DASH streaming
|
|
'm3u8', // HLS without extension
|
|
'mpd', // DASH without extension
|
|
];
|
|
|
|
// Check if URL contains streaming format indicators
|
|
const isStreamingFormat = streamingFormats.some(format =>
|
|
lower.includes(format) ||
|
|
lower.includes(`ext=${format}`) ||
|
|
lower.includes(`format=${format}`) ||
|
|
lower.includes(`container=${format}`)
|
|
);
|
|
|
|
// Return true if it's NOT a streaming format (m3u8 or DASH)
|
|
return !isStreamingFormat;
|
|
}
|
|
|
|
function hashString(input: string): string {
|
|
let hash = 0;
|
|
for (let i = 0; i < input.length; i++) {
|
|
const chr = input.charCodeAt(i);
|
|
hash = (hash << 5) - hash + chr;
|
|
hash |= 0; // Convert to 32bit integer
|
|
}
|
|
// Convert to unsigned and hex
|
|
return (hash >>> 0).toString(16);
|
|
}
|
|
|
|
export const DownloadsProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
|
|
const [downloads, setDownloads] = useState<DownloadItem[]>([]);
|
|
const downloadsRef = useRef(downloads);
|
|
useEffect(() => {
|
|
downloadsRef.current = downloads;
|
|
}, [downloads]);
|
|
// Keep active resumables in memory (not persisted)
|
|
const resumablesRef = useRef<Map<string, any>>(new Map());
|
|
const lastBytesRef = useRef<Map<string, { bytes: number; time: number }>>(new Map());
|
|
|
|
// Persist and restore
|
|
useEffect(() => {
|
|
(async () => {
|
|
try {
|
|
const raw = await mmkvStorage.getItem(STORAGE_KEY);
|
|
if (raw) {
|
|
const list = JSON.parse(raw) as Array<Partial<DownloadItem>>;
|
|
// Mark any in-progress as paused on restore (cannot resume across sessions reliably)
|
|
const restored: DownloadItem[] = list.map((d) => {
|
|
const status = (d.status as DownloadStatus) || 'paused';
|
|
const safe: DownloadItem = {
|
|
id: String(d.id),
|
|
contentId: String(d.contentId ?? d.id),
|
|
type: (d.type as 'movie' | 'series') ?? 'movie',
|
|
title: String(d.title ?? 'Content'),
|
|
providerName: d.providerName,
|
|
season: typeof d.season === 'number' ? d.season : undefined,
|
|
episode: typeof d.episode === 'number' ? d.episode : undefined,
|
|
episodeTitle: d.episodeTitle ? String(d.episodeTitle) : undefined,
|
|
quality: d.quality ? String(d.quality) : undefined,
|
|
size: typeof d.size === 'number' ? d.size : undefined,
|
|
downloadedBytes: typeof d.downloadedBytes === 'number' ? d.downloadedBytes : 0,
|
|
totalBytes: typeof d.totalBytes === 'number' ? d.totalBytes : 0,
|
|
progress: typeof d.progress === 'number' ? d.progress : 0,
|
|
status: status === 'downloading' || status === 'queued' ? 'paused' : status,
|
|
speedBps: undefined,
|
|
etaSeconds: undefined,
|
|
posterUrl: (d.posterUrl as any) ?? null,
|
|
sourceUrl: String(d.sourceUrl ?? ''),
|
|
headers: (d.headers as any) ?? undefined,
|
|
fileUri: d.fileUri ? String(d.fileUri) : undefined,
|
|
createdAt: typeof d.createdAt === 'number' ? d.createdAt : Date.now(),
|
|
updatedAt: typeof d.updatedAt === 'number' ? d.updatedAt : Date.now(),
|
|
// Restore metadata for progress tracking
|
|
imdbId: (d as any).imdbId ? String((d as any).imdbId) : undefined,
|
|
tmdbId: typeof (d as any).tmdbId === 'number' ? (d as any).tmdbId : undefined,
|
|
// CRITICAL: Restore resumeData for proper resume across sessions
|
|
resumeData: (d as any).resumeData ? String((d as any).resumeData) : undefined,
|
|
};
|
|
return safe;
|
|
});
|
|
setDownloads(restored);
|
|
}
|
|
} catch {}
|
|
})();
|
|
}, []);
|
|
|
|
// Notifications are configured globally by notificationService
|
|
|
|
// Track app state to know foreground/background
|
|
const appStateRef = useRef<string>('active');
|
|
useEffect(() => {
|
|
const sub = AppState.addEventListener('change', (s) => {
|
|
appStateRef.current = s;
|
|
});
|
|
return () => sub.remove();
|
|
}, []);
|
|
|
|
// Cache last notified progress to reduce spam
|
|
const lastNotifyRef = useRef<Map<string, number>>(new Map());
|
|
|
|
const maybeNotifyProgress = useCallback(async (d: DownloadItem) => {
|
|
try {
|
|
if (appStateRef.current === 'active') return;
|
|
if (d.status !== 'downloading') return;
|
|
const prev = lastNotifyRef.current.get(d.id) ?? -1;
|
|
if (d.progress <= prev || d.progress - prev < 2) return; // notify every 2%
|
|
lastNotifyRef.current.set(d.id, d.progress);
|
|
await notificationService.notifyDownloadProgress(d.title, d.progress, d.downloadedBytes, d.totalBytes);
|
|
} catch {}
|
|
}, []);
|
|
|
|
const notifyCompleted = useCallback(async (d: DownloadItem) => {
|
|
try {
|
|
if (appStateRef.current === 'active') return;
|
|
await notificationService.notifyDownloadComplete(d.title);
|
|
} catch {}
|
|
}, []);
|
|
|
|
useEffect(() => {
|
|
mmkvStorage.setItem(STORAGE_KEY, JSON.stringify(downloads)).catch(() => {});
|
|
}, [downloads]);
|
|
|
|
const updateDownload = useCallback((id: string, updater: (d: DownloadItem) => DownloadItem) => {
|
|
setDownloads(prev => prev.map(d => (d.id === id ? updater(d) : d)));
|
|
}, []);
|
|
|
|
const resumeDownload = useCallback(async (id: string) => {
|
|
console.log(`[DownloadsContext] Resuming download: ${id}`);
|
|
const item = downloadsRef.current.find(d => d.id === id); // Use ref
|
|
if (!item) {
|
|
console.log(`[DownloadsContext] No item found for download: ${id}`);
|
|
return;
|
|
}
|
|
|
|
// Update status to downloading immediately
|
|
updateDownload(id, (d) => ({ ...d, status: 'downloading', updatedAt: Date.now() }));
|
|
|
|
// Always try to use existing resumable first - this is crucial for proper resume
|
|
let resumable = resumablesRef.current.get(id);
|
|
|
|
if (resumable) {
|
|
console.log(`[DownloadsContext] Using existing resumable for download: ${id}`);
|
|
// Existing resumable should already have the correct progress callback and file URI
|
|
// No need to recreate it
|
|
} else {
|
|
console.log(`[DownloadsContext] Creating new resumable for download: ${id}`);
|
|
|
|
// Use the exact same file URI that was used initially
|
|
const fileUri = item.fileUri;
|
|
if (!fileUri) {
|
|
console.error(`[DownloadsContext] No fileUri found for download: ${id}`);
|
|
updateDownload(id, (d) => ({ ...d, status: 'error', updatedAt: Date.now() }));
|
|
return;
|
|
}
|
|
|
|
const progressCallback = (data: any) => {
|
|
const { totalBytesWritten, totalBytesExpectedToWrite } = data;
|
|
const now = Date.now();
|
|
const last = lastBytesRef.current.get(id);
|
|
let speedBps = 0;
|
|
if (last) {
|
|
const deltaBytes = totalBytesWritten - last.bytes;
|
|
const deltaTime = Math.max(1, now - last.time) / 1000;
|
|
speedBps = deltaBytes / deltaTime;
|
|
}
|
|
lastBytesRef.current.set(id, { bytes: totalBytesWritten, time: now });
|
|
|
|
updateDownload(id, (d) => ({
|
|
...d,
|
|
downloadedBytes: totalBytesWritten,
|
|
totalBytes: totalBytesExpectedToWrite || d.totalBytes,
|
|
progress: totalBytesExpectedToWrite ? Math.floor((totalBytesWritten / totalBytesExpectedToWrite) * 100) : d.progress,
|
|
speedBps,
|
|
status: 'downloading',
|
|
updatedAt: now,
|
|
}));
|
|
|
|
// Fire background progress notification (throttled)
|
|
const current = downloadsRef.current.find(x => x.id === id);
|
|
if (current) {
|
|
maybeNotifyProgress({ ...current, downloadedBytes: totalBytesWritten, totalBytes: totalBytesExpectedToWrite || current.totalBytes, progress: totalBytesExpectedToWrite ? Math.floor((totalBytesWritten / totalBytesExpectedToWrite) * 100) : current.progress });
|
|
}
|
|
};
|
|
|
|
// CRITICAL FIX: Create resumable with resumeData (5th parameter) for proper resume
|
|
resumable = FileSystem.createDownloadResumable(
|
|
item.sourceUrl,
|
|
fileUri,
|
|
{ headers: item.headers || {} },
|
|
progressCallback,
|
|
item.resumeData // This is the critical parameter that was missing!
|
|
);
|
|
resumablesRef.current.set(id, resumable);
|
|
lastBytesRef.current.set(id, { bytes: item.downloadedBytes, time: Date.now() });
|
|
}
|
|
|
|
try {
|
|
console.log(`[DownloadsContext] Calling resumeAsync for download: ${id}`);
|
|
const result = await resumable.resumeAsync();
|
|
|
|
// Check if download was paused during resume
|
|
const currentItem = downloadsRef.current.find(d => d.id === id);
|
|
if (currentItem && currentItem.status === 'paused') {
|
|
console.log(`[DownloadsContext] Download was paused during resume, keeping paused state: ${id}`);
|
|
// Keep resumable for next resume attempt - DO NOT DELETE
|
|
return;
|
|
}
|
|
|
|
if (!result) throw new Error('Resume failed');
|
|
|
|
console.log(`[DownloadsContext] Resume successful for download: ${id}`);
|
|
|
|
// Validate the downloaded file
|
|
try {
|
|
const fileInfo = await FileSystem.getInfoAsync(result.uri);
|
|
if (!fileInfo.exists) {
|
|
throw new Error('Downloaded file does not exist');
|
|
}
|
|
if (fileInfo.size === 0) {
|
|
throw new Error('Downloaded file is empty (0 bytes)');
|
|
}
|
|
|
|
// CRITICAL FIX: Check if file size matches expected size (if known)
|
|
const currentItem = downloadsRef.current.find(d => d.id === id);
|
|
if (currentItem && currentItem.totalBytes > 0) {
|
|
const sizeDifference = Math.abs(fileInfo.size - currentItem.totalBytes);
|
|
const percentDifference = (sizeDifference / currentItem.totalBytes) * 100;
|
|
|
|
// Allow up to 1% difference to account for potential header/metadata variations
|
|
if (percentDifference > 1) {
|
|
throw new Error(
|
|
`File size mismatch: expected ${currentItem.totalBytes} bytes, got ${fileInfo.size} bytes (${percentDifference.toFixed(2)}% difference)`
|
|
);
|
|
}
|
|
}
|
|
|
|
console.log(`[DownloadsContext] File validation passed: ${result.uri} (${fileInfo.size} bytes)`);
|
|
} catch (validationError) {
|
|
console.error(`[DownloadsContext] File validation failed: ${validationError}`);
|
|
// Delete the corrupted file
|
|
try {
|
|
await FileSystem.deleteAsync(result.uri, { idempotent: true });
|
|
console.log(`[DownloadsContext] Deleted corrupted file: ${result.uri}`);
|
|
} catch (deleteError) {
|
|
console.error(`[DownloadsContext] Failed to delete corrupted file: ${deleteError}`);
|
|
}
|
|
throw new Error(`Downloaded file validation failed: ${validationError}`);
|
|
}
|
|
|
|
// Ensure we use the correct file URI from the result
|
|
const finalFileUri = result.uri;
|
|
updateDownload(id, (d) => ({ ...d, status: 'completed', progress: 100, updatedAt: Date.now(), fileUri: finalFileUri, resumeData: undefined }));
|
|
|
|
const done = downloadsRef.current.find(x => x.id === id);
|
|
if (done) notifyCompleted({ ...done, status: 'completed', progress: 100, fileUri: finalFileUri } as DownloadItem);
|
|
|
|
// Clean up only after successful completion
|
|
resumablesRef.current.delete(id);
|
|
lastBytesRef.current.delete(id);
|
|
} catch (e: any) {
|
|
console.log(`[DownloadsContext] Resume threw error for download: ${id}`, e);
|
|
|
|
// Check if the error was due to pause
|
|
const currentItem = downloadsRef.current.find(d => d.id === id);
|
|
if (currentItem && currentItem.status === 'paused') {
|
|
console.log(`[DownloadsContext] Error was due to pause, keeping paused state and resumable: ${id}`);
|
|
// Keep resumable for next resume attempt - DO NOT DELETE
|
|
return;
|
|
}
|
|
|
|
// Only mark as error and clean up if it's a real error (not pause-related)
|
|
console.log(`[DownloadsContext] Marking download as error: ${id}`);
|
|
|
|
// For validation errors, clear resumeData and allow fresh restart
|
|
if (e.message && e.message.includes('validation failed')) {
|
|
console.log(`[DownloadsContext] Validation error - clearing resume data for fresh start: ${id}`);
|
|
updateDownload(id, (d) => ({
|
|
...d,
|
|
status: 'error',
|
|
resumeData: undefined, // Clear corrupted resume data
|
|
updatedAt: Date.now()
|
|
}));
|
|
// Clean up resumable to force fresh download on retry
|
|
resumablesRef.current.delete(id);
|
|
lastBytesRef.current.delete(id);
|
|
} else if (e.message && (e.message.includes('size mismatch') || e.message.includes('empty'))) {
|
|
// File corruption detected - clear everything for fresh start
|
|
console.log(`[DownloadsContext] File corruption detected - clearing for fresh start: ${id}`);
|
|
updateDownload(id, (d) => ({
|
|
...d,
|
|
status: 'error',
|
|
downloadedBytes: 0,
|
|
progress: 0,
|
|
resumeData: undefined, // Clear corrupted resume data
|
|
updatedAt: Date.now()
|
|
}));
|
|
resumablesRef.current.delete(id);
|
|
lastBytesRef.current.delete(id);
|
|
} else {
|
|
// Network or other errors - keep resume data for retry
|
|
console.log(`[DownloadsContext] Network/other error - keeping resume data for retry: ${id}`);
|
|
updateDownload(id, (d) => ({ ...d, status: 'error', updatedAt: Date.now() }));
|
|
// Keep resumable for potential retry
|
|
}
|
|
}
|
|
}, [updateDownload, maybeNotifyProgress, notifyCompleted]);
|
|
|
|
const startDownload = useCallback(async (input: StartDownloadInput) => {
|
|
// Validate that the URL is downloadable (not m3u8 or DASH)
|
|
if (!isDownloadableUrl(input.url)) {
|
|
throw new Error('This stream format cannot be downloaded. M3U8 (HLS) and DASH streaming formats are not supported for download.');
|
|
}
|
|
|
|
const contentId = input.id;
|
|
// Create unique ID per URL - allows same episode/movie from different sources
|
|
const urlHash = hashString(input.url);
|
|
const baseId = input.type === 'series' && input.season && input.episode
|
|
? `${contentId}:S${input.season}E${input.episode}`
|
|
: contentId;
|
|
const compoundId = `${baseId}:${urlHash}`;
|
|
|
|
// Check if this exact URL is already being downloaded
|
|
const existing = downloadsRef.current.find(d => d.sourceUrl === input.url);
|
|
if (existing) {
|
|
if (existing.status === 'completed') {
|
|
return; // Already completed, do nothing
|
|
} else if (existing.status === 'downloading') {
|
|
return; // Already downloading, do nothing
|
|
} else if (existing.status === 'paused' || existing.status === 'error') {
|
|
// Resume the paused or errored download instead of starting new one
|
|
await resumeDownload(existing.id);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Create file path - use a simple unique identifier with extension from HEAD request
|
|
const baseDir = (FileSystem as any).documentDirectory || (FileSystem as any).cacheDirectory || '/tmp/';
|
|
const uniqueId = `${Date.now()}_${Math.random().toString(36).substring(7)}`;
|
|
const extension = await getExtensionFromHeaders(input.url, input.headers);
|
|
const fileUri = extension ? `${baseDir}downloads/${uniqueId}.${extension}` : `${baseDir}downloads/${uniqueId}`;
|
|
|
|
// Ensure directory exists
|
|
await FileSystem.makeDirectoryAsync(`${baseDir}downloads`, { intermediates: true }).catch(() => {});
|
|
|
|
const createdAt = Date.now();
|
|
const newItem: DownloadItem = {
|
|
id: compoundId,
|
|
contentId,
|
|
type: input.type,
|
|
title: input.title,
|
|
providerName: input.providerName,
|
|
season: input.season,
|
|
episode: input.episode,
|
|
episodeTitle: input.episodeTitle,
|
|
quality: input.quality,
|
|
size: undefined,
|
|
downloadedBytes: 0,
|
|
totalBytes: 0,
|
|
progress: 0,
|
|
status: 'downloading',
|
|
speedBps: 0,
|
|
etaSeconds: undefined,
|
|
posterUrl: input.posterUrl || null,
|
|
sourceUrl: input.url,
|
|
headers: input.headers,
|
|
fileUri,
|
|
createdAt,
|
|
updatedAt: createdAt,
|
|
// Store metadata for progress tracking
|
|
imdbId: input.imdbId,
|
|
tmdbId: input.tmdbId,
|
|
// Initialize resumeData as undefined
|
|
resumeData: undefined,
|
|
};
|
|
|
|
setDownloads(prev => [newItem, ...prev]);
|
|
|
|
const progressCallback = (data: any) => {
|
|
const { totalBytesWritten, totalBytesExpectedToWrite } = data;
|
|
const now = Date.now();
|
|
const last = lastBytesRef.current.get(compoundId);
|
|
let speedBps = 0;
|
|
if (last) {
|
|
const deltaBytes = totalBytesWritten - last.bytes;
|
|
const deltaTime = Math.max(1, now - last.time) / 1000;
|
|
speedBps = deltaBytes / deltaTime;
|
|
}
|
|
lastBytesRef.current.set(compoundId, { bytes: totalBytesWritten, time: now });
|
|
|
|
updateDownload(compoundId, (d) => ({
|
|
...d,
|
|
downloadedBytes: totalBytesWritten,
|
|
totalBytes: totalBytesExpectedToWrite || d.totalBytes,
|
|
progress: totalBytesExpectedToWrite ? Math.floor((totalBytesWritten / totalBytesExpectedToWrite) * 100) : d.progress,
|
|
speedBps,
|
|
updatedAt: now,
|
|
}));
|
|
// Fire background progress notification (throttled)
|
|
const current = downloadsRef.current.find(x => x.id === compoundId);
|
|
if (current) {
|
|
maybeNotifyProgress({ ...current, downloadedBytes: totalBytesWritten, totalBytes: totalBytesExpectedToWrite || current.totalBytes, progress: totalBytesExpectedToWrite ? Math.floor((totalBytesWritten / totalBytesExpectedToWrite) * 100) : current.progress });
|
|
}
|
|
};
|
|
|
|
// Create resumable
|
|
const resumable = FileSystem.createDownloadResumable(
|
|
input.url,
|
|
fileUri,
|
|
{ headers: input.headers || {} },
|
|
progressCallback
|
|
);
|
|
resumablesRef.current.set(compoundId, resumable);
|
|
lastBytesRef.current.set(compoundId, { bytes: 0, time: Date.now() });
|
|
|
|
try {
|
|
const result = await resumable.downloadAsync();
|
|
|
|
// Check if download was paused during download
|
|
const currentItem = downloadsRef.current.find(d => d.id === compoundId);
|
|
if (currentItem && currentItem.status === 'paused') {
|
|
console.log(`[DownloadsContext] Download was paused during initial download, keeping paused state: ${compoundId}`);
|
|
// CRITICAL FIX: Save resumeData when paused
|
|
try {
|
|
const savableState = resumable.savable();
|
|
updateDownload(compoundId, (d) => ({
|
|
...d,
|
|
resumeData: savableState.resumeData,
|
|
updatedAt: Date.now(),
|
|
}));
|
|
} catch (savableError) {
|
|
console.log(`[DownloadsContext] Could not get savable state after pause: ${compoundId}`, savableError);
|
|
}
|
|
// Don't delete resumable - keep it for resume
|
|
return;
|
|
}
|
|
|
|
if (!result) throw new Error('Download failed');
|
|
|
|
// Validate the downloaded file
|
|
try {
|
|
const fileInfo = await FileSystem.getInfoAsync(result.uri);
|
|
if (!fileInfo.exists) {
|
|
throw new Error('Downloaded file does not exist');
|
|
}
|
|
if (fileInfo.size === 0) {
|
|
throw new Error('Downloaded file is empty (0 bytes)');
|
|
}
|
|
|
|
// CRITICAL FIX: Check if file size matches expected size (if known)
|
|
const currentItem = downloadsRef.current.find(d => d.id === compoundId);
|
|
if (currentItem && currentItem.totalBytes > 0) {
|
|
const sizeDifference = Math.abs(fileInfo.size - currentItem.totalBytes);
|
|
const percentDifference = (sizeDifference / currentItem.totalBytes) * 100;
|
|
|
|
// Allow up to 1% difference to account for potential header/metadata variations
|
|
if (percentDifference > 1) {
|
|
throw new Error(
|
|
`File size mismatch: expected ${currentItem.totalBytes} bytes, got ${fileInfo.size} bytes (${percentDifference.toFixed(2)}% difference)`
|
|
);
|
|
}
|
|
}
|
|
|
|
console.log(`[DownloadsContext] File validation passed: ${result.uri} (${fileInfo.size} bytes)`);
|
|
} catch (validationError) {
|
|
console.error(`[DownloadsContext] File validation failed: ${validationError}`);
|
|
// Delete the corrupted file
|
|
try {
|
|
await FileSystem.deleteAsync(result.uri, { idempotent: true });
|
|
console.log(`[DownloadsContext] Deleted corrupted file: ${result.uri}`);
|
|
} catch (deleteError) {
|
|
console.error(`[DownloadsContext] Failed to delete corrupted file: ${deleteError}`);
|
|
}
|
|
throw new Error(`Downloaded file validation failed: ${validationError}`);
|
|
}
|
|
|
|
updateDownload(compoundId, (d) => ({ ...d, status: 'completed', progress: 100, updatedAt: Date.now(), fileUri: result.uri, resumeData: undefined }));
|
|
const done = downloadsRef.current.find(x => x.id === compoundId);
|
|
if (done) notifyCompleted({ ...done, status: 'completed', progress: 100, fileUri: result.uri } as DownloadItem);
|
|
resumablesRef.current.delete(compoundId);
|
|
lastBytesRef.current.delete(compoundId);
|
|
} catch (e: any) {
|
|
// If user paused, keep paused state, else error
|
|
const current = downloadsRef.current.find(d => d.id === compoundId);
|
|
if (current && current.status === 'paused') {
|
|
console.log(`[DownloadsContext] Error was due to pause during initial download, keeping paused state and resumable: ${compoundId}`);
|
|
// CRITICAL FIX: Save resumeData when paused
|
|
try {
|
|
const savableState = resumable.savable();
|
|
updateDownload(compoundId, (d) => ({
|
|
...d,
|
|
resumeData: savableState.resumeData,
|
|
updatedAt: Date.now(),
|
|
}));
|
|
} catch (savableError) {
|
|
console.log(`[DownloadsContext] Could not get savable state after pause error: ${compoundId}`, savableError);
|
|
}
|
|
// Don't delete resumable - keep it for resume
|
|
return;
|
|
}
|
|
|
|
console.log(`[DownloadsContext] Marking initial download as error: ${compoundId}`);
|
|
|
|
// For validation errors, clear resumeData and allow fresh restart
|
|
if (e.message && e.message.includes('validation failed')) {
|
|
console.log(`[DownloadsContext] Validation error - clearing resume data for fresh start: ${compoundId}`);
|
|
updateDownload(compoundId, (d) => ({
|
|
...d,
|
|
status: 'error',
|
|
resumeData: undefined, // Clear corrupted resume data
|
|
updatedAt: Date.now()
|
|
}));
|
|
// Clean up resumable to force fresh download on retry
|
|
resumablesRef.current.delete(compoundId);
|
|
lastBytesRef.current.delete(compoundId);
|
|
} else if (e.message && (e.message.includes('size mismatch') || e.message.includes('empty'))) {
|
|
// File corruption detected - clear everything for fresh start
|
|
console.log(`[DownloadsContext] File corruption detected - clearing for fresh start: ${compoundId}`);
|
|
updateDownload(compoundId, (d) => ({
|
|
...d,
|
|
status: 'error',
|
|
downloadedBytes: 0,
|
|
progress: 0,
|
|
resumeData: undefined, // Clear corrupted resume data
|
|
updatedAt: Date.now()
|
|
}));
|
|
resumablesRef.current.delete(compoundId);
|
|
lastBytesRef.current.delete(compoundId);
|
|
} else {
|
|
// Network or other errors - keep resume data for retry
|
|
console.log(`[DownloadsContext] Network/other error - keeping resume data for retry: ${compoundId}`);
|
|
updateDownload(compoundId, (d) => ({ ...d, status: 'error', updatedAt: Date.now() }));
|
|
// Keep resumable for potential retry
|
|
}
|
|
}
|
|
}, [updateDownload, resumeDownload]);
|
|
|
|
const pauseDownload = useCallback(async (id: string) => {
|
|
console.log(`[DownloadsContext] Pausing download: ${id}`);
|
|
|
|
// First, update the status to 'paused' immediately
|
|
// This will cause any ongoing download/resume operations to check status and exit gracefully
|
|
updateDownload(id, (d) => ({ ...d, status: 'paused', updatedAt: Date.now() }));
|
|
|
|
const resumable = resumablesRef.current.get(id);
|
|
if (resumable) {
|
|
try {
|
|
// CRITICAL FIX: Get the pause state which contains resumeData
|
|
const pauseResult = await resumable.pauseAsync();
|
|
console.log(`[DownloadsContext] Successfully paused download: ${id}`);
|
|
|
|
// CRITICAL FIX: Save the resumeData from pauseAsync result or savable()
|
|
// The pauseAsync returns a DownloadPauseState object with resumeData
|
|
const savableState = resumable.savable();
|
|
|
|
// Update the download item with the critical resumeData for future resume
|
|
updateDownload(id, (d) => ({
|
|
...d,
|
|
status: 'paused',
|
|
resumeData: savableState.resumeData || pauseResult.resumeData, // Store resume data
|
|
updatedAt: Date.now(),
|
|
}));
|
|
|
|
console.log(`[DownloadsContext] Saved resume data for download: ${id}`);
|
|
|
|
// Keep the resumable in memory for resume - DO NOT DELETE
|
|
} catch (error) {
|
|
console.log(`[DownloadsContext] Pause async failed (this is normal if already paused): ${id}`, error);
|
|
// Keep resumable even if pause fails - we still want to be able to resume
|
|
// Try to get savable state even if pause failed
|
|
try {
|
|
const savableState = resumable.savable();
|
|
updateDownload(id, (d) => ({
|
|
...d,
|
|
status: 'paused',
|
|
resumeData: savableState.resumeData,
|
|
updatedAt: Date.now(),
|
|
}));
|
|
} catch (savableError) {
|
|
console.log(`[DownloadsContext] Could not get savable state: ${id}`, savableError);
|
|
}
|
|
}
|
|
} else {
|
|
console.log(`[DownloadsContext] No resumable found for download: ${id}, just marked as paused`);
|
|
}
|
|
}, [updateDownload]);
|
|
|
|
const cancelDownload = useCallback(async (id: string) => {
|
|
const resumable = resumablesRef.current.get(id);
|
|
try {
|
|
if (resumable) {
|
|
try { await resumable.pauseAsync(); } catch {}
|
|
}
|
|
} finally {
|
|
resumablesRef.current.delete(id);
|
|
lastBytesRef.current.delete(id);
|
|
}
|
|
|
|
const item = downloadsRef.current.find(d => d.id === id);
|
|
if (item?.fileUri) {
|
|
await FileSystem.deleteAsync(item.fileUri, { idempotent: true }).catch(() => {});
|
|
}
|
|
setDownloads(prev => prev.filter(d => d.id !== id));
|
|
}, []);
|
|
|
|
const removeDownload = useCallback(async (id: string) => {
|
|
const item = downloadsRef.current.find(d => d.id === id);
|
|
if (item?.fileUri && item.status === 'completed') {
|
|
await FileSystem.deleteAsync(item.fileUri, { idempotent: true }).catch(() => {});
|
|
}
|
|
setDownloads(prev => prev.filter(d => d.id !== id));
|
|
}, []);
|
|
|
|
const value = useMemo<DownloadsContextValue>(() => ({
|
|
downloads,
|
|
startDownload,
|
|
pauseDownload,
|
|
resumeDownload,
|
|
cancelDownload,
|
|
removeDownload,
|
|
isDownloadingUrl: (url: string) => {
|
|
return downloadsRef.current.some(d => d.sourceUrl === url && (d.status === 'queued' || d.status === 'downloading' || d.status === 'paused'));
|
|
},
|
|
}), [downloads, startDownload, pauseDownload, resumeDownload, cancelDownload, removeDownload]);
|
|
|
|
return (
|
|
<DownloadsContext.Provider value={value}>
|
|
{children}
|
|
</DownloadsContext.Provider>
|
|
);
|
|
};
|
|
|
|
export function useDownloads(): DownloadsContextValue {
|
|
const ctx = useContext(DownloadsContext);
|
|
if (!ctx) throw new Error('useDownloads must be used within DownloadsProvider');
|
|
return ctx;
|
|
}
|
|
|
|
|