update EnhancedZoom implementation

Fling gesture target is acquired before animation ends to have visible image section while animation is in progress

Author: SmartToolFactory

image/src/main/java/com/smarttoolfactory/image/zoom/EnhancedZoomStateImpl.kt

@@ -81,24 +81,23 @@ open class EnhancedZoomState constructor(
         )
 
     private fun calculateRectBounds(): IntRect {
-
         val width = size.width
         val height = size.height
+
+        val bounds = getBounds()
         val zoom = animatableZoom.targetValue
-        val panX = animatablePanX.targetValue
-        val panY = animatablePanY.targetValue
+        val panX = animatablePanX.targetValue.coerceIn(-bounds.x, bounds.x)
+        val panY = animatablePanY.targetValue.coerceIn(-bounds.y, bounds.y)
 
         // Offset for interpolating offset from (imageWidth/2,-imageWidth/2) interval
         // to (0, imageWidth) interval when
         // transform origin is TransformOrigin(0.5f,0.5f)
         val horizontalCenterOffset = width * (zoom - 1) / 2f
         val verticalCenterOffset = height * (zoom - 1) / 2f
 
-        val bounds = getBounds()
-
-        val offsetX = (horizontalCenterOffset - panX.coerceIn(-bounds.x, bounds.x))
+        val offsetX = (horizontalCenterOffset - panX)
             .coerceAtLeast(0f) / zoom
-        val offsetY = (verticalCenterOffset - panY.coerceIn(-bounds.y, bounds.y))
+        val offsetY = (verticalCenterOffset - panY)
             .coerceAtLeast(0f) / zoom
 
         val offset = Offset(offsetX, offsetY)
@@ -167,18 +166,25 @@ open class BaseEnhancedZoomState constructor(
 
     open suspend fun onGestureStart() = coroutineScope {}
 
-    open suspend fun onGestureEnd(onFinish: () -> Unit) {
+    open suspend fun onGestureEnd(onBoundsCalculated: () -> Unit) {
 
         // Gesture end might be called after second tap and we don't want to fling
         // or animate back to valid bounds when doubled tapped
         if (!doubleTapped) {
+
             if (fling && zoom > 1) {
-                fling()
+                fling {
+                    // We get target value on start instead of updating bounds after
+                    // gesture has finished
+                    onBoundsCalculated()
+                }
+            } else {
+                onBoundsCalculated()
             }
+
             if (moveToBounds) {
                 resetToValidBounds()
             }
-            onFinish()
         }
     }
 
@@ -224,21 +230,28 @@ open class BaseEnhancedZoomState constructor(
      * Create a fling gesture when user removes finger from scree to have continuous movement
      * until [velocityTracker] speed reached to lower bound
      */
-    private suspend fun fling() = coroutineScope {
+    private suspend fun fling(onFlingStart: () -> Unit) = coroutineScope {
         val velocityTracker = velocityTracker.calculateVelocity()
         val velocity = Offset(velocityTracker.x, velocityTracker.y)
+        var flingStarted = false
 
+        val bounds = getBounds()
         launch {
             animatablePanX.animateDecay(
                 velocity.x,
-                exponentialDecay(
-                    absVelocityThreshold = 20f
-                )
+                exponentialDecay(absVelocityThreshold = 20f),
+                block = {
+                    // This callback returns target value of fling gesture initially
+                    if (!flingStarted) {
+                        onFlingStart()
+                        flingStarted = true
+                    }
+                }
             )
         }
 
         launch {
-            animatablePanY.animateDecay(
+            val animationResult = animatablePanY.animateDecay(
                 velocity.y,
                 exponentialDecay(
                     absVelocityThreshold = 20f

image/src/main/java/com/smarttoolfactory/image/zoom/ZoomStateImpl.kt

@@ -136,26 +136,26 @@ open class ZoomState(
     }
 
     internal suspend fun animatePanXto(panX: Float) {
-        if (pannable) {
+        if (pannable && pan.x != panX) {
             animatablePanX.animateTo(panX)
         }
     }
 
     internal suspend fun animatePanYto(panY: Float) {
-        if (pannable) {
+        if (pannable && pan.y != panY) {
             animatablePanY.animateTo(panY)
         }
     }
 
     internal suspend fun animateZoomTo(zoom: Float) {
-        if (zoomable) {
+        if (zoomable && this.zoom != zoom) {
             val newZoom = zoom.coerceIn(zoomMin, zoomMax)
             animatableZoom.animateTo(newZoom)
         }
     }
 
     internal suspend fun animateRotationTo(rotation: Float) {
-        if (rotatable) {
+        if (rotatable && this.rotation != rotation) {
             animatableRotation.animateTo(rotation)
         }
     }