E2E 便携式加密文件导入导出功能

{
  "meta": {
    "name": "原始文件名.jpg",
    "mimeType": "image/jpeg", 
    "size": 123456
  },
  "data": "<base64 encoded file content>"
}

// E2E 便携式加密文件格式常量
const (
    E2EMagicBytes    = "E2EEPAN1" // 8 bytes
    E2EVersion       = 1
    E2ESaltSize      = 16
    E2EPBKDF2Iter    = 100000 // PBKDF2 迭代次数
)
 
// E2EMeta E2E文件内嵌的元数据
type E2EMeta struct {
    Name     string `json:"name"`
    MimeType string `json:"mimeType"`
    Size     int64  `json:"size"`
}
 
// DeriveKeyPBKDF2 使用 PBKDF2-SHA256 从密码派生密钥
func DeriveKeyPBKDF2(password string, salt []byte) []byte {
    return pbkdf2.Key([]byte(password), salt, E2EPBKDF2Iter, KeySize, sha256.New)
}
 
// ExportToE2E 将文件导出为 E2E 便携式加密格式
func ExportToE2E(data []byte, meta E2EMeta, password string) ([]byte, error)
 
// ImportFromE2E 从 E2E 便携式加密文件导入
func ImportFromE2E(e2eData []byte, password string) ([]byte, E2EMeta, error)

// 路由注册
api.POST("/e2e/export/:id", s.exportToE2E)
api.POST("/e2e/import", s.importFromE2E)

/// 导出文件为 E2E 便携式加密格式
Future<ApiResult<Uint8List>> exportToE2E({
  required String fileId,
  required String password,
  void Function(int received, int total)? onProgress,
  CancelToken? cancelToken,
}) async
 
/// 从 E2E 便携式加密文件导入
Future<ApiResult<FileMetadata>> importFromE2E({
  required Uint8List fileData,
  required String password,
  required String targetPath,
  String? filename,
  void Function(int sent, int total)? onProgress,
  CancelToken? cancelToken,
}) async

// 原代码
late OverlayEntry _entry;
 
void show() {
  _entry = OverlayEntry(...);  // 这里才初始化
  ...
}
 
// 但在 showAppToast 中
toast.show();  // 先初始化
_updateToastPositions(overlay);  // 这里访问 _entry，但如果并发可能还没初始化

OverlayEntry? _entry;  // 改为可空类型
 
void _updatePosition(int index) {
  _positionIndex = index;
  _entry?.markNeedsBuild();  // 安全调用
}

String generateRandomFileName(String extension) {
  final random = Random.secure();
  final name = String.fromCharCodes(
    List.generate(8, (_) => random.nextInt(26) + 97), // a-z
  );
  return '$name.$extension';
}

Future<String> getResolvedDownloadDirPath() async {
  if (_downloadDirPath != null && _downloadDirPath!.isNotEmpty) {
    return _downloadDirPath!;  // 自定义路径
  }
  
  // Android: 使用公共下载目录
  if (io.Platform.isAndroid) {
    return '/storage/emulated/0/Download/E2EPan';
  }
  
  // 其他平台: 使用 path_provider
  final downloads = await getDownloadsDirectory();
  if (downloads != null) {
    return '${downloads.path}/E2EPan';
  }
  final docs = await getApplicationDocumentsDirectory();
  return '${docs.path}/E2EPan';
}

metadata := FileMetadata{
    ID:            fileID,
    Name:          e2eMeta.Name,
    Path:          targetPath,  // 指定的目标路径
    Size:          e2eMeta.Size,
    EncryptedSize: encryptedSize,
    IsDir:         false,
    MimeType:      e2eMeta.MimeType,
    CreatedAt:     now,
    UpdatedAt:     now,
}
 
if err := s.updateMetadataIndex(ctx, &metadata); err != nil {
    c.JSON(http.StatusInternalServerError, gin.H{"error": "update metadata failed"})
    return
}

final isDesktop = io.Platform.isWindows || io.Platform.isLinux || io.Platform.isMacOS;
final result = await FilePicker.platform.pickFiles(
  type: FileType.any,
  withData: !isDesktop,  // 桌面端使用 path，移动端使用 bytes
);
 
// 桌面端从文件路径读取
if (isDesktop && pickedFile.path != null) {
  fileBytes = await io.File(pickedFile.path!).readAsBytes();
} else {
  fileBytes = pickedFile.bytes;
}

class _DownloadJob {
  final String id;
  final FileMetadata file;
  final String? localRelativeDir;
  final CancelToken cancelToken;
  
  // 导出相关字段
  final bool isExport;
  final String? exportPassword;
  
  _DownloadJob({
    required this.id,
    required this.file,
    this.localRelativeDir,
    this.isExport = false,
    this.exportPassword,
  }) : cancelToken = CancelToken();
}

void enqueueExport(FileMetadata file, {required String password}) {
  // ... 创建传输记录
  _downloadQueue.add(
    _DownloadJob(
      id: id,
      file: file,
      isExport: true,
      exportPassword: password,
    ),
  );
  _downloadJobs[id] = _downloadQueue.last;
  _tryStartNextDownload();
}

if (job.isExport && job.exportPassword != null) {
  // 导出模式：使用随机文件名
  final fileName = generateRandomFileName('e2e');
  result = await api.exportToE2E(
    fileId: job.file.id,
    password: job.exportPassword!,
    onProgress: onProgress,
    cancelToken: job.cancelToken,
  );
  // 保存到下载目录
  final saveDir = await getResolvedDownloadDirPath();
  await io.File('$saveDir/$fileName').writeAsBytes(result.data!);
} else {
  // 正常下载模式
  result = await api.downloadFile(...);
}

class _ImportJob {
  final String id;
  final Uint8List fileData;
  final String fileName;
  final String password;
  final String targetPath;
  final CancelToken cancelToken;
  // ...
}

final List<_ImportJob> _importQueue = [];
final Map<String, _ImportJob> _importJobs = {};
 
void enqueueImport({...}) { /* 加入队列 */ }
void _tryStartNextImport() { /* 复用上传并发控制 */ }
void _startImportJob(_ImportJob job) { /* 执行导入 */ }

void onProgress(int sent, int total) {
  // 上传阶段占 0-90%，后端处理占 90-100%
  final prog = (sent / total) * 0.9;
  // ...
}
 
// 上传完成后更新为 "处理中" (90%)
_transfers[idx] = _transfers[idx].copyWith(
  status: TransferStatus.finishing,
  progress: 0.9,
);
 
// 后端返回成功后更新为 100%

void cancelTransfer(String id) {
  // 检查上传队列
  // 检查下载队列
  // 检查导入队列（新增）
  final queueImportIdx = _importQueue.indexWhere((j) => j.id == id);
  if (queueImportIdx >= 0) {
    _importQueue.removeAt(queueImportIdx);
    _importJobs.remove(id);
    _updateTransferStatus(id, TransferStatus.cancelled, '已取消');
    return;
  }
  
  // 检查正在运行的任务，调用 cancelToken.cancel()
  final importJob = _importJobs[id];
  if (importJob != null) {
    importJob.cancelToken.cancel();
  }
}

func (s *Server) downloadThumbnail(c *gin.Context) {
  // 检查 S3 是否已有缩略图
  // 如果没有，读取原图，调用 generateThumbnail()，保存后返回
}

Future<void> _generateAndUploadImportedVideoThumbnail(
  Uint8List videoData,
  String fileId,
  String fileName,
) async {
  io.File? tempFile;
  try {
    // 创建临时文件
    final tempDir = await getTemporaryDirectory();
    final ext = fileName.contains('.') ? fileName.split('.').last : 'mp4';
    tempFile = io.File('${tempDir.path}/import_thumb_$fileId.$ext');
    
    // 写入视频数据
    await tempFile.writeAsBytes(videoData);
    
    // 使用统一的缩略图服务生成
    final thumbData = await VideoThumbnailService().generateFromFile(tempFile.path);
    
    if (thumbData != null) {
      await api.uploadThumbnail(fileId, thumbData);
    }
  } finally {
    // 清理临时文件
    if (tempFile != null && await tempFile.exists()) {
      await tempFile.delete();
    }
  }
}

// 导入成功
final importedFile = result.data!;
 
// 视频文件导入后，生成并上传缩略图
if (isVideoFile(importedFile.mimeType, importedFile.name)) {
  _generateAndUploadImportedVideoThumbnail(
    job.fileData,
    importedFile.id,
    importedFile.name,
  );
}
 
// 刷新文件列表
await refreshFiles();

// Before
Future<ApiResult<FileMetadata>> importFromE2E({
  required Uint8List fileData,  // 整个文件在内存
  ...
}) async {
  final formData = FormData.fromMap({
    'file': MultipartFile.fromBytes(fileData, ...),  // 内存副本
  });
}
 
// After
Future<ApiResult<FileMetadata>> importFromE2E({
  required String filePath,  // 只传递路径
  ...
}) async {
  final formData = FormData.fromMap({
    'file': await MultipartFile.fromFile(filePath, ...),  // 流式读取
  });
}

// Before
class _ImportJob {
  final Uint8List fileData;  // ~400MB 在内存
  ...
}
 
// After
class _ImportJob {
  final String filePath;   // 只存路径
  final int fileSize;      // 用于进度显示
  ...
}