π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
[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.dartnew file mode 100644index 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.dartnew file mode 100644index 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.dartindex 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;@overridevoid 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);- }-@overrideFuture<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.dartnew file mode 100644index 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.dartnew file mode 100644index 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,+ );+ });+}