Flutter实现资源下载断点续传的示例代码

import 'package:dio/dio.dart';

typedef progresscallback = void function(int count, int total);

typedef canceltokenprovider = void function(canceltoken canceltoken);

abstract class assetrepositoryprotocol {
  /// 下载单一资源
  future<string> downloadasset(string url,
      {string? subdir,
      progresscallback? onreceiveprogress,
      canceltokenprovider? canceltokenprovider,
      function(string)? done,
      function(exception)? failed});

  /// 取消下载，dio中通过canceltoken可控制
  void canceldownload(canceltoken canceltoken);

  /// 获取文件的缓存地址
  future<string?> filepathforasset(string url, {string? subdir});

  /// 检查文件是否缓存成功，简单对比md5
  future<string?> checkcachedsuccess(string url, {string? md5str});
  
  /// 查看缓存文件的大小
  future<int> cachedfilesize({string? subdir});

  /// 清除缓存
  future<void> clearcache({string? subdir});
}

class assetrepository implements assetrepositoryprotocol {
  assetrepository(this.httpmanager);

  final httpmanagerprotocol httpmanager;

  @override
  future<string> downloadasset(string url,
      {string? subdir,
      progresscallback? onreceiveprogress,
      canceltokenprovider? canceltokenprovider,
      function(string)? done,
      function(exception)? failed}) async {
    canceltoken canceltoken = canceltoken();
    if (canceltokenprovider != null) {
      canceltokenprovider(canceltoken);
    }

    final savepath = await _getsavepath(url, subdir: subdir);
    try {
      httpmanager.downloadfile(
          url: url,
          savepath: savepath + '.temp',
          onreceiveprogress: onreceiveprogress,
          canceltoken: canceltoken,
          done: () {
            done?.call(savepath);
          },
          failed: (e) {
            print(e);
            failed?.call(e);
          });
      return savepath;
    } catch (e) {
      print(e);
      rethrow;
    }
  }

  @override
  void canceldownload(canceltoken canceltoken) {
    try {
      if (!canceltoken.iscancelled) {
        canceltoken.cancel();
      }
    } catch (e) {
      print(e);
    }
  }

  @override
  future<string?> filepathforasset(string url, {string? subdir}) async {
    final path = await _getsavepath(url, subdir: subdir);
    final file = file(path);
    if (!(await file.exists())) {
      return null;
    }
    return path;
  }

  @override
  future<string?> checkcachedsuccess(string url, {string? md5str}) async {
    string? path = await _getsavepath(url, subdir: filetype.video.dirname);
    bool iscached = await file(path).exists();
    if (iscached && (md5str != null && md5str.isnotempty)) {
      // 存在但是md5验证不通过
      file(path).readasbytes().then((uint8list str) {
        if (md5.convert(str).tostring() != md5str) {
          path = null;
        }
      });
    } else if (iscached) {
      return path;
    } else {
      path = null;
    }
    return path;
  }
  
  @override
  future<int> cachedfilesize({string? subdir}) async {
    final dir = await _getdir(subdir: subdir);
    if (!(await dir.exists())) {
      return 0;
    }

    int totalsize = 0;
    await for (var entity in dir.list(recursive: true)) {
      if (entity is file) {
        try {
          totalsize += await entity.length();
        } catch (e) {
          print('get size of $entity failed with exception: $e');
        }
      }
    }

    return totalsize;
  }

  @override
  future<void> clearcache({string? subdir}) async {
    final dir = await _getdir(subdir: subdir);
    if (!(await dir.exists())) {
      return;
    }
    dir.deletesync(recursive: true);
  }

  future<string> _getsavepath(string url, {string? subdir}) async {
    final savedir = await _getdir(subdir: subdir);

    if (!savedir.existssync()) {
      savedir.createsync(recursive: true);
    }

    final uri = uri.parse(url);
    final filename = uri.pathsegments.last;
    return savedir.path + filename;
  }

  future<directory> _getdir({string? subdir}) async {
    final cachedir = await gettemporarydirectory();
    late final directory savedir;
    if (subdir == null) {
      savedir = cachedir;
    } else {
      savedir = directory(cachedir.path + '/$subdir/');
    }
    return savedir;
  }
}

final downloaddio = dio();

future<void> downloadfile({
  required string url,
  required string savepath,
  required canceltoken canceltoken,
  progresscallback? onreceiveprogress,
  void function()? done,
  void function(exception)? failed,
}) async {
  int downloadstart = 0;
  file f = file(savepath);
  if (await f.exists()) {
    // 文件存在时拿到已下载的字节数
    downloadstart = f.lengthsync();
  }
  print("start: $downloadstart");
  try {
    var response = await downloaddio.get<responsebody>(
      url,
      options: options(
        /// receive response data as a stream
        responsetype: responsetype.stream,
        followredirects: false,
        headers: {
          /// 加入range请求头，实现断点续传
          "range": "bytes=$downloadstart-",
        },
      ),
    );
    file file = file(savepath);
    randomaccessfile raf = file.opensync(mode: filemode.append);
    int received = downloadstart;
    int total = await _getcontentlength(response);
    stream<uint8list> stream = response.data!.stream;
    streamsubscription<uint8list>? subscription;
    subscription = stream.listen(
      (data) {
        /// write files must be synchronized
        raf.writefromsync(data);
        received += data.length;
        onreceiveprogress?.call(received, total);
      },
      ondone: () async {
        file.rename(savepath.replaceall('.temp', ''));
        await raf.close();
        done?.call();
      },
      onerror: (e) async {
        await raf.close();
        failed?.call(e);
      },
      cancelonerror: true,
    );
    canceltoken.whencancel.then((_) async {
      await subscription?.cancel();
      await raf.close();
    });
  } on dioerror catch (error) {
    if (canceltoken.iscancel(error)) {
      print("download cancelled");
    } else {
      failed?.call(error);
    }
  }
}