How to send data greatter than 512 bytes using flutter_blue?

Question

I have a file that is larger than 512 bytes to send to an esp32. I'm sending "withoutResponse: false", the flutter_blue library does the split according to the mtu size without problems, but when it reaches 512 bytes it returns an error to write in characteristic. To solve this I have a function that splits the file and writes each 512 bytes. Esp32 can send me files larger than 512 without doing anything. Can I send larger files without splitting?

Example of code or library that makes this possible

Answer 1

ok, I decided to switch to the flutter_reactive_ble library, and I developed code similar to this one. Basically I split the file into smaller packets of 4096 bytes (this was defined in my communication protocol with esp32), then I call the function that sends and it splits again the file into packets the size of mtu less 19 bytes that are from the header. In the last packet I "writeWithResponse" and wait for the response, if it responds ok, increment and send the next package and repit the processs until the end of file.

   late StreamSubscription<List<int>>? subscribeStream;
    List<int> bytesOfFile = [];
    int _size = 0;
    int _increment = 0;
    List<int> _returnOfSubscribe = [];
    int _indexOfUploadController = 0;

    Future<void> subscribeCharacteristic() async {
      subscribeStream = widget
          .subscribeToCharacteristic(widget.rcharacteristic)
          .listen((event) {
        debugPrint("resposta${hexToString(event)}");
        setState(() {
          _returnOfSubscribe = event;
          if (_returnOfSubscribe != 'code of confirm reception file') {
            debugPrint('err');
          } else {
            _increment++;
            actualize();
          }
        });
      });
    }
    void actualize() async {
      int splitSize = 4096;
      Iterable<int> s;

      int n = (bytesOfFile.length / splitSize).ceil();

      //if is the last split
      if (_increment >= n) {
        if (_returnOfSubscribe == 'code of confirm end of file') {
          debugPrint("success");
        } else {
          debugPrint("err");
        }
        return;
      }

      if ((_size + splitSize) < bytesOfFile.length) {
        s = bytesOfFile.getRange(_size, _size + splitSize);
      } else {
        s = bytesOfFile.getRange(_size, bytesOfFile.length);
      }
      await writeLongData(s.toList());
      _size += splitSize;
    }

    writeLongData(List<int> data) async {
      int splitSize = mtuNotifier.value - 19;
      Iterable<int> s;
      int size = 0;
      int n = (data.length / splitSize).ceil();
      for (int i = 0; i < n; i++) {
        if ((size + splitSize) < data.length) {
          s = data.getRange(size, size + splitSize);
        } else {
          s = data.getRange(size, data.length);
        }
        try {
          if ((size + splitSize) < data.length) {
            await widget.writeWithoutResponse(widget.wcharacteristic, s.toList());
          } else {
            //if the last, write with response
            await widget.writeWithResponse(widget.wcharacteristic, s.toList());
          }
        } catch (e) {
          debugPrint('$e');
          return;
        }
        size += splitSize;
      }
    }