一分钟搭建影视站,支持Docker等部署方式
'use client';
import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import { api } from '@/lib/client-api';
import { LIVE_PROBE_TTL_MS, useAppStore, type LiveProbeEntry } from '@/lib/store';
/**
* 直播频道批量测活 hook:
* - 结果持久化到 store(liveProbeResults),6 小时内直接复用(LIVE_PROBE_TTL_MS);
* - 触发探测时只补测缺失或已过期的频道,全部仍有效则提示跳过;
* - 服务端以 NDJSON 流式逐条返回,结果边测边写入列表(节流合并,避免高频 re-render);
* - 每批 CHUNK_SIZE 条并行 CHUNK_CONCURRENCY 批,服务端批内并发 16、单 host 在途 ≤3(按源排队,不冲垮弱源);
* - 目标数无上限(仅 MAX_TARGETS 保险阀防病态列表):几千频道自动分批排队跑完,
* 进度带 ETA,可随时取消(保留已完成的结果);
* - 重新测活/清空时 abort 在途请求并作废上一轮(runId 比对)。
*/
export interface ProbeResult {
ok: boolean;
ms?: number;
level?: 'segment' | 'manifest' | 'head';
error?: string;
codec?: string;
/** 因超时失败(源可能只是慢) */
timedOut?: boolean;
/** 分片吞吐估算(kbps),低于阈值为「源限速」 */
kbps?: number;
}
const CHUNK_SIZE = 50;
/** 同时在途的批次数:与 CHUNK_SIZE 相乘即最大并发探测规模 */
const CHUNK_CONCURRENCY = 2;
/**
* 单轮测活目标数上限(保险阀):正常几千个频道分批排队都能跑完,不设人为瓶颈;
* 只防病态超大列表(如数十万行的脏 M3U)拖死浏览器与服务端,超出部分提示后丢弃。
*/
const MAX_TARGETS = 20_000;
/** 流式结果的写回节流间隔:把高频到达的结果合并成一次 store 更新 */
const FLUSH_INTERVAL_MS = 200;
export function useLiveProbe() {
const cache = useAppStore((s) => s.liveProbeResults);
const [progress, setProgress] = useState<{ done: number; total: number; startedAt: number } | null>(null);
const [hint, setHint] = useState('');
const runIdRef = useRef(0);
const hintTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
const abortRef = useRef<AbortController | null>(null);
const showHint = useCallback((text: string) => {
setHint(text);
if (hintTimerRef.current) clearTimeout(hintTimerRef.current);
hintTimerRef.current = setTimeout(() => setHint(''), 3000);
}, []);
useEffect(() => () => {
// 卸载时作废在途轮次并断开请求
runIdRef.current++;
if (hintTimerRef.current) clearTimeout(hintTimerRef.current);
abortRef.current?.abort();
}, []);
// 仅暴露 6 小时内的结果,过期条目对 UI 不可见。
// 结果对象按 (url, timestamp) 复用身份:节流写回只更新被探测到的频道,
// 未变化的条目保持同一对象引用,下游 memo 行组件才能精确跳过重渲染。
const identityRef = useRef(new Map<string, { timestamp: number; result: ProbeResult }>());
const results = useMemo(() => {
const now = Date.now();
const map = new Map<string, ProbeResult>();
const identities = identityRef.current;
for (const [url, e] of Object.entries(cache)) {
if (now - e.timestamp >= LIVE_PROBE_TTL_MS) continue;
const known = identities.get(url);
const result =
known && known.timestamp === e.timestamp
? known.result
: {
ok: e.ok,
ms: e.ms,
level: e.level,
error: e.error,
codec: e.codec,
timedOut: e.timedOut,
kbps: e.kbps,
};
if (!known || known.timestamp !== e.timestamp) identities.set(url, { timestamp: e.timestamp, result });
map.set(url, result);
}
// 清理已过期频道的身份缓存,避免无界增长
if (identities.size > map.size) {
for (const url of identities.keys()) {
if (!map.has(url)) identities.delete(url);
}
}
return map;
}, [cache]);
const clear = useCallback(() => {
runIdRef.current++;
abortRef.current?.abort();
abortRef.current = null;
useAppStore.getState().clearLiveProbeResults();
setProgress(null);
}, []);
/** 中止在途测活:已完成的结果保留,未完成的频道保持待测状态(下次测活会补上) */
const cancel = useCallback(() => {
if (!abortRef.current) return;
runIdRef.current++;
abortRef.current.abort();
abortRef.current = null;
setProgress(null);
}, []);
const probe = useCallback(
async (targets: { url: string }[]) => {
const allUrls = [...new Set(targets.map((t) => t.url))];
if (allUrls.length === 0) return;
if (allUrls.length > MAX_TARGETS) {
showHint(`频道数超过 ${MAX_TARGETS},仅测前 ${MAX_TARGETS} 个,请精简订阅源`);
}
const urls = allUrls.slice(0, MAX_TARGETS);
// 6 小时内已测过的直接复用,仅补测缺失或过期的频道
const now = Date.now();
const cached = useAppStore.getState().liveProbeResults;
const stale = urls.filter((u) => {
const e = cached[u];
return !e || now - e.timestamp >= LIVE_PROBE_TTL_MS;
});
if (stale.length === 0) {
showHint('测活结果 6 小时内有效,无需重测');
return;
}
const runId = ++runIdRef.current;
// 作废上一轮的在途请求,避免切换筛选/重复点击后旧结果继续写回
abortRef.current?.abort();
const controller = new AbortController();
abortRef.current = controller;
const chunks: string[][] = [];
for (let i = 0; i < stale.length; i += CHUNK_SIZE) {
chunks.push(stale.slice(i, i + CHUNK_SIZE));
}
// startedAt 供 UI 按已完成均速估算剩余时间
const startedAt = Date.now();
setProgress({ done: 0, total: stale.length, startedAt });
let done = 0;
let buffer: Record<string, LiveProbeEntry> = {};
let flushTimer: ReturnType<typeof setTimeout> | null = null;
const flush = () => {
if (flushTimer) {
clearTimeout(flushTimer);
flushTimer = null;
}
if (runIdRef.current !== runId) return;
if (Object.keys(buffer).length > 0) {
const entries = buffer;
buffer = {};
useAppStore.getState().setLiveProbeResults(entries);
}
setProgress({ done: Math.min(done, stale.length), total: stale.length, startedAt });
};
const scheduleFlush = () => {
if (!flushTimer) flushTimer = setTimeout(flush, FLUSH_INTERVAL_MS);
};
let nextChunk = 0;
const worker = async () => {
for (;;) {
if (runIdRef.current !== runId) return;
const index = nextChunk++;
if (index >= chunks.length) return;
const chunk = chunks[index];
const received = new Set<string>();
try {
await api.liveProbeStream(
chunk,
(r) => {
received.add(r.url);
if (runIdRef.current !== runId) return;
buffer[r.url] = {
ok: r.ok,
ms: r.ms,
level: r.level,
error: r.error,
codec: r.codec,
timedOut: r.timedOut,
kbps: r.kbps,
timestamp: Date.now(),
};
done++;
scheduleFlush();
},
controller.signal
);
} catch {
// 整批失败/被取消:不写缓存,保持待测状态以便下次重试
}
// 流中途断开时未返回的目标:只补进度,不写缓存
done += chunk.length - received.size;
flush();
}
};
await Promise.all(
Array.from({ length: Math.min(CHUNK_CONCURRENCY, chunks.length) }, worker)
);
if (flushTimer) clearTimeout(flushTimer);
if (runIdRef.current !== runId) return;
flush();
setProgress(null);
if (abortRef.current === controller) abortRef.current = null;
},
[showHint]
);
return { results, progress, probe, cancel, clear, isProbing: progress !== null, hint };
}