Add files via upload

@@ -147,6 +147,13 @@
  -Added setKey to improve modular compatibility
  -Added ability to define transition duration directly when calling the new route.
 
+## [1.11.0] 
+ -Added experimental GetCupertino
+
+## [1.11.1] 
+ -Improve swipe to back on iOS devices
+
+
 
 
 

@@ -17,7 +17,7 @@ Add this to your package's pubspec.yaml file:
 
 ```
 dependencies:
-  get: ^1.10.5
+  get: ^1.11.1
 ```
   
 And import it:
@@ -28,7 +28,6 @@ Add GetKey to your MaterialApp and enjoy:
 ```dart
 MaterialApp(
     navigatorKey: Get.key,
- // navigatorKey: Get.addKey(Modular.navigatorKey), // to modular users
     home: MyHome(),
   )
 ```
@@ -252,8 +251,6 @@ class MiddleWare {
 
 ### COPY THE ROUTER CLASS BELOW:
 Copy this Router class below and put it in your app, rename routes and classes for your own, add more classes to it if necessary.
-#### Important!!! 
-GetRoute has great performance optimizations that MaterialPageRoute and CupertinoPageRoute do not. It solves the main problems with memory leaks and unexpected reconstructions of the Flutter, so please do not insert MaterialPageRoute or CupertinoPageRoute here, or you will lose one of the main benefits of this lib, in addition to experiencing inconsistencies in the transitions. We recommend always using GetRoute, and if you need custom transitions, use PageRouteBuilder by adding the parameter 'opaque = false' to maintain compatibility with the library.
 
 ```dart
 class Router {
@@ -284,6 +281,35 @@ class Router {
   }
 }
 ```
+##### Experimental
+If you need specific Cupertino elements, such as dragging to close, you can use GetCupertino:
+```dart
+class Router {
+  static Route<dynamic> generateRoute(RouteSettings settings) {
+    switch (settings.name) {
+      case '/':
+        return GetCupertino(
+          page: First(),
+          settings: settings,
+        );
+      case '/second':
+        return GetCupertino(
+            settings: settings, page: Second());
+      case '/third':
+        return GetCupertino(
+            settings: settings,
+            page: Third());
+      default:
+        return GetCupertino(
+            settings: settings,
+            page: Scaffold(
+              body:
+                  Center(child: Text('No route defined for ${settings.name}')),
+            ));
+    }
+  }
+}
+```
 And now, all you need to do is use Get.toNamed() to navigate your named routes, without any context (BLoC will love it), and when your app is compiled to the web, your routes will appear in the url beautifully <3
 
 ```dart

 import 'package:flutter/material.dart';
 import 'package:get/get.dart';
 
-void main() {
-  runApp(MaterialApp(
-    title: 'Navigation Basics',
-    navigatorKey: Get.key,
-    home: FirstRoute(),
-  ));
+void main() => runApp(MyApp());
+
+class MyApp extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp(
+      navigatorKey: Get.key,
+      initialRoute: "/",
+      navigatorObservers: [
+        GetObserver(MiddleWare.observer),
+      ],
+      onGenerateRoute: Router.generateRoute,
+    );
+  }
+}
+
+class MiddleWare {
+  static observer(Routing routing) {
+    ///Trigger any event when a route is pushed or popped by Get. 
+    /// You can listen in addition to the routes, the snackbars, dialogs and bottomsheets on each screen. 
+    ///If you need to enter any of these 3 events directly here, 
+    ///you must specify that the event is != Than you are trying to do.
+    if (routing.current == '/second' && !routing.isSnackbar) {
+      Get.snackbar("Hi", "You are on second route");
+    } else if (routing.current =='/third'){
+      print('last route called');
+    }
+  }
 }
 
-class FirstRoute extends StatelessWidget {
+class First extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     return Scaffold(
       appBar: AppBar(
+        leading: IconButton(
+          icon: Icon(Icons.add),
+          onPressed: () {
+            Get.snackbar("hi", "i am a modern snackbar");
+          },
+        ),
         title: Text('First Route'),
       ),
       body: Center(
         child: RaisedButton(
           child: Text('Open route'),
           onPressed: () {
-            Get.to(SecondRoute());
+            Get.toNamed("/second");
+          },
+        ),
+      ),
+    );
+  }
+}
+
+class Second extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        leading: IconButton(
+          icon: Icon(Icons.add),
+          onPressed: () {
+            Get.snackbar("hi", "i am a modern snackbar");
+          },
+        ),
+        title: Text('second Route'),
+      ),
+      body: Center(
+        child: RaisedButton(
+          child: Text('Open route'),
+          onPressed: () {
+            Get.toNamed("/third");
           },
         ),
       ),
@@ -28,12 +81,12 @@ class FirstRoute extends StatelessWidget {
   }
 }
 
-class SecondRoute extends StatelessWidget {
+class Third extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     return Scaffold(
       appBar: AppBar(
-        title: Text("Second Route"),
+        title: Text("Third Route"),
       ),
       body: Center(
         child: RaisedButton(
@@ -52,21 +105,21 @@ class Router {
     switch (settings.name) {
       case '/':
         return GetRoute(
-          page: SplashScreen(),
+          page: First(),
           settings: settings,
         );
-      case '/Home':
+      case '/second':
         return GetRoute(
-            settings: settings, page: Home(), transition: Transition.fade);
-      case '/Chat':
+            settings: settings, page: Second(), transition: Transition.fade);
+      case '/third':
         return GetRoute(
             settings: settings,
-            page: Chat(),
+            page: Third(),
             transition: Transition.rightToLeft);
       default:
         return GetRoute(
             settings: settings,
-            transition: Transition.rotate,
+            transition: Transition.fade,
             page: Scaffold(
               body:
                   Center(child: Text('No route defined for ${settings.name}')),

@@ -80,7 +80,7 @@ packages:
       name: get
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "1.8.0"
+    version: "1.10.0"
   image:
     dependency: transitive
     description:

@@ -6,3 +6,5 @@ export 'src/snack.dart';
 export 'src/bottomsheet.dart';
 export 'src/snack_route.dart';
 export 'src/route_observer.dart';
+export 'src/getroute_cupertino.dart';
+export 'src/transitions_type.dart';

 import 'package:flutter/material.dart';
 
+import 'transitions_type.dart';
+
 class GetRoute<T> extends PageRouteBuilder<T> {
   /// Construct a Modified PageRoute whose contents are defined by child.
   /// The values of [child], [maintainState], [opaque], and [fullScreenDialog] must not
@@ -221,16 +223,3 @@ class GetRoute<T> extends PageRouteBuilder<T> {
 
   final Duration duration;
 }
-
-enum Transition {
-  fade,
-  rightToLeft,
-  leftToRight,
-  upToDown,
-  downToUp,
-  scale,
-  rotate,
-  size,
-  rightToLeftWithFade,
-  leftToRightWithFade,
-}

+import 'dart:math';
+import 'dart:ui' show lerpDouble;
+
+import 'package:flutter/cupertino.dart';
+import 'package:flutter/foundation.dart';
+import 'package:flutter/gestures.dart';
+
+import 'transitions_type.dart';
+
+const double _kBackGestureWidth = 20.0;
+const double _kMinFlingVelocity = 1.0;
+const int _kMaxDroppedSwipePageForwardAnimationTime = 800; // Milliseconds.
+
+// The maximum time for a page to get reset to it's original position if the
+// user releases a page mid swipe.
+const int _kMaxPageBackAnimationTime = 300;
+
+class GetCupertino<T> extends PageRoute<T> {
+  /// Creates a page route for use in an iOS designed app.
+  ///
+  /// The [builder], [maintainState], and [fullscreenDialog] arguments must not
+  /// be null.
+  GetCupertino({
+    @required this.page,
+    this.title,
+    RouteSettings settings,
+    this.maintainState = true,
+    this.curve = Curves.linear,
+    this.alignment,
+    this.opaque = false,
+    this.transition = Transition.cupertino,
+    this.duration = const Duration(milliseconds: 400),
+    bool fullscreenDialog = false,
+  })  : assert(page != null),
+        assert(maintainState != null),
+        assert(fullscreenDialog != null),
+        //  assert(opaque),
+        super(settings: settings, fullscreenDialog: fullscreenDialog);
+
+  /// Builds the primary contents of the route.
+  final Widget page;
+
+  final Duration duration;
+
+  final String title;
+
+  final Transition transition;
+
+  final Curve curve;
+
+  final Alignment alignment;
+
+  ValueNotifier<String> _previousTitle;
+
+  /// The title string of the previous [GetCupertino].
+  ///
+  /// The [ValueListenable]'s value is readable after the route is installed
+  /// onto a [Navigator]. The [ValueListenable] will also notify its listeners
+  /// if the value changes (such as by replacing the previous route).
+  ///
+  /// The [ValueListenable] itself will be null before the route is installed.
+  /// Its content value will be null if the previous route has no title or
+  /// is not a [GetCupertino].
+  ///
+  /// See also:
+  ///
+  ///  * [ValueListenableBuilder], which can be used to listen and rebuild
+  ///    widgets based on a ValueListenable.
+  ValueListenable<String> get previousTitle {
+    assert(
+      _previousTitle != null,
+      'Cannot read the previousTitle for a route that has not yet been installed',
+    );
+    return _previousTitle;
+  }
+
+  @override
+  void didChangePrevious(Route<dynamic> previousRoute) {
+    final String previousTitleString =
+        previousRoute is GetCupertino ? previousRoute.title : null;
+    if (_previousTitle == null) {
+      _previousTitle = ValueNotifier<String>(previousTitleString);
+    } else {
+      _previousTitle.value = previousTitleString;
+    }
+    super.didChangePrevious(previousRoute);
+  }
+
+  @override
+  final bool maintainState;
+
+  /// Allows you to set opaque to false to prevent route reconstruction.
+  @override
+  final bool opaque;
+
+  @override
+  // A relatively rigorous eyeball estimation.
+  Duration get transitionDuration => const Duration(milliseconds: 400);
+
+  @override
+  Color get barrierColor => null;
+
+  @override
+  String get barrierLabel => null;
+
+  @override
+  bool canTransitionTo(TransitionRoute<dynamic> nextRoute) {
+    // Don't perform outgoing animation if the next route is a fullscreen dialog.
+    return nextRoute is GetCupertino && !nextRoute.fullscreenDialog;
+  }
+
+  /// True if an iOS-style back swipe pop gesture is currently underway for [route].
+  ///
+  /// This just check the route's [NavigatorState.userGestureInProgress].
+  ///
+  /// See also:
+  ///
+  ///  * [popGestureEnabled], which returns true if a user-triggered pop gesture
+  ///    would be allowed.
+  static bool isPopGestureInProgress(PageRoute<dynamic> route) {
+    return route.navigator.userGestureInProgress;
+  }
+
+  /// True if an iOS-style back swipe pop gesture is currently underway for this route.
+  ///
+  /// See also:
+  ///
+  ///  * [isPopGestureInProgress], which returns true if a Cupertino pop gesture
+  ///    is currently underway for specific route.
+  ///  * [popGestureEnabled], which returns true if a user-triggered pop gesture
+  ///    would be allowed.
+  bool get popGestureInProgress => isPopGestureInProgress(this);
+
+  /// Whether a pop gesture can be started by the user.
+  ///
+  /// Returns true if the user can edge-swipe to a previous route.
+  ///
+  /// Returns false once [isPopGestureInProgress] is true, but
+  /// [isPopGestureInProgress] can only become true if [popGestureEnabled] was
+  /// true first.
+  ///
+  /// This should only be used between frames, not during build.
+  bool get popGestureEnabled => _isPopGestureEnabled(this);
+
+  static bool _isPopGestureEnabled<T>(PageRoute<T> route) {
+    // If there's nothing to go back to, then obviously we don't support
+    // the back gesture.
+    if (route.isFirst) return false;
+    // If the route wouldn't actually pop if we popped it, then the gesture
+    // would be really confusing (or would skip internal routes), so disallow it.
+    if (route.willHandlePopInternally) return false;
+    // If attempts to dismiss this route might be vetoed such as in a page
+    // with forms, then do not allow the user to dismiss the route with a swipe.
+    if (route.hasScopedWillPopCallback) return false;
+    // Fullscreen dialogs aren't dismissible by back swipe.
+    if (route.fullscreenDialog) return false;
+    // If we're in an animation already, we cannot be manually swiped.
+    if (route.animation.status != AnimationStatus.completed) return false;
+    // If we're being popped into, we also cannot be swiped until the pop above
+    // it completes. This translates to our secondary animation being
+    // dismissed.
+    if (route.secondaryAnimation.status != AnimationStatus.dismissed)
+      return false;
+    // If we're in a gesture already, we cannot start another.
+    if (isPopGestureInProgress(route)) return false;
+
+    // Looks like a back gesture would be welcome!
+    return true;
+  }
+
+  @override
+  Widget buildPage(BuildContext context, Animation<double> animation,
+      Animation<double> secondaryAnimation) {
+    final Widget child = page;
+    final Widget result = Semantics(
+      scopesRoute: true,
+      explicitChildNodes: true,
+      child: child,
+    );
+    assert(() {
+      if (child == null) {
+        throw FlutterError.fromParts(<DiagnosticsNode>[
+          ErrorSummary(
+              'The builder for route "${settings.name}" returned null.'),
+          ErrorDescription('Route builders must never return null.'),
+        ]);
+      }
+      return true;
+    }());
+    return result;
+  }
+
+  // Called by _CupertinoBackGestureDetector when a pop ("back") drag start
+  // gesture is detected. The returned controller handles all of the subsequent
+  // drag events.
+  static _CupertinoBackGestureController<T> _startPopGesture<T>(
+      PageRoute<T> route) {
+    assert(_isPopGestureEnabled(route));
+
+    return _CupertinoBackGestureController<T>(
+      navigator: route.navigator,
+      controller: route.controller, // protected access
+    );
+  }
+
+  /// Returns a [CupertinoFullscreenDialogTransition] if [route] is a full
+  /// screen dialog, otherwise a [CupertinoPageTransition] is returned.
+  ///
+  /// Used by [GetCupertino.buildTransitions].
+  ///
+  /// This method can be applied to any [PageRoute], not just
+  /// [GetCupertino]. It's typically used to provide a Cupertino style
+  /// horizontal transition for material widgets when the target platform
+  /// is [TargetPlatform.iOS].
+  ///
+  /// See also:
+  ///
+  ///  * [CupertinoPageTransitionsBuilder], which uses this method to define a
+  ///    [PageTransitionsBuilder] for the [PageTransitionsTheme].
+  static Widget buildPageTransitions<T>(
+    PageRoute<T> route,
+    BuildContext context,
+    Animation<double> animation,
+    Animation<double> secondaryAnimation,
+    Widget child,
+    Transition transition,
+    Curve curve,
+    Alignment alignment,
+  ) {
+    if (route.fullscreenDialog) {
+      return CupertinoFullscreenDialogTransition(
+        animation: animation,
+        child: child,
+      );
+    } else {
+      switch (transition) {
+        case Transition.fade:
+          return FadeTransition(
+            opacity: animation,
+            child: _CupertinoBackGestureDetector<T>(
+              enabledCallback: () => _isPopGestureEnabled<T>(route),
+              onStartPopGesture: () => _startPopGesture<T>(route),
+              child: child,
+            ),
+          );
+          break;
+        case Transition.rightToLeft:
+          return SlideTransition(
+            transformHitTests: false,
+            position: new Tween<Offset>(
+              begin: const Offset(1.0, 0.0),
+              end: Offset.zero,
+            ).animate(animation),
+            child: new SlideTransition(
+              position: new Tween<Offset>(
+                begin: Offset.zero,
+                end: const Offset(-1.0, 0.0),
+              ).animate(secondaryAnimation),
+              child: _CupertinoBackGestureDetector<T>(
+                enabledCallback: () => _isPopGestureEnabled<T>(route),
+                onStartPopGesture: () => _startPopGesture<T>(route),
+                child: child,
+              ),
+            ),
+          );
+          break;
+        case Transition.leftToRight:
+          return SlideTransition(
+            transformHitTests: false,
+            position: Tween<Offset>(
+              begin: const Offset(-1.0, 0.0),
+              end: Offset.zero,
+            ).animate(animation),
+            child: new SlideTransition(
+              position: new Tween<Offset>(
+                begin: Offset.zero,
+                end: const Offset(1.0, 0.0),
+              ).animate(secondaryAnimation),
+              child: _CupertinoBackGestureDetector<T>(
+                enabledCallback: () => _isPopGestureEnabled<T>(route),
+                onStartPopGesture: () => _startPopGesture<T>(route),
+                child: child,
+              ),
+            ),
+          );
+          break;
+        case Transition.upToDown:
+          return SlideTransition(
+            transformHitTests: false,
+            position: Tween<Offset>(
+              begin: const Offset(0.0, -1.0),
+              end: Offset.zero,
+            ).animate(animation),
+            child: new SlideTransition(
+              position: new Tween<Offset>(
+                begin: Offset.zero,
+                end: const Offset(0.0, 1.0),
+              ).animate(secondaryAnimation),
+              child: _CupertinoBackGestureDetector<T>(
+                enabledCallback: () => _isPopGestureEnabled<T>(route),
+                onStartPopGesture: () => _startPopGesture<T>(route),
+                child: child,
+              ),
+            ),
+          );
+          break;
+        case Transition.downToUp:
+          return SlideTransition(
+            transformHitTests: false,
+            position: Tween<Offset>(
+              begin: const Offset(0.0, 1.0),
+              end: Offset.zero,
+            ).animate(animation),
+            child: new SlideTransition(
+              position: new Tween<Offset>(
+                begin: Offset.zero,
+                end: const Offset(0.0, -1.0),
+              ).animate(secondaryAnimation),
+              child: _CupertinoBackGestureDetector<T>(
+                enabledCallback: () => _isPopGestureEnabled<T>(route),
+                onStartPopGesture: () => _startPopGesture<T>(route),
+                child: child,
+              ),
+            ),
+          );
+          break;
+        case Transition.scale:
+          return ScaleTransition(
+            alignment: alignment,
+            scale: CurvedAnimation(
+              parent: animation,
+              curve: Interval(
+                0.00,
+                0.50,
+                curve: curve,
+              ),
+            ),
+            child: _CupertinoBackGestureDetector<T>(
+              enabledCallback: () => _isPopGestureEnabled<T>(route),
+              onStartPopGesture: () => _startPopGesture<T>(route),
+              child: child,
+            ),
+          );
+          break;
+        case Transition.rotate:
+          return RotationTransition(
+            alignment: alignment,
+            turns: animation,
+            child: ScaleTransition(
+              alignment: alignment,
+              scale: animation,
+              child: FadeTransition(
+                opacity: animation,
+                child: _CupertinoBackGestureDetector<T>(
+                  enabledCallback: () => _isPopGestureEnabled<T>(route),
+                  onStartPopGesture: () => _startPopGesture<T>(route),
+                  child: child,
+                ),
+              ),
+            ),
+          );
+          break;
+        case Transition.size:
+          return Align(
+            alignment: alignment,
+            child: SizeTransition(
+              sizeFactor: CurvedAnimation(
+                parent: animation,
+                curve: curve,
+              ),
+              child: _CupertinoBackGestureDetector<T>(
+                enabledCallback: () => _isPopGestureEnabled<T>(route),
+                onStartPopGesture: () => _startPopGesture<T>(route),
+                child: child,
+              ),
+            ),
+          );
+          break;
+        case Transition.rightToLeftWithFade:
+          return SlideTransition(
+            position: Tween<Offset>(
+              begin: const Offset(1.0, 0.0),
+              end: Offset.zero,
+            ).animate(animation),
+            child: FadeTransition(
+              opacity: animation,
+              child: SlideTransition(
+                position: Tween<Offset>(
+                  begin: Offset.zero,
+                  end: const Offset(-1.0, 0.0),
+                ).animate(secondaryAnimation),
+                child: _CupertinoBackGestureDetector<T>(
+                  enabledCallback: () => _isPopGestureEnabled<T>(route),
+                  onStartPopGesture: () => _startPopGesture<T>(route),
+                  child: child,
+                ),
+              ),
+            ),
+          );
+          break;
+        case Transition.leftToRightWithFade:
+          return SlideTransition(
+            position: Tween<Offset>(
+              begin: const Offset(-1.0, 0.0),
+              end: Offset.zero,
+            ).animate(animation),
+            child: FadeTransition(
+              opacity: animation,
+              child: SlideTransition(
+                position: Tween<Offset>(
+                  begin: Offset.zero,
+                  end: const Offset(1.0, 0.0),
+                ).animate(secondaryAnimation),
+                child: _CupertinoBackGestureDetector<T>(
+                  enabledCallback: () => _isPopGestureEnabled<T>(route),
+                  onStartPopGesture: () => _startPopGesture<T>(route),
+                  child: child,
+                ),
+              ),
+            ),
+          );
+          break;
+        case Transition.cupertino:
+          return CupertinoPageTransition(
+            primaryRouteAnimation: animation,
+            secondaryRouteAnimation: secondaryAnimation,
+            // Check if the route has an animation that's currently participating
+            // in a back swipe gesture.
+            //
+            // In the middle of a back gesture drag, let the transition be linear to
+            // match finger motions.
+            linearTransition: isPopGestureInProgress(route),
+            child: _CupertinoBackGestureDetector<T>(
+              enabledCallback: () => _isPopGestureEnabled<T>(route),
+              onStartPopGesture: () => _startPopGesture<T>(route),
+              child: child,
+            ),
+          );
+          break;
+        default:
+          return CupertinoPageTransition(
+            primaryRouteAnimation: animation,
+            secondaryRouteAnimation: secondaryAnimation,
+            // Check if the route has an animation that's currently participating
+            // in a back swipe gesture.
+            //
+            // In the middle of a back gesture drag, let the transition be linear to
+            // match finger motions.
+            linearTransition: isPopGestureInProgress(route),
+            child: _CupertinoBackGestureDetector<T>(
+              enabledCallback: () => _isPopGestureEnabled<T>(route),
+              onStartPopGesture: () => _startPopGesture<T>(route),
+              child: child,
+            ),
+          );
+      }
+    }
+  }
+
+  @override
+  Widget buildTransitions(BuildContext context, Animation<double> animation,
+      Animation<double> secondaryAnimation, Widget child) {
+    return buildPageTransitions<T>(this, context, animation, secondaryAnimation,
+        child, transition, curve, alignment);
+  }
+
+  @override
+  String get debugLabel => '${super.debugLabel}(${settings.name})';
+}
+
+class _CupertinoBackGestureDetector<T> extends StatefulWidget {
+  const _CupertinoBackGestureDetector({
+    Key key,
+    @required this.enabledCallback,
+    @required this.onStartPopGesture,
+    @required this.child,
+  })  : assert(enabledCallback != null),
+        assert(onStartPopGesture != null),
+        assert(child != null),
+        super(key: key);
+
+  final Widget child;
+
+  final ValueGetter<bool> enabledCallback;
+
+  final ValueGetter<_CupertinoBackGestureController<T>> onStartPopGesture;
+
+  @override
+  _CupertinoBackGestureDetectorState<T> createState() =>
+      _CupertinoBackGestureDetectorState<T>();
+}
+
+class _CupertinoBackGestureDetectorState<T>
+    extends State<_CupertinoBackGestureDetector<T>> {
+  _CupertinoBackGestureController<T> _backGestureController;
+
+  HorizontalDragGestureRecognizer _recognizer;
+
+  @override
+  void initState() {
+    super.initState();
+    _recognizer = HorizontalDragGestureRecognizer(debugOwner: this)
+      ..onStart = _handleDragStart
+      ..onUpdate = _handleDragUpdate
+      ..onEnd = _handleDragEnd
+      ..onCancel = _handleDragCancel;
+  }
+
+  @override
+  void dispose() {
+    _recognizer.dispose();
+    super.dispose();
+  }
+
+  void _handleDragStart(DragStartDetails details) {
+    assert(mounted);
+    assert(_backGestureController == null);
+    _backGestureController = widget.onStartPopGesture();
+  }
+
+  void _handleDragUpdate(DragUpdateDetails details) {
+    assert(mounted);
+    assert(_backGestureController != null);
+    _backGestureController.dragUpdate(
+        _convertToLogical(details.primaryDelta / context.size.width));
+  }
+
+  void _handleDragEnd(DragEndDetails details) {
+    assert(mounted);
+    assert(_backGestureController != null);
+    _backGestureController.dragEnd(_convertToLogical(
+        details.velocity.pixelsPerSecond.dx / context.size.width));
+    _backGestureController = null;
+  }
+
+  void _handleDragCancel() {
+    assert(mounted);
+    // This can be called even if start is not called, paired with the "down" event
+    // that we don't consider here.
+    _backGestureController?.dragEnd(0.0);
+    _backGestureController = null;
+  }
+
+  void _handlePointerDown(PointerDownEvent event) {
+    if (widget.enabledCallback()) _recognizer.addPointer(event);
+  }
+
+  double _convertToLogical(double value) {
+    switch (Directionality.of(context)) {
+      case TextDirection.rtl:
+        return -value;
+      case TextDirection.ltr:
+        return value;
+    }
+    return null;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    assert(debugCheckHasDirectionality(context));
+    // For devices with notches, the drag area needs to be larger on the side
+    // that has the notch.
+    double dragAreaWidth = Directionality.of(context) == TextDirection.ltr
+        ? MediaQuery.of(context).padding.left
+        : MediaQuery.of(context).padding.right;
+    dragAreaWidth = max(dragAreaWidth, _kBackGestureWidth);
+    return Stack(
+      fit: StackFit.passthrough,
+      children: <Widget>[
+        widget.child,
+        PositionedDirectional(
+          start: 0.0,
+          width: dragAreaWidth,
+          top: 0.0,
+          bottom: 0.0,
+          child: Listener(
+            onPointerDown: _handlePointerDown,
+            behavior: HitTestBehavior.translucent,
+          ),
+        ),
+      ],
+    );
+  }
+}
+
+class _CupertinoBackGestureController<T> {
+  /// Creates a controller for an iOS-style back gesture.
+  ///
+  /// The [navigator] and [controller] arguments must not be null.
+  _CupertinoBackGestureController({
+    @required this.navigator,
+    @required this.controller,
+  })  : assert(navigator != null),
+        assert(controller != null) {
+    navigator.didStartUserGesture();
+  }
+
+  final AnimationController controller;
+  final NavigatorState navigator;
+
+  /// The drag gesture has changed by [fractionalDelta]. The total range of the
+  /// drag should be 0.0 to 1.0.
+  void dragUpdate(double delta) {
+    controller.value -= delta;
+  }
+
+  /// The drag gesture has ended with a horizontal motion of
+  /// [fractionalVelocity] as a fraction of screen width per second.
+  void dragEnd(double velocity) {
+    // Fling in the appropriate direction.
+    // AnimationController.fling is guaranteed to
+    // take at least one frame.
+    //
+    // This curve has been determined through rigorously eyeballing native iOS
+    // animations.
+    const Curve animationCurve = Curves.fastLinearToSlowEaseIn;
+    bool animateForward;
+
+    // If the user releases the page before mid screen with sufficient velocity,
+    // or after mid screen, we should animate the page out. Otherwise, the page
+    // should be animated back in.
+    if (velocity.abs() >= _kMinFlingVelocity)
+      animateForward = velocity <= 0;
+    else
+      animateForward = controller.value > 0.5;
+
+    if (animateForward) {
+      // The closer the panel is to dismissing, the shorter the animation is.
+      // We want to cap the animation time, but we want to use a linear curve
+      // to determine it.
+      final int droppedPageForwardAnimationTime = min(
+        lerpDouble(
+                _kMaxDroppedSwipePageForwardAnimationTime, 0, controller.value)
+            .floor(),
+        _kMaxPageBackAnimationTime,
+      );
+      controller.animateTo(1.0,
+          duration: Duration(milliseconds: droppedPageForwardAnimationTime),
+          curve: animationCurve);
+    } else {
+      // This route is destined to pop at this point. Reuse navigator's pop.
+      navigator.pop();
+
+      // The popping may have finished inline if already at the target destination.
+      if (controller.isAnimating) {
+        // Otherwise, use a custom popping animation duration and curve.
+        final int droppedPageBackAnimationTime = lerpDouble(
+                0, _kMaxDroppedSwipePageForwardAnimationTime, controller.value)
+            .floor();
+        controller.animateBack(0.0,
+            duration: Duration(milliseconds: droppedPageBackAnimationTime),
+            curve: animationCurve);
+      }
+    }
+
+    if (controller.isAnimating) {
+      // Keep the userGestureInProgress in true state so we don't change the
+      // curve of the page transition mid-flight since CupertinoPageTransition
+      // depends on userGestureInProgress.
+      AnimationStatusListener animationStatusCallback;
+      animationStatusCallback = (AnimationStatus status) {
+        navigator.didStopUserGesture();
+        controller.removeStatusListener(animationStatusCallback);
+      };
+      controller.addStatusListener(animationStatusCallback);
+    } else {
+      navigator.didStopUserGesture();
+    }
+  }
+}

+import 'dart:io';
+
 import 'package:flutter/material.dart';
 import 'package:flutter/scheduler.dart';
 import 'backdrop_blur.dart';
 import 'bottomsheet.dart';
 import 'dialog.dart';
+import 'getroute_cupertino.dart';
 import 'snack.dart';
 import 'getroute.dart';
+import 'transitions_type.dart';
 import 'transparent_route.dart';
 
 class Get {
@@ -46,16 +50,23 @@ class Get {
   /// routes rebuild bug present in Flutter. If for some strange reason you want the default behavior
   /// of rebuilding every app after a route, use rebuildRoutes = true as the parameter.
   static to(Widget page,
-      {bool rebuildRoutes = false,
-      Transition transition = Transition.fade,
+      {bool rebuildRoutes,
+      Transition transition,
       Duration duration = const Duration(milliseconds: 400)}) {
     // if (key.currentState.mounted) // add this if appear problems on future with route navigate
     // when widget don't mounted
-    return key.currentState.push(GetRoute(
-        opaque: rebuildRoutes,
-        page: page,
-        transition: transition,
-        duration: duration));
+
+    return Platform.isIOS
+        ? key.currentState.push(GetCupertino(
+            opaque: rebuildRoutes ?? true,
+            page: page,
+            transition: transition ?? Transition.cupertino,
+            duration: duration))
+        : key.currentState.push(GetRoute(
+            opaque: rebuildRoutes ?? false,
+            page: page,
+            transition: transition ?? Transition.fade,
+            duration: duration));
   }
 
   /// It replaces Navigator.pushNamed, but needs no context, and it doesn't have the Navigator.pushNamed
@@ -357,4 +368,16 @@ class Get {
         ..show();
     });
   }
+
+  static iconColor() {
+    return Theme.of(key.currentContext).iconTheme.color;
+  }
+
+  static height() {
+    return MediaQuery.of(key.currentContext).size.height;
+  }
+
+  static width() {
+    return MediaQuery.of(key.currentContext).size.width;
+  }
 }

+enum Transition {
+  fade,
+  rightToLeft,
+  leftToRight,
+  upToDown,
+  downToUp,
+  scale,
+  rotate,
+  size,
+  rightToLeftWithFade,
+  leftToRightWithFade,
+  cupertino
+}

 name: get
 description: A consistent navigation library that lets you navigate between screens, open dialogs, and display snackbars easily with no context.
-version: 1.10.5
+version: 1.11.1
 homepage: https://github.com/jonataslaw/get
 
 environment: