Injector class Null safety

A widget used to provide a business logic model to the widget tree, and make one instance of the model available to all its children.

//Your pure dare model
class Foo {}

//Your user interface
class App extends StatelessWidget {
  Widget build(BuildContext context) {
    return Injector(
      inject: [Inject(() => Foo())],
      builder: (BuildContext context) {
        return ChildWidgetTree();

With Injector you can inject multiple dependent or independent models (BloCs, Services) at the same time. Also you can inject stream and future.

 inject: [
   //The order is not mandatory even for dependent models.
   Inject<ModelA>(() => ModelA()),
   Inject(() => ModelB()),//Generic type in inferred.
   Inject(() => ModelC(Injector.get<ModelA>())),// Directly inject ModelA in ModelC constructor
   Inject(() => ModelC(Injector.get())),// Type in inferred.
   Inject<IModelD>(() => ModelD()),// Register with Interface type.
   Inject<IModelE>({ //Inject through interface with environment flavor.
     'prod': ()=>ModelImplA(),
     'test': ()=>ModelImplB(),
   }), // you have to set the `Inject.env = 'prod'` before `runApp` method
   //You can inject streams and future and make them accessible to all the widget tree.
   Inject<bool>.future(() => Future(), initialValue:0),// Register a future.
   Inject<int>.stream(() => Stream()),// Register a stream.
   Inject(() => ModelD(),name:"customName"), // Use custom name

   //Inject and reinject with previous value provided.
   Inject<ModelA>.previous((ModelA previous){
     return ModelA(id:;
 builder: (BuildContext context) {
        return ChildWidgetTree();

Models are registered lazily by default. That is, they will not be instantiated until they are first used. To instantiate a particular model at the time of registration, you can set the isLazy variable of the class Inject to false.

To consume any of the above injected model you can use :

IN.get<Foo>(); // to get the injected instance (equivalent to Injector.get<Foo>())
RM.get<Foo>(); // to get the injected instance decorated with ReactiveModel  (equivalent to Injector.getAsReactive<Foo>())

You can injected asynchronously dependent object

   inject: [
       //Inject the first future
       Inject<FutureA>.future(() => futureA()),
       //Inject the second future that depends on the first future
         () async => futureB(await RM.get<FutureA>().stateAsync),
       //Inject the third future that depends on the second future
         () async => futureC(await RM.get<FutureB>().stateAsync),
   builder: (context) {
       return WhenRebuilderOr(
       observe: () => RM.get<FutureC>(),
       onWaiting: () => CircularProgressIndicator(),
       builder: (context, futureCRM) {
           //here the three future are resolved and their values can be obtained
           final futureAValue = IN.get<FutureA>();
           final futureBValue = IN.get<FutureB>();
           final futureCValue = IN.get<FutureC>();

see also : ReactiveModel, RM.get and IN.get.



Injector({Key? key, required List<Injectable> inject, required Widget builder(BuildContext), void initState()?, void dispose()?, void afterInitialBuild(BuildContext context)?, void appLifeCycle(AppLifecycleState)?, List<ReactiveModel>? reinjectOn, bool shouldNotifyOnReinjectOn = true})
A class used to register (inject) models.


afterInitialBuild → (void Function?(BuildContext context)?)
Called after the widget is inserted in the widget tree.
appLifeCycle → (void Function?(AppLifecycleState)?)
Function to track app life cycle state. It takes as parameter the AppLifeCycleState.
builder Widget Function(BuildContext)
The builder closure. It takes as parameter the context.
dispose → (void Function?()?)
Function to execute in dispose of the state.
hashCode int
The hash code for this object. [...]
@nonVirtual, read-only, inherited
initState → (void Function?()?)
Function to execute in initState of the state.
inject List<Injectable>
List of models to register (inject). [...]
key Key?
Controls how one widget replaces another widget in the tree. [...]
final, inherited
reinjectOn List<ReactiveModel>?
Refresh the list of inject model, whenever any of the observables in the reinjectOn emits a notification
runtimeType Type
A representation of the runtime type of the object.
read-only, inherited
shouldNotifyOnReinjectOn bool
By default refreshed model from reinjectOn will notify their observers. [...]


createElement() StatefulElement
Creates a StatefulElement to manage this widget's location in the tree. [...]
createState() State<Injector>
Creates the mutable state for this widget at a given location in the tree. [...]
debugDescribeChildren() List<DiagnosticsNode>
Returns a list of DiagnosticsNode objects describing this node's children. [...]
@protected, inherited
debugFillProperties(DiagnosticPropertiesBuilder properties) → void
Add additional properties associated with the node. [...]
noSuchMethod(Invocation invocation) → dynamic
Invoked when a non-existent method or property is accessed. [...]
toDiagnosticsNode({String? name, DiagnosticsTreeStyle? style}) DiagnosticsNode
Returns a debug representation of the object that is used by debugging tools and by DiagnosticsNode.toStringDeep. [...]
toString({DiagnosticLevel minLevel =}) String
A string representation of this object. [...]
toStringDeep({String prefixLineOne = '', String? prefixOtherLines, DiagnosticLevel minLevel = DiagnosticLevel.debug}) String
Returns a string representation of this node and its descendants. [...]
toStringShallow({String joiner = ', ', DiagnosticLevel minLevel = DiagnosticLevel.debug}) String
Returns a one-line detailed description of the object. [...]
toStringShort() String
A short, textual description of this widget.


operator ==(Object other) bool
The equality operator. [...]
@nonVirtual, inherited

Static Properties

enableTestMode bool
set to true for test. It allows for injecting mock instances.
read / write

Static Methods

get<T>({dynamic name, bool silent = false}) → T
Get the singleton instance of a model registered with Injector.
getAsReactive<T>({dynamic name, bool silent = false}) ReactiveModel<T>
Get the singleton ReactiveModel instance of a model registered with Injector.