Merge pull request #565 from roipeker/master

improve docs, cleanup workers, added samples, fixed rx operators

@@ -59,55 +59,101 @@ var name = 'Jonatas Borges'.obs;
 
 
 That's all. It's *that* simple.
 That's all. It's *that* simple.
 
 
-What did we do under the hood? We created a stream of Strings, assigned the initial value "Jonatas Borges", we warn all widgets that use "Jonatas Borges" that they now belong to this variable, and when it is changed, they will be changed too. This is the magic of Get, that only dart allows us to do this.
+From now on, we might refer to this reactive-".obs"(ervables) variables as _Rx_.   
 
 
-Okay, but as we know, a widget can only be changed if it is inside a function, because static classes do not have the power to "auto-change". You will need to create a StreamBuilder, subscribe to listen to this variable, and create a "cascade" of StreamBuilder if you want to change several variables in the same scope, right?
-No, you don't need a StreamBuilder, but you are right about static classes.
+What did we do under the hood? We created a `Stream` of `String`s, assigned the initial value `"Jonatas Borges"`, we notified all widgets that use `"Jonatas Borges"` that they now "belong" to this variable, and when the _Rx_ value changes, they will have to change as well. 
 
 
-Well, in the view we usually have a lot of boilerplate when we want to change a specific widget. With Get you can also forget about this Boilerplate. StreamBuilder? initialValue? builder?
-No, you just need to play this variable inside an Obx widget.
+This is the **magic of GetX**, thanks to Dart's capabilities.
+
+But, as we know, a `Widget` can only be changed if it is inside a function, because static classes do not have the power to "auto-change". 
+
+You will need to create a `StreamBuilder`, subscribe to this variable to listen for changes, and create a "cascade" of nested `StreamBuilder` if you want to change several variables in the same scope, right?
+
+No, you don't need a `StreamBuilder`, but you are right about static classes.
+
+Well, in the view, we usually have a lot of boilerplate when we want to change a specific Widget, that's the Flutter way. 
+With **GetX** you can also forget about this boilerplate code. 
+
+`StreamBuilder( … )`? `initialValue: …`? `builder: …`? Nope, you just need to place this variable inside an `Obx()` Widget.
 
 
 ```dart
 ```dart
 Obx (() => Text (controller.name));
 Obx (() => Text (controller.name));
 ```
 ```
 
 
-What do you need to memorize? Only `Obx(() =>`. You are just passing that widget through an arrow-function into an Obx. Obx is smart, and will only be changed if the value of name is changed. If name is "John" and you change it to "John", it will not have any changes on the screen, and Obx will simply ignore this change, and will not rebuild the widget, to save resources. Isn't that amazing?
+_What do you need to memorize?_  Only `Obx(() =>`. 
+
+You are just passing that Widget through an arrow-function into an `Obx()` (the "Observer" of the _Rx_). 
+
+`Obx` is pretty smart, and will only change if the value of `controller.name` changes. 
+
+If `name` is `"John"`, and you change it to `"John"` (`name.value = "John"`), as it's the same `value` as before, nothing will change on the screen, and `Obx`, to save resources, will simply ignore the new value and not rebuild the Widget. **Isn't that amazing?**
 
 
-What if I have 5 observable variables within an Obx? It will update when any of them are changed. And if I have 30 variables in a class, when I update one, will it update all variables that are in that class? No, just the specific widget that uses that variable.
+> So, what if I have 5 _Rx_ (observable) variables within an `Obx`?
 
 
-GetX only updates the screen when the variable changes on the screen, if the screen remains the same, it will not reconstruct anything.
+It will just update when **any** of them changes. 
 
 
+> And if I have 30 variables in a class, when I update one, will it update **all** the variables that are in that class?
+
+Nope, just the **specific Widget** that uses that _Rx_ variable.
+
+So, **GetX** only updates the screen, when the _Rx_ variable changes it's value.
+
+```
+final isOpen = false.obs;
+
+// NOTHING will happen... same value.
+void onButtonTap() => isOpen.value=false;
+```
 ### Advantages
 ### Advantages
 
 
-GetX is focused for when you need granular control over what is being updated. Is for situations where you want only the widget when a certain variable has been changed to be rebuilt.
+**GetX()** helps you when you need **granular** control over what's being updated.
+
+If you do not need `unique IDs`, because all your variables will be modified when you perform an action, then use `GetBuilder`, 
+because it's a Simple State Updater (in blocks, like `setState()`), made in just a few lines of code.
+It was made simple, to have the least CPU impact, and just to fulfill a single purpose (a _State_ rebuild) and spend the minimum resources possible.
 
 
-If you do not need unique IDs, because all your variables will be changed when you perform an action, use GetBuilder, because it is a simple state updater in blocks, made in a few lines of code. It was done in a simple way, to have the least computational logic involved, just to fulfill a single purpose and spend the minimum resources possible for that purpose.
+If you need a **powerful** State Manager, you can't go wrong with **GetX**.
 
 
-If you want a powerful state manager, you can go without fear to GetX. It does not work with variables, but flows, everything in it is streams under the hood. You can use rxDart in conjunction with it, because everything is stream, you can hear the event of each "variable", because everything in it is stream, it is literally BLoC, easier than MobX, and without code generator or decorations .
+It doesn't work with variables, but __flows__, everything in it are `Streams` under the hood. 
+You can use _rxDart_ in conjunction with it, because everything are `Streams`, 
+you can listen the `event` of each "_Rx_ variable", 
+because everything in it are `Streams`. 
 
 
-Without decorations, you can turn anything into Observable with just a ".obs".
+It is literally a _BLoC_ approach, easier than _MobX_, and without code generators or decorations.
+You can turn **anything** into an _"Observable"_ with just a `.obs`.
 
 
-Maximum performance: In addition to having a smart algorithm for minimal reconstruction, Get uses comparators to make sure the state has changed. If you experience any errors in your application, and send a duplicate change of state, Get will ensure that your application does not collapse.
+### Maximum performance:
 
 
-The state only changes if the values ​​change. That's the main difference between Get, and using Computed from MobX for example. When joining two observables, when one is changed, the hearing of that observable will change. With Get, if you join two variables (which is unnecessary computed for that), GetX (similar to Observer) will only change if it implies a real change of state.
+In addition to having a smart algorithm for minimal rebuilds, **GetX** uses comparators 
+to make sure the State has changed. 
+
+If you experience any errors in your app, and send a duplicate change of State, 
+**GetX** will ensure it will not crash.
+
+With **GetX** the State only changes if the `value` change. 
+That's the main difference between **GetX**, and using _`computed` from MobX_. 
+When joining two __observables__, and one changes; the listener of that _observable_ will change as well.
+
+With **GetX**, if you join two variables, `GetX()` (similar to `Observer()`) will only rebuild if it implies a real change of State.
 
 
 ### Declaring a reactive variable
 ### Declaring a reactive variable
 
 
-You have 3 ways to turn a variable into an observable.
-The first is using Rx{Type}.
+You have 3 ways to turn a variable into an "observable".
+
+
+1 - The first is using **`Rx{Type}`**.
 
 
 ```dart
 ```dart
-// initial value is recommended but not mandatory
+// initial value is recommended, but not mandatory
 final name = RxString('');
 final name = RxString('');
 final isLogged = RxBool(false);
 final isLogged = RxBool(false);
 final count = RxInt(0);
 final count = RxInt(0);
 final balance = RxDouble(0.0);
 final balance = RxDouble(0.0);
-final number = RxNum(0)
 final items = RxList<String>([]);
 final items = RxList<String>([]);
 final myMap = RxMap<String, int>({});
 final myMap = RxMap<String, int>({});
 ```
 ```
 
 
-The second is to use Rx and type it with `Rx<Type>`
+2 - The second is to use **`Rx`** and use Darts Generics, `Rx<Type>`
 
 
 ```dart
 ```dart
 final name = Rx<String>('');
 final name = Rx<String>('');
@@ -122,7 +168,7 @@ final myMap = Rx<Map<String, int>>({});
 final user = Rx<User>();
 final user = Rx<User>();
 ```
 ```
 
 
-The third, more practical and easier approach, is just to add an .obs to your variable.
+3 - The third, more practical, easier and preferred approach, just add **`.obs`** as a property of your `value`:
 
 
 ```dart
 ```dart
 final name = ''.obs;
 final name = ''.obs;
@@ -137,9 +183,16 @@ final myMap = <String, int>{}.obs;
 final user = User().obs;
 final user = User().obs;
 ```
 ```
 
 
-As we know, Dart is now heading towards null safety. Since that it is a good idea, from now on, you should start to use your variables always with an initial value. Transforming a variable into an observable with an initial value with Get is the simplest and most practical approach. You will literally add a ".obs" to the end of your variable, and that’s it, you’ve made it observable, and its value will be the initial value.
+##### Having a reactive state, is easy.
+
+As we know, _Dart_ is now heading towards _null safety_.
+To be prepared, from now on, you should always start your _Rx_ variables with an **initial value**.
+
+> Transforming a variable into an _observable_ + _initial value_ with **GetX** is the simplest, and most practical approach.
+
+You will literally add a "`.obs`" to the end of your variable, and **that’s it**, you’ve made it observable,
+and its `.value`, well, will be the _initial value_).
 
 
-You can add variables, and if you want to type your widget to get your controller inside, you just need to use GetX widget instead of Obx
 
 
 ### Using the values in the view
 ### Using the values in the view
 
 
@@ -172,22 +225,31 @@ GetX<Controller>(
 ),
 ),
 ```
 ```
 
 
-If we increment the number of count 1, only count 1 and count 3 are reconstructed, because count 1 now has a value of 1, and 1 + 0 = 1, changing the sum value.
+If we increment `count1.value++`, it will print:
+- `count 1 rebuild` 
+- `count 3 rebuild`
 
 
-If we change count 2, only count2 and 3 are reconstructed, because the value of 2 has changed, and the result of the sum is now 2.
+because `count1` has a value of `1`, and `1 + 0 = 1`, changing the `sum` getter value.
 
 
-If we add the number 1 to count 1, which already contains 1, no widget is reconstructed. If we add a value of 1 for count 1 and a value of 2 for count 2, only 2 and 3 will be reconstructed, simply because GetX not only changes what is necessary, it avoids duplicating events.
+If we change `count2.value++`, it will print:
+- `count 2 rebuild` 
+- `count 3 rebuild`
+
+because `count2.value` changed, and the result of the `sum` is now `2`.
+
+- NOTE: By default, the very first event will rebuild the widget, even if it is the same `value`.
+ This behavior exists due to Boolean variables.
 
 
-- NOTE: By default, the first event will allow rebuild even if it is the same. We created this behavior due to dualistic variables, such as Boolean.
 Imagine you did this:
 Imagine you did this:
 
 
 ```dart
 ```dart
 var isLogged = false.obs;
 var isLogged = false.obs;
 ```
 ```
 
 
-and then you check if a user is logged in to trigger an event in "ever".
+And then, you checked if a user is "logged in" to trigger an event in `ever`.
 
 
 ```dart
 ```dart
+@override
 onInit(){
 onInit(){
   ever(isLogged, fireRoute);
   ever(isLogged, fireRoute);
   isLogged.value = await Preferences.hasToken();
   isLogged.value = await Preferences.hasToken();
@@ -202,7 +264,10 @@ fireRoute(logged) {
 }
 }
 ```
 ```
 
 
-if hasToken was false, there would be no change to isLogged, so ever would never be called. To avoid this type of behavior, the first change to an observable will always trigger an event, even if it is the same.
+if `hasToken` was `false`, there would be no change to `isLogged`, so `ever()` would never be called.
+To avoid this type of behavior, the first change to an _observable_ will always trigger an event, 
+even if it contains the same `.value`.
+
 You can remove this behavior if you want, using:
 You can remove this behavior if you want, using:
 `isLogged.firstRebuild = false;`
 `isLogged.firstRebuild = false;`
 
 
@@ -311,13 +376,13 @@ The "assignAll" api will clear the existing list and add any iterable objects th
 
 
 ### Why i have to use .value
 ### Why i have to use .value
 
 
-We could remove the obligation to use 'value' to String and int with a simple decoration and code generator, but the purpose of this lib is precisely not to need any external dependency. It is to offer an environment ready for programming, involving the essentials (management of routes, dependencies and states), in a simple, light and performance way without needing any external package.
+We could remove the obligation to use 'value' to `String` and `int` with a simple decoration and code generator, but the purpose of this library is precisely avoid external dependencies. We want to offer an environment ready for programming, involving the essentials (management of routes, dependencies and states), in a simple, lightweight and performant way, without a need of an external package.
 
 
 You can literally add 3 letters to your pubspec (get) and a colon and start programming. All solutions included by default, from route management to state management, aim at ease, productivity and performance.
 You can literally add 3 letters to your pubspec (get) and a colon and start programming. All solutions included by default, from route management to state management, aim at ease, productivity and performance.
 
 
 The total weight of this library is less than that of a single state manager, even though it is a complete solution, and that is what you must understand.
 The total weight of this library is less than that of a single state manager, even though it is a complete solution, and that is what you must understand.
 
 
-If you are bothered by value, and like a code generator, MobX is a great alternative, and you can use it in conjunction with Get. For those who want to add a single dependency in pubspec and start programming without worrying about the version of a package being incompatible with another, or if the error of a state update is coming from the state manager or dependency, or still, do not want to worrying about the availability of controllers, whether literally "just programming", get is just perfect.
+If you are bothered by `.value`, and like a code generator, MobX is a great alternative, and you can use it in conjunction with Get. For those who want to add a single dependency in pubspec and start programming without worrying about the version of a package being incompatible with another, or if the error of a state update is coming from the state manager or dependency, or still, do not want to worrying about the availability of controllers, whether literally "just programming", get is just perfect.
 
 
 If you have no problem with the MobX code generator, or have no problem with the BLoC boilerplate, you can simply use Get for routes, and forget that it has state manager. Get SEM and RSM were born out of necessity, my company had a project with more than 90 controllers, and the code generator simply took more than 30 minutes to complete its tasks after a Flutter Clean on a reasonably good machine, if your project it has 5, 10, 15 controllers, any state manager will supply you well. If you have an absurdly large project, and code generator is a problem for you, you have been awarded this solution.
 If you have no problem with the MobX code generator, or have no problem with the BLoC boilerplate, you can simply use Get for routes, and forget that it has state manager. Get SEM and RSM were born out of necessity, my company had a project with more than 90 controllers, and the code generator simply took more than 30 minutes to complete its tasks after a Flutter Clean on a reasonably good machine, if your project it has 5, 10, 15 controllers, any state manager will supply you well. If you have an absurdly large project, and code generator is a problem for you, you have been awarded this solution.
 
 
@@ -333,7 +398,7 @@ Obviously, if you don't use a type, you will need to have an instance of your co
 Workers will assist you, triggering specific callbacks when an event occurs.
 Workers will assist you, triggering specific callbacks when an event occurs.
 
 
 ```dart
 ```dart
-/// Called every time the variable $_ is changed
+/// Called every time `count1` changes.
 ever(count1, (_) => print("$_ has been changed"));
 ever(count1, (_) => print("$_ has been changed"));
 
 
 /// Called only first time the variable $_ is changed
 /// Called only first time the variable $_ is changed
@@ -345,17 +410,25 @@ debounce(count1, (_) => print("debouce$_"), time: Duration(seconds: 1));
 /// Ignore all changes within 1 second.
 /// Ignore all changes within 1 second.
 interval(count1, (_) => print("interval $_"), time: Duration(seconds: 1));
 interval(count1, (_) => print("interval $_"), time: Duration(seconds: 1));
 ```
 ```
+All workers (except `debounce`) have a `condition` named parameter, which can be a `bool` or a callback that returns a `bool`.
+This `condition` defines when the `callback` function executes.
+
+All workers returns a `Worker` instance, that you can use to cancel ( via `dispose()` ) the worker.
+ 
+- **`ever`**
+ is called every time the _Rx_ variable emits a new value.
+
+- **`everAll`**
+ Much like `ever`, but it takes a `List` of _Rx_ values Called every time its variable is changed. That's it.
 
 
-- ever
-'ever' is called every time its variable is changed. That's it.
 
 
-- ever
+- **`once`**
 'once' is called only the first time the variable has been changed.
 'once' is called only the first time the variable has been changed.
 
 
-- debounce
+- **`debounce`**
 'debounce' is very useful in search functions, where you only want the API to be called when the user finishes typing. If the user types "Jonny", you will have 5 searches in the APIs, by the letter J, o, n, n, and y. With Get this does not happen, because you will have a "debounce" Worker that will only be triggered at the end of typing.
 'debounce' is very useful in search functions, where you only want the API to be called when the user finishes typing. If the user types "Jonny", you will have 5 searches in the APIs, by the letter J, o, n, n, and y. With Get this does not happen, because you will have a "debounce" Worker that will only be triggered at the end of typing.
 
 
-- interval
+- **`interval`**
 'interval' is different from the debouce. debouce if the user makes 1000 changes to a variable within 1 second, he will send only the last one after the stipulated timer (the default is 800 milliseconds). Interval will instead ignore all user actions for the stipulated period. If you send events for 1 minute, 1000 per second, debounce will only send you the last one, when the user stops strafing events. interval will deliver events every second, and if set to 3 seconds, it will deliver 20 events that minute. This is recommended to avoid abuse, in functions where the user can quickly click on something and get some advantage (imagine that the user can earn coins by clicking on something, if he clicked 300 times in the same minute, he would have 300 coins, using interval, you you can set a time frame for 3 seconds, and even then clicking 300 or a thousand times, the maximum he would get in 1 minute would be 20 coins, clicking 300 or 1 million times). The debounce is suitable for anti-DDos, for functions like search where each change to onChange would cause a query to your api. Debounce will wait for the user to stop typing the name, to make the request. If it were used in the coin scenario mentioned above, the user would only win 1 coin, because it is only executed, when the user "pauses" for the established time.
 'interval' is different from the debouce. debouce if the user makes 1000 changes to a variable within 1 second, he will send only the last one after the stipulated timer (the default is 800 milliseconds). Interval will instead ignore all user actions for the stipulated period. If you send events for 1 minute, 1000 per second, debounce will only send you the last one, when the user stops strafing events. interval will deliver events every second, and if set to 3 seconds, it will deliver 20 events that minute. This is recommended to avoid abuse, in functions where the user can quickly click on something and get some advantage (imagine that the user can earn coins by clicking on something, if he clicked 300 times in the same minute, he would have 300 coins, using interval, you you can set a time frame for 3 seconds, and even then clicking 300 or a thousand times, the maximum he would get in 1 minute would be 20 coins, clicking 300 or 1 million times). The debounce is suitable for anti-DDos, for functions like search where each change to onChange would cause a query to your api. Debounce will wait for the user to stop typing the name, to make the request. If it were used in the coin scenario mentioned above, the user would only win 1 coin, because it is only executed, when the user "pauses" for the established time.
 
 
 ## Simple State Manager
 ## Simple State Manager

@@ -19,8 +19,14 @@ import '../navigation/routes/transitions_type.dart';
 abstract class GetInterface {
 abstract class GetInterface {
   bool defaultPopGesture = GetPlatform.isIOS;
   bool defaultPopGesture = GetPlatform.isIOS;
   bool defaultOpaqueRoute = true;
   bool defaultOpaqueRoute = true;
+
   Transition defaultTransition;
   Transition defaultTransition;
-  Duration defaultDurationTransition = Duration(milliseconds: 400);
+  Duration defaultTransitionDuration = Duration(milliseconds: 400);
+  Curve defaultTransitionCurve = Curves.easeOutQuad;
+
+  Curve defaultDialogTransitionCurve = Curves.easeOutQuad;
+  Duration defaultDialogTransitionDuration = Duration(milliseconds: 400);
+
   bool defaultGlobalState = true;
   bool defaultGlobalState = true;
   RouteSettings settings;
   RouteSettings settings;
   String defaultSeparator = "_";
   String defaultSeparator = "_";

@@ -43,6 +43,7 @@ extension GetNavigation on GetInterface {
     Widget page, {
     Widget page, {
     bool opaque,
     bool opaque,
     Transition transition,
     Transition transition,
+    Curve curve,
     Duration duration,
     Duration duration,
     int id,
     int id,
     bool fullscreenDialog = false,
     bool fullscreenDialog = false,
@@ -66,9 +67,10 @@ extension GetNavigation on GetInterface {
             ),
             ),
             popGesture: popGesture ?? defaultPopGesture,
             popGesture: popGesture ?? defaultPopGesture,
             transition: transition ?? defaultTransition,
             transition: transition ?? defaultTransition,
+            curve: curve ?? defaultTransitionCurve,
             fullscreenDialog: fullscreenDialog,
             fullscreenDialog: fullscreenDialog,
             binding: binding,
             binding: binding,
-            transitionDuration: duration ?? defaultDurationTransition,
+            transitionDuration: duration ?? defaultTransitionDuration,
           ),
           ),
         );
         );
   }
   }
@@ -326,7 +328,8 @@ extension GetNavigation on GetInterface {
   /// It has the advantage of not needing context,
   /// It has the advantage of not needing context,
   /// so you can call from your business logic
   /// so you can call from your business logic
   ///
   ///
-  /// You can set a custom [transition], and a transition [duration].
+  /// You can set a custom [transition], define a Tween [curve],
+  /// and a transition [duration].
   ///
   ///
   /// You can send any type of value to the other route in the [arguments].
   /// You can send any type of value to the other route in the [arguments].
   ///
   ///
@@ -347,6 +350,7 @@ extension GetNavigation on GetInterface {
     Widget page, {
     Widget page, {
     bool opaque = false,
     bool opaque = false,
     Transition transition,
     Transition transition,
+    Curve curve,
     bool popGesture,
     bool popGesture,
     int id,
     int id,
     Object arguments,
     Object arguments,
@@ -368,7 +372,8 @@ extension GetNavigation on GetInterface {
         fullscreenDialog: fullscreenDialog,
         fullscreenDialog: fullscreenDialog,
         popGesture: popGesture ?? defaultPopGesture,
         popGesture: popGesture ?? defaultPopGesture,
         transition: transition ?? defaultTransition,
         transition: transition ?? defaultTransition,
-        transitionDuration: duration ?? defaultDurationTransition));
+        curve: curve ?? defaultTransitionCurve,
+        transitionDuration: duration ?? defaultTransitionDuration));
   }
   }
 
 
   /// **Navigation.pushAndRemoveUntil()** shortcut .<br><br>
   /// **Navigation.pushAndRemoveUntil()** shortcut .<br><br>
@@ -379,7 +384,7 @@ extension GetNavigation on GetInterface {
   /// It has the advantage of not needing context,
   /// It has the advantage of not needing context,
   /// so you can call from your business logic
   /// so you can call from your business logic
   ///
   ///
-  /// You can set a custom [transition], and a transition [duration].
+  /// You can set a custom [transition], a [curve] and a transition [duration].
   ///
   ///
   /// You can send any type of value to the other route in the [arguments].
   /// You can send any type of value to the other route in the [arguments].
   ///
   ///
@@ -411,8 +416,9 @@ extension GetNavigation on GetInterface {
     Object arguments,
     Object arguments,
     Bindings binding,
     Bindings binding,
     bool fullscreenDialog = false,
     bool fullscreenDialog = false,
-    Duration duration,
     Transition transition,
     Transition transition,
+    Curve curve,
+    Duration duration,
   }) {
   }) {
     var routeName = "/${page.runtimeType.toString()}";
     var routeName = "/${page.runtimeType.toString()}";
 
 
@@ -424,15 +430,19 @@ extension GetNavigation on GetInterface {
           binding: binding,
           binding: binding,
           settings: RouteSettings(arguments: arguments),
           settings: RouteSettings(arguments: arguments),
           fullscreenDialog: fullscreenDialog,
           fullscreenDialog: fullscreenDialog,
-            routeName: routeName,
+          routeName: routename,
           transition: transition ?? defaultTransition,
           transition: transition ?? defaultTransition,
-            transitionDuration: duration ?? defaultDurationTransition,
+          curve: curve ?? defaultTransitionCurve,
+          transitionDuration: duration ?? defaultTransitionDuration,
         ),
         ),
-          predicate ?? (_) => false,
-        );
+        predicate ?? route);
+
   }
   }
 
 
-  /// Show a dialog
+  /// Show a dialog.
+  /// You can pass a [transitionDuration] and/or [transitionCurve],
+  /// overriding the defaults when the dialog shows up and closes.
+  /// When the dialog closes, uses those animations in reverse.
   Future<T> dialog<T>(
   Future<T> dialog<T>(
     Widget widget, {
     Widget widget, {
     bool barrierDismissible = true,
     bool barrierDismissible = true,
@@ -440,6 +450,8 @@ extension GetNavigation on GetInterface {
     bool useSafeArea = true,
     bool useSafeArea = true,
     bool useRootNavigator = true,
     bool useRootNavigator = true,
     RouteSettings routeSettings,
     RouteSettings routeSettings,
+    Duration transitionDuration,
+    Curve transitionCurve,
   }) {
   }) {
     assert(widget != null);
     assert(widget != null);
     assert(barrierDismissible != null);
     assert(barrierDismissible != null);
@@ -464,12 +476,12 @@ extension GetNavigation on GetInterface {
       barrierDismissible: barrierDismissible,
       barrierDismissible: barrierDismissible,
       barrierLabel: MaterialLocalizations.of(context).modalBarrierDismissLabel,
       barrierLabel: MaterialLocalizations.of(context).modalBarrierDismissLabel,
       barrierColor: barrierColor ?? Colors.black54,
       barrierColor: barrierColor ?? Colors.black54,
-      transitionDuration: const Duration(milliseconds: 150),
+      transitionDuration: transitionDuration ?? defaultDialogTransitionDuration,
       transitionBuilder: (context, animation, secondaryAnimation, child) {
       transitionBuilder: (context, animation, secondaryAnimation, child) {
         return FadeTransition(
         return FadeTransition(
           opacity: CurvedAnimation(
           opacity: CurvedAnimation(
             parent: animation,
             parent: animation,
-            curve: Curves.easeOut,
+            curve: transitionCurve ?? defaultDialogTransitionCurve,
           ),
           ),
           child: child,
           child: child,
         );
         );
@@ -874,7 +886,7 @@ extension GetNavigation on GetInterface {
     }
     }
 
 
     if (defaultDurationTransition != null) {
     if (defaultDurationTransition != null) {
-      this.defaultDurationTransition = defaultDurationTransition;
+      this.defaultTransitionDuration = defaultDurationTransition;
     }
     }
 
 
     if (defaultGlobalState != null) {
     if (defaultGlobalState != null) {

 import 'package:flutter/foundation.dart';
 import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/material.dart';
-
 import '../../../get.dart';
 import '../../../get.dart';
 import '../../core/log.dart';
 import '../../core/log.dart';
 import '../../instance/get_instance.dart';
 import '../../instance/get_instance.dart';
@@ -211,7 +210,7 @@ class GetMaterialApp extends StatelessWidget {
             defaultOpaqueRoute: opaqueRoute ?? Get.isOpaqueRouteDefault,
             defaultOpaqueRoute: opaqueRoute ?? Get.isOpaqueRouteDefault,
             defaultPopGesture: popGesture ?? Get.isPopGestureEnable,
             defaultPopGesture: popGesture ?? Get.isPopGestureEnable,
             defaultDurationTransition:
             defaultDurationTransition:
-                transitionDuration ?? Get.defaultDurationTransition,
+                transitionDuration ?? Get.defaultTransitionDuration,
             defaultGlobalState: defaultGlobalState ?? Get.defaultGlobalState,
             defaultGlobalState: defaultGlobalState ?? Get.defaultGlobalState,
           );
           );
         },
         },

+import 'dart:ui';
 import '../../../get.dart';
 import '../../../get.dart';
 
 
 /// [Bindings] should be extended or implemented.
 /// [Bindings] should be extended or implemented.
@@ -18,14 +19,20 @@ abstract class Bindings {
 /// GetPage(
 /// GetPage(
 ///   name: '/',
 ///   name: '/',
 ///   page: () => Home(),
 ///   page: () => Home(),
-///   binding: BindingsBuilder(() => Get.put(HomeController())),
+///   // This might cause you an error.
+///   // binding: BindingsBuilder(() => Get.put(HomeController())),
+///   binding: BindingsBuilder(() { Get.put(HomeController(); })),
+///   // Using .lazyPut() works fine.
+///   // binding: BindingsBuilder(() => Get.lazyPut(() => HomeController())),
 /// ),
 /// ),
 /// ```
 /// ```
 class BindingsBuilder<T> extends Bindings {
 class BindingsBuilder<T> extends Bindings {
   /// Register your dependencies in the [builder] callback.
   /// Register your dependencies in the [builder] callback.
-  final void Function() builder;
+  final VoidCallback builder;
 
 
-  /// Shortcut to register 1 Controller with Get.put().
+  /// Shortcut to register 1 Controller with Get.put(),
+  /// Prevents the issue of the fat arrow function with the constructor.
+  /// BindingsBuilder(() => Get.put(HomeController())),
   ///
   ///
   /// Sample:
   /// Sample:
   /// ```
   /// ```
@@ -41,6 +48,9 @@ class BindingsBuilder<T> extends Bindings {
         .put<T>(null, tag: tag, permanent: permanent, builder: builder));
         .put<T>(null, tag: tag, permanent: permanent, builder: builder));
   }
   }
 
 
+  /// WARNING: don't use `()=> Get.put(Controller())`,
+  /// if only passing 1 callback use `BindingsBuilder.put(Controller())`
+  /// or `BindingsBuilder(()=> Get.lazyPut(Controller()))`
   BindingsBuilder(this.builder);
   BindingsBuilder(this.builder);
 
 
   @override
   @override

@@ -4,7 +4,6 @@ import 'dart:ui' show lerpDouble;
 import 'package:flutter/cupertino.dart';
 import 'package:flutter/cupertino.dart';
 import 'package:flutter/gestures.dart';
 import 'package:flutter/gestures.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/material.dart';
-
 import '../../../route_manager.dart';
 import '../../../route_manager.dart';
 import '../../../utils.dart';
 import '../../../utils.dart';
 import '../../core/get_main.dart';
 import '../../core/get_main.dart';
@@ -143,18 +142,23 @@ class GetPageRoute<T> extends PageRoute<T> {
   @override
   @override
   Widget buildTransitions(BuildContext context, Animation<double> animation,
   Widget buildTransitions(BuildContext context, Animation<double> animation,
       Animation<double> secondaryAnimation, Widget child) {
       Animation<double> secondaryAnimation, Widget child) {
+    final finalCurve = curve ?? Get.defaultTransitionCurve;
+    final hasCurve = curve != null;
     if (fullscreenDialog && transition == null) {
     if (fullscreenDialog && transition == null) {
+      /// by default, if no curve is defined, use Cupertino transition in the
+      /// default way (no linearTransition)... otherwise take the curve passed.
       return CupertinoFullscreenDialogTransition(
       return CupertinoFullscreenDialogTransition(
-          primaryRouteAnimation: animation,
+          primaryRouteAnimation: hasCurve
+              ? CurvedAnimation(parent: animation, curve: finalCurve)
+              : animation,
           secondaryRouteAnimation: secondaryAnimation,
           secondaryRouteAnimation: secondaryAnimation,
           child: child,
           child: child,
-          linearTransition: true);
+          linearTransition: hasCurve);
     }
     }
-
-    if (customTransition != null) {
-      return customTransition.buildTransition(
+    if (this.customTransition != null) {
+      return this.customTransition.buildTransition(
           context,
           context,
-        curve,
+          finalCurve,
           alignment,
           alignment,
           animation,
           animation,
           secondaryAnimation,
           secondaryAnimation,
@@ -165,8 +169,13 @@ class GetPageRoute<T> extends PageRoute<T> {
                   child: child)
                   child: child)
               : child,
               : child,
           );
           );
+
     }
     }
 
 
+    /// Apply the curve by default...
+    final iosAnimation = animation;
+    animation = CurvedAnimation(parent: animation, curve: finalCurve);
+
     switch (transition ?? Get.defaultTransition) {
     switch (transition ?? Get.defaultTransition) {
       case Transition.leftToRight:
       case Transition.leftToRight:
         return SlideLeftTransition().buildTransitions(
         return SlideLeftTransition().buildTransitions(
@@ -291,9 +300,9 @@ class GetPageRoute<T> extends PageRoute<T> {
       case Transition.cupertino:
       case Transition.cupertino:
         return CupertinoTransitions().buildTransitions(
         return CupertinoTransitions().buildTransitions(
             context,
             context,
-            curve,
+            hasCurve,
             alignment,
             alignment,
-            animation,
+            hasCurve ? animation : iosAnimation,
             secondaryAnimation,
             secondaryAnimation,
             popGesture ?? Get.defaultPopGesture
             popGesture ?? Get.defaultPopGesture
                 ? _CupertinoBackGestureDetector<T>(
                 ? _CupertinoBackGestureDetector<T>(
@@ -343,40 +352,13 @@ class GetPageRoute<T> extends PageRoute<T> {
                 : child);
                 : child);
 
 
       case Transition.native:
       case Transition.native:
-        if (GetPlatform.isIOS) {
-          return CupertinoTransitions().buildTransitions(
-              context,
-              curve,
-              alignment,
-              animation,
-              secondaryAnimation,
-              popGesture ?? Get.defaultPopGesture
-                  ? _CupertinoBackGestureDetector<T>(
-                      enabledCallback: () => _isPopGestureEnabled<T>(this),
-                      onStartPopGesture: () => _startPopGesture<T>(this),
-                      child: child)
-                  : child);
-        }
-
-        return FadeUpwardsPageTransitionsBuilder().buildTransitions(
-            this,
-            context,
-            animation,
-            secondaryAnimation,
-            popGesture ?? Get.defaultPopGesture
-                ? _CupertinoBackGestureDetector<T>(
-                    enabledCallback: () => _isPopGestureEnabled<T>(this),
-                    onStartPopGesture: () => _startPopGesture<T>(this),
-                    child: child)
-                : child);
-
       default:
       default:
         if (GetPlatform.isIOS) {
         if (GetPlatform.isIOS) {
           return CupertinoTransitions().buildTransitions(
           return CupertinoTransitions().buildTransitions(
               context,
               context,
-              curve,
+              hasCurve,
               alignment,
               alignment,
-              animation,
+              hasCurve ? animation : iosAnimation,
               secondaryAnimation,
               secondaryAnimation,
               popGesture ?? Get.defaultPopGesture
               popGesture ?? Get.defaultPopGesture
                   ? _CupertinoBackGestureDetector<T>(
                   ? _CupertinoBackGestureDetector<T>(

@@ -188,7 +188,7 @@ class SizeTransitions {
 class CupertinoTransitions {
 class CupertinoTransitions {
   Widget buildTransitions(
   Widget buildTransitions(
       BuildContext context,
       BuildContext context,
-      Curve curve,
+      bool useLinearTransition,
       Alignment alignment,
       Alignment alignment,
       Animation<double> animation,
       Animation<double> animation,
       Animation<double> secondaryAnimation,
       Animation<double> secondaryAnimation,
@@ -196,7 +196,7 @@ class CupertinoTransitions {
     return CupertinoPageTransition(
     return CupertinoPageTransition(
       primaryRouteAnimation: animation,
       primaryRouteAnimation: animation,
       secondaryRouteAnimation: secondaryAnimation,
       secondaryRouteAnimation: secondaryAnimation,
-      linearTransition: true,
+      linearTransition: useLinearTransition,
       child: child,
       child: child,
     );
     );
   }
   }

@@ -23,7 +23,7 @@ class _RxImpl<T> implements RxInterface<T> {
   ///
   ///
   /// WARNING: still WIP, needs testing!
   /// WARNING: still WIP, needs testing!
   _RxImpl<T> operator <<(T val) {
   _RxImpl<T> operator <<(T val) {
-    subject.add(value = val);
+    subject.add(_value = val);
     return this;
     return this;
   }
   }
 
 
@@ -94,9 +94,9 @@ class _RxImpl<T> implements RxInterface<T> {
   /// });
   /// });
   /// print( person );
   /// print( person );
   /// ```
   /// ```
-  void update(void fn(T value)) {
-    fn(value);
-    subject.add(value);
+  void update(void fn(T val)) {
+    fn(_value);
+    subject.add(_value);
   }
   }
 
 
   String get string => value.toString();
   String get string => value.toString();
@@ -179,60 +179,52 @@ class RxBool extends _RxImpl<bool> {
   }
   }
 }
 }
 
 
-class RxDouble extends _RxImpl<double> {
-  RxDouble([double initial]) {
-    _value = initial;
-  }
-
-  RxDouble operator +(double val) {
-    subject.add(value += val);
+abstract class _BaseRxNum<T> extends _RxImpl<num> {
+  _BaseRxNum operator +(num val) {
+    subject.add(_value += val);
     return this;
     return this;
   }
   }
 
 
-  RxDouble operator -(double val) {
-    subject.add(value -= val);
+  _BaseRxNum operator -(num val) {
+    subject.add(_value -= val);
     return this;
     return this;
   }
   }
 
 
-  RxDouble operator /(double val) {
-    subject.add(value /= val);
+  _BaseRxNum operator /(num val) {
+    subject.add(_value /= val);
     return this;
     return this;
   }
   }
 
 
-  RxDouble operator *(double val) {
-    subject.add(value *= val);
+  _BaseRxNum operator *(num val) {
+    subject.add(_value *= val);
     return this;
     return this;
   }
   }
-}
-
-class RxNum extends _RxImpl<num> {
-  RxNum([num initial]) {
-    _value = initial;
-  }
 
 
-  RxNum operator >>(num val) {
-    subject.add(value = val);
+  _BaseRxNum operator ~/(num val) {
+    subject.add(_value ~/ val);
     return this;
     return this;
   }
   }
 
 
-  RxNum operator +(num val) {
-    subject.add(value += val);
+  _BaseRxNum operator %(num val) {
+    subject.add(_value % val);
     return this;
     return this;
   }
   }
 
 
-  RxNum operator -(num val) {
-    subject.add(value -= val);
-    return this;
-  }
+  bool operator <=(num other) => _value <= other;
+  bool operator >=(num other) => _value >= other;
+  bool operator <(num other) => _value < other;
+  bool operator >(num other) => _value > other;
+}
 
 
-  RxNum operator /(num val) {
-    subject.add(value /= val);
-    return this;
+class RxDouble extends _BaseRxNum<double> {
+  RxDouble([double initial]) {
+    _value = initial;
   }
   }
+}
 
 
-  RxNum operator *(num val) {
-    subject.add(value *= val);
-    return this;
+class RxNum extends _BaseRxNum<num> {
+  RxNum([num initial]) {
+    _value = initial;
   }
   }
 }
 }
 
 
@@ -241,51 +233,21 @@ class RxString extends _RxImpl<String> {
     _value = initial;
     _value = initial;
   }
   }
 
 
-  RxString operator >>(String val) {
-    subject.add(value = val);
-    return this;
-  }
-
   RxString operator +(String val) {
   RxString operator +(String val) {
-    subject.add(value += val);
+    subject.add(_value += val);
     return this;
     return this;
   }
   }
 
 
   RxString operator *(int val) {
   RxString operator *(int val) {
-    subject.add(value *= val);
+    subject.add(_value *= val);
     return this;
     return this;
   }
   }
 }
 }
 
 
-class RxInt extends _RxImpl<int> {
+class RxInt extends _BaseRxNum<int> {
   RxInt([int initial]) {
   RxInt([int initial]) {
     _value = initial;
     _value = initial;
   }
   }
-
-  RxInt operator >>(int val) {
-    subject.add(value = val);
-    return this;
-  }
-
-  RxInt operator +(int val) {
-    subject.add(value += val);
-    return this;
-  }
-
-  RxInt operator -(int val) {
-    subject.add(value -= val);
-    return this;
-  }
-
-  RxInt operator /(int val) {
-    subject.add(value ~/= val);
-    return this;
-  }
-
-  RxInt operator *(int val) {
-    subject.add(value *= val);
-    return this;
-  }
 }
 }
 
 
 class Rx<T> extends _RxImpl<T> {
 class Rx<T> extends _RxImpl<T> {

 import 'dart:async';
 import 'dart:async';
-
 import '../../../../get.dart';
 import '../../../../get.dart';
 import '../rx_core/rx_interface.dart';
 import '../rx_core/rx_interface.dart';
 import 'utils/debouncer.dart';
 import 'utils/debouncer.dart';
 
 
+bool _conditional(dynamic condition) {
+  if (condition == null) return true;
+  if (condition is bool) return condition;
+  if (condition is bool Function()) return condition();
+  return true;
+}
+
+///
+/// Called every time [listener] changes. As long as the [condition] returns true.
+///
+/// Sample:
+/// Every time increment() is called, ever() will process the [condition]
+/// (can be a [bool] expression or a [bool Function()]), and only call the callback
+/// when [condition] is true.
+/// In our case, only when count is bigger to 5. In order to "dispose" this Worker
+/// that will run forever, we made a [worker] variable. So, when the count value
+/// reaches 10, the worker gets disposed, and releases any memory resources.
+///
+/// ```
+/// // imagine some counter widget...
+///
+/// class _CountController extends GetxController {
+///   final count = 0.obs;
+///   Worker worker;
+///
+///   void onInit() {
+///     worker = ever(count, (value) {
+///       print('counter changed to: $value');
+///       if (value == 10) worker.dispose();
+///     }, condition: () => count > 5);
+///   }
+///
+///   void increment() => count + 1;
+/// }
+/// ```
 Worker ever<T>(RxInterface<T> listener, Function(T) callback,
 Worker ever<T>(RxInterface<T> listener, Function(T) callback,
-    {bool condition = true}) {
+    {dynamic condition = true}) {
   StreamSubscription sub = listener.subject.stream.listen((event) {
   StreamSubscription sub = listener.subject.stream.listen((event) {
-    if (condition) callback(event);
+    if (_conditional(condition)) callback(event);
   });
   });
-
-  Future<void> cancel() {
-    return sub.cancel();
-  }
-
-  return Worker(cancel, '[ever]');
+  return Worker(sub.cancel, '[ever]');
 }
 }
 
 
+/// 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.
 Worker everAll(List<RxInterface> listeners, Function(dynamic) callback,
 Worker everAll(List<RxInterface> listeners, Function(dynamic) callback,
-    {bool condition = true}) {
-  var evers = <StreamSubscription>[];
-
-  for (final listener in listeners) {
-    final sub = listener.subject.stream.listen((event) {
-      if (condition) {
-        callback(event);
-      }
+    {dynamic condition = true}) {
+  List<StreamSubscription> evers = <StreamSubscription>[];
+  for (var i in listeners) {
+    StreamSubscription sub = i.subject.stream.listen((event) {
+      if (_conditional(condition)) callback(event);
     });
     });
     evers.add(sub);
     evers.add(sub);
   }
   }
 
 
   Future<void> cancel() {
   Future<void> cancel() {
-    for (var i in evers) {
-      i.cancel();
-    }
+    for (var i in evers) i.cancel();
     return Future.value(() {});
     return Future.value(() {});
   }
   }
 
 
   return Worker(cancel, '[everAll]');
   return Worker(cancel, '[everAll]');
 }
 }
 
 
-Worker once<T>(
-  RxInterface<T> listener,
-  Function(T) callback, {
-  bool condition = true,
-}) {
-  StreamSubscription subscription;
-  var times = 0;
 
 
-  subscription = listener.subject.stream.listen((event) {
-    if (!condition) return null;
-    times++;
-    if (times < 2) {
+/// [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()].
+///
+/// Sample:
+/// ```
+///  class _CountController extends GetxController {
+///   final count = 0.obs;
+///   Worker worker;
+///
+///   @override
+///   Future<void> onInit() async {
+///     worker = once(count, (value) {
+///       print("counter reached $value before 3 seconds.");
+///     }, condition: () => count() > 2);
+///     3.delay(worker.dispose);
+///   }
+///   void increment() => count + 1;
+/// }
+///```
+Worker once<T>(RxInterface<T> listener, Function(T) callback,
+    {dynamic condition}) {
+  Worker ref;
+  StreamSubscription sub;
+  sub = listener.subject.stream.listen((event) {
+    if (!_conditional(condition)) return;
+    ref._disposed = true;
+    ref._log('called');
+    sub?.cancel();
     callback(event);
     callback(event);
-    } else {
-      subscription.cancel();
-    }
   });
   });
-
-  Future<void> cancel() {
-    return subscription.cancel();
-  }
-
-  return Worker(cancel, '[once]');
+  ref = Worker(sub.cancel, '[once]');
+  return ref;
 }
 }
 
 
+/// 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).
+///
+/// Sample:
+/// // wait 1 sec each time an event starts, only if counter is lower than 20.
+/// worker = interval(
+///    count,
+///    (value) => print(value),
+///    time: 1.seconds,
+///    condition: () => count < 20,
+/// );
+/// ```
 Worker interval<T>(RxInterface<T> listener, Function(T) callback,
 Worker interval<T>(RxInterface<T> listener, Function(T) callback,
-    {Duration time, bool condition = true}) {
-  var debounceActive = false;
+    {Duration time = const Duration(seconds: 1), dynamic condition = true}) {
+  bool debounceActive = false;
+  time ??= const Duration(seconds: 1);
   StreamSubscription sub = listener.subject.stream.listen((event) async {
   StreamSubscription sub = listener.subject.stream.listen((event) async {
-    if (debounceActive || !condition) return null;
+    if (debounceActive || !_conditional(condition)) return;
     debounceActive = true;
     debounceActive = true;
-    await Future.delayed(time ?? Duration(seconds: 1));
+    await Future.delayed(time);
     debounceActive = false;
     debounceActive = false;
     callback(event);
     callback(event);
   });
   });
-
-  Future<void> cancel() {
-    return sub.cancel();
-  }
-
-  return Worker(cancel, '[interval]');
+  return Worker(sub?.cancel, '[interval]');
 }
 }
 
 
+/// [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.
+///
+/// Sample:
+///
+/// ```
+/// worker = debounce(
+///      count,
+///      (value) {
+///        print(value);
+///        if( value > 20 ) worker.dispose();
+///      },
+///      time: 1.seconds,
+///    );
+///  }
+///  ```
 Worker debounce<T>(RxInterface<T> listener, Function(T) callback,
 Worker debounce<T>(RxInterface<T> listener, Function(T) callback,
     {Duration time}) {
     {Duration time}) {
-  final _debouncer = Debouncer(delay: time ?? Duration(milliseconds: 800));
+  final _debouncer =
+      Debouncer(delay: time ?? const Duration(milliseconds: 800));
   StreamSubscription sub = listener.subject.stream.listen((event) {
   StreamSubscription sub = listener.subject.stream.listen((event) {
     _debouncer(() {
     _debouncer(() {
       callback(event);
       callback(event);
     });
     });
   });
   });
-
-  Future<void> cancel() {
-    return sub.cancel();
-  }
-
-  return Worker(cancel, '[debounce]');
+  return Worker(sub.cancel, '[debounce]');
 }
 }
 
 
 class Worker {
 class Worker {
   Worker(this.worker, this.type);
   Worker(this.worker, this.type);
 
 
+  /// subscription.cancel() callback
   final Future<void> Function() worker;
   final Future<void> Function() worker;
+
+  /// type of worker (debounce, interval, ever)..
   final String type;
   final String type;
+  bool _disposed = false;
 
 
-  void _message() {
-    GetConfig.log('Worker $type disposed');
+  bool _verbose = true;
+  void _log(String msg) {
+    if (!_verbose) return;
+    GetConfig.log('$runtimeType $type $msg');
   }
   }
 
 
   void dispose() {
   void dispose() {
-    worker();
-    _message();
+    if (_disposed) {
+      _log('already disposed');
+      return;
     }
     }
-
-  void call() {
+    _disposed = true;
     worker();
     worker();
-    _message();
+    _log('disposed');
   }
   }
+
+  void call() => dispose();
 }
 }

@@ -8,46 +8,122 @@ import '../../navigation/root/smart_management.dart';
 import '../rx/rx_core/rx_interface.dart';
 import '../rx/rx_core/rx_interface.dart';
 import 'simple_builder.dart';
 import 'simple_builder.dart';
 
 
-typedef Disposer = void Function();
+// Changed to VoidCallback.
+//typedef Disposer = void Function();
+
+// replacing StateSetter, return if the Widget is mounted for extra validation.
+// if it brings overhead the extra call,
+typedef GetStateUpdate = bool Function();
+//typedef GetStateUpdate = void Function(VoidCallback fn);
+
+/// Complies with [GetStateUpdater]
+///
+/// This mixin's function represents a [GetStateUpdater], and might be used
+/// by [GetBuilder()], [SimpleBuilder()] (or similar) to comply
+/// with [GetStateUpdate] signature. REPLACING the [StateSetter].
+/// Avoids the potential (but extremely unlikely) issue of having
+/// the Widget in a dispose() state, and abstracts the API from the ugly fn((){}).
+/// TODO: check performance HIT for the extra method call.
+///
+mixin GetStateUpdaterMixin<T extends StatefulWidget> on State<T> {
+  // To avoid the creation of an anonym function to be GC later.
+  static VoidCallback _stateCallback = () {};
+
+  /// Experimental method to replace setState((){});
+  /// Used with GetStateUpdate.
+  bool getUpdate() {
+    final _mounted = mounted;
+    if (_mounted) setState(_stateCallback);
+    return _mounted;
+  }
+}
 
 
 class GetxController extends DisposableInterface {
 class GetxController extends DisposableInterface {
-  final HashSet<StateSetter> _updaters = HashSet<StateSetter>();
+  final _updaters = HashSet<GetStateUpdate>();
+
+//  final _updatersIds = HashMap<String, StateSetter>(); //<old>
+  final _updatersIds = HashMap<String, GetStateUpdate>();
 
 
-  final HashMap<String, StateSetter> _updatersIds =
-      HashMap<String, StateSetter>();
+  final _updatersGroupIds = HashMap<String, HashSet<GetStateUpdate>>();
 
 
-  /// Update GetBuilder with update();
+  /// Rebuilds [GetBuilder] each time you call [update()];
+  /// Can take a List of [ids], that will only update the matching
+  /// `GetBuilder( id: )`,
+  /// [ids] can be reused among `GetBuilders` like group tags.
+  /// The update will only notify the Widgets, if [condition] is true.
   void update([List<String> ids, bool condition = true]) {
   void update([List<String> ids, bool condition = true]) {
+
     if (!condition) {
     if (!condition) {
       return;
       return;
     }
     }
-
     if (ids == null) {
     if (ids == null) {
+//      _updaters?.forEach((rs) => rs(() {})); //<old>
       for (final updater in _updaters) {
       for (final updater in _updaters) {
-        updater(() {});
+        updater();
       }
       }
     } else {
     } else {
-      for (final id in ids) {
-        _updatersIds[id]?.call(() {});
-      }
+      // @jonny, remove this commented code if it's not more optimized.
+//      for (final id in ids) {
+//        if (_updatersIds[id] != null) _updatersIds[id]();
+//        if (_updatersGroupIds[id] != null)
+//          for (final rs in _updatersGroupIds[id]) rs();
+//      }
+
+      ids.forEach((id) {
+//        _updatersIds[id]?.call(() {}); //<old>
+//        _updatersGroupIds[id]?.forEach((rs) => rs(() {})); //<old>
+        _updatersIds[id]?.call();
+        _updatersGroupIds[id]?.forEach((rs) => rs());
+      });
     }
     }
   }
   }
 
 
-  Disposer addListener(StateSetter listener) {
+//  VoidCallback addListener(StateSetter listener) {//<old>
+  VoidCallback addListener(GetStateUpdate listener) {
     _updaters.add(listener);
     _updaters.add(listener);
     return () => _updaters.remove(listener);
     return () => _updaters.remove(listener);
   }
   }
 
 
-  // void removeListener(StateSetter listener) {
-  //   _updaters.remove(listener);
-  // }
-
-  Disposer addListenerId(String key, StateSetter listener) {
+//  VoidCallback addListenerId(String key, StateSetter listener) {//<old>
+  VoidCallback addListenerId(String key, GetStateUpdate listener) {
+//    _printCurrentIds();
+    if (_updatersIds.containsKey(key)) {
+      _updatersGroupIds[key] ??= HashSet<GetStateUpdate>.identity();
+      _updatersGroupIds[key].add(listener);
+      return () {
+        _updatersGroupIds[key].remove(listener);
+      };
+    } else {
       _updatersIds[key] = listener;
       _updatersIds[key] = listener;
       return () => _updatersIds.remove(key);
       return () => _updatersIds.remove(key);
     }
     }
+  }
 
 
-  void disposeKey(String key) => _updatersIds.remove(key);
+  /// To dispose an [id] from future updates(), this ids are registered
+  /// by [GetBuilder()] or similar, so is a way to unlink the state change with
+  /// the Widget from the Controller.
+  void disposeId(String id) {
+    _updatersIds.remove(id);
+    _updatersGroupIds.remove(id);
+  }
+
+  /// Remove this after checking the new implementation makes sense.
+  /// Uncomment this if you wanna control the removal of ids..
+//  bool _debugging = false;
+//  Future<void> _printCurrentIds() async {
+//    if (_debugging) return;
+//    _debugging = true;
+//    print('about to debug...');
+//    await Future.delayed(Duration(milliseconds: 10));
+//    int totalGroups = 0;
+//    _updatersGroupIds.forEach((key, value) {
+//      totalGroups += value.length;
+//    });
+//    int totalIds = _updatersIds.length;
+//    print(
+//        'Total: ${totalIds + totalGroups}, in groups:$totalGroups, solo ids:$totalIds');
+//    _debugging = false;
+//  }
 }
 }
 
 
 class GetBuilder<T extends GetxController> extends StatefulWidget {
 class GetBuilder<T extends GetxController> extends StatefulWidget {
@@ -81,11 +157,13 @@ class GetBuilder<T extends GetxController> extends StatefulWidget {
   _GetBuilderState<T> createState() => _GetBuilderState<T>();
   _GetBuilderState<T> createState() => _GetBuilderState<T>();
 }
 }
 
 
-class _GetBuilderState<T extends GetxController> extends State<GetBuilder<T>> {
-  T controller;
+
+class _GetBuilderState<T extends GetxController> extends State<GetBuilder<T>>
+    with GetStateUpdaterMixin {
+  GetxController controller;
+
   bool isCreator = false;
   bool isCreator = false;
-  final HashSet<Disposer> disposers = HashSet<Disposer>();
-  Disposer remove;
+  VoidCallback remove;
 
 
   @override
   @override
   void initState() {
   void initState() {
@@ -119,28 +197,40 @@ class _GetBuilderState<T extends GetxController> extends State<GetBuilder<T>> {
         GetConfig.smartManagement == SmartManagement.onlyBuilder) {
         GetConfig.smartManagement == SmartManagement.onlyBuilder) {
       controller?.onStart();
       controller?.onStart();
     }
     }
+    _subscribeToController();
+  }
+
+  /// Register to listen Controller's events.
+  /// It gets a reference to the remove() callback, to delete the
+  /// setState "link" from the Controller.
+  void _subscribeToController() {
+    remove?.call();
     remove = (widget.id == null)
     remove = (widget.id == null)
-        ? controller?.addListener(setState)
-        : controller?.addListenerId(widget.id, setState);
+//        ? controller?.addListener(setState) //<old>
+//        : controller?.addListenerId(widget.id, setState); //<old>
+        ? controller?.addListener(getUpdate)
+        : controller?.addListenerId(widget.id, getUpdate);
   }
   }
 
 
+  /// Sample for [GetStateUpdate] when you don't wanna use [GetStateHelper mixin].
+//  bool _getUpdater() {
+//    final _mounted = mounted;
+//    if (_mounted) setState(() {});
+//    return _mounted;
+//  }
+
   @override
   @override
   void dispose() {
   void dispose() {
     super.dispose();
     super.dispose();
     if (widget.dispose != null) widget.dispose(this);
     if (widget.dispose != null) widget.dispose(this);
     if (isCreator || widget.assignId) {
     if (isCreator || widget.assignId) {
       if (widget.autoRemove && GetInstance().isRegistered<T>(tag: widget.tag)) {
       if (widget.autoRemove && GetInstance().isRegistered<T>(tag: widget.tag)) {
-        if (remove != null) remove();
-
         GetInstance().delete<T>(tag: widget.tag);
         GetInstance().delete<T>(tag: widget.tag);
       }
       }
-    } else {
-      if (remove != null) remove();
     }
     }
 
 
-    for (final disposer in disposers) {
-      disposer();
-    }
+    remove?.call();
+
   }
   }
 
 
   @override
   @override
@@ -154,6 +244,10 @@ class _GetBuilderState<T extends GetxController> extends State<GetBuilder<T>> {
   @override
   @override
   void didUpdateWidget(GetBuilder oldWidget) {
   void didUpdateWidget(GetBuilder oldWidget) {
     super.didUpdateWidget(oldWidget as GetBuilder<T>);
     super.didUpdateWidget(oldWidget as GetBuilder<T>);
+    // to avoid conflicts when modifying a "grouped" id list.
+    if (oldWidget.id != widget.id) {
+      _subscribeToController();
+    }
     if (widget.didUpdateWidget != null) widget.didUpdateWidget(oldWidget, this);
     if (widget.didUpdateWidget != null) widget.didUpdateWidget(oldWidget, this);
   }
   }
 
 

@@ -88,8 +88,9 @@ class SimpleBuilder extends StatefulWidget {
   _SimpleBuilderState createState() => _SimpleBuilderState();
   _SimpleBuilderState createState() => _SimpleBuilderState();
 }
 }
 
 
-class _SimpleBuilderState extends State<SimpleBuilder> {
-  final HashSet<Disposer> disposers = HashSet<Disposer>();
+class _SimpleBuilderState extends State<SimpleBuilder>
+    with GetStateUpdaterMixin {
+  final HashSet<VoidCallback> disposers = HashSet<VoidCallback>();
 
 
   @override
   @override
   void dispose() {
   void dispose() {
@@ -101,9 +102,10 @@ class _SimpleBuilderState extends State<SimpleBuilder> {
 
 
   @override
   @override
   Widget build(BuildContext context) {
   Widget build(BuildContext context) {
+
     return TaskManager.instance.exchange(
     return TaskManager.instance.exchange(
      disposers, 
      disposers, 
-      setState,
+     getUpdate, 
      widget.builder, 
      widget.builder, 
      context,
      context,
     );
     );
@@ -117,10 +119,15 @@ class TaskManager {
 
 
   static TaskManager get instance => _instance ??= TaskManager._();
   static TaskManager get instance => _instance ??= TaskManager._();
 
 
-  StateSetter _setter;
-  HashSet<Disposer> _remove;
+//  StateSetter _setter;//<old>
+  GetStateUpdate _setter;
+
+
+  HashSet<VoidCallback> _remove;
+
+//  void notify(HashSet<StateSetter> _updaters) { //<old>
+  void notify(HashSet<GetStateUpdate> _updaters) {
 
 
-  void notify(HashSet<StateSetter> _updaters) {
     if (_setter != null) {
     if (_setter != null) {
       if (!_updaters.contains(_setter)) {
       if (!_updaters.contains(_setter)) {
         _updaters.add(_setter);
         _updaters.add(_setter);
@@ -130,8 +137,9 @@ class TaskManager {
   }
   }
 
 
   Widget exchange(
   Widget exchange(
-    HashSet<Disposer> disposers,
-    StateSetter setState,
+    HashSet<VoidCallback> disposers,
+//    StateSetter setState, //<old>
+    GetStateUpdate setState,
     Widget Function(BuildContext) builder,
     Widget Function(BuildContext) builder,
     BuildContext context,
     BuildContext context,
   ) {
   ) {