π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
[mob][photos] Own image zoom behavior
ashil-pilotc4a573afbf84
diff --git a/mobile/apps/photos/changes/zoom-to-tapped-point.md b/mobile/apps/photos/changes/zoom-to-tapped-point.mdnew file mode 100644index 0000000000..6dff691424--- /dev/null+++ b/mobile/apps/photos/changes/zoom-to-tapped-point.md@@ -0,0 +1 @@+- Zoom double-tapped photos toward the tapped area instead of the image center.diff --git a/mobile/apps/photos/lib/ui/viewer/actions/file_viewer.dart b/mobile/apps/photos/lib/ui/viewer/actions/file_viewer.dartindex 039b42fbbf..d6fefe9fce 100644--- a/mobile/apps/photos/lib/ui/viewer/actions/file_viewer.dart+++ b/mobile/apps/photos/lib/ui/viewer/actions/file_viewer.dart@@ -11,7 +11,6 @@ import "package:media_extension/media_extension.dart";import "package:media_extension/media_extension_action_types.dart";import "package:photo_manager/photo_manager.dart";import "package:photo_manager_image_provider/photo_manager_image_provider.dart";-import "package:photo_view/photo_view.dart";import "package:photos/models/file/file.dart";import "package:photos/models/gallery_type.dart";import "package:photos/models/metadata/file_magic.dart";@@ -19,6 +18,7 @@ import "package:photos/module/metadata/local_file.dart";import "package:photos/module/metadata/video.dart";import "package:photos/services/app_lifecycle_service.dart";import "package:photos/ui/viewer/file/detail_page.dart";+import "package:photos/ui/viewer/file/image_zoom_viewer.dart";import "package:receive_sharing_intent/receive_sharing_intent.dart";import "package:video_player/video_player.dart";@@ -51,14 +51,11 @@ class FileViewerState extends State<FileViewer> {action.action == IntentAction.view &&(action.type == MediaType.image || action.type == MediaType.video);- Widget _boundedPhotoView(ImageProvider imageProvider) {- return PhotoView(+ Widget _boundedImageViewer(ImageProvider imageProvider) {+ return ImageZoomViewer(imageProvider: imageProvider,filterQuality: FilterQuality.high,- initialScale: PhotoViewComputedScale.contained,- minScale: PhotoViewComputedScale.contained,- maxScale: PhotoViewComputedScale.covered * 3.0,- strictScale: true,+ maxScaleOverCover: 3.0,);}@@ -417,7 +414,7 @@ class FileViewerState extends State<FileViewer> {builder: (context, snapshot) {final bytes = snapshot.data;if (bytes != null) {- return _boundedPhotoView(MemoryImage(bytes));+ return _boundedImageViewer(MemoryImage(bytes));}if (snapshot.connectionState != ConnectionState.done) {return const CircularProgressIndicator();@@ -430,7 +427,7 @@ class FileViewerState extends State<FileViewer> {Widget _buildImageViewer() {final sharedMediaPath = widget.sharedMediaFile?.path;if (sharedMediaPath != null) {- return _boundedPhotoView(Image.file(File(sharedMediaPath)).image);+ return _boundedImageViewer(Image.file(File(sharedMediaPath)).image);}final data = action.data;@@ -441,7 +438,7 @@ class FileViewerState extends State<FileViewer> {final uri = Uri.tryParse(data);if (uri?.scheme == "file") {- return _boundedPhotoView(FileImage(File(uri!.toFilePath())));+ return _boundedImageViewer(FileImage(File(uri!.toFilePath())));}final assetFuture = mediaStoreAssetFuture;@@ -459,7 +456,7 @@ class FileViewerState extends State<FileViewer> {}return const CircularProgressIndicator();}- return _boundedPhotoView(AssetEntityImageProvider(asset));+ return _boundedImageViewer(AssetEntityImageProvider(asset));},);}@@ -474,7 +471,7 @@ class FileViewerState extends State<FileViewer> {}try {- return _boundedPhotoView(MemoryImage(base64Decode(data)));+ return _boundedImageViewer(MemoryImage(base64Decode(data)));} catch (e, s) {_logger.severe("failed to decode shared image payload", e, s);return const Icon(Icons.error);diff --git a/mobile/apps/photos/lib/ui/viewer/file/detail_page.dart b/mobile/apps/photos/lib/ui/viewer/file/detail_page.dartindex 885ddc90f5..a7f3f434f9 100644--- a/mobile/apps/photos/lib/ui/viewer/file/detail_page.dart+++ b/mobile/apps/photos/lib/ui/viewer/file/detail_page.dart@@ -452,6 +452,7 @@ class _BodyState extends State<_Body> {autoPlay: shouldAutoPlay(),tagPrefix: widget.config.tagPrefix,shouldDisableScroll: (value) {+ if (_selectedFile?.tag != file.tag) return;if (_shouldDisableScroll != value) {setState(() {_logger.info('setState $_shouldDisableScroll to $value');@@ -502,6 +503,10 @@ class _BodyState extends State<_Body> {if (file == null) {return;}+ final selectedFileChanged = _selectedFile?.tag != file.tag;+ if (selectedFileChanged) {+ _clearZoomStateForSelectedFileChange();+ }if (_selectedIndexNotifier.value == index) {if (kDebugMode) {debugPrint("onPageChanged called with same index $index");@@ -556,12 +561,14 @@ class _BodyState extends State<_Body> {return;}setState(() {+ _shouldDisableScroll = false;_files!.removeAt(_selectedIndexNotifier.value);_selectedIndexNotifier.value = min(_selectedIndexNotifier.value,totalFiles - 2,);});+ _clearZoomNotifiers();final currentPageIndex = _pageController.page!.round();final int targetPageIndex = _files!.length > currentPageIndex? currentPageIndex@@ -575,6 +582,24 @@ class _BodyState extends State<_Body> {}}+ void _clearZoomStateForSelectedFileChange() {+ if (_shouldDisableScroll) {+ setState(() => _shouldDisableScroll = false);+ }+ _clearZoomNotifiers();+ }++ void _clearZoomNotifiers() {+ final detailState = InheritedDetailPageState.maybeOf(context);+ if (detailState == null) return;+ if (detailState.isZoomedNotifier.value) {+ detailState.isZoomedNotifier.value = false;+ }+ if (detailState.zoomTransformNotifier.value != ZoomTransform.identity) {+ detailState.zoomTransformNotifier.value = ZoomTransform.identity;+ }+ }+Future<void> _onEditFileRequested(EnteFile file) async {if (file.uploadedFileID != null &&file.ownerID != Configuration.instance.getUserID()) {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.dartnew file mode 100644index 0000000000..7f35826994--- /dev/null+++ b/mobile/apps/photos/lib/ui/viewer/file/image_zoom_viewer.dart@@ -0,0 +1,985 @@+import "dart:async";+import "dart:math" as math;++import "package:flutter/material.dart";++const double _kZoomEpsilon = 0.001;++enum ImageZoomStage { initial, covering, originalSize, gesture }++typedef ImageZoomLoadingBuilder =+ Widget Function(BuildContext context, ImageChunkEvent? progress);++@immutable+class ImageZoomTransform {+ static const identity = ImageZoomTransform(scale: 1.0, offset: Offset.zero);++ final double scale;+ final Offset offset;++ const ImageZoomTransform({required this.scale, required this.offset});++ @override+ bool operator ==(Object other) =>+ identical(this, other) ||+ other is ImageZoomTransform &&+ other.scale == scale &&+ other.offset == offset;++ @override+ int get hashCode => Object.hash(scale, offset);+}++abstract interface class _ImageZoomControllerDelegate {+ Future<void> reset({required bool animated});+}++class ImageZoomController extends ChangeNotifier {+ ImageZoomTransform _transform = ImageZoomTransform.identity;+ ImageZoomStage _stage = ImageZoomStage.initial;+ _ImageZoomControllerDelegate? _delegate;++ ImageZoomTransform get transform => _transform;+ ImageZoomStage get stage => _stage;++ bool get isZoomed =>+ (_transform.scale - 1.0).abs() > _kZoomEpsilon ||+ _transform.offset.distanceSquared > _kZoomEpsilon * _kZoomEpsilon;++ Future<void> reset({bool animated = true}) async {+ await _delegate?.reset(animated: animated);+ }++ void _attach(_ImageZoomControllerDelegate delegate) {+ if (_delegate != null && !identical(_delegate, delegate)) {+ throw StateError(+ "An ImageZoomController cannot be attached to multiple viewers.",+ );+ }+ _delegate = delegate;+ }++ void _detach(_ImageZoomControllerDelegate delegate) {+ if (identical(_delegate, delegate)) {+ _delegate = null;+ }+ }++ void _update(ImageZoomTransform transform, ImageZoomStage stage) {+ if (_transform == transform && _stage == stage) return;+ _transform = transform;+ _stage = stage;+ notifyListeners();+ }+}++class ImageZoomViewer extends StatefulWidget {+ final ImageProvider imageProvider;+ final ImageZoomController? controller;+ final Size? imageSizeHint;+ final Object? heroTag;+ final Decoration? backgroundDecoration;+ final BoxFit initialFit;+ final double maxScaleOverCover;+ final FilterQuality filterQuality;+ final bool gaplessPlayback;+ final bool gesturesEnabled;+ final ImageZoomLoadingBuilder? loadingBuilder;+ final ImageErrorWidgetBuilder? errorBuilder;+ final String? semanticLabel;+ final ValueChanged<bool>? onInteractionLockChanged;+ final Duration animationDuration;++ const ImageZoomViewer({+ super.key,+ required this.imageProvider,+ this.controller,+ this.imageSizeHint,+ this.heroTag,+ this.backgroundDecoration,+ this.initialFit = BoxFit.contain,+ this.maxScaleOverCover = double.infinity,+ this.filterQuality = FilterQuality.high,+ this.gaplessPlayback = true,+ this.gesturesEnabled = true,+ this.loadingBuilder,+ this.errorBuilder,+ this.semanticLabel,+ this.onInteractionLockChanged,+ this.animationDuration = const Duration(milliseconds: 220),+ }) : assert(initialFit == BoxFit.contain || initialFit == BoxFit.cover),+ assert(maxScaleOverCover > 0);++ @override+ State<ImageZoomViewer> createState() => _ImageZoomViewerState();+}++class _ImageZoomViewerState extends State<ImageZoomViewer>+ with SingleTickerProviderStateMixin+ implements _ImageZoomControllerDelegate {+ late ImageZoomController _controller;+ late bool _ownsController;+ late final _BoundedTransformationController _transformationController;+ late final AnimationController _animationController;++ Animation<Matrix4>? _matrixAnimation;+ Completer<void>? _animationCompleter;+ ImageZoomStage _stage = ImageZoomStage.initial;++ ImageStream? _imageStream;+ ImageStreamListener? _imageStreamListener;+ Size? _resolvedImageSize;+ ImageChunkEvent? _loadingProgress;+ Object? _imageError;+ 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;++ final Map<int, Offset> _pointerPositions = <int, Offset>{};+ List<int> _manualPinchPointers = const <int>[];+ Matrix4? _manualPinchStartMatrix;+ Offset? _manualPinchScenePoint;+ double _manualPinchStartDistance = 0;+ bool _manualPinchActive = false;+ bool _programmaticAnimationActive = false;+ bool _interactionLocked = false;+ bool _interactiveViewerEnabled = false;+ int _interactiveViewerGeneration = 0;+ double? _interactiveStartScale;+ Offset? _doubleTapPosition;+ int _geometryGeneration = 0;++ bool get _hasGeometry =>+ _viewportSize != null &&+ _fittedImageSize != null &&+ _viewportSize!.width > 0 &&+ _viewportSize!.height > 0 &&+ _fittedImageSize!.width > 0 &&+ _fittedImageSize!.height > 0;++ @override+ void initState() {+ super.initState();+ _resolvedImageSize = _validSize(widget.imageSizeHint);+ _attachController(widget.controller);+ _transformationController = _BoundedTransformationController()+ ..addListener(_onTransformationChanged);+ _animationController =+ AnimationController(vsync: this, duration: widget.animationDuration)+ ..addListener(_onAnimationTick)+ ..addStatusListener(_onAnimationStatusChanged);+ }++ @override+ void didChangeDependencies() {+ super.didChangeDependencies();+ _resolveImage();+ }++ @override+ void didUpdateWidget(covariant ImageZoomViewer oldWidget) {+ super.didUpdateWidget(oldWidget);+ if (oldWidget.controller != widget.controller) {+ _detachController();+ _attachController(widget.controller);+ _publishTransform();+ }+ if (oldWidget.imageProvider != widget.imageProvider) {+ final hint = _validSize(widget.imageSizeHint);+ if (!_hasImageFrame && hint != null) {+ _resolvedImageSize = hint;+ }+ _resolveImage();+ if (_stage != ImageZoomStage.initial) {+ _stage = ImageZoomStage.gesture;+ }+ } else if (oldWidget.imageSizeHint != widget.imageSizeHint &&+ !_hasImageFrame) {+ _resolvedImageSize = _validSize(widget.imageSizeHint);+ }+ if (oldWidget.animationDuration != widget.animationDuration) {+ _animationController.duration = widget.animationDuration;+ }+ if (oldWidget.gesturesEnabled && !widget.gesturesEnabled) {+ _pointerPositions.clear();+ _manualPinchActive = false;+ _updateInteractionLock();+ }+ }++ void _attachController(ImageZoomController? controller) {+ _ownsController = controller == null;+ _controller = controller ?? ImageZoomController();+ _controller._attach(this);+ }++ void _detachController() {+ _controller._detach(this);+ if (_ownsController) {+ _controller.dispose();+ }+ }++ @override+ void dispose() {+ _detachImageStreamListener();+ _animationController+ ..removeListener(_onAnimationTick)+ ..removeStatusListener(_onAnimationStatusChanged)+ ..dispose();+ _animationCompleter?.complete();+ _transformationController+ ..removeListener(_onTransformationChanged)+ ..dispose();+ _detachController();+ super.dispose();+ }++ void _resolveImage() {+ final newStream = widget.imageProvider.resolve(+ createLocalImageConfiguration(context),+ );+ if (_imageStream?.key == newStream.key) return;+ _detachImageStreamListener();+ _imageStream = newStream;+ _imageStreamListener = ImageStreamListener(+ _handleImageFrame,+ onChunk: _handleImageChunk,+ onError: _handleImageError,+ );+ newStream.addListener(_imageStreamListener!);+ }++ void _detachImageStreamListener() {+ final listener = _imageStreamListener;+ if (_imageStream != null && listener != null) {+ _imageStream!.removeListener(listener);+ }+ _imageStreamListener = null;+ }++ void _handleImageFrame(ImageInfo imageInfo, bool synchronousCall) {+ final imageSize = Size(+ imageInfo.image.width.toDouble(),+ imageInfo.image.height.toDouble(),+ );+ final shouldUpdate =+ !_hasImageFrame ||+ _resolvedImageSize != imageSize ||+ _loadingProgress != null ||+ _imageError != null;+ if (!shouldUpdate) {+ imageInfo.dispose();+ return;+ }+ void update() {+ _resolvedImageSize = imageSize;+ _hasImageFrame = true;+ _loadingProgress = null;+ _imageError = null;+ _imageErrorStack = null;+ }++ if (synchronousCall) {+ update();+ } else if (mounted) {+ setState(update);+ }+ imageInfo.dispose();+ }++ void _handleImageChunk(ImageChunkEvent progress) {+ if (!mounted || _hasImageFrame) return;+ setState(() {+ _loadingProgress = progress;+ _imageError = null;+ _imageErrorStack = null;+ });+ }++ void _handleImageError(Object error, StackTrace? stackTrace) {+ if (!mounted || _hasImageFrame) return;+ setState(() {+ _imageError = error;+ _imageErrorStack = stackTrace;+ _loadingProgress = null;+ });+ }++ Size? _validSize(Size? size) {+ if (size == null ||+ !size.width.isFinite ||+ !size.height.isFinite ||+ size.width <= 0 ||+ size.height <= 0) {+ return null;+ }+ return size;+ }++ 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 previousMatrix = _transformationController.value.clone();+ final hadGeometry = _hasGeometry;++ 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) {+ _stopProgrammaticAnimationForGeometryChange();+ }++ _viewportSize = viewportSize;+ _fittedImageSize = fittedSize;+ _initialScale = initialScale;+ _coverScale = coverScale;+ _originalScale = originalScale;+ _maxScale = maxScale;+ _transformationController.configure(+ viewportSize: viewportSize,+ fittedImageSize: fittedSize,+ minScale: initialScale,+ maxScale: maxScale,+ );++ if (!hadGeometry ||+ previousViewport == null ||+ previousFittedSize == null) {+ _transformationController.setOwnerValue(+ _matrixForScaleAndOffset(initialScale, Offset.zero),+ );+ _stage = ImageZoomStage.initial;+ _publishTransform();+ return;+ }++ 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,+ );+ 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;+ }+ _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();+ _syncInteractiveViewerEnabled();+ }++ void _syncInteractiveViewerEnabled() {+ final shouldEnable =+ widget.gesturesEnabled &&+ !_manualPinchActive &&+ (_interactiveStartScale != null ||+ !_isMatrixAtInitial(_transformationController.value));+ if (_interactiveViewerEnabled != shouldEnable && mounted) {+ setState(() => _interactiveViewerEnabled = shouldEnable);+ }+ }++ 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) {+ _stage = ImageZoomStage.initial;+ }+ _controller._update(+ isInitial+ ? ImageZoomTransform.identity+ : ImageZoomTransform(scale: relativeScale, offset: offset),+ _stage,+ );+ _updateInteractionLock();+ }++ void _updateInteractionLock() {+ final shouldLock =+ widget.gesturesEnabled &&+ (_pointerPositions.length >= 2 ||+ _manualPinchActive ||+ _programmaticAnimationActive ||+ _controller.isZoomed);+ if (shouldLock == _interactionLocked) return;+ _interactionLocked = shouldLock;+ widget.onInteractionLockChanged?.call(shouldLock);+ }++ void _onPointerDown(PointerDownEvent event) {+ if (!widget.gesturesEnabled) return;+ _pointerPositions[event.pointer] = event.localPosition;+ if (_animationController.isAnimating) {+ _stopProgrammaticAnimation();+ }+ if (_manualPinchActive &&+ _pointerPositions.length >= 2 &&+ !_manualPinchPointers.every(_pointerPositions.containsKey)) {+ _beginManualPinch();+ } else if (_pointerPositions.length >= 2 &&+ !_manualPinchActive &&+ _isMatrixAtInitial(_transformationController.value)) {+ _beginManualPinch();+ }+ _updateInteractionLock();+ }++ void _onPointerMove(PointerMoveEvent event) {+ if (!widget.gesturesEnabled ||+ !_pointerPositions.containsKey(event.pointer)) {+ return;+ }+ _pointerPositions[event.pointer] = event.localPosition;+ if (_manualPinchActive) {+ _updateManualPinch();+ }+ }++ void _onPointerUp(PointerEvent event) {+ if (!widget.gesturesEnabled) return;+ _pointerPositions.remove(event.pointer);+ if (_manualPinchActive &&+ !_manualPinchPointers.every(_pointerPositions.containsKey)) {+ if (_pointerPositions.length >= 2) {+ _beginManualPinch();+ } else if (_pointerPositions.isEmpty) {+ _endManualPinch();+ }+ }+ _updateInteractionLock();+ }++ void _beginManualPinch() {+ if (_pointerPositions.length < 2) return;+ _transformationController.allowInteractiveWrites();+ _manualPinchActive = true;+ _manualPinchPointers = _pointerPositions.keys+ .take(2)+ .toList(growable: false);+ final first = _pointerPositions[_manualPinchPointers[0]]!;+ final second = _pointerPositions[_manualPinchPointers[1]]!;+ final focalPoint = (first + second) / 2;+ _manualPinchStartDistance = (first - second).distance;+ _manualPinchStartMatrix = _transformationController.value.clone();+ _manualPinchScenePoint = _scenePoint(_manualPinchStartMatrix!, focalPoint);+ if (mounted) setState(() {});+ }++ void _updateManualPinch() {+ if (!_hasGeometry ||+ _manualPinchStartDistance <= 0 ||+ _manualPinchStartMatrix == null ||+ _manualPinchScenePoint == null ||+ !_manualPinchPointers.every(_pointerPositions.containsKey)) {+ return;+ }+ final first = _pointerPositions[_manualPinchPointers[0]]!;+ final second = _pointerPositions[_manualPinchPointers[1]]!;+ final distance = (first - second).distance;+ final focalPoint = (first + second) / 2;+ final startScale = _manualPinchStartMatrix!.getMaxScaleOnAxis();+ final targetScale = (startScale * distance / _manualPinchStartDistance)+ .clamp(_initialScale, _maxScale);+ final translation = focalPoint - _manualPinchScenePoint! * targetScale;+ _stage = ImageZoomStage.gesture;+ _transformationController.setOwnerValue(+ _matrixForScaleAndTranslation(targetScale, translation),+ );+ }++ void _endManualPinch() {+ _manualPinchActive = false;+ _manualPinchPointers = const <int>[];+ _manualPinchStartMatrix = null;+ _manualPinchScenePoint = null;+ if (_isMatrixAtInitial(_transformationController.value)) {+ _stage = ImageZoomStage.initial;+ _transformationController.setOwnerValue(+ _matrixForScaleAndOffset(_initialScale, Offset.zero),+ );+ }+ _publishTransform();+ _syncInteractiveViewerEnabled();+ }++ void _onInteractionStart(ScaleStartDetails _) {+ _transformationController.allowInteractiveWrites();+ _interactiveStartScale = _transformationController.value+ .getMaxScaleOnAxis();+ if (_animationController.isAnimating) {+ _stopProgrammaticAnimation();+ }+ }++ void _onInteractionUpdate(ScaleUpdateDetails details) {+ if (_pointerPositions.length >= 2 &&+ (details.scale - 1.0).abs() > _kZoomEpsilon) {+ _stage = ImageZoomStage.gesture;+ _publishTransform();+ }+ }++ void _onInteractionEnd(ScaleEndDetails _) {+ _interactiveStartScale = null;+ _syncInteractiveViewerEnabled();+ }++ void _onDoubleTapDown(TapDownDetails details) {+ _doubleTapPosition = details.localPosition;+ }++ void _onDoubleTapCancel() {+ _doubleTapPosition = null;+ }++ void _onDoubleTap() {+ final tapPosition = _doubleTapPosition;+ _doubleTapPosition = null;+ if (!_hasGeometry || tapPosition == null) return;++ final currentScale = _transformationController.value.getMaxScaleOnAxis();+ final nextStage = _nextDistinctStage(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,+ );+ }+ 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) {+ _stage = ImageZoomStage.initial;+ _controller._update(ImageZoomTransform.identity, _stage);+ return Future<void>.value();+ }+ final target = _matrixForScaleAndOffset(_initialScale, Offset.zero);+ if (!animated) {+ _stopProgrammaticAnimation();+ _stage = ImageZoomStage.initial;+ _transformationController+ ..suppressInteractiveWrites()+ ..setOwnerValue(target);+ _publishTransform();+ return Future<void>.value();+ }+ return _animateTo(target, ImageZoomStage.initial);+ }++ Future<void> _animateTo(Matrix4 target, ImageZoomStage targetStage) {+ _animationController.stop();+ _animationCompleter?.complete();+ final completer = Completer<void>();+ _animationCompleter = completer;+ _stage = targetStage;+ _programmaticAnimationActive = true;+ _transformationController.suppressInteractiveWrites();+ _matrixAnimation =+ Matrix4Tween(+ begin: _transformationController.value.clone(),+ end: _transformationController.sanitize(target),+ ).animate(+ CurvedAnimation(+ parent: _animationController,+ curve: Curves.easeOutCubic,+ ),+ );+ _interactiveViewerGeneration++;+ _updateInteractionLock();+ if (mounted) setState(() {});+ _animationController.forward(from: 0);+ return completer.future;+ }++ void _onAnimationTick() {+ final value = _matrixAnimation?.value;+ if (value != null) {+ _transformationController.setOwnerValue(value);+ }+ }++ void _onAnimationStatusChanged(AnimationStatus status) {+ if (status != AnimationStatus.completed) return;+ _programmaticAnimationActive = false;+ _matrixAnimation = null;+ _publishTransform();+ _animationCompleter?.complete();+ _animationCompleter = null;+ _updateInteractionLock();+ }++ void _stopProgrammaticAnimation() {+ if (!_animationController.isAnimating && !_programmaticAnimationActive) {+ return;+ }+ _animationController.stop();+ _programmaticAnimationActive = false;+ _matrixAnimation = null;+ _animationCompleter?.complete();+ _animationCompleter = null;+ _updateInteractionLock();+ }++ // Geometry is updated from LayoutBuilder. Avoid invoking the interaction+ // callback there; the post-frame geometry rebase publishes the new lock.+ void _stopProgrammaticAnimationForGeometryChange() {+ _animationController.stop();+ _programmaticAnimationActive = false;+ _matrixAnimation = null;+ _animationCompleter?.complete();+ _animationCompleter = null;+ }++ @override+ Widget build(BuildContext context) {+ if (_imageError != null && !_hasImageFrame) {+ return widget.errorBuilder?.call(+ context,+ _imageError!,+ _imageErrorStack,+ ) ??+ const Center(child: Icon(Icons.broken_image_outlined));+ }+ if (!_hasImageFrame || _resolvedImageSize == null) {+ return widget.loadingBuilder?.call(context, _loadingProgress) ??+ const Center(child: CircularProgressIndicator());+ }++ return LayoutBuilder(+ builder: (context, constraints) {+ final viewportSize = constraints.biggest;+ if (viewportSize.isEmpty || !viewportSize.isFinite) {+ return const SizedBox.shrink();+ }+ _updateGeometry(viewportSize, _resolvedImageSize!);+ final fittedSize = applyBoxFit(+ BoxFit.contain,+ _resolvedImageSize!,+ viewportSize,+ ).destination;++ Widget image = Image(+ image: widget.imageProvider,+ width: fittedSize.width,+ height: fittedSize.height,+ fit: BoxFit.fill,+ gaplessPlayback: widget.gaplessPlayback,+ filterQuality: widget.filterQuality,+ semanticLabel: widget.semanticLabel,+ errorBuilder: widget.errorBuilder,+ );+ if (widget.heroTag != null) {+ image = Hero(tag: widget.heroTag!, child: image);+ }++ final transformedChild = SizedBox.expand(+ child: Center(+ child: SizedBox(+ width: fittedSize.width,+ height: fittedSize.height,+ child: image,+ ),+ ),+ );+ final interactiveViewer = InteractiveViewer(+ key: ValueKey(_interactiveViewerGeneration),+ transformationController: _transformationController,+ alignment: null,+ minScale: _initialScale,+ maxScale: _maxScale,+ panEnabled: true,+ scaleEnabled: true,+ clipBehavior: Clip.hardEdge,+ onInteractionStart: _onInteractionStart,+ onInteractionUpdate: _onInteractionUpdate,+ onInteractionEnd: _onInteractionEnd,+ child: transformedChild,+ );++ final content = GestureDetector(+ behavior: HitTestBehavior.opaque,+ onDoubleTapDown: widget.gesturesEnabled ? _onDoubleTapDown : null,+ onDoubleTap: widget.gesturesEnabled ? _onDoubleTap : null,+ onDoubleTapCancel: widget.gesturesEnabled ? _onDoubleTapCancel : null,+ child: Listener(+ behavior: HitTestBehavior.opaque,+ onPointerDown: widget.gesturesEnabled ? _onPointerDown : null,+ onPointerMove: widget.gesturesEnabled ? _onPointerMove : null,+ onPointerUp: widget.gesturesEnabled ? _onPointerUp : null,+ onPointerCancel: widget.gesturesEnabled ? _onPointerUp : null,+ child: IgnorePointer(+ ignoring:+ !widget.gesturesEnabled ||+ _manualPinchActive ||+ !_interactiveViewerEnabled,+ child: interactiveViewer,+ ),+ ),+ );++ return DecoratedBox(+ decoration:+ widget.backgroundDecoration ??+ const BoxDecoration(color: Colors.black),+ child: content,+ );+ },+ );+ }+}++class _BoundedTransformationController extends TransformationController {+ Size? _viewportSize;+ Size? _fittedImageSize;+ double _minScale = 1.0;+ double _maxScale = double.infinity;+ 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 suppressInteractiveWrites() {+ _suppressInteractiveWrites = true;+ }++ void allowInteractiveWrites() {+ _suppressInteractiveWrites = false;+ }++ void setOwnerValue(Matrix4 matrix) {+ _ownerWrite = true;+ value = matrix;+ _ownerWrite = false;+ }++ @override+ set value(Matrix4 newValue) {+ if (_suppressInteractiveWrites && !_ownerWrite) return;+ final sanitized = sanitize(newValue);+ if (!_ownerWrite && _matricesNearlyEqual(value, sanitized)) return;+ 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);+ }+}++bool _matricesNearlyEqual(Matrix4 first, Matrix4 second) {+ if (MatrixUtils.matrixEquals(first, second)) return true;+ for (var index = 0; index < 16; index++) {+ if ((first.storage[index] - second.storage[index]).abs() > 0.0000001) {+ return false;+ }+ }+ 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/lib/ui/viewer/file/ocr/inline_text_detection.dart b/mobile/apps/photos/lib/ui/viewer/file/ocr/inline_text_detection.dartindex cf582bbc3c..28b98f24bd 100644--- a/mobile/apps/photos/lib/ui/viewer/file/ocr/inline_text_detection.dart+++ b/mobile/apps/photos/lib/ui/viewer/file/ocr/inline_text_detection.dart@@ -827,7 +827,7 @@ class _InlineTextDetectionState extends State<InlineTextDetection> {child: overlay,);- // Let PhotoView own gestures while pinching or settling a zoom.+ // Let the image viewer own gestures while pinching or settling a zoom.final shouldIgnore =_isPinching || (isZoomed && !_zoomGestureSettled);diff --git a/mobile/apps/photos/lib/ui/viewer/file/ocr/text_overlay_widget.dart b/mobile/apps/photos/lib/ui/viewer/file/ocr/text_overlay_widget.dartindex 4e1844a40e..c940e8ddee 100644--- a/mobile/apps/photos/lib/ui/viewer/file/ocr/text_overlay_widget.dart+++ b/mobile/apps/photos/lib/ui/viewer/file/ocr/text_overlay_widget.dart@@ -2475,7 +2475,7 @@ class _EditableBlockPainter extends CustomPainter {}}-// Reject hits outside text so PageView and PhotoView receive the gesture.+// Reject hits outside text so PageView and the image viewer receive the gesture.class _TextRegionHitTestBox extends SingleChildRenderObjectWidget {final bool Function(Offset globalPosition) hitTest;diff --git a/mobile/apps/photos/lib/ui/viewer/file/zoomable_image.dart b/mobile/apps/photos/lib/ui/viewer/file/zoomable_image.dartindex e3ac47da12..7af15cd786 100644--- a/mobile/apps/photos/lib/ui/viewer/file/zoomable_image.dart+++ b/mobile/apps/photos/lib/ui/viewer/file/zoomable_image.dart@@ -7,7 +7,6 @@ import 'package:ente_ui/components/loading_widget.dart';import 'package:flutter/material.dart';import "package:flutter_image_compress/flutter_image_compress.dart";import 'package:logging/logging.dart';-import 'package:photo_view/photo_view.dart';import 'package:photos/core/cache/thumbnail_in_memory_cache.dart';import 'package:photos/core/constants.dart';import 'package:photos/core/event_bus.dart';@@ -25,6 +24,7 @@ import "package:photos/service_locator.dart" show flagService;import "package:photos/src/rust/api/image_processing_api.dart" as rust_image;import "package:photos/states/detail_page_state.dart";import "package:photos/ui/actions/file/file_actions.dart";+import "package:photos/ui/viewer/file/image_zoom_viewer.dart";import 'package:photos/ui/viewer/file/thumbnail_widget.dart';import 'package:photos/utils/image_util.dart';import "package:photos/utils/ram_check_util.dart";@@ -74,15 +74,9 @@ class _ZoomableImageState extends State<ZoomableImage> {// Start the memory slideshow timer when any image is ready, without waiting// for the original.bool _firedOnReady = false;- ValueChanged<PhotoViewScaleState>? _scaleStateChangedCallback;bool _isZooming = false;- PhotoViewController _photoViewController = PhotoViewController();- final _scaleStateController = PhotoViewScaleStateController();- StreamSubscription<dynamic>? _zoomStreamSubscription;-- // Baseline PhotoView scale for the current image/controller when the image- // is at its contained size. ZoomTransform.scale is reported relative to this.- double? _initialScale;+ bool _interactionLocked = false;+ final _imageZoomController = ImageZoomController();late final StreamSubscription<ResetZoomOfPhotoView> _resetZoomSubscription;late final StreamSubscription<RetryFailedImageLoadEvent>_retryFailedLoadSubscription;@@ -113,20 +107,7 @@ class _ZoomableImageState extends State<ZoomableImage> {_loadedSmallThumbnail = true;_notifyReadyOnce();}- _scaleStateChangedCallback = (value) {- if (widget.shouldDisableScroll != null) {- widget.shouldDisableScroll!(value != PhotoViewScaleState.initial);- }- _isZooming = value != PhotoViewScaleState.initial;- final state = InheritedDetailPageState.maybeOf(context);- state?.isZoomedNotifier.value = _isZooming;- if (!_isZooming) {- _initialScale = _photoViewController.scale ?? _initialScale;- state?.zoomTransformNotifier.value = ZoomTransform.identity;- }- };-- _subscribeToZoomStream();+ _imageZoomController.addListener(_onZoomChanged);_resetZoomSubscription = Bus.instance.on<ResetZoomOfPhotoView>().listen((event,@@ -135,7 +116,7 @@ class _ZoomableImageState extends State<ZoomableImage> {uploadedFileID: widget.photo.uploadedFileID,localID: widget.photo.localID,)) {- _scaleStateController.scaleState = PhotoViewScaleState.initial;+ unawaited(_imageZoomController.reset());}});@@ -155,31 +136,28 @@ class _ZoomableImageState extends State<ZoomableImage> {});}- void _subscribeToZoomStream() {- _zoomStreamSubscription = _photoViewController.outputStateStream.listen((- value,- ) {- if (!mounted) return;- final state = InheritedDetailPageState.maybeOf(context);- if (value.scale == null) return;- if (!_isZooming) {- _initialScale = value.scale;- state?.zoomTransformNotifier.value = ZoomTransform.identity;- return;- }- _initialScale ??= value.scale;- state?.zoomTransformNotifier.value = ZoomTransform(- scale: value.scale! / _initialScale!,- offset: value.position,- );- });+ void _onZoomChanged() {+ if (!mounted) return;+ final transform = _imageZoomController.transform;+ _isZooming = _imageZoomController.isZoomed;+ final state = InheritedDetailPageState.maybeOf(context);+ state?.isZoomedNotifier.value = _isZooming;+ state?.zoomTransformNotifier.value = _isZooming+ ? ZoomTransform(scale: transform.scale, offset: transform.offset)+ : ZoomTransform.identity;+ }++ void _onInteractionLockChanged(bool isLocked) {+ widget.shouldDisableScroll?.call(isLocked);+ if (_interactionLocked == isLocked || !mounted) return;+ setState(() => _interactionLocked = isLocked);}@overridevoid dispose() {- _zoomStreamSubscription?.cancel();- _photoViewController.dispose();- _scaleStateController.dispose();+ _imageZoomController+ ..removeListener(_onZoomChanged)+ ..dispose();_resetZoomSubscription.cancel();_retryFailedLoadSubscription.cancel();super.dispose();@@ -195,61 +173,53 @@ class _ZoomableImageState extends State<ZoomableImage> {Widget content;if (_imageProvider != null) {- content = PhotoViewGestureDetectorScope(- axis: Axis.vertical,- child: PhotoView(- // Rebuild PhotoView when the original replaces a zoomed thumbnail so- // the adjusted zoom takes effect. Memories do not zoom; a stable key- // lets gaplessPlayback replace the image without flashing the layer- // underneath.- key: widget.isFromMemories ? null : ValueKey(_loadedFinalImage),- imageProvider: _imageProvider,- controller: _photoViewController,- filterQuality: FilterQuality.high,- scaleStateController: _scaleStateController,- scaleStateChangedCallback: _scaleStateChangedCallback,- minScale: widget.shouldCover- ? PhotoViewComputedScale.covered- : PhotoViewComputedScale.contained,- gaplessPlayback: true,- heroAttributes: PhotoViewHeroAttributes(- tag: widget.tagPrefix! + _photo.tag,- ),- backgroundDecoration: widget.backgroundDecoration as BoxDecoration?,- loadingBuilder: (context, event) {- // Match the loading state to the image's on-screen size during the- // hero animation.- final screenDimensions = MediaQuery.sizeOf(context);- late final double screenRelativeImageWidth;- late final double screenRelativeImageHeight;- final screenWidth = screenDimensions.width;- final screenHeight = screenDimensions.height;-- final aspectRatioOfScreen = screenWidth / screenHeight;- final aspectRatioOfImage = _photo.width / _photo.height;-- if (aspectRatioOfImage > aspectRatioOfScreen) {- screenRelativeImageWidth = screenWidth;- screenRelativeImageHeight = screenWidth / aspectRatioOfImage;- } else if (aspectRatioOfImage < aspectRatioOfScreen) {- screenRelativeImageHeight = screenHeight;- screenRelativeImageWidth = screenHeight * aspectRatioOfImage;- } else {- screenRelativeImageWidth = screenWidth;- screenRelativeImageHeight = screenHeight;- }+ content = ImageZoomViewer(+ imageProvider: _imageProvider!,+ controller: _imageZoomController,+ imageSizeHint: _photo.width > 0 && _photo.height > 0+ ? Size(_photo.width.toDouble(), _photo.height.toDouble())+ : null,+ heroTag: widget.tagPrefix! + _photo.tag,+ backgroundDecoration: widget.backgroundDecoration,+ initialFit: widget.shouldCover ? BoxFit.cover : BoxFit.contain,+ // Collage already owns its transform with an outer InteractiveViewer.+ gesturesEnabled: !widget.shouldCover,+ filterQuality: FilterQuality.high,+ gaplessPlayback: true,+ onInteractionLockChanged: _onInteractionLockChanged,+ loadingBuilder: (context, event) {+ // Match the loading state to the image's on-screen size during the+ // hero animation.+ final screenDimensions = MediaQuery.sizeOf(context);+ late final double screenRelativeImageWidth;+ late final double screenRelativeImageHeight;+ final screenWidth = screenDimensions.width;+ final screenHeight = screenDimensions.height;++ final aspectRatioOfScreen = screenWidth / screenHeight;+ final aspectRatioOfImage = _photo.width / _photo.height;++ if (aspectRatioOfImage > aspectRatioOfScreen) {+ screenRelativeImageWidth = screenWidth;+ screenRelativeImageHeight = screenWidth / aspectRatioOfImage;+ } else if (aspectRatioOfImage < aspectRatioOfScreen) {+ screenRelativeImageHeight = screenHeight;+ screenRelativeImageWidth = screenHeight * aspectRatioOfImage;+ } else {+ screenRelativeImageWidth = screenWidth;+ screenRelativeImageHeight = screenHeight;+ }- return Center(- child: SizedBox(- width: screenRelativeImageWidth,- height: screenRelativeImageHeight,- child: widget.isFromMemories- ? const _DelayedLoadingIndicator()- : const EnteLoadingWidget(color: Colors.white),- ),- );- },- ),+ return Center(+ child: SizedBox(+ width: screenRelativeImageWidth,+ height: screenRelativeImageHeight,+ child: widget.isFromMemories+ ? const _DelayedLoadingIndicator()+ : const EnteLoadingWidget(color: Colors.white),+ ),+ );+ },);} else if (_showingThumbnailFallback) {content = Center(@@ -267,7 +237,7 @@ class _ZoomableImageState extends State<ZoomableImage> {}final GestureDragUpdateCallback? verticalDragCallback =- _isZooming || widget.isGuestView+ _interactionLocked || widget.isGuestView? null: (d) => {if (!_isZooming)@@ -554,10 +524,6 @@ class _ZoomableImageState extends State<ZoomableImage> {ImageProvider imageProvider,File file,) async {- await _updatePhotoViewController(- previewImageProvider: _imageProvider,- finalImageProvider: imageProvider,- );setState(() {_imageProvider = imageProvider;_loadedFinalImage = true;@@ -567,48 +533,6 @@ class _ZoomableImageState extends State<ZoomableImage> {widget.onFinalImageLoaded?.call(file);}- Future<void> _updatePhotoViewController({- required ImageProvider? previewImageProvider,- required ImageProvider finalImageProvider,- }) async {- final bool shouldFixPosition =- previewImageProvider != null &&- _isZooming &&- _photoViewController.scale != null;- ImageInfo? finalImageInfo;- if (shouldFixPosition) {- final prevImageInfo = await getImageInfo(previewImageProvider);- finalImageInfo = await getImageInfo(finalImageProvider);- final previousScale = _photoViewController.scale!;- final previousRelativeScale = _initialScale != null && _initialScale! > 0- ? previousScale / _initialScale!- : null;- final scale =- previousScale /- (finalImageInfo.image.width / prevImageInfo.image.width);- final currentPosition = _photoViewController.value.position;- unawaited(_zoomStreamSubscription?.cancel());- _photoViewController = PhotoViewController(- initialPosition: currentPosition,- initialScale: scale,- );- if (previousRelativeScale != null &&- previousRelativeScale.isFinite &&- previousRelativeScale > 0) {- _initialScale = scale / previousRelativeScale;- } else {- _initialScale = null;- }- _subscribeToZoomStream();- // Prevent auto-zoom when the original loads after two double taps.- _scaleStateController.scaleState = PhotoViewScaleState.zoomedIn;- }- final bool canUpdateMetadata = _photo.canEditMetaInfo;- if (finalImageInfo == null && canUpdateMetadata && !_photo.hasDimensions) {- finalImageInfo = await getImageInfo(finalImageProvider);- }- }-bool _isGIF() => _photo.displayName.toLowerCase().endsWith(".gif");bool _isAndroidHeic() => Platform.isAndroid && _isHeic();diff --git a/mobile/apps/photos/pubspec.yaml b/mobile/apps/photos/pubspec.yamlindex 2e30a3a4e2..b2d71e9b09 100644--- a/mobile/apps/photos/pubspec.yaml+++ b/mobile/apps/photos/pubspec.yaml@@ -172,7 +172,6 @@ dependencies:permission_handler: 12.0.1photo_manager: 3.11.0photo_manager_image_provider: 2.2.0- photo_view: 0.15.0pinput: 5.0.2pointycastle: 3.9.1pro_image_editor: 11.23.0diff --git a/mobile/apps/photos/test/ui/viewer/file/zoom_to_tapped_point_test.dart b/mobile/apps/photos/test/ui/viewer/file/zoom_to_tapped_point_test.dartnew file mode 100644index 0000000000..24ed2a6848--- /dev/null+++ b/mobile/apps/photos/test/ui/viewer/file/zoom_to_tapped_point_test.dart@@ -0,0 +1,1338 @@+import "dart:math" as math;+import "dart:ui" as ui;++import "package:flutter/foundation.dart";+import "package:flutter/gestures.dart";+import "package:flutter/material.dart";+import "package:flutter/rendering.dart";+import "package:flutter_test/flutter_test.dart";+import "package:photos/ui/viewer/file/image_zoom_viewer.dart";++const _viewportSize = Size(400, 400);+const _landscapeSize = Size(1200, 800);+const _portraitSize = Size(800, 1200);++void main() {+ TestWidgetsFlutterBinding.ensureInitialized();++ late ui.Image landscapeImage;+ late ui.Image portraitImage;+ late ui.Image largerLandscapeImage;++ setUpAll(() async {+ landscapeImage = await _createTestImage(_landscapeSize);+ portraitImage = await _createTestImage(_portraitSize);+ largerLandscapeImage = await _createTestImage(const Size(2400, 1600));+ });++ setUp(() {+ imageCache+ ..clear()+ ..clearLiveImages();+ });++ tearDown(() {+ imageCache+ ..clear()+ ..clearLiveImages();+ });++ tearDownAll(() {+ landscapeImage.dispose();+ portraitImage.dispose();+ largerLandscapeImage.dispose();+ });++ group("double-tap focal zoom", () {+ testWidgets("a center double tap changes scale without translating", (+ tester,+ ) async {+ final harness = await _pumpViewer(tester, image: landscapeImage);++ await _doubleTap(tester, harness.globalPoint(const Offset(200, 200)));++ _expectTransform(harness.controller, scale: 1.5, offset: Offset.zero);+ expect(harness.controller.stage, ImageZoomStage.covering);+ });++ testWidgets("centers the tapped horizontal area", (tester) async {+ final harness = await _pumpViewer(tester, image: landscapeImage);++ expect(harness.controller.transform, ImageZoomTransform.identity);+ expect(harness.controller.stage, ImageZoomStage.initial);++ await _doubleTap(tester, harness.globalPoint(const Offset(250, 200)));++ _expectTransform(+ harness.controller,+ scale: 1.5,+ offset: const Offset(-75, 0),+ );+ expect(harness.controller.stage, ImageZoomStage.covering);+ });++ testWidgets("centers the tapped vertical area", (tester) async {+ final harness = await _pumpViewer(tester, image: portraitImage);++ await _doubleTap(tester, harness.globalPoint(const Offset(200, 250)));++ _expectTransform(+ harness.controller,+ scale: 1.5,+ offset: const Offset(0, -75),+ );+ });++ testWidgets("clamps a focal point near the image edge", (tester) async {+ final harness = await _pumpViewer(tester, image: landscapeImage);++ await _doubleTap(tester, harness.globalPoint(const Offset(390, 200)));++ _expectTransform(+ harness.controller,+ scale: 1.5,+ offset: const Offset(-100, 0),+ );+ });++ testWidgets("cycles through cover, original size, and initial", (+ tester,+ ) async {+ final harness = await _pumpViewer(tester, image: landscapeImage);+ final center = harness.globalPoint(const Offset(200, 200));++ await _doubleTap(tester, center);+ _expectTransform(harness.controller, scale: 1.5, offset: Offset.zero);+ expect(harness.controller.stage, ImageZoomStage.covering);++ await _doubleTap(tester, center);+ _expectTransform(harness.controller, scale: 3, offset: Offset.zero);+ expect(harness.controller.stage, ImageZoomStage.originalSize);++ await _doubleTap(tester, center);+ expect(harness.controller.transform, ImageZoomTransform.identity);+ expect(harness.controller.stage, ImageZoomStage.initial);+ expect(harness.controller.isZoomed, isFalse);+ });++ testWidgets("a canceled second tap cannot poison the next valid tap", (+ tester,+ ) async {+ final harness = await _pumpViewer(tester, image: landscapeImage);+ final canceledPoint = harness.globalPoint(const Offset(250, 200));++ await tester.tapAt(canceledPoint);+ await tester.pump(const Duration(milliseconds: 50));+ final secondTap = await tester.startGesture(canceledPoint, pointer: 11);+ await tester.pump(const Duration(milliseconds: 16));+ await secondTap.moveBy(const Offset(60, 0));+ await secondTap.up();+ await tester.pump(kDoubleTapTimeout + const Duration(milliseconds: 50));++ expect(harness.controller.transform, ImageZoomTransform.identity);+ expect(harness.controller.stage, ImageZoomStage.initial);++ await _doubleTap(tester, harness.globalPoint(const Offset(150, 200)));++ _expectTransform(+ harness.controller,+ scale: 1.5,+ offset: const Offset(75, 0),+ );+ });++ testWidgets("single taps reach the parent and double taps do not", (+ tester,+ ) async {+ var parentTapCount = 0;+ final harness = await _pumpViewer(+ tester,+ image: landscapeImage,+ onParentTap: () => parentTapCount++,+ );+ final center = harness.globalPoint(const Offset(200, 200));++ await tester.tapAt(center);+ await tester.pump(kDoubleTapTimeout + const Duration(milliseconds: 50));+ expect(parentTapCount, 1);++ await _doubleTap(tester, harness.globalPoint(const Offset(250, 200)));++ expect(parentTapCount, 1);+ _expectTransform(+ harness.controller,+ scale: 1.5,+ offset: const Offset(-75, 0),+ );+ });++ testWidgets("double-tap resets a manual pinch from the baseline", (+ tester,+ ) async {+ final harness = await _pumpViewer(tester, image: landscapeImage);+ final center = harness.globalPoint(const Offset(200, 200));+ final firstFinger = await tester.createGesture(pointer: 21);+ final secondFinger = await tester.createGesture(pointer: 22);++ await firstFinger.down(center - const Offset(20, 0));+ await secondFinger.down(center + const Offset(20, 0));+ await tester.pump();+ await firstFinger.moveTo(center - const Offset(80, 0));+ await secondFinger.moveTo(center + const Offset(80, 0));+ await tester.pump();+ await firstFinger.up();+ await secondFinger.up();+ await tester.pump();++ expect(harness.controller.transform.scale, closeTo(4, 0.01));+ expect(harness.controller.transform.offset.dx, closeTo(0, 0.5));+ expect(harness.controller.transform.offset.dy, closeTo(0, 0.5));+ expect(harness.controller.stage, ImageZoomStage.gesture);++ await _doubleTap(tester, center);++ expect(harness.controller.transform, ImageZoomTransform.identity);+ expect(harness.controller.stage, ImageZoomStage.initial);+ });++ testWidgets("a baseline pinch enables a subsequent one-finger pan", (+ tester,+ ) async {+ final harness = await _pumpViewer(tester, image: landscapeImage);+ final center = harness.globalPoint(const Offset(200, 200));+ final firstFinger = await tester.createGesture(pointer: 23);+ final secondFinger = await tester.createGesture(pointer: 24);++ await firstFinger.down(center - const Offset(40, 0));+ await secondFinger.down(center + const Offset(40, 0));+ await firstFinger.moveTo(center - const Offset(80, 0));+ await secondFinger.moveTo(center + const Offset(80, 0));+ await firstFinger.up();+ await secondFinger.up();+ await tester.pump();++ _expectTransform(harness.controller, scale: 2, offset: Offset.zero);++ await tester.dragFrom(center, const Offset(80, 0));+ await tester.pumpAndSettle();++ expect(harness.controller.transform.offset.dx, greaterThan(20));+ expect(harness.controller.transform.offset.dx, lessThanOrEqualTo(200));+ expect(harness.controller.transform.scale, closeTo(2, 0.01));+ });++ testWidgets("a replacement pointer rebases an active baseline pinch", (+ tester,+ ) async {+ final lockChanges = <bool>[];+ final harness = await _pumpViewer(+ tester,+ image: landscapeImage,+ onInteractionLockChanged: lockChanges.add,+ );+ final center = harness.globalPoint(const Offset(200, 200));+ final firstFinger = await tester.createGesture(pointer: 31);+ final secondFinger = await tester.createGesture(pointer: 32);+ final replacementFinger = await tester.createGesture(pointer: 33);++ await firstFinger.down(center - const Offset(40, 0));+ await secondFinger.down(center + const Offset(40, 0));+ await tester.pump();+ expect(lockChanges, <bool>[true]);++ await firstFinger.moveTo(center - const Offset(60, 0));+ await secondFinger.moveTo(center + const Offset(60, 0));+ await tester.pump();+ _expectTransform(harness.controller, scale: 1.5, offset: Offset.zero);++ await secondFinger.up();+ await tester.pump();+ expect(lockChanges.last, isTrue);++ await replacementFinger.down(center + const Offset(60, 0));+ await tester.pump();+ final beforeReplacementMove = harness.controller.transform;+ _expectTransform(harness.controller, scale: 1.5, offset: Offset.zero);++ await replacementFinger.moveTo(center + const Offset(20, 0));+ await tester.pump();+ expect(+ harness.controller.transform.scale,+ lessThan(beforeReplacementMove.scale),+ );+ expect(harness.controller.transform, ImageZoomTransform.identity);+ expect(lockChanges.last, isTrue);++ await replacementFinger.up();+ await tester.pump();+ expect(lockChanges.last, isTrue);++ await firstFinger.up();+ await tester.pump(const Duration(milliseconds: 50));+ expect(lockChanges, <bool>[true, false]);+ expect(harness.controller.transform, ImageZoomTransform.identity);+ expect(harness.controller.stage, ImageZoomStage.initial);+ });++ testWidgets(+ "animation frames stay bounded and move the focus monotonically",+ (tester) async {+ final harness = await _pumpViewer(tester, image: landscapeImage);+ const localTap = Offset(250, 200);+ await _beginDoubleTap(tester, harness.globalPoint(localTap));++ var previousDistance =+ (localTap - _viewportSize.center(Offset.zero)).distance;+ var sawIntermediateFrame = false;+ for (var frame = 0; frame < 12; frame++) {+ await tester.pump(const Duration(milliseconds: 20));+ final transform = harness.controller.transform;+ _expectFiniteAndInBounds(+ transform,+ viewportSize: _viewportSize,+ fittedImageSize: const Size(400, 800 / 3),+ );+ final transformedFocus = _applyTransform(+ transform,+ point: localTap,+ viewportSize: _viewportSize,+ );+ final distance =+ (transformedFocus - _viewportSize.center(Offset.zero)).distance;+ expect(distance, lessThanOrEqualTo(previousDistance + 0.01));+ previousDistance = distance;+ sawIntermediateFrame |=+ transform.scale > 1.001 && transform.scale < 1.499;+ }++ expect(sawIntermediateFrame, isTrue);+ _expectTransform(+ harness.controller,+ scale: 1.5,+ offset: const Offset(-75, 0),+ );+ expect(previousDistance, closeTo(0, 0.1));+ },+ );++ testWidgets("a pinch interrupts a double-tap animation cleanly", (+ tester,+ ) async {+ final harness = await _pumpViewer(tester, image: landscapeImage);+ final center = harness.globalPoint(const Offset(200, 200));+ await _beginDoubleTap(tester, center);+ await tester.pump(const Duration(milliseconds: 60));+ final interruptedScale = harness.controller.transform.scale;+ expect(interruptedScale, inExclusiveRange(1, 1.5));++ final firstFinger = await tester.createGesture(pointer: 41);+ final secondFinger = await tester.createGesture(pointer: 42);+ await firstFinger.down(center - const Offset(30, 0));+ await secondFinger.down(center + const Offset(30, 0));+ await tester.pump();+ await firstFinger.moveTo(center - const Offset(70, 0));+ await secondFinger.moveTo(center + const Offset(70, 0));+ await tester.pump();+ await firstFinger.up();+ await secondFinger.up();+ await tester.pump();++ final pinchResult = harness.controller.transform;+ expect(pinchResult.scale, greaterThan(interruptedScale + 0.1));+ expect(harness.controller.stage, ImageZoomStage.gesture);+ _expectFiniteAndInBounds(+ pinchResult,+ viewportSize: _viewportSize,+ fittedImageSize: const Size(400, 800 / 3),+ );++ await tester.pump(const Duration(milliseconds: 500));+ _expectSameTransform(harness.controller.transform, pinchResult);+ });+ });++ group("parent gesture handoff", () {+ testWidgets("baseline horizontal drag is handed to PageView", (+ tester,+ ) async {+ final harness = await _pumpPageHarness(tester, image: landscapeImage);++ await tester.dragFrom(+ harness.globalPoint(const Offset(200, 200)),+ const Offset(-300, 0),+ );+ await tester.pumpAndSettle();++ expect(harness.pageController.page, closeTo(2, 0.01));+ expect(harness.zoomController.transform, ImageZoomTransform.identity);+ });++ testWidgets("baseline vertical drag is handed to the outer detector", (+ tester,+ ) async {+ var verticalDragDistance = 0.0;+ final harness = await _pumpViewer(+ tester,+ image: landscapeImage,+ onVerticalDragUpdate: (details) {+ verticalDragDistance += details.delta.dy;+ },+ );++ await tester.dragFrom(+ harness.globalPoint(const Offset(200, 200)),+ const Offset(0, 120),+ );+ await tester.pumpAndSettle();++ // The vertical recognizer consumes the initial 20 logical pixels as slop;+ // every post-slop update must still be delivered to the outer detector.+ expect(verticalDragDistance, closeTo(100, 0.5));+ expect(harness.controller.transform, ImageZoomTransform.identity);+ });++ testWidgets("the second pointer locks interaction before either moves", (+ tester,+ ) async {+ final lockChanges = <bool>[];+ final harness = await _pumpViewer(+ tester,+ image: landscapeImage,+ onInteractionLockChanged: lockChanges.add,+ );+ final center = harness.globalPoint(const Offset(200, 200));+ final firstFinger = await tester.createGesture(pointer: 31);+ final secondFinger = await tester.createGesture(pointer: 32);++ await firstFinger.down(center - const Offset(20, 0));+ expect(lockChanges, isEmpty);+ await secondFinger.down(center + const Offset(20, 0));++ expect(lockChanges, <bool>[true]);+ expect(harness.controller.transform, ImageZoomTransform.identity);++ await firstFinger.up();+ expect(lockChanges.last, isTrue);+ await secondFinger.up();+ await tester.pump(kDoubleTapTimeout + const Duration(milliseconds: 1));+ expect(lockChanges.last, isFalse);+ });++ testWidgets("a baseline long press reaches the parent", (tester) async {+ var longPressCount = 0;+ final harness = await _pumpViewer(+ tester,+ image: landscapeImage,+ onParentLongPress: () => longPressCount++,+ );+ final gesture = await tester.startGesture(+ harness.globalPoint(const Offset(200, 200)),+ pointer: 51,+ );++ await tester.pump(kLongPressTimeout + const Duration(milliseconds: 50));+ expect(longPressCount, 1);+ await gesture.up();+ await tester.pumpAndSettle();++ expect(harness.controller.transform, ImageZoomTransform.identity);+ });++ testWidgets("a zoomed vertical drag on a clamped axis is a no-op", (+ tester,+ ) async {+ var parentVerticalDragDistance = 0.0;+ final harness = await _pumpPageHarness(+ tester,+ image: landscapeImage,+ onVerticalDragUpdate: (details) {+ parentVerticalDragDistance += details.delta.dy;+ },+ );+ final center = harness.globalPoint(const Offset(200, 200));++ await _doubleTap(tester, center);+ final beforeDrag = harness.zoomController.transform;+ _expectTransform(harness.zoomController, scale: 1.5, offset: Offset.zero);+ expect(harness.isLocked, isTrue);++ await tester.dragFrom(center, const Offset(0, 120));+ await tester.pumpAndSettle();++ expect(parentVerticalDragDistance, 0);+ _expectSameTransform(harness.zoomController.transform, beforeDrag);+ expect(harness.zoomController.stage, ImageZoomStage.covering);+ expect(harness.pageController.page, closeTo(1, 0.01));+ });++ testWidgets("reset restores PageView and vertical-dismiss handoff", (+ tester,+ ) async {+ var verticalDragDistance = 0.0;+ final harness = await _pumpPageHarness(+ tester,+ image: landscapeImage,+ onVerticalDragUpdate: (details) {+ verticalDragDistance += details.delta.dy;+ },+ );+ final center = harness.globalPoint(const Offset(200, 200));++ await _doubleTap(tester, center);+ expect(harness.isLocked, isTrue);+ expect(harness.pageController.page, closeTo(1, 0.01));++ await tester.dragFrom(center, const Offset(300, 0));+ await tester.pumpAndSettle();++ expect(harness.pageController.page, closeTo(1, 0.01));+ _expectTransform(+ harness.zoomController,+ scale: 1.5,+ offset: const Offset(100, 0),+ );++ await harness.zoomController.reset(animated: false);+ await tester.pump();+ expect(harness.isLocked, isFalse);+ expect(harness.zoomController.transform, ImageZoomTransform.identity);++ await tester.dragFrom(center, const Offset(0, 120));+ await tester.pumpAndSettle();+ expect(verticalDragDistance, closeTo(100, 0.5));+ expect(harness.pageController.page, closeTo(1, 0.01));+ expect(harness.zoomController.transform, ImageZoomTransform.identity);++ await tester.dragFrom(center, const Offset(-300, 0));+ await tester.pumpAndSettle();++ expect(harness.pageController.page, closeTo(2, 0.01));+ });+ });++ testWidgets("reset during or after a fling cannot be overwritten", (+ tester,+ ) async {+ final harness = await _pumpViewer(tester, image: landscapeImage);+ final center = harness.globalPoint(const Offset(200, 200));++ await _doubleTap(tester, center);+ await tester.flingFrom(center, const Offset(160, 0), 3000);+ await harness.controller.reset(animated: false);+ await tester.pump();+ expect(harness.controller.transform, ImageZoomTransform.identity);++ await tester.pump(const Duration(seconds: 1));+ expect(harness.controller.transform, ImageZoomTransform.identity);+ expect(harness.controller.stage, ImageZoomStage.initial);++ await _doubleTap(tester, center);+ await tester.flingFrom(center, const Offset(-160, 0), 3000);+ await tester.pumpAndSettle();+ expect(harness.controller.isZoomed, isTrue);++ await harness.controller.reset(animated: false);+ await tester.pump(const Duration(seconds: 1));+ expect(harness.controller.transform, ImageZoomTransform.identity);+ expect(harness.controller.stage, ImageZoomStage.initial);+ });++ testWidgets("fling inertia stays bounded and keeps the image visible", (+ tester,+ ) async {+ final controller = ImageZoomController();+ final boundaryKey = GlobalKey();+ final viewportKey = GlobalKey();+ addTearDown(controller.dispose);++ await tester.pumpWidget(+ MaterialApp(+ home: Scaffold(+ backgroundColor: Colors.black,+ body: Center(+ child: RepaintBoundary(+ key: boundaryKey,+ child: SizedBox(+ key: viewportKey,+ width: _viewportSize.width,+ height: _viewportSize.height,+ child: ImageZoomViewer(+ imageProvider: _DeterministicImageProvider(landscapeImage),+ controller: controller,+ loadingBuilder: _emptyLoadingBuilder,+ ),+ ),+ ),+ ),+ ),+ ),+ );+ await tester.pump();++ final center = tester.getCenter(find.byKey(viewportKey));+ await _doubleTap(tester, center);+ _expectTransform(controller, scale: 1.5, offset: Offset.zero);+ expect(+ await tester.runAsync(() => _centerPixel(find.byKey(boundaryKey))),+ const Color(0xFFFFFFFF),+ );++ var transformNotifications = 0;+ void onTransformChanged() => transformNotifications++;+ controller.addListener(onTransformChanged);+ addTearDown(() => controller.removeListener(onTransformChanged));++ await tester.flingFrom(center, const Offset(0, 220), 3000);+ await tester.pump(const Duration(milliseconds: 500));++ _expectTransform(controller, scale: 1.5, offset: Offset.zero);+ expect(transformNotifications, 0);+ expect(+ await tester.runAsync(() => _centerPixel(find.byKey(boundaryKey))),+ const Color(0xFFFFFFFF),+ );++ transformNotifications = 0;+ await tester.flingFrom(center, const Offset(220, 0), 3000);+ for (var index = 0; index < 12; index++) {+ await tester.pump(const Duration(milliseconds: 250));+ expect(+ await tester.runAsync(() => _centerPixel(find.byKey(boundaryKey))),+ const Color(0xFFFFFFFF),+ );+ }++ _expectTransform(controller, scale: 1.5, offset: const Offset(100, 0));+ expect(transformNotifications, greaterThan(0));+ });++ testWidgets("orientation change preserves a valid normalized focus", (+ tester,+ ) async {+ final controller = ImageZoomController();+ addTearDown(controller.dispose);+ final viewportKey = GlobalKey();+ var viewportSize = const Size(400, 600);+ late StateSetter setHostState;++ await tester.pumpWidget(+ MaterialApp(+ home: Scaffold(+ body: Center(+ child: StatefulBuilder(+ builder: (context, setState) {+ setHostState = setState;+ return SizedBox(+ key: viewportKey,+ width: viewportSize.width,+ height: viewportSize.height,+ child: ImageZoomViewer(+ imageProvider: _DeterministicImageProvider(landscapeImage),+ controller: controller,+ loadingBuilder: _emptyLoadingBuilder,+ ),+ );+ },+ ),+ ),+ ),+ ),+ );+ await tester.pump();+ var viewportTopLeft = tester.getTopLeft(find.byKey(viewportKey));+ await _doubleTap(tester, viewportTopLeft + const Offset(250, 300));+ _expectTransform(controller, scale: 2.25, offset: const Offset(-112.5, 0));++ setHostState(() => viewportSize = const Size(600, 400));+ await tester.pump();+ await tester.pump();+ viewportTopLeft = tester.getTopLeft(find.byKey(viewportKey));++ final transform = controller.transform;+ expect(transform.scale, closeTo(2.25, 0.01));+ expect(controller.stage, ImageZoomStage.gesture);+ _expectFiniteAndInBounds(+ transform,+ viewportSize: viewportSize,+ fittedImageSize: viewportSize,+ );+ // The old normalized x focus was 0.625. It remains centered after the+ // fitted image changes from 400x266.67 to 600x400.+ final transformedFocus = _applyTransform(+ transform,+ point: const Offset(375, 200),+ viewportSize: viewportSize,+ );+ expect(transformedFocus.dx, closeTo(300, 0.5));+ expect(transformedFocus.dy, closeTo(200, 0.5));+ final globalFocus = viewportTopLeft + transformedFocus;+ final globalViewportCenter = tester.getCenter(find.byKey(viewportKey));+ expect(globalFocus.dx, closeTo(globalViewportCenter.dx, 0.01));+ expect(globalFocus.dy, closeTo(globalViewportCenter.dy, 0.01));+ });++ testWidgets(+ "orientation change cancels an active animation without a stale resume",+ (tester) async {+ final controller = ImageZoomController();+ addTearDown(controller.dispose);+ final viewportKey = GlobalKey();+ final imageProvider = _DeterministicImageProvider(landscapeImage);+ final lockChanges = <bool>[];+ var viewportSize = const Size(400, 600);+ late StateSetter setHostState;++ await tester.pumpWidget(+ MaterialApp(+ home: Scaffold(+ body: Center(+ child: StatefulBuilder(+ builder: (context, setState) {+ setHostState = setState;+ return SizedBox(+ key: viewportKey,+ width: viewportSize.width,+ height: viewportSize.height,+ child: ImageZoomViewer(+ imageProvider: imageProvider,+ controller: controller,+ loadingBuilder: _emptyLoadingBuilder,+ onInteractionLockChanged: lockChanges.add,+ ),+ );+ },+ ),+ ),+ ),+ ),+ );+ await tester.pump();++ final initialTopLeft = tester.getTopLeft(find.byKey(viewportKey));+ await _beginDoubleTap(tester, initialTopLeft + const Offset(250, 300));+ await tester.pump(const Duration(milliseconds: 60));++ final beforeRotation = controller.transform;+ expect(beforeRotation.scale, inExclusiveRange(1, 2.25));+ expect(lockChanges, contains(true));+ final oldCenter = viewportSize.center(Offset.zero);+ final oldFittedRect = Alignment.center.inscribe(+ const Size(400, 800 / 3),+ Offset.zero & viewportSize,+ );+ final oldSceneFocus =+ oldCenter - beforeRotation.offset / beforeRotation.scale;+ final normalizedFocus = Offset(+ (oldSceneFocus.dx - oldFittedRect.left) / oldFittedRect.width,+ (oldSceneFocus.dy - oldFittedRect.top) / oldFittedRect.height,+ );++ setHostState(() => viewportSize = const Size(600, 400));+ await tester.pump();+ await tester.pump();++ final afterRotation = controller.transform;+ expect(afterRotation.scale, closeTo(beforeRotation.scale, 0.01));+ expect(afterRotation.scale, lessThan(2.25));+ expect(controller.stage, ImageZoomStage.gesture);+ _expectFiniteAndInBounds(+ afterRotation,+ viewportSize: viewportSize,+ fittedImageSize: viewportSize,+ );+ final newSceneFocus = Offset(+ normalizedFocus.dx * viewportSize.width,+ normalizedFocus.dy * viewportSize.height,+ );+ final transformedFocus = _applyTransform(+ afterRotation,+ point: newSceneFocus,+ viewportSize: viewportSize,+ );+ expect(transformedFocus.dx, closeTo(viewportSize.width / 2, 0.5));+ expect(transformedFocus.dy, closeTo(viewportSize.height / 2, 0.5));+ // The parent remains locked because the preserved transform is zoomed,+ // even though the old programmatic animation has been canceled.+ expect(lockChanges.last, isTrue);+ final lockChangeCountAfterRotation = lockChanges.length;++ await tester.pump(const Duration(milliseconds: 500));++ _expectSameTransform(controller.transform, afterRotation);+ expect(controller.stage, ImageZoomStage.gesture);+ expect(lockChanges, hasLength(lockChangeCountAfterRotation));+ },+ );++ testWidgets("one controller cannot be attached to two viewers", (+ tester,+ ) async {+ final controller = ImageZoomController();+ addTearDown(controller.dispose);+ final imageProvider = _DeterministicImageProvider(landscapeImage);++ await tester.pumpWidget(+ Directionality(+ textDirection: TextDirection.ltr,+ child: Row(+ children: [+ for (var index = 0; index < 2; index++)+ SizedBox(+ width: 200,+ height: 200,+ child: ImageZoomViewer(+ imageProvider: imageProvider,+ controller: controller,+ loadingBuilder: _emptyLoadingBuilder,+ ),+ ),+ ],+ ),+ ),+ );++ expect(tester.takeException(), isA<StateError>());+ await tester.pumpWidget(const SizedBox.shrink());+ });++ testWidgets(+ "cover baseline is semantic identity when collage owns gestures",+ (tester) async {+ final lockChanges = <bool>[];+ final harness = await _pumpViewer(+ tester,+ image: landscapeImage,+ initialFit: BoxFit.cover,+ gesturesEnabled: false,+ onInteractionLockChanged: lockChanges.add,+ );+ final center = harness.globalPoint(const Offset(200, 200));++ expect(harness.controller.transform, ImageZoomTransform.identity);+ expect(harness.controller.stage, ImageZoomStage.initial);+ expect(harness.controller.isZoomed, isFalse);++ await _doubleTap(tester, center);+ final firstFinger = await tester.createGesture(pointer: 61);+ final secondFinger = await tester.createGesture(pointer: 62);+ await firstFinger.down(center - const Offset(20, 0));+ await secondFinger.down(center + const Offset(20, 0));+ await firstFinger.moveTo(center - const Offset(80, 0));+ await secondFinger.moveTo(center + const Offset(80, 0));+ await firstFinger.up();+ await secondFinger.up();+ await tester.pump();++ expect(harness.controller.transform, ImageZoomTransform.identity);+ expect(harness.controller.stage, ImageZoomStage.initial);+ expect(lockChanges, isEmpty);+ },+ );++ testWidgets("Hero bounds match the fitted image instead of the viewport", (+ tester,+ ) async {+ final harness = await _pumpViewer(+ tester,+ image: landscapeImage,+ heroTag: "fitted-image-hero",+ );++ final viewportRect = Rect.fromLTWH(+ harness.viewportTopLeft.dx,+ harness.viewportTopLeft.dy,+ _viewportSize.width,+ _viewportSize.height,+ );+ final heroRect = tester.getRect(find.byType(Hero));++ expect(heroRect.width, closeTo(400, 0.01));+ expect(heroRect.height, closeTo(800 / 3, 0.01));+ expect(heroRect.center, viewportRect.center);+ expect(heroRect, isNot(viewportRect));+ });++ testWidgets(+ "same-aspect provider replacement preserves the visible transform",+ (tester) async {+ final controller = ImageZoomController();+ addTearDown(controller.dispose);+ final viewportKey = GlobalKey();+ final firstProvider = _DeterministicImageProvider(landscapeImage);+ final replacementProvider = _DeterministicImageProvider(+ largerLandscapeImage,+ );+ ImageProvider currentProvider = firstProvider;+ late StateSetter setHostState;++ await tester.pumpWidget(+ MaterialApp(+ home: Scaffold(+ body: Center(+ child: StatefulBuilder(+ builder: (context, setState) {+ setHostState = setState;+ return SizedBox(+ key: viewportKey,+ width: _viewportSize.width,+ height: _viewportSize.height,+ child: ImageZoomViewer(+ imageProvider: currentProvider,+ controller: controller,+ loadingBuilder: _emptyLoadingBuilder,+ ),+ );+ },+ ),+ ),+ ),+ ),+ );+ await tester.pump();++ final viewportTopLeft = tester.getTopLeft(find.byKey(viewportKey));+ await _doubleTap(tester, viewportTopLeft + const Offset(250, 200));+ _expectTransform(controller, scale: 1.5, offset: const Offset(-75, 0));++ setHostState(() => currentProvider = replacementProvider);+ await tester.pump();+ await tester.pump();++ _expectTransform(controller, scale: 1.5, offset: const Offset(-75, 0));+ expect(controller.stage, ImageZoomStage.gesture);+ },+ );++ testWidgets(+ "same-aspect provider replacement during animation stays stable",+ (tester) async {+ final controller = ImageZoomController();+ addTearDown(controller.dispose);+ final viewportKey = GlobalKey();+ ImageProvider currentProvider = _DeterministicImageProvider(+ landscapeImage,+ );+ late StateSetter setHostState;++ await tester.pumpWidget(+ MaterialApp(+ home: Scaffold(+ body: Center(+ child: StatefulBuilder(+ builder: (context, setState) {+ setHostState = setState;+ return SizedBox(+ key: viewportKey,+ width: _viewportSize.width,+ height: _viewportSize.height,+ child: ImageZoomViewer(+ imageProvider: currentProvider,+ controller: controller,+ loadingBuilder: _emptyLoadingBuilder,+ ),+ );+ },+ ),+ ),+ ),+ ),+ );+ await tester.pump();++ final tapPoint =+ tester.getTopLeft(find.byKey(viewportKey)) + const Offset(250, 200);+ await _beginDoubleTap(tester, tapPoint);+ await tester.pump(const Duration(milliseconds: 60));+ final beforeReplacement = controller.transform;+ expect(beforeReplacement.scale, inExclusiveRange(1, 1.5));++ setHostState(() {+ currentProvider = _DeterministicImageProvider(largerLandscapeImage);+ });+ await tester.pump();++ _expectSameTransform(controller.transform, beforeReplacement);+ _expectFiniteAndInBounds(+ controller.transform,+ viewportSize: _viewportSize,+ fittedImageSize: const Size(400, 800 / 3),+ );++ await tester.pumpAndSettle();++ _expectTransform(controller, scale: 1.5, offset: const Offset(-75, 0));+ expect(controller.stage, ImageZoomStage.gesture);++ await _doubleTap(tester, tapPoint);+ expect(controller.transform, ImageZoomTransform.identity);+ expect(controller.stage, ImageZoomStage.initial);+ },+ );++ testWidgets("dimension probes detach across replacement and disposal", (+ tester,+ ) async {+ final firstProvider = _TrackingImageProvider(landscapeImage);+ final replacementProvider = _TrackingImageProvider(largerLandscapeImage);+ ImageProvider currentProvider = firstProvider;+ late StateSetter setHostState;++ await tester.pumpWidget(+ MaterialApp(+ home: Scaffold(+ body: StatefulBuilder(+ builder: (context, setState) {+ setHostState = setState;+ return ImageZoomViewer(+ imageProvider: currentProvider,+ loadingBuilder: _emptyLoadingBuilder,+ );+ },+ ),+ ),+ ),+ );+ await tester.pump();++ // One listener belongs to ImageZoomViewer's dimension probe and one to the+ // Image widget that paints the frame. Cache bookkeeping is already settled.+ expect(firstProvider.completer.activeListenerCount, 2);++ setHostState(() => currentProvider = replacementProvider);+ await tester.pump();+ await tester.pump();++ expect(firstProvider.completer.activeListenerCount, 0);+ expect(replacementProvider.completer.activeListenerCount, 2);++ await tester.pumpWidget(const SizedBox.shrink());+ await tester.pump();++ expect(replacementProvider.completer.activeListenerCount, 0);+ expect(+ firstProvider.completer.removeCount,+ firstProvider.completer.addCount,+ );+ expect(+ replacementProvider.completer.removeCount,+ replacementProvider.completer.addCount,+ );+ });+}++Future<_ViewerHarness> _pumpViewer(+ WidgetTester tester, {+ required ui.Image image,+ VoidCallback? onParentTap,+ VoidCallback? onParentLongPress,+ GestureDragUpdateCallback? onVerticalDragUpdate,+ ValueChanged<bool>? onInteractionLockChanged,+ BoxFit initialFit = BoxFit.contain,+ bool gesturesEnabled = true,+ Object? heroTag,+}) async {+ final viewportKey = GlobalKey();+ final controller = ImageZoomController();+ addTearDown(controller.dispose);++ await tester.pumpWidget(+ MaterialApp(+ home: Scaffold(+ body: Center(+ child: GestureDetector(+ onTap: onParentTap,+ onLongPress: onParentLongPress,+ onVerticalDragUpdate: onVerticalDragUpdate,+ child: SizedBox(+ key: viewportKey,+ width: _viewportSize.width,+ height: _viewportSize.height,+ child: ImageZoomViewer(+ imageProvider: _DeterministicImageProvider(image),+ controller: controller,+ initialFit: initialFit,+ gesturesEnabled: gesturesEnabled,+ heroTag: heroTag,+ loadingBuilder: _emptyLoadingBuilder,+ onInteractionLockChanged: onInteractionLockChanged,+ ),+ ),+ ),+ ),+ ),+ ),+ );+ await tester.pump();++ return _ViewerHarness(+ controller: controller,+ viewportTopLeft: tester.getTopLeft(find.byKey(viewportKey)),+ );+}++Future<_PageHarness> _pumpPageHarness(+ WidgetTester tester, {+ required ui.Image image,+ GestureDragUpdateCallback? onVerticalDragUpdate,+}) async {+ final viewportKey = GlobalKey();+ final zoomController = ImageZoomController();+ final pageController = PageController(initialPage: 1);+ final imageProvider = _DeterministicImageProvider(image);+ addTearDown(zoomController.dispose);+ addTearDown(pageController.dispose);+ var isLocked = false;+ late StateSetter setHostState;++ await tester.pumpWidget(+ MaterialApp(+ home: Scaffold(+ body: Center(+ child: StatefulBuilder(+ builder: (context, setState) {+ setHostState = setState;+ return SizedBox(+ key: viewportKey,+ width: _viewportSize.width,+ height: _viewportSize.height,+ child: PageView.builder(+ controller: pageController,+ physics: isLocked+ ? const NeverScrollableScrollPhysics()+ : const ClampingScrollPhysics(),+ itemCount: 3,+ itemBuilder: (context, index) {+ if (index != 1) {+ return ColoredBox(+ color: index == 0 ? Colors.red : Colors.blue,+ );+ }+ return GestureDetector(+ // Match ZoomableImage: vertical dismissal is removed while+ // ImageZoomViewer reports an interaction lock.+ onVerticalDragUpdate: isLocked+ ? null+ : onVerticalDragUpdate,+ child: ImageZoomViewer(+ imageProvider: imageProvider,+ controller: zoomController,+ loadingBuilder: _emptyLoadingBuilder,+ onInteractionLockChanged: (value) {+ if (isLocked == value) return;+ setHostState(() => isLocked = value);+ },+ ),+ );+ },+ ),+ );+ },+ ),+ ),+ ),+ ),+ );+ await tester.pump();++ return _PageHarness(+ zoomController: zoomController,+ pageController: pageController,+ viewportTopLeft: tester.getTopLeft(find.byKey(viewportKey)),+ isLocked: () => isLocked,+ );+}++Widget _emptyLoadingBuilder(BuildContext context, ImageChunkEvent? progress) =>+ const SizedBox.shrink();++Future<void> _doubleTap(WidgetTester tester, Offset globalPosition) async {+ await _beginDoubleTap(tester, globalPosition);+ await tester.pumpAndSettle();+}++Future<void> _beginDoubleTap(WidgetTester tester, Offset globalPosition) async {+ await tester.tapAt(globalPosition);+ await tester.pump(const Duration(milliseconds: 50));+ await tester.tapAt(globalPosition);+ await tester.pump();+}++void _expectTransform(+ ImageZoomController controller, {+ required double scale,+ required Offset offset,+}) {+ expect(controller.transform.scale, closeTo(scale, 0.01));+ expect(controller.transform.offset.dx, closeTo(offset.dx, 0.5));+ expect(controller.transform.offset.dy, closeTo(offset.dy, 0.5));+}++void _expectSameTransform(+ ImageZoomTransform actual,+ ImageZoomTransform expected,+) {+ expect(actual.scale, closeTo(expected.scale, 0.01));+ expect(actual.offset.dx, closeTo(expected.offset.dx, 0.5));+ expect(actual.offset.dy, closeTo(expected.offset.dy, 0.5));+}++void _expectFiniteAndInBounds(+ ImageZoomTransform transform, {+ required Size viewportSize,+ required Size fittedImageSize,+}) {+ expect(transform.scale.isFinite, isTrue);+ expect(transform.scale, greaterThan(0));+ expect(transform.offset.dx.isFinite, isTrue);+ expect(transform.offset.dy.isFinite, isTrue);++ final maxOffsetX = math.max(+ 0.0,+ (fittedImageSize.width * transform.scale - viewportSize.width) / 2,+ );+ final maxOffsetY = math.max(+ 0.0,+ (fittedImageSize.height * transform.scale - viewportSize.height) / 2,+ );+ expect(+ transform.offset.dx,+ inInclusiveRange(-maxOffsetX - 0.01, maxOffsetX + 0.01),+ );+ expect(+ transform.offset.dy,+ inInclusiveRange(-maxOffsetY - 0.01, maxOffsetY + 0.01),+ );+}++Offset _applyTransform(+ ImageZoomTransform transform, {+ required Offset point,+ required Size viewportSize,+}) {+ final center = viewportSize.center(Offset.zero);+ return center + transform.offset + (point - center) * transform.scale;+}++Future<ui.Image> _createTestImage(Size size) async {+ final recorder = ui.PictureRecorder();+ final canvas = ui.Canvas(recorder);+ canvas.drawRect(+ Offset.zero & size,+ ui.Paint()..color = const Color(0xFFFFFFFF),+ );+ final picture = recorder.endRecording();+ final image = await picture.toImage(size.width.toInt(), size.height.toInt());+ picture.dispose();+ return image;+}++Future<Color> _centerPixel(Finder boundaryFinder) async {+ final boundary =+ boundaryFinder.evaluate().single.renderObject! as RenderRepaintBoundary;+ final image = await boundary.toImage();+ final data = await image.toByteData(format: ui.ImageByteFormat.rawRgba);+ final x = image.width ~/ 2;+ final y = image.height ~/ 2;+ final offset = (y * image.width + x) * 4;+ final color = Color.fromARGB(+ data!.getUint8(offset + 3),+ data.getUint8(offset),+ data.getUint8(offset + 1),+ data.getUint8(offset + 2),+ );+ image.dispose();+ return color;+}++class _DeterministicImageProvider+ extends ImageProvider<_DeterministicImageProvider> {+ const _DeterministicImageProvider(this.image);++ final ui.Image image;++ @override+ Future<_DeterministicImageProvider> obtainKey(+ ImageConfiguration configuration,+ ) => SynchronousFuture<_DeterministicImageProvider>(this);++ @override+ ImageStreamCompleter loadImage(+ _DeterministicImageProvider key,+ ImageDecoderCallback decode,+ ) => OneFrameImageStreamCompleter(+ SynchronousFuture<ImageInfo>(ImageInfo(image: image.clone())),+ );+}++class _TrackingImageProvider extends ImageProvider<_TrackingImageProvider> {+ _TrackingImageProvider(ui.Image image)+ : completer = _TrackingImageStreamCompleter(image);++ final _TrackingImageStreamCompleter completer;++ @override+ Future<_TrackingImageProvider> obtainKey(ImageConfiguration configuration) =>+ SynchronousFuture<_TrackingImageProvider>(this);++ @override+ ImageStreamCompleter loadImage(+ _TrackingImageProvider key,+ ImageDecoderCallback decode,+ ) => completer;+}++class _TrackingImageStreamCompleter extends OneFrameImageStreamCompleter {+ _TrackingImageStreamCompleter(ui.Image image)+ : super(SynchronousFuture<ImageInfo>(ImageInfo(image: image.clone())));++ final List<ImageStreamListener> _activeListeners = <ImageStreamListener>[];+ int addCount = 0;+ int removeCount = 0;++ int get activeListenerCount => _activeListeners.length;++ @override+ void addListener(ImageStreamListener listener) {+ addCount++;+ _activeListeners.add(listener);+ super.addListener(listener);+ }++ @override+ void removeListener(ImageStreamListener listener) {+ super.removeListener(listener);+ if (_activeListeners.remove(listener)) {+ removeCount++;+ }+ }+}++class _ViewerHarness {+ const _ViewerHarness({+ required this.controller,+ required this.viewportTopLeft,+ });++ final ImageZoomController controller;+ final Offset viewportTopLeft;++ Offset globalPoint(Offset localPoint) => viewportTopLeft + localPoint;+}++class _PageHarness {+ const _PageHarness({+ required this.zoomController,+ required this.pageController,+ required this.viewportTopLeft,+ required bool Function() isLocked,+ }) : _isLocked = isLocked;++ final ImageZoomController zoomController;+ final PageController pageController;+ final Offset viewportTopLeft;+ final bool Function() _isLocked;++ bool get isLocked => _isLocked();++ Offset globalPoint(Offset localPoint) => viewportTopLeft + localPoint;+}diff --git a/mobile/pubspec.lock b/mobile/pubspec.lockindex b667a37cb4..109b8cae9a 100644--- a/mobile/pubspec.lock+++ b/mobile/pubspec.lock@@ -2084,14 +2084,6 @@ packages:url: "https://pub.dev"source: hostedversion: "2.2.0"- photo_view:- dependency: transitive- description:- name: photo_view- sha256: "1fc3d970a91295fbd1364296575f854c9863f225505c28c46e0a03e48960c75e"- url: "https://pub.dev"- source: hosted- version: "0.15.0"pinput:dependency: transitivedescription: