原生路由

初始化

在MyApp的build方法中添加常规路由处理方法onGenerateRoute，未知路由处理方法onUnknownRoute，以及定义初始路由initialRoute。

  1. class MyApp extends StatelessWidget {
  2.   const MyApp({Key? key}) : super(key: key);
  3.   // This widget is the root of your application.
  4.   @override
  5.   Widget build(BuildContext context) {
  6.     return MaterialApp(
  7.       title: 'Flutter Demo',
  8.       theme: ThemeData(
  9.         primarySwatch: Colors.blue,
  10.       ),
  11.       initialRoute: 'splash',
  12.       onGenerateRoute: onGenerateRoute,
  13.       onUnknownRoute: onUnknownRoute,
  14.     );
  15.   }
  16. }
  18. //固定写法
  19. var onGenerateRoute = (RouteSettings settings) {
  20.   final String name = settings.name ??"404";
  21.   final Function pageContentBuilder = routes[name] as Function;
  22.   if (pageContentBuilder != null) {
  23.     if (settings.arguments != null) {
  24.       final Route route = MaterialPageRoute(
  25.           builder: (context) =>
  26.               pageContentBuilder(context, arguments: settings.arguments));
  27.       return route;
  28.     } else {
  29.       final Route route =
  30.       MaterialPageRoute(builder: (context) => pageContentBuilder(context));
  31.       return route;
  32.     }
  33.   }
  34. };
  36. // 未知路由
  37. var onUnknownRoute = (RouteSettings settings) {
  38.   final String name = "404";
  39.   final Function pageContentBuilder = routes[name] as Function;
  40.   if (pageContentBuilder != null) {
  41.     final Route route =
  42.     MaterialPageRoute(builder: (context) => pageContentBuilder(context));
  43.     return route;
  44.   }
  45. };
  47. final routes = {
  48.   '404': (context) => NotFoundPage(),/// 404 notfound
  49.   /// 往这里加
  50. };

添加了onGenerateRoute之后，Flutter的路由优先执行onGenerateRoute方法，initialRoute配置的初始路由也是通过onGenerateRoute去查找。当代码传递的路由名称在routes中找不到时，就会执行onUnknownRoute方法，跳转到自定义未知路由。

跳转

使用Navigator.pushNamed 跳转到指定的路由。

  1. Navigator.pushNamed(context, 'RouteName',arguments: 携带的数据);

这是Navigator.pushNamed方法的源码：

  1. @optionalTypeArgs
  2.   static Future<T?> pushNamed<T extends Object?>(
  3.     BuildContext context,
  4.     String routeName, {
  5.     Object? arguments,
  6.   }) {
  7.     return Navigator.of(context).pushNamed<T>(routeName, arguments: arguments);
  8.   }

返回的是一个 Future类型，所以可以使用.then来监听返回值，相当于实现了Android中的onActivityResult：

  1. Navigator.pushNamed(context, 'RouteName',arguments: 携带的数据)
  2.       .then((value) {
  3.         // todo something
  4.       });

关闭页面

使用Navigator.pop来关闭当前页面。

  1. Navigator.pop(context);

这是Navigator.pop方法的源码：

  1.     @optionalTypeArgs
  2.   static void pop<T extends Object?>(BuildContext context, [ T? result ]) {
  3.     Navigator.of(context).pop<T>(result);
  4.   }

若果需要带参返回，则将参数赋值给result,由Navigator.pushNamed().then接收数据。如：

  1. Navigator.pop(context,data);

其他方法

  • popAndPushNamed 关闭当前页并根据名称跳转到指定页
  • pushReplacementNamed 根据名称更换当前路由堆栈
  • pushNamedAndRemoveUntil 根据名称跳转指定页并移除之前的路由堆栈（将跳转到的页面作为根路由）
  • push 跳转到指定页
  • pushReplacement 更换当前路由堆栈
  • pushAndRemoveUntil 跳转指定页并移除之前的路由堆栈（将跳转到的页面作为根路由）
  • replace 替换路由
  • replaceRouteBelow 更换路由路线
  • popUntil 关闭所有路由
  • removeRoute 移除路由
  • removeRouteBelow 移除路由路线
  • canPop 判断当前页面是否可关闭

GetX(推荐使用)※

getx是一款功能强大的插件，路由管理是其中一项功能。

初始化

在pubspec.yaml中引入getx，当前使用的版本为4.3.4。

  1. dependencies:
  2.   flutter:
  3.     sdk: flutter
  6.   # The following adds the Cupertino Icons font to your application.
  7.   # Use with the CupertinoIcons class for iOS style icons.
  8.   cupertino_icons: ^1.0.2
  10.   get: ^4.3.4  # 路由和状态管理

在main.dart的MyApp中使用GetMaterialApp替换原有的MaterialApp：

  1. void main() {
  2.   runApp(MyApp());
  3. }
  5. class MyApp extends StatelessWidget {
  6.   @override
  7.   Widget build(BuildContext context) {
  8.     return GetMaterialApp(
  9.       title: 'Flutter Demo',
  10.       theme: ThemeData(
  11.         primarySwatch: Colors.blue,
  12.       ),
  13.       home: HomePage(),
  14.     );
  15.   }
  16. }

跳转

使用 Get.to(()=>Page()) （或Get.to(Page()) ，没有其他参数的情况下推荐使用前者） 实现跳转,表示从当前页面跳转到Page页面，也可以使用Get.toNamed(‘path’):

  1. Get.to(()=>Page()) ; // Get.to(Page());
  3. Get.toNamed('path');

使用Get.to可以在Page()中传递构造参数，也可以使用get中的arguments传参：

  1. Get.to(Page(data:data),arguments: data);
  3. Get.toNamed('path',arguments: data); ///Get.toNamed 不能使用构造参数传值

如果使用Get.toNamed，需要配置path解析方法getPages：

  1. class MyApp extends StatelessWidget {
  2.   @override
  3.   Widget build(BuildContext context) {
  4.     return GetMaterialApp(
  5.       title: 'Flutter Demo',
  6.       theme: ThemeData(
  7.         primarySwatch: Colors.blue,
  8.       ),
  9.       initialRoute: '/home',
  10.       getPages: getPageList,
  11.     );
  12.   }
  13. }
  15. var getPageList = [GetPage(name: '/home', page: () => HomePage()),];

getPageList是个数组，按GetPage(name: ‘/home’, page: () => HomePage()),格式往里边添加即可。
相同的，Get.to方法返回一个Future?，可以使用.then来监听返回值：

  1. Get.to(()=>HomePage())?.then((value) {
  2.   ScaffoldMessenger.of(context).showSnackBar(
  3.     SnackBar(
  4.       content: Text('返回值为：$value'),
  5.     ),// 弹出底部提示框，显示返回值
  6.   );
  7. });

关闭页面

关闭当前页面：

  1. Get.back();

关闭当前页面并跳转到新页面：

  1. Get.off(()=>Page());
  2. Get.offNamed('path');

清除所有路由并跳转到新页面（以新页面作为根节点）：

  1. Get.offAll(()=>Page());
  2. Get.offAllNamed('path');

其他方法

其他用法和原生相似，具体方法可在getx的GetNavigation类中查询，附上源码：

  1. extension GetNavigation on GetInterface {
  2.   /// **Navigation.push()** shortcut.<br><br>
  3.   ///
  4.   /// Pushes a new `page` to the stack
  5.   ///
  6.   /// It has the advantage of not needing context,
  7.   /// so you can call from your business logic
  8.   ///
  9.   /// You can set a custom [transition], and a transition [duration].
  10.   ///
  11.   /// You can send any type of value to the other route in the [arguments].
  12.   ///
  13.   /// Just like native routing in Flutter, you can push a route
  14.   /// as a [fullscreenDialog],
  15.   ///
  16.   /// [id] is for when you are using nested navigation,
  17.   /// as explained in documentation
  18.   ///
  19.   /// If you want the same behavior of ios that pops a route when the user drag,
  20.   /// you can set [popGesture] to true
  21.   ///
  22.   /// If you're using the [Bindings] api, you must define it here
  23.   ///
  24.   /// By default, GetX will prevent you from push a route that you already in,
  25.   /// if you want to push anyway, set [preventDuplicates] to false
  26.   Future<T?>? to<T>(
  27.     dynamic page, {
  28.     bool? opaque,
  29.     Transition? transition,
  30.     Curve? curve,
  31.     Duration? duration,
  32.     int? id,
  33.     String? routeName,
  34.     bool fullscreenDialog = false,
  35.     dynamic arguments,
  36.     Bindings? binding,
  37.     bool preventDuplicates = true,
  38.     bool? popGesture,
  39.     double Function(BuildContext context)? gestureWidth,
  40.   }) {
  41.     // var routeName = "/${page.runtimeType}";
  42.     routeName ??= "/${page.runtimeType}";
  43.     routeName = _cleanRouteName(routeName);
  44.     if (preventDuplicates && routeName == currentRoute) {
  45.       return null;
  46.     }
  47.     return global(id).currentState?.push<T>(
  48.           GetPageRoute<T>(
  49.             opaque: opaque ?? true,
  50.             page: _resolvePage(page, 'to'),
  51.             routeName: routeName,
  52.             gestureWidth: gestureWidth,
  53.             settings: RouteSettings(
  54.               name: routeName,
  55.               arguments: arguments,
  56.             ),
  57.             popGesture: popGesture ?? defaultPopGesture,
  58.             transition: transition ?? defaultTransition,
  59.             curve: curve ?? defaultTransitionCurve,
  60.             fullscreenDialog: fullscreenDialog,
  61.             binding: binding,
  62.             transitionDuration: duration ?? defaultTransitionDuration,
  63.           ),
  64.         );
  65.   }
  67.   GetPageBuilder _resolvePage(dynamic page, String method) {
  68.     if (page is GetPageBuilder) {
  69.       return page;
  70.     } else if (page is Widget) {
  71.       Get.log(
  72.           '''WARNING, consider using: "Get.$method(() => Page())" instead of "Get.$method(Page())".
  73. Using a widget function instead of a widget fully guarantees that the widget and its controllers will be removed from memory when they are no longer used.
  74.       ''');
  75.       return () => page;
  76.     } else if (page is String) {
  77.       throw '''Unexpected String,
  78. use toNamed() instead''';
  79.     } else {
  80.       throw '''Unexpected format,
  81. you can only use widgets and widget functions here''';
  82.     }
  83.   }
  85.   /// **Navigation.pushNamed()** shortcut.<br><br>
  86.   ///
  87.   /// Pushes a new named `page` to the stack.
  88.   ///
  89.   /// It has the advantage of not needing context, so you can call
  90.   /// from your business logic.
  91.   ///
  92.   /// You can send any type of value to the other route in the [arguments].
  93.   ///
  94.   /// [id] is for when you are using nested navigation,
  95.   /// as explained in documentation
  96.   ///
  97.   /// By default, GetX will prevent you from push a route that you already in,
  98.   /// if you want to push anyway, set [preventDuplicates] to false
  99.   ///
  100.   /// Note: Always put a slash on the route ('/page1'), to avoid unnexpected errors
  101.   Future<T?>? toNamed<T>(
  102.     String page, {
  103.     dynamic arguments,
  104.     int? id,
  105.     bool preventDuplicates = true,
  106.     Map<String, String>? parameters,
  107.   }) {
  108.     if (preventDuplicates && page == currentRoute) {
  109.       return null;
  110.     }
  112.     if (parameters != null) {
  113.       final uri = Uri(path: page, queryParameters: parameters);
  114.       page = uri.toString();
  115.     }
  117.     return global(id).currentState?.pushNamed<T>(
  118.           page,
  119.           arguments: arguments,
  120.         );
  121.   }
  123.   /// **Navigation.pushReplacementNamed()** shortcut.<br><br>
  124.   ///
  125.   /// Pop the current named `page` in the stack and push a new one in its place
  126.   ///
  127.   /// It has the advantage of not needing context, so you can call
  128.   /// from your business logic.
  129.   ///
  130.   /// You can send any type of value to the other route in the [arguments].
  131.   ///
  132.   /// [id] is for when you are using nested navigation,
  133.   /// as explained in documentation
  134.   ///
  135.   /// By default, GetX will prevent you from push a route that you already in,
  136.   /// if you want to push anyway, set [preventDuplicates] to false
  137.   ///
  138.   /// Note: Always put a slash on the route ('/page1'), to avoid unnexpected errors
  139.   Future<T?>? offNamed<T>(
  140.     String page, {
  141.     dynamic arguments,
  142.     int? id,
  143.     bool preventDuplicates = true,
  144.     Map<String, String>? parameters,
  145.   }) {
  146.     if (preventDuplicates && page == currentRoute) {
  147.       return null;
  148.     }
  150.     if (parameters != null) {
  151.       final uri = Uri(path: page, queryParameters: parameters);
  152.       page = uri.toString();
  153.     }
  154.     return global(id).currentState?.pushReplacementNamed(
  155.           page,
  156.           arguments: arguments,
  157.         );
  158.   }
  160.   /// **Navigation.popUntil()** shortcut.<br><br>
  161.   ///
  162.   /// Calls pop several times in the stack until [predicate] returns true
  163.   ///
  164.   /// [id] is for when you are using nested navigation,
  165.   /// as explained in documentation
  166.   ///
  167.   /// [predicate] can be used like this:
  168.   /// `Get.until((route) => Get.currentRoute == '/home')`so when you get to home page,
  169.   ///
  170.   /// or also like this:
  171.   /// `Get.until((route) => !Get.isDialogOpen())`, to make sure the
  172.   /// dialog is closed
  173.   void until(RoutePredicate predicate, {int? id}) {
  174.     // if (key.currentState.mounted) // add this if appear problems on future with route navigate
  175.     // when widget don't mounted
  176.     return global(id).currentState?.popUntil(predicate);
  177.   }
  179.   /// **Navigation.pushAndRemoveUntil()** shortcut.<br><br>
  180.   ///
  181.   /// Push the given `page`, and then pop several pages in the stack until
  182.   /// [predicate] returns true
  183.   ///
  184.   /// [id] is for when you are using nested navigation,
  185.   /// as explained in documentation
  186.   ///
  187.   /// Obs: unlike other get methods, this one you need to send a function
  188.   /// that returns the widget to the page argument, like this:
  189.   /// Get.offUntil(GetPageRoute(page: () => HomePage()), predicate)
  190.   ///
  191.   /// [predicate] can be used like this:
  192.   /// `Get.offUntil(page, (route) => (route as GetPageRoute).routeName == '/home')`
  193.   /// to pop routes in stack until home,
  194.   /// or also like this:
  195.   /// `Get.until((route) => !Get.isDialogOpen())`, to make sure the dialog
  196.   /// is closed
  197.   Future<T?>? offUntil<T>(Route<T> page, RoutePredicate predicate, {int? id}) {
  198.     // if (key.currentState.mounted) // add this if appear problems on future with route navigate
  199.     // when widget don't mounted
  200.     return global(id).currentState?.pushAndRemoveUntil<T>(page, predicate);
  201.   }
  203.   /// **Navigation.pushNamedAndRemoveUntil()** shortcut.<br><br>
  204.   ///
  205.   /// Push the given named `page`, and then pop several pages in the stack
  206.   /// until [predicate] returns true
  207.   ///
  208.   /// You can send any type of value to the other route in the [arguments].
  209.   ///
  210.   /// [id] is for when you are using nested navigation,
  211.   /// as explained in documentation
  212.   ///
  213.   /// [predicate] can be used like this:
  214.   /// `Get.offNamedUntil(page, ModalRoute.withName('/home'))`
  215.   /// to pop routes in stack until home,
  216.   /// or like this:
  217.   /// `Get.offNamedUntil((route) => !Get.isDialogOpen())`,
  218.   /// to make sure the dialog is closed
  219.   ///
  220.   /// Note: Always put a slash on the route name ('/page1'), to avoid unexpected errors
  221.   Future<T?>? offNamedUntil<T>(
  222.     String page,
  223.     RoutePredicate predicate, {
  224.     int? id,
  225.     dynamic arguments,
  226.     Map<String, String>? parameters,
  227.   }) {
  228.     if (parameters != null) {
  229.       final uri = Uri(path: page, queryParameters: parameters);
  230.       page = uri.toString();
  231.     }
  233.     return global(id).currentState?.pushNamedAndRemoveUntil<T>(
  234.           page,
  235.           predicate,
  236.           arguments: arguments,
  237.         );
  238.   }
  240.   /// **Navigation.popAndPushNamed()** shortcut.<br><br>
  241.   ///
  242.   /// Pop the current named page and pushes a new `page` to the stack
  243.   /// in its place
  244.   ///
  245.   /// You can send any type of value to the other route in the [arguments].
  246.   /// It is very similar to `offNamed()` but use a different approach
  247.   ///
  248.   /// The `offNamed()` pop a page, and goes to the next. The
  249.   /// `offAndToNamed()` goes to the next page, and removes the previous one.
  250.   /// The route transition animation is different.
  251.   Future<T?>? offAndToNamed<T>(
  252.     String page, {
  253.     dynamic arguments,
  254.     int? id,
  255.     dynamic result,
  256.     Map<String, String>? parameters,
  257.   }) {
  258.     if (parameters != null) {
  259.       final uri = Uri(path: page, queryParameters: parameters);
  260.       page = uri.toString();
  261.     }
  262.     return global(id).currentState?.popAndPushNamed(
  263.           page,
  264.           arguments: arguments,
  265.           result: result,
  266.         );
  267.   }
  269.   /// **Navigation.removeRoute()** shortcut.<br><br>
  270.   ///
  271.   /// Remove a specific [route] from the stack
  272.   ///
  273.   /// [id] is for when you are using nested navigation,
  274.   /// as explained in documentation
  275.   void removeRoute(Route<dynamic> route, {int? id}) {
  276.     return global(id).currentState?.removeRoute(route);
  277.   }
  279.   /// **Navigation.pushNamedAndRemoveUntil()** shortcut.<br><br>
  280.   ///
  281.   /// Push a named `page` and pop several pages in the stack
  282.   /// until [predicate] returns true. [predicate] is optional
  283.   ///
  284.   /// It has the advantage of not needing context, so you can
  285.   /// call from your business logic.
  286.   ///
  287.   /// You can send any type of value to the other route in the [arguments].
  288.   ///
  289.   /// [predicate] can be used like this:
  290.   /// `Get.until((route) => Get.currentRoute == '/home')`so when you get to home page,
  291.   /// or also like
  292.   /// `Get.until((route) => !Get.isDialogOpen())`, to make sure the dialog
  293.   /// is closed
  294.   ///
  295.   /// [id] is for when you are using nested navigation,
  296.   /// as explained in documentation
  297.   ///
  298.   /// Note: Always put a slash on the route ('/page1'), to avoid unexpected errors
  299.   Future<T?>? offAllNamed<T>(
  300.     String newRouteName, {
  301.     RoutePredicate? predicate,
  302.     dynamic arguments,
  303.     int? id,
  304.     Map<String, String>? parameters,
  305.   }) {
  306.     if (parameters != null) {
  307.       final uri = Uri(path: newRouteName, queryParameters: parameters);
  308.       newRouteName = uri.toString();
  309.     }
  311.     return global(id).currentState?.pushNamedAndRemoveUntil<T>(
  312.           newRouteName,
  313.           predicate ?? (_) => false,
  314.           arguments: arguments,
  315.         );
  316.   }
  318.   /// Returns true if a Snackbar, Dialog or BottomSheet is currently OPEN
  319.   bool get isOverlaysOpen =>
  320.       (isSnackbarOpen! || isDialogOpen! || isBottomSheetOpen!);
  322.   /// Returns true if there is no Snackbar, Dialog or BottomSheet open
  323.   bool get isOverlaysClosed =>
  324.       (!isSnackbarOpen! && !isDialogOpen! && !isBottomSheetOpen!);
  326.   /// **Navigation.popUntil()** shortcut.<br><br>
  327.   ///
  328.   /// Pop the current page, snackbar, dialog or bottomsheet in the stack
  329.   ///
  330.   /// if your set [closeOverlays] to true, Get.back() will close the
  331.   /// currently open snackbar/dialog/bottomsheet AND the current page
  332.   ///
  333.   /// [id] is for when you are using nested navigation,
  334.   /// as explained in documentation
  335.   ///
  336.   /// It has the advantage of not needing context, so you can call
  337.   /// from your business logic.
  338.   void back<T>({
  339.     T? result,
  340.     bool closeOverlays = false,
  341.     bool canPop = true,
  342.     int? id,
  343.   }) {
  344.     if (closeOverlays && isOverlaysOpen) {
  345.       navigator?.popUntil((route) {
  346.         return (isOverlaysClosed);
  347.       });
  348.     }
  349.     if (canPop) {
  350.       if (global(id).currentState?.canPop() == true) {
  351.         global(id).currentState?.pop<T>(result);
  352.       }
  353.     } else {
  354.       global(id).currentState?.pop<T>(result);
  355.     }
  356.   }
  358.   /// **Navigation.popUntil()** (with predicate) shortcut .<br><br>
  359.   ///
  360.   /// Close as many routes as defined by [times]
  361.   ///
  362.   /// [id] is for when you are using nested navigation,
  363.   /// as explained in documentation
  364.   void close(int times, [int? id]) {
  365.     if (times < 1) {
  366.       times = 1;
  367.     }
  368.     var count = 0;
  369.     var back = global(id).currentState?.popUntil((route) => count++ == times);
  371.     return back;
  372.   }
  374.   /// **Navigation.pushReplacement()** shortcut .<br><br>
  375.   ///
  376.   /// Pop the current page and pushes a new `page` to the stack
  377.   ///
  378.   /// It has the advantage of not needing context,
  379.   /// so you can call from your business logic
  380.   ///
  381.   /// You can set a custom [transition], define a Tween [curve],
  382.   /// and a transition [duration].
  383.   ///
  384.   /// You can send any type of value to the other route in the [arguments].
  385.   ///
  386.   /// Just like native routing in Flutter, you can push a route
  387.   /// as a [fullscreenDialog],
  388.   ///
  389.   /// [id] is for when you are using nested navigation,
  390.   /// as explained in documentation
  391.   ///
  392.   /// If you want the same behavior of ios that pops a route when the user drag,
  393.   /// you can set [popGesture] to true
  394.   ///
  395.   /// If you're using the [Bindings] api, you must define it here
  396.   ///
  397.   /// By default, GetX will prevent you from push a route that you already in,
  398.   /// if you want to push anyway, set [preventDuplicates] to false
  399.   Future<T?>? off<T>(
  400.     dynamic page, {
  401.     bool opaque = false,
  402.     Transition? transition,
  403.     Curve? curve,
  404.     bool? popGesture,
  405.     int? id,
  406.     String? routeName,
  407.     dynamic arguments,
  408.     Bindings? binding,
  409.     bool fullscreenDialog = false,
  410.     bool preventDuplicates = true,
  411.     Duration? duration,
  412.     double Function(BuildContext context)? gestureWidth,
  413.   }) {
  414.     routeName ??= "/${page.runtimeType.toString()}";
  415.     routeName = _cleanRouteName(routeName);
  416.     if (preventDuplicates && routeName == currentRoute) {
  417.       return null;
  418.     }
  419.     return global(id).currentState?.pushReplacement(GetPageRoute(
  420.         opaque: opaque,
  421.         gestureWidth: gestureWidth,
  422.         page: _resolvePage(page, 'off'),
  423.         binding: binding,
  424.         settings: RouteSettings(
  425.           arguments: arguments,
  426.           name: routeName,
  427.         ),
  428.         routeName: routeName,
  429.         fullscreenDialog: fullscreenDialog,
  430.         popGesture: popGesture ?? defaultPopGesture,
  431.         transition: transition ?? defaultTransition,
  432.         curve: curve ?? defaultTransitionCurve,
  433.         transitionDuration: duration ?? defaultTransitionDuration));
  434.   }
  436.   ///
  437.   /// Push a `page` and pop several pages in the stack
  438.   /// until [predicate] returns true. [predicate] is optional
  439.   ///
  440.   /// It has the advantage of not needing context,
  441.   /// so you can call from your business logic
  442.   ///
  443.   /// You can set a custom [transition], a [curve] and a transition [duration].
  444.   ///
  445.   /// You can send any type of value to the other route in the [arguments].
  446.   ///
  447.   /// Just like native routing in Flutter, you can push a route
  448.   /// as a [fullscreenDialog],
  449.   ///
  450.   /// [predicate] can be used like this:
  451.   /// `Get.until((route) => Get.currentRoute == '/home')`so when you get to home page,
  452.   /// or also like
  453.   /// `Get.until((route) => !Get.isDialogOpen())`, to make sure the dialog
  454.   /// is closed
  455.   ///
  456.   /// [id] is for when you are using nested navigation,
  457.   /// as explained in documentation
  458.   ///
  459.   /// If you want the same behavior of ios that pops a route when the user drag,
  460.   /// you can set [popGesture] to true
  461.   ///
  462.   /// If you're using the [Bindings] api, you must define it here
  463.   ///
  464.   /// By default, GetX will prevent you from push a route that you already in,
  465.   /// if you want to push anyway, set [preventDuplicates] to false
  466.   Future<T?>? offAll<T>(
  467.     dynamic page, {
  468.     RoutePredicate? predicate,
  469.     bool opaque = false,
  470.     bool? popGesture,
  471.     int? id,
  472.     String? routeName,
  473.     dynamic arguments,
  474.     Bindings? binding,
  475.     bool fullscreenDialog = false,
  476.     Transition? transition,
  477.     Curve? curve,
  478.     Duration? duration,
  479.     double Function(BuildContext context)? gestureWidth,
  480.   }) {
  481.     routeName ??= "/${page.runtimeType.toString()}";
  482.     routeName = _cleanRouteName(routeName);
  483.     return global(id).currentState?.pushAndRemoveUntil<T>(
  484.         GetPageRoute<T>(
  485.           opaque: opaque,
  486.           popGesture: popGesture ?? defaultPopGesture,
  487.           page: _resolvePage(page, 'offAll'),
  488.           binding: binding,
  489.           gestureWidth: gestureWidth,
  490.           settings: RouteSettings(
  491.             name: routeName,
  492.             arguments: arguments,
  493.           ),
  494.           fullscreenDialog: fullscreenDialog,
  495.           routeName: routeName,
  496.           transition: transition ?? defaultTransition,
  497.           curve: curve ?? defaultTransitionCurve,
  498.           transitionDuration: duration ?? defaultTransitionDuration,
  499.         ),
  500.         predicate ?? (route) => false);
  501.   }
  503.  /// 省略部分代码
  504. }