Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

[mob][photos] Modularize image zoom viewer

ashil-pilotd6fd524a3811
diff --git a/mobile/apps/photos/lib/ui/viewer/file/image_zoom_geometry.dart b/mobile/apps/photos/lib/ui/viewer/file/image_zoom_geometry.dart
new file mode 100644
index 0000000000..6e20531865
--- /dev/null
+++ b/mobile/apps/photos/lib/ui/viewer/file/image_zoom_geometry.dart
@@ -0,0 +1,227 @@
+import "dart:math" as math;
+
+import "package:flutter/widgets.dart";
+
+const double _imageZoomGeometryEpsilon = 0.001;
+
+@immutable
+final class ImageZoomGeometry {
+ final Size viewportSize;
+ final Size fittedImageSize;
+ final double initialScale;
+ final double coverScale;
+ final double originalScale;
+ final double maxScale;
+
+ const ImageZoomGeometry._({
+ required this.viewportSize,
+ required this.fittedImageSize,
+ required this.initialScale,
+ required this.coverScale,
+ required this.originalScale,
+ required this.maxScale,
+ });
+
+ static ImageZoomGeometry? calculate({
+ required Size viewportSize,
+ required Size imageSize,
+ required BoxFit initialFit,
+ required double maxScaleOverCover,
+ }) {
+ assert(initialFit == BoxFit.contain || initialFit == BoxFit.cover);
+ assert(maxScaleOverCover > 0);
+
+ final fittedImageSize = applyBoxFit(
+ BoxFit.contain,
+ imageSize,
+ viewportSize,
+ ).destination;
+ if (fittedImageSize.isEmpty) return null;
+
+ final coverScale = math.max(
+ viewportSize.width / fittedImageSize.width,
+ viewportSize.height / fittedImageSize.height,
+ );
+ final initialScale = initialFit == BoxFit.cover ? coverScale : 1.0;
+ final originalScale = math.max(
+ imageSize.width / fittedImageSize.width,
+ imageSize.height / fittedImageSize.height,
+ );
+ final maxScale = maxScaleOverCover.isInfinite
+ ? double.infinity
+ : math.max(initialScale, coverScale * maxScaleOverCover);
+
+ return ImageZoomGeometry._(
+ viewportSize: viewportSize,
+ fittedImageSize: fittedImageSize,
+ initialScale: initialScale,
+ coverScale: coverScale,
+ originalScale: originalScale,
+ maxScale: maxScale,
+ );
+ }
+
+ Rect get fittedImageRect =>
+ Alignment.center.inscribe(fittedImageSize, Offset.zero & viewportSize);
+
+ Offset get viewportCenter => viewportSize.center(Offset.zero);
+
+ bool coordinatesMatch(ImageZoomGeometry other) =>
+ _sizesNearlyEqual(viewportSize, other.viewportSize) &&
+ _sizesNearlyEqual(fittedImageSize, other.fittedImageSize) &&
+ (initialScale - other.initialScale).abs() <= _imageZoomGeometryEpsilon;
+
+ bool hasSameConfiguration(ImageZoomGeometry other) =>
+ viewportSize == other.viewportSize &&
+ fittedImageSize == other.fittedImageSize &&
+ initialScale == other.initialScale &&
+ coverScale == other.coverScale &&
+ originalScale == other.originalScale &&
+ maxScale == other.maxScale;
+
+ double clampScale(double scale) => scale.clamp(initialScale, maxScale);
+
+ Matrix4 matrixForScaleAndOffset(double scale, Offset offset) =>
+ matrixForScaleAndTranslation(
+ scale,
+ offset - viewportCenter * (scale - 1.0),
+ );
+
+ Matrix4 matrixForScaleAndTranslation(double scale, Offset translation) =>
+ Matrix4.identity()
+ ..translateByDouble(translation.dx, translation.dy, 0, 1)
+ ..scaleByDouble(scale, scale, 1, 1);
+
+ Matrix4 matrixForFocalPoint(
+ Matrix4 currentMatrix,
+ Offset viewportPoint,
+ double targetScale,
+ ) {
+ final sceneFocus = scenePoint(currentMatrix, viewportPoint);
+ return sanitize(
+ matrixForScaleAndTranslation(
+ targetScale,
+ viewportCenter - sceneFocus * targetScale,
+ ),
+ );
+ }
+
+ Offset scenePoint(Matrix4 matrix, Offset viewportPoint) {
+ final inverse = Matrix4.tryInvert(matrix);
+ return inverse == null
+ ? viewportPoint
+ : MatrixUtils.transformPoint(inverse, viewportPoint);
+ }
+
+ ImageZoomMatrixState describe(Matrix4 matrix) {
+ final absoluteScale = matrix.getMaxScaleOnAxis();
+ final relativeScale = absoluteScale / initialScale;
+ final translation = Offset(matrix.storage[12], matrix.storage[13]);
+ final semanticOffset = translation + viewportCenter * (absoluteScale - 1.0);
+ final isInitial =
+ (relativeScale - 1.0).abs() <= _imageZoomGeometryEpsilon &&
+ semanticOffset.distanceSquared <=
+ _imageZoomGeometryEpsilon * _imageZoomGeometryEpsilon;
+ return ImageZoomMatrixState(
+ absoluteScale: absoluteScale,
+ relativeScale: relativeScale,
+ semanticOffset: semanticOffset,
+ isInitial: isInitial,
+ );
+ }
+
+ Matrix4 sanitize(Matrix4 matrix) {
+ var scale = matrix.getMaxScaleOnAxis();
+ if (!scale.isFinite || scale <= 0) scale = initialScale;
+ scale = clampScale(scale);
+
+ var translation = Offset(matrix.storage[12], matrix.storage[13]);
+ if (!translation.dx.isFinite || !translation.dy.isFinite) {
+ translation = -(viewportCenter * (scale - 1.0));
+ }
+ var offset = translation + viewportCenter * (scale - 1.0);
+ final maxOffsetX = math.max(
+ 0.0,
+ (fittedImageSize.width * scale - viewportSize.width) / 2,
+ );
+ final maxOffsetY = math.max(
+ 0.0,
+ (fittedImageSize.height * scale - viewportSize.height) / 2,
+ );
+ offset = Offset(
+ offset.dx.clamp(-maxOffsetX, maxOffsetX),
+ offset.dy.clamp(-maxOffsetY, maxOffsetY),
+ );
+ translation = offset - viewportCenter * (scale - 1.0);
+ return matrixForScaleAndTranslation(scale, translation);
+ }
+}
+
+@immutable
+final class ImageZoomMatrixState {
+ final double absoluteScale;
+ final double relativeScale;
+ final Offset semanticOffset;
+ final bool isInitial;
+
+ const ImageZoomMatrixState({
+ required this.absoluteScale,
+ required this.relativeScale,
+ required this.semanticOffset,
+ required this.isInitial,
+ });
+}
+
+@immutable
+final class ImageZoomRebase {
+ final bool wasInitial;
+ final double relativeScale;
+ final Offset normalizedFocus;
+
+ const ImageZoomRebase._({
+ required this.wasInitial,
+ required this.relativeScale,
+ required this.normalizedFocus,
+ });
+
+ static ImageZoomRebase capture(ImageZoomGeometry geometry, Matrix4 matrix) {
+ final state = geometry.describe(matrix);
+ final sceneCenter = geometry.scenePoint(matrix, geometry.viewportCenter);
+ final imageRect = geometry.fittedImageRect;
+ return ImageZoomRebase._(
+ wasInitial: state.isInitial,
+ relativeScale: state.relativeScale,
+ normalizedFocus: Offset(
+ (sceneCenter.dx - imageRect.left) / imageRect.width,
+ (sceneCenter.dy - imageRect.top) / imageRect.height,
+ ),
+ );
+ }
+
+ Matrix4 resolve(ImageZoomGeometry geometry) {
+ if (wasInitial) {
+ return geometry.matrixForScaleAndOffset(
+ geometry.initialScale,
+ Offset.zero,
+ );
+ }
+ final targetScale = geometry.clampScale(
+ geometry.initialScale * relativeScale,
+ );
+ final imageRect = geometry.fittedImageRect;
+ final sceneFocus = Offset(
+ imageRect.left + normalizedFocus.dx * imageRect.width,
+ imageRect.top + normalizedFocus.dy * imageRect.height,
+ );
+ return geometry.sanitize(
+ geometry.matrixForScaleAndTranslation(
+ targetScale,
+ geometry.viewportCenter - sceneFocus * targetScale,
+ ),
+ );
+ }
+}
+
+bool _sizesNearlyEqual(Size first, Size second) =>
+ (first.width - second.width).abs() <= _imageZoomGeometryEpsilon &&
+ (first.height - second.height).abs() <= _imageZoomGeometryEpsilon;
diff --git a/mobile/apps/photos/lib/ui/viewer/file/image_zoom_stage_policy.dart b/mobile/apps/photos/lib/ui/viewer/file/image_zoom_stage_policy.dart
new file mode 100644
index 0000000000..fb758cdddd
--- /dev/null
+++ b/mobile/apps/photos/lib/ui/viewer/file/image_zoom_stage_policy.dart
@@ -0,0 +1,52 @@
+import "package:flutter/foundation.dart";
+
+const double _kZoomStageEpsilon = 0.001;
+
+enum ImageZoomStage { initial, covering, originalSize, gesture }
+
+@immutable
+final class ImageZoomStagePolicy {
+ final double initialScale;
+ final double coverScale;
+ final double originalScale;
+ final double maxScale;
+
+ const ImageZoomStagePolicy({
+ required this.initialScale,
+ required this.coverScale,
+ required this.originalScale,
+ required this.maxScale,
+ });
+
+ double targetScale(ImageZoomStage stage) {
+ final scale = switch (stage) {
+ ImageZoomStage.initial || ImageZoomStage.gesture => initialScale,
+ ImageZoomStage.covering => coverScale,
+ ImageZoomStage.originalSize => originalScale,
+ };
+ return scale.clamp(initialScale, maxScale);
+ }
+
+ ImageZoomStage? nextDoubleTapStage({
+ required ImageZoomStage currentStage,
+ required double currentScale,
+ }) {
+ if (currentStage == ImageZoomStage.gesture) {
+ return ImageZoomStage.initial;
+ }
+
+ var candidate = currentStage;
+ for (var i = 0; i < 3; i++) {
+ candidate = switch (candidate) {
+ ImageZoomStage.initial => ImageZoomStage.covering,
+ ImageZoomStage.covering => ImageZoomStage.originalSize,
+ ImageZoomStage.originalSize ||
+ ImageZoomStage.gesture => ImageZoomStage.initial,
+ };
+ if ((targetScale(candidate) - currentScale).abs() > _kZoomStageEpsilon) {
+ return candidate;
+ }
+ }
+ return null;
+ }
+}
diff --git a/mobile/apps/photos/lib/ui/viewer/file/image_zoom_viewer.dart b/mobile/apps/photos/lib/ui/viewer/file/image_zoom_viewer.dart
index 7f35826994..eaabc8b156 100644
--- a/mobile/apps/photos/lib/ui/viewer/file/image_zoom_viewer.dart
+++ b/mobile/apps/photos/lib/ui/viewer/file/image_zoom_viewer.dart
@@ -1,11 +1,13 @@
import "dart:async";
-import "dart:math" as math;
import "package:flutter/material.dart";
+import "package:photos/ui/viewer/file/image_zoom_geometry.dart";
+import "package:photos/ui/viewer/file/image_zoom_stage_policy.dart";
-const double _kZoomEpsilon = 0.001;
+export "package:photos/ui/viewer/file/image_zoom_stage_policy.dart"
+ show ImageZoomStage;
-enum ImageZoomStage { initial, covering, originalSize, gesture }
+const double _kZoomEpsilon = 0.001;
typedef ImageZoomLoadingBuilder =
Widget Function(BuildContext context, ImageChunkEvent? progress);
@@ -134,12 +136,7 @@ class _ImageZoomViewerState extends State<ImageZoomViewer>
StackTrace? _imageErrorStack;
bool _hasImageFrame = false;
- Size? _viewportSize;
- Size? _fittedImageSize;
- double _initialScale = 1.0;
- double _coverScale = 1.0;
- double _originalScale = 1.0;
- double _maxScale = double.infinity;
+ ImageZoomGeometry? _geometry;
final Map<int, Offset> _pointerPositions = <int, Offset>{};
List<int> _manualPinchPointers = const <int>[];
@@ -155,13 +152,7 @@ class _ImageZoomViewerState extends State<ImageZoomViewer>
Offset? _doubleTapPosition;
int _geometryGeneration = 0;
- bool get _hasGeometry =>
- _viewportSize != null &&
- _fittedImageSize != null &&
- _viewportSize!.width > 0 &&
- _viewportSize!.height > 0 &&
- _fittedImageSize!.width > 0 &&
- _fittedImageSize!.height > 0;
+ bool get _hasGeometry => _geometry != null;
@override
void initState() {
@@ -324,70 +315,33 @@ class _ImageZoomViewerState extends State<ImageZoomViewer>
}
void _updateGeometry(Size viewportSize, Size imageSize) {
- final fittedSize = applyBoxFit(
- BoxFit.contain,
- imageSize,
- viewportSize,
- ).destination;
- if (fittedSize.isEmpty) return;
-
- final previousViewport = _viewportSize;
- final previousFittedSize = _fittedImageSize;
- final previousInitialScale = _initialScale;
+ final nextGeometry = ImageZoomGeometry.calculate(
+ viewportSize: viewportSize,
+ imageSize: imageSize,
+ initialFit: widget.initialFit,
+ maxScaleOverCover: widget.maxScaleOverCover,
+ );
+ if (nextGeometry == null) return;
+
+ final previousGeometry = _geometry;
final previousMatrix = _transformationController.value.clone();
- final hadGeometry = _hasGeometry;
+ if (previousGeometry?.hasSameConfiguration(nextGeometry) ?? false) return;
- final coverScale = math.max(
- viewportSize.width / fittedSize.width,
- viewportSize.height / fittedSize.height,
- );
- final initialScale = widget.initialFit == BoxFit.cover ? coverScale : 1.0;
- final originalScale = math.max(
- imageSize.width / fittedSize.width,
- imageSize.height / fittedSize.height,
- );
- final maxScale = widget.maxScaleOverCover.isInfinite
- ? double.infinity
- : math.max(initialScale, coverScale * widget.maxScaleOverCover);
-
- final geometryUnchanged =
- viewportSize == previousViewport &&
- fittedSize == previousFittedSize &&
- initialScale == previousInitialScale &&
- coverScale == _coverScale &&
- originalScale == _originalScale &&
- maxScale == _maxScale;
- if (geometryUnchanged) return;
-
- final coordinateGeometryChanged =
- hadGeometry &&
- previousViewport != null &&
- previousFittedSize != null &&
- (!_sizesNearlyEqual(viewportSize, previousViewport) ||
- !_sizesNearlyEqual(fittedSize, previousFittedSize) ||
- (initialScale - previousInitialScale).abs() > _kZoomEpsilon);
- if (coordinateGeometryChanged && _programmaticAnimationActive) {
+ if (previousGeometry != null &&
+ !nextGeometry.coordinatesMatch(previousGeometry) &&
+ _programmaticAnimationActive) {
_stopProgrammaticAnimationForGeometryChange();
}
- _viewportSize = viewportSize;
- _fittedImageSize = fittedSize;
- _initialScale = initialScale;
- _coverScale = coverScale;
- _originalScale = originalScale;
- _maxScale = maxScale;
- _transformationController.configure(
- viewportSize: viewportSize,
- fittedImageSize: fittedSize,
- minScale: initialScale,
- maxScale: maxScale,
- );
+ _geometry = nextGeometry;
+ _transformationController.configure(nextGeometry);
- if (!hadGeometry ||
- previousViewport == null ||
- previousFittedSize == null) {
+ if (previousGeometry == null) {
_transformationController.setOwnerValue(
- _matrixForScaleAndOffset(initialScale, Offset.zero),
+ nextGeometry.matrixForScaleAndOffset(
+ nextGeometry.initialScale,
+ Offset.zero,
+ ),
);
_stage = ImageZoomStage.initial;
_publishTransform();
@@ -395,94 +349,17 @@ class _ImageZoomViewerState extends State<ImageZoomViewer>
}
final generation = ++_geometryGeneration;
- final wasInitial = _isMatrixAtInitial(
- previousMatrix,
- viewport: previousViewport,
- initialScale: previousInitialScale,
- );
- final previousScale = previousMatrix.getMaxScaleOnAxis();
- final relativeScale = previousInitialScale > 0
- ? previousScale / previousInitialScale
- : 1.0;
- final previousSceneCenter = _scenePoint(
- previousMatrix,
- previousViewport.center(Offset.zero),
- );
- final previousRect = Alignment.center.inscribe(
- previousFittedSize,
- Offset.zero & previousViewport,
- );
- final normalizedFocus = Offset(
- (previousSceneCenter.dx - previousRect.left) / previousRect.width,
- (previousSceneCenter.dy - previousRect.top) / previousRect.height,
- );
+ final rebase = ImageZoomRebase.capture(previousGeometry, previousMatrix);
WidgetsBinding.instance.addPostFrameCallback((_) {
if (!mounted || generation != _geometryGeneration) return;
- if (wasInitial) {
- _transformationController.setOwnerValue(
- _matrixForScaleAndOffset(_initialScale, Offset.zero),
- );
- _stage = ImageZoomStage.initial;
- } else {
- final targetScale = (_initialScale * relativeScale).clamp(
- _initialScale,
- _maxScale,
- );
- final newRect = Alignment.center.inscribe(
- _fittedImageSize!,
- Offset.zero & _viewportSize!,
- );
- final newSceneFocus = Offset(
- newRect.left + normalizedFocus.dx * newRect.width,
- newRect.top + normalizedFocus.dy * newRect.height,
- );
- final center = _viewportSize!.center(Offset.zero);
- final translation = center - newSceneFocus * targetScale;
- _transformationController.setOwnerValue(
- _matrixForScaleAndTranslation(targetScale, translation),
- );
- _stage = ImageZoomStage.gesture;
- }
+ _transformationController.setOwnerValue(rebase.resolve(_geometry!));
+ _stage = rebase.wasInitial
+ ? ImageZoomStage.initial
+ : ImageZoomStage.gesture;
_publishTransform();
});
}
- Matrix4 _matrixForScaleAndOffset(double scale, Offset offset) {
- final center = _viewportSize!.center(Offset.zero);
- return _matrixForScaleAndTranslation(
- scale,
- offset - (center * (scale - 1.0)),
- );
- }
-
- Matrix4 _matrixForScaleAndTranslation(double scale, Offset translation) =>
- Matrix4.identity()
- ..translateByDouble(translation.dx, translation.dy, 0, 1)
- ..scaleByDouble(scale, scale, 1, 1);
-
- Offset _scenePoint(Matrix4 matrix, Offset viewportPoint) {
- final inverse = Matrix4.tryInvert(matrix);
- return inverse == null
- ? viewportPoint
- : MatrixUtils.transformPoint(inverse, viewportPoint);
- }
-
- bool _isMatrixAtInitial(
- Matrix4 matrix, {
- Size? viewport,
- double? initialScale,
- }) {
- final size = viewport ?? _viewportSize;
- final scale = initialScale ?? _initialScale;
- if (size == null) return true;
- final actualScale = matrix.getMaxScaleOnAxis();
- final center = size.center(Offset.zero);
- final translation = Offset(matrix.storage[12], matrix.storage[13]);
- final offset = translation + center * (actualScale - 1.0);
- return (actualScale / scale - 1.0).abs() <= _kZoomEpsilon &&
- offset.distanceSquared <= _kZoomEpsilon * _kZoomEpsilon;
- }
-
void _onTransformationChanged() {
if (!_hasGeometry) return;
_publishTransform();
@@ -494,7 +371,7 @@ class _ImageZoomViewerState extends State<ImageZoomViewer>
widget.gesturesEnabled &&
!_manualPinchActive &&
(_interactiveStartScale != null ||
- !_isMatrixAtInitial(_transformationController.value));
+ !_geometry!.describe(_transformationController.value).isInitial);
if (_interactiveViewerEnabled != shouldEnable && mounted) {
setState(() => _interactiveViewerEnabled = shouldEnable);
}
@@ -502,22 +379,17 @@ class _ImageZoomViewerState extends State<ImageZoomViewer>
void _publishTransform() {
if (!_hasGeometry) return;
- final matrix = _transformationController.value;
- final scale = matrix.getMaxScaleOnAxis();
- final relativeScale = scale / _initialScale;
- final center = _viewportSize!.center(Offset.zero);
- final translation = Offset(matrix.storage[12], matrix.storage[13]);
- final offset = translation + center * (scale - 1.0);
- final isInitial =
- (relativeScale - 1.0).abs() <= _kZoomEpsilon &&
- offset.distanceSquared <= _kZoomEpsilon * _kZoomEpsilon;
- if (isInitial) {
+ final matrixState = _geometry!.describe(_transformationController.value);
+ if (matrixState.isInitial) {
_stage = ImageZoomStage.initial;
}
_controller._update(
- isInitial
+ matrixState.isInitial
? ImageZoomTransform.identity
- : ImageZoomTransform(scale: relativeScale, offset: offset),
+ : ImageZoomTransform(
+ scale: matrixState.relativeScale,
+ offset: matrixState.semanticOffset,
+ ),
_stage,
);
_updateInteractionLock();
@@ -547,7 +419,7 @@ class _ImageZoomViewerState extends State<ImageZoomViewer>
_beginManualPinch();
} else if (_pointerPositions.length >= 2 &&
!_manualPinchActive &&
- _isMatrixAtInitial(_transformationController.value)) {
+ _geometry!.describe(_transformationController.value).isInitial) {
_beginManualPinch();
}
_updateInteractionLock();
@@ -590,7 +462,10 @@ class _ImageZoomViewerState extends State<ImageZoomViewer>
final focalPoint = (first + second) / 2;
_manualPinchStartDistance = (first - second).distance;
_manualPinchStartMatrix = _transformationController.value.clone();
- _manualPinchScenePoint = _scenePoint(_manualPinchStartMatrix!, focalPoint);
+ _manualPinchScenePoint = _geometry!.scenePoint(
+ _manualPinchStartMatrix!,
+ focalPoint,
+ );
if (mounted) setState(() {});
}
@@ -607,12 +482,13 @@ class _ImageZoomViewerState extends State<ImageZoomViewer>
final distance = (first - second).distance;
final focalPoint = (first + second) / 2;
final startScale = _manualPinchStartMatrix!.getMaxScaleOnAxis();
- final targetScale = (startScale * distance / _manualPinchStartDistance)
- .clamp(_initialScale, _maxScale);
+ final targetScale = _geometry!.clampScale(
+ startScale * distance / _manualPinchStartDistance,
+ );
final translation = focalPoint - _manualPinchScenePoint! * targetScale;
_stage = ImageZoomStage.gesture;
_transformationController.setOwnerValue(
- _matrixForScaleAndTranslation(targetScale, translation),
+ _geometry!.matrixForScaleAndTranslation(targetScale, translation),
);
}
@@ -621,10 +497,13 @@ class _ImageZoomViewerState extends State<ImageZoomViewer>
_manualPinchPointers = const <int>[];
_manualPinchStartMatrix = null;
_manualPinchScenePoint = null;
- if (_isMatrixAtInitial(_transformationController.value)) {
+ if (_geometry!.describe(_transformationController.value).isInitial) {
_stage = ImageZoomStage.initial;
_transformationController.setOwnerValue(
- _matrixForScaleAndOffset(_initialScale, Offset.zero),
+ _geometry!.matrixForScaleAndOffset(
+ _geometry!.initialScale,
+ Offset.zero,
+ ),
);
}
_publishTransform();
@@ -666,51 +545,30 @@ class _ImageZoomViewerState extends State<ImageZoomViewer>
_doubleTapPosition = null;
if (!_hasGeometry || tapPosition == null) return;
+ final geometry = _geometry!;
final currentScale = _transformationController.value.getMaxScaleOnAxis();
- final nextStage = _nextDistinctStage(currentScale);
+ final stagePolicy = ImageZoomStagePolicy(
+ initialScale: geometry.initialScale,
+ coverScale: geometry.coverScale,
+ originalScale: geometry.originalScale,
+ maxScale: geometry.maxScale,
+ );
+ final nextStage = stagePolicy.nextDoubleTapStage(
+ currentStage: _stage,
+ currentScale: currentScale,
+ );
if (nextStage == null) return;
- final targetScale = _scaleForStage(nextStage);
- late final Matrix4 target;
- if (nextStage == ImageZoomStage.initial) {
- target = _matrixForScaleAndOffset(_initialScale, Offset.zero);
- } else {
- final scenePoint = _transformationController.toScene(tapPosition);
- final center = _viewportSize!.center(Offset.zero);
- target = _matrixForScaleAndTranslation(
- targetScale,
- center - scenePoint * targetScale,
- );
- }
+ final targetScale = stagePolicy.targetScale(nextStage);
+ final target = nextStage == ImageZoomStage.initial
+ ? geometry.matrixForScaleAndOffset(geometry.initialScale, Offset.zero)
+ : geometry.matrixForFocalPoint(
+ _transformationController.value,
+ tapPosition,
+ targetScale,
+ );
unawaited(_animateTo(target, nextStage));
}
- ImageZoomStage? _nextDistinctStage(double currentScale) {
- if (_stage == ImageZoomStage.gesture) return ImageZoomStage.initial;
- var candidate = _stage;
- for (var i = 0; i < 3; i++) {
- candidate = switch (candidate) {
- ImageZoomStage.initial => ImageZoomStage.covering,
- ImageZoomStage.covering => ImageZoomStage.originalSize,
- ImageZoomStage.originalSize ||
- ImageZoomStage.gesture => ImageZoomStage.initial,
- };
- final targetScale = _scaleForStage(candidate);
- if ((targetScale - currentScale).abs() > _kZoomEpsilon) {
- return candidate;
- }
- }
- return null;
- }
-
- double _scaleForStage(ImageZoomStage stage) {
- final scale = switch (stage) {
- ImageZoomStage.initial || ImageZoomStage.gesture => _initialScale,
- ImageZoomStage.covering => _coverScale,
- ImageZoomStage.originalSize => _originalScale,
- };
- return scale.clamp(_initialScale, _maxScale);
- }
-
@override
Future<void> reset({required bool animated}) {
if (!_hasGeometry) {
@@ -718,7 +576,11 @@ class _ImageZoomViewerState extends State<ImageZoomViewer>
_controller._update(ImageZoomTransform.identity, _stage);
return Future<void>.value();
}
- final target = _matrixForScaleAndOffset(_initialScale, Offset.zero);
+ final geometry = _geometry!;
+ final target = geometry.matrixForScaleAndOffset(
+ geometry.initialScale,
+ Offset.zero,
+ );
if (!animated) {
_stopProgrammaticAnimation();
_stage = ImageZoomStage.initial;
@@ -817,11 +679,9 @@ class _ImageZoomViewerState extends State<ImageZoomViewer>
return const SizedBox.shrink();
}
_updateGeometry(viewportSize, _resolvedImageSize!);
- final fittedSize = applyBoxFit(
- BoxFit.contain,
- _resolvedImageSize!,
- viewportSize,
- ).destination;
+ final geometry = _geometry;
+ if (geometry == null) return const SizedBox.shrink();
+ final fittedSize = geometry.fittedImageSize;
Widget image = Image(
image: widget.imageProvider,
@@ -850,8 +710,8 @@ class _ImageZoomViewerState extends State<ImageZoomViewer>
key: ValueKey(_interactiveViewerGeneration),
transformationController: _transformationController,
alignment: null,
- minScale: _initialScale,
- maxScale: _maxScale,
+ minScale: geometry.initialScale,
+ maxScale: geometry.maxScale,
panEnabled: true,
scaleEnabled: true,
clipBehavior: Clip.hardEdge,
@@ -894,26 +754,11 @@ class _ImageZoomViewerState extends State<ImageZoomViewer>
}
class _BoundedTransformationController extends TransformationController {
- Size? _viewportSize;
- Size? _fittedImageSize;
- double _minScale = 1.0;
- double _maxScale = double.infinity;
+ ImageZoomGeometry? _geometry;
bool _ownerWrite = false;
bool _suppressInteractiveWrites = false;
- bool get _hasGeometry => _viewportSize != null && _fittedImageSize != null;
-
- void configure({
- required Size viewportSize,
- required Size fittedImageSize,
- required double minScale,
- required double maxScale,
- }) {
- _viewportSize = viewportSize;
- _fittedImageSize = fittedImageSize;
- _minScale = minScale;
- _maxScale = maxScale;
- }
+ void configure(ImageZoomGeometry geometry) => _geometry = geometry;
void suppressInteractiveWrites() {
_suppressInteractiveWrites = true;
@@ -937,37 +782,8 @@ class _BoundedTransformationController extends TransformationController {
super.value = sanitized;
}
- Matrix4 sanitize(Matrix4 matrix) {
- if (!_hasGeometry) return matrix.clone();
- var scale = matrix.getMaxScaleOnAxis();
- if (!scale.isFinite || scale <= 0) scale = _minScale;
- scale = scale.clamp(_minScale, _maxScale);
-
- final viewportSize = _viewportSize!;
- final fittedImageSize = _fittedImageSize!;
- final center = viewportSize.center(Offset.zero);
- var translation = Offset(matrix.storage[12], matrix.storage[13]);
- if (!translation.dx.isFinite || !translation.dy.isFinite) {
- translation = -(center * (scale - 1.0));
- }
- var offset = translation + center * (scale - 1.0);
- final maxOffsetX = math.max(
- 0.0,
- (fittedImageSize.width * scale - viewportSize.width) / 2,
- );
- final maxOffsetY = math.max(
- 0.0,
- (fittedImageSize.height * scale - viewportSize.height) / 2,
- );
- offset = Offset(
- offset.dx.clamp(-maxOffsetX, maxOffsetX),
- offset.dy.clamp(-maxOffsetY, maxOffsetY),
- );
- translation = offset - center * (scale - 1.0);
- return Matrix4.identity()
- ..translateByDouble(translation.dx, translation.dy, 0, 1)
- ..scaleByDouble(scale, scale, 1, 1);
- }
+ Matrix4 sanitize(Matrix4 matrix) =>
+ _geometry?.sanitize(matrix) ?? matrix.clone();
}
bool _matricesNearlyEqual(Matrix4 first, Matrix4 second) {
@@ -979,7 +795,3 @@ bool _matricesNearlyEqual(Matrix4 first, Matrix4 second) {
}
return true;
}
-
-bool _sizesNearlyEqual(Size first, Size second) =>
- (first.width - second.width).abs() <= _kZoomEpsilon &&
- (first.height - second.height).abs() <= _kZoomEpsilon;
diff --git a/mobile/apps/photos/test/ui/viewer/file/image_zoom_geometry_test.dart b/mobile/apps/photos/test/ui/viewer/file/image_zoom_geometry_test.dart
new file mode 100644
index 0000000000..144aad91f9
--- /dev/null
+++ b/mobile/apps/photos/test/ui/viewer/file/image_zoom_geometry_test.dart
@@ -0,0 +1,215 @@
+import "dart:math" as math;
+
+import "package:flutter/material.dart";
+import "package:flutter_test/flutter_test.dart";
+import "package:photos/ui/viewer/file/image_zoom_geometry.dart";
+
+void main() {
+ group("ImageZoomGeometry", () {
+ test("calculates contain, cover, original, and maximum scales", () {
+ final geometry = _geometry(
+ viewportSize: const Size(400, 300),
+ imageSize: const Size(1000, 500),
+ maxScaleOverCover: 2,
+ );
+
+ expect(geometry.fittedImageSize, const Size(400, 200));
+ expect(geometry.fittedImageRect, const Rect.fromLTWH(0, 50, 400, 200));
+ expect(geometry.viewportCenter, const Offset(200, 150));
+ expect(geometry.initialScale, 1);
+ expect(geometry.coverScale, 1.5);
+ expect(geometry.originalScale, 2.5);
+ expect(geometry.maxScale, 3);
+ });
+
+ test("uses exact configuration equality and tolerant coordinates", () {
+ final first = _geometry(
+ viewportSize: const Size(400, 300),
+ imageSize: const Size(1000, 500),
+ );
+ final exactCopy = _geometry(
+ viewportSize: const Size(400, 300),
+ imageSize: const Size(1000, 500),
+ );
+ final higherResolution = _geometry(
+ viewportSize: const Size(400, 300),
+ imageSize: const Size(2000, 1000),
+ );
+ final rotated = _geometry(
+ viewportSize: const Size(300, 400),
+ imageSize: const Size(1000, 500),
+ );
+ final withinCoordinateEpsilon = _geometry(
+ viewportSize: const Size(400.0005, 300),
+ imageSize: const Size(1000, 500),
+ );
+ final outsideCoordinateEpsilon = _geometry(
+ viewportSize: const Size(400.01, 300),
+ imageSize: const Size(1000, 500),
+ );
+
+ expect(first.hasSameConfiguration(exactCopy), isTrue);
+ expect(first.hasSameConfiguration(higherResolution), isFalse);
+ expect(first.coordinatesMatch(higherResolution), isTrue);
+ expect(first.coordinatesMatch(withinCoordinateEpsilon), isTrue);
+ expect(first.coordinatesMatch(outsideCoordinateEpsilon), isFalse);
+ expect(first.coordinatesMatch(rotated), isFalse);
+ });
+
+ test("builds a bounded focal target around the tapped scene point", () {
+ final geometry = _geometry(
+ viewportSize: const Size(400, 400),
+ imageSize: const Size(800, 800),
+ );
+ final initial = geometry.matrixForScaleAndOffset(1, Offset.zero);
+ final target = geometry.matrixForFocalPoint(
+ initial,
+ const Offset(100, 120),
+ 2,
+ );
+
+ expect(geometry.scenePoint(target, geometry.viewportCenter).dx, 100);
+ expect(geometry.scenePoint(target, geometry.viewportCenter).dy, 120);
+ final state = geometry.describe(target);
+ expect(state.absoluteScale, 2);
+ expect(state.semanticOffset, const Offset(200, 160));
+ });
+
+ test("clamps scale and offsets to visible image bounds", () {
+ final geometry = _geometry(
+ viewportSize: const Size(400, 300),
+ imageSize: const Size(1000, 500),
+ maxScaleOverCover: 2,
+ );
+ final unbounded = geometry.matrixForScaleAndOffset(
+ 5,
+ const Offset(900, -900),
+ );
+ final state = geometry.describe(geometry.sanitize(unbounded));
+
+ expect(state.absoluteScale, 3);
+ expect(state.semanticOffset, const Offset(400, -150));
+ expect(geometry.clampScale(0.5), 1);
+ expect(geometry.clampScale(8), 3);
+ });
+
+ test("describes the normalized OCR-compatible semantic transform", () {
+ final geometry = _geometry(
+ viewportSize: const Size(400, 300),
+ imageSize: const Size(1000, 500),
+ );
+ final matrix = geometry.matrixForScaleAndOffset(2, const Offset(30, -20));
+ final state = geometry.describe(matrix);
+
+ expect(state.absoluteScale, 2);
+ expect(state.relativeScale, 2);
+ expect(state.semanticOffset, const Offset(30, -20));
+ expect(state.isInitial, isFalse);
+ });
+
+ test("describes an initial cover transform as semantic identity", () {
+ final geometry = _geometry(
+ viewportSize: const Size(400, 300),
+ imageSize: const Size(1000, 500),
+ initialFit: BoxFit.cover,
+ );
+ final state = geometry.describe(
+ geometry.matrixForScaleAndOffset(geometry.initialScale, Offset.zero),
+ );
+
+ expect(state.absoluteScale, 1.5);
+ expect(state.relativeScale, 1);
+ expect(state.semanticOffset, Offset.zero);
+ expect(state.isInitial, isTrue);
+ });
+ });
+
+ group("ImageZoomRebase", () {
+ test("preserves relative scale and normalized focus", () {
+ final before = _geometry(
+ viewportSize: const Size(400, 300),
+ imageSize: const Size(1000, 500),
+ );
+ final after = _geometry(
+ viewportSize: const Size(300, 400),
+ imageSize: const Size(1000, 500),
+ );
+ final matrix = before.sanitize(
+ before.matrixForScaleAndOffset(2, const Offset(50, 0)),
+ );
+ final rebase = ImageZoomRebase.capture(before, matrix);
+ final resolved = rebase.resolve(after);
+ final resolvedState = after.describe(resolved);
+ final recaptured = ImageZoomRebase.capture(after, resolved);
+
+ expect(resolvedState.relativeScale, closeTo(rebase.relativeScale, 1e-9));
+ expect(
+ recaptured.normalizedFocus.dx,
+ closeTo(rebase.normalizedFocus.dx, 1e-9),
+ );
+ expect(
+ recaptured.normalizedFocus.dy,
+ closeTo(rebase.normalizedFocus.dy, 1e-9),
+ );
+ });
+
+ test("keeps out-of-bounds focus until target sanitization", () {
+ final before = _geometry(
+ viewportSize: const Size(400, 300),
+ imageSize: const Size(1000, 500),
+ );
+ final after = _geometry(
+ viewportSize: const Size(300, 400),
+ imageSize: const Size(1000, 500),
+ );
+ final unbounded = before.matrixForScaleAndTranslation(
+ 2,
+ const Offset(900, 700),
+ );
+ final rebase = ImageZoomRebase.capture(before, unbounded);
+
+ expect(
+ rebase.normalizedFocus.dx < 0 || rebase.normalizedFocus.dx > 1,
+ isTrue,
+ );
+ expect(
+ rebase.normalizedFocus.dy < 0 || rebase.normalizedFocus.dy > 1,
+ isTrue,
+ );
+
+ final resolvedState = after.describe(rebase.resolve(after));
+ final maxOffsetX = math.max(
+ 0,
+ (after.fittedImageSize.width * resolvedState.absoluteScale -
+ after.viewportSize.width) /
+ 2,
+ );
+ final maxOffsetY = math.max(
+ 0,
+ (after.fittedImageSize.height * resolvedState.absoluteScale -
+ after.viewportSize.height) /
+ 2,
+ );
+ expect(
+ resolvedState.semanticOffset.dx.abs(),
+ lessThanOrEqualTo(maxOffsetX),
+ );
+ expect(
+ resolvedState.semanticOffset.dy.abs(),
+ lessThanOrEqualTo(maxOffsetY),
+ );
+ });
+ });
+}
+
+ImageZoomGeometry _geometry({
+ required Size viewportSize,
+ required Size imageSize,
+ BoxFit initialFit = BoxFit.contain,
+ double maxScaleOverCover = double.infinity,
+}) => ImageZoomGeometry.calculate(
+ viewportSize: viewportSize,
+ imageSize: imageSize,
+ initialFit: initialFit,
+ maxScaleOverCover: maxScaleOverCover,
+)!;
diff --git a/mobile/apps/photos/test/ui/viewer/file/image_zoom_stage_policy_test.dart b/mobile/apps/photos/test/ui/viewer/file/image_zoom_stage_policy_test.dart
new file mode 100644
index 0000000000..a47097f53d
--- /dev/null
+++ b/mobile/apps/photos/test/ui/viewer/file/image_zoom_stage_policy_test.dart
@@ -0,0 +1,172 @@
+import "package:flutter_test/flutter_test.dart";
+import "package:photos/ui/viewer/file/image_zoom_stage_policy.dart";
+
+void main() {
+ const standardPolicy = ImageZoomStagePolicy(
+ initialScale: 1,
+ coverScale: 1.5,
+ originalScale: 3,
+ maxScale: 6,
+ );
+
+ test("normal double-tap cycle advances through every distinct stage", () {
+ expect(
+ standardPolicy.nextDoubleTapStage(
+ currentStage: ImageZoomStage.initial,
+ currentScale: 1,
+ ),
+ ImageZoomStage.covering,
+ );
+ expect(
+ standardPolicy.nextDoubleTapStage(
+ currentStage: ImageZoomStage.covering,
+ currentScale: 1.5,
+ ),
+ ImageZoomStage.originalSize,
+ );
+ expect(
+ standardPolicy.nextDoubleTapStage(
+ currentStage: ImageZoomStage.originalSize,
+ currentScale: 3,
+ ),
+ ImageZoomStage.initial,
+ );
+ });
+
+ test("duplicate cover rung is skipped", () {
+ const policy = ImageZoomStagePolicy(
+ initialScale: 1,
+ coverScale: 1,
+ originalScale: 3,
+ maxScale: 6,
+ );
+
+ expect(
+ policy.nextDoubleTapStage(
+ currentStage: ImageZoomStage.initial,
+ currentScale: 1,
+ ),
+ ImageZoomStage.originalSize,
+ );
+ });
+
+ test("duplicate original rung cycles from cover back to initial", () {
+ const policy = ImageZoomStagePolicy(
+ initialScale: 1,
+ coverScale: 2,
+ originalScale: 2,
+ maxScale: 6,
+ );
+
+ expect(
+ policy.nextDoubleTapStage(
+ currentStage: ImageZoomStage.initial,
+ currentScale: 1,
+ ),
+ ImageZoomStage.covering,
+ );
+ expect(
+ policy.nextDoubleTapStage(
+ currentStage: ImageZoomStage.covering,
+ currentScale: 2,
+ ),
+ ImageZoomStage.initial,
+ );
+ });
+
+ test("maximum-scale clamping collapses duplicate higher rungs", () {
+ const policy = ImageZoomStagePolicy(
+ initialScale: 1,
+ coverScale: 2,
+ originalScale: 3,
+ maxScale: 1.5,
+ );
+
+ expect(policy.targetScale(ImageZoomStage.covering), 1.5);
+ expect(policy.targetScale(ImageZoomStage.originalSize), 1.5);
+ expect(
+ policy.nextDoubleTapStage(
+ currentStage: ImageZoomStage.initial,
+ currentScale: 1,
+ ),
+ ImageZoomStage.covering,
+ );
+ expect(
+ policy.nextDoubleTapStage(
+ currentStage: ImageZoomStage.covering,
+ currentScale: 1.5,
+ ),
+ ImageZoomStage.initial,
+ );
+ });
+
+ test("all programmatic targets equal produces no next stage", () {
+ const policy = ImageZoomStagePolicy(
+ initialScale: 1,
+ coverScale: 1,
+ originalScale: 1,
+ maxScale: 1,
+ );
+
+ for (final stage in <ImageZoomStage>[
+ ImageZoomStage.initial,
+ ImageZoomStage.covering,
+ ImageZoomStage.originalSize,
+ ]) {
+ expect(
+ policy.nextDoubleTapStage(currentStage: stage, currentScale: 1),
+ isNull,
+ );
+ }
+ });
+
+ test("gesture stage always resets to initial", () {
+ expect(
+ standardPolicy.nextDoubleTapStage(
+ currentStage: ImageZoomStage.gesture,
+ currentScale: 2.25,
+ ),
+ ImageZoomStage.initial,
+ );
+ expect(
+ standardPolicy.nextDoubleTapStage(
+ currentStage: ImageZoomStage.gesture,
+ currentScale: 1,
+ ),
+ ImageZoomStage.initial,
+ );
+ });
+
+ test("target scales map stages and clamp to the configured range", () {
+ expect(standardPolicy.targetScale(ImageZoomStage.initial), 1);
+ expect(standardPolicy.targetScale(ImageZoomStage.gesture), 1);
+ expect(standardPolicy.targetScale(ImageZoomStage.covering), 1.5);
+ expect(standardPolicy.targetScale(ImageZoomStage.originalSize), 3);
+
+ const clampedPolicy = ImageZoomStagePolicy(
+ initialScale: 1,
+ coverScale: 0.5,
+ originalScale: 8,
+ maxScale: 4,
+ );
+ expect(clampedPolicy.targetScale(ImageZoomStage.covering), 1);
+ expect(clampedPolicy.targetScale(ImageZoomStage.originalSize), 4);
+ });
+
+ test("scale differences at epsilon are skipped and larger ones are not", () {
+ expect(
+ standardPolicy.nextDoubleTapStage(
+ currentStage: ImageZoomStage.initial,
+ currentScale: 1.499,
+ ),
+ ImageZoomStage.originalSize,
+ );
+ expect(
+ standardPolicy.nextDoubleTapStage(
+ currentStage: ImageZoomStage.initial,
+ currentScale: 1.4989,
+ ),
+ ImageZoomStage.covering,
+ );
+ });
+}