How can I cancel Firestore listeners to avoid permission errors during auth transitions in Flutter?

I have a Flutter app that uses Firestore and Redux for state management and relies on a Firestore streaming query. The query works fine for logged-in users, but when switching to anonymous login, there's a gap between logout and new login that results in this error:

flutter: ----------------FIREBASE CRASHLYTICS----------------
flutter: [cloud_firestore/permission-denied] The caller does not have permission to execute the specified operation.
flutter:
#0 EventChannelExtension.receiveGuardedBroadcastStream (package:_flutterfire_internals/src/exception.dart:67:43)
#1 MethodChannelQuery.snapshots. (package:cloud_firestore_platform_interface/src/method_channel/method_channel_query.dart:183:18)

According to the documentation (https://firebase.google.com/docs/firestore/query-data/listen#handle_listen_errors), this is a known scenario. I tried adding an error handler and canceling the subscription, but the error still occurs. Below is the service code where the Firestore query resides:

DARTCopied
class GroupService {
  final FirebaseAuth _auth = FirebaseAuth.instance;
  final FirebaseFirestore _db = FirebaseFirestore.instance;

  StreamController<void> _logoutController = StreamController<void>();

  StreamSubscription<List<Member?>>? _groupMembershipsSubscription;

  GroupService();

  get _getUid {
    firebaseuser.User user = _auth.currentUser!;
    return user.uid;
  }

  // Return user's group memberships from firestore
  Stream<List<Member?>> getGroupMemberships() {
    String uid = _getUid;
      print('GroupService :: getGroupMemberships: Uid: $uid');

    final docRef =
        _db.collection('memberships').where('memberId', isEqualTo: uid).where(
      'status',
    );
    return docRef.snapshots().map((snapshot) {
      List<Member?> memberships = [];
      if (snapshot.docs.isNotEmpty) {
        memberships = snapshot.docs.map((doc) {
          Member? membership =
              serializers.deserializeWith(Member.serializer, doc.data());
          return membership;
        }).toList();
      }
      return memberships;
    }).handleError(
      (error) {
        print('GroupService :: getGroupMemberships : Error: $error');
      },
    );
  }

  // Start listening to the stream and store the subscription
  void startListeningToGroupMemberships({
    required void Function(List<Member?>) onData,
    required void Function(dynamic error) onError,
  }) {
    // Initialize a new logout controller
    _logoutController = StreamController<void>();

    // Create a new subscription
    _groupMembershipsSubscription =
        getGroupMemberships().takeUntil(_logoutController.stream).listen(
      (memberships) {
        onData(memberships);
      },
      onError: (error) {
        onError(error);
      },
    );
  }

  // Cancel the subscription
  void cancelGroupMembershipsSubscription() {
    _logoutController.add(null); // Trigger takeUntil
    _logoutController.close(); // Close the logout stream
    _groupMembershipsSubscription?.cancel();
    _groupMembershipsSubscription = null;
    print('GroupService :: Subscription cancelled');
  }
}

And the middleware calls the service as follows:

DARTCopied
void Function(
  Store<AppState> store,
  dynamic action,
  NextDispatcher next,
) _loadGroups() {
  GroupService groupService = GetIt.I.get<GroupService>();
  return (store, action, next) async {
    next(action);

    if (action is LoadGroupsAction) {

      print('MW :: _loadGroups : Called on LoadGroupsAction');

      groupService.startListeningToGroupMemberships(onData: (memberships) {
        store.dispatch(RefreshGroupsAction());
        if (memberships.isEmpty) {
          store.dispatch(LoadGroupSucceededAction(null));
        } else {
          for (Member? m in memberships) {
            try {
              groupService.getGroup(m!.groupId!).then((group) {
                  if (m.status == MemberStatusType.active) {
                    store.dispatch(LoadGroupSucceededAction(group));
                  } else {
                    store.dispatch(LoadNonMemberGroupSucceededAction(group));
                  }
                } else {
                  store.dispatch(LoadGroupSucceededAction(null));
                }
              });
            } catch (e) {
              print('MW :: _loadGroups : Error: $e');
            }
          }
        }
      }, onError: (error) async {
        print('MW :: _loadGroups : Error: $e');
      });

    } else if (action is LogoutAction) {

      print('MW :: _loadGroups : Called on LogoutAction');
      groupService.cancelGroupMembershipsSubscription();

    }
  };
}

I need advice on how to reliably cancel these listeners (or improve the error handling) to prevent the permission-denied error during the logout to anonymous login transition.