方案一：通过Electron的DownloadItem
- 支持点击链接下载
- 支持输入文件名称和选择下载路径后，手动下载
import { IpcEvents } from '@interfaces/ipc-events'
import { DownLoadFile } from '@interfaces/types'
import { DownloadFileStore, getUniqueFilename } from '@utils/download'
import { app, dialog, ipcMain, session } from 'electron'
import { existsSync, unlinkSync } from 'node:fs'
import { resolve } from 'node:path'
import { v4 as uuidv4 } from 'uuid'
import { WindowsManager } from './windows'
/**
* 设置基于 Electron DownloadItem 的文件下载管理。
* 监听会话的 'will-download' 事件来捕获下载项，
* 并为每个下载项设置事件监听器以跟踪其状态和计算速度。
* 同时注册 IPC 处理程序来控制下载（开始、取消、暂停、恢复）。
*/
export const setupDownloadFileByDownloadItem = () => {
// 存储下载记录的实例
const recordStore = new DownloadFileStore()
// 存储下载项对象的映射，键为下载记录的唯一标识符
const downloadItemMap = new Map<string, Electron.DownloadItem>()
const windowsManager = WindowsManager.getInstance()
const pendingDownloadOptions = new Map<string, { savePath?: string; filename?: string }>()
// 定义一个接口来存储速度计算所需的历史数据
interface SpeedCalculationData {
lastTimestamp: number // 上次采样时间戳 (毫秒)
lastBytesReceived: number // 上次采样时已接收的字节数
// 可以扩展以存储更多历史点用于平滑计算
}
// 使用 Map 来存储每个下载项的速度计算数据
const speedDataMap = new Map<string, SpeedCalculationData>()
/**
* 监听会话的 'will-download' 事件。
* 当一个新的下载请求被发起时，此事件会被触发。
* @param _event - Electron 事件对象
* @param item - Electron DownloadItem 对象，代表当前的下载任务
*/
session.defaultSession.on('will-download', async (_event, item): Promise<boolean | void> => {
const url = item.getURL()
const options = pendingDownloadOptions.get(url)
let savePathToUse = app.getPath('downloads') // 默认保存路径为下载文件夹
let filenameToUse = item.getFilename() // 默认使用服务器提供的文件名
if (options) {
savePathToUse = options.savePath || app.getPath('downloads')
filenameToUse = options.filename || item.getFilename()
}
filenameToUse = getUniqueFilename(savePathToUse, filenameToUse)
const filePath = resolve(savePathToUse, filenameToUse)
item.setSavePath(filePath) // 设置下载文件的保存路径
// 创建一个新的下载记录对象
const record: DownLoadFile.DownloadRecord = {
key: uuidv4(), // 使用 uuid 生成唯一标识符
url, // 获取下载链接
filename: filenameToUse, // 获取文件名
status: 'no-start', // 初始状态为未开始
savePath: savePathToUse, // 获取保存路径 (可能为空，由对话框决定)
fileSize: item.getTotalBytes(), // 获取文件总大小
downloadedBytes: 0, // 已下载字节数初始化为 0
speedBytesPerSecond: 0 // 初始速度为 0
}
// 将新记录添加到存储中
recordStore.addNewDownloadRecord(record)
// 将 DownloadItem 对象存入 Map，方便后续通过 key 查找
downloadItemMap.set(record.key, item)
// 为这个特定的下载项设置事件监听器
setupDownloadEvents(record.key)
sendDownloadRecords()
})
const sendDownloadRecords = () => {
windowsManager.receiveDownloadInfoWindows.forEach((win) => {
win.webContents.send(IpcEvents.SEND_DOWNLOAD_RECORDS, recordStore.downloadRecords)
})
}
ipcMain.handle(IpcEvents.OPEN_FILE_DIALOG, async (_, oldPath?: string) => {
oldPath = oldPath ? oldPath : recordStore.downloadFileDir
const { canceled, filePaths } = await dialog.showOpenDialog({
properties: ['openDirectory', 'createDirectory'],
filters: [
{
name: 'All Files',
extensions: ['*']
}
],
title: '选择保存位置',
defaultPath: oldPath
})
if (canceled || !filePaths || filePaths.length === 0) {
return oldPath
} else {
const newPath = filePaths[0]
recordStore.downloadFileDir = newPath
return newPath
}
})
ipcMain.handle(IpcEvents.GET_DOWNLOAD_RECORDS, () => {
return recordStore.downloadRecords
})
ipcMain.handle(IpcEvents.DELETE_DOWNLOAD, (_event, record: DownLoadFile.DownloadRecord) => {
recordStore.removeDownloadRecord(record.key)
const filePath = record.savePath
if (existsSync(filePath)) {
unlinkSync(filePath)
}
sendDownloadRecords()
return true
})
ipcMain.handle(IpcEvents.DOWNLOAD_FILE, (_event, options: DownLoadFile.DownloadOptions) => {
const { savePath, url, filename } = options
pendingDownloadOptions.set(url, { savePath, filename })
session.defaultSession.downloadURL(url, {})
})
/**
* 为指定 key 的 DownloadItem 设置事件监听器 ('updated' 和 'done')。
* @param key - 下载记录的唯一标识符
*/
const setupDownloadEvents = (key: string) => {
const item = downloadItemMap.get(key)
if (item) {
// 初始化该下载项的速度计算数据
speedDataMap.set(key, {
lastTimestamp: Date.now(),
lastBytesReceived: 0 // 初始为 0
})
/**
* 监听 DownloadItem 的 'updated' 事件。
* 当下载进度更新或状态改变时触发。
* @param _ - Electron 事件对象
* @param state - 下载状态 ('progressing', 'interrupted')
*/
item.on('updated', (_event, state) => {
const record = recordStore.findDownloadRecord(key)
if (!record) return // 安全检查
if (state === 'interrupted') {
// 如果下载被中断，更新记录状态为暂停或取消
const status: DownLoadFile.DownloadRecord['status'] = item.isPaused()
? 'paused'
: 'cancelled'
recordStore.updateDownloadRecord(key, {
status: status,
speedBytesPerSecond: 0, // 中断时速度归零
savePath: item.savePath
})
// 可以选择在此清理 speedDataMap，但如果用户可能恢复，则保留
// speedDataMap.delete(key);
} else if (state === 'progressing') {
// 如果下载正在进行，更新记录的状态、已下载字节数等信息
const currentBytes = item.getReceivedBytes()
const totalBytes = item.getTotalBytes()
const currentTimestamp = Date.now()
let speedBytesPerSecond = 0
const speedData = speedDataMap.get(key)
if (speedData) {
const timeDiffSeconds = (currentTimestamp - speedData.lastTimestamp) / 1000 // 转换为秒
// 避免除以零或负数时间差
if (timeDiffSeconds > 0) {
const bytesDiff = currentBytes - speedData.lastBytesReceived
// 计算瞬时速度 (字节/秒)
speedBytesPerSecond = bytesDiff / timeDiffSeconds
}
// 更新速度计算数据为当前值，供下次计算使用
speedData.lastTimestamp = currentTimestamp
speedData.lastBytesReceived = currentBytes
} else {
// 如果没有速度数据（理论上不应该发生，但做安全检查）
// 重新初始化
speedDataMap.set(key, {
lastTimestamp: currentTimestamp,
lastBytesReceived: currentBytes
})
}
// 更新记录，包括速度
recordStore.updateDownloadRecord(key, {
status: 'progressing',
downloadedBytes: currentBytes,
fileSize: totalBytes, // 文件大小可能在下载过程中更新
speedBytesPerSecond: Math.max(0, Math.round(speedBytesPerSecond)), // 确保非负，并四舍五入为整数 B/s
savePath: item.savePath
})
sendDownloadRecords()
}
})
/**
* 监听 DownloadItem 的 'done' 事件。
* 当下载完成、取消或失败时触发。
*/
item.on('done', (_event, state) => {
// 注意：Electron 30+ 'done' 事件回调签名已更改，包含 state 参数
// state 可能是 'completed', 'cancelled', 'interrupted'
// 为了兼容性和准确性，使用 state 参数
const record = recordStore.findDownloadRecord(key)
console.log(item.getSavePath(), item.getFilename())
if (record) {
let finalStatus: DownLoadFile.DownloadRecord['status'] = 'interrupted' // 默认
if (state === 'completed') {
finalStatus = 'complete'
} else if (state === 'cancelled') {
finalStatus = 'cancelled'
} else {
// 'interrupted' or unknown
finalStatus = 'interrupted'
}
// 根据 DownloadItem 的最终状态更新记录
recordStore.updateDownloadRecord(key, {
status: finalStatus,
downloadedBytes: item.getReceivedBytes(),
fileSize: item.getTotalBytes(),
speedBytesPerSecond: 0 // 完成后速度为 0
})
}
// 下载结束后，从 Maps 中移除对应的引用
downloadItemMap.delete(key)
speedDataMap.delete(key) // 清除速度计算数据
sendDownloadRecords()
recordStore.persistRecords()
})
}
}
/**
* 监听 IPC 事件 IpcEvents.DOWNLOAD_FILE。
* 当渲染进程请求开始下载一个文件时触发。
* @param _event - IPC 事件对象
* @param options - 下载选项，包含 URL
*/
ipcMain.on(IpcEvents.DOWNLOAD_FILE, (_event, options: DownLoadFile.DownloadOptions) => {
// 调用 session 的 downloadURL 方法开始下载
session.defaultSession.downloadURL(options.url)
})
/**
* 处理 IPC 事件 IpcEvents.CANCEL_DOWNLOAD。
* 当渲染进程请求取消一个下载时触发。
* @param _event - IPC 事件对象
* @param key - 要取消的下载记录的唯一标识符
* @returns Promise<boolean> - 操作结果 (总是返回 true)
*/
ipcMain.handle(IpcEvents.CANCEL_DOWNLOAD, async (_event, key: string) => {
const item = downloadItemMap.get(key)
if (item) {
// 调用 DownloadItem 的 cancel 方法取消下载
item.cancel()
}
// 返回操作结果
return true
})
/**
* 处理 IPC 事件 IpcEvents.PAUSE_DOWNLOAD。
* 当渲染进程请求暂停一个下载时触发。
* @param _event - IPC 事件对象
* @param key - 要暂停的下载记录的唯一标识符
*/
ipcMain.handle(IpcEvents.PAUSE_DOWNLOAD, async (_event, key: string) => {
const item = downloadItemMap.get(key)
if (item) {
// 调用 DownloadItem 的 pause 方法暂停下载
item.pause()
}
// 无返回值
})
/**
* 处理 IPC 事件 IpcEvents.RESUME_DOWNLOAD。
* 当渲染进程请求恢复一个下载时触发。
* @param _event - IPC 事件对象
* @param key - 要恢复的下载记录的唯一标识符
*/
ipcMain.handle(IpcEvents.RESUME_DOWNLOAD, async (_event, key: string) => {
const item = downloadItemMap.get(key)
if (item) {
// 如果 DownloadItem 存在，直接调用 resume 方法恢复下载
item.resume()
// 恢复时重置速度计算的基准点，以避免速度突增
const speedData = speedDataMap.get(key)
if (speedData) {
const now = Date.now()
speedData.lastTimestamp = now
speedData.lastBytesReceived = item.getReceivedBytes()
}
return
}
// 如果 DownloadItem 不存在（可能因为应用重启），但记录存在且状态为暂停
const record = recordStore.findDownloadRecord(key)
if (record && !item && record.status === 'paused') {
// 检查本地是否已存在部分下载的文件
const filePath = resolve(record.savePath)
if (existsSync(filePath)) {
// 如果存在，先删除它，然后重新开始下载
unlinkSync(filePath)
}
// 重新调用 session 的 downloadURL 方法开始下载
session.defaultSession.downloadURL(record.url)
}
// 无返回值
})
/**
* 监听 app 的 'before-quit' 事件。
* 在应用退出前，取消所有正在进行的下载任务。
*/
app.on('before-quit', () => {
// 遍历所有 DownloadItem 并调用 cancel 方法
downloadItemMap.forEach((item) => {
item.cancel()
})
// 清理速度数据 Map
speedDataMap.clear()
recordStore.persistRecords()
})
}
方案二：通过worker_thread方案，基于nodejs相关网络库的流式下载
- 拦截默认下载
- 支持手动下载
- 支持应用退出后续传
- 扩展性更强
主进程
// setupDownloadFileV2.ts
import { app, ipcMain, session } from 'electron'
import { IpcEvents } from '@interfaces/ipc-events'
import { DownloadFileStore, DownloadWorkerManager } from '@utils/download'
import type { DownLoadFile } from '@interfaces/types'
import { v4 as uuidV4 } from 'uuid'
import { WindowsManager } from './windows'
import { debounce } from 'lodash'
export async function setupDownloadFileV2() {
await app.whenReady()
const recordStore = new DownloadFileStore()
const downloadWorkerManager = new DownloadWorkerManager()
session.defaultSession.on('will-download', (event, item) => {
// electron的默认下载行为，这里拦截并阻止，使用自定义下载行为
const filename = item.getFilename()
const url = item.getURL()
const savePath = item.savePath || app.getPath('downloads')
handleDownload({ url, savePath, filename: filename })
event.preventDefault()
return false
})
ipcMain.handle(IpcEvents.GET_DOWNLOAD_RECORDS, () => {
return recordStore.downloadRecords
})
// 开启一个下载任务
ipcMain.handle(IpcEvents.DOWNLOAD_FILE, async (_event, options: DownLoadFile.DownloadOptions) => {
handleDownload(options)
})
// 继续下载 todo : 断点续传
ipcMain.handle(IpcEvents.RESUME_DOWNLOAD, async (_event, record: DownLoadFile.DownloadRecord) => {
handleResume(record)
})
// 取消下载
ipcMain.handle(IpcEvents.CANCEL_DOWNLOAD, async (event, record: DownLoadFile.DownloadRecord) => {
const worker = downloadWorkerManager.getWorker(record.key)
if (worker) {
worker.postMessage({ type: 'cancel', data: { key: record.key } })
}
event.sender.send(IpcEvents.SEND_DOWNLOAD_RECORDS, recordStore.downloadRecords)
})
// 暂停下载
ipcMain.handle(IpcEvents.PAUSE_DOWNLOAD, async (_event, record: DownLoadFile.DownloadRecord) => {
const worker = downloadWorkerManager.getWorker(record.key)
if (worker) {
worker.postMessage({ type: 'pause', data: { key: record.key } })
}
})
ipcMain.handle(IpcEvents.DELETE_DOWNLOAD, (_event, record: DownLoadFile.DownloadRecord) => {
const worker = downloadWorkerManager.getWorker(record.key)
if (worker) {
worker.postMessage({ type: 'cancel', data: { key: record.key } })
}
recordStore.removeDownloadRecord(record.key)
WindowsManager.getInstance().receiveDownloadInfoWindows.forEach((window) => {
window.webContents.send(IpcEvents.SEND_DOWNLOAD_RECORDS, recordStore.downloadRecords)
})
})
const messageHandler = debounce((message: DownLoadFile.DownloadFileResult) => {
const { key, ...rest } = message.data
recordStore.updateDownloadRecord(key, rest)
if (message.type === 'progress') {
WindowsManager.getInstance().receiveDownloadInfoWindows.forEach((window) => {
window.webContents.send(IpcEvents.DOWNLOAD_FILE_PROGRESS, message.data)
})
}
if (['error', 'cancelled', 'paused', 'complete'].includes(message.type)) {
downloadWorkerManager.removeWorker(message.data.key)
}
if (['error', 'cancelled', 'paused', 'complete', 'begin'].includes(message.type)) {
WindowsManager.getInstance().receiveDownloadInfoWindows.forEach((window) => {
window.webContents.send(IpcEvents.SEND_DOWNLOAD_RECORDS, recordStore.downloadRecords)
})
}
})
const handleResume = (record: DownLoadFile.DownloadRecord) => {
downloadWorkerManager.createWorker({
action: 'resume',
record
})
downloadWorkerManager.on('message', (message: DownLoadFile.DownloadFileResult) => {
messageHandler(message)
})
}
const handleDownload = (options: DownLoadFile.DownloadOptions) => {
const record: DownLoadFile.DownloadRecord = {
url: options.url,
savePath: options.savePath ?? app.getPath('downloads'),
key: uuidV4(),
filename: options.filename || '',
// 初次创建时，文件大小为0，下载状态为未开始，后续通过网络获取
fileSize: 0,
status: 'no-start',
downloadedBytes: 0
}
recordStore.addNewDownloadRecord(record)
downloadWorkerManager.createWorker({
action: 'download',
record
})
downloadWorkerManager.on('message', (message) => {
messageHandler(message)
})
}
}
worker
import { DownLoadFile } from '@interfaces/types'
import { workerData, parentPort } from 'node:worker_threads'
import axios, { AxiosResponse } from 'axios'
import { basename, dirname, join, parse } from 'node:path'
import { createWriteStream, existsSync, mkdirSync, statSync, unlinkSync } from 'node:fs'
import { IncomingMessage } from 'node:http'
import { EventEmitter } from 'node:events'
class DownloadWorker extends EventEmitter {
private supportsRange = true
private abortCtrl = new AbortController()
private currentState: 'running' | 'paused' | 'cancelled' = 'running'
static DOWN_CHUNK_SIZE = 1024 * 1024
constructor(private record: DownLoadFile.DownloadRecord) {
super()
}
get key() {
return this.record.key
}
get filename() {
return this.record.filename
}
set filename(value: string) {
this.record.filename = value
}
get savePath() {
return this.record.savePath
}
get url() {
return this.record.url
}
get fileSize() {
return this.record.fileSize
}
set fileSize(value: number) {
this.record.fileSize = value
}
get downloadedBytes() {
return this.record.downloadedBytes
}
set downloadedBytes(value: number) {
this.record.downloadedBytes = value
}
async beginDownload() {
try {
this.currentState = 'running'
await this.ensureFileBaseInfo()
await this.download()
} catch (err: any) {
if (axios.isCancel(err)) {
console.log(`Download cancelled for ${this.key}`)
} else {
console.error(`Download failed for ${this.key}:`, err.message)
this.emit('error', err)
}
}
}
cancel() {
if (this.currentState === 'cancelled') {
console.warn(`Download ${this.key} is already cancelled`)
return
}
this.currentState = 'cancelled'
this.abortCtrl.abort()
this.deleteFile()
}
pause() {
if (this.currentState !== 'running') {
console.warn(`Cannot pause download ${this.key}, current state is ${this.currentState}`)
return
}
this.currentState = 'paused'
this.abortCtrl.abort()
}
/**
*
* @description 恢复下载，备用api，为了后续暂停时不退出worker时使用
*/
async resume() {
this.currentState = 'running'
this.abortCtrl = new AbortController()
if (existsSync(this.filePath)) {
this.downloadedBytes = statSync(this.filePath).size
this._download()
} else {
// 如果文件不存在，重新开始下载
await this.beginDownload()
}
}
get filePath() {
return join(this.savePath, this.filename)
}
/**
* @description 删除文件，在取消下载是会调用
*/
deleteFile() {
const filepath = this.filePath
if (existsSync(filepath)) {
unlinkSync(filepath)
}
}
async download() {
const dir = dirname(this.savePath)
const filepath = this.filePath
if (existsSync(dir)) {
mkdirSync(dir, { recursive: true })
}
if (existsSync(filepath)) {
const stats = statSync(filepath)
this.downloadedBytes = stats.size
if (this.downloadedBytes === this.fileSize) {
this.sendComplete()
return
}
// 如果本地文件大于远程文件，可能有问题，从头开始
if (this.downloadedBytes > this.fileSize) {
unlinkSync(filepath)
this.downloadedBytes = 0
}
}
console.log(`Starting/Resuming download for ${this.key} from byte ${this.downloadedBytes}`)
console.log(filepath, this.filename)
this._download()
}
private async _download() {
const writeStream = createWriteStream(this.filePath, {
flags: this.downloadedBytes === 0 ? 'w' : 'a'
})
try {
const response: AxiosResponse<IncomingMessage> = await axios.get(this.url, {
responseType: 'stream',
headers: {
Range: this.supportsRange ? `bytes=${this.downloadedBytes}-` : undefined
},
signal: this.abortCtrl.signal
})
const downloadStream = response.data
downloadStream.on('data', (chunk) => {
if (this.currentState !== 'running') return
this.downloadedBytes += chunk.length
this.sendProgress()
})
downloadStream.on('error', (err) => {
// 尝试关闭写入流
writeStream.destroy(err)
if (this.currentState === 'paused') {
this.sendPaused()
} else if (this.currentState === 'cancelled') {
this.sendCancelled()
} else {
console.error(`Download stream failed for key ${this.key}:`, err.message)
this.sendError(err.message)
}
})
writeStream.on('error', (err) => {
console.error(`Write stream error for key ${this.key}:`, err.message)
if (downloadStream) {
downloadStream.destroy()
}
if (this.currentState === 'paused') {
this.sendPaused()
} else if (this.currentState === 'cancelled') {
this.sendCancelled()
} else {
this.sendError((err as Error).message)
}
})
writeStream.on('finish', () => {
if (this.currentState === 'running') {
console.log(`Download completed for key ${this.key}: ${this.filePath}`)
this.sendComplete()
}
})
downloadStream.pipe(writeStream)
} catch (err: any) {
console.log(`Download failed for key ${this.key}: ${err.message}`)
if (this.currentState === 'paused') {
this.sendPaused()
} else if (this.currentState === 'cancelled') {
this.sendCancelled()
} else {
this.sendError(err.message)
}
}
}
private getFileNameFromContentDispositionOrUrl(
contentDisposition: string | undefined,
url: string
) {
if (contentDisposition) {
let filename = this.extractFilenameFromContentDisposition(contentDisposition)
if (filename) {
return filename
}
}
const filename = this.getFileNameFromUrl(url)
if (filename) {
return filename
}
// 返回默认名称
return Date.now().toString()
}
getFileNameFromUrl(fileUrl: string) {
try {
const parseUrl = new URL(fileUrl)
const pathname = parseUrl.pathname
let filename = basename(pathname)
// 去除可能的末尾 '/'
filename = filename.replace(/\/+$/, '')
// 如果路径是像 /download/123 这样的 ID，basename 可能无扩展名
// 但至少返回它
if (filename) {
return filename
}
return filename
} catch (e) {
console.log('get filename from url error')
}
return null
}
extractFilenameFromContentDisposition(contentDisposition: string): string | null {
// 匹配 filename="..."
const filenameMatch = contentDisposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/i)
if (filenameMatch) {
let filename = filenameMatch[1]
// 移除包裹的引号
if (filename.startsWith('"') && filename.endsWith('"')) {
filename = filename.slice(1, -1)
}
return decodeURIComponent(filename.trim())
}
// 匹配 filename*=UTF-8''...
const encodedFilenameMatch = contentDisposition.match(
/filename[^;=\n]*\*=(?:UTF-8|utf-8)''(.+)/i
)
if (encodedFilenameMatch) {
try {
// URL 解码（处理百分号编码）
return decodeURIComponent(encodedFilenameMatch[1])
} catch (e) {
console.warn('Failed to decode URI component:', encodedFilenameMatch[1])
return null
}
}
return null
}
getUniqueFilename(
directory: string,
filename: string,
suffixTemplate: string = ' (%d)' // 可自定义模板
): string {
const { name, ext } = parse(filename)
let candidate = filename
let counter = 1
while (existsSync(join(directory, candidate))) {
candidate = `${name}${suffixTemplate.replace('%d', counter.toString())}${ext}`
counter++
}
return candidate
}
initFilename(response: AxiosResponse) {
this.filename = this.filename
? this.filename
: this.getFileNameFromContentDispositionOrUrl(
response.headers['content-disposition'],
this.url
)
this.filename = this.getUniqueFilename(this.savePath, this.filename)
}
async ensureFileBaseInfo() {
try {
const response = await axios.head(this.url)
if (response.status >= 200 && response.status < 300) {
this.initFilename(response)
const contentLength = response.headers['content-length']
if (contentLength) {
this.fileSize = Number(contentLength)
this.supportsRange = response.headers['accept-ranges'] === 'bytes'
console.log(
`File size for ${this.key}: ${this.fileSize}, Supports Range: ${this.supportsRange}`
)
this.sendBegin()
} else {
throw new Error('Content-Length header not found in HEAD response')
}
} else if (response.status === 404) {
throw new Error('File not found (404)')
} else {
throw new Error(`Failed to get file info, status: ${response.status}`)
}
} catch (err: any) {
console.warn(`HEAD request failed for ${this.key}, trying GET for headers:`, err.message)
try {
const getResponse = await axios.get(this.url, {
responseType: 'stream'
})
this.initFilename(getResponse)
const contentLength = getResponse.headers['content-length']
if (contentLength) {
this.fileSize = Number(contentLength)
this.supportsRange = getResponse.headers['accept-ranges'] === 'bytes'
console.log(
`(GET fallback) File size for ${this.key}: ${this.fileSize}, Supports Range: ${this.supportsRange}`
)
getResponse.data.destroy()
this.sendBegin()
} else {
getResponse.data.destroy()
throw new Error('Content-Length header not found in GET response (fallback)')
}
} catch (getErr: any) {
console.error(`GET request (fallback) also failed for ${this.key}:`, getErr.message)
throw new Error(
`Could not determine file size: HEAD failed (${err.message}), GET fallback failed (${getErr.message})`
)
}
}
}
sendPaused() {
this.record = { ...this.record, status: 'paused' }
const event: DownLoadFile.DownloadFileResult = {
type: 'paused',
data: this.record
}
this.emit('paused', event)
}
sendCancelled() {
this.record = { ...this.record, status: 'cancelled' }
const event: DownLoadFile.DownloadFileResult = {
type: 'cancelled',
data: this.record
}
this.emit('cancelled', event)
}
sendBegin() {
this.record = { ...this.record, status: 'progressing' }
const event: DownLoadFile.DownloadFileResult = {
type: 'begin',
data: this.record
}
this.emit('begin', event)
}
sendError(err: string) {
this.record = { ...this.record, status: 'error' }
const event: DownLoadFile.DownloadFileResult = {
type: 'error',
data: this.record,
message: err
}
this.emit('error', event)
}
sendComplete() {
this.record = { ...this.record, status: 'complete' }
const event: DownLoadFile.DownloadFileResult = {
type: 'complete',
data: this.record
}
this.emit('complete', event)
}
sendProgress() {
this.record = { ...this.record, status: 'progressing' }
const event: DownLoadFile.DownloadFileResult = {
type: 'progress',
data: this.record
}
this.emit('progress', event)
}
}
;(async (data: DownLoadFile.DownloadFileWorkerData) => {
const { action, record } = data
const downloadWorker = new DownloadWorker(record)
try {
downloadWorker.on('progress', (event: DownLoadFile.DownloadFileResult) => {
parentPort?.postMessage(event)
})
downloadWorker.on('complete', (event: DownLoadFile.DownloadFileResult) => {
parentPort?.postMessage(event)
})
downloadWorker.on('error', (event: DownLoadFile.DownloadFileResult) => {
parentPort?.postMessage(event)
})
downloadWorker.on('paused', (event: DownLoadFile.DownloadFileResult) => {
parentPort?.postMessage(event)
})
downloadWorker.on('cancelled', (event: DownLoadFile.DownloadFileResult) => {
parentPort?.postMessage(event)
})
if (action === 'download') {
downloadWorker.beginDownload()
} else {
downloadWorker.resume()
}
parentPort?.on('message', (event: DownLoadFile.ToDownloadWorkerEvent) => {
if (event.type === 'cancel') {
downloadWorker.cancel()
} else if (event.type === 'pause') {
downloadWorker.pause()
} else if (event.type === 'resume') {
// 由于目前是发生异常则退出该worker所以resume暂时不实现
}
})
} catch (err: any) {
downloadWorker.sendError(err.message || '下载异常')
}
})(workerData as DownLoadFile.DownloadFileWorkerData)