837 lines
20 KiB
JavaScript
837 lines
20 KiB
JavaScript
// 媒体文件管理器 - 微信小程序专用
|
||
// 处理图片、视频、音频、文件的上传、下载、预览、缓存等
|
||
|
||
const apiClient = require('../../../utils/api-client.js');
|
||
|
||
/**
|
||
* 媒体文件管理器
|
||
* 功能：
|
||
* 1. 文件选择和上传
|
||
* 2. 媒体文件预览
|
||
* 3. 文件下载和缓存
|
||
* 4. 文件压缩和优化
|
||
* 5. 云存储管理
|
||
* 6. 文件类型检测
|
||
*/
|
||
class MediaManager {
|
||
constructor() {
|
||
this.isInitialized = false;
|
||
|
||
// 媒体配置
|
||
this.mediaConfig = {
|
||
// 图片配置
|
||
image: {
|
||
maxSize: 10 * 1024 * 1024, // 10MB
|
||
maxCount: 9, // 最多选择9张
|
||
quality: 80, // 压缩质量
|
||
formats: ['jpg', 'jpeg', 'png', 'gif', 'webp'],
|
||
compressWidth: 1080 // 压缩宽度
|
||
},
|
||
|
||
// 视频配置
|
||
video: {
|
||
maxSize: 100 * 1024 * 1024, // 100MB
|
||
maxDuration: 300, // 最长5分钟
|
||
formats: ['mp4', 'mov', 'avi'],
|
||
compressQuality: 'medium'
|
||
},
|
||
|
||
// 音频配置
|
||
audio: {
|
||
maxSize: 20 * 1024 * 1024, // 20MB
|
||
maxDuration: 600, // 最长10分钟
|
||
formats: ['mp3', 'wav', 'aac', 'm4a'],
|
||
sampleRate: 16000
|
||
},
|
||
|
||
// 文件配置
|
||
file: {
|
||
maxSize: 50 * 1024 * 1024, // 50MB
|
||
allowedTypes: ['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'txt', 'zip', 'rar'],
|
||
maxCount: 5
|
||
},
|
||
|
||
// 缓存配置
|
||
cache: {
|
||
maxSize: 200 * 1024 * 1024, // 200MB
|
||
expireTime: 7 * 24 * 60 * 60 * 1000, // 7天
|
||
cleanupInterval: 24 * 60 * 60 * 1000 // 24小时清理一次
|
||
}
|
||
};
|
||
|
||
// 文件缓存
|
||
this.fileCache = new Map();
|
||
|
||
// 上传队列
|
||
this.uploadQueue = [];
|
||
|
||
// 下载队列
|
||
this.downloadQueue = [];
|
||
|
||
// 当前上传任务
|
||
this.currentUploads = new Map();
|
||
|
||
// 缓存统计
|
||
this.cacheStats = {
|
||
totalSize: 0,
|
||
fileCount: 0,
|
||
lastCleanup: 0
|
||
};
|
||
|
||
this.init();
|
||
}
|
||
|
||
// 初始化媒体管理器
|
||
async init() {
|
||
if (this.isInitialized) return;
|
||
|
||
try {
|
||
// 加载文件缓存信息
|
||
await this.loadCacheInfo();
|
||
|
||
// 检查存储权限
|
||
await this.checkStoragePermission();
|
||
|
||
// 启动缓存清理
|
||
this.startCacheCleanup();
|
||
|
||
this.isInitialized = true;
|
||
|
||
} catch (error) {
|
||
console.error('❌ 媒体文件管理器初始化失败:', error);
|
||
}
|
||
}
|
||
|
||
// 📷 ===== 图片处理 =====
|
||
|
||
// 选择图片
|
||
async chooseImages(options = {}) {
|
||
try {
|
||
const {
|
||
count = this.mediaConfig.image.maxCount,
|
||
sizeType = ['compressed', 'original'],
|
||
sourceType = ['album', 'camera']
|
||
} = options;
|
||
|
||
const result = await new Promise((resolve, reject) => {
|
||
wx.chooseImage({
|
||
count: count,
|
||
sizeType: sizeType,
|
||
sourceType: sourceType,
|
||
success: resolve,
|
||
fail: reject
|
||
});
|
||
});
|
||
|
||
// 验证和处理图片
|
||
const processedImages = await this.processImages(result.tempFilePaths);
|
||
|
||
return {
|
||
success: true,
|
||
images: processedImages
|
||
};
|
||
|
||
} catch (error) {
|
||
console.error('❌ 选择图片失败:', error);
|
||
return {
|
||
success: false,
|
||
error: error.errMsg || '选择图片失败'
|
||
};
|
||
}
|
||
}
|
||
|
||
// 处理图片
|
||
async processImages(tempFilePaths) {
|
||
const processedImages = [];
|
||
|
||
for (const tempPath of tempFilePaths) {
|
||
try {
|
||
// 获取图片信息
|
||
const imageInfo = await this.getImageInfo(tempPath);
|
||
|
||
// 检查文件大小
|
||
if (imageInfo.size > this.mediaConfig.image.maxSize) {
|
||
console.warn('⚠️ 图片过大，需要压缩:', imageInfo.size);
|
||
// 压缩图片
|
||
const compressedPath = await this.compressImage(tempPath);
|
||
imageInfo.tempFilePath = compressedPath;
|
||
}
|
||
|
||
// 生成缩略图
|
||
const thumbnailPath = await this.generateThumbnail(imageInfo.tempFilePath);
|
||
|
||
processedImages.push({
|
||
...imageInfo,
|
||
thumbnailPath: thumbnailPath,
|
||
type: 'image',
|
||
status: 'ready'
|
||
});
|
||
|
||
} catch (error) {
|
||
console.error('❌ 处理图片失败:', error);
|
||
}
|
||
}
|
||
|
||
return processedImages;
|
||
}
|
||
|
||
// 获取图片信息
|
||
async getImageInfo(src) {
|
||
return new Promise((resolve, reject) => {
|
||
wx.getImageInfo({
|
||
src: src,
|
||
success: (res) => {
|
||
// 获取文件大小
|
||
wx.getFileInfo({
|
||
filePath: src,
|
||
success: (fileInfo) => {
|
||
resolve({
|
||
...res,
|
||
size: fileInfo.size,
|
||
tempFilePath: src
|
||
});
|
||
},
|
||
fail: () => {
|
||
resolve({
|
||
...res,
|
||
size: 0,
|
||
tempFilePath: src
|
||
});
|
||
}
|
||
});
|
||
},
|
||
fail: reject
|
||
});
|
||
});
|
||
}
|
||
|
||
// 压缩图片
|
||
// 图片压缩处理函数
|
||
compressImage(tempFilePath) {
|
||
return new Promise((resolve, reject) => {
|
||
// 先获取图片信息，用于计算压缩比例
|
||
wx.getImageInfo({
|
||
src: tempFilePath,
|
||
success: (info) => {
|
||
// 根据图片尺寸计算合适的压缩比例
|
||
let quality = 0.6; // 初始质量
|
||
let width = info.width;
|
||
let height = info.height;
|
||
|
||
// 对于过大的图片先缩小尺寸
|
||
if (width > 1000 || height > 1000) {
|
||
const scale = 1000 / Math.max(width, height);
|
||
width = Math.floor(width * scale);
|
||
height = Math.floor(height * scale);
|
||
quality = 0.5; // 大图片适当降低质量
|
||
} else if (width > 500 || height > 500) {
|
||
quality = 0.55; // 中等图片适度压缩
|
||
}
|
||
|
||
// 执行压缩
|
||
wx.compressImage({
|
||
src: tempFilePath,
|
||
quality: quality, // 质量，0-100，这里用0.6表示60%质量
|
||
width: width, // 压缩后的宽度
|
||
height: height, // 压缩后的高度
|
||
success: (res) => {
|
||
resolve(res.tempFilePath);
|
||
},
|
||
fail: (err) => {
|
||
reject(err);
|
||
}
|
||
});
|
||
},
|
||
fail: (err) => {
|
||
reject(err);
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
// 生成缩略图
|
||
async generateThumbnail(src) {
|
||
try {
|
||
// 创建canvas生成缩略图
|
||
const canvas = wx.createOffscreenCanvas({ type: '2d' });
|
||
const ctx = canvas.getContext('2d');
|
||
|
||
// 设置缩略图尺寸
|
||
const thumbnailSize = 200;
|
||
canvas.width = thumbnailSize;
|
||
canvas.height = thumbnailSize;
|
||
|
||
// 加载图片
|
||
const image = canvas.createImage();
|
||
|
||
return new Promise((resolve) => {
|
||
image.onload = () => {
|
||
// 计算绘制尺寸
|
||
const { drawWidth, drawHeight, drawX, drawY } = this.calculateDrawSize(
|
||
image.width,
|
||
image.height,
|
||
thumbnailSize,
|
||
thumbnailSize
|
||
);
|
||
|
||
// 绘制缩略图
|
||
ctx.drawImage(image, drawX, drawY, drawWidth, drawHeight);
|
||
|
||
// 导出为临时文件
|
||
wx.canvasToTempFilePath({
|
||
canvas: canvas,
|
||
success: (res) => {
|
||
resolve(res.tempFilePath);
|
||
},
|
||
fail: () => {
|
||
resolve(src); // 生成失败返回原图
|
||
}
|
||
});
|
||
};
|
||
|
||
image.onerror = () => {
|
||
resolve(src); // 加载失败返回原图
|
||
};
|
||
|
||
image.src = src;
|
||
});
|
||
|
||
} catch (error) {
|
||
console.error('❌ 生成缩略图失败:', error);
|
||
return src;
|
||
}
|
||
}
|
||
|
||
// 计算绘制尺寸
|
||
calculateDrawSize(imageWidth, imageHeight, canvasWidth, canvasHeight) {
|
||
const imageRatio = imageWidth / imageHeight;
|
||
const canvasRatio = canvasWidth / canvasHeight;
|
||
|
||
let drawWidth, drawHeight, drawX, drawY;
|
||
|
||
if (imageRatio > canvasRatio) {
|
||
// 图片更宽，以高度为准
|
||
drawHeight = canvasHeight;
|
||
drawWidth = drawHeight * imageRatio;
|
||
drawX = (canvasWidth - drawWidth) / 2;
|
||
drawY = 0;
|
||
} else {
|
||
// 图片更高，以宽度为准
|
||
drawWidth = canvasWidth;
|
||
drawHeight = drawWidth / imageRatio;
|
||
drawX = 0;
|
||
drawY = (canvasHeight - drawHeight) / 2;
|
||
}
|
||
|
||
return { drawWidth, drawHeight, drawX, drawY };
|
||
}
|
||
|
||
// 🎬 ===== 视频处理 =====
|
||
|
||
// 选择视频
|
||
async chooseVideo(options = {}) {
|
||
try {
|
||
const {
|
||
sourceType = ['album', 'camera'],
|
||
maxDuration = this.mediaConfig.video.maxDuration,
|
||
camera = 'back'
|
||
} = options;
|
||
|
||
const result = await new Promise((resolve, reject) => {
|
||
wx.chooseVideo({
|
||
sourceType: sourceType,
|
||
maxDuration: maxDuration,
|
||
camera: camera,
|
||
success: resolve,
|
||
fail: reject
|
||
});
|
||
});
|
||
|
||
// 验证和处理视频
|
||
const processedVideo = await this.processVideo(result);
|
||
|
||
return {
|
||
success: true,
|
||
video: processedVideo
|
||
};
|
||
|
||
} catch (error) {
|
||
console.error('❌ 选择视频失败:', error);
|
||
return {
|
||
success: false,
|
||
error: error.errMsg || '选择视频失败'
|
||
};
|
||
}
|
||
}
|
||
|
||
// 处理视频
|
||
async processVideo(videoResult) {
|
||
try {
|
||
// 检查文件大小
|
||
if (videoResult.size > this.mediaConfig.video.maxSize) {
|
||
throw new Error('视频文件过大');
|
||
}
|
||
|
||
// 检查时长
|
||
if (videoResult.duration > this.mediaConfig.video.maxDuration) {
|
||
throw new Error('视频时长超出限制');
|
||
}
|
||
|
||
// 生成视频缩略图
|
||
const thumbnailPath = await this.generateVideoThumbnail(videoResult.tempFilePath);
|
||
|
||
return {
|
||
tempFilePath: videoResult.tempFilePath,
|
||
duration: videoResult.duration,
|
||
size: videoResult.size,
|
||
width: videoResult.width,
|
||
height: videoResult.height,
|
||
thumbnailPath: thumbnailPath,
|
||
type: 'video',
|
||
status: 'ready'
|
||
};
|
||
|
||
} catch (error) {
|
||
console.error('❌ 处理视频失败:', error);
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
// 生成视频缩略图
|
||
async generateVideoThumbnail(videoPath) {
|
||
try {
|
||
// 微信小程序暂不支持视频帧提取，使用默认图标
|
||
return null;
|
||
} catch (error) {
|
||
console.error('❌ 生成视频缩略图失败:', error);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
// 📄 ===== 文件处理 =====
|
||
|
||
// 选择文件
|
||
async chooseFile(options = {}) {
|
||
try {
|
||
const {
|
||
count = this.mediaConfig.file.maxCount,
|
||
type = 'all'
|
||
} = options;
|
||
|
||
const result = await new Promise((resolve, reject) => {
|
||
wx.chooseMessageFile({
|
||
count: count,
|
||
type: type,
|
||
success: resolve,
|
||
fail: reject
|
||
});
|
||
});
|
||
|
||
// 验证和处理文件
|
||
const processedFiles = await this.processFiles(result.tempFiles);
|
||
|
||
return {
|
||
success: true,
|
||
files: processedFiles
|
||
};
|
||
|
||
} catch (error) {
|
||
console.error('❌ 选择文件失败:', error);
|
||
return {
|
||
success: false,
|
||
error: error.errMsg || '选择文件失败'
|
||
};
|
||
}
|
||
}
|
||
|
||
// 处理文件
|
||
async processFiles(tempFiles) {
|
||
const processedFiles = [];
|
||
|
||
for (const file of tempFiles) {
|
||
try {
|
||
// 检查文件大小
|
||
if (file.size > this.mediaConfig.file.maxSize) {
|
||
console.warn('⚠️ 文件过大:', file.name, file.size);
|
||
continue;
|
||
}
|
||
|
||
// 检查文件类型
|
||
const fileExtension = this.getFileExtension(file.name);
|
||
if (!this.isAllowedFileType(fileExtension)) {
|
||
console.warn('⚠️ 不支持的文件类型:', fileExtension);
|
||
continue;
|
||
}
|
||
|
||
processedFiles.push({
|
||
tempFilePath: file.path,
|
||
name: file.name,
|
||
size: file.size,
|
||
type: 'file',
|
||
extension: fileExtension,
|
||
status: 'ready'
|
||
});
|
||
|
||
} catch (error) {
|
||
console.error('❌ 处理文件失败:', error);
|
||
}
|
||
}
|
||
|
||
return processedFiles;
|
||
}
|
||
|
||
// 获取文件扩展名
|
||
getFileExtension(fileName) {
|
||
const lastDotIndex = fileName.lastIndexOf('.');
|
||
if (lastDotIndex === -1) return '';
|
||
return fileName.substring(lastDotIndex + 1).toLowerCase();
|
||
}
|
||
|
||
// 检查文件类型是否允许
|
||
isAllowedFileType(extension) {
|
||
return this.mediaConfig.file.allowedTypes.includes(extension);
|
||
}
|
||
|
||
// 📤 ===== 文件上传 =====
|
||
|
||
// 上传文件
|
||
async uploadFile(file, options = {}) {
|
||
try {
|
||
const {
|
||
onProgress,
|
||
onSuccess,
|
||
onError
|
||
} = options;
|
||
|
||
// 生成上传ID
|
||
const uploadId = this.generateUploadId();
|
||
|
||
// 添加到上传队列
|
||
const uploadTask = {
|
||
id: uploadId,
|
||
file: file,
|
||
status: 'uploading',
|
||
progress: 0,
|
||
onProgress: onProgress,
|
||
onSuccess: onSuccess,
|
||
onError: onError
|
||
};
|
||
|
||
this.currentUploads.set(uploadId, uploadTask);
|
||
|
||
// 执行上传
|
||
const result = await this.performUpload(uploadTask);
|
||
|
||
// 移除上传任务
|
||
this.currentUploads.delete(uploadId);
|
||
|
||
return result;
|
||
|
||
} catch (error) {
|
||
console.error('❌ 上传文件失败:', error);
|
||
return {
|
||
success: false,
|
||
error: error.message
|
||
};
|
||
}
|
||
}
|
||
|
||
// 执行上传
|
||
async performUpload(uploadTask) {
|
||
return new Promise((resolve, reject) => {
|
||
const uploadTask_wx = wx.uploadFile({
|
||
url: `${apiClient.baseURL}/api/v1/files/upload`,
|
||
filePath: uploadTask.file.tempFilePath,
|
||
name: 'file',
|
||
header: {
|
||
'Authorization': `Bearer ${wx.getStorageSync('token')}`
|
||
},
|
||
formData: {
|
||
type: uploadTask.file.type,
|
||
name: uploadTask.file.name || 'unknown'
|
||
},
|
||
success: (res) => {
|
||
try {
|
||
const data = JSON.parse(res.data);
|
||
if (data.success) {
|
||
|
||
const result = {
|
||
success: true,
|
||
data: {
|
||
url: data.data.url,
|
||
fileId: data.data.fileId,
|
||
fileName: uploadTask.file.name,
|
||
fileSize: uploadTask.file.size,
|
||
fileType: uploadTask.file.type
|
||
}
|
||
};
|
||
|
||
if (uploadTask.onSuccess) {
|
||
uploadTask.onSuccess(result);
|
||
}
|
||
|
||
resolve(result);
|
||
} else {
|
||
throw new Error(data.error || '上传失败');
|
||
}
|
||
} catch (error) {
|
||
reject(error);
|
||
}
|
||
},
|
||
fail: (error) => {
|
||
console.error('❌ 上传请求失败:', error);
|
||
if (uploadTask.onError) {
|
||
uploadTask.onError(error);
|
||
}
|
||
reject(error);
|
||
}
|
||
});
|
||
|
||
// 监听上传进度
|
||
uploadTask_wx.onProgressUpdate((res) => {
|
||
uploadTask.progress = res.progress;
|
||
|
||
if (uploadTask.onProgress) {
|
||
uploadTask.onProgress({
|
||
progress: res.progress,
|
||
totalBytesSent: res.totalBytesSent,
|
||
totalBytesExpectedToSend: res.totalBytesExpectedToSend
|
||
});
|
||
}
|
||
});
|
||
|
||
// 保存上传任务引用
|
||
uploadTask.wxTask = uploadTask_wx;
|
||
});
|
||
}
|
||
|
||
// 取消上传
|
||
cancelUpload(uploadId) {
|
||
const uploadTask = this.currentUploads.get(uploadId);
|
||
if (uploadTask && uploadTask.wxTask) {
|
||
uploadTask.wxTask.abort();
|
||
this.currentUploads.delete(uploadId);
|
||
|
||
}
|
||
}
|
||
|
||
// 生成上传ID
|
||
generateUploadId() {
|
||
return `upload_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
|
||
}
|
||
|
||
// 📥 ===== 文件下载和缓存 =====
|
||
|
||
// 下载文件
|
||
async downloadFile(url, options = {}) {
|
||
try {
|
||
const {
|
||
fileName,
|
||
onProgress,
|
||
useCache = true
|
||
} = options;
|
||
|
||
// 检查缓存
|
||
if (useCache) {
|
||
const cachedPath = this.getCachedFilePath(url);
|
||
if (cachedPath) {
|
||
|
||
return {
|
||
success: true,
|
||
tempFilePath: cachedPath,
|
||
cached: true
|
||
};
|
||
}
|
||
}
|
||
|
||
// 执行下载
|
||
const result = await this.performDownload(url, { fileName, onProgress });
|
||
|
||
// 缓存文件
|
||
if (result.success && useCache) {
|
||
this.cacheFile(url, result.tempFilePath);
|
||
}
|
||
|
||
return result;
|
||
|
||
} catch (error) {
|
||
console.error('❌ 下载文件失败:', error);
|
||
return {
|
||
success: false,
|
||
error: error.message
|
||
};
|
||
}
|
||
}
|
||
|
||
// 执行下载
|
||
async performDownload(url, options = {}) {
|
||
return new Promise((resolve, reject) => {
|
||
const downloadTask = wx.downloadFile({
|
||
url: url,
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
|
||
resolve({
|
||
success: true,
|
||
tempFilePath: res.tempFilePath,
|
||
cached: false
|
||
});
|
||
} else {
|
||
reject(new Error(`下载失败: ${res.statusCode}`));
|
||
}
|
||
},
|
||
fail: reject
|
||
});
|
||
|
||
// 监听下载进度
|
||
if (options.onProgress) {
|
||
downloadTask.onProgressUpdate((res) => {
|
||
options.onProgress({
|
||
progress: res.progress,
|
||
totalBytesWritten: res.totalBytesWritten,
|
||
totalBytesExpectedToWrite: res.totalBytesExpectedToWrite
|
||
});
|
||
});
|
||
}
|
||
});
|
||
}
|
||
|
||
// 检查存储权限
|
||
async checkStoragePermission() {
|
||
try {
|
||
const storageInfo = wx.getStorageInfoSync();
|
||
|
||
return true;
|
||
} catch (error) {
|
||
console.error('❌ 检查存储权限失败:', error);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 加载缓存信息
|
||
async loadCacheInfo() {
|
||
try {
|
||
const cacheInfo = wx.getStorageSync('mediaCacheInfo') || {};
|
||
this.cacheStats = {
|
||
totalSize: cacheInfo.totalSize || 0,
|
||
fileCount: cacheInfo.fileCount || 0,
|
||
lastCleanup: cacheInfo.lastCleanup || 0
|
||
};
|
||
} catch (error) {
|
||
console.error('❌ 加载缓存信息失败:', error);
|
||
}
|
||
}
|
||
|
||
// 保存缓存信息
|
||
async saveCacheInfo() {
|
||
try {
|
||
wx.setStorageSync('mediaCacheInfo', this.cacheStats);
|
||
} catch (error) {
|
||
console.error('❌ 保存缓存信息失败:', error);
|
||
}
|
||
}
|
||
|
||
// 获取缓存文件路径
|
||
getCachedFilePath(url) {
|
||
const cacheKey = this.generateCacheKey(url);
|
||
return this.fileCache.get(cacheKey);
|
||
}
|
||
|
||
// 缓存文件
|
||
cacheFile(url, filePath) {
|
||
const cacheKey = this.generateCacheKey(url);
|
||
this.fileCache.set(cacheKey, filePath);
|
||
|
||
// 更新缓存统计
|
||
this.cacheStats.fileCount++;
|
||
this.saveCacheInfo();
|
||
}
|
||
|
||
// 生成缓存键
|
||
generateCacheKey(url) {
|
||
// 使用URL的hash作为缓存键
|
||
let hash = 0;
|
||
for (let i = 0; i < url.length; i++) {
|
||
const char = url.charCodeAt(i);
|
||
hash = ((hash << 5) - hash) + char;
|
||
hash = hash & hash; // 转换为32位整数
|
||
}
|
||
return `cache_${Math.abs(hash)}`;
|
||
}
|
||
|
||
// 启动缓存清理
|
||
startCacheCleanup() {
|
||
setInterval(() => {
|
||
this.performCacheCleanup();
|
||
}, this.mediaConfig.cache.cleanupInterval);
|
||
}
|
||
|
||
// 执行缓存清理
|
||
performCacheCleanup() {
|
||
try {
|
||
|
||
const now = Date.now();
|
||
const expireTime = this.mediaConfig.cache.expireTime;
|
||
|
||
// 清理过期缓存
|
||
for (const [key, filePath] of this.fileCache) {
|
||
try {
|
||
const stats = wx.getFileInfo({ filePath });
|
||
if (now - stats.createTime > expireTime) {
|
||
this.fileCache.delete(key);
|
||
// 删除文件
|
||
wx.removeSavedFile({ filePath });
|
||
}
|
||
} catch (error) {
|
||
// 文件不存在，从缓存中移除
|
||
this.fileCache.delete(key);
|
||
}
|
||
}
|
||
|
||
// 更新清理时间
|
||
this.cacheStats.lastCleanup = now;
|
||
this.saveCacheInfo();
|
||
|
||
} catch (error) {
|
||
console.error('❌ 缓存清理失败:', error);
|
||
}
|
||
}
|
||
|
||
// 获取媒体管理器状态
|
||
getStatus() {
|
||
return {
|
||
isInitialized: this.isInitialized,
|
||
uploadCount: this.currentUploads.size,
|
||
cacheStats: { ...this.cacheStats },
|
||
config: this.mediaConfig
|
||
};
|
||
}
|
||
|
||
// 清除所有缓存
|
||
clearAllCache() {
|
||
this.fileCache.clear();
|
||
this.cacheStats = {
|
||
totalSize: 0,
|
||
fileCount: 0,
|
||
lastCleanup: Date.now()
|
||
};
|
||
this.saveCacheInfo();
|
||
|
||
}
|
||
|
||
// 重置管理器
|
||
reset() {
|
||
// 取消所有上传任务
|
||
for (const [uploadId] of this.currentUploads) {
|
||
this.cancelUpload(uploadId);
|
||
}
|
||
|
||
this.clearAllCache();
|
||
}
|
||
}
|
||
|
||
// 创建全局实例
|
||
const mediaManager = new MediaManager();
|
||
|
||
module.exports = mediaManager;
|
||
|