406 lines
13 KiB
TypeScript
406 lines
13 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 = 10; // 同时最多上传10个文件
|
|
|
|
// 获取指定时间范围内的媒体文件（包含 EXIF 信息）
|
|
export const getMediaByDateRange = async (startDate: Date, endDate: Date) => {
|
|
console.log("getMediaByDateRange", startDate.getTime(), endDate.getTime());
|
|
|
|
try {
|
|
const { status } = await MediaLibrary.requestPermissionsAsync();
|
|
if (status !== 'granted') {
|
|
return [];
|
|
}
|
|
|
|
// 获取媒体资源
|
|
const media = await MediaLibrary.getAssetsAsync({
|
|
mediaType: ['photo', 'video'],
|
|
first: 10, // 每次最多获取100个
|
|
sortBy: [MediaLibrary.SortBy.creationTime],
|
|
createdAfter: startDate.getTime(),
|
|
createdBefore: endDate.getTime(),
|
|
});
|
|
|
|
console.log("media1111111111", media);
|
|
|
|
// 为每个资源获取完整的 EXIF 信息
|
|
const assetsWithExif = await Promise.all(
|
|
media.assets.map(async (asset) => {
|
|
try {
|
|
if (asset.mediaType === 'photo') {
|
|
const assetInfo = await MediaLibrary.getAssetInfoAsync(asset.id);
|
|
return {
|
|
...asset,
|
|
exif: assetInfo.exif || null,
|
|
location: assetInfo.location || null
|
|
};
|
|
}
|
|
return asset; // 视频不处理 EXIF
|
|
} catch (error) {
|
|
return asset; // 如果获取 EXIF 失败，返回原始资源
|
|
}
|
|
})
|
|
);
|
|
|
|
return assetsWithExif;
|
|
} catch (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) {
|
|
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) => {
|
|
})
|
|
}
|
|
|
|
// 上传文件到URL
|
|
const uploadFile = async (file: File, uploadUrl: string): Promise<void> => {
|
|
return new Promise((resolve, reject) => {
|
|
const xhr = new XMLHttpRequest();
|
|
|
|
xhr.open('PUT', uploadUrl);
|
|
xhr.setRequestHeader('Content-Type', file.type);
|
|
|
|
// 进度监听
|
|
xhr.upload.onprogress = (event) => {
|
|
if (event.lengthComputable) {
|
|
const progress = Math.round((event.loaded / event.total) * 100);
|
|
}
|
|
};
|
|
|
|
xhr.onload = () => {
|
|
if (xhr.status >= 200 && xhr.status < 300) {
|
|
resolve();
|
|
} else {
|
|
reject(new Error(`Upload failed with status ${xhr.status}`));
|
|
}
|
|
};
|
|
|
|
xhr.onerror = () => {
|
|
reject(new Error('Network error during upload'));
|
|
};
|
|
|
|
xhr.send(file);
|
|
});
|
|
};
|
|
|
|
// 检查并请求媒体库权限
|
|
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) {
|
|
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 });
|
|
|
|
// 获取上传URL并上传原始文件
|
|
const { upload_url, file_id } = await getUploadUrl(file, {
|
|
originalUri: asset.uri,
|
|
creationTime: asset.creationTime,
|
|
mediaType: isVideo ? 'video' : 'image',
|
|
isCompressed: false,
|
|
...asset?.exif,
|
|
GPSVersionID: undefined
|
|
});
|
|
|
|
await uploadFile(file, upload_url);
|
|
await confirmUpload(file_id);
|
|
|
|
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`;
|
|
|
|
// 获取上传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);
|
|
return { success: true, file_id };
|
|
} catch (error) {
|
|
return { success: false, error };
|
|
}
|
|
};
|
|
|
|
// 同时上传原始文件和压缩文件
|
|
const [originalResult, compressedResult] = await Promise.all([
|
|
uploadOriginalFile(),
|
|
uploadCompressedFile()
|
|
]);
|
|
|
|
// 添加素材
|
|
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) {
|
|
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, // 系统启动后自动运行
|
|
});
|
|
|
|
return true;
|
|
} catch (error) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// 定义后台任务
|
|
TaskManager.defineTask(BACKGROUND_UPLOAD_TASK, async () => {
|
|
try {
|
|
// 检查并请求媒体库权限
|
|
const { hasPermission } = await checkMediaLibraryPermission();
|
|
if (!hasPermission) {
|
|
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);
|
|
|
|
if (media.length === 0) {
|
|
return BackgroundFetch.BackgroundFetchResult.NoData;
|
|
}
|
|
|
|
// 创建并发限制器
|
|
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) {
|
|
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;
|
|
|
|
// 如果有权限错误，返回失败
|
|
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) {
|
|
return BackgroundFetch.BackgroundFetchResult.Failed;
|
|
}
|
|
});
|
|
|
|
// 手动触发上传
|
|
export const triggerManualUpload = async (startDate: Date, endDate: Date) => {
|
|
try {
|
|
const media = await getMediaByDateRange(startDate, endDate);
|
|
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) {
|
|
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) {
|
|
Alert.alert('错误', '上传过程中出现错误');
|
|
throw error;
|
|
}
|
|
};
|