Skip to content

armgit / ente

Public Imported from GitHub
0

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

[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.md
new file mode 100644
index 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.dart
index 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.dart
index 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.dart
new file mode 100644
index 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.dart
index 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.dart
index 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.dart
index 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);
}
@override
void 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.yaml
index 2e30a3a4e2..b2d71e9b09 100644
--- a/mobile/apps/photos/pubspec.yaml
+++ b/mobile/apps/photos/pubspec.yaml
@@ -172,7 +172,6 @@ dependencies:
permission_handler: 12.0.1
photo_manager: 3.11.0
photo_manager_image_provider: 2.2.0
- photo_view: 0.15.0
pinput: 5.0.2
pointycastle: 3.9.1
pro_image_editor: 11.23.0
diff --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.dart
new file mode 100644
index 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.lock
index b667a37cb4..109b8cae9a 100644
--- a/mobile/pubspec.lock
+++ b/mobile/pubspec.lock
@@ -2084,14 +2084,6 @@ packages:
url: "https://pub.dev"
source: hosted
version: "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: transitive
description: