import 'dart:math' as math; import 'package:flutter/gestures.dart'; import 'package:flutter/services.dart'; import 'package:flutter/widgets.dart'; /// What a back gesture needs from the page it closes. abstract interface class ContainerTransformGestureRoute implements PredictiveBackRoute { /// Whether a back gesture may start now: the page is current, at rest and /// would really pop. bool get backGestureEnabled; /// A finger took the page from the start edge. void startSwipeBack(); /// The finger moved by [fraction] of the page's width toward the end edge. void updateSwipeBack(double fraction); /// The finger let go at [velocity] page widths per second. void endSwipeBack(double velocity); } /// The back gestures of a page that shrinks into its item: on a Cupertino /// host the native swipe from the start edge; on Android the system's /// predictive back. Either one drives the page's own animation, so the /// shrink follows the finger, and releasing commits or cancels it. class ContainerTransformBackGestures extends StatelessWidget { const ContainerTransformBackGestures({ super.key, required this.route, required this.cupertino, required this.child, }); final ContainerTransformGestureRoute route; final bool cupertino; final Widget child; @override Widget build(BuildContext context) => cupertino ? _EdgeSwipeBack(route: route, child: child) : _PredictiveBack(route: route, child: child); } /// The width of the start edge that takes a swipe back, as in iOS. const double _edgeWidth = 20; class _EdgeSwipeBack extends StatefulWidget { const _EdgeSwipeBack({required this.route, required this.child}); final ContainerTransformGestureRoute route; final Widget child; @override State<_EdgeSwipeBack> createState() => _EdgeSwipeBackState(); } class _EdgeSwipeBackState extends State<_EdgeSwipeBack> { late final HorizontalDragGestureRecognizer _recognizer = HorizontalDragGestureRecognizer(debugOwner: this) ..onStart = _start ..onUpdate = _update ..onEnd = _end ..onCancel = _cancel; bool _dragging = false; @override void dispose() { _recognizer.dispose(); if (_dragging) widget.route.endSwipeBack(0); super.dispose(); } double _logical(double value) => Directionality.of(context) == TextDirection.rtl ? -value : value; void _start(DragStartDetails details) { _dragging = true; widget.route.startSwipeBack(); } void _update(DragUpdateDetails details) { if (!_dragging) return; widget.route.updateSwipeBack( _logical(details.primaryDelta! / context.size!.width), ); } void _end(DragEndDetails details) { if (!_dragging) return; _dragging = false; widget.route.endSwipeBack( _logical(details.velocity.pixelsPerSecond.dx / context.size!.width), ); } void _cancel() { if (!_dragging) return; _dragging = false; widget.route.endSwipeBack(0); } @override Widget build(BuildContext context) { final padding = MediaQuery.paddingOf(context); final notch = Directionality.of(context) == TextDirection.rtl ? padding.right : padding.left; return Stack( fit: StackFit.passthrough, children: [ widget.child, PositionedDirectional( start: 0, top: 0, bottom: 0, width: math.max(notch, _edgeWidth), child: Listener( behavior: HitTestBehavior.translucent, onPointerDown: (event) { if (widget.route.backGestureEnabled) { _recognizer.addPointer(event); } }, ), ), ], ); } } /// Forwards Android's predictive back to the page, as the stock Material /// page transition does, without that transition's own shrink. class _PredictiveBack extends StatefulWidget { const _PredictiveBack({required this.route, required this.child}); final ContainerTransformGestureRoute route; final Widget child; @override State<_PredictiveBack> createState() => _PredictiveBackState(); } class _PredictiveBackState extends State<_PredictiveBack> with WidgetsBindingObserver { @override void initState() { super.initState(); WidgetsBinding.instance.addObserver(this); } @override void dispose() { WidgetsBinding.instance.removeObserver(this); super.dispose(); } @override bool handleStartBackGesture(PredictiveBackEvent backEvent) { if (backEvent.isButtonEvent || !widget.route.backGestureEnabled) { return false; } widget.route.handleStartBackGesture(progress: 1 - backEvent.progress); return true; } @override void handleUpdateBackGestureProgress(PredictiveBackEvent backEvent) => widget .route .handleUpdateBackGestureProgress(progress: 1 - backEvent.progress); @override void handleCancelBackGesture() => widget.route.handleCancelBackGesture(); @override void handleCommitBackGesture() => widget.route.handleCommitBackGesture(); @override Widget build(BuildContext context) => widget.child; }