RxBlocListener<B extends RxBlocTypeBase, S> constructor

const RxBlocListener<B extends RxBlocTypeBase, S>({
  1. required RxBlocWidgetListener<S> listener,
  2. required Stream<S> state(
    1. B
    ),
  3. Key? key,
  4. B? bloc,
  5. RxBlocListenerCondition<S>? condition,
  6. dynamic onWaiting(
    1. BuildContext,
    2. S?
    )?,
  7. void onError(
    1. BuildContext,
    2. Object,
    3. StackTrace
    )?,
  8. dynamic onComplete(
    1. BuildContext
    )?,
  9. S? initialValue,
  10. Widget child = const SizedBox(),
})

Takes a RxBlocWidgetListener and an optional bloc and invokes the listener in response to state changes in the bloc. It should be used for functionality that needs to occur only in response to a state change such as navigation, showing a SnackBar, showing a Dialog, etc... The listener is guaranteed to only be called once for each state change unlike the builder in RxBlocBuilder.

If the bloc parameter is omitted, RxBlocListener will automatically perform a lookup using BlocProvider and the current BuildContext.

RxBlocListener<BlocA, String>(
  state: (bloc) => bloc.state.details
  listener: (context, state) {
    // do stuff here based on BlocA's state
  }
)

Only specify the bloc if you wish to provide a bloc that is otherwise not accessible via RxBlocProvider and the current BuildContext.

RxBlocListener<BlocAType, String>(
  bloc: blocA,
  state: (bloc) => bloc.state.details
  listener: (context, state) {
    // do stuff here based on BlocA's state
  }
)

An optional condition can be implemented for more granular control over when listener is called. The condition function will be invoked on each bloc state change. The condition takes the previous state and current state and must return a bool which determines whether or not the listener function will be invoked. The previous state will be initialized to the state of the bloc when the RxBlocListener is initialized. condition is optional and if it isn't implemented, it will default to true.

RxBlocListener<BlocA, String>(
  state: (bloc) => bloc.state.details,

  condition: (previous, current) {
    // return true/false to determine whether or not
    // to invoke listener with state
  },
  listener: (context, state) {
    // do stuff here based on BlocA's state
  }
)

If an error occurs within the provided listened state, an optional onError callback will be triggered. In such case, the listener callback won't be executed. The onError function must be able to be called with either one positional argument, or with two positional arguments where the seconds is always a StackTrace.

Implementation

const RxBlocListener({
  required RxBlocWidgetListener<S> listener,
  required Stream<S> Function(B) state,
  Key? key,
  B? bloc,
  RxBlocListenerCondition<S>? condition,
  Function(BuildContext, S?)? onWaiting,
  void Function(BuildContext, Object, StackTrace)? onError,
  Function(BuildContext)? onComplete,
  S? initialValue,
  Widget child = const SizedBox(),
}) : super(
        key: key,
        child: child,
        listener: listener,
        bloc: bloc,
        condition: condition,
        state: state,
        initialValue: initialValue,
        onWaiting: onWaiting,
        onError: onError,
        onComplete: onComplete,
      );