From 94a41ff56386fe5137ed2b5c62471f2b2867be64 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Mon, 2 Nov 2026 15:58:51 +0000 Subject: [PATCH] Glide one tab highlight and stop tab entrances replaying on selection The per-tab entrance pop lived in each icon, but the hosts swap a tab's icon subtree when it is selected or deselected (Material wrapped the selected icon in its own circle; Cupertino did the same in activeIcon), so every tab switch remounted those icons and replayed their pop. The bar now owns the entrance, highlight slide and bounce animations and restarts the entrance only when its set of tabs changes. One highlight behind the icons glides to the new tab (250 ms, stretching to 1.25x wide mid-move) and the new icon bounces (1.08x, 180 ms); reduced motion jumps. Cupertino paints it from tab 0 above the host's backdrop blur. --- .../ui/adaptive/floating_destination_bar.dart | 382 +++++++++--------- app/lib/ui/adaptive/floating_tab_motion.dart | 251 ++++++++++++ app/lib/ui/motion/motion.dart | 13 + .../adaptive/floating_bar_edge_gap_test.dart | 52 ++- .../ui/adaptive/floating_tab_motion_test.dart | 287 +++++++++++++ 5 files changed, 766 insertions(+), 219 deletions(-) create mode 100644 app/lib/ui/adaptive/floating_tab_motion.dart create mode 100644 app/test/ui/adaptive/floating_tab_motion_test.dart diff --git a/app/lib/ui/adaptive/floating_destination_bar.dart b/app/lib/ui/adaptive/floating_destination_bar.dart index 22ca1007..b7646b7c 100644 --- a/app/lib/ui/adaptive/floating_destination_bar.dart +++ b/app/lib/ui/adaptive/floating_destination_bar.dart @@ -4,8 +4,8 @@ import 'package:flutter/cupertino.dart'; import 'package:flutter/material.dart'; import 'floating_bar_layout.dart'; +import 'floating_tab_motion.dart'; import 'glass_pill.dart'; -import '../motion/motion.dart'; /// A tab bar which floats above the bottom edge in a frosted [GlassPill] /// instead of becoming a full-width system bar. Used for the app's @@ -16,10 +16,13 @@ import '../motion/motion.dart'; /// [kFloatingBarMargin] from the sides and above the bottom safe area. Only /// the pill takes taps: the space beside it reaches the content behind. /// -/// The selected tab's icon sits in a tinted circle. Each circle keeps the -/// same gap from its neighbours as from the pill's top and bottom, and the -/// outer ones the same gap from the pill's sides, so the pill's round ends -/// are concentric with them. +/// One tinted circle sits behind the selected tab's icon and glides to a +/// newly selected tab. At rest it keeps the same gap from its neighbours' slots +/// as from the pill's top and bottom, and at the outer tabs the same gap from +/// the pill's sides, so the pill's round ends are concentric with it. +/// +/// The tabs pop in when the bar appears or its set of tabs changes, never +/// when only the selection does. /// /// The tabs show icons only. Each tab's label stays its accessible name (and /// the Material tooltip), so screen readers still announce it; the icons must @@ -29,7 +32,7 @@ import '../motion/motion.dart'; /// [NavigationBar], Cupertino [CupertinoTabBar]), so tab semantics (selected /// state, "tab n of m") come from the host. The Cupertino path builds no /// Material widget. -class FloatingDestinationBar extends StatelessWidget { +class FloatingDestinationBar extends StatefulWidget { const FloatingDestinationBar({ super.key, required this.cupertino, @@ -93,9 +96,66 @@ class FloatingDestinationBar extends StatelessWidget { /// The side margin at [FloatingBarEdge.top], matching the top bar's own. static const double topMargin = 12; + /// The selection highlight inside each bar, for tests. + static const Key highlightKey = ValueKey( + 'floating-destination-bar.highlight', + ); + + /// The width of a pill holding [tabs] tabs, when the space allows it. + static double pillWidth({required bool cupertino, required int tabs}) => + cupertino + ? cupertinoHighlightSize * tabs + + 2 * cupertinoEdgeGap + + math.max(0, tabs - 1) * cupertinoNeighbourGap + : materialHighlightSize * tabs + + 2 * materialEdgeGap + + math.max(0, tabs - 1) * materialNeighbourGap; + + @override + State createState() => _FloatingDestinationBarState(); +} + +class _FloatingDestinationBarState extends State + with TickerProviderStateMixin { + late final FloatingTabMotion _motion = FloatingTabMotion(this); + bool _entered = false; + + bool get cupertino => widget.cupertino; + List get items => widget.items; + int get currentIndex => widget.currentIndex; + + @override + void didChangeDependencies() { + super.didChangeDependencies(); + if (_entered) return; + _entered = true; + _motion.enter(context, count: items.length, selected: currentIndex); + } + + @override + void didUpdateWidget(FloatingDestinationBar oldWidget) { + super.didUpdateWidget(oldWidget); + if (_tabSetIdentity(oldWidget.items) != _tabSetIdentity(items)) { + // New tabs (a run's page tabs appearing): they pop in, and the + // highlight starts on the selected one. + _motion.enter(context, count: items.length, selected: currentIndex); + } else if (oldWidget.currentIndex != currentIndex) { + _motion.select(context, currentIndex); + } + } + + @override + void dispose() { + _motion.dispose(); + super.dispose(); + } + + static String _tabSetIdentity(List items) => + items.map((item) => '${item.key ?? item.label}:${item.label}').join('|'); + @override Widget build(BuildContext context) { - final top = edge == FloatingBarEdge.top; + final top = widget.edge == FloatingBarEdge.top; final bar = LayoutBuilder( builder: (context, constraints) { final width = math.max(0.0, math.min(constraints.maxWidth, _tabsWidth)); @@ -120,8 +180,11 @@ class FloatingDestinationBar extends StatelessWidget { child: GlassPill( cupertino: cupertino, child: _edgeAligned( + context, width, - cupertino ? _cupertinoBar(context) : _materialBar(context), + cupertino + ? _cupertinoBar(context, _slot(width)) + : _materialBar(context), ), ), ), @@ -133,7 +196,12 @@ class FloatingDestinationBar extends StatelessWidget { // Under a top bar: no safe area to keep clear of, only the gap to the // content below. return Padding( - padding: const EdgeInsets.fromLTRB(topMargin, 0, topMargin, 8), + padding: const EdgeInsets.fromLTRB( + FloatingDestinationBar.topMargin, + 0, + FloatingDestinationBar.topMargin, + 8, + ), child: bar, ); } @@ -149,74 +217,114 @@ class FloatingDestinationBar extends StatelessWidget { ); } - double get _highlight => - cupertino ? cupertinoHighlightSize : materialHighlightSize; - double get _gap => cupertino ? cupertinoEdgeGap : materialEdgeGap; - double get _neighbourGap => - cupertino ? cupertinoNeighbourGap : materialNeighbourGap; + double get _highlight => cupertino + ? FloatingDestinationBar.cupertinoHighlightSize + : FloatingDestinationBar.materialHighlightSize; + double get _gap => cupertino + ? FloatingDestinationBar.cupertinoEdgeGap + : FloatingDestinationBar.materialEdgeGap; + double get _neighbourGap => cupertino + ? FloatingDestinationBar.cupertinoNeighbourGap + : FloatingDestinationBar.materialNeighbourGap; /// The width the icon-only tabs need side by side. Icons do not scale with /// text, so the pill keeps its size at any text scale. - double get _tabsWidth => pillWidth(cupertino: cupertino, tabs: items.length); + double get _tabsWidth => FloatingDestinationBar.pillWidth( + cupertino: cupertino, + tabs: items.length, + ); - /// The width of a pill holding [tabs] tabs, when the space allows it. - static double pillWidth({required bool cupertino, required int tabs}) => - cupertino - ? cupertinoHighlightSize * tabs + - 2 * cupertinoEdgeGap + - math.max(0, tabs - 1) * cupertinoNeighbourGap - : materialHighlightSize * tabs + - 2 * materialEdgeGap + - math.max(0, tabs - 1) * materialNeighbourGap; + /// The gap between neighbouring circles in a pill [width] wide: the named + /// one, or less in a pill squeezed below its tabs' width. + double _neighbour(double width) { + final count = items.length; + if (count < 2) return _neighbourGap; + final available = math.max(0.0, width - 2 * _gap - count * _highlight); + return math.min(_neighbourGap, available / (count - 1)); + } + + /// The width of each equal tab slot, which is also the distance between + /// neighbouring circles' centres. + double _slot(double width) => _highlight + math.max(0, _neighbour(width)); + + bool get _hasSelection => currentIndex >= 0 && currentIndex < items.length; /// Insets the host bar's equal tab slots so the outer circles sit the edge /// gap from the pill's sides. A pill squeezed below its tabs' width keeps /// that gap and narrows the gaps between neighbours instead, as long as - /// the circles still fit side by side. - Widget _edgeAligned(double width, Widget bar) { + /// the circles still fit side by side. The Material highlight is laid over + /// the first slot, behind the host bar. + Widget _edgeAligned(BuildContext context, double width, Widget bar) { final count = items.length; - if (count < 2) return bar; + if (count == 0) return bar; // The native bars use equal-width slots. Let their slot centers be the // desired circle centers, and translate the slots by half the difference // between the outer and neighbour gaps. The pill clips the harmless // overflow of the native slot backgrounds, while the circles remain // exactly edge-aligned. - final available = math.max(0.0, width - 2 * _gap - count * _highlight); - final neighbour = math.min(_neighbourGap, available / (count - 1)); - final slot = _highlight + math.max(0, neighbour); - final barWidth = slot * count; - final offset = _gap - neighbour / 2; + final slot = _slot(width); + final offset = _gap - _neighbour(width) / 2; return ClipRect( child: SizedBox( width: width, - height: cupertino ? cupertinoHeight : materialHeight, + height: cupertino + ? FloatingDestinationBar.cupertinoHeight + : FloatingDestinationBar.materialHeight, child: OverflowBox( alignment: AlignmentDirectional.topStart, minWidth: 0, maxWidth: double.infinity, child: Transform.translate( offset: Offset(offset, 0), - child: SizedBox(width: barWidth, child: bar), + child: SizedBox( + width: slot * count, + child: Stack( + fit: StackFit.expand, + children: [ + if (!cupertino && _hasSelection) + PositionedDirectional( + start: 0, + top: 0, + bottom: 0, + width: slot, + child: _highlightFor(context, slot), + ), + bar, + ], + ), + ), ), ), ), ); } + /// The bar's one selection highlight, laid out over tab 0. + Widget _highlightFor(BuildContext context, double slot) => + FloatingTabHighlight( + key: FloatingDestinationBar.highlightKey, + motion: _motion, + slot: slot, + size: _highlight, + color: cupertino + ? CupertinoTheme.of(context).primaryColor.withValues(alpha: 0.16) + : Theme.of(context).colorScheme.secondaryContainer, + ); + Widget _materialBar(BuildContext context) { - final scheme = Theme.of(context).colorScheme; return NavigationBarTheme( data: const NavigationBarThemeData( backgroundColor: Colors.transparent, elevation: 0, surfaceTintColor: Colors.transparent, - // The selected icon draws its own circle (the stock indicator is a - // fixed 64x32); the stock one stays for its circular ink response. + // The bar draws one gliding highlight behind the icons (the stock + // indicator is a fixed 64x32 that jumps); the stock one stays for + // its circular ink response. indicatorColor: Colors.transparent, indicatorShape: CircleBorder(), - height: materialHeight, + height: FloatingDestinationBar.materialHeight, iconTheme: WidgetStatePropertyAll( - IconThemeData(size: materialIconSize), + IconThemeData(size: FloatingDestinationBar.materialIconSize), ), // Icons only; the label remains each tab's accessible name and its // tooltip. @@ -224,19 +332,15 @@ class FloatingDestinationBar extends StatelessWidget { ), child: NavigationBar( selectedIndex: currentIndex, - onDestinationSelected: onTap, + onDestinationSelected: widget.onTap, destinations: [ for (var index = 0; index < items.length; index += 1) NavigationDestination( key: items[index].key, - icon: _entrance(items[index].icon, index), - selectedIcon: _SelectionCircle( - color: scheme.secondaryContainer, - ring: _materialRing, - child: _entrance( - items[index].selectedIcon ?? items[index].icon, - index, - ), + icon: _icon(items[index].icon, index), + selectedIcon: _icon( + items[index].selectedIcon ?? items[index].icon, + index, ), label: items[index].label, ), @@ -247,30 +351,42 @@ class FloatingDestinationBar extends StatelessWidget { /// The stock Cupertino bar, transparent inside the pill. Each tab shows its /// icon only, named by its label for accessibility; the item's key covers - /// the whole tab, and the selected tab's icon sits in a tinted circle so - /// the selection reads at a glance, not by colour alone. - Widget _cupertinoBar(BuildContext context) { - final active = CupertinoTheme.of(context).primaryColor; + /// the whole tab, and the highlight behind the selected icon makes the + /// selection read at a glance, not by colour alone. + /// + /// The host blurs whatever is behind its translucent background, so the + /// highlight is painted from inside tab 0, under the icons but above the + /// blur. + Widget _cupertinoBar(BuildContext context, double slot) { Widget tab( FloatingDestinationItem item, { required bool selected, required int index, }) { - final icon = selected - ? _SelectionCircle( - color: active.withValues(alpha: 0.16), - ring: _cupertinoRing, - child: _entrance(item.selectedIcon ?? item.icon, index), - ) - : _entrance(item.icon, index); + final icon = _icon( + selected ? item.selectedIcon ?? item.icon : item.icon, + index, + ); return KeyedSubtree( key: item.key, child: Semantics( label: item.label, // The host centres the icon above a 4px bottom inset; 4 above it - // centres the icon and its circle in the whole bar, so the circle - // is as far from the pill's top as from its bottom. - child: Padding(padding: const EdgeInsets.only(top: 4), child: icon), + // centres the icon and its highlight in the whole bar, so the + // highlight is as far from the pill's top as from its bottom. + child: Padding( + padding: const EdgeInsets.only(top: 4), + child: index == 0 && _hasSelection + ? Stack( + clipBehavior: Clip.none, + alignment: Alignment.center, + children: [ + Positioned.fill(child: _highlightFor(context, slot)), + icon, + ], + ) + : icon, + ), ), ); } @@ -283,10 +399,10 @@ class FloatingDestinationBar extends StatelessWidget { // Secondary-label translucency over glass falls below text contrast // requirements. The host label role remains readable in both themes. inactiveColor: CupertinoColors.label.resolveFrom(context), - iconSize: cupertinoIconSize, - height: cupertinoHeight, + iconSize: FloatingDestinationBar.cupertinoIconSize, + height: FloatingDestinationBar.cupertinoHeight, currentIndex: currentIndex, - onTap: onTap, + onTap: widget.onTap, items: [ for (var index = 0; index < items.length; index += 1) BottomNavigationBarItem( @@ -298,138 +414,10 @@ class FloatingDestinationBar extends StatelessWidget { ); } - Widget _entrance(Widget child, int index) => _TabEntrance( - key: ValueKey('${_tabSetIdentity}_$index'), - index: index, - count: items.length, - child: child, - ); - - String get _tabSetIdentity => - items.map((item) => '${item.key ?? item.label}:${item.label}').join('|'); -} - -class _TabEntrance extends StatefulWidget { - const _TabEntrance({ - super.key, - required this.index, - required this.count, - required this.child, - }); - - final int index; - final int count; - final Widget child; - - @override - State<_TabEntrance> createState() => _TabEntranceState(); -} - -class _TabEntranceState extends State<_TabEntrance> - with SingleTickerProviderStateMixin { - late final AnimationController _controller; - bool _started = false; - - @override - void initState() { - super.initState(); - _controller = AnimationController( - vsync: this, - duration: - Motion.tabEntranceDuration + - Motion.tabEntranceStagger * (widget.count - 1), - ); - } - - @override - void didChangeDependencies() { - super.didChangeDependencies(); - if (_started) return; - _started = true; - final duration = Motion.of(context, Motion.tabEntranceDuration); - _controller.duration = - duration + Motion.tabEntranceStagger * (widget.count - 1); - if (duration == Duration.zero) { - _controller.value = 1; - } else { - _controller.forward(); - } - } - - @override - void dispose() { - _controller.dispose(); - super.dispose(); - } - - @override - Widget build(BuildContext context) { - final total = _controller.duration!.inMicroseconds; - final start = Motion.tabEntranceStagger.inMicroseconds * widget.index; - final window = Motion.tabEntranceDuration.inMicroseconds; - final begin = total == 0 ? 0.0 : start / total; - final end = total == 0 ? 1.0 : (start + window) / total; - final pop = CurvedAnimation( - parent: _controller, - curve: Interval( - begin, - end.clamp(begin, 1.0).toDouble(), - curve: Curves.easeOutBack, - ), - ); - final opacity = CurvedAnimation( - parent: _controller, - curve: Interval( - begin, - total == 0 - ? 1.0 - : (start + window * Motion.tabEntranceOpacityPortion) - .clamp(start, total) - .toDouble() / - total, - curve: Curves.easeOut, - ), - ); - return FadeTransition( - opacity: opacity, - // Tabs (and their badge counts) stay announced while they fade in. - alwaysIncludeSemantics: true, - child: AnimatedBuilder( - animation: pop, - child: widget.child, - builder: (context, child) => Transform.translate( - offset: Offset(0, (1 - pop.value) * Motion.tabEntranceSlideDistance), - child: Transform.scale( - scale: Tween( - begin: Motion.tabEntranceScaleBegin, - end: 1, - ).evaluate(pop), - child: child, - ), - ), - ), - ); - } -} - -/// The selected tab's icon (and any badge on it) in a tinted circle, [ring] -/// wider than the icon on every side. -class _SelectionCircle extends StatelessWidget { - const _SelectionCircle({ - required this.color, - required this.ring, - required this.child, - }); - - final Color color; - final double ring; - final Widget child; - - @override - Widget build(BuildContext context) => DecoratedBox( - decoration: ShapeDecoration(color: color, shape: const CircleBorder()), - child: Padding(padding: EdgeInsets.all(ring), child: child), - ); + /// Tab [index]'s icon, animated by the bar: the host swaps a tab's icon + /// subtree on selection, so the icon itself holds no animation state. + Widget _icon(Widget child, int index) => + FloatingTabEntrance(motion: _motion, index: index, child: child); } /// The platform-neutral data needed by [FloatingDestinationBar]. diff --git a/app/lib/ui/adaptive/floating_tab_motion.dart b/app/lib/ui/adaptive/floating_tab_motion.dart new file mode 100644 index 00000000..d5b54c99 --- /dev/null +++ b/app/lib/ui/adaptive/floating_tab_motion.dart @@ -0,0 +1,251 @@ +import 'dart:math' as math; + +import 'package:flutter/widgets.dart'; + +import '../motion/motion.dart'; + +/// The animations of one floating tab bar: its tabs popping in, the +/// selection highlight gliding between tabs and the newly selected icon's +/// bounce. +/// +/// They live with the bar, not with each tab's icon, because the host +/// navigation controls rebuild a tab's icon subtree whenever it is selected +/// or deselected: state kept in the icons would restart with every tap. +class FloatingTabMotion { + FloatingTabMotion(TickerProvider vsync) + : entrance = AnimationController(vsync: vsync), + slide = AnimationController( + vsync: vsync, + duration: Motion.tabHighlightDuration, + value: 1, + ), + bounce = AnimationController( + vsync: vsync, + duration: Motion.tabBounceDuration, + value: 1, + ); + + /// Drives every tab's entrance; tab n plays its pop in its own window. + final AnimationController entrance; + final AnimationController slide; + final AnimationController bounce; + + int _count = 0; + final List<({Animation pop, Animation opacity})> _entrances = + []; + double _from = 0; + int _to = 0; + + /// Plays the entrance of a bar of [count] tabs, from the start, and places + /// the highlight on [selected] without a move. + void enter( + BuildContext context, { + required int count, + required int selected, + }) { + _count = count; + final duration = Motion.of(context, Motion.tabEntranceDuration); + entrance.duration = + duration + Motion.tabEntranceStagger * math.max(0, count - 1); + if (duration == Duration.zero) { + entrance.value = 1; + } else { + entrance.forward(from: 0); + } + _splitEntrance(); + _from = selected.toDouble(); + _to = selected; + slide.value = 1; + bounce.value = 1; + } + + /// Glides the highlight from where it is now to [selected] and bounces + /// that tab's icon. Under reduced motion the highlight jumps. + void select(BuildContext context, int selected) { + if (selected == _to) return; + _from = position; + _to = selected; + if (Motion.of(context, Motion.tabHighlightDuration) == Duration.zero) { + slide.value = 1; + bounce.value = 1; + return; + } + slide.forward(from: 0); + bounce.forward(from: 0); + } + + double get _travel => Motion.curve.transform(slide.value); + + /// The highlight's position in tab slots: 1.5 is halfway from tab 1 to 2. + double get position => _from + (_to - _from) * _travel; + + /// The highlight's width over its height: 1 at rest, at most + /// [Motion.tabHighlightStretch] halfway through a move. + double get stretch => _from == _to + ? 1 + : 1 + (Motion.tabHighlightStretch - 1) * math.sin(math.pi * _travel); + + /// The scale of tab [index]'s icon: only the newly selected one bounces. + double scaleOf(int index) { + if (index != _to || bounce.isCompleted) return 1; + final t = bounce.value; + final rise = t < 0.5 ? t * 2 : (1 - t) * 2; + return 1 + (Motion.tabBounceScale - 1) * Curves.easeOut.transform(rise); + } + + /// Tab [index]'s share of [entrance]: its pop, then its fade. + ({Animation pop, Animation opacity}) entranceOf(int index) => + index >= 0 && index < _entrances.length + ? _entrances[index] + : (pop: kAlwaysCompleteAnimation, opacity: kAlwaysCompleteAnimation); + + /// Splits [entrance] into each tab's window, once per entrance. + void _splitEntrance() { + _disposeEntrances(); + final total = entrance.duration!.inMicroseconds; + if (total == 0) return; + final window = Motion.tabEntranceDuration.inMicroseconds; + for (var index = 0; index < _count; index += 1) { + final start = Motion.tabEntranceStagger.inMicroseconds * index; + final begin = (start / total).clamp(0.0, 1.0); + final end = ((start + window) / total).clamp(begin, 1.0); + final faded = + ((start + window * Motion.tabEntranceOpacityPortion) / total).clamp( + begin, + 1.0, + ); + _entrances.add(( + pop: CurvedAnimation( + parent: entrance, + curve: Interval(begin, end, curve: Curves.easeOutBack), + ), + opacity: CurvedAnimation( + parent: entrance, + curve: Interval(begin, faded, curve: Curves.easeOut), + ), + )); + } + } + + void _disposeEntrances() { + for (final animations in _entrances) { + (animations.pop as CurvedAnimation).dispose(); + (animations.opacity as CurvedAnimation).dispose(); + } + _entrances.clear(); + } + + void dispose() { + _disposeEntrances(); + entrance.dispose(); + slide.dispose(); + bounce.dispose(); + } +} + +/// Tab [index]'s icon (or the highlight behind it) popping in with the bar, +/// and bouncing when it becomes selected. +class FloatingTabEntrance extends StatelessWidget { + const FloatingTabEntrance({ + super.key, + required this.motion, + required this.index, + required this.child, + this.bounces = true, + }); + + final FloatingTabMotion motion; + final int index; + final bool bounces; + final Widget child; + + @override + Widget build(BuildContext context) { + final entrance = motion.entranceOf(index); + return FadeTransition( + opacity: entrance.opacity, + // Tabs (and their badge counts) stay announced while they fade in. + alwaysIncludeSemantics: true, + child: AnimatedBuilder( + animation: Listenable.merge([entrance.pop, motion.bounce]), + child: child, + builder: (context, child) { + final pop = entrance.pop.value; + final scale = + Motion.tabEntranceScaleBegin + + (1 - Motion.tabEntranceScaleBegin) * pop; + return Transform.translate( + offset: Offset(0, (1 - pop) * Motion.tabEntranceSlideDistance), + child: Transform.scale( + scale: scale * (bounces ? motion.scaleOf(index) : 1), + child: child, + ), + ); + }, + ), + ); + } +} + +/// The one selection highlight of a bar, behind its icons: a circle of +/// [size] centred on the selected tab, gliding (and stretching along the way) +/// to a newly selected one. It takes no taps and says nothing; the host's +/// tabs carry the selected state. +/// +/// It is laid out over tab 0 (its slot, or its icon) and paints itself +/// [slot] widths along the reading direction per tab, unclipped. +class FloatingTabHighlight extends StatelessWidget { + const FloatingTabHighlight({ + super.key, + required this.motion, + required this.slot, + required this.size, + required this.color, + }); + + final FloatingTabMotion motion; + + /// The distance between neighbouring tabs' centres. + final double slot; + final double size; + final Color color; + + @override + Widget build(BuildContext context) { + final direction = Directionality.of(context) == TextDirection.rtl ? -1 : 1; + return IgnorePointer( + child: ExcludeSemantics( + child: AnimatedBuilder( + animation: motion.slide, + builder: (context, _) { + final width = size * motion.stretch; + return OverflowBox( + minWidth: 0, + minHeight: 0, + maxWidth: double.infinity, + maxHeight: double.infinity, + child: Transform.translate( + offset: Offset(direction * slot * motion.position, 0), + child: FloatingTabEntrance( + motion: motion, + index: motion.position.round(), + bounces: false, + child: SizedBox( + width: width, + height: size, + child: DecoratedBox( + decoration: ShapeDecoration( + color: color, + shape: const StadiumBorder(), + ), + ), + ), + ), + ), + ); + }, + ), + ), + ); + } +} diff --git a/app/lib/ui/motion/motion.dart b/app/lib/ui/motion/motion.dart index 07c36d93..1a2b4142 100644 --- a/app/lib/ui/motion/motion.dart +++ b/app/lib/ui/motion/motion.dart @@ -34,6 +34,19 @@ abstract final class Motion { /// The fraction of a tab's entrance spent fading in. static const double tabEntranceOpacityPortion = 0.6; + /// How long a tab bar's selection highlight takes to glide to a new tab. + static const Duration tabHighlightDuration = Duration(milliseconds: 250); + + /// The highlight's width, relative to its height, halfway through a move; + /// it is a circle again at rest. + static const double tabHighlightStretch = 1.25; + + /// The newly selected tab icon's brief bounce. + static const Duration tabBounceDuration = Duration(milliseconds: 180); + + /// The icon's scale at the top of its bounce. + static const double tabBounceScale = 1.08; + static const Curve curve = Curves.easeOutCubic; /// [duration], or zero under the system's reduce-motion setting. diff --git a/app/test/ui/adaptive/floating_bar_edge_gap_test.dart b/app/test/ui/adaptive/floating_bar_edge_gap_test.dart index d712d0c2..272dc19a 100644 --- a/app/test/ui/adaptive/floating_bar_edge_gap_test.dart +++ b/app/test/ui/adaptive/floating_bar_edge_gap_test.dart @@ -65,19 +65,24 @@ void main() { await tester.pumpAndSettle(); } - Rect circle(WidgetTester tester, int index) => tester.getRect( - find - .descendant( - of: find.byKey(tabKey(index)), - matching: find.byWidgetPredicate( - (widget) => - widget is DecoratedBox && - widget.decoration is ShapeDecoration && - (widget.decoration as ShapeDecoration).shape is CircleBorder, - ), - ) - .first, - ); + /// The bar's one selection highlight, at rest on tab [index]. + Rect circle(WidgetTester tester, int index) { + final rect = tester.getRect( + find.descendant( + of: find.byKey(FloatingDestinationBar.highlightKey), + matching: find.byType(DecoratedBox), + ), + ); + final icon = tester.getCenter( + find.descendant( + of: find.byKey(tabKey(index)), + matching: find.byIcon(icons[index]), + ), + ); + expect(rect.center.dx, moreOrLessEquals(icon.dx, epsilon: 0.5)); + expect(rect.center.dy, moreOrLessEquals(icon.dy, epsilon: 0.5)); + return rect; + } Rect pill(WidgetTester tester) => tester.getRect( find.descendant( @@ -169,17 +174,20 @@ void main() { ), ), ); - final entrance = find.descendant( - of: find.byType(FloatingDestinationBar), - matching: find.byWidgetPredicate( - (widget) => - widget is FadeTransition && widget.child is AnimatedBuilder, - ), - ); + Finder entranceOf(int index) => find + .descendant( + of: find.byKey(tabKey(index)), + matching: find.byWidgetPredicate( + (widget) => + widget is FadeTransition && widget.child is AnimatedBuilder, + ), + ) + .last; + final entrance = entranceOf(0); double firstOpacity() => - tester.widget(entrance.at(0)).opacity.value; + tester.widget(entranceOf(0)).opacity.value; double lastOpacity() => - tester.widget(entrance.at(2)).opacity.value; + tester.widget(entranceOf(2)).opacity.value; expect(firstOpacity(), 0); expect(lastOpacity(), 0); await tester.pump(const Duration(milliseconds: 130)); diff --git a/app/test/ui/adaptive/floating_tab_motion_test.dart b/app/test/ui/adaptive/floating_tab_motion_test.dart new file mode 100644 index 00000000..60578aaf --- /dev/null +++ b/app/test/ui/adaptive/floating_tab_motion_test.dart @@ -0,0 +1,287 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/shell/adaptive_shell.dart'; +import 'package:pipelines_app/shell/destination.dart'; +import 'package:pipelines_app/ui/adaptive/floating_destination_bar.dart'; + +/// The floating tab bar's motion: the tabs pop in only when the bar appears +/// or its set of tabs changes, and one selection highlight glides (and +/// stretches on the way) to a newly selected tab, whose icon bounces. +void main() { + const icons = [ + Icons.account_tree_outlined, + Icons.play_circle_outline, + Icons.chat_bubble_outline, + Icons.search, + ]; + + Key tabKey(int index) => ValueKey('tab-$index'); + + List items(int count) => [ + for (var index = 0; index < count; index += 1) + FloatingDestinationItem( + key: tabKey(index), + icon: Icon(icons[index]), + label: 'Tab $index', + ), + ]; + + void animate(WidgetTester tester, {required bool on}) { + tester.platformDispatcher.accessibilityFeaturesTestValue = + FakeAccessibilityFeatures(disableAnimations: !on); + addTearDown(() { + tester.platformDispatcher.accessibilityFeaturesTestValue = + const FakeAccessibilityFeatures(disableAnimations: true); + }); + tester.view.physicalSize = const Size(560, 900); + tester.view.devicePixelRatio = 1; + addTearDown(tester.view.reset); + } + + /// A bar of [count] tabs whose tap selects. + Future pumpBar( + WidgetTester tester, { + required bool cupertino, + int count = 3, + }) async { + var selected = 0; + final body = StatefulBuilder( + builder: (context, setState) { + return Align( + alignment: Alignment.bottomCenter, + child: FloatingDestinationBar( + cupertino: cupertino, + currentIndex: selected, + onTap: (index) => setState(() => selected = index), + items: items(count), + ), + ); + }, + ); + await tester.pumpWidget( + cupertino + ? CupertinoApp(home: CupertinoPageScaffold(child: body)) + : MaterialApp(home: Scaffold(body: body)), + ); + } + + /// The opacity of [tab]'s entrance fade. + double opacityOf(WidgetTester tester, Finder tab) => tester + .widget( + find + .descendant( + of: tab, + matching: find.byWidgetPredicate( + (widget) => + widget is FadeTransition && widget.child is AnimatedBuilder, + ), + ) + .last, + ) + .opacity + .value; + + double iconWidth(WidgetTester tester, Finder tab, IconData icon) => tester + .getRect(find.descendant(of: tab, matching: find.byIcon(icon))) + .width; + + Rect highlight(WidgetTester tester) => tester.getRect( + find.descendant( + of: find.byKey(FloatingDestinationBar.highlightKey), + matching: find.byType(DecoratedBox), + ), + ); + + Offset iconCentre(WidgetTester tester, int index) => tester.getCenter( + find.descendant( + of: find.byKey(tabKey(index)), + matching: find.byIcon(icons[index]), + ), + ); + + for (final cupertino in [false, true]) { + final host = cupertino ? 'Cupertino' : 'Material'; + final iconSize = cupertino + ? FloatingDestinationBar.cupertinoIconSize + : FloatingDestinationBar.materialIconSize; + final size = cupertino + ? FloatingDestinationBar.cupertinoHighlightSize + : FloatingDestinationBar.materialHighlightSize; + + testWidgets('$host: the entrance does not replay when the selection ' + 'changes, and plays again for a new set of tabs', (tester) async { + animate(tester, on: true); + await pumpBar(tester, cupertino: cupertino); + expect(opacityOf(tester, find.byKey(tabKey(0))), 0); + await tester.pumpAndSettle(); + for (final target in [1, 2, 0]) { + await tester.tap(find.byKey(tabKey(target))); + for (var frame = 0; frame < 12; frame += 1) { + await tester.pump(const Duration(milliseconds: 25)); + for (var index = 0; index < 3; index += 1) { + final tab = find.byKey(tabKey(index)); + expect(opacityOf(tester, tab), 1, reason: 'tab $index faded'); + // Only the bounce may grow an icon; a replayed pop shrinks it. + expect( + iconWidth(tester, tab, icons[index]), + greaterThanOrEqualTo(iconSize - 0.01), + reason: 'tab $index popped again', + ); + } + } + } + }); + + testWidgets('$host: a new set of tabs pops in again', (tester) async { + animate(tester, on: true); + var count = 3; + late StateSetter update; + Widget build() => StatefulBuilder( + builder: (context, setState) { + update = setState; + return Align( + alignment: Alignment.bottomCenter, + child: FloatingDestinationBar( + cupertino: cupertino, + currentIndex: 0, + onTap: (_) {}, + items: items(count), + ), + ); + }, + ); + await tester.pumpWidget( + cupertino + ? CupertinoApp(home: CupertinoPageScaffold(child: build())) + : MaterialApp(home: Scaffold(body: build())), + ); + await tester.pumpAndSettle(); + expect(opacityOf(tester, find.byKey(tabKey(2))), 1); + update(() => count = 4); + await tester.pump(); + expect(opacityOf(tester, find.byKey(tabKey(3))), 0); + expect(opacityOf(tester, find.byKey(tabKey(2))), 0); + await tester.pumpAndSettle(); + expect(opacityOf(tester, find.byKey(tabKey(3))), 1); + }); + + testWidgets('$host: the highlight rests on the selected tab as the old ' + 'circle did, glides and stretches between tabs, and the new icon ' + 'bounces', (tester) async { + animate(tester, on: true); + await pumpBar(tester, cupertino: cupertino); + await tester.pumpAndSettle(); + expect( + highlight(tester), + rectMoreOrLessEquals( + Rect.fromCenter( + center: iconCentre(tester, 0), + width: size, + height: size, + ), + epsilon: 0.01, + ), + ); + expect(find.byKey(FloatingDestinationBar.highlightKey), findsOneWidget); + + await tester.tap(find.byKey(tabKey(2))); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 60)); + final from = iconCentre(tester, 0).dx; + final to = iconCentre(tester, 2).dx; + final moving = highlight(tester); + expect(moving.center.dx, greaterThan(from + 1)); + expect(moving.center.dx, lessThan(to - 1)); + expect(moving.height, moreOrLessEquals(size)); + expect(moving.width, greaterThan(size * 1.1)); + expect(moving.width, lessThanOrEqualTo(size * 1.25 + 0.01)); + expect( + iconWidth(tester, find.byKey(tabKey(2)), icons[2]), + greaterThan(iconSize * 1.02), + ); + + await tester.pumpAndSettle(); + expect( + highlight(tester), + rectMoreOrLessEquals( + Rect.fromCenter( + center: iconCentre(tester, 2), + width: size, + height: size, + ), + epsilon: 0.01, + ), + ); + expect( + iconWidth(tester, find.byKey(tabKey(2)), icons[2]), + moreOrLessEquals(iconSize), + ); + }); + + testWidgets('$host: under reduced motion the highlight jumps and the ' + 'icons neither pop nor bounce', (tester) async { + animate(tester, on: false); + await pumpBar(tester, cupertino: cupertino); + await tester.pump(); + expect(opacityOf(tester, find.byKey(tabKey(1))), 1); + await tester.tap(find.byKey(tabKey(2))); + await tester.pump(); + expect( + highlight(tester), + rectMoreOrLessEquals( + Rect.fromCenter( + center: iconCentre(tester, 2), + width: size, + height: size, + ), + epsilon: 0.01, + ), + ); + expect( + iconWidth(tester, find.byKey(tabKey(2)), icons[2]), + moreOrLessEquals(iconSize), + ); + }); + + testWidgets('$host: switching the shell tabs never replays the main ' + "bar's entrance", (tester) async { + animate(tester, on: true); + var destination = AppDestination.runs; + final shell = StatefulBuilder( + builder: (context, setState) => AdaptiveShell( + cupertino: cupertino, + destination: destination, + onDestinationSelected: (value) => setState(() => destination = value), + ), + ); + await tester.pumpWidget( + cupertino ? CupertinoApp(home: shell) : MaterialApp(home: shell), + ); + await tester.pumpAndSettle(); + for (final next in [ + AppDestination.pipelines, + AppDestination.chat, + AppDestination.runs, + ]) { + await tester.tap( + find.byKey(ValueKey('shell.destination.${next.name}')), + ); + for (var frame = 0; frame < 12; frame += 1) { + await tester.pump(const Duration(milliseconds: 25)); + for (final tab in shellTabDestinations) { + expect( + opacityOf( + tester, + find.byKey(ValueKey('shell.destination.${tab.name}')), + ), + 1, + reason: '${tab.name} faded switching to ${next.name}', + ); + } + } + await tester.pumpAndSettle(); + } + }); + } +}