Injector class

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 {
  @override
  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.

Injector(
 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: previous.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

Injector(
   inject: [
       //Inject the first future
       Inject<FutureA>.future(() => futureA()),
       //Inject the second future that depends on the first future
       Inject<FutureB>.future(
         () async => futureB(await RM.get<FutureA>().stateAsync),
       ),
       //Inject the third future that depends on the second future
       Inject<FutureC>.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.

Inheritance

Constructors

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.
const

Properties

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

Methods

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

Operators

operator ==(Object other) → bool: The equality operator.
inherited

Static Properties

enableTestMode ↔ bool: set to true for test. It allows for injecting mock instances.
getter/setter pair

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.