How can I implement the Lock/Unlock mechanism with version 5+

[burekas7]

Request Statement

@cfa
I have a really significant use of the lock/unlock mechanism that was in the old versions (below 5.0.0),
mainly for use when the Internet connection disconnects and comes back, among other things.
For example with the use of the Queue package (but not only):
So requests are waiting to be sent until the connection returns, and meanwhile the Futures in the Queue are waiting and so is Queue.onComplete.

I looked for different Interceptors to meet this need and none perform the operation performed by the lock/unlock mechanism (which is of course based on the Lock class that was found in the interceptor.dart file)

I would like to know how I can implement this mechanism also in the new versions (5+)
or if it is still possible to return this mechanism?
(I didn't understand why it was removed in the first place)

Thanks in advance

[AlexV525]

Pseudo flow:

1. Defines a global completer: Completer<void>? _connectionsLock
2. If connections are unavailable, assign a Completer to the global.
3. Implement a QueuedInterceptor with onRequest, and write await _connectionsLock?.future.
4. If connections become available, resolve the lock and unassign it from the global.

[burekas7]

@AlexV525
Thanks a lot. It's working!!!
(Although I think it would be nice if it was built-in as it was before)

This is my implementation:

class NetworkManager with ChangeNotifier {

  final Connectivity _connectivity = Connectivity();
  late StreamSubscription _streamSubscription;
  ConnectivityResult connectivityResult = ConnectivityResult.none;
  
  final Dio _dio = Dio();
  late Completer<void>? _connectionLockCompleter = Completer<void>();
  
  NetworkManager() {
    setupQueuedInterceptorsLockWrapper();
  
    _streamSubscription = _connectivity.onConnectivityChanged.listen((connectivityResult) async {
      this.connectivityResult = connectivityResult;
      print("Connectivity status: ${this.connectivityResult.name}");
      if (connectivityResult != ConnectivityResult.none) {
        unlock();
      } else {
        lock();
      }
    });
  }
  
  void lock() {
    if (_connectionLockCompleter == null) {
      _connectionLockCompleter = Completer<void>();
    }
  }

  void unlock() {
    _connectionLockCompleter?.complete();
    _connectionLockCompleter = null;
  }
  
  void setupQueuedInterceptorsLockWrapper() {
    _dio.interceptors.add(QueuedInterceptorsWrapper(
        onRequest: (RequestOptions options, RequestInterceptorHandler handler) async {
      if (_connectionLockCompleter != null) {
        await _connectionLockCompleter!.future;
      }
      return handler.next(options);
    }));
  }
  
  @override
  void dispose() {
    _streamSubscription.cancel();
    super.dispose();
  }
}

[AlexV525]

Some suggestions about your implementation:

1. Do not use late for the lock, it's unnecessary.
2. setupQueuedInterceptorsLockWrapper is unnecessary because you can write Dio()..interceptors.add(foo).
3. if (_connectionLockCompleter != null) is unnecessary because you can write await _connectionLockCompleter?.future.

[burekas7]

@AlexV525
Thanks for the suggestions.

Regarding (2), in my code I have flags to enable/disable interceptors, so I took it from there.
For this code here you are right.