LCOV - code coverage report
Current view: top level - src/state - get_state.dart (source / functions) Hit Total Coverage
Test: lcov.info Lines: 58 59 98.3 %
Date: 2020-07-01 03:00:01 Functions: 0 0 -

          Line data    Source code
       1             : import 'dart:collection';
       2             : import 'package:flutter/widgets.dart';
       3             : import 'package:get/src/instance/get_instance.dart';
       4             : import 'package:get/src/root/smart_management.dart';
       5             : import 'package:get/src/state_manager/rx/rx_interface.dart';
       6             : 
       7             : class GetxController extends DisposableInterface {
       8             :   final HashSet<Updater> _updaters = HashSet<Updater>();
       9             : 
      10             :   /// Update GetBuilder with update();
      11           1 :   void update([List<String> ids, bool condition = true]) {
      12             :     if (!condition) return;
      13             :     (ids == null)
      14           3 :         ? _updaters.forEach((rs) {
      15           3 :             rs.updater(() {});
      16             :           })
      17           1 :         : _updaters
      18           4 :             .where((element) => ids.contains(element.id))
      19           5 :             .forEach((rs) => rs.updater(() {}));
      20             :   }
      21             : 
      22             :   @override
      23           7 :   void onInit() async {}
      24             : 
      25             :   @override
      26           6 :   void onReady() async {}
      27             : 
      28             :   @override
      29           6 :   void onClose() async {}
      30             : }
      31             : 
      32             : class GetBuilder<T extends GetxController> extends StatefulWidget {
      33             :   final Widget Function(T) builder;
      34             :   final bool global;
      35             :   final String id;
      36             :   final String tag;
      37             :   final bool autoRemove;
      38             :   final bool assignId;
      39             :   final void Function(State state) initState, dispose, didChangeDependencies;
      40             :   final void Function(GetBuilder oldWidget, State state) didUpdateWidget;
      41             :   final T init;
      42           5 :   const GetBuilder({
      43             :     Key key,
      44             :     this.init,
      45             :     this.global = true,
      46             :     @required this.builder,
      47             :     this.autoRemove = true,
      48             :     this.assignId = false,
      49             :     this.initState,
      50             :     this.tag,
      51             :     this.dispose,
      52             :     this.id,
      53             :     this.didChangeDependencies,
      54             :     this.didUpdateWidget,
      55           1 :   })  : assert(builder != null),
      56           5 :         super(key: key);
      57           5 :   @override
      58           5 :   _GetBuilderState<T> createState() => _GetBuilderState<T>();
      59             : }
      60             : 
      61             : class _GetBuilderState<T extends GetxController> extends State<GetBuilder<T>> {
      62             :   T controller;
      63             :   Updater real;
      64             :   bool isCreator = false;
      65           5 :   @override
      66             :   void initState() {
      67           5 :     super.initState();
      68             : 
      69          10 :     if (widget.global) {
      70          20 :       final isPrepared = GetInstance().isPrepared<T>(tag: widget.tag);
      71          20 :       final isRegistred = GetInstance().isRegistred<T>(tag: widget.tag);
      72             : 
      73             :       if (isPrepared) {
      74           2 :         if (GetConfig.smartManagement != SmartManagement.keepFactory) {
      75           1 :           isCreator = true;
      76             :         }
      77           5 :         controller = GetInstance().find<T>(tag: widget.tag);
      78           5 :         real = Updater(updater: setState, id: widget.id);
      79           4 :         controller._updaters.add(real);
      80             :       } else if (isRegistred) {
      81           5 :         controller = GetInstance().find<T>(tag: widget.tag);
      82           1 :         isCreator = false;
      83           5 :         real = Updater(updater: setState, id: widget.id);
      84           4 :         controller._updaters.add(real);
      85             :       } else {
      86          15 :         controller = widget.init;
      87           5 :         isCreator = true;
      88          25 :         real = Updater(updater: setState, id: widget.id);
      89          20 :         controller._updaters.add(real);
      90          25 :         GetInstance().put<T>(controller, tag: widget.tag);
      91             :       }
      92             :     } else {
      93           3 :       controller = widget.init;
      94           1 :       isCreator = true;
      95           5 :       real = Updater(updater: setState, id: widget.id);
      96           4 :       controller._updaters.add(real);
      97           2 :       controller?.onStart();
      98             :     }
      99          19 :     if (widget.initState != null) widget.initState(this);
     100          15 :     if (isCreator && GetConfig.smartManagement == SmartManagement.onlyBuilder) {
     101           0 :       controller?.onStart();
     102             :     }
     103             :   }
     104             : 
     105           5 :   @override
     106             :   void dispose() {
     107           5 :     super.dispose();
     108          19 :     if (widget.dispose != null) widget.dispose(this);
     109           7 :     if (isCreator || widget.assignId) {
     110          30 :       if (widget.autoRemove && GetInstance().isRegistred<T>(tag: widget.tag)) {
     111          20 :         controller._updaters.remove(real);
     112          20 :         GetInstance().delete<T>(tag: widget.tag);
     113             :       }
     114             :     } else {
     115           4 :       controller._updaters.remove(real);
     116             :     }
     117             :   }
     118             : 
     119           5 :   @override
     120             :   void didChangeDependencies() {
     121           5 :     super.didChangeDependencies();
     122          10 :     if (widget.didChangeDependencies != null) {
     123           3 :       widget.didChangeDependencies(this);
     124             :     }
     125             :   }
     126             : 
     127           2 :   @override
     128             :   void didUpdateWidget(GetBuilder oldWidget) {
     129           2 :     super.didUpdateWidget(oldWidget as GetBuilder<T>);
     130           4 :     if (widget.didUpdateWidget != null) widget.didUpdateWidget(oldWidget, this);
     131             :   }
     132             : 
     133           5 :   @override
     134             :   Widget build(BuildContext context) {
     135          20 :     return widget.builder(controller);
     136             :   }
     137             : }
     138             : 
     139             : class Updater {
     140             :   final StateSetter updater;
     141             :   final String id;
     142           5 :   const Updater({this.updater, this.id});
     143             : }

Generated by: LCOV version 1.14