Bump to 2.10.2

+## [2.10.2]
+- Fix Get.generalDialog default options
+
 ## [2.10.1]
 - Fix broken links on pub
 - Fix List empty error

@@ -232,7 +232,7 @@ class Get {
   /// Api from showGeneralDialog with no context
   static Future<T> generalDialog<T>({
     @required RoutePageBuilder pageBuilder,
-    String barrierLabel,
+    String barrierLabel = "Dismiss",
     bool barrierDismissible = true,
     Color barrierColor = const Color(0x80000000),
     Duration transitionDuration = const Duration(milliseconds: 200),
@@ -643,11 +643,16 @@ class Get {
 
   Map<dynamic, _FcBuilderFunc> _factory = {};
 
-  static void lazyPut<S>(_FcBuilderFunc<S> builder, {String tag}) {
+  static void lazyPut<S>(_FcBuilderFunc builder, {String tag}) {
     String key = _getKey(S, tag);
     Get()._factory.putIfAbsent(key, () => builder);
   }
 
+  static Future<S> putAsync<S>(_FcBuilderFuncAsync<S> builder,
+      {String tag}) async {
+    return Get.put<S>(await builder(), tag: tag);
+  }
+
   /// Inject class on Get Instance Manager
   static S put<S>(
     S dependency, {
@@ -966,3 +971,5 @@ enum SmartManagement {
 }
 
 typedef _FcBuilderFunc<S> = S Function();
+
+typedef _FcBuilderFuncAsync<S> = Future<S> Function();

@@ -175,6 +175,7 @@ class GetMaterialApp extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
+ 
     return GetBuilder<GetMaterialController>(
         init: Get().getController,
         dispose: (d) {

@@ -90,8 +90,6 @@ class GetObserver extends NavigatorObserver {
         print("[CLOSE BOTTOMSHEET] ${route?.settings?.name}");
     } else if ('${route?.settings?.name}' == 'dialog') {
       if (Get.isLogEnable) print("[CLOSE DIALOG] ${route?.settings?.name}");
-    } else if ('${route?.settings?.name}' == 'snackbar') {
-      if (Get.isLogEnable) print("[CLOSE SNACKBAR] ${route?.settings?.name}");
     } else {
       if (Get.isLogEnable) print("[BACK ROUTE] ${route?.settings?.name}");
     }

@@ -2,15 +2,20 @@ import 'package:get/get.dart';
 import 'rx_interface.dart';
 import 'utils/debouncer.dart';
 
-void ever(RxInterface listener, Function(dynamic) callback) {
+void ever(RxInterface listener, Function(dynamic) callback,
+    {bool condition = true}) {
   listener.subject.stream.listen((event) {
-    callback(event.$new);
+    if (condition) {
+      callback(event.$new);
+    }
   });
 }
 
-void once(RxInterface listener, Function(dynamic) callback) {
+void once(RxInterface listener, Function(dynamic) callback,
+    {bool condition = true}) {
   int times = 0;
   listener.subject.stream.listen((event) {
+    if (!condition) return null;
     times++;
     if (times < 2) {
       callback(event.$new);
@@ -19,14 +24,12 @@ void once(RxInterface listener, Function(dynamic) callback) {
 }
 
 void interval(RxInterface listener, Function(dynamic) callback,
-    {Duration time}) {
+    {Duration time, bool condition = true}) {
   bool debounceActive = false;
-  Duration timer = time ?? Duration(seconds: 1);
-
   listener.subject.stream.listen((event) async {
-    if (debounceActive) return null;
+    if (debounceActive || !condition) return null;
     debounceActive = true;
-    await Future.delayed(timer);
+    await Future.delayed(time ?? Duration(seconds: 1));
     debounceActive = false;
     callback(event.$new);
   });

@@ -106,16 +106,12 @@ class _GetBuilderState<T extends GetController> extends State<GetBuilder<T>> {
     }
     if (widget.initState != null) widget.initState(this);
     if (isCreator) {
-      try {
-        controller?.onInit();
-      } catch (e) {
-        if (Get.isLogEnable) print("[GET] error: $e");
-      }
+      controller?.onInit();
     }
   }
 
   @override
-  void dispose() async {
+  void dispose() {
     super.dispose();
 
     if (widget.dispose != null) widget.dispose(this);

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

@@ -25,4 +25,48 @@ void main() {
 
     expect(find.byIcon(Icons.music_note), findsOneWidget);
   });
+
+  testWidgets("Get.bottomSheet close test", (tester) async {
+    await tester.pumpWidget(
+      Wrapper(child: Container()),
+    );
+
+    Get.bottomSheet(Container(
+      child: Wrap(
+        children: <Widget>[
+          ListTile(
+              leading: Icon(Icons.music_note),
+              title: Text('Music'),
+              onTap: () => {}),
+        ],
+      ),
+    ));
+
+    expect(Get.isBottomSheetOpen, true);
+
+    Get.back();
+    expect(Get.isBottomSheetOpen, false);
+
+    expect(() => Get.bottomSheet(Container(), isScrollControlled: null),
+        throwsAssertionError);
+
+    expect(() => Get.bottomSheet(Container(), isDismissible: null),
+        throwsAssertionError);
+
+    expect(() => Get.bottomSheet(Container(), enableDrag: null),
+        throwsAssertionError);
+
+    await tester.pumpAndSettle();
+  });
+
+  testWidgets(
+    "GetMaterialApp with debugShowMaterialGrid null",
+    (WidgetTester testr) async {
+      expect(
+          () => GetMaterialApp(
+                debugShowMaterialGrid: null,
+              ),
+          throwsAssertionError);
+    },
+  );
 }

@@ -30,6 +30,18 @@ void main() {
 
     expect(find.byType(YourDialogWidget), findsOneWidget);
   });
+
+  testWidgets("Get.dialog close test", (tester) async {
+    await tester.pumpWidget(
+      Wrapper(child: Container()),
+    );
+
+    Get.dialog(YourDialogWidget());
+    expect(Get.isDialogOpen, true);
+    Get.back();
+    expect(Get.isDialogOpen, false);
+    await tester.pumpAndSettle();
+  });
 }
 
 class YourDialogWidget extends StatelessWidget {

+import 'package:flutter_test/flutter_test.dart';
+import 'package:get/get.dart';
+
+class Mock {
+  static Future<String> test() async {
+    await Future.delayed(Duration.zero);
+    return 'test';
+  }
+}
+
+class Controller {}
+
+abstract class Service {
+  String post();
+}
+
+class Api implements Service {
+  @override
+  String post() {
+    return 'test';
+  }
+}
+
+void main() {
+  test('Get.putAsync test', () async {
+    await Get.putAsync<String>(() => Mock.test());
+    expect('test', Get.find<String>());
+    Get.reset();
+  });
+
+  test('Get.put test', () async {
+    final instance = Get.put<Controller>(Controller());
+    expect(instance, Get.find<Controller>());
+    Get.reset();
+  });
+
+  test('Get.lazyPut test', () async {
+    final controller = Controller();
+    Get.lazyPut<Controller>(() => controller);
+    final ct1 = Get.find<Controller>();
+    expect(ct1, controller);
+    Get.reset();
+  });
+
+  test('Get.lazyPut with abstract class test', () async {
+    final api = Api();
+    Get.lazyPut<Service>(() => api);
+    final ct1 = Get.find<Service>();
+    expect(ct1, api);
+    Get.reset();
+  });
+}

+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get/get.dart';
+
+void main() {
+  testWidgets("MixinBuilder smoke test", (tester) async {
+    await tester.pumpWidget(
+      MaterialApp(
+        home: MixinBuilder<Controller>(
+          init: Controller(),
+          builder: (controller) {
+            return Column(
+              children: [
+                Text(
+                  'Count: ${controller.counter.value}',
+                ),
+                Text(
+                  'Count2: ${controller.count}',
+                ),
+                Text(
+                  'Double: ${controller.doubleNum.value}',
+                ),
+                Text(
+                  'String: ${controller.string.value}',
+                ),
+                Text(
+                  'List: ${controller.list.length}',
+                ),
+                Text(
+                  'Bool: ${controller.boolean.value}',
+                ),
+                Text(
+                  'Map: ${controller.map.value.length}',
+                ),
+                FlatButton(
+                  child: Text("increment"),
+                  onPressed: () => controller.increment(),
+                )
+              ],
+            );
+          },
+        ),
+      ),
+    );
+
+    expect(find.text("Count: 0"), findsOneWidget);
+    expect(find.text("Count2: 0"), findsOneWidget);
+    expect(find.text("Double: 0.0"), findsOneWidget);
+    expect(find.text("String: string"), findsOneWidget);
+    expect(find.text("Bool: true"), findsOneWidget);
+    expect(find.text("List: 0"), findsOneWidget);
+    expect(find.text("Map: 0"), findsOneWidget);
+
+    Controller.to.increment();
+
+    await tester.pump();
+
+    expect(find.text("Count: 1"), findsOneWidget);
+
+    await tester.tap(find.text('increment'));
+
+    await tester.pump();
+
+    expect(find.text("Count: 2"), findsOneWidget);
+  });
+
+  testWidgets(
+    "MixinBuilder with build null",
+    (WidgetTester tester) async {
+      expect(
+          () => MixinBuilder<Controller>(
+                init: Controller(),
+                builder: null,
+              ),
+          throwsAssertionError);
+    },
+  );
+}
+
+class Controller extends GetController {
+  static Controller get to => Get.find();
+  int count = 0;
+  var counter = 0.obs;
+  var doubleNum = 0.0.obs;
+  var string = "string".obs;
+  var list = [].obs;
+  var map = {}.obs;
+  var boolean = true.obs;
+
+  void increment() {
+    counter.value++;
+  }
+
+  void increment2() {
+    count++;
+    update(this);
+  }
+}

+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get/get.dart';
+
+void main() {
+  Controller controller = Get.put<Controller>(Controller());
+  testWidgets("GetController smoke test", (tester) async {
+    await tester.pumpWidget(
+      MaterialApp(
+        home: Column(
+          children: [
+            Obx(
+              () => Column(children: [
+                Text(
+                  'Count: ${controller.counter.value}',
+                ),
+                Text(
+                  'Double: ${controller.doubleNum.value}',
+                ),
+                Text(
+                  'String: ${controller.string.value}',
+                ),
+                Text(
+                  'List: ${controller.list.length}',
+                ),
+                Text(
+                  'Bool: ${controller.boolean.value}',
+                ),
+                Text(
+                  'Map: ${controller.map.value.length}',
+                ),
+                FlatButton(
+                  child: Text("increment"),
+                  onPressed: () => controller.increment(),
+                ),
+                obx(() => Text(
+                      'Obx: ${controller.map.value.length}',
+                    ))
+              ]),
+            ),
+          ],
+        ),
+      ),
+    );
+
+    expect(find.text("Count: 0"), findsOneWidget);
+    expect(find.text("Double: 0.0"), findsOneWidget);
+    expect(find.text("String: string"), findsOneWidget);
+    expect(find.text("Bool: true"), findsOneWidget);
+    expect(find.text("List: 0"), findsOneWidget);
+    expect(find.text("Map: 0"), findsOneWidget);
+    expect(find.text("Obx: 0"), findsOneWidget);
+
+    Controller.to.increment();
+
+    await tester.pump();
+
+    expect(find.text("Count: 1"), findsOneWidget);
+
+    await tester.tap(find.text('increment'));
+
+    await tester.pump();
+
+    expect(find.text("Count: 2"), findsOneWidget);
+  });
+}
+
+class Controller extends RxController {
+  static Controller get to => Get.find();
+
+  var counter = 0.obs;
+  var doubleNum = 0.0.obs;
+  var string = "string".obs;
+  var list = [].obs;
+  var map = {}.obs;
+  var boolean = true.obs;
+
+  void increment() {
+    counter.value++;
+  }
+}

@@ -3,6 +3,7 @@ import 'package:flutter_test/flutter_test.dart';
 import 'package:get/get.dart';
 
 void main() {
+  Get.lazyPut<Controller2>(() => Controller2());
   testWidgets("GetController smoke test", (tester) async {
     await tester.pumpWidget(
       MaterialApp(
@@ -32,7 +33,19 @@ void main() {
                 FlatButton(
                   child: Text("increment"),
                   onPressed: () => controller.increment(),
-                )
+                ),
+                GetX<Controller2>(builder: (controller) {
+                  return Text('lazy ${controller.lazy}');
+                }),
+                GetX<Controller>(builder: (controller) {
+                  return Container();
+                }),
+                GetX<ControllerNonGlobal>(
+                    init: ControllerNonGlobal(),
+                    global: false,
+                    builder: (controller) {
+                      return Text('single ${controller.nonGlobal}');
+                    })
               ],
             );
           },
@@ -58,9 +71,19 @@ void main() {
     await tester.pump();
 
     expect(find.text("Count: 2"), findsOneWidget);
+    expect(find.text("lazy 0"), findsOneWidget);
+    expect(find.text("single 0"), findsOneWidget);
   });
 }
 
+class Controller2 extends RxController {
+  int lazy = 0;
+}
+
+class ControllerNonGlobal extends RxController {
+  int nonGlobal = 0;
+}
+
 class Controller extends RxController {
   static Controller get to => Get.find();
 

@@ -3,8 +3,9 @@ import 'package:flutter_test/flutter_test.dart';
 import 'package:get/get.dart';
 
 void main() {
-  testWidgets("GetController smoke test", (tester) async {
-    await tester.pumpWidget(
+  Get.lazyPut<Controller2>(() => Controller2());
+  testWidgets("GetController smoke test", (testr) async {
+    await testr.pumpWidget(
       MaterialApp(
         home: GetBuilder<Controller>(
           init: Controller(),
@@ -16,7 +17,28 @@ void main() {
               FlatButton(
                 child: Text("increment"),
                 onPressed: () => controller.increment(),
-              )
+              ),
+              FlatButton(
+                child: Text("incrementWithId"),
+                onPressed: () => controller.incrementWithId(),
+              ),
+              GetBuilder<Controller>(
+                  id: '1',
+                  didChangeDependencies: (_) {
+                    print("didChangeDependencies called");
+                  },
+                  builder: (controller) {
+                    return Text('id ${controller.counter}');
+                  }),
+              GetBuilder<Controller2>(builder: (controller) {
+                return Text('lazy ${controller.test}');
+              }),
+              GetBuilder<ControllerNonGlobal>(
+                  init: ControllerNonGlobal(),
+                  global: false,
+                  builder: (controller) {
+                    return Text('single ${controller.nonGlobal}');
+                  })
             ],
           ),
         ),
@@ -27,16 +49,44 @@ void main() {
 
     Controller.to.increment();
 
-    await tester.pump();
+    await testr.pump();
 
     expect(find.text("1"), findsOneWidget);
 
-    await tester.tap(find.text('increment'));
+    await testr.tap(find.text('increment'));
 
-    await tester.pump();
+    await testr.pump();
 
     expect(find.text("2"), findsOneWidget);
+
+    await testr.tap(find.text('incrementWithId'));
+
+    await testr.pump();
+
+    expect(find.text("id 3"), findsOneWidget);
+    expect(find.text("lazy 0"), findsOneWidget);
+    expect(find.text("single 0"), findsOneWidget);
   });
+
+  testWidgets(
+    "MixinBuilder with build null",
+    (WidgetTester testr) async {
+      expect(
+          () => GetBuilder<Controller>(
+                init: Controller(),
+                builder: null,
+              ),
+          throwsAssertionError);
+    },
+  );
+
+  testWidgets(
+    "GetBuilder controller error",
+    (WidgetTester testr) async {
+      expect(() => ControllerError().callBuild(),
+          throwsA("build method can\'t be called"));
+    },
+  );
 }
 
 class Controller extends GetController {
@@ -47,4 +97,26 @@ class Controller extends GetController {
     counter++;
     update(this);
   }
+
+  void incrementWithId() {
+    counter++;
+    update(this, ['1']);
+  }
+}
+
+class Controller2 extends GetController {
+  int test = 0;
+}
+
+class ControllerError extends GetController {
+  int test = 0;
+
+  callBuild() {
+    BuildContext context;
+    build(context);
+  }
+}
+
+class ControllerNonGlobal extends GetController {
+  int nonGlobal = 0;
 }

+import 'dart:io';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get/get.dart';
+import 'package:get/src/platform/platform_web.dart';
+
+void main() {
+  test('Platform test', () {
+    expect(GetPlatform.isAndroid, Platform.isAndroid);
+    expect(GetPlatform.isIOS, Platform.isIOS);
+    expect(GetPlatform.isFuchsia, Platform.isFuchsia);
+    expect(GetPlatform.isLinux, Platform.isLinux);
+    expect(GetPlatform.isMacOS, Platform.isMacOS);
+    expect(GetPlatform.isWindows, Platform.isWindows);
+    expect(GetPlatform.isWeb, false);
+    expect(GeneralPlatform.isWeb, true);
+    expect(GeneralPlatform.isAndroid, false);
+    expect(GeneralPlatform.isIOS, false);
+    expect(GeneralPlatform.isFuchsia, false);
+    expect(GeneralPlatform.isLinux, false);
+    expect(GeneralPlatform.isMacOS, false);
+    expect(GeneralPlatform.isWindows, false);
+  });
+}

+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get/get.dart';
+
+import 'util/wrapper.dart';
+
+void main() {
+  testWidgets("Get.dialog close test", (tester) async {
+    await tester.pumpWidget(
+      Wrapper(child: Container()),
+    );
+
+    expect(Get.isDarkMode, false);
+    Get.changeTheme(ThemeData.dark());
+    await Future.delayed(Duration.zero);
+    expect(Get.isDarkMode, true);
+    await tester.pumpAndSettle();
+  });
+}

+import 'package:flutter_test/flutter_test.dart';
+import 'package:get/get.dart';
+
+void main() {
+  testWidgets(
+    "GetMaterialApp with routes null",
+    (WidgetTester testr) async {
+      expect(
+          () => GetMaterialApp(
+                routes: null,
+              ),
+          throwsAssertionError);
+    },
+  );
+
+  testWidgets(
+    "GetMaterialApp with navigatorObservers null",
+    (WidgetTester testr) async {
+      expect(
+          () => GetMaterialApp(
+                navigatorObservers: null,
+              ),
+          throwsAssertionError);
+    },
+  );
+  testWidgets(
+    "GetMaterialApp with title null",
+    (WidgetTester testr) async {
+      expect(
+          () => GetMaterialApp(
+                title: null,
+              ),
+          throwsAssertionError);
+    },
+  );
+  testWidgets(
+    "GetMaterialApp with debugShowMaterialGrid null",
+    (WidgetTester testr) async {
+      expect(
+          () => GetMaterialApp(
+                debugShowMaterialGrid: null,
+              ),
+          throwsAssertionError);
+    },
+  );
+  testWidgets(
+    "GetMaterialApp with showPerformanceOverlay null",
+    (WidgetTester testr) async {
+      expect(
+          () => GetMaterialApp(
+                showPerformanceOverlay: null,
+              ),
+          throwsAssertionError);
+    },
+  );
+  testWidgets(
+    "GetMaterialApp with showSemanticsDebugger null",
+    (WidgetTester testr) async {
+      expect(
+          () => GetMaterialApp(
+                showSemanticsDebugger: null,
+              ),
+          throwsAssertionError);
+    },
+  );
+  testWidgets(
+    "GetMaterialApp with debugShowCheckedModeBanner null",
+    (WidgetTester testr) async {
+      expect(
+          () => GetMaterialApp(
+                debugShowCheckedModeBanner: null,
+              ),
+          throwsAssertionError);
+    },
+  );
+
+  testWidgets(
+    "GetMaterialApp with checkerboardRasterCacheImages null",
+    (WidgetTester testr) async {
+      expect(
+          () => GetMaterialApp(
+                checkerboardRasterCacheImages: null,
+              ),
+          throwsAssertionError);
+    },
+  );
+
+  testWidgets(
+    "GetMaterialApp with checkerboardOffscreenLayers null",
+    (WidgetTester testr) async {
+      expect(
+          () => GetMaterialApp(
+                checkerboardOffscreenLayers: null,
+              ),
+          throwsAssertionError);
+    },
+  );
+}

+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:get/src/routes/get_route.dart';
+
+void main() {
+  testWidgets(
+    "GetRoute page null",
+    (WidgetTester testr) async {
+      expect(() => GetRoute(page: null), throwsAssertionError);
+    },
+  );
+
+  testWidgets(
+    "GetRoute maintainState null",
+    (WidgetTester testr) async {
+      expect(() => GetRoute(page: Scaffold(), maintainState: null),
+          throwsAssertionError);
+    },
+  );
+
+  testWidgets(
+    "GetRoute fullscreenDialog null",
+    (WidgetTester testr) async {
+      expect(() => GetRoute(page: Scaffold(), fullscreenDialog: null),
+          throwsAssertionError);
+    },
+  );
+}

+import 'package:flutter_test/flutter_test.dart';
+import 'package:get/get.dart';
+
+void main() {
+  test('once', () async {
+    final count = 0.obs;
+    int result = -1;
+    once(count, (_) {
+      result = _;
+    });
+    count.value++;
+    await Future.delayed(Duration.zero);
+    expect(1, result);
+    count.value++;
+    await Future.delayed(Duration.zero);
+    expect(1, result);
+    count.value++;
+    await Future.delayed(Duration.zero);
+    expect(1, result);
+  });
+
+  test('ever', () async {
+    final count = 0.obs;
+    int result = -1;
+    ever(count, (_) {
+      result = _;
+    });
+    count.value++;
+    await Future.delayed(Duration.zero);
+    expect(1, result);
+    count.value++;
+    await Future.delayed(Duration.zero);
+    expect(2, result);
+    count.value++;
+    await Future.delayed(Duration.zero);
+    expect(3, result);
+  });
+
+  test('debounce', () async {
+    final count = 0.obs;
+    int result = -1;
+    debounce(count, (_) {
+      print(_);
+      result = _;
+    }, time: Duration(milliseconds: 100));
+
+    count.value++;
+    count.value++;
+    count.value++;
+    count.value++;
+    await Future.delayed(Duration.zero);
+    expect(-1, result);
+    await Future.delayed(Duration(milliseconds: 100));
+    expect(4, result);
+  });
+
+  test('interval', () async {
+    final count = 0.obs;
+    int result = -1;
+    interval(count, (_) {
+      print(_);
+      result = _;
+    }, time: Duration(milliseconds: 100));
+
+    count.value++;
+    await Future.delayed(Duration.zero);
+    await Future.delayed(Duration(milliseconds: 100));
+    expect(1, result);
+    count.value++;
+    count.value++;
+    count.value++;
+    await Future.delayed(Duration.zero);
+    await Future.delayed(Duration(milliseconds: 100));
+    expect(2, result);
+    count.value++;
+    await Future.delayed(Duration.zero);
+    await Future.delayed(Duration(milliseconds: 100));
+    expect(5, result);
+  });
+}