eventstateprocessor
library
Classes
-
Bloc<Event, State>
-
Takes a
Stream
of Events
as input
and transforms them into a Stream
of States
as output.
-
BlocBase<State>
-
An interface for the core functionality implemented by
both Bloc and Cubit.
-
BlocBuilder<B extends BlocBase<S>, S>
-
BlocBuilder handles building a widget in response to new
states
.
BlocBuilder is analogous to StreamBuilder but has simplified API to
reduce the amount of boilerplate code needed as well as bloc-specific
performance improvements.
Please refer to BlocListener if you want to "do" anything in response to
state
changes such as navigation, showing a dialog, etc...
-
BlocBuilderBase<B extends BlocBase<S>, S>
-
Base class for widgets that build themselves based on interaction with
a specified bloc.
-
BlocConsumer<B extends BlocBase<S>, S>
-
BlocConsumer exposes a builder and listener in order react to new
states.
BlocConsumer is analogous to a nested
BlocListener
and BlocBuilder
but reduces the amount of boilerplate needed.
BlocConsumer should only be used when it is necessary to both rebuild UI
and execute other reactions to state changes in the bloc.
-
BlocListener<B extends BlocBase<S>, S>
-
Takes a BlocWidgetListener 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 BlocBuilder
.
-
BlocListenerBase<B extends BlocBase<S>, S>
-
Base class for widgets that listen to state changes in a specified bloc.
-
BlocObserver
-
An interface for observing the behavior of Bloc instances.
-
BlocProvider<T extends BlocBase<Object?>>
-
Takes a
Create
function that is responsible for
creating the Bloc or Cubit and a child which will have access
to the instance via BlocProvider.of(context)
.
It is used as a dependency injection (DI) widget so that a single instance
of a Bloc or Cubit can be provided to multiple widgets within a subtree.
-
BlocSelector<B extends BlocBase<S>, S, T>
-
BlocSelector is analogous to BlocBuilder but allows developers to
filter updates by selecting a new value based on the bloc state.
Unnecessary builds are prevented if the selected value does not change.
-
Change<State>
-
A Change represents the change from one
State
to another.
A Change consists of the currentState and nextState.
-
CoreScreen<E extends UiEvent, S extends DataState, EP extends EventToStateProcessor<E, S>>
-
Base class for building screen ui
-
Cubit<State>
-
A Cubit is similar to Bloc but has no notion of events
and relies on methods to emit new states.
-
DataState
-
Base class for define data state
-
Emitter<State>
-
An Emitter is a class which is capable of emitting new states.
-
EventToStateProcessor<E extends UiEvent, S extends DataState>
-
Takes a
Stream
of UiEvent
as input
and transforms them into a Stream
of DataState
as output.
-
MultiBlocListener
-
Merges multiple BlocListener widgets into one widget tree.
-
MultiBlocProvider
-
Merges multiple BlocProvider widgets into one widget tree.
-
MultiProcessorProvider
-
Merges multiple ProcessorProvider widgets into one widget tree.
-
MultiRepositoryProvider
-
Merges multiple RepositoryProvider widgets into one widget tree.
-
ProcessorProvider<EP extends EventToStateProcessor>
-
Takes a CreateEventStateProcessorFun that is responsible for creating the EventToStateProcessor and
a child which will have access to the EventToStateProcessor via
BlocProvider.of(context)
.
It is used as a dependency injection (DI) widget so that a single instance
of a EventToStateProcessor can be provided to multiple widgets within a subtree.
-
RepositoryProvider<T>
-
Takes a
Create
function that is responsible for creating the repository
and a child
which will have access to the repository via
RepositoryProvider.of(context)
.
It is used as a dependency injection (DI) widget so that a single instance
of a repository can be provided to multiple widgets within a subtree.
-
RequestData
-
Base class for define ui event
-
ResultData
-
-
Transition<Event, State>
-
A Transition is the change from one state to another.
Consists of the currentState, an event, and the nextState.
-
UiEvent
-
Base class for define ui event
Typedefs
-
BlocBuilderCondition<S>
= bool Function(S previous, S current)
-
Signature for the
buildWhen
function which takes the previous state
and
the current state
and is responsible for returning a bool which
determines whether to rebuild BlocBuilder with the current state
.
-
BlocListenerCondition<S>
= bool Function(S previous, S current)
-
Signature for the
listenWhen
function which takes the previous state
and the current state
and is responsible for returning a bool which
determines whether or not to call BlocWidgetListener of BlocListener
with the current state
.
-
BlocWidgetBuilder<S>
= Widget Function(BuildContext context, S state)
-
Signature for the
builder
function which takes the BuildContext
and
state
and is responsible for returning a widget which is to be rendered.
This is analogous to the builder
function in StreamBuilder.
-
BlocWidgetListener<S>
= void Function(BuildContext context, S state)
-
Signature for the
listener
function which takes the BuildContext
along
with the state
and is responsible for executing in response to
state
changes.
-
BlocWidgetSelector<S, T>
= T Function(S state)
-
Signature for the
selector
function which
is responsible for returning a selected value, T
, based on state
.
-
CreateEventStateProcessorFun<EP>
= EP Function(BuildContext context)
-
Function alias which take
context
for creating EventStateProcessor
-
DataStateChangeHandler<E extends UiEvent, S extends DataState, EP extends EventToStateProcessor<E, S>>
= void Function(BuildContext context, EP processor, S state)
-
Callback function alias which handles logic when there is changes in data state
-
EventHandler<Event, State>
= FutureOr<void> Function(Event event, Emitter<State> emit)
-
An event handler is responsible for reacting to an incoming
Event
and can emit zero or more states via the Emitter.
-
EventMapper<Event>
= Stream<Event> Function(Event event)
-
Signature for a function which converts an incoming event
into an outbound stream of events.
Used when defining custom EventTransformers.
-
EventTransformer<Event>
= Stream<Event> Function(Stream<Event> events, EventMapper<Event> mapper)
-
Used to change how events are processed.
By default events are processed concurrently.
-
RequestHandler
= Future<ResultData> Function(RequestData requestData)
-
Function alias which take
requestData
for processor request screen do some action for result. For example: navigate to new screen
-
ScreenContentBuilder<E extends UiEvent, S extends DataState, EP extends EventToStateProcessor<E, S>>
= Widget Function(BuildContext context, EP processor, S state)
-
Function alias which take
context
for build main screen ui base on state
and can raise event by using processor
-
TransitionFunction<Event, State>
= Stream<Transition<Event, State>> Function(Event)
-
@Deprecated - Use
on<Event>
with an EventTransformer
instead.
Will be removed in v8.0.0