devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

flutter 文件上传组件和大文件分片上传

作者：小蓝xlanll | 2024-02-21 14:32:47

赞

踩

flutter 文件上传组件和大文件分片上传

文件分片上传

资料

https://www.cnblogs.com/caijinglong/p/11558389.html

使用分段上传来上传和复制对象 - Amazon Simple Storage Service

因为公司使用的是亚马逊的s3桶  下面是查阅资料获得的

亚马逊s3桶的文件上传分片

分段上分为三个步骤：开始上传、上传对象分段，以及在上传所有分段后完成分段上传。在收到完成分段上传请求后，Amazon S3 会利用上传的分段创建对象，然后您可以像在您的存储桶中访问任何其他对象一样访问该对象。

您可以列出所有正在执行的分段上传，或者获取为特定分段上传操作上传的分段列表。以上每个操作都在本节中进行了说明。

分段上传开始

当您发送请求以开始分段上传时，Amazon S3 将返回具有上传 ID 的响应，此 ID 是分段上传的唯一标识符。无论您何时上传分段、列出分段、完成上传或停止上传，您都必须包括此上传 ID。如果您想要提供描述已上传的对象的任何元数据，必须在请求中提供它以开始分段上传。

分段上传

上传分段时，除了指定上传 ID，还必须指定分段编号。您可以选择 1 和 10000 之间的任意分段编号。分段编号在您正在上传的对象中唯一地识别分段及其位置。您选择的分段编号不必是连续序列（例如，它可以是 1、5 和 14）。如果您使用之前上传的分段的同一分段编号上传新分段，则之前上传的分段将被覆盖。

无论您何时上传分段，Amazon S3 都将在其响应中返回实体标签 (ETag) 标头。对于每个分段上传，您必须记录分段编号和 ETag 值。所有对象分段上传的 ETag 值将保持不变，但将为每个分段分配不同的分段号。您必须在随后的请求中包括这些值以完成分段上传。

分段上传完成

完成分段上传时，Amazon S3 通过按升序的分段编号规范化分段来创建对象。如果在开始分段上传请求中提供了任何对象元数据，则 Amazon S3 会将该元数据与对象相关联。成功完成请求后，分段将不再存在。

完成分段上传请求必须包括上传 ID 以及分段编号和相应的 ETag 值的列表。Amazon S3 响应包括可唯一地识别组合对象数据的 ETag。此 ETag 无需成为对象数据的 MD5 哈希。

文件分片基本原理

前端使用插件获取到本地选择的文件，判断文件的大小，超过设置的限制数，就进行大文件分片上传逻辑

第一步

进行文件分片 下面这个方法 返回的是大文件分片后的开始索引和结束索引

  1.  List<List<int>> sliceFileIntoChunks(
  2.       int fileSize, int sliceMinSize, int sliceMaxCount) {
  3.     List<List<int>> slices = [];
  4.     int start = 0;
  5.  
  6.     while (start < fileSize) {
  7.       int end = start + sliceMinSize;
  8.       if (end > fileSize || slices.length + 1 >= sliceMaxCount) {
  9.         end = fileSize;
  10.       }
  11.       slices.add([start, end]);
  12.       start = end;
  13.     }
  14.  
  15.     return slices;
  16.   }

第二步

将分片信息 生成新的配置对象 配置对象会导出 分片的json

List<SliceChunkItem> config = await utils.getJsonFromSplitFileIntoChunks();
  1. // 切片项
  2. class SliceChunkItem {
  3.   // 切片所在文件的位置
  4.   final int start;
  5.   final int end;
  6.   final int partNumber;
  7.   String uploadId = "";
  8.   String tag = "";
  9.   String checksum = "";
  10.   List<int> fileBytes = [];
  11.   MultipartFile? multipartFile;
  12.  
  13.   SliceChunkItem({
  14.     required this.start,
  15.     required this.end,
  16.     required this.partNumber,
  17.   });
  18.  
  19.   setUploadId(id) {
  20.     uploadId = id;
  21.   }
  22.  
  23.   setTag(id) {
  24.     tag = id;
  25.   }
  26.  
  27.   Map<String, dynamic> toJson() {
  28.     return {
  29.       "partNumber": partNumber,
  30.       "tag": tag,
  31.       "checksum": checksum,
  32.     };
  33.   }
  34.  
  35.   List<int> toClunk() {
  36.     return fileBytes;
  37.   }
  38. }

第三步

接口发送，分为三个接口，第一个为初始化接口、第二个为分片上传接口、第三个为文件合成接口(因为需求原因 希望存的是一个完整的文件，且不做分片下载功能)

第一个接口 传递了文件名 和加密的类型 因为是亚马逊 hashMethod= SHA1

String fileName = file.path.split('/').last;
  1.   final aa = await multipartUploadInit(
  2.   fileName: fileName, checksumType: FileUtils.hashMethod);

第二个接口 因为需要并发去发分片 

分片使用FormData进行存 其他信息也加在FormData中

  1. static multipartUpload({
  2.     required FormData formData,
  3.   }) async {
  4.     final res = await dio.post(
  5.       Url.multipartUpload,
  6.       data: formData,
  7.       options: Options(
  8.         method: "post",
  9.         contentType: "multipart/form-data",
  10.         sendTimeout: const Duration(days: 5),
  11.         receiveTimeout: const Duration(days: 5),
  12.       ),
  13.     );
  14.     return res.data;
  15.   }
  1.   // 同时对分片进行并发
  2.   Future sendItems({
  3.     required List<SliceChunkItem> config,
  4.     required int concurrentLimit,
  5.     required Function(SliceChunkItem) callback,
  6.   }) async {
  7.     return await Future.wait(config.map((item) async {
  8.       // 判断是否需要取消请求
  9.       if (cancelCompleter.isCompleted) {
  10.         throw 'Requests are cancelled';
  11.       }
  12.  
  13.       // 控制并发数量
  14.       while (count >= concurrentLimit) {
  15.         await Future.delayed(const Duration(milliseconds: 100));
  16.       }
  17.       count++;
  18.       try {
  19.         await callback(item);
  20.       } finally {
  21.         count--;
  22.       }
  23.     }));
  24.   }

使用

  1.     await utils.sendItems(
  2.         config: config,
  3.         concurrentLimit: 5,
  4.         callback: (item) async {
  5.           item.setUploadId(uploadId);
  6.           "[分片上传] bb 开始上传 partNumber ${item.partNumber} ".w();
  7.           var fileBytes = await utils.getRange(item.start, item.end);
  8.           item.checksum = utils.calculateSHA1FormList(fileBytes);
  9.           // 直接传递数组fileBytes 给dio 会导致内存崩溃
  10.           formData = FormData.fromMap({
  11.             'file': MultipartFile.fromBytes(fileBytes, filename: "11"),
  12.             'partNumber': item.partNumber,
  13.             'checksum': item.checksum,
  14.             'uploadId': item.uploadId,
  15.           });
  16.           final b = await multipartUpload(formData: formData);
  17.           finalUploadSliceCount++;
  18.           onSendProgress?.call(finalUploadSliceCount, config.length);
  19.           "[分片上传] bb 结束上传 partNumber ${item.partNumber} $b".w();
  20.           String tag = b["data"]["tag"];
  21.           item.setTag(tag);
  22.         });

第三个接口

  1.   final cc = await multipartUploadComplete(
  2.       // checksum: checksum,
  3.       uploadId: uploadId,
  4.       partList: config.map((e) => e.toJson()).toList(),
  5.     );

大文件加载到内存问题

1、读大文件的时候

去拿文件的句柄 然后通过移动获取不同的文件段

file.openRead();

2、读取后存储问题

如果将获取的分片数据直接存到一个类里面，这样的操作会导致内存被撑爆，

必须发送接口的时候再进行 文件指针方式进行文件数据读取 然后发送接口后直接释放

所有分片上传的接口 做了 读取大文件分片数据的逻辑操作

3、对大文件分片 进行哈希计算

错误代码示范

  1.  // ShA 1 进行文件哈希
  2.   Future<String> calculateSHA1() async {
  3.     if (await file.exists()) {
  4.       List<int> contents = await file.readAsBytes();
  5.       Digest sha1Result = sha1.convert(contents);
  6.       return sha1Result.toString();
  7.     } else {
  8.       throw const FileSystemException('File not found');
  9.     }
  10.   }

修改后的代码 (对内存基本没影响)

  1.  Future<String> calculateSHA1() async {
  2.     if (await file.exists()) {
  3.       Digest value = await sha1.bind(file.openRead()).first;
  4.       return value.toString();
  5.     } else {
  6.       throw const FileSystemException('File not found');
  7.     }
  8.   }

出现的问题 （就是内存被撑爆的原因）

E/DartVM (24105): Exhausted heap space, trying to allocate 67108872 bytes. E/flutter (24105): [ERROR:flutter/runtime/dart_vm_initializer.cc(41)] Unhandled Exception: Out of Memory

出现问题的地方 (分片完成后 直接加载每个分片到内存中了 所有导致内容崩溃)

如下面代码 将获得的分片数据 存在了内存中 ，如果文件过大 就会被撑爆

  1. Future<List<SliceChunkItem>> getJsonFromSplitFileIntoChunks() async {
  2.     List<SliceChunkItem> sliceChunkList = [];
  3.     // int i = 0;
  4.     int partNumber = 1;
  5.     // List<int> chunks = splitFileIntoChunks();
  6.     // for (var v in chunks) {
  7.     //   sliceChunkList.add(
  8.     //     SliceChunkItem(
  9.     //       start: i,
  10.     //       end: v + i,
  11.     //       fileBytes: await getRange(i, v + i),
  12.     //       partNumber: partNumber,
  13.     //     ),
  14.     //   );
  15.     //   i = v;
  16.     //   partNumber++;
  17.     // }
  18.  
  19.     List<List<int>> chunks =
  20.         sliceFileIntoChunks(file.lengthSync(), sliceMinSize, sliceMaxCount);
  21.     "[分片上传] ${chunks.length}".w();
  22.     for (List<int> v in chunks) {
  23.       sliceChunkList.add(
  24.         SliceChunkItem(
  25.           start: v[0],
  26.           end: v[1],
  27.           fileBytes: await getRange(v[0], v[1]),
  28.           partNumber: partNumber,
  29.         ),
  30.       );
  31.       partNumber++;
  32.     }
  33.  
  34.     return sliceChunkList;
  35.   }

修改如下

发送的时候 再去进行获取 fileBytes 和 checksum;

完整代码如下

大文件上传工具类

  1. import 'dart:async';
  2. import 'dart:convert';
  3. import 'dart:io';
  4.  
  5. import 'package:LS/common/extension/custom_ext.dart';
  6. import 'package:crypto/crypto.dart';
  7. import 'package:dio/dio.dart';
  8.  
  9. class MyCompleter<T> {
  10.   MyCompleter();
  11.   Completer<T> completer = Completer();
  12.  
  13.   Future<T> get future => completer.future;
  14.  
  15.   void reply(T result) {
  16.     if (!completer.isCompleted) {
  17.       completer.complete(result);
  18.     }
  19.   }
  20. }
  21.  
  22. class FileUtils {
  23.   File file;
  24.  
  25.   // 文件哈希
  26.   String hash = "";
  27.  
  28.   static String hashMethod = "SHA1";
  29.  
  30.   // 每个切片最小的大小
  31.   int sliceMinSize = 1024 * 1024 * 10; // 10MB
  32.  
  33.   // 最大的切片数量
  34.   int sliceMaxCount = 10000;
  35.  
  36.   // 限制并发数量的计数器
  37.   int count = 0;
  38.  
  39.   // 用于取消请求的Completer
  40.   final cancelCompleter = Completer<void>();
  41.  
  42.   FileUtils(this.file) {
  43.     // 后端改动不需要l
  44.     // // 默认后台进行文件求哈希
  45.     // backstageCalculateSHA1();
  46.   }
  47.  
  48.   // 读取文件的某个范围返回
  49.   Future<List<int>> getRange(int start, int end) async {
  50.     if (start < 0) {
  51.       throw RangeError.range(start, 0, file.lengthSync());
  52.     }
  53.     if (end > file.lengthSync()) {
  54.       throw RangeError.range(end, 0, file.lengthSync());
  55.     }
  56.     final c = MyCompleter<List<int>>();
  57.     List<int> result = [];
  58.     file.openRead(start, end).listen((data) {
  59.       result.addAll(data);
  60.     }).onDone(() {
  61.       c.reply(result);
  62.     });
  63.     return c.future;
  64.   }
  65.  
  66.   Stream<List<int>> getRangeStream(int start, int end) {
  67.     if (start < 0) {
  68.       throw RangeError.range(start, 0, file.lengthSync());
  69.     }
  70.     if (end > file.lengthSync()) {
  71.       throw RangeError.range(end, 0, file.lengthSync());
  72.     }
  73.     return file.openRead(start, end);
  74.   }
  75.  
  76.   // 读取文件的前n个字节返回
  77.   List<int> splitFileIntoChunks() {
  78.     final size = file.lengthSync();
  79.     int chunkSize = size ~/ sliceMaxCount;
  80.     chunkSize = chunkSize < sliceMinSize ? sliceMinSize : chunkSize;
  81.  
  82.     List<int> chunkSizes = [];
  83.     int currentPosition = 0;
  84.  
  85.     while (currentPosition < size) {
  86.       int remainingSize = size - currentPosition;
  87.       int currentChunkSize =
  88.           remainingSize > chunkSize ? chunkSize : remainingSize;
  89.       chunkSizes.add(currentChunkSize);
  90.       currentPosition += currentChunkSize;
  91.     }
  92.     return chunkSizes;
  93.   }
  94.  
  95.   List<List<int>> sliceFileIntoChunks(
  96.       int fileSize, int sliceMinSize, int sliceMaxCount) {
  97.     List<List<int>> slices = [];
  98.     int start = 0;
  99.  
  100.     while (start < fileSize) {
  101.       int end = start + sliceMinSize;
  102.       if (end > fileSize || slices.length + 1 >= sliceMaxCount) {
  103.         end = fileSize;
  104.       }
  105.       slices.add([start, end]);
  106.       start = end;
  107.     }
  108.  
  109.     return slices;
  110.   }
  111.  
  112.   Future<List<SliceChunkItem>> getJsonFromSplitFileIntoChunks() async {
  113.     List<SliceChunkItem> sliceChunkList = [];
  114.     int partNumber = 1;
  115.     List<List<int>> chunks =
  116.         sliceFileIntoChunks(file.lengthSync(), sliceMinSize, sliceMaxCount);
  117.     "[分片上传] 当前分片 ${chunks.length}".w();
  118.  
  119.     for (List<int> v in chunks) {
  120.       sliceChunkList.add(
  121.         SliceChunkItem(
  122.           start: v[0],
  123.           end: v[1],
  124.           partNumber: partNumber,
  125.         ),
  126.       );
  127.       partNumber++;
  128.     }
  129.  
  130.     return sliceChunkList;
  131.   }
  132.  
  133.   // 将M 单位转为基本单位字节
  134.   static int mToSize(int m) {
  135.     return 1024 * 1024 * m;
  136.   }
  137.  
  138.   // ShA 1 进行文件哈希
  139.   Future<String> calculateSHA1(Stream<List<int>> stream) async {
  140.     Digest digest = await sha1.bind(stream).first;
  141.     return base64.encode(digest.bytes);
  142.   }
  143.  
  144.   // 将数组数据重新组合成文件
  145.  
  146.   ///
  147.   /// 测试使用 将分片合成一个文件 写到本地
  148.   // String appDocDir = (await getDownloadsDirectory())?.path ?? "";
  149.   // String filePath = '$appDocDir/new.zip';
  150.  
  151.   // await FileUtils.mergeChunksIntoFile(
  152.   //     config.map((e) => e.toClunk()).toList(), filePath);
  153.   static Future<void> mergeChunksIntoFile(
  154.       List<List<int>> chunks, String outputPath) async {
  155.     File outputFile = File(outputPath);
  156.     outputFile.createSync();
  157.     IOSink output = outputFile.openWrite(mode: FileMode.writeOnlyAppend);
  158.     "将数组数据重新组合成文件 a".w();
  159.     for (List<int> chunk in chunks) {
  160.       output.add(chunk);
  161.       "将数组数据重新组合成文件 b".w();
  162.     }
  163.     "将数组数据重新组合成文件 c".w();
  164.  
  165.     await output.close();
  166.   }
  167.  
  168.   String calculateSHA1FormList(List<int> data) {
  169.     Digest digest = sha1.convert(data);
  170.     return base64.encode(digest.bytes);
  171.   }
  172.  
  173.   static String staticCalculateSHA1FormList(List<int> data) {
  174.     Digest digest = sha1.convert(data);
  175.     return base64.encode(digest.bytes);
  176.   }
  177.  
  178.   // 后台进行对文件的哈希
  179.   // backstageCalculateSHA1() async {
  180.   //   hash = await calculateSHA1();
  181.   //   return hash;
  182.   // }
  183.  
  184.   // 同时对分片进行并发
  185.   Future sendItems({
  186.     required List<SliceChunkItem> config,
  187.     required int concurrentLimit,
  188.     required Function(SliceChunkItem) callback,
  189.   }) async {
  190.     return await Future.wait(config.map((item) async {
  191.       // 判断是否需要取消请求
  192.       if (cancelCompleter.isCompleted) {
  193.         throw 'Requests are cancelled';
  194.       }
  195.  
  196.       // 控制并发数量
  197.       while (count >= concurrentLimit) {
  198.         await Future.delayed(const Duration(milliseconds: 100));
  199.       }
  200.       count++;
  201.       try {
  202.         await callback(item);
  203.       } finally {
  204.         count--;
  205.       }
  206.     }));
  207.   }
  208.  
  209.   // 取消所有请求
  210.   cancelSendItems() {
  211.     if (!cancelCompleter.isCompleted) {
  212.       cancelCompleter.complete();
  213.     }
  214.     count = 0;
  215.     "[切片上传] 取消并发成功".w();
  216.   }
  217. }
  218.  
  219. // 切片项
  220. class SliceChunkItem {
  221.   // 切片所在文件的位置
  222.   final int start;
  223.   final int end;
  224.   final int partNumber;
  225.   String uploadId = "";
  226.   String tag = "";
  227.   String checksum = "";
  228.   List<int> fileBytes = [];
  229.   MultipartFile? multipartFile;
  230.  
  231.   SliceChunkItem({
  232.     required this.start,
  233.     required this.end,
  234.     required this.partNumber,
  235.   });
  236.  
  237.   setUploadId(id) {
  238.     uploadId = id;
  239.   }
  240.  
  241.   setTag(id) {
  242.     tag = id;
  243.   }
  244.  
  245.   Map<String, dynamic> toJson() {
  246.     return {
  247.       "partNumber": partNumber,
  248.       "tag": tag,
  249.       "checksum": checksum,
  250.     };
  251.   }
  252.  
  253.   List<int> toClunk() {
  254.     return fileBytes;
  255.   }
  256. }

分片上传总接口

  1.   // 文件分片上传
  2.   static uploadSliceFile(
  3.     String path, {
  4.     ProgressCallback? onSendProgress,
  5.     required Function(FileUtils) getFileUtils,
  6.   }) async {
  7.     File file = File(path);
  8.  
  9.     String fileName = file.path.split('/').last;
  10.     final utils = FileUtils(file);
  11.     getFileUtils.call(utils);
  12.     List<SliceChunkItem> config = await utils.getJsonFromSplitFileIntoChunks();
  13.  
  14.     final aa = await multipartUploadInit(
  15.         fileName: fileName, checksumType: FileUtils.hashMethod);
  16.     String uploadId = aa['data']['uploadId'];
  17.     "[分片上传] aa $aa".w();
  18.  
  19.     int finalUploadSliceCount = 0;
  20.  
  21.     FormData formData;
  22.     // for (SliceChunkItem item in config) {
  23.     //   item.setUploadId(uploadId);
  24.     //   "[分片上传] bb 开始上传 partNumber ${item.partNumber} ".w();
  25.     //   var fileBytes = await utils.getRange(item.start, item.end);
  26.     //   item.checksum = utils.calculateSHA1FormList(fileBytes);
  27.     //   // 直接传递数组fileBytes 给dio 会导致内存崩溃
  28.     //   formData = FormData.fromMap({
  29.     //     'file': MultipartFile.fromBytes(fileBytes, filename: "11"),
  30.     //     'partNumber': item.partNumber,
  31.     //     'checksum': item.checksum,
  32.     //     'uploadId': item.uploadId,
  33.     //   });
  34.     //   final b = await multipartUpload(formData: formData);
  35.     //   finalUploadSliceCount++;
  36.     //   onSendProgress?.call(finalUploadSliceCount, config.length);
  37.     //   "[分片上传] bb 结束上传 partNumber ${item.partNumber} $b".w();
  38.     //   String tag = b["data"]["tag"];
  39.     //   item.setTag(tag);
  40.     // }
  41.     await utils.sendItems(
  42.         config: config,
  43.         concurrentLimit: 5,
  44.         callback: (item) async {
  45.           item.setUploadId(uploadId);
  46.           "[分片上传] bb 开始上传 partNumber ${item.partNumber} ".w();
  47.           var fileBytes = await utils.getRange(item.start, item.end);
  48.           item.checksum = utils.calculateSHA1FormList(fileBytes);
  49.           // 直接传递数组fileBytes 给dio 会导致内存崩溃
  50.           formData = FormData.fromMap({
  51.             'file': MultipartFile.fromBytes(fileBytes, filename: "11"),
  52.             'partNumber': item.partNumber,
  53.             'checksum': item.checksum,
  54.             'uploadId': item.uploadId,
  55.           });
  56.           final b = await multipartUpload(formData: formData);
  57.           finalUploadSliceCount++;
  58.           onSendProgress?.call(finalUploadSliceCount, config.length);
  59.           "[分片上传] bb 结束上传 partNumber ${item.partNumber} $b".w();
  60.           String tag = b["data"]["tag"];
  61.           item.setTag(tag);
  62.         });
  63.  
  64.     // 废弃 后端不需要整体文件的hash
  65.     // String checksum = utils.hash;
  66.     // if (checksum.isEmpty) {
  67.     //   checksum = await utils.backstageCalculateSHA1();
  68.     // }
  69.  
  70.     final cc = await multipartUploadComplete(
  71.       // checksum: checksum,
  72.       uploadId: uploadId,
  73.       partList: config.map((e) => e.toJson()).toList(),
  74.     );
  75.  
  76.     // String filePath = cc["data"]["file_path"];
  77.  
  78.     "[分片上传] cc $cc".w();
  79.     return cc;
  80.   }

文件上传组件代码

  1. import 'dart:io';
  2.  
  3. import 'package:LS/common/index.dart';
  4. import 'package:LS/gen/assets.gen.dart';
  5. import 'package:cached_network_image/cached_network_image.dart';
  6. import 'package:file_picker/file_picker.dart';
  7. import 'package:flutter/foundation.dart';
  8. import 'package:flutter/material.dart';
  9. import 'package:flutter_screenutil/flutter_screenutil.dart';
  10. import 'package:get/get.dart';
  11. import 'package:image_picker/image_picker.dart';
  12.  
  13. enum UploadType {
  14.   image,
  15.   file,
  16. }
  17.  
  18. class UploadWidget extends StatefulWidget {
  19.   final UploadType type;
  20.   final Function(String, int)? onSuccess;
  21.   final Function(int, List, UploadType)? onDelete;
  22.   final Function()? onPickAssets;
  23.   final List<String>? allowedExtensions;
  24.   final int? limit;
  25.  
  26.   const UploadWidget({
  27.     super.key,
  28.     this.type = UploadType.image,
  29.     this.onSuccess,
  30.     this.onDelete,
  31.     this.limit,
  32.     this.onPickAssets,
  33.     this.allowedExtensions,
  34.   });
  35.  
  36.   @override
  37.   State<UploadWidget> createState() => _UploadWidgetState();
  38. }
  39.  
  40. class _UploadWidgetState extends State<UploadWidget> {
  41.   // 这两个是上传图片的时候存的
  42.   List<Uint8List> webImageList = [];
  43.   List<File> appImageList = [];
  44.  
  45.   // 这两个是上传文件的时候存的 文件上传只有 接口上传的时候 有不同所有只要一个
  46.   List<FilePickerResult> filesList = [];
  47.   FilePickerResult? files;
  48.  
  49.   Widget get curContain {
  50.     switch (widget.type) {
  51.       case UploadType.image:
  52.         return uploadImage();
  53.       case UploadType.file:
  54.         return uploadFile();
  55.     }
  56.   }
  57.  
  58.   onPreview(String url) {
  59.     if (url.isNotEmpty) {
  60.       Get.to(
  61.         () => ImagePreviewPage(
  62.           imageUrl: url,
  63.         ),
  64.       );
  65.     }
  66.   }
  67.  
  68.   //   选择图片
  69.   pickImages() async {
  70.     Uint8List? webImage;
  71.     File? appImage;
  72.     XFile? image = await AppToast.getLostData();
  73.     if (image != null) {
  74.       if (kIsWeb) {
  75.         webImage = await image.readAsBytes();
  76.       } else {
  77.         appImage = File(image.path);
  78.       }
  79.     }
  80.     if (webImage != null) {
  81.       webImageList.add(webImage);
  82.     }
  83.     if (appImage != null) {
  84.       appImageList.add(appImage);
  85.     }
  86.     widget.onPickAssets?.call();
  87.     setState(() {});
  88.   }
  89.  
  90.   bool isValidExtension(FilePickerResult files) {
  91.     return files.files.every((file) {
  92.       String extension = (file.extension ?? "").toLowerCase();
  93.       return (widget.allowedExtensions ??
  94.               [
  95.                 'jpg',
  96.                 'png',
  97.                 'doc',
  98.                 'xls',
  99.                 'pdf',
  100.                 'ppt',
  101.                 'docx',
  102.                 'xlsx',
  103.                 'pptx'
  104.               ])
  105.           .contains(extension);
  106.     });
  107.   }
  108.  
  109.   // 选择文件
  110.   pickFiles() async {
  111.     files = await AppToast.getLostFileData(
  112.       allowMultiple: false,
  113.       allowedExtensions: (widget.allowedExtensions ??
  114.           ['jpg', 'png', 'doc', 'xls', 'pdf', 'ppt', 'docx', 'xlsx', 'pptx']),
  115.     );
  116.     if (files != null) {
  117.       if (!isValidExtension(files as FilePickerResult)) {
  118.         AppToast.show("请选择正确的文件格式");
  119.         return;
  120.       }
  121.       filesList.add(files!);
  122.       widget.onPickAssets?.call();
  123.       setState(() {});
  124.     }
  125.   }
  126.  
  127.   // 上传图片
  128.   Widget uploadImage() {
  129.     return SizedBox(
  130.       width: double.infinity,
  131.       child: GridView.builder(
  132.         physics: const NeverScrollableScrollPhysics(),
  133.         shrinkWrap: true,
  134.         gridDelegate: const SliverGridDelegateWithFixedCrossAxisCount(
  135.           crossAxisCount: 4,
  136.           crossAxisSpacing: 10,
  137.           mainAxisSpacing: 10,
  138.           childAspectRatio: 1,
  139.         ),
  140.         // +1 是为了添加图片按钮
  141.         itemCount: widget.limit != null &&
  142.                 widget.limit! <=
  143.                     (kIsWeb ? webImageList.length : appImageList.length)
  144.             ? (kIsWeb ? webImageList.length : appImageList.length)
  145.             : (kIsWeb ? webImageList.length : appImageList.length) + 1,
  146.         itemBuilder: (c, i) {
  147.           if (kIsWeb) {
  148.             if (i >= webImageList.length) {
  149.               return addContainer(onTap: pickImages);
  150.             }
  151.             return UploadingImageWidget(
  152.               webImage: webImageList[i],
  153.               onDelete: () => onImageDelete(i),
  154.               onSuccess: (url) => onSuccess(i, url),
  155.               onPreview: onPreview,
  156.             );
  157.           } else {
  158.             if (i >= appImageList.length) {
  159.               return addContainer(onTap: pickImages);
  160.             }
  161.             return UploadingImageWidget(
  162.               image: appImageList[i],
  163.               onDelete: () => onImageDelete(i),
  164.               onSuccess: (url) => onSuccess(i, url),
  165.               onPreview: onPreview,
  166.             );
  167.           }
  168.         },
  169.       ),
  170.     );
  171.   }
  172.  
  173.   // 上传文件
  174.   Widget uploadFile() {
  175.     return SizedBox(
  176.       width: double.infinity,
  177.       child: GridView.builder(
  178.         physics: const NeverScrollableScrollPhysics(),
  179.         shrinkWrap: true,
  180.         gridDelegate: const SliverGridDelegateWithFixedCrossAxisCount(
  181.           crossAxisCount: 4,
  182.           crossAxisSpacing: 10,
  183.           mainAxisSpacing: 10,
  184.           childAspectRatio: 1,
  185.         ),
  186.         // +1 是为了添加图片按钮
  187.         itemCount: widget.limit != null && widget.limit! <= filesList.length
  188.             ? filesList.length
  189.             : (filesList.length + 1),
  190.         itemBuilder: (c, i) {
  191.           if (i >= filesList.length) {
  192.             return addContainer(onTap: pickFiles);
  193.           }
  194.           return UploadingFileWidget(
  195.             files: filesList[i],
  196.             index: i,
  197.             onDelete: () => onFileDelete(i),
  198.             onSuccess: (url) => onSuccess(i, url),
  199.             onPreview: onPreview,
  200.           );
  201.         },
  202.       ),
  203.     );
  204.   }
  205.  
  206.   onImageDelete(int i) {
  207.     if (kIsWeb) {
  208.       webImageList.removeAt(i);
  209.       widget.onDelete?.call(i, webImageList, UploadType.image);
  210.     } else {
  211.       appImageList.removeAt(i);
  212.       widget.onDelete?.call(i, appImageList, UploadType.image);
  213.     }
  214.     setState(() {});
  215.   }
  216.  
  217.   onFileDelete(int i) {
  218.     filesList.removeAt(i);
  219.     widget.onDelete?.call(i, filesList, UploadType.file);
  220.     setState(() {});
  221.   }
  222.  
  223.   onSuccess(int i, String url) {
  224.     widget.onSuccess?.call(url, i);
  225.   }
  226.  
  227.   // 已上传完成的容器
  228.   Widget hasUploadContainer() {
  229.     return Container(
  230.       width: 75.w,
  231.       height: 75.w,
  232.       decoration: BoxDecoration(
  233.         color: HexColor("#F2F4F7"),
  234.         borderRadius: BorderRadius.circular(5.r),
  235.       ),
  236.     );
  237.   }
  238.  
  239.   // 点击添加
  240.   Widget addContainer({
  241.     Function? onTap,
  242.   }) {
  243.     return InkWell(
  244.       child: Container(
  245.         width: 75.w,
  246.         height: 75.w,
  247.         decoration: BoxDecoration(
  248.           color: HexColor("#F2F4F7"),
  249.           borderRadius: BorderRadius.circular(5.r),
  250.           image: DecorationImage(
  251.             image: Assets.images.uploadAdd.provider(),
  252.           ),
  253.         ),
  254.         alignment: Alignment.center,
  255.       ),
  256.       onTap: () {
  257.         onTap?.call();
  258.       },
  259.     );
  260.   }
  261.  
  262.   @override
  263.   Widget build(BuildContext context) {
  264.     return curContain;
  265.   }
  266. }
  267.  
  268. // 上传图片 上传中的组件
  269. class UploadingImageWidget extends StatefulWidget {
  270.   final File? image;
  271.   final Uint8List? webImage;
  272.   final Function(String)? onSuccess;
  273.   final Function()? onFail;
  274.   final Function()? onDelete;
  275.   final Function(String)? onPreview;
  276.  
  277.   const UploadingImageWidget({
  278.     super.key,
  279.     this.image,
  280.     this.webImage,
  281.     this.onSuccess,
  282.     this.onFail,
  283.     this.onDelete,
  284.     this.onPreview,
  285.   });
  286.  
  287.   @override
  288.   State<UploadingImageWidget> createState() => _UploadingImageWidgetState();
  289. }
  290.  
  291. class _UploadingImageWidgetState extends State<UploadingImageWidget> {
  292.   // 是否上传失败
  293.   bool isUploadFail = false;
  294.   double cruProgress = 0.0;
  295.   String httpPath = "";
  296.  
  297.   // 正在上传中
  298.   bool isUploading = false;
  299.  
  300.   @override
  301.   void initState() {
  302.     super.initState();
  303.     initUpload();
  304.   }
  305.  
  306.   // 立即进行上传
  307.   initUpload() {
  308.     try {
  309.       kIsWeb ? webUpload() : appUpload();
  310.     } catch (e) {
  311.       widget.onFail?.call();
  312.       setState(() {
  313.         isUploadFail = true;
  314.       });
  315.     }
  316.   }
  317.  
  318.   onTapDelete() {
  319.     widget.onDelete?.call();
  320.   }
  321.  
  322.   webUpload() async {
  323.     setState(() {
  324.       isUploading = true;
  325.     });
  326.     final res = await Api.uploadFileListInt(
  327.       widget.webImage as Uint8List,
  328.       name: "img",
  329.       onSendProgress: (count, total) {
  330.         setState(() {
  331.           cruProgress = count / total;
  332.         });
  333.       },
  334.     );
  335.     setState(() {
  336.       isUploading = false;
  337.     });
  338.     httpPath = res["data"] ?? "";
  339.     widget.onSuccess?.call(httpPath);
  340.   }
  341.  
  342.   appUpload() async {
  343.     setState(() {
  344.       isUploading = true;
  345.     });
  346.     final res = await Api.uploadFile(
  347.       widget.image!.path,
  348.       onSendProgress: (count, total) {
  349.         setState(() {
  350.           cruProgress = count / total;
  351.         });
  352.       },
  353.     );
  354.     setState(() {
  355.       isUploading = false;
  356.     });
  357.     httpPath = res["data"] ?? "";
  358.     widget.onSuccess?.call(httpPath);
  359.   }
  360.  
  361.   @override
  362.   Widget build(BuildContext context) {
  363.     return AnimatedContainer(
  364.       duration: const Duration(seconds: 1),
  365.       width: double.infinity,
  366.       height: double.infinity,
  367.       decoration: BoxDecoration(
  368.         color: HexColor("#F2F4F7"),
  369.         borderRadius: BorderRadius.circular(5.r),
  370.       ),
  371.       child: isUploadFail
  372.           ? failUploadContainer()
  373.           : (cruProgress == 1.0 && !isUploading
  374.               ? finallyUploadContainer()
  375.               : beforeUploadContainer()),
  376.     );
  377.   }
  378.  
  379.   // 上传之前的容器
  380.   Stack beforeUploadContainer() {
  381.     return Stack(
  382.       clipBehavior: Clip.none,
  383.       children: [
  384.         if (widget.webImage != null)
  385.           Container(
  386.             width: double.infinity,
  387.             height: double.infinity,
  388.             clipBehavior: Clip.hardEdge,
  389.             decoration: BoxDecoration(
  390.               borderRadius: BorderRadius.circular(5.r),
  391.             ),
  392.             child: Image.memory(
  393.               widget.webImage as Uint8List,
  394.               width: double.infinity,
  395.               height: double.infinity,
  396.             ),
  397.           ),
  398.         if (widget.image != null)
  399.           Container(
  400.             width: double.infinity,
  401.             height: double.infinity,
  402.             clipBehavior: Clip.hardEdge,
  403.             decoration: BoxDecoration(
  404.               borderRadius: BorderRadius.circular(5.r),
  405.             ),
  406.             child: Image.file(
  407.               widget.image as File,
  408.               width: double.infinity,
  409.               height: double.infinity,
  410.               fit: BoxFit.cover,
  411.             ),
  412.           ),
  413.         Positioned.fill(
  414.           child: Opacity(
  415.             opacity: 0.6,
  416.             child: Container(
  417.               width: double.infinity,
  418.               height: double.infinity,
  419.               decoration: BoxDecoration(
  420.                 color: HexColor("#000000"),
  421.                 borderRadius: BorderRadius.circular(5.r),
  422.               ),
  423.             ),
  424.           ),
  425.         ),
  426.         Positioned(
  427.           top: -4.w,
  428.           right: -4.w,
  429.           child: InkWell(
  430.             onTap: onTapDelete,
  431.             child: Container(
  432.               width: 18.w,
  433.               height: 18.w,
  434.               decoration: const BoxDecoration(
  435.                 shape: BoxShape.circle,
  436.                 color: Colors.white,
  437.               ),
  438.               child: Assets.images.uploadClose.image(width: 18.w),
  439.             ),
  440.           ),
  441.         ),
  442.         Positioned.fill(
  443.           child: Container(
  444.             width: double.infinity,
  445.             height: double.infinity,
  446.             alignment: Alignment.center,
  447.             decoration: BoxDecoration(
  448.               borderRadius: BorderRadius.circular(5.r),
  449.             ),
  450.             child: SizedBox(
  451.               width: 40.w,
  452.               child: LineProgressWidget(
  453.                 cruProgress: cruProgress,
  454.                 minHeight: 5.h,
  455.                 color: HexColor("#CCCCCC"),
  456.                 showText: false,
  457.                 valueColor: AlwaysStoppedAnimation<Color>(HexColor("#F9DE4A")),
  458.               ),
  459.             ),
  460.           ),
  461.         ),
  462.       ],
  463.     );
  464.   }
  465.  
  466. // 完成上传的容器
  467.   Stack finallyUploadContainer() {
  468.     return Stack(
  469.       clipBehavior: Clip.none,
  470.       children: [
  471.         if (widget.webImage != null)
  472.           InkWell(
  473.             onTap: () => widget.onPreview?.call(httpPath),
  474.             child: Container(
  475.               width: double.infinity,
  476.               height: double.infinity,
  477.               clipBehavior: Clip.hardEdge,
  478.               decoration: BoxDecoration(
  479.                 borderRadius: BorderRadius.circular(5.r),
  480.               ),
  481.               child: Image.memory(
  482.                 widget.webImage as Uint8List,
  483.                 width: double.infinity,
  484.                 height: double.infinity,
  485.               ),
  486.             ),
  487.           ),
  488.         if (widget.image != null)
  489.           InkWell(
  490.             onTap: () => widget.onPreview?.call(httpPath),
  491.             child: Container(
  492.               width: double.infinity,
  493.               height: double.infinity,
  494.               clipBehavior: Clip.hardEdge,
  495.               decoration: BoxDecoration(
  496.                 borderRadius: BorderRadius.circular(5.r),
  497.               ),
  498.               child: Image.file(
  499.                 widget.image as File,
  500.                 width: double.infinity,
  501.                 height: double.infinity,
  502.                 fit: BoxFit.cover,
  503.               ),
  504.             ),
  505.           ),
  506.         Positioned(
  507.           top: -4.w,
  508.           right: -4.w,
  509.           child: InkWell(
  510.             onTap: onTapDelete,
  511.             child: Container(
  512.               width: 18.w,
  513.               height: 18.w,
  514.               decoration: const BoxDecoration(
  515.                 shape: BoxShape.circle,
  516.                 color: Colors.white,
  517.               ),
  518.               child: Assets.images.uploadClose.image(width: 18.w),
  519.             ),
  520.           ),
  521.         ),
  522.       ],
  523.     );
  524.   }
  525.  
  526.   // 上传失败重新上传
  527.   failReUpload() async {
  528.     cruProgress = 0.0;
  529.     isUploadFail = false;
  530.     setState(() {});
  531.     initUpload();
  532.   }
  533.  
  534.   // 失败上传的容器
  535.   Stack failUploadContainer() {
  536.     return Stack(
  537.       clipBehavior: Clip.none,
  538.       children: [
  539.         if (widget.webImage != null)
  540.           Container(
  541.             width: double.infinity,
  542.             height: double.infinity,
  543.             clipBehavior: Clip.hardEdge,
  544.             decoration: BoxDecoration(
  545.               borderRadius: BorderRadius.circular(5.r),
  546.             ),
  547.             child: Image.memory(
  548.               widget.webImage as Uint8List,
  549.               width: double.infinity,
  550.               height: double.infinity,
  551.             ),
  552.           ),
  553.         if (widget.image != null)
  554.           Container(
  555.             width: double.infinity,
  556.             height: double.infinity,
  557.             clipBehavior: Clip.hardEdge,
  558.             decoration: BoxDecoration(
  559.               borderRadius: BorderRadius.circular(5.r),
  560.             ),
  561.             child: Image.file(
  562.               widget.image as File,
  563.               width: double.infinity,
  564.               height: double.infinity,
  565.               fit: BoxFit.cover,
  566.             ),
  567.           ),
  568.         Positioned.fill(
  569.           child: Container(
  570.             width: double.infinity,
  571.             height: double.infinity,
  572.             decoration: BoxDecoration(
  573.               borderRadius: BorderRadius.circular(5.r),
  574.               color: HexColor("#000000").withOpacity(0.6),
  575.             ),
  576.             alignment: Alignment.center,
  577.             child: InkWell(
  578.               onTap: failReUpload,
  579.               child: SizedBox(
  580.                 width: 20.w,
  581.                 height: 20.w,
  582.                 child: Assets.images.uploadReload.image(width: 20.w),
  583.               ),
  584.             ),
  585.           ),
  586.         ),
  587.         Positioned(
  588.           top: -4.w,
  589.           right: -4.w,
  590.           child: InkWell(
  591.             onTap: onTapDelete,
  592.             child: Container(
  593.               width: 18.w,
  594.               height: 18.w,
  595.               decoration: const BoxDecoration(
  596.                 shape: BoxShape.circle,
  597.                 color: Colors.white,
  598.               ),
  599.               child: Assets.images.uploadClose.image(width: 18.w),
  600.             ),
  601.           ),
  602.         ),
  603.       ],
  604.     );
  605.   }
  606. }
  607.  
  608. // 上传文件 上传中的组件
  609. class UploadingFileWidget extends StatefulWidget {
  610.   final int index;
  611.   final FilePickerResult? files;
  612.   final Function(String)? onSuccess;
  613.   final Function()? onFail;
  614.   final Function()? onDelete;
  615.   final Function(String)? onPreview;
  616.  
  617.   const UploadingFileWidget({
  618.     super.key,
  619.     this.files,
  620.     required this.index,
  621.     this.onSuccess,
  622.     this.onFail,
  623.     this.onDelete,
  624.     this.onPreview,
  625.   });
  626.  
  627.   @override
  628.   State<UploadingFileWidget> createState() => _UploadingFileWidgetState();
  629. }
  630.  
  631. class _UploadingFileWidgetState extends State<UploadingFileWidget> {
  632.   // 是否上传失败
  633.   bool isUploadFail = false;
  634.   // 正在上传中
  635.   bool isUploading = false;
  636.   double cruProgress = 0.0;
  637.   String httpPath = "";
  638.  
  639.   Function? cancelSendItems;
  640.  
  641.   @override
  642.   void initState() {
  643.     super.initState();
  644.     initUpload();
  645.   }
  646.  
  647.   // 立即进行上传
  648.   initUpload() {
  649.     try {
  650.       kIsWeb ? webUpload() : appUpload();
  651.     } catch (e) {
  652.       widget.onFail?.call();
  653.       setState(() {
  654.         isUploadFail = true;
  655.       });
  656.     }
  657.   }
  658.  
  659.   onTapDelete() {
  660.     widget.onDelete?.call();
  661.     if (cancelSendItems != null) {
  662.       cancelSendItems!.call();
  663.     }
  664.   }
  665.  
  666.   webUpload() async {
  667.     PlatformFile curFile = widget.files!.files.first;
  668.     setState(() {
  669.       isUploading = true;
  670.     });
  671.     final res = await Api.uploadFilePlatformFile(
  672.       curFile,
  673.       onSendProgress: (count, total) {
  674.         setState(() {
  675.           cruProgress = count / total;
  676.         });
  677.       },
  678.     );
  679.     httpPath = res["data"] ?? "";
  680.     setState(() {
  681.       isUploading = false;
  682.     });
  683.     widget.onSuccess?.call(httpPath);
  684.   }
  685.  
  686.   appUpload() async {
  687.     var path = widget.files!.paths.first;
  688.     int size = widget.files?.files.first.size ?? 0;
  689.     if (size > FileUtils.mToSize(20)) {
  690.       appSliceUpload();
  691.       return;
  692.     }
  693.  
  694.     setState(() {
  695.       isUploading = true;
  696.     });
  697.     final res = await Api.uploadFile(
  698.       path as String,
  699.       onSendProgress: (count, total) async {
  700.         // await Future.delayed(const Duration(seconds: 1));
  701.         setState(() {
  702.           cruProgress = count / total;
  703.         });
  704.       },
  705.     );
  706.     setState(() {
  707.       isUploading = false;
  708.     });
  709.     httpPath = res["data"] ?? "";
  710.     widget.onSuccess?.call(httpPath);
  711.   }
  712.  
  713.   // 大文件切片上传
  714.   appSliceUpload() async {
  715.     var path = widget.files!.paths.first;
  716.     setState(() {
  717.       isUploading = true;
  718.     });
  719.  
  720.     final res = await Api.uploadSliceFile(
  721.       path as String,
  722.       onSendProgress: (count, total) async {
  723.         // await Future.delayed(const Duration(seconds: 1));
  724.         setState(() {
  725.           cruProgress = count / total;
  726.         });
  727.       },
  728.       getFileUtils: (utils) {
  729.         "[分片上传] 获取 utils $utils".w();
  730.         cancelSendItems = () => utils.cancelSendItems();
  731.       },
  732.     );
  733.     setState(() {
  734.       isUploading = false;
  735.     });
  736.     httpPath = res["data"] ?? "";
  737.     widget.onSuccess?.call(httpPath);
  738.   }
  739.  
  740.   @override
  741.   Widget build(BuildContext context) {
  742.     return AnimatedContainer(
  743.       duration: const Duration(seconds: 1),
  744.       width: double.infinity,
  745.       height: double.infinity,
  746.       decoration: BoxDecoration(
  747.         color: HexColor("#F2F4F7"),
  748.         borderRadius: BorderRadius.circular(5.r),
  749.       ),
  750.       child: isUploadFail
  751.           ? failUploadContainer()
  752.           : (cruProgress == 1.0 && !isUploading
  753.               ? finallyUploadContainer()
  754.               : beforeUploadContainer()),
  755.     );
  756.   }
  757.  
  758.   // 上传之前的容器
  759.   Stack beforeUploadContainer() {
  760.     return Stack(
  761.       clipBehavior: Clip.none,
  762.       children: [
  763.         if (widget.files?.files.first != null)
  764.           fileInfoContainer(widget.files?.files.first),
  765.         Positioned.fill(
  766.           child: Opacity(
  767.             opacity: 0.6,
  768.             child: Container(
  769.               width: double.infinity,
  770.               height: double.infinity,
  771.               decoration: BoxDecoration(
  772.                 color: HexColor("#000000"),
  773.                 borderRadius: BorderRadius.circular(5.r),
  774.               ),
  775.             ),
  776.           ),
  777.         ),
  778.         Positioned.fill(
  779.           child: Container(
  780.             width: double.infinity,
  781.             height: double.infinity,
  782.             alignment: Alignment.center,
  783.             decoration: BoxDecoration(
  784.               borderRadius: BorderRadius.circular(5.r),
  785.             ),
  786.             child: SizedBox(
  787.               width: 40.w,
  788.               child: LineProgressWidget(
  789.                 cruProgress: cruProgress,
  790.                 minHeight: 5.h,
  791.                 color: HexColor("#CCCCCC"),
  792.                 showText: false,
  793.                 valueColor: AlwaysStoppedAnimation<Color>(HexColor("#F9DE4A")),
  794.               ),
  795.             ),
  796.           ),
  797.         ),
  798.         Positioned(
  799.           top: -4.w,
  800.           right: -4.w,
  801.           child: InkWell(
  802.             onTap: onTapDelete,
  803.             child: Container(
  804.               width: 18.w,
  805.               height: 18.w,
  806.               decoration: const BoxDecoration(
  807.                 shape: BoxShape.circle,
  808.                 color: Colors.white,
  809.               ),
  810.               child: Assets.images.uploadClose.image(width: 18.w),
  811.             ),
  812.           ),
  813.         ),
  814.       ],
  815.     );
  816.   }
  817.  
  818.   // 文件信息展示容器
  819.   Widget fileInfoContainer(PlatformFile? file) {
  820.     String fileName = file?.name ?? "";
  821.     if (Utils.isImageFile(fileName)) {
  822.       if (kIsWeb) {
  823.         Uint8List webImageFile = file?.bytes as Uint8List;
  824.         return InkWell(
  825.           onTap: () => widget.onPreview?.call(httpPath),
  826.           child: Container(
  827.             width: double.infinity,
  828.             height: double.infinity,
  829.             clipBehavior: Clip.hardEdge,
  830.             decoration: BoxDecoration(
  831.               borderRadius: BorderRadius.circular(5.r),
  832.             ),
  833.             child: Image.memory(
  834.               webImageFile,
  835.               width: double.infinity,
  836.               height: double.infinity,
  837.             ),
  838.           ),
  839.         );
  840.       } else {
  841.         File imageFile = File(file?.path ?? "");
  842.         return InkWell(
  843.           onTap: () => widget.onPreview?.call(httpPath),
  844.           child: Container(
  845.             width: double.infinity,
  846.             height: double.infinity,
  847.             clipBehavior: Clip.hardEdge,
  848.             decoration: BoxDecoration(
  849.               borderRadius: BorderRadius.circular(5.r),
  850.             ),
  851.             child: Image.file(
  852.               imageFile,
  853.               width: double.infinity,
  854.               height: double.infinity,
  855.               fit: BoxFit.cover,
  856.             ),
  857.           ),
  858.         );
  859.       }
  860.     }
  861.     return Container(
  862.       width: double.infinity,
  863.       height: double.infinity,
  864.       clipBehavior: Clip.hardEdge,
  865.       decoration: BoxDecoration(
  866.         borderRadius: BorderRadius.circular(5.r),
  867.       ),
  868.       alignment: Alignment.center,
  869.       child: Column(
  870.         mainAxisSize: MainAxisSize.min,
  871.         crossAxisAlignment: CrossAxisAlignment.center,
  872.         mainAxisAlignment: MainAxisAlignment.center,
  873.         children: [
  874.           Assets.images.uploadFileIcon.image(width: 20.w),
  875.           SizedBox(height: 5.h),
  876.           Text(
  877.             fileName,
  878.             style: TextStyle(
  879.               fontFamily: Font.pingFang,
  880.               fontWeight: FontWeight.w500,
  881.               fontSize: 12.sp,
  882.               color: HexColor("#1A1A1A"),
  883.               height: 1.1,
  884.             ),
  885.             textAlign: TextAlign.center,
  886.             overflow: TextOverflow.ellipsis,
  887.             maxLines: 3,
  888.           ),
  889.         ],
  890.       ),
  891.     );
  892.   }
  893.  
  894. // 完成上传的容器
  895.   Stack finallyUploadContainer() {
  896.     return Stack(
  897.       clipBehavior: Clip.none,
  898.       children: [
  899.         if (widget.files?.files.first != null)
  900.           fileInfoContainer(widget.files?.files.first),
  901.         Positioned(
  902.           top: -4.w,
  903.           right: -4.w,
  904.           child: InkWell(
  905.             onTap: onTapDelete,
  906.             child: Container(
  907.               width: 18.w,
  908.               height: 18.w,
  909.               decoration: const BoxDecoration(
  910.                 shape: BoxShape.circle,
  911.                 color: Colors.white,
  912.               ),
  913.               child: Assets.images.uploadClose.image(width: 18.w),
  914.             ),
  915.           ),
  916.         ),
  917.       ],
  918.     );
  919.   }
  920.  
  921.   // 上传失败重新上传
  922.   failReUpload() async {
  923.     cruProgress = 0.0;
  924.     isUploadFail = false;
  925.     setState(() {});
  926.     initUpload();
  927.   }
  928.  
  929.   // 失败上传的容器
  930.   Stack failUploadContainer() {
  931.     return Stack(
  932.       clipBehavior: Clip.none,
  933.       children: [
  934.         if (widget.files?.files.first != null)
  935.           fileInfoContainer(widget.files?.files.first),
  936.         Positioned.fill(
  937.           child: Container(
  938.             width: double.infinity,
  939.             height: double.infinity,
  940.             decoration: BoxDecoration(
  941.               borderRadius: BorderRadius.circular(5.r),
  942.               color: HexColor("#000000").withOpacity(0.6),
  943.             ),
  944.             alignment: Alignment.center,
  945.             child: InkWell(
  946.               onTap: failReUpload,
  947.               child: SizedBox(
  948.                 width: 20.w,
  949.                 height: 20.w,
  950.                 child: Assets.images.uploadReload.image(width: 20.w),
  951.               ),
  952.             ),
  953.           ),
  954.         ),
  955.         Positioned(
  956.           top: -4.w,
  957.           right: -4.w,
  958.           child: InkWell(
  959.             onTap: onTapDelete,
  960.             child: Container(
  961.               width: 18.w,
  962.               height: 18.w,
  963.               decoration: const BoxDecoration(
  964.                 shape: BoxShape.circle,
  965.                 color: Colors.white,
  966.               ),
  967.               child: Assets.images.uploadClose.image(width: 18.w),
  968.             ),
  969.           ),
  970.         ),
  971.       ],
  972.     );
  973.   }
  974. }
  975.  
  976. // 已上传图片或文件展示
  977. class HasUploadShowWidget extends StatelessWidget {
  978.   final List<String?> urls;
  979.   final Function(int)? onDelete;
  980.   final bool showDelete;
  981.   final Function(String)? onFileTap;
  982.   final TextDirection textDirection;
  983.   const HasUploadShowWidget({
  984.     super.key,
  985.     required this.urls,
  986.     this.onDelete,
  987.     this.showDelete = true,
  988.     this.onFileTap,
  989.     this.textDirection = TextDirection.ltr,
  990.   });
  991.  
  992.   onTapDelete(int idx) {
  993.     onDelete?.call(idx);
  994.   }
  995.  
  996.   onPreview(String url) {
  997.     if (url.isNotEmpty) {
  998.       Get.to(
  999.         () => ImagePreviewPage(
  1000.           imageUrl: url,
  1001.         ),
  1002.       );
  1003.     }
  1004.   }
  1005.  
  1006.   @override
  1007.   Widget build(BuildContext context) {
  1008.     return SizedBox(
  1009.       width: double.infinity,
  1010.       child: Directionality(
  1011.         textDirection: textDirection,
  1012.         child: GridView.builder(
  1013.             shrinkWrap: true,
  1014.             itemCount: urls.length,
  1015.             physics: const NeverScrollableScrollPhysics(),
  1016.             gridDelegate: const SliverGridDelegateWithFixedCrossAxisCount(
  1017.               crossAxisCount: 4,
  1018.               crossAxisSpacing: 10,
  1019.               mainAxisSpacing: 10,
  1020.               childAspectRatio: 1,
  1021.             ),
  1022.             itemBuilder: (c, i) {
  1023.               if (Utils.isImageFile(urls[i] ?? "")) {
  1024.                 return Stack(
  1025.                   clipBehavior: Clip.none,
  1026.                   children: [
  1027.                     InkWell(
  1028.                       onTap: () => onPreview(urls[i] ?? ""),
  1029.                       child: Container(
  1030.                         width: 75.w,
  1031.                         height: 75.w,
  1032.                         clipBehavior: Clip.hardEdge,
  1033.                         decoration: BoxDecoration(
  1034.                           borderRadius: BorderRadius.circular(5.r),
  1035.                         ),
  1036.                         child: urls[i] != null
  1037.                             ? CachedNetworkImage(
  1038.                                 width: 75.w,
  1039.                                 height: 75.w,
  1040.                                 imageUrl: urls[i] ?? "",
  1041.                                 fit: BoxFit.cover,
  1042.                               )
  1043.                             : null,
  1044.                       ),
  1045.                     ),
  1046.                     if (showDelete)
  1047.                       Positioned(
  1048.                         top: -4.w,
  1049.                         right: -4.w,
  1050.                         child: InkWell(
  1051.                           onTap: () => onTapDelete(i),
  1052.                           child: Container(
  1053.                             width: 18.w,
  1054.                             height: 18.w,
  1055.                             decoration: const BoxDecoration(
  1056.                               shape: BoxShape.circle,
  1057.                               color: Colors.white,
  1058.                             ),
  1059.                             child: Assets.images.uploadClose.image(width: 18.w),
  1060.                           ),
  1061.                         ),
  1062.                       ),
  1063.                   ],
  1064.                 );
  1065.               }
  1066.               return Stack(
  1067.                 clipBehavior: Clip.none,
  1068.                 children: [
  1069.                   InkWell(
  1070.                     onTap: () => onFileTap?.call(urls[i] ?? ""),
  1071.                     child: Container(
  1072.                       width: 75.w,
  1073.                       height: 75.w,
  1074.                       clipBehavior: Clip.none,
  1075.                       decoration: BoxDecoration(
  1076.                         borderRadius: BorderRadius.circular(5.r),
  1077.                         color: HexColor("#F2F4F7"),
  1078.                       ),
  1079.                       alignment: Alignment.center,
  1080.                       child: Column(
  1081.                         crossAxisAlignment: CrossAxisAlignment.center,
  1082.                         mainAxisAlignment: MainAxisAlignment.center,
  1083.                         children: [
  1084.                           Assets.images.uploadFileIcon.image(width: 20.w),
  1085.                           SizedBox(height: 5.h),
  1086.                           Container(
  1087.                             constraints: BoxConstraints(maxWidth: 75.w),
  1088.                             child: Text(
  1089.                               Utils.getFileNameFromUrl((urls[i] ?? "")),
  1090.                               style: TextStyle(
  1091.                                 fontFamily: Font.pingFang,
  1092.                                 fontWeight: FontWeight.w500,
  1093.                                 fontSize: 12.sp,
  1094.                                 color: HexColor("#1A1A1A"),
  1095.                                 height: 1.1,
  1096.                               ),
  1097.                               textAlign: TextAlign.center,
  1098.                               overflow: TextOverflow.ellipsis,
  1099.                               maxLines: 2,
  1100.                             ),
  1101.                           ),
  1102.                         ],
  1103.                       ),
  1104.                     ),
  1105.                   ),
  1106.                   if (showDelete)
  1107.                     Positioned(
  1108.                       top: -4.w,
  1109.                       right: -4.w,
  1110.                       child: InkWell(
  1111.                         onTap: () => onTapDelete(i),
  1112.                         child: Container(
  1113.                           width: 18.w,
  1114.                           height: 18.w,
  1115.                           decoration: const BoxDecoration(
  1116.                             shape: BoxShape.circle,
  1117.                             color: Colors.white,
  1118.                           ),
  1119.                           child: Assets.images.uploadClose.image(width: 18.w),
  1120.                         ),
  1121.                       ),
  1122.                     ),
  1123.                 ],
  1124.               );
  1125.             }),
  1126.       ),
  1127.     );
  1128.   }
  1129. }

使用 文件上传 （如果上传的是图片 显示的也是图片样式）

  1. UploadWidget(
  2.                     type: UploadType.file,
  3.                     limit: 5 - controller.lastFiles.length,
  4.                     onPickAssets: () {
  5.                       controller.curUploadCount++;
  6.                     },
  7.                     onDelete: (i, list, t) {
  8.                       controller.curUploadCount--;
  9.                       controller.state.files.removeAt(i);
  10.                       controller.update();
  11.                     },
  12.                     onSuccess: (url, i) {
  13.                       controller.curUploadCount--;
  14.                       controller.state.files.add(url);
  15.                       controller.update();
  16.                     },
  17.                   )

图片上传

  1. UploadWidget(
  2.                                 type: UploadType.image,
  3.                                 limit: 9,
  4.                                 onPickAssets: () {
  5.                                   curUploadCount++;
  6.                                   setState(() {});
  7.                                 },
  8.                                 onDelete: (i, list, t) {
  9.                                   curUploadCount--;
  10.                                   print("文件 -- $curUploadCount");
  11.                                   imagesFiles.removeAt(i);
  12.                                   setState(() {});
  13.                                 },
  14.                                 onSuccess: (url, i) {
  15.                                   curUploadCount--;
  16.                                   // controller.state.files.add(url);
  17.                                   imagesFiles.add(url);
  18.                                   setState(() {});
  19.                                 },
  20.                               ),

支持撤销文件上传

断点续传功能和秒传

在原有的基础上改动如下

所有上传接口都加上文件的MD5 值，分片的几个接口将uploadId改为整个文件的MD5

新增MD5的方法 依旧使用crypto 库

crypto | Dart PackageImplementations of SHA, MD5, and HMAC cryptographic functions.icon-default.png?t=N7T8https://pub-web.flutter-io.cn/packages/crypto

  1.  static staticCalculateMD5(File file) async {
  2.     if (!file.existsSync()) {
  3.       print('File "$file" does not exist.');
  4.       return;
  5.     }
  6.     Digest digest = await md5.bind(file.openRead()).first;
  7.     return digest.toString();
  8.   }

 app 使用

  1.   FormData formData = FormData.fromMap({
  2.       'file': await MultipartFile.fromFile(path),
  3.       'md5': await FileUtils.staticCalculateMD5(File(path)),
  4.     });

web端使用

  1. static staticCalculateMD5Stream(List<int> input) async {
  2.     Digest digest = md5.convert(input);
  3.     return digest.toString();
  4.   }
  1. FormData formData = FormData.fromMap({
  2.       'file': multipartFile,
  3.       'md5': await FileUtils.staticCalculateMD5Stream(fileBytes),
  4.     });

分片接口改动如下

1、初始化分片接口

新增参数 md5 文件的MD5  这样就可以验证文件是否上传过，如果上传直接返回文件地址

未上传完 会返回已上传的分片 然后对求出未上传的分片进行继续上传 

逻辑修改如下

  1.     String filePath = aa['data']['filePath'] ?? "";
  2.     List<SliceChunkItem> sendSliceConfig = config;
  3.  
  4.     int finalUploadSliceCount = 0;
  5.     // 说明是上传过的文件 直接秒传
  6.     if (filePath.isNotEmpty) {
  7.       onSendProgress?.call(1, 1);
  8.       return aa;
  9.     } else {
  10.       List partList = (aa['data']['partList'] ?? []);
  11.       List<SliceChunkItem> filterPartList = partList
  12.           .map<SliceChunkItem>((e) => SliceChunkItem.fromJson(e))
  13.           .toList();
  14.  
  15.       for (var it in filterPartList) {
  16.         int idx = config.indexWhere((e) => e.partNumber == it.partNumber);
  17.         if (idx != -1) {
  18.           config[idx] = it;
  19.         }
  20.       }
  21.  
  22.       sendSliceConfig =
  23.           config.where((e) => !(e.end == 0 && e.start == 0)).toList();
  24.  
  25.       if (sendSliceConfig.isNotEmpty) {
  26.         finalUploadSliceCount = filterPartList.length;
  27.         onSendProgress?.call(finalUploadSliceCount, config.length);
  28.       }
  29.     }

2、分片的接口 新增了文件的MD5

 完成接口一样的新增md5

最后最新的分片上传接口逻辑如下

 

  1. // 文件分片上传
  2.   static uploadSliceFile(
  3.     String path, {
  4.     ProgressCallback? onSendProgress,
  5.     required Function(FileUtils) getFileUtils,
  6.   }) async {
  7.     File file = File(path);
  8.  
  9.     String fileName = file.path.split('/').last;
  10.     final utils = FileUtils(file);
  11.     getFileUtils.call(utils);
  12.     List<SliceChunkItem> config = await utils.getJsonFromSplitFileIntoChunks();
  13.  
  14.     String curMd5Code = utils.hash;
  15.     if (curMd5Code.isEmpty) {
  16.       curMd5Code = await FileUtils.staticCalculateMD5(file);
  17.     }
  18.  
  19.     final aa = await multipartUploadInit(
  20.       fileName: fileName,
  21.       checksumType: FileUtils.hashMethod,
  22.       md5: curMd5Code,
  23.     );
  24.     String filePath = aa['data']['filePath'] ?? "";
  25.     List<SliceChunkItem> sendSliceConfig = config;
  26.  
  27.     int finalUploadSliceCount = 0;
  28.     // 说明是上传过的文件 直接秒传
  29.     if (filePath.isNotEmpty) {
  30.       onSendProgress?.call(1, 1);
  31.       return aa;
  32.     } else {
  33.       List partList = (aa['data']['partList'] ?? []);
  34.       List<SliceChunkItem> filterPartList = partList
  35.           .map<SliceChunkItem>((e) => SliceChunkItem.fromJson(e))
  36.           .toList();
  37.  
  38.       for (var it in filterPartList) {
  39.         int idx = config.indexWhere((e) => e.partNumber == it.partNumber);
  40.         if (idx != -1) {
  41.           config[idx] = it;
  42.         }
  43.       }
  44.  
  45.       sendSliceConfig =
  46.           config.where((e) => !(e.end == 0 && e.start == 0)).toList();
  47.  
  48.       if (sendSliceConfig.isNotEmpty) {
  49.         finalUploadSliceCount = filterPartList.length;
  50.         onSendProgress?.call(finalUploadSliceCount, config.length);
  51.       }
  52.     }
  53.  
  54.     // String uploadId = aa['data']['uploadId'];
  55.     "[分片上传] aa $aa".w();
  56.  
  57.     FormData formData;
  58.     await utils.sendItems(
  59.         config: sendSliceConfig,
  60.         concurrentLimit: 4,
  61.         callback: (item) async {
  62.           // item.setUploadId(uploadId);
  63.           "[分片上传] bb 开始上传 partNumber ${item.partNumber} ".w();
  64.           var fileBytes = await utils.getRange(item.start ?? 0, item.end ?? 0);
  65.           item.checksum = utils.calculateSHA1FormList(fileBytes);
  66.           // 直接传递数组fileBytes 给dio 会导致内存崩溃
  67.           formData = FormData.fromMap({
  68.             'file': MultipartFile.fromBytes(fileBytes, filename: "11"),
  69.             'partNumber': item.partNumber,
  70.             'checksum': item.checksum,
  71.             'md5': curMd5Code,
  72.           });
  73.           final b = await multipartUpload(formData: formData);
  74.           finalUploadSliceCount++;
  75.           onSendProgress?.call(finalUploadSliceCount, config.length);
  76.           "[分片上传] bb 结束上传 partNumber ${item.partNumber} $b".w();
  77.           String tag = b["data"]["tag"];
  78.           item.setTag(tag);
  79.         });
  80.  
  81.     final cc = await multipartUploadComplete(
  82.       // checksum: checksum,
  83.       // uploadId: uploadId,
  84.       md5: curMd5Code,
  85.       partList: config.map((e) => e.toJson()).toList(),
  86.     );
  87.  
  88.     // String filePath = cc["data"]["file_path"];
  89.  
  90.     "[分片上传] cc $cc".w();
  91.     return cc;
  92.   }

上传组件发现删除存在bug 修复如下

UploadingFileWidget 组件使用key: ValueKey('image_$i'),进行标识

  1. GridView.builder(
  2.         physics: const NeverScrollableScrollPhysics(),
  3.         shrinkWrap: true,
  4.         gridDelegate: const SliverGridDelegateWithFixedCrossAxisCount(
  5.           crossAxisCount: 4,
  6.           crossAxisSpacing: 10,
  7.           mainAxisSpacing: 10,
  8.           childAspectRatio: 1,
  9.         ),
  10.         // +1 是为了添加图片按钮
  11.         itemCount: widget.limit != null && widget.limit! <= filesList.length
  12.             ? filesList.length
  13.             : (filesList.length + 1),
  14.         itemBuilder: (c, i) {
  15.           if (i >= filesList.length) {
  16.             return addContainer(onTap: pickFiles);
  17.           }
  18.           return UploadingFileWidget(
  19.             files: filesList[i],
  20.             index: i,
  21.             onDelete: () => onFileDelete(i),
  22.             onSuccess: (url) => onSuccess(i, url),
  23.             onPreview: onPreview,
  24.             key: ValueKey('image_$i'),
  25.           );
  26.         },
  27.       ),

在Flutter中，Key可以是任何类型的对象，但最常用的是 GlobalKey、ValueKey 和 ObjectKey。

  1. GlobalKey: 用于在整个应用程序中唯一标识一个Widget。当你需要在程序的不同部分引用同一个组件时，可以使用GlobalKey。比如，如果你需要通过GlobalKey在一个页面中的某个组件，可以使用GlobalKey。

  2. ValueKey: 用于基于值的比较，可以根据给定的值来标识Widget，在列表、集合或父子关系中非常有用。比如，如果你有一个具有一组项目的列表，并且需要标识这些项目，可以使用ValueKey，并以项目的唯一标识符作为值。

  3. ObjectKey: 与ValueKey类似，可以根据对象的身份来标识Widget。如果你需要根据对象的身份来标识Widget，而不是基于对象的值，可以使用ObjectKey。

除了这些内置的Key类型，你也可以创建自定义的Key类，只要它们遵循Key的方法和属性即可。

在你的情况下，你可以使用GlobalKey来保证每个UploadingImageWidget都有唯一的标识，这样就可以避免状态混淆的问题。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/124405
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号