state_manager library

Get State Manager is a light, modern and powerful state manager to Flutter

Classes

Bind<T>
Abstract class representing a binding widget responsible for managing a specific type of controller.
BindElement<T>
The BindElement is responsible for injecting dependencies into the widget tree so that they can be observed.
Binder<T>
An inherited widget that updates its dependents when the controller sends notifications.
Binding<T>
Binding should be extended. When using GetMaterialApp, all GetPages and navigation methods (like Get.to()) have a binding property that takes an instance of Bindings to manage the dependencies() (via Get.put()) for the Route you are opening.
Binds<S>
A widget responsible for managing a list of bindings and providing them to its child widget.
CustomStatus<T>
A custom status indicating that the state is in a custom state.
EmptyStatus<T>
A status indicating that the state is empty.
Engine
A utility class for accessing the engine instance.
ErrorStatus<T, S>
A status indicating that the state has encountered an error.
FullController<T>
A controller with both state management and lifecycle observation capabilities.
FullLifeCycleController
Alias for LifecycleController to maintain backward compatibility.
GetBuilder<T extends GetxController>
A widget that builds itself based on the latest value of a GetxController.
GetInterface
A contract defining the interface for interacting with the "Get" class, enabling auxiliary packages to extend its functionality through extensions.
GetListenable<T>
A class that provides listenable behavior similar to ValueNotifier.
GetNotifier<T>
A class representing a state notifier with a Get lifecycle.
GetStatus<T>
Represents the status of an asynchronous operation, such as loading, error, empty, success, or custom.
GetView<T>
GetView is a great way of quickly access your Controller without having to call Get.find<AwesomeController>() yourself.
GetWidget<S extends GetLifeCycleMixin>
GetWidget is a great way of quickly access your individual Controller without having to call Get.find<AwesomeController>() yourself. Get save you controller on cache, so, you can to use Get.create() safely GetWidget is perfect to multiples instance of a same controller. Each GetWidget will have your own controller, and will be call events as onInit and onClose when the controller get in/get out on memory.
GetX<T extends GetLifeCycleMixin>
A widget that manages the lifecycle of a GetX controller and rebuilds its child widget whenever the controller's state changes.
GetxController
Base controller class that provides state management capabilities. This is the foundation for all other controllers.
GetxScrollController
A controller for managing scroll events at the top and bottom of scrollable content. Provides automatic handling of scroll edge detection with debouncing.
GetXState<T extends GetLifeCycleMixin>
LifecycleController
A controller with full app lifecycle observation capabilities.
ListNotifier
A notifier that supports both single and grouped listeners.
ListNotifierGroup
A Notifier that supports a group of listeners identified by an ID.
ListNotifierSingle
A Notifier that supports single listeners.
LoadingStatus<T>
A status indicating that the state is currently loading.
Notifier
A class responsible for managing notifications and listeners.
NotifyData
Data class containing information about notifications and listeners.
Observer
An experimental widget that rebuilds when observed reactive variables change.
Obx
A reactive widget that rebuilds whenever the observed state changes.
ObxElement
A wrapper around a StatelessElement that enables observation of changes in the stateless widget's reactive dependencies.
ObxStatelessWidget
A stateless widget that can listen to reactive changes.
ObxValue<T extends RxInterface>
A reactive widget similar to Obx, but manages a local state. Pass the initial data in the constructor. This is useful for simple local states, like toggles, visibility, themes, button states, etc.
ObxWidget
The base class for all GetX reactive widgets. This class is used as a foundation for widgets that react to changes in GetX observables.
Rx<T>
A foundation class that wraps a value of type T in a reactive container. This class provides the ability to track and manage the state of the wrapped value.
RxBool
An Rx object for managing boolean values.
RxController
A lightweight controller designed for use with reactive (Rx) variables.
RxDouble
A reactive extension of double type, enabling reactive operations on double values.
RxInt
A reactive extension of int type, enabling reactive operations on integer values.
RxInterface<T>
This class is the foundation for all reactive (Rx) classes that makes Get so powerful. This interface is the contract that [_RxImpl]<T> uses in all it's subclass.
RxJsonUtils
Utility functions for safer JSON conversion in reactive classes.
RxList<E>
A reactive list that extends functionality similar to List<T> and provides automatic notifications on changes.
RxMap<K, V>
Rxn<T>
A specialized version of Rx for nullable types (T?).
RxnBool
An Rx object for managing nullable boolean values.
RxnDouble
A reactive extension of double? type, enabling reactive operations on nullable double values.
RxnInt
A reactive extension of int? type, enabling reactive operations on nullable integer values.
RxnNum
A reactive extension of num? type, enabling reactive operations on nullable numeric values.
RxnString
Rx class for String Type.
RxNum
A reactive extension of num type, enabling reactive operations on numeric values.
RxSet<E>
RxString
Rx class for String Type.
StateController<T>
A controller with state management capabilities for async operations.
SuccessStatus<T>
A status indicating that the state has been successfully updated with data of type T.
SuperController<T>
Alias for FullController to maintain backward compatibility.
Value<T>
A class similar to ValueNotifier with additional state management capabilities.
ValueBuilder<T>
A widget that manages local state like ObxValue, but uses a callback instead of a reactive value.
ValueBuilderState<T>
The state associated with the ValueBuilder widget.
Worker
A class representing a worker for executing asynchronous tasks with disposal functionality.
Workers
A class for managing a collection of workers and disposing them when necessary.

Enums

SmartManagement
Refreshed by default disposes unused controllers from memory, Through different behaviors.

Mixins

AppLifecycleMixin
Mixin that provides app lifecycle observation capabilities. This separates the app lifecycle logic from the controller hierarchy.
FullLifeCycleMixin
Mixin that provides backward compatibility with the old lifecycle implementation.
GetSingleTickerProviderStateMixin
Mixin to provide a single ticker for GetxControllers. Works like SingleTickerProviderMixin but optimized for GetX.
GetTickerProviderStateMixin
Mixin to provide multiple tickers for GetxControllers. Works like TickerProviderMixin but optimized for GetX.
ListNotifierGroupMixin
A mixin for managing a group of listeners identified by an ID.
ListNotifierSingleMixin
This mixin adds listener management capabilities to Listenable.
RxObjectMixin<T>
global object that registers against GetX and Obx, and allows the reactivity of those Widgets and Rx values.
ScrollMixin
Alias for GetxScrollController to maintain backward compatibility.
StatelessObserverComponent
A mixin that provides functionality for observing reactive changes in a StatelessElement.
StateMixin<T>
A mixin that provides state management capabilities.
UpdateMixin
Mixin that provides update capabilities for controllers. This separates the update logic from the controller base class.

Extensions

BoolExtension on bool
Extension on bool providing methods to create reactive booleans.
DoubleExtension on double
Extension on double providing methods to create reactive doubles.
IntExtension on int
Extension on int providing methods to create reactive integers.
ListExtension on List<E>
MapExtension on Map<K, V>
RxBoolExt on Rx<bool>
Extension on Rx<bool> providing methods for boolean operations.
RxDoubleExt on Rx<double>
Extension providing additional functionality for double values wrapped in an Rx object.
RxIntExt on Rx<int>
Extension providing additional functionality for int values wrapped in an Rx object.
RxnBoolExt on Rx<bool?>
Extension on Rx<bool?> providing methods for nullable boolean operations.
RxnDoubleExt on Rx<double?>
Extension providing additional functionality for nullable double values wrapped in an Rx object.
RxnIntExt on Rx<int?>
Extension providing additional functionality for nullable int values wrapped in an Rx object.
RxnNumExt on Rx<T?>
Extension providing additional functionality for nullable numeric values wrapped in an Rx object.
RxnStringExt on Rx<String?>
RxNumExt on Rx<T>
Extension providing additional functionality for numeric values wrapped in an Rx object.
RxStringExt on Rx<String>
Extension methods for Rx<String> to provide additional functionality.
RxT on T
Generic extension for creating reactive instances of any custom type T.
RxTnew on Object
A new method to replace the old .obs getter. This method avoids conflicts with Dart 3 features by using contextual type inference to determine T.
SetExtension on Set<E>
StateAccessExtension on BuildContext
Extension methods for accessing state in the context of a widget build.
StateExtension on StateMixin<T>
Extension methods for the StateMixin class.
StatusDataExtension on GetStatus<T>
Extension methods for the GetStatus class.
StringExtension on String
Extension on String providing methods to create reactive strings.

Properties

Get → _GetImpl
Global instance of GetX controller.
final

Functions

debounce<T>(GetListenable<T> listener, WorkerCallback<T> callback, {Duration? time, Function? onError, void onDone()?, bool? cancelOnError}) → Worker
debounce is similar to interval, but sends the last value. Useful for Anti DDos, every time the user stops typing for 1 second, for instance. When listener emits the last "value", when time hits, it calls callback with the last "value" emitted.
defaultLogWriterCallback(String value, {bool isError = false}) → void
The default logger function used by Refreshed for writing logs.
ever<T>(GetListenable<T> listener, WorkerCallback<T> callback, {dynamic condition = true, Function? onError, void onDone()?, bool? cancelOnError}) → Worker
Called every time listener changes. As long as the condition returns true.
everAll(List<RxInterface> listeners, WorkerCallback callback, {dynamic condition = true, Function? onError, void onDone()?, bool? cancelOnError}) → Worker
Similar to ever, but takes a list of listeners, the condition for the callback is common to all listeners, and the callback is executed to each one of them. The Worker is common to all, so worker.dispose() will cancel all streams.
interval<T>(GetListenable<T> listener, WorkerCallback<T> callback, {Duration time = const Duration(seconds: 1), dynamic condition = true, Function? onError, void onDone()?, bool? cancelOnError}) → Worker
Ignore all changes in listener during time (1 sec by default) or until condition is met (can be a bool expression or a bool Function()), It brings the 1st "value" since the period of time, so if you click a counter button 3 times in 1 sec, it will show you "1" (after 1 sec of the first press) click counter 3 times in 1 sec, it will show you "4" (after 1 sec) click counter 2 times in 1 sec, it will show you "7" (after 1 sec).
once<T>(GetListenable<T> listener, WorkerCallback<T> callback, {dynamic condition = true, Function? onError, void onDone()?, bool? cancelOnError}) → Worker
once() will execute only 1 time when condition is met and cancel the subscription to the listener stream right after that. condition defines when callback is called, and can be a bool or a bool Function().

Typedefs

Disposer = void Function()
This callback removes the listener when called.
GetControllerBuilder<T extends GetLifeCycleMixin> = Widget Function(T controller)
Signature for a function that builds a widget with a controller of type T.
GetStateUpdate = void Function()
Replaces StateSetter, returning whether the Widget is mounted for extra validation. If this brings overhead, consider removing the extra call.
GetXControllerBuilder<T extends GetLifeCycleMixin> = Widget Function(T controller)
A typedef for a function that builds a widget based on a GetX controller.
InitBuilder<T> = T Function()
Signature for a function that creates an object of type T.
LogWriterCallback = void Function(String text, {bool isError})
A typedef representing a callback function for writing logs, typically used in the context of Refreshed.
NotifierBuilder<T> = Widget Function(T state)
A builder function for creating widgets based on a state.
ValueBuilderBuilder<T> = Widget Function(T snapshot, ValueBuilderUpdateCallback<T> updater)
A function that builds a widget based on the current value and an updater function.
ValueBuilderUpdateCallback<T> = void Function(T snapshot)
A callback function that is called when the ValueBuilder updates its value.
ValueUpdater<T> = T Function()
A function type representing a value updater.
WidgetCallback = Widget Function()
Callback signature for a widget builder function.
WorkerCallback<T> = dynamic Function(T callback)
A typedef representing a callback function used by workers.

Exceptions / Errors

BindError<T>
A class representing an error encountered during binding resolution.
ObxError
Represents an error specific to the use of GetX or Obx.