review fix

flutter/lib/common/widgets/autocomplete.dart

@@ -102,22 +102,34 @@ class AllPeersLoader {
   Set<String> _lastQueryOnlineIds = {};
   DateTime _lastQueryOnlineTime = DateTime.fromMillisecondsSinceEpoch(0);
   Timer? _queryOnlineTimer;
+  List<Peer> _lastQueryOnlineOptions = const [];
+  Set<String> _lastOnlineIds = {};
+  Set<String> _lastOfflineIds = {};
+  final Future<void> Function(List<String> ids) _queryOnlines;
+  final Duration _queryOnlineDebounce;
+  void Function(VoidCallback)? _setState;
+  bool _isCleared = false;
 
   final String _listenerKey = 'AllPeersLoader';
   static const String _cbQueryOnlines = 'callback_query_onlines';
   static const Duration _queryOnlineInterval = Duration(seconds: 5);
-  static const Duration _queryOnlineDebounce = Duration(milliseconds: 300);
+  static const Duration _defaultQueryOnlineDebounce =
+      Duration(milliseconds: 300);
   static const int _maxQueryOnlineOptions = 20;
 
-  late void Function(VoidCallback) setState;
-
   bool get needLoad => !_isPeersLoaded && !_isPeersLoading;
   bool get isPeersLoaded => _isPeersLoaded;
 
-  AllPeersLoader();
+  AllPeersLoader({
+    @visibleForTesting Future<void> Function(List<String> ids)? queryOnlines,
+    @visibleForTesting Duration? queryOnlineDebounce,
+  })  : _queryOnlines = queryOnlines ?? ((ids) => bind.queryOnlines(ids: ids)),
+        _queryOnlineDebounce =
+            queryOnlineDebounce ?? _defaultQueryOnlineDebounce;
 
   void init(void Function(VoidCallback) setState) {
-    this.setState = setState;
+    _setState = setState;
+    _isCleared = false;
     gFFI.recentPeersModel.addListener(_mergeAllPeers);
     gFFI.lanPeersModel.addListener(_mergeAllPeers);
     gFFI.abModel.addPeerUpdateListener(_listenerKey, _mergeAllPeers);
@@ -135,6 +147,9 @@ class AllPeersLoader {
     gFFI.groupModel.removePeerUpdateListener(_listenerKey);
     platformFFI.unregisterEventHandler(_cbQueryOnlines, _listenerKey);
     _queryOnlineTimer?.cancel();
+    _lastQueryOnlineOptions = const [];
+    _setState = null;
+    _isCleared = true;
   }
 
   Future<void> getAllPeers() async {
@@ -161,6 +176,9 @@ class AllPeersLoader {
   }
 
   void _mergeAllPeers() {
+    if (_isCleared) {
+      return;
+    }
     peers = mergeAutocompletePeers(
       addressBookPeers: gFFI.abModel.allPeers(),
       groupPeers: gFFI.groupModel.peers,
@@ -168,21 +186,44 @@ class AllPeersLoader {
       recentPeers: gFFI.recentPeersModel.peers,
       restRecentPeerIds: gFFI.recentPeersModel.restPeerIds,
     );
-    setState(() {
+    _applyLastOnlineState(peers);
+    _scheduleSetState(() {
       _isPeersLoading = false;
       _isPeersLoaded = true;
     });
   }
 
   void _updateOnlineState(Map<String, dynamic> evt) {
-    final changed = updateAutocompletePeerOnlineStates(
-      peers,
-      onlines: _splitPeerIds(evt['onlines']),
-      offlines: _splitPeerIds(evt['offlines']),
-    );
-    if (changed) {
-      setState(() {});
+    if (_isCleared) {
+      return;
     }
+    _lastOnlineIds = _splitPeerIds(evt['onlines']);
+    _lastOfflineIds = _splitPeerIds(evt['offlines']);
+    final peersChanged = _applyLastOnlineState(peers);
+    final optionsChanged = _applyLastOnlineState(_lastQueryOnlineOptions);
+    if (peersChanged || optionsChanged) {
+      _scheduleSetState(() {});
+    }
+  }
+
+  void _scheduleSetState(VoidCallback callback) {
+    if (_isCleared) {
+      return;
+    }
+    final setState = _setState;
+    if (setState == null) {
+      callback();
+    } else {
+      setState(callback);
+    }
+  }
+
+  bool _applyLastOnlineState(List<Peer> peers) {
+    return updateAutocompletePeerOnlineStates(
+      peers,
+      onlines: _lastOnlineIds,
+      offlines: _lastOfflineIds,
+    );
   }
 
   Set<String> _splitPeerIds(dynamic ids) {
@@ -193,10 +234,16 @@ class AllPeersLoader {
   }
 
   void queryOnlines(Iterable<Peer> options) {
+    if (_isCleared) {
+      return;
+    }
+    _lastQueryOnlineOptions = options.toList(growable: false);
     final ids = autocompleteOnlineQueryIds(
-      options,
+      _lastQueryOnlineOptions,
       limit: _maxQueryOnlineOptions,
     ).toSet();
+    _queryOnlineTimer?.cancel();
+    _queryOnlineTimer = null;
     if (ids.isEmpty) {
       return;
     }
@@ -206,15 +253,29 @@ class AllPeersLoader {
       return;
     }
 
-    _queryOnlineTimer?.cancel();
-    _queryOnlineTimer = Timer(_queryOnlineDebounce, () {
-      _lastQueryOnlineIds = ids;
-      _lastQueryOnlineTime = DateTime.now();
-      bind.queryOnlines(ids: ids.toList(growable: false)).catchError((e) {
+    _queryOnlineTimer = Timer(_queryOnlineDebounce, () async {
+      try {
+        await _queryOnlines(ids.toList(growable: false));
+        if (_isCleared) {
+          return;
+        }
+        _lastQueryOnlineIds = ids;
+        _lastQueryOnlineTime = DateTime.now();
+      } catch (e) {
         debugPrint('query autocomplete online state failed: $e');
-      });
+      }
     });
   }
+
+  @visibleForTesting
+  void updateOnlineStateForTesting(Map<String, dynamic> evt) {
+    _updateOnlineState(evt);
+  }
+
+  @visibleForTesting
+  bool applyLastOnlineStateForTesting(List<Peer> peers) {
+    return _applyLastOnlineState(peers);
+  }
 }
 
 class AutocompletePeerTile extends StatefulWidget {

flutter/test/autocomplete_peer_merge_test.dart

@@ -80,4 +80,69 @@ void main() {
     expect(ids.where((id) => id == '0'), hasLength(1));
     expect(ids.last, '19');
   });
+
+  test('empty online query ids cancel pending debounce', () async {
+    final queriedIds = <List<String>>[];
+    final loader = AllPeersLoader(
+      queryOnlines: (ids) async {
+        queriedIds.add(ids);
+      },
+      queryOnlineDebounce: Duration(milliseconds: 1),
+    );
+
+    loader.queryOnlines([_peer(id: '123456789')]);
+    loader.queryOnlines([]);
+    await Future.delayed(Duration(milliseconds: 2));
+
+    expect(queriedIds, isEmpty);
+  });
+
+  test('failed online query enqueue does not suppress retry', () async {
+    var queryCount = 0;
+    final loader = AllPeersLoader(
+      queryOnlines: (ids) {
+        queryCount += 1;
+        return Future<void>.error(Exception('queue full'));
+      },
+      queryOnlineDebounce: Duration(milliseconds: 1),
+    );
+
+    loader.queryOnlines([_peer(id: '123456789')]);
+    await Future.delayed(Duration(milliseconds: 2));
+
+    loader.queryOnlines([_peer(id: '123456789')]);
+    await Future.delayed(Duration(milliseconds: 2));
+
+    expect(queryCount, 2);
+  });
+
+  test('online callback updates currently displayed options', () async {
+    final loader = AllPeersLoader(
+      queryOnlines: (ids) async {},
+      queryOnlineDebounce: Duration(milliseconds: 1),
+    );
+    final displayedOptions = [_peer(id: '123456789')];
+
+    loader.queryOnlines(displayedOptions);
+    loader.updateOnlineStateForTesting({
+      'onlines': '123456789',
+      'offlines': '',
+    });
+
+    expect(displayedOptions.single.online, isTrue);
+    await Future.delayed(Duration(milliseconds: 2));
+  });
+
+  test('cached online callback state is reapplied after peers merge', () {
+    final loader = AllPeersLoader();
+    loader.updateOnlineStateForTesting({
+      'onlines': '123456789',
+      'offlines': '',
+    });
+
+    final mergedPeers = [_peer(id: '123456789')];
+    loader.applyLastOnlineStateForTesting(mergedPeers);
+
+    expect(mergedPeers.single.online, isTrue);
+  });
 }