Added docs

+## [2.5.8]
+- Added docs
+
+## [2.5.7]
+- Fix Get.generalDialog optionals
+- Added GetX onInit support
+
+## [2.5.6]
+- GetBuilder refactor to work with lazyPut.
+Now you can list your controllers in advance with Get.lazyPut, and only when it is called for the first time will it be relocated in memory.
+
+## [2.5.5]
+- Fix arguments broken by new methods
+
+## [2.5.4]
+- Refactor methods
+
+## [2.5.3]
+- Fix snackbar padding on iPhone SE 2.
+- Added themes docs
+
 ## [2.5.2]
 ## [2.5.2]
 - Fix: key not found when Get.key is used with no MaterialApp
 - Fix: key not found when Get.key is used with no MaterialApp
 
 

@@ -40,6 +40,16 @@ This library that will change the way you work with the Framework and save your
 - **[Other Advanced APIs and Manual configurations](#Other-Advanced-APIs-and-Manual-configurations)**
 - **[Other Advanced APIs and Manual configurations](#Other-Advanced-APIs-and-Manual-configurations)**
 - **[Nested Navigators](#Nested-Navigators)**
 - **[Nested Navigators](#Nested-Navigators)**
 
 
+
+#### You can contribute to the project in multiple ways:
+- Helping to translate the readme into other languages.
+- Adding documentation to the readme (not even half of Get's functions have been documented yet).
+- Writing articles/videos about Get (they will be inserted in the Readme, and in the future in our Wiki).
+- Offering PRs for code/tests.
+- Including new functions.
+
+Any contribution is welcome!
+
 ## How to use?
 ## How to use?
 
 
 <!-- - Flutter Master/Dev/Beta: version 2.0.x-dev 
 <!-- - Flutter Master/Dev/Beta: version 2.0.x-dev 
@@ -88,13 +98,13 @@ var data = await Get.to(Payment());
 on other screen, send a data for previous route:
 on other screen, send a data for previous route:
 
 
 ```dart
 ```dart
-Get.back(result: 'success');
+Get.back(result: 'sucess');
 ```
 ```
 And use it:
 And use it:
 
 
 ex:
 ex:
 ```dart
 ```dart
-if(data == 'success') madeAnything();
+if(data == 'sucess') madeAnything();
 ```
 ```
 
 
 Don't you want to learn our syntax?
 Don't you want to learn our syntax?
@@ -348,9 +358,12 @@ FloatingActionButton(
 When you press FloatingActionButton, all widgets that are listening to the 'counter' variable will be updated automatically.
 When you press FloatingActionButton, all widgets that are listening to the 'counter' variable will be updated automatically.
 
 
 #### No StatefulWidget:
 #### No StatefulWidget:
-Using StatefulWidgets means storing the state of entire screens unnecessarily. With Get the use of StatefulWidget is optional. Avoid them and save your users' RAM.
+Using StatefulWidgets means storing the state of entire screens unnecessarily, even because if you need to minimally rebuild a widget, you will embed it in a Consumer/Observer/BlocProvider/GetBuilder, which will be another StatefulWidget.
+The StatefulWidget class is a class larger than StatelessWidget, which will allocate more RAM, and this may not make a significant difference between one or two classes, but it will most certainly do when you have 100 of them!
+Unless you need to use a mixin, like TickerProviderStateMixin, it will be totally unnecessary to use a StatefulWidget with Get. 
 
 
-If you need to call initState() or dispose() method, you can call them directly from GetBuilder();
+You can call all methods of a StatefulWidget directly from a GetBuilder.
+If you need to call initState() or dispose() method for example, you can call them directly;
 
 
 ```dart
 ```dart
 GetBuilder<Controller>(
 GetBuilder<Controller>(
@@ -360,8 +373,22 @@ GetBuilder<Controller>(
         ),
         ),
 ```
 ```
 
 
+A much better approach than this is to use the onInit() and onClose() method directly from your controller.
+
+```dart
+@override
+void onInit() {
+  fetchApi();
+  super.onInit();
+}
+```
+
+- NOTE: If you want to start a method at the moment the controller is called for the first time, you DON'T NEED to use constructors for this, in fact, using a performance-oriented package like Get, this borders on bad practice, because it deviates from the logic in which the controllers are created or allocated (if you create an instance of this controller, the constructor will be called immediately, you will be populating a controller before it is even used, you are allocating memory without it being in use, this definitely hurts the principles of this library). The onInit() methods; and onClose(); were created for this, they will be called when the Controller is created, or used for the first time, depending on whether you are using Get.lazyPut or not. If you want, for example, to make a call to your API to populate data, you can forget about the old-fashioned method of initState/dispose, just start your call to the api in onInit, and if you need to execute any command like closing streams, use the onClose() for that.
+The purpose of this package is precisely to give you a complete solution for navigation of routes, management of dependencies and states, using the least possible dependencies, with a high degree of decoupling. Get engages all high and low level Flutter APIs within itself, to ensure that you work with the least possible coupling. We centralize everything in a single package, to ensure that you don't have any kind of coupling in your project. That way, you can put only widgets in your view, and leave the part of your team that works with the business logic free, to work with the business logic without depending on any element of the View. This provides a much cleaner working environment, so that part of your team works only with widgets, without worrying about sending data to your controller, and part of your team works only with the business logic in its breadth, without depending on no element of the view.
 
 
-- NOTE: If you are working with reactive programming with Get, know that it automatically closes your streams, as long as you close them correctly inside the close() method;
+So to simplify this:
+You don't need to call methods in initState and send them by parameter to your controller, nor use your controller constructor for that, you have the onInit() method that is called at the right time for you to start your services.
+You do not need to call the device, you have the onClose() method that will be called at the exact moment when your controller is no longer needed and will be removed from memory. That way, leave views for widgets only, refrain from any kind of business logic from it.
 
 
 Do not call a dispose method inside GetController, it will not do anything, remember that the controller is not a Widget, you should not "dispose" it, and it will be automatically and intelligently removed from memory by Get. If you used any stream on it and want to close it, just insert it into the close method. Example:
 Do not call a dispose method inside GetController, it will not do anything, remember that the controller is not a Widget, you should not "dispose" it, and it will be automatically and intelligently removed from memory by Get. If you used any stream on it and want to close it, just insert it into the close method. Example:
 
 
@@ -370,15 +397,19 @@ class Controller extends GetController {
 StreamController<User> user = StreamController<User>();
 StreamController<User> user = StreamController<User>();
 StreamController<String> name = StreamController<String>();
 StreamController<String> name = StreamController<String>();
 
 
-/// close stream = close method, not dispose.
+/// close stream = onClose method, not dispose.
 @override
 @override
-void close() {
+void onClose() {
   user.close();
   user.close();
   name.close();
   name.close();
-  super.close();
+  super.onClose();
 }
 }
 
 
 ```
 ```
+Controller life cycle:
+- onInit() where it is created.
+- onClose() where it is closed to make any changes in preparation for the delete method
+- deleted: you do not have access to this API because it is literally removing the controller from memory. It is literally deleted, without leaving any trace.
 
 
 ##### Forms of use:
 ##### Forms of use:
 
 
@@ -420,7 +451,7 @@ GetBuilder<Controller>(
               )),
               )),
 ```
 ```
 
 
-- Not recommended (because you will need to use StatefulWidget to instantiate your controller), but functional:
+- You can use "non-canonical" approaches to do this. If you are using some other dependency manager, like get_it, modular, etc., and just want to deliver the controller instance, you can do this:
 
 
 ```dart
 ```dart
 
 
@@ -433,8 +464,9 @@ GetBuilder( // you dont need to type on this way
               )),
               )),
 
 
 ```
 ```
+This approach is not recommended, as you will have to manually dispose of your controllers, close your streams manually, and literally give up one of the great benefits of this library, which is intelligent memory control. But if you trust your potential, go ahead!
 
 
-If you want to refine a widget's update control, you can assign them unique IDs:
+If you want to refine a widget's update control with GetBuilder, you can assign them unique IDs:
 ```dart
 ```dart
 GetBuilder<Controller>( 
 GetBuilder<Controller>( 
     id: 'text' 
     id: 'text' 
@@ -443,14 +475,23 @@ GetBuilder<Controller>(
               '${Get.find<Controller>().counter}', //here
               '${Get.find<Controller>().counter}', //here
               )),
               )),
 ```
 ```
-And update it fis form:
+And update it this form:
 ```dart
 ```dart
 update(this,['text']);
 update(this,['text']);
-
+```
 You can also impose conditions for the update:
 You can also impose conditions for the update:
 
 
-```
+```dart
 update(this,['text'], counter < 10);
 update(this,['text'], counter < 10);
+```
+
+GetX does this automatically and only reconstructs the widget that uses the exact variable that was changed, if you change a variable to the same as the previous one and that does not imply a change of state , GetX will not rebuild the widget to save memory and CPU cycles (3 is being displayed on the screen, and you change the variable to 3 again. In most state managers, this will cause a new rebuild, but with GetX the widget will only is rebuilt again, if in fact his state has changed).
+GetBuilder is aimed precisely at multiple state control. Imagine that you added 30 products to a cart, you click delete one, at the same time that the list is updated, the price is updated and the badge in the shopping cart is updated to a smaller number. This type of approach makes GetBuilder killer, because it groups states and changes them all at once without any "computational logic" for that. GetBuilder was created with this type of situation in mind, since for ephemeral change of state, you can use setState and you would not need a state manager for this. However, there are situations where you want only the widget where a certain variable has been changed to be rebuilt, and this is what GetX does with a mastery never seen before.
+
+That way, if you want an individual controller, you can assign IDs for that, or use GetX. This is up to you, remembering that the more "individual" widgets you have, the more the performance of GetX will stand out, while the performance of GetBuilder should be superior, when there is multiple change of state.
+
+You can use both in any situation, but if you want to tune their application to the maximum possible performance, I would say that: if your variables are changed at different times, use GetX, because there is no competition for it when the subject is to rebuild only what is necessary, 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, to make just what he promises to do: update state in blocks. There is no way to compare RAM, CPU, or anything else from a giant state manager to a simple StatefulWidget (like GetBuilder) that is updated when you call update(this). 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 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 .
 
 
 
 
 ## Reactive State Manager
 ## Reactive State Manager
@@ -507,7 +548,7 @@ Do you know Flutter's counter app? Your Controller class might look like this:
 
 
 ```dart
 ```dart
 class CountCtl extends RxController {
 class CountCtl extends RxController {
-  int count = 0.obs;
+  final count = 0.obs;
 }
 }
 ```
 ```
 With a simple:
 With a simple:
@@ -556,6 +597,32 @@ Camila
 
 
 ```
 ```
 
 
+Before you immerse yourself in this world, I will give you a tip, always access the "value" of your flow when reading it, especially if you are working with lists where this is apparently optional.
+You can access list.length, or list.value.length. Most of the time, both ways will work, since the GetX list inherits directly from the dart List. But there is a difference between you accessing the object, and accessing the flow. I strongly recommend you to access the value:
+```dart
+final list = List<User>().obs;
+```
+```dart
+ListView.builder (
+itemCount: list.value.lenght
+```
+or else create a "get" method for it and abandon "value" for life. example:
+
+```dart
+final _list = List<User>().obs;
+List get list => _list.value;
+```
+```dart
+ListView.builder (
+itemCount: list.lenght
+```
+You could add an existing list of another type to the observable list using a list.assign (oldList); or the assignAll method, which differs from add, and addAll, which must be of the same type. All existing methods in a list are also available on GetX.
+
+We could remove the obligation to use value 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. You can literally add 3 letters to your pubspec (get) 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. 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.
+
+Obviously, if someone wants to contribute to the project and create a code generator, or something similar, I will link in this readme as an alternative, my need is not the need for all devs, but for now I say, there are good solutions that already do that, like MobX.
+
 ## Simple Instance Manager
 ## Simple Instance Manager
 Are you already using Get and want to make your project as lean as possible? Get has a simple and powerful dependency manager that allows you to retrieve the same class as your Bloc or Controller with just 1 lines of code, no Provider context, no inheritedWidget:
 Are you already using Get and want to make your project as lean as possible? Get has a simple and powerful dependency manager that allows you to retrieve the same class as your Bloc or Controller with just 1 lines of code, no Provider context, no inheritedWidget:
 
 
@@ -638,7 +705,7 @@ print(Get.arguments);
 ```
 ```
 
 
 #### Dynamic urls links
 #### Dynamic urls links
-Get is the first and only package to offer advanced dynamic urls just like on the Web. Web developers have probably already wanted this feature on Flutter, and most likely have seen a package promise this feature and deliver a totally different syntax than a URL would have on web, but Get also solves that.
+Get offer advanced dynamic urls just like on the Web. Web developers have probably already wanted this feature on Flutter, and most likely have seen a package promise this feature and deliver a totally different syntax than a URL would have on web, but Get also solves that.
 
 
 ```dart
 ```dart
 Get.offAllNamed("/NextScreen?device=phone&id=354&name=Enzo");
 Get.offAllNamed("/NextScreen?device=phone&id=354&name=Enzo");
@@ -802,21 +869,27 @@ class Third extends StatelessWidget {
 
 
 ### Change Theme
 ### Change Theme
 Please do not use any higher level widget than GetMaterialApp in order to update it. This can trigger duplicate keys. A lot of people are used to the prehistoric approach of creating a "ThemeProvider" widget just to change the theme of your app, and this is definitely NOT necessary with Get.
 Please do not use any higher level widget than GetMaterialApp in order to update it. This can trigger duplicate keys. A lot of people are used to the prehistoric approach of creating a "ThemeProvider" widget just to change the theme of your app, and this is definitely NOT necessary with Get.
-If you want to change the theme, just use:
+
+You can create your custom theme and simply add it within Get.changeTheme without any boilerplate for that:
+
 
 
 ```dart
 ```dart
-Get.changeTheme (Theme.dark());
+Get.changeTheme(ThemeData.light());
 ```
 ```
 
 
-If you want to create something like a button that changes the theme with touch, you can combine two Get APIs for that, the api that checks if the dark theme is being used, and the theme change API, you can just put this within an onPressed:
+If you want to create something like a button that changes the theme with onTap, you can combine two Get APIs for that, the api that checks if the dark theme is being used, and the theme change API, you can just put this within an onPressed:
 
 
 ```dart
 ```dart
-Get.changeTheme (Get.isDarkMode? Theme.light(): Theme.dark());
+Get.changeTheme(Get.isDarkMode? ThemeData.light(): ThemeData.dark());
 ```
 ```
 
 
 When darkmode is activated, it will switch to the light theme, and when the light theme is activated, it will change to dark.
 When darkmode is activated, it will switch to the light theme, and when the light theme is activated, it will change to dark.
 
 
-You can create your custom theme and simply add it within Get.changeTheme without any cliche code for that.
+
+If you want to know in depth how to change the theme, you can follow this tutorial on Medium that even teaches the persistence of the theme using Get:
+
+- [Dynamic Themes in 3 lines using Get](https://medium.com/swlh/flutter-dynamic-themes-in-3-lines-c3b375f292e3) - Tutorial by [Rod Brown](https://github.com/RodBr).
+
 
 
 ### Optional Global Settings
 ### Optional Global Settings
 You can create Global settings for Get. Just add Get.config to your code before pushing any route or do it directly in your GetMaterialApp
 You can create Global settings for Get. Just add Get.config to your code before pushing any route or do it directly in your GetMaterialApp

 name: get
 name: get
 description: Open screens/snackbars/dialogs/bottomSheets without context, manage states and inject dependencies easily with Get.
 description: Open screens/snackbars/dialogs/bottomSheets without context, manage states and inject dependencies easily with Get.
-version: 2.5.5
+version: 2.5.8
 homepage: https://github.com/jonataslaw/get
 homepage: https://github.com/jonataslaw/get
 
 
 environment:
 environment: