Camera Zoom Fixes (#850)

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>

Author: 3 people

CHANGELOG.md

@@ -1,3 +1,10 @@
+## [57.1.1]
+- [iOS][Camera] Fixed focus locking on startup by enabling continuous autofocus and auto-exposure when camera session starts
+- [iOS][Camera] Fixed tap-to-focus permanently locking focus by returning to continuous autofocus after one-shot focus completes
+- [iOS][Camera] Fixed zoom not triggering refocus by re-engaging continuous autofocus after pinch-to-zoom and slider zoom changes
+- [Android][Camera] Fixed zoom not triggering refocus by starting a new focus metering action after pinch-to-zoom
+- [Android][Camera] Fixed tap-to-focus indicator appearing at wrong position by using view-relative touch coordinates and correcting for preview translation offset
+
 ## [57.1.0]
 - [LayoutDiagnostics] Added runtime layout diagnostics API for profiling measure/arrange counts per element type. Includes a floating overlay visible over modals and bottom sheets, automatic snapshot capture during page and bottom sheet lifecycle, per-instance thrashing detection, and JSON export.
 

src/library/DIPS.Mobile.UI/API/Camera/Preview/Android/PreviewView/PreviewViewHandler.cs

@@ -21,26 +21,32 @@ protected override void ConnectHandler(AndroidX.Camera.View.PreviewView platform
             scaleFactor =>
         {
             OnScaled?.Invoke(scaleFactor);
+        }, () =>
+        {
+            OnScaleEnded?.Invoke();
         }, (x, y) =>
         {
             OnTapped?.Invoke(x, y);
         }));
     }
 
     public event Action<float>? OnScaled;
+    public event Action? OnScaleEnded;
     public event Action<float, float>? OnTapped;
 }
 
 internal class TouchScaleListener : Object, View.IOnTouchListener, ScaleGestureDetector.IOnScaleGestureListener
 {
     private readonly Action<float>? m_onScale;
+    private readonly Action? m_onScaleEnd;
     private readonly Action<float, float>? m_onTouch;
     private readonly ScaleGestureDetector m_scaleGestureDetector;
     private bool m_ignoreTouchUp;
 
-    public TouchScaleListener(Action<float>? onScale, Action<float, float>? onTouch)
+    public TouchScaleListener(Action<float>? onScale, Action? onScaleEnd, Action<float, float>? onTouch)
     {
         m_onScale = onScale;
+        m_onScaleEnd = onScaleEnd;
         m_onTouch = onTouch;
 
         m_scaleGestureDetector = new ScaleGestureDetector(Application.Context, this);
@@ -56,7 +62,7 @@ public bool OnTouch(View? v, MotionEvent? e)
         if (e.Action == MotionEventActions.Up)
         {
             if(!m_ignoreTouchUp)
-                m_onTouch?.Invoke(e.RawX, e.RawY);
+                m_onTouch?.Invoke(e.GetX(), e.GetY());
 
             m_ignoreTouchUp = false;
         }
@@ -76,5 +82,8 @@ public bool OnScaleBegin(ScaleGestureDetector detector)
         return true;
     }
 
-    public void OnScaleEnd(ScaleGestureDetector detector) {}
+    public void OnScaleEnd(ScaleGestureDetector detector)
+    {
+        m_onScaleEnd?.Invoke();
+    }
 }

src/library/DIPS.Mobile.UI/API/Camera/Preview/CameraPreview.cs

@@ -167,11 +167,7 @@ internal void AddFocusIndicator(float percentX, float percentY)
         m_indicatorWrapper.TranslationX = percentX * PreviewView.Width - m_indicator.WidthRequest / 2;
         m_indicatorWrapper.TranslationY = percentY * PreviewView.Height;
 
-#if __IOS__
         m_indicatorWrapper.TranslationY -= (m_indicator.HeightRequest / 2) - PreviewView.TranslationY;
-#else
-        m_indicatorWrapper.TranslationY -= m_indicator.HeightRequest / 1.25f;
-#endif
 
         m_indicator.ScaleTo(1, easing: Easing.SpringOut);
         m_indicator.FadeTo(1);

src/library/DIPS.Mobile.UI/API/Camera/Preview/iOS/PreviewView.cs

@@ -120,6 +120,25 @@ private void PinchToZoom(UIPinchGestureRecognizer pinchRecognizer, AVCaptureDevi
                 }
             }
         }
+        else if (pinchRecognizer.State is UIGestureRecognizerState.Ended or UIGestureRecognizerState.Cancelled)
+        {
+            // Re-trigger continuous autofocus after zoom change so the camera
+            // adjusts focus to the new effective distance.
+            if (captureDevice.LockForConfiguration(out _))
+            {
+                try
+                {
+                    if (captureDevice.IsFocusModeSupported(AVCaptureFocusMode.ContinuousAutoFocus))
+                    {
+                        captureDevice.FocusMode = AVCaptureFocusMode.ContinuousAutoFocus;
+                    }
+                }
+                finally
+                {
+                    captureDevice.UnlockForConfiguration();
+                }
+            }
+        }
     }
 
     internal void RemovePinchToZoom()
@@ -286,6 +305,10 @@ internal void SetFocusPoint(double x, double y, AVCaptureDevice captureDevice, o
                 {
                     captureDevice.UnlockForConfiguration();
                 }
+                
+                // Return to continuous autofocus after one-shot focus completes,
+                // so the camera can re-adjust when distance changes.
+                ObserveFocusAndRestoreContinuous(captureDevice);
             }
             else
             {
@@ -296,11 +319,53 @@ internal void SetFocusPoint(double x, double y, AVCaptureDevice captureDevice, o
             }
         }
     }
+    
+    private IDisposable? m_focusObserver;
+    
+    private void ObserveFocusAndRestoreContinuous(AVCaptureDevice captureDevice)
+    {
+        m_focusObserver?.Dispose();
+        m_focusObserver = captureDevice.AddObserver(
+            "adjustingFocus",
+            NSKeyValueObservingOptions.New,
+            change =>
+            {
+                if (change?.NewValue is NSNumber adjusting && !adjusting.BoolValue)
+                {
+                    // Focus has settled — restore continuous AF
+                    if (captureDevice.LockForConfiguration(out _))
+                    {
+                        try
+                        {
+                            if (captureDevice.IsFocusModeSupported(AVCaptureFocusMode.ContinuousAutoFocus))
+                            {
+                                captureDevice.FocusMode = AVCaptureFocusMode.ContinuousAutoFocus;
+                            }
+
+                            if (captureDevice.IsExposureModeSupported(AVCaptureExposureMode.ContinuousAutoExposure))
+                            {
+                                captureDevice.ExposureMode = AVCaptureExposureMode.ContinuousAutoExposure;
+                            }
+                        }
+                        finally
+                        {
+                            captureDevice.UnlockForConfiguration();
+                        }
+                    }
+                    
+                    m_focusObserver?.Dispose();
+                    m_focusObserver = null;
+                }
+            });
+    }
 
     public new void Dispose()
     {
         m_avCaptureDevice = null;
 
+        m_focusObserver?.Dispose();
+        m_focusObserver = null;
+        
         RemovePinchToZoom();
         RemoveTouchToFocus();    
         RemovePreviewLayer();

src/library/DIPS.Mobile.UI/API/Camera/Shared/Android/CameraFragment.cs

@@ -290,6 +290,7 @@ private void AddPinchToZoom()
         if(PreviewViewHandler is not null)
         {
             PreviewViewHandler.OnScaled += OnScaled;
+            PreviewViewHandler.OnScaleEnded += TriggerContinuousAutoFocus;
         }
     }
 
@@ -342,6 +343,21 @@ private void OnChangedZoomRatio(float zoomRatio)
 
         CameraControl?.SetZoomRatio(zoomRatio);
     }
+    
+    private void TriggerContinuousAutoFocus()
+    {
+        if (PreviewView is null || CameraControl is null)
+            return;
+        
+        // Create a center-point focus action to briefly re-engage autofocus after zoom
+        // changes, then automatically return control to the camera's normal behavior.
+        var centerPoint = PreviewView.MeteringPointFactory.CreatePoint(
+            PreviewView.Width / 2f, PreviewView.Height / 2f);
+        var action = new FocusMeteringAction.Builder(centerPoint, FocusMeteringAction.FlagAf)
+            .SetAutoCancelDuration(2, TimeUnit.Seconds)
+            .Build();
+        CameraControl.StartFocusAndMetering(action);
+    }
 
     public override void OnConfigurationChanged(Configuration newConfig)
     {
@@ -409,6 +425,7 @@ private void UnRegisterRotationEvents()
         if (PreviewViewHandler is not null)
         {
             PreviewViewHandler.OnScaled -= OnScaled;
+            PreviewViewHandler.OnScaleEnded -= TriggerContinuousAutoFocus;
             PreviewViewHandler.OnTapped -= PreviewViewOnTapped;
         }
 

src/library/DIPS.Mobile.UI/API/Camera/Shared/iOS/CameraSession.cs

@@ -180,6 +180,8 @@ internal async Task ConfigureAndStart(CameraPreview cameraPreview, int? maxHeigh
                 m_avCaptureOutput); //this has to be set before setting metadata objects, or else it crashes
 
             ConfigureSession();
+            
+            SetContinuousAutoFocus();
 
             //Commit the configuration
             CaptureSession.CommitConfiguration();
@@ -319,12 +321,37 @@ private void OnChangedZoomRatio(float zoomRatio)
         {
             CaptureDevice.UnlockForConfiguration();
         }
+        
+        SetContinuousAutoFocus();
     }
 
     public abstract void ConfigureSession();
 
     public abstract AVCaptureDevice? SelectCaptureDevice();
 
+    private void SetContinuousAutoFocus()
+    {
+        if (CaptureDevice is null || !CaptureDevice.LockForConfiguration(out _))
+            return;
+
+        try
+        {
+            if (CaptureDevice.IsFocusModeSupported(AVCaptureFocusMode.ContinuousAutoFocus))
+            {
+                CaptureDevice.FocusMode = AVCaptureFocusMode.ContinuousAutoFocus;
+            }
+
+            if (CaptureDevice.IsExposureModeSupported(AVCaptureExposureMode.ContinuousAutoExposure))
+            {
+                CaptureDevice.ExposureMode = AVCaptureExposureMode.ContinuousAutoExposure;
+            }
+        }
+        finally
+        {
+            CaptureDevice.UnlockForConfiguration();
+        }
+    }
+    
     internal void OnCameraFailed<T>(CameraException exception, bool shouldOnlyLog = false) where T : class
     {
         DUILogService.LogError<T>(exception.Message);