443 lines
15 KiB
TypeScript
443 lines
15 KiB
TypeScript
import { fetchApi } from '@/lib/server-api-util';
|
|
import * as BackgroundFetch from 'expo-background-fetch';
|
|
import * as ImageManipulator from 'expo-image-manipulator';
|
|
import * as MediaLibrary from 'expo-media-library';
|
|
import * as TaskManager from 'expo-task-manager';
|
|
import pLimit from 'p-limit';
|
|
import { Alert } from 'react-native';
|
|
|
|
const BACKGROUND_UPLOAD_TASK = 'background-upload-task';
|
|
// 设置最大并发数
|
|
const CONCURRENCY_LIMIT = 3; // 同时最多上传3个文件
|
|
// 获取指定时间范围内的媒体文件
|
|
export const getMediaByDateRange = async (startDate: Date, endDate: Date) => {
|
|
try {
|
|
const { status } = await MediaLibrary.requestPermissionsAsync();
|
|
if (status !== 'granted') {
|
|
console.log('Media library permission not granted');
|
|
return [];
|
|
}
|
|
|
|
// 获取媒体资源
|
|
const media = await MediaLibrary.getAssetsAsync({
|
|
mediaType: ['photo', 'video'],
|
|
first: 100, // 每次最多获取100个
|
|
sortBy: [MediaLibrary.SortBy.creationTime],
|
|
createdAfter: startDate.getTime(),
|
|
createdBefore: endDate.getTime(),
|
|
});
|
|
|
|
return media.assets;
|
|
} catch (error) {
|
|
console.error('Error getting media by date range:', error);
|
|
return [];
|
|
}
|
|
};
|
|
|
|
// 压缩图片
|
|
const compressImage = async (uri: string): Promise<{ uri: string; file: File }> => {
|
|
try {
|
|
const manipResult = await ImageManipulator.manipulateAsync(
|
|
uri,
|
|
[
|
|
{
|
|
resize: {
|
|
width: 1200,
|
|
height: 1200,
|
|
},
|
|
},
|
|
],
|
|
{
|
|
compress: 0.7,
|
|
format: ImageManipulator.SaveFormat.JPEG,
|
|
base64: false,
|
|
}
|
|
);
|
|
|
|
const response = await fetch(manipResult.uri);
|
|
const blob = await response.blob();
|
|
const filename = uri.split('/').pop() || `image_${Date.now()}.jpg`;
|
|
const file = new File([blob], filename, { type: 'image/jpeg' });
|
|
|
|
return { uri: manipResult.uri, file };
|
|
} catch (error) {
|
|
console.error('Error compressing image:', error);
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
// 获取上传URL
|
|
const getUploadUrl = async (file: File, metadata: Record<string, any> = {}): Promise<{ upload_url: string; file_id: string }> => {
|
|
const body = {
|
|
filename: file.name,
|
|
content_type: file.type,
|
|
file_size: file.size,
|
|
metadata: {
|
|
...metadata,
|
|
originalName: file.name,
|
|
fileType: file.type.startsWith('video/') ? 'video' : 'image',
|
|
isCompressed: 'true',
|
|
},
|
|
};
|
|
|
|
return await fetchApi<{ upload_url: string; file_id: string }>("/file/generate-upload-url", {
|
|
method: 'POST',
|
|
body: JSON.stringify(body)
|
|
});
|
|
};
|
|
|
|
// 确认上传
|
|
const confirmUpload = async (file_id: string) => {
|
|
return await fetchApi('/file/confirm-upload', {
|
|
method: 'POST',
|
|
body: JSON.stringify({ file_id })
|
|
});
|
|
};
|
|
|
|
// 新增素材
|
|
const addMaterial = async (file: string, compressFile: string) => {
|
|
await fetchApi('/material', {
|
|
method: 'POST',
|
|
body: JSON.stringify([{
|
|
"file_id": file,
|
|
"preview_file_id": compressFile
|
|
}])
|
|
}).catch((error) => {
|
|
// console.log(error);
|
|
})
|
|
}
|
|
|
|
// 上传文件到URL
|
|
const uploadFile = async (file: File, uploadUrl: string): Promise<void> => {
|
|
console.log('=== Starting file upload ===');
|
|
console.log('File info:', {
|
|
name: file.name,
|
|
type: file.type,
|
|
size: file.size,
|
|
lastModified: file.lastModified
|
|
});
|
|
console.log('Upload URL:', uploadUrl);
|
|
|
|
try {
|
|
const controller = new AbortController();
|
|
const timeoutId = setTimeout(() => {
|
|
console.log('Upload timeout triggered');
|
|
controller.abort();
|
|
}, 30000);
|
|
|
|
console.log('Sending upload request...');
|
|
const startTime = Date.now();
|
|
|
|
const response = await fetch(uploadUrl, {
|
|
method: 'PUT',
|
|
headers: {
|
|
'Content-Type': file.type,
|
|
'x-oss-forbid-overwrite': 'true'
|
|
},
|
|
body: file,
|
|
signal: controller.signal
|
|
});
|
|
|
|
clearTimeout(timeoutId);
|
|
const endTime = Date.now();
|
|
|
|
console.log(`Upload completed in ${endTime - startTime}ms`, {
|
|
status: response.status,
|
|
statusText: response.statusText,
|
|
headers: Object.fromEntries(response.headers.entries())
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const errorText = await response.text().catch(() => '');
|
|
console.error('Upload failed with response:', errorText);
|
|
throw new Error(`Upload failed: ${response.status} ${response.statusText}\n${errorText}`);
|
|
}
|
|
|
|
console.log('Upload successful');
|
|
} catch (error: any) {
|
|
console.error('Upload error details:', {
|
|
name: error.name,
|
|
message: error.message,
|
|
stack: error.stack
|
|
});
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
// 检查并请求媒体库权限
|
|
const checkMediaLibraryPermission = async (): Promise<{ hasPermission: boolean, status?: string }> => {
|
|
try {
|
|
const { status, accessPrivileges } = await MediaLibrary.getPermissionsAsync();
|
|
|
|
// 如果已经授权，直接返回
|
|
if (status === 'granted' && accessPrivileges === 'all') {
|
|
return { hasPermission: true, status };
|
|
}
|
|
|
|
// 如果没有授权，请求权限
|
|
const { status: newStatus, accessPrivileges: newPrivileges } = await MediaLibrary.requestPermissionsAsync();
|
|
const isGranted = newStatus === 'granted' && newPrivileges === 'all';
|
|
|
|
if (!isGranted) {
|
|
console.log('Media library permission not granted or limited access');
|
|
}
|
|
|
|
return {
|
|
hasPermission: isGranted,
|
|
status: newStatus
|
|
};
|
|
} catch (error) {
|
|
console.error('Error checking media library permission:', error);
|
|
return { hasPermission: false };
|
|
}
|
|
};
|
|
|
|
// 处理单个媒体文件上传
|
|
const processMediaUpload = async (asset: MediaLibrary.Asset) => {
|
|
try {
|
|
// 检查权限
|
|
const { hasPermission } = await checkMediaLibraryPermission();
|
|
if (!hasPermission) {
|
|
throw new Error('No media library permission');
|
|
}
|
|
|
|
const isVideo = asset.mediaType === 'video';
|
|
|
|
// 上传原始文件
|
|
const uploadOriginalFile = async () => {
|
|
const response = await fetch(asset.uri);
|
|
const blob = await response.blob();
|
|
const filename = asset.filename ||
|
|
`${isVideo ? 'video' : 'image'}_${Date.now()}_original.${isVideo ? 'mp4' : 'jpg'}`;
|
|
|
|
const mimeType = isVideo ? 'video/mp4' : 'image/jpeg';
|
|
const file = new File([blob], filename, { type: mimeType });
|
|
|
|
console.log("Original file prepared for upload:", file);
|
|
|
|
// 获取上传URL并上传原始文件
|
|
const { upload_url, file_id } = await getUploadUrl(file, {
|
|
originalUri: asset.uri,
|
|
creationTime: asset.creationTime,
|
|
mediaType: isVideo ? 'video' : 'image',
|
|
isCompressed: false
|
|
});
|
|
|
|
await uploadFile(file, upload_url);
|
|
await confirmUpload(file_id);
|
|
console.log(`Successfully uploaded original: ${filename}`);
|
|
return { success: true, file_id };
|
|
};
|
|
|
|
// 上传压缩文件（仅图片）
|
|
const uploadCompressedFile = async () => {
|
|
if (isVideo) return { success: true, file_id: null }; // 视频不压缩
|
|
|
|
try {
|
|
const { file: compressedFile } = await compressImage(asset.uri);
|
|
const filename = asset.filename ?
|
|
`compressed_${asset.filename}` :
|
|
`image_${Date.now()}_compressed.jpg`;
|
|
|
|
console.log("Compressed file prepared for upload:", {
|
|
name: filename,
|
|
size: compressedFile.size,
|
|
type: compressedFile.type
|
|
});
|
|
console.log("compressedFile", compressedFile);
|
|
|
|
// 获取上传URL并上传压缩文件
|
|
const { upload_url, file_id } = await getUploadUrl(compressedFile, {
|
|
originalUri: asset.uri,
|
|
creationTime: asset.creationTime,
|
|
mediaType: 'image',
|
|
isCompressed: true
|
|
});
|
|
|
|
await uploadFile(compressedFile, upload_url);
|
|
await confirmUpload(file_id);
|
|
console.log(`Successfully uploaded compressed: ${filename}`);
|
|
return { success: true, file_id };
|
|
} catch (error) {
|
|
console.error('Error uploading compressed file:', error);
|
|
return { success: false, error };
|
|
}
|
|
};
|
|
|
|
// 同时上传原始文件和压缩文件
|
|
console.log("Asset info:", asset);
|
|
const [originalResult, compressedResult] = await Promise.all([
|
|
uploadOriginalFile(),
|
|
uploadCompressedFile()
|
|
]);
|
|
console.log("originalResult", originalResult);
|
|
console.log("compressedResult", compressedResult);
|
|
addMaterial(originalResult.file_id, compressedResult.file_id)
|
|
return {
|
|
originalSuccess: originalResult.success,
|
|
compressedSuccess: compressedResult.success,
|
|
fileIds: {
|
|
original: originalResult.file_id,
|
|
compressed: compressedResult.file_id
|
|
}
|
|
};
|
|
} catch (error: any) {
|
|
console.error('Error in processMediaUpload:', error);
|
|
if (error.message === 'No media library permission') {
|
|
throw error;
|
|
}
|
|
return {
|
|
originalSuccess: false,
|
|
compressedSuccess: false,
|
|
error
|
|
};
|
|
}
|
|
};
|
|
|
|
// 注册后台任务
|
|
export const registerBackgroundUploadTask = async () => {
|
|
try {
|
|
// 检查是否已注册
|
|
const isRegistered = await TaskManager.isTaskRegisteredAsync(BACKGROUND_UPLOAD_TASK);
|
|
if (isRegistered) {
|
|
await BackgroundFetch.unregisterTaskAsync(BACKGROUND_UPLOAD_TASK);
|
|
}
|
|
|
|
// 注册后台任务
|
|
await BackgroundFetch.registerTaskAsync(BACKGROUND_UPLOAD_TASK, {
|
|
minimumInterval: 15 * 60, // 15分钟
|
|
stopOnTerminate: false, // 应用关闭后继续运行
|
|
startOnBoot: true, // 系统启动后自动运行
|
|
});
|
|
|
|
console.log('Background upload task registered');
|
|
return true;
|
|
} catch (error) {
|
|
console.error('Error registering background task:', error);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// 定义后台任务
|
|
TaskManager.defineTask(BACKGROUND_UPLOAD_TASK, async () => {
|
|
try {
|
|
console.log('Background upload task started');
|
|
|
|
// 检查并请求媒体库权限
|
|
const { hasPermission } = await checkMediaLibraryPermission();
|
|
if (!hasPermission) {
|
|
console.log('Media library permission not granted');
|
|
return BackgroundFetch.BackgroundFetchResult.NoData;
|
|
}
|
|
|
|
// 获取过去24小时内的媒体
|
|
const now = new Date();
|
|
const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
|
|
|
|
const media = await getMediaByDateRange(yesterday, now);
|
|
console.log("media", media);
|
|
|
|
if (media.length === 0) {
|
|
console.log('No media found in the specified time range');
|
|
return BackgroundFetch.BackgroundFetchResult.NoData;
|
|
}
|
|
|
|
console.log(`Found ${media.length} media items to process`);
|
|
|
|
// 创建并发限制器
|
|
const limit = pLimit(CONCURRENCY_LIMIT);
|
|
|
|
// 准备所有上传任务
|
|
const uploadPromises = media.map(item =>
|
|
limit(async () => {
|
|
try {
|
|
await processMediaUpload(item);
|
|
return { success: true, id: item.id };
|
|
} catch (error: any) {
|
|
console.error(`Error processing media ${item.id}:`, error);
|
|
if (error.message === 'No media library permission') {
|
|
throw error; // 权限错误直接抛出
|
|
}
|
|
return { success: false, id: item.id, error };
|
|
}
|
|
})
|
|
);
|
|
|
|
// 等待所有上传任务完成
|
|
const results = await Promise.allSettled(uploadPromises);
|
|
|
|
// 统计结果
|
|
const succeeded = results.filter(r =>
|
|
r.status === 'fulfilled' && r.value.success
|
|
).length;
|
|
const failed = results.length - succeeded;
|
|
|
|
console.log(`Background upload task completed. Success: ${succeeded}, Failed: ${failed}`);
|
|
|
|
// 如果有权限错误，返回失败
|
|
const hasPermissionError = results.some(r =>
|
|
r.status === 'rejected' ||
|
|
(r.status === 'fulfilled' && r.value.error?.message === 'No media library permission')
|
|
);
|
|
|
|
if (hasPermissionError) {
|
|
return BackgroundFetch.BackgroundFetchResult.Failed;
|
|
}
|
|
|
|
return succeeded > 0 ?
|
|
BackgroundFetch.BackgroundFetchResult.NewData :
|
|
BackgroundFetch.BackgroundFetchResult.NoData;
|
|
} catch (error) {
|
|
console.error('Error in background upload task:', error);
|
|
return BackgroundFetch.BackgroundFetchResult.Failed;
|
|
}
|
|
});
|
|
|
|
// 手动触发上传
|
|
export const triggerManualUpload = async (startDate: Date, endDate: Date) => {
|
|
try {
|
|
console.log('Starting manual upload...');
|
|
console.log("startDate", startDate);
|
|
console.log("endDate", endDate);
|
|
|
|
const media = await getMediaByDateRange(startDate, endDate);
|
|
console.log("media", media);
|
|
if (media.length === 0) {
|
|
Alert.alert('提示', '在指定时间范围内未找到媒体文件');
|
|
return [];
|
|
}
|
|
|
|
const results = [];
|
|
|
|
for (const item of media) {
|
|
try {
|
|
const result = await processMediaUpload(item);
|
|
results.push({
|
|
id: item.id,
|
|
originalSuccess: result.originalSuccess,
|
|
compressedSuccess: result.compressedSuccess,
|
|
fileIds: result.fileIds,
|
|
});
|
|
} catch (error) {
|
|
console.error(`Error uploading ${item.filename}:`, error);
|
|
results.push({
|
|
id: item.id,
|
|
originalSuccess: false,
|
|
compressedSuccess: false,
|
|
error: error instanceof Error ? error.message : 'Unknown error',
|
|
});
|
|
}
|
|
}
|
|
|
|
const originalSuccessCount = results.filter(r => r.originalSuccess).length;
|
|
const compressedSuccessCount = results.filter(r => r.compressedSuccess).length;
|
|
Alert.alert('上传完成', `成功上传 ${originalSuccessCount}/${media.length} 个原始文件，${compressedSuccessCount}/${media.length} 个压缩文件`);
|
|
|
|
return results;
|
|
} catch (error) {
|
|
console.error('Error in manual upload:', error);
|
|
Alert.alert('错误', '上传过程中出现错误');
|
|
throw error;
|
|
}
|
|
};
|