Closes the event and stateStreams.
This method should be called when a Bloc is no longer needed.
Once close is called, events that are added will not be
In addition, if close is called while events are still being
processed, the Bloc will finish processing the pending events.
Must be implemented when a class extends Bloc.
mapEventToState is called whenever an event is added
and is responsible for converting that event into a new state.
mapEventToState can yield zero, one, or multiple states for an event.
Called whenever a change occurs with the given change.
A change occurs when a new state is emitted.
onChange is called before the state of the cubit is updated.
onChange is a great spot to add logging/analytics for a specific cubit. [...]
Called whenever an error is thrown within mapEventToState.
By default all errors will be ignored and Bloc functionality will be
The stackTrace argument may be null if the state stream received
an error without a stackTrace.
A great spot to handle errors at the individual Bloc level. [...]
Called whenever a transition occurs with the given transition.
A transition occurs when a new event is added and mapEventToState
onTransition is called before a Bloc's state has been updated.
A great spot to add logging/analytics at the individual Bloc level. [...]
Transforms the events stream along with a transitionFn function into
Events that should be processed by mapEventToState need to be passed to
By default asyncExpand is used to ensure all events are processed in
the order in which they are received.
You can override transformEvents for advanced usage in order to
manipulate the frequency and specificity with which mapEventToState is
called as well as which events are processed. [...]
Transforms the Stream<Transition> into a new Stream<Transition>.
By default transformTransitions returns
the incoming Stream<Transition>.
You can override transformTransitions for advanced usage in order to
manipulate the frequency and specificity at which transitions
(state changes) occur. [...]