Difference between future/ stream to emit the state in BLOC ?

Overview

In

flutter_bloc

async*

yield

async

emit()

emit()

Modern API — async + emit() (Recommended)

Since

flutter_bloc 7.2+

Future<void>

Emitter<State>

dartCopy
class LoginBloc extends Bloc<LoginEvent, LoginState> {
  LoginBloc() : super(LoginInitial()) {
    on<LoginSubmitted>(_onLoginSubmitted);
  }

  // Future-based handler
  Future<void> _onLoginSubmitted(
    LoginSubmitted event,
    Emitter<LoginState> emit,
  ) async {
    emit(LoginLoading());

    try {
      final user = await authRepo.signIn(event.email, event.password);
      emit(LoginSuccess(user));
    } catch (e) {
      emit(LoginFailure(e.toString()));
    }
  }
}

Stream-based emit (for streaming data sources)

When your data source IS a stream (e.g., Firestore, MQTT), use

emit.forEach

emit.onEach

dartCopy
// Listening to a Stream from Firestore
Future<void> _onWatchUsers(
  WatchUsersEvent event,
  Emitter<UsersState> emit,
) async {
  await emit.forEach<List<User>>(
    userRepository.watchUsers(), // Returns Stream<List<User>>
    onData: (users) => UsersLoaded(users),
    onError: (error, stackTrace) => UsersError(error.toString()),
  );
}

dartCopy
// Using emit.onEach for side effects without state mapping
await emit.onEach<int>(
  timerStream,
  onData: (tick) => emit(TimerTick(tick)),
  onError: (e, _) => emit(TimerError()),
);

Key Differences

emit()

emit.forEach

onError

Old API (Pre-7.2) — mapEventToState with yield

dartCopy
// ❌ Old style — deprecated in newer flutter_bloc versions
@override
Stream<LoginState> mapEventToState(LoginEvent event) async* {
  if (event is LoginSubmitted) {
    yield LoginLoading();
    try {
      final user = await authRepo.signIn(event.email, event.password);
      yield LoginSuccess(user);
    } catch (e) {
      yield LoginFailure(e.toString());
    }
  }
}

Real-World Pattern — Mixed

dartCopy
class DashboardBloc extends Bloc<DashboardEvent, DashboardState> {
  DashboardBloc() : super(DashboardInitial()) {
    on<LoadDashboard>(_onLoad);
    on<WatchNotifications>(_onWatchNotifications);
  }

  // One-time API call → use emit() directly
  Future<void> _onLoad(LoadDashboard event, Emitter<DashboardState> emit) async {
    emit(DashboardLoading());
    final data = await apiService.fetchDashboard();
    emit(DashboardLoaded(data));
  }

  // Ongoing stream → use emit.forEach
  Future<void> _onWatchNotifications(
    WatchNotifications event,
    Emitter<DashboardState> emit,
  ) async {
    await emit.forEach(
      notificationService.stream,
      onData: (notifications) => NotificationsUpdated(notifications),
    );
  }
}

Rule: Use

textCopy

emit()

directly for one-shot operations (API calls, DB reads). Use

textCopy

emit.forEach

/

textCopy

emit.onEach

when your data source is a continuous

textCopy

Stream

.