Flutter Bloc to Bloc Communication: How to receive data on initial listen to broadcast stream?

Question

Problem Summary: I'm trying to fetch a list from StateA of BlocA when I create a new bloc.

Simplified Background: I have an overarching bloc (BlocA), that is always active in the context of this problem, and 2 screens with a corresponding bloc each (BlocB & BlocC) that gets created when routing to its associated screen and closes when routing away from its associated screen. Every time a new bloc is created it needs to fetch its data from the state of BlocA. The user might move back and forth between screens.

What I tried: I created stream controllers in BlocA that streams relevant data to each of the blocs via a getter. At first, I tried a normal (single listner) stream which worked fine initially. However, when routing away and then back to the screen it throws an error when resubscribing to the same stream using the getter. I then instantiated the stream controller as a broadcast stream StreamController.broadcast(). The problem is then that, when subscribing to the stream, no data is passed on subscription to the stream like with a normal stream and when I try to implement an onListen callback in the broadcast constructor (to add an event to the sink) it gives me an error The instance member '_aStream' can't be accessed in an initializer. A similar error appears for state. See below:

... _aStream = StreamController.broadcast(onListen: () {return _aStream.add(state.TypeX)})

Simplified Example Code:

class BlocA extends Bloc<BlocAEvent, BlocAState> {
  BlocA() : super(BlocAState()) {
    on<EventA>(_onevent);
  }

  final StreamController<TypeX> _aStream = StreamController.broadcast();
  Stream<TypeX> get aStream => _aStream.stream;

  final StreamController<TypeY> _bStream = StreamController.broadcast();
  Stream<TypeY> get bStream => _bStream.stream;

  ...
  
  // sink.add()'s are implemented in events
}

class BlocB extends Bloc<BlocBEvent, BlocBState> {
  BlocB({required this.blocA}) : super(BlocBState()) {
    on<EventB>(_onEventB);
    blocASubscription = blocA.aStream.listen((stream) {
      if (stream != state.fieldX) {
        add(EventB(fieldX: stream));
      }
    });
  }

  final BlocA blocA
  late final StreamSubscription blocASubscription;


  FutureOr<void> _onEventB(EventB event, Emitter<BlocBState> emit) {
    emit(state.copyWith(fieldX: event.fieldX));
  }
}
    
class BlocC extends Bloc<BlocCEvent, BlocCState> {
  // similar to BlocB
}

Answer 1

I ended up staying with the stream controllers, as used in the example code, but created a new event for BlocA where it is triggered when the user changes between screens and sinks the appropriate state data into the stream. The event carried an index field to indicate the screen that was routed to. The event's index corresponds with the navBar index.

The event handling implementation looked like this:

  FutureOr<void> _onScreenChanged(
    ScreenChanged event,
    Emitter<BlocAState> emit,
  ) async {
    switch (event.index) {
      case 0:
        _aStream.sink.add(state.fieldX);
        break;
      case 1:
        _bStream.sink.add(state.fieldY);
        break;
      default:
    }
  }