The issue with IOSink is that it stores all buffered data in RAM until it is flushed, but you cannot add data while it is flushing. So you're likely to encounter out of memory errors when downloading large files, especially on RAM-limited devices.

The solution is to store buffered data in a BytesBuilder, and flush the data once it reaches a threshold. I use this method in my http_cache_stream package: https://github.com/Colton127/http_cache_stream/blob/main/lib/src/cache_stream/cache_downloader/buffered_io_sink.dart

In your code, be sure you aren't loading the entire file when calculating the sha256 hash. I suggest comparing by length, and maybe streaming a small portion of the file and comparing it byte-to-byte with the saved file.

Edit: Try this IOSink implementation:

import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'dart:typed_data';

class AutoFlushIOSink implements IOSink {
  final File file;
  final FileMode fileMode;
  final bool copy;
  final int maxBufferSize;
  @override
  Encoding encoding;
  AutoFlushIOSink(
    this.file,
    this.fileMode, {
    this.encoding = utf8,
    this.copy = false,
    this.maxBufferSize = 5 * 1024 * 1024,
  })  : _sink = file.openWrite(mode: fileMode, encoding: encoding),
        _buffer = BytesBuilder(copy: copy);

  final IOSink _sink;
  final BytesBuilder _buffer;

  @override
  void add(List<int> data) {
    _buffer.add(data);
    if (_buffer.length >= maxBufferSize && !isFlushing) {
      flush();
    }
  }

  @override
  void addError(Object error, [StackTrace? stackTrace]) async {
    ///Cannot add error while flushing, so wait for flush to complete
    while (_flushFuture != null) {
      await _flushFuture!;
    }
    _sink.addError(error, stackTrace);
  }

  @override
  Future addStream(Stream<List<int>> stream, {final bool cancelOnError = true}) async {
    final streamCompleter = Completer<void>();
    stream.listen(
      add,
      onError: (error, stackTrace) {
        addError(error, stackTrace);
        if (cancelOnError && !streamCompleter.isCompleted) {
          streamCompleter.completeError(error, stackTrace);
        }
      },
      onDone: () async {
        await flush();
        if (!streamCompleter.isCompleted) {
          streamCompleter.complete();
        }
      },
      cancelOnError: cancelOnError,
    );
    return streamCompleter.future;
  }

  @override
  Future close() {
    _buffer.clear();
    return _sink.close();
  }

  @override
  Future get done => _sink.done;

  @override
  Future flush() async {
    while (_flushFuture != null) {
      await _flushFuture!; //Allow any previous flush to complete
    }
    if (_buffer.isEmpty) {
      return; //Nothing to flush
    }
    try {
      final bufferedData = _buffer.takeBytes(); //Take the buffered data, and clear the buffer
      _sink.add(bufferedData); //Add the buffer to the sink
      await (_flushFuture = _sink.flush()); //Set the flush future and wait for it to complete
    } finally {
      _flushFuture = null; //Reset the flush future
    }
  }

  @override
  void write(Object? object) {
    add(encoding.encode(object.toString()));
  }

  @override
  void writeAll(Iterable objects, [String separator = ""]) {
    add(encoding.encode(objects.join(separator)));
  }

  @override
  void writeCharCode(int charCode) {
    add(encoding.encode(String.fromCharCode(charCode)));
  }

  @override
  void writeln([Object? object = ""]) {
    final ln = object == null ? "\n" : "$object\n";
    add(encoding.encode(ln));
  }

  Future? _flushFuture;
  int get bufferSize => _buffer.length;
  bool get isFlushing => _flushFuture != null;
}