From 9d37db5939418f22d0db3fb9835f711516618598 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 22 Nov 2026 18:19:22 +0000 Subject: [PATCH] Measure the running composer border once per size The highlight's outline was rebuilt and measured (computeMetrics) on every animation frame of a running turn, the largest app cost while a reply streams (about 600 ms of CPU over 15 s at 4K). The painter now keeps the measured outline for its size and only extracts the moving pieces per frame. Co-Authored-By: Claude Opus 5.5 --- .../conversation/composer_running_arc.dart | 40 ++++++++++++++----- .../conversation/composer_running_border.dart | 15 +++++-- .../composer_running_arc_test.dart | 29 ++++++++++++++ 3 files changed, 70 insertions(+), 14 deletions(-) diff --git a/app/lib/features/chat/conversation/composer_running_arc.dart b/app/lib/features/chat/conversation/composer_running_arc.dart index 79dde2b0..d8697ec7 100644 --- a/app/lib/features/chat/conversation/composer_running_arc.dart +++ b/app/lib/features/chat/conversation/composer_running_arc.dart @@ -137,17 +137,35 @@ List runningHighlightStrokes({ required double progress, required Color primary, required Color tertiary, -}) { - final metrics = outline.computeMetrics().toList(); - final length = metrics.fold(0, (sum, m) => sum + m.length); - final segments = runningHighlightSegments( - progress: progress, - length: length, - primary: primary, - tertiary: tertiary, - ); - return [ - for (final segment in segments) +}) => RunningOutline( + outline, +).strokes(progress: progress, primary: primary, tertiary: tertiary); + +/// An outline measured once: its contours and total length. Measuring a +/// path is the expensive part of drawing the highlight, and the outline only +/// changes with the pill's size and shape, so a painter keeps one of these +/// across animation frames and only extracts the moving pieces per frame. +class RunningOutline { + RunningOutline(Path outline) + : metrics = outline.computeMetrics().toList(growable: false) { + length = metrics.fold(0, (sum, m) => sum + m.length); + } + + final List metrics; + late final double length; + + /// The strokes of the highlight at [progress] along this outline. + List strokes({ + required double progress, + required Color primary, + required Color tertiary, + }) => [ + for (final segment in runningHighlightSegments( + progress: progress, + length: length, + primary: primary, + tertiary: tertiary, + )) RunningBorderStroke( path: runningArcPath(metrics, segment.start, segment.end), color: segment.color, diff --git a/app/lib/features/chat/conversation/composer_running_border.dart b/app/lib/features/chat/conversation/composer_running_border.dart index e64c2a87..44f759cc 100644 --- a/app/lib/features/chat/conversation/composer_running_border.dart +++ b/app/lib/features/chat/conversation/composer_running_border.dart @@ -112,19 +112,28 @@ class _RunningBorderPainter extends CustomPainter { /// The lap's progress, or null for the static reduced-motion border. final Animation? lap; + Size? _outlineSize; + RunningOutline? _outline; + @override void paint(Canvas canvas, Size size) { final progress = lap?.value; // Reduced motion: no highlight; the normal static border shows alone. if (progress == null || size.isEmpty) return; - final outline = shape.getOuterPath((Offset.zero & size).deflate(width / 2)); + // The outline is measured once per size (the painter lives across the + // lap's frames; a new shape, width or colour makes a new painter). + if (_outline == null || _outlineSize != size) { + _outlineSize = size; + _outline = RunningOutline( + shape.getOuterPath((Offset.zero & size).deflate(width / 2)), + ); + } final line = Paint() ..style = PaintingStyle.stroke ..strokeWidth = width; // The highlight is laid along the outline by arc length, so its speed is // even around corners and straight edges alike. Only its pieces are drawn. - for (final stroke in runningHighlightStrokes( - outline: outline, + for (final stroke in _outline!.strokes( progress: progress, primary: primary, tertiary: tertiary, diff --git a/app/test/features/chat/conversation/composer_running_arc_test.dart b/app/test/features/chat/conversation/composer_running_arc_test.dart index 0f29e0db..b6fa3cd7 100644 --- a/app/test/features/chat/conversation/composer_running_arc_test.dart +++ b/app/test/features/chat/conversation/composer_running_arc_test.dart @@ -208,4 +208,33 @@ void main() { // Curve metrics are approximations; a fraction of a pixel is exact enough. expect(_length(pieceMetrics), closeTo(20, .5)); }); + + test('a measured outline draws the same strokes as measuring each time', () { + final outline = Path() + ..addRRect( + RRect.fromRectAndRadius( + const Rect.fromLTWH(0, 0, 300, 56), + const Radius.circular(28), + ), + ); + final measured = RunningOutline(outline); + for (final progress in [0.0, 0.3, 0.97]) { + final once = runningHighlightStrokes( + outline: outline, + progress: progress, + primary: const Color(0xFF0000FF), + tertiary: const Color(0xFFFF0000), + ); + final kept = measured.strokes( + progress: progress, + primary: const Color(0xFF0000FF), + tertiary: const Color(0xFFFF0000), + ); + expect(kept.length, once.length); + for (var i = 0; i < kept.length; i++) { + expect(kept[i].color, once[i].color); + expect(kept[i].path.getBounds(), once[i].path.getBounds()); + } + } + }); }