Improve iOS barcode close focus (#894)

Vetle444 · Vetle Finstad · web-flow · commit a80f403a4a3e · 2026-06-10T14:15:15.000+02:00
Co-authored-by: Vetle Finstad &lt;finstad@Vetles-MacBook-Pro-2.local&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,6 @@
+## [60.2.12]
+- [Camera][iOS] Added ultra-wide capable back camera selection and zoom mapping for barcode scanning and image capture on supported devices.
+
 ## [60.2.11]
 - [CollectionView][Android] Fixed crash when deferred item decoration updates ran after the RecyclerView was detached during list reloads.
 
diff --git a/src/library/DIPS.Mobile.UI/API/Camera/BarcodeScanning/iOS/BarcodeScanner.cs b/src/library/DIPS.Mobile.UI/API/Camera/BarcodeScanning/iOS/BarcodeScanner.cs
@@ -83,10 +83,8 @@ public override void ConfigureSession()
         SetRecommendedZoomFactor();
     }
 
-    //Choosing build in wide angle camera, same as the sample app from Apple: AVCamBarCode: https://developer.apple.com/documentation/avfoundation/capture_setup/avcambarcode_detecting_barcodes_and_faces
-    public override AVCaptureDevice? SelectCaptureDevice() =>
-        AVCaptureDevice.GetDefaultDevice(AVCaptureDeviceType.BuiltInWideAngleCamera,
-            AVMediaTypes.Video, AVCaptureDevicePosition.Back);
+    // Prefer virtual back cameras so iOS starts at normal 1x wide framing but can switch to macro-capable lenses when close.
+    public override AVCaptureDevice? SelectCaptureDevice() => SelectPreferredBackCaptureDevice();
 
     //Taken from: https://developer.apple.com/wwdc21/10047?time=117
     //and sample code from Apple: https://developer.apple.com/documentation/avfoundation/capture_setup/avcambarcode_detecting_barcodes_and_faces
@@ -125,7 +123,7 @@ of minimumCodeSize (mm) fill the previewFillPercentage.
         
         if (m_cameraPreview is { CameraZoomView: not null })
         {
-            m_cameraPreview.CameraZoomView.SetZoomRatio((float)captureDevice.VideoZoomFactor);
+            m_cameraPreview.CameraZoomView.SetZoomRatio(ToDisplayZoomRatio((float)captureDevice.VideoZoomFactor));
         }
     }
 
diff --git a/src/library/DIPS.Mobile.UI/API/Camera/ImageCapturing/Views/CameraZoom/CameraZoomView.cs b/src/library/DIPS.Mobile.UI/API/Camera/ImageCapturing/Views/CameraZoom/CameraZoomView.cs
@@ -20,9 +20,6 @@ public CameraZoomView(float minRatio, float maxRatio, Action<float> onChangedZoo
         InputTransparent = true;
         CascadeInputTransparent = false;
         
-        // We do not support ultra-wide cameras yet, so we can safely assume that the minimum ratio is 1
-        minRatio = 1;
-        
         VerticalOptions = LayoutOptions.End;
 
         Margin = new Thickness(0, 0, 0, Sizes.GetSize(SizeName.content_margin_large));
diff --git a/src/library/DIPS.Mobile.UI/API/Camera/ImageCapturing/Views/CameraZoom/ZoomButtons.cs b/src/library/DIPS.Mobile.UI/API/Camera/ImageCapturing/Views/CameraZoom/ZoomButtons.cs
@@ -18,9 +18,6 @@ public ZoomButtons(float minRatio, float maxRatio, Action<float> onChangedZoomRa
     {
         m_onChangedZoomRatio = onChangedZoomRatio;
         m_onPanned = onPanned;
-
-        // We do not support ultra-wide cameras yet, so we can safely assume that the minimum ratio is 1
-        minRatio = 1;
         
         var panGestureRecognizer = new PanGestureRecognizer();
         panGestureRecognizer.PanUpdated += OnPanned;
@@ -33,37 +30,51 @@ public ZoomButtons(float minRatio, float maxRatio, Action<float> onChangedZoomRa
         Padding = 2;
         
         UI.Effects.Layout.Layout.SetCornerRadius(this, Sizes.GetSize(SizeName.size_5));
-        
-        var firstButton = CreateCameraZoomButton(minRatio, true);
-        var secondButton = CreateCameraZoomButton(minRatio + 1);
-        var thirdButton = CreateCameraZoomButton(MathF.Min(secondButton.DefaultZoomRatio + 1, maxRatio));
 
-        // If we have not yet hit the max ratio, lets add another button
-        ZoomButton? fourthButton = null;
-        if (Math.Abs(thirdButton.DefaultZoomRatio - maxRatio) > 0.01f)
+        m_zoomButtons = CreateDefaultZoomRatios(minRatio, maxRatio)
+            .Select((zoomRatio, index) => CreateCameraZoomButton(zoomRatio, index == 0))
+            .ToList();
+
+        m_currentlyActiveButton = m_zoomButtons.First();
+
+        foreach (var zoomButton in m_zoomButtons)
         {
-            fourthButton = CreateCameraZoomButton(MathF.Min(secondButton.DefaultZoomRatio + 2, maxRatio));
+            Add(zoomButton);
         }
-
-        m_currentlyActiveButton = firstButton.IsDefaultActive ? firstButton : secondButton;
-        
-        Add(firstButton);
-        Add(secondButton);
-        Add(thirdButton);
-        
-        if(fourthButton is not null)
-            Add(fourthButton);
         
         this.SizeChanged += OnSizeChanged;
         
-        m_zoomButtons = [firstButton, secondButton, thirdButton];
-        
-        if(fourthButton is not null)
-            m_zoomButtons.Add(fourthButton);
-        
         DUI.OrientationChanged += OrientationChanged;
     }
 
+    private static List<float> CreateDefaultZoomRatios(float minRatio, float maxRatio)
+    {
+        var zoomRatios = new List<float>();
+
+        AddZoomRatio(minRatio);
+        AddZoomRatio(minRatio < 1 ? 1 : minRatio + 1);
+        AddZoomRatio(MathF.Min(zoomRatios.Last() + 1, maxRatio));
+
+        var fourthZoomRatio = maxRatio;
+        if (Math.Abs(zoomRatios.Last() - fourthZoomRatio) > 0.01f)
+        {
+            AddZoomRatio(fourthZoomRatio);
+        }
+
+        return zoomRatios;
+
+        void AddZoomRatio(float zoomRatio)
+        {
+            zoomRatio = Math.Clamp(zoomRatio, minRatio, maxRatio);
+            if (zoomRatios.Any(existingZoomRatio => Math.Abs(existingZoomRatio - zoomRatio) <= 0.01f))
+            {
+                return;
+            }
+
+            zoomRatios.Add(zoomRatio);
+        }
+    }
+
     private void OrientationChanged(OrientationDegree orientationDegree)
     {
         foreach (var child in Children)
@@ -170,7 +181,7 @@ public ZoomButton(float defaultZoomRatio, Action<(float, ZoomButton)> onTapped,
         
         m_label = new Label
         {
-            Text = IsDefaultActive ? $"{defaultZoomRatio} ×" : $"{defaultZoomRatio}",
+            Text = IsDefaultActive ? $"{FormatZoomRatio(defaultZoomRatio)} ×" : FormatZoomRatio(defaultZoomRatio),
             TextColor = IsDefaultActive ? Colors.Gold : Colors.White,
             VerticalTextAlignment = TextAlignment.Center,
             HorizontalTextAlignment = TextAlignment.Center,
@@ -227,9 +238,11 @@ public void SetCustomZoomRatio(float zoomRatio)
 
     public void ResetToDefault()
     {
-        m_label.Text = $"{DefaultZoomRatio}";
+        m_label.Text = FormatZoomRatio(DefaultZoomRatio);
         m_label.TextColor = Colors.White;
     }
+
+    private static string FormatZoomRatio(float zoomRatio) => zoomRatio.ToString("0.#");
     
     public float DefaultZoomRatio { get; }
     public bool IsDefaultActive { get; }
diff --git a/src/library/DIPS.Mobile.UI/API/Camera/ImageCapturing/Views/CameraZoom/ZoomSlider.cs b/src/library/DIPS.Mobile.UI/API/Camera/ImageCapturing/Views/CameraZoom/ZoomSlider.cs
@@ -16,15 +16,19 @@ internal class ZoomSlider : Grid
     private Border m_zoomRatioLevelBorder;
     private Label m_zoomRatioLevelLabel;
     
+    private readonly float m_minRatio;
     private readonly float m_maxRatio;
     
     private readonly Action<float> m_onChangedZoomRatio;
     private readonly Action<PanUpdatedEventArgs> m_onPanned;
     
     private double m_startingX;
+    private float m_startingZoomRatio;
     private double m_minimumZoomRatiosLayoutTranslationX;
     private double m_maxZoomRatiosLayoutTranslationX;
     private double m_zoomRatioLevel;
+    private float? m_pendingZoomRatio;
+    private bool m_hasMeasuredZoomRatiosLayout;
     
     private int m_currentSnappedZoomRatio;
 
@@ -34,6 +38,7 @@ public ZoomSlider(float minRatio, float maxRatio, Action<float> onChangedZoomRat
     {
         InputTransparent = true;
         CascadeInputTransparent = false;
+        m_minRatio = minRatio;
         m_maxRatio = maxRatio;
         m_onChangedZoomRatio = onChangedZoomRatio;
         m_onPanned = onPanned;
@@ -159,12 +164,23 @@ private static List<float> GenerateZoomRatios(float minRatio, float maxRatio)
     
     private void ZoomRatiosLayoutOnSizeChanged(object? sender, EventArgs e)
     {
-        if(m_zoomRatiosLayout.TranslationX != 0)
+        if (m_zoomRatiosLayout.Width <= 0)
             return;
-        
-        m_zoomRatiosLayout.TranslationX += m_zoomRatiosLayout.Width / 2;
-        m_maxZoomRatiosLayoutTranslationX = m_zoomRatiosLayout.TranslationX;
+
+        if (m_hasMeasuredZoomRatiosLayout && m_pendingZoomRatio is null)
+            return;
+
+        m_maxZoomRatiosLayoutTranslationX = m_zoomRatiosLayout.Width / 2;
         m_minimumZoomRatiosLayoutTranslationX = m_maxZoomRatiosLayoutTranslationX - m_zoomRatiosLayout.Width;
+        m_hasMeasuredZoomRatiosLayout = true;
+
+        if (m_pendingZoomRatio is { } pendingZoomRatio)
+        {
+            SetZoomRatio(pendingZoomRatio);
+            return;
+        }
+
+        m_zoomRatiosLayout.TranslationX = m_maxZoomRatiosLayoutTranslationX;
     }
 
     private double CalculateZoomRatio(double desiredTranslationX)
@@ -173,48 +189,52 @@ private double CalculateZoomRatio(double desiredTranslationX)
         currentTranslation = m_zoomRatiosLayout.Width - currentTranslation;
         var translationPercentage = (currentTranslation / m_zoomRatiosLayout.Width);
 
-        var zoomRatioIndex = ((m_maxRatio - 1) * 10) * translationPercentage;
+        var zoomRatioIndex = ((m_maxRatio - m_minRatio) * 10) * translationPercentage;
         
-        return zoomRatioIndex / 10 + 1;
+        return zoomRatioIndex / 10 + m_minRatio;
     }
 
     private double CalculateTranslationXFromZoomRatio(float zoomRatio)
     {
-        return m_maxZoomRatiosLayoutTranslationX - (m_zoomRatiosLayout.Width * ((zoomRatio - 1) / (m_maxRatio - 1)));
+        if (Math.Abs(m_maxRatio - m_minRatio) < 0.01f)
+        {
+            return m_maxZoomRatiosLayoutTranslationX;
+        }
+
+        return m_maxZoomRatiosLayoutTranslationX - (m_zoomRatiosLayout.Width * ((zoomRatio - m_minRatio) / (m_maxRatio - m_minRatio)));
     }
 
     private void PanGestureRecognizerOnPanUpdated(PanUpdatedEventArgs e)
     {
         m_onPanned.Invoke(e);
     }
+
+    private float ClampZoomRatio(float zoomRatio) => Math.Clamp(zoomRatio, m_minRatio, m_maxRatio);
     
     public void TranslateZoomSlider(PanUpdatedEventArgs e)
     {
         switch (e.StatusType)
         {
             case GestureStatus.Started:
                 m_startingX = e.TotalX;
+                m_startingZoomRatio = ClampZoomRatio((float)m_zoomRatioLevel);
                 
                 m_cancellationTokenSource.Cancel();
                 m_cancellationTokenSource = new CancellationTokenSource();
                 break;
             case GestureStatus.Running:
                 {
-                    var desiredTranslationX = m_zoomRatiosLayout.TranslationX + e.TotalX - m_startingX;
-            
-                    var actualZoomRatio = CalculateZoomRatio(m_zoomRatiosLayout.TranslationX);
-                    
-                    // Vibrate when near integers
-                    var roundedZoomRatio = (int)MathF.Round((float)actualZoomRatio);
-                    if (Math.Abs(roundedZoomRatio - actualZoomRatio) < 0.025f)
+                    if (m_minRatio < 1)
                     {
-                        if (roundedZoomRatio != m_currentSnappedZoomRatio)
-                        {
-                            VibrationService.SelectionChanged();
-                        }
-                        m_currentSnappedZoomRatio = roundedZoomRatio;
+                        var dragRange = Math.Max(Width, 1);
+                        var zoomRatioDelta = (float)((m_startingX - e.TotalX) / dragRange * (m_maxRatio - m_minRatio));
+                        var desiredZoomRatio = ClampZoomRatio(m_startingZoomRatio + zoomRatioDelta);
+                        m_zoomRatiosLayout.TranslationX = CalculateTranslationXFromZoomRatio(desiredZoomRatio);
+                        UpdateZoomRatio(desiredZoomRatio);
+                        break;
                     }
-                    else m_currentSnappedZoomRatio = -1;
+
+                    var desiredTranslationX = m_zoomRatiosLayout.TranslationX + e.TotalX - m_startingX;
                     
                     // Stop the user from panning too far or too little
                     if(desiredTranslationX > m_maxZoomRatiosLayoutTranslationX)
@@ -229,13 +249,30 @@ public void TranslateZoomSlider(PanUpdatedEventArgs e)
                     m_zoomRatiosLayout.TranslationX = desiredTranslationX;
                     m_startingX = e.TotalX;
 
-                    ZoomRatioLevel = actualZoomRatio;
+                    UpdateZoomRatio(CalculateZoomRatio(desiredTranslationX));
 
                     break;
                 }
         }
     }
 
+    private void UpdateZoomRatio(double zoomRatio)
+    {
+        // Vibrate when near integers
+        var roundedZoomRatio = (int)MathF.Round((float)zoomRatio);
+        if (Math.Abs(roundedZoomRatio - zoomRatio) < 0.025f)
+        {
+            if (roundedZoomRatio != m_currentSnappedZoomRatio)
+            {
+                VibrationService.SelectionChanged();
+            }
+            m_currentSnappedZoomRatio = roundedZoomRatio;
+        }
+        else m_currentSnappedZoomRatio = -1;
+
+        ZoomRatioLevel = zoomRatio;
+    }
+
     public double ZoomRatioLevel
     {
         get => m_zoomRatioLevel;
@@ -249,13 +286,23 @@ private set
 
     public void SetZoomRatio(float zoomRatio)
     {
-        m_zoomRatiosLayout.TranslationX = CalculateTranslationXFromZoomRatio((int)zoomRatio);
+        zoomRatio = ClampZoomRatio(zoomRatio);
+        m_zoomRatioLevel = zoomRatio;
+        m_zoomRatioLevelLabel.Text = zoomRatio.ToString("F1");
+
+        if (!m_hasMeasuredZoomRatiosLayout)
+        {
+            m_pendingZoomRatio = zoomRatio;
+            return;
+        }
+
+        m_zoomRatiosLayout.TranslationX = CalculateTranslationXFromZoomRatio(zoomRatio);
+        m_pendingZoomRatio = null;
     }
 
     public async Task<bool> OnPinchToZoom(float zoomRatio)
     {
-        m_zoomRatiosLayout.TranslationX = CalculateTranslationXFromZoomRatio(zoomRatio);
-        m_zoomRatioLevelLabel.Text = zoomRatio.ToString("F1");
+        SetZoomRatio(zoomRatio);
 
         m_cancellationTokenSource.Cancel();
         m_cancellationTokenSource = new CancellationTokenSource();
diff --git a/src/library/DIPS.Mobile.UI/API/Camera/ImageCapturing/iOS/ImageCapture.cs b/src/library/DIPS.Mobile.UI/API/Camera/ImageCapturing/iOS/ImageCapture.cs
@@ -53,11 +53,7 @@ private Size GetCurrentCameraResolution()
     private partial void PlatformOnCameraFailed(CameraException cameraException) =>
         OnCameraFailed<ImageCapture>(cameraException);
 
-    public override AVCaptureDevice? SelectCaptureDevice() =>
-        AVCaptureDevice.GetDefaultDevice(AVCaptureDeviceType.BuiltInWideAngleCamera,
-            AVMediaTypes.Video, AVCaptureDevicePosition.Back) ??
-        AVCaptureDevice.GetDefaultDevice(AVCaptureDeviceType.BuiltInDualCamera,
-            AVMediaTypes.Video, AVCaptureDevicePosition.Back);
+    public override AVCaptureDevice? SelectCaptureDevice() => SelectPreferredBackCaptureDevice();
 
     private void PhotoCaptured(AVCapturePhoto photo)
     {
@@ -223,6 +219,6 @@ protected override void Dispose(bool disposing)
 
         m_onPhotoCaptureFailed = null!;
         m_onPhotoCaptured = null!;
-        m_onBeforeCapture = null;
+        m_onBeforeCapture = null!;
     }
 }
diff --git a/src/library/DIPS.Mobile.UI/API/Camera/Preview/iOS/PreviewView.cs b/src/library/DIPS.Mobile.UI/API/Camera/Preview/iOS/PreviewView.cs
@@ -77,15 +77,15 @@ private void TapToFocus(NSSet touches, UIEvent @event, AVCaptureDevice captureDe
         /*UISlider?.BecomeFirstResponder();*/ //Make sure slider does not loose focus for people to slide it after they tap to focus
     }
     
-    public void AddPinchToZoom(AVCaptureDevice captureDevice)
+    public void AddPinchToZoom(AVCaptureDevice captureDevice, float maximumZoomRatio)
     {
         m_pinchToZoomGestureRecognizer =
-            new UIPinchGestureRecognizer((recognizer => PinchToZoom(recognizer, captureDevice)));
+            new UIPinchGestureRecognizer((recognizer => PinchToZoom(recognizer, captureDevice, maximumZoomRatio)));
         AddGestureRecognizer(m_pinchToZoomGestureRecognizer);
     }
     
     //Taken from: https://stackoverflow.com/a/31214458
-    private void PinchToZoom(UIPinchGestureRecognizer pinchRecognizer, AVCaptureDevice captureDevice)
+    private void PinchToZoom(UIPinchGestureRecognizer pinchRecognizer, AVCaptureDevice captureDevice, float maximumZoomRatio)
     {
         if (pinchRecognizer.State == UIGestureRecognizerState.Changed)
         {
@@ -94,13 +94,12 @@ private void PinchToZoom(UIPinchGestureRecognizer pinchRecognizer, AVCaptureDevi
                 try
                 {
                     var pinchVelocityDividerFactor = 10f;
-                    var desiredZoomFactor = captureDevice.VideoZoomFactor +
+                    var desiredZoomFactor = (double)captureDevice.VideoZoomFactor +
                                             Math.Atan2(pinchRecognizer.Velocity, pinchVelocityDividerFactor);
                     
-                    var maxZoomFactor = Math.Min(captureDevice.ActiveFormat.VideoMaxZoomFactor, MaxZoomRatio);
+                    var maxZoomFactor = Math.Min((double)captureDevice.ActiveFormat.VideoMaxZoomFactor, maximumZoomRatio);
                     // Check if desiredZoomFactor fits required range from 1.0 to activeFormat.videoMaxZoomFactor
-                    var zoomFactor = (nfloat)Math.Max(1.0,
-                        Math.Min(desiredZoomFactor, maxZoomFactor));
+                    var zoomFactor = (nfloat)Math.Max(1.0, Math.Min(desiredZoomFactor, maxZoomFactor));
                     captureDevice.VideoZoomFactor = zoomFactor;
 
                     OnZoomChanged?.Invoke((float)zoomFactor);
diff --git a/src/library/DIPS.Mobile.UI/API/Camera/Shared/iOS/CameraSession.cs b/src/library/DIPS.Mobile.UI/API/Camera/Shared/iOS/CameraSession.cs
diff --git a/wiki/Media/Camera.md b/wiki/Media/Camera.md
diff --git a/wiki/Media/ImageCapture.md b/wiki/Media/ImageCapture.md

Original file line number	Diff line number	Diff line change
`@@ -83,10 +83,8 @@ public override void ConfigureSession()`
`83`	`83`	`SetRecommendedZoomFactor();`
`84`	`84`	`}`
`85`	`85`
`86`		`- //Choosing build in wide angle camera, same as the sample app from Apple: AVCamBarCode: https://developer.apple.com/documentation/avfoundation/capture_setup/avcambarcode_detecting_barcodes_and_faces`
`87`		`- public override AVCaptureDevice? SelectCaptureDevice() =>`
`88`		`- AVCaptureDevice.GetDefaultDevice(AVCaptureDeviceType.BuiltInWideAngleCamera,`
`89`		`- AVMediaTypes.Video, AVCaptureDevicePosition.Back);`
	`86`	`+ // Prefer virtual back cameras so iOS starts at normal 1x wide framing but can switch to macro-capable lenses when close.`
	`87`	`+ public override AVCaptureDevice? SelectCaptureDevice() => SelectPreferredBackCaptureDevice();`
`90`	`88`
`91`	`89`	`//Taken from: https://developer.apple.com/wwdc21/10047?time=117`
`92`	`90`	`//and sample code from Apple: https://developer.apple.com/documentation/avfoundation/capture_setup/avcambarcode_detecting_barcodes_and_faces`
`@@ -125,7 +123,7 @@ of minimumCodeSize (mm) fill the previewFillPercentage.`
`125`	`123`
`126`	`124`	`if (m_cameraPreview is { CameraZoomView: not null })`
`127`	`125`	`{`
`128`		`- m_cameraPreview.CameraZoomView.SetZoomRatio((float)captureDevice.VideoZoomFactor);`
	`126`	`+ m_cameraPreview.CameraZoomView.SetZoomRatio(ToDisplayZoomRatio((float)captureDevice.VideoZoomFactor));`
`129`	`127`	`}`
`130`	`128`	`}`
`131`	`129`
Original file line number	Diff line number	Diff line change
`@@ -53,11 +53,7 @@ private Size GetCurrentCameraResolution()`
`53`	`53`	`private partial void PlatformOnCameraFailed(CameraException cameraException) =>`
`54`	`54`	`OnCameraFailed<ImageCapture>(cameraException);`
`55`	`55`
`56`		`- public override AVCaptureDevice? SelectCaptureDevice() =>`
`57`		`- AVCaptureDevice.GetDefaultDevice(AVCaptureDeviceType.BuiltInWideAngleCamera,`
`58`		`- AVMediaTypes.Video, AVCaptureDevicePosition.Back) ??`
`59`		`- AVCaptureDevice.GetDefaultDevice(AVCaptureDeviceType.BuiltInDualCamera,`
`60`		`- AVMediaTypes.Video, AVCaptureDevicePosition.Back);`
	`56`	`+ public override AVCaptureDevice? SelectCaptureDevice() => SelectPreferredBackCaptureDevice();`
`61`	`57`
`62`	`58`	`private void PhotoCaptured(AVCapturePhoto photo)`
`63`	`59`	`{`
`@@ -223,6 +219,6 @@ protected override void Dispose(bool disposing)`
`223`	`219`
`224`	`220`	`m_onPhotoCaptureFailed = null!;`
`225`	`221`	`m_onPhotoCaptured = null!;`
`226`		`- m_onBeforeCapture = null;`
	`222`	`+ m_onBeforeCapture = null!;`
`227`	`223`	`}`
`228`	`224`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,15 +77,15 @@ private void TapToFocus(NSSet touches, UIEvent @event, AVCaptureDevice captureDe`
`77`	`77`	`/UISlider?.BecomeFirstResponder();/ //Make sure slider does not loose focus for people to slide it after they tap to focus`
`78`	`78`	`}`
`79`	`79`
`80`		`- public void AddPinchToZoom(AVCaptureDevice captureDevice)`
	`80`	`+ public void AddPinchToZoom(AVCaptureDevice captureDevice, float maximumZoomRatio)`
`81`	`81`	`{`
`82`	`82`	`m_pinchToZoomGestureRecognizer =`
`83`		`- new UIPinchGestureRecognizer((recognizer => PinchToZoom(recognizer, captureDevice)));`
	`83`	`+ new UIPinchGestureRecognizer((recognizer => PinchToZoom(recognizer, captureDevice, maximumZoomRatio)));`
`84`	`84`	`AddGestureRecognizer(m_pinchToZoomGestureRecognizer);`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`//Taken from: https://stackoverflow.com/a/31214458`
`88`		`- private void PinchToZoom(UIPinchGestureRecognizer pinchRecognizer, AVCaptureDevice captureDevice)`
	`88`	`+ private void PinchToZoom(UIPinchGestureRecognizer pinchRecognizer, AVCaptureDevice captureDevice, float maximumZoomRatio)`
`89`	`89`	`{`
`90`	`90`	`if (pinchRecognizer.State == UIGestureRecognizerState.Changed)`
`91`	`91`	`{`
`@@ -94,13 +94,12 @@ private void PinchToZoom(UIPinchGestureRecognizer pinchRecognizer, AVCaptureDevi`
`94`	`94`	`try`
`95`	`95`	`{`
`96`	`96`	`var pinchVelocityDividerFactor = 10f;`
`97`		`- var desiredZoomFactor = captureDevice.VideoZoomFactor +`
	`97`	`+ var desiredZoomFactor = (double)captureDevice.VideoZoomFactor +`
`98`	`98`	`Math.Atan2(pinchRecognizer.Velocity, pinchVelocityDividerFactor);`
`99`	`99`
`100`		`- var maxZoomFactor = Math.Min(captureDevice.ActiveFormat.VideoMaxZoomFactor, MaxZoomRatio);`
	`100`	`+ var maxZoomFactor = Math.Min((double)captureDevice.ActiveFormat.VideoMaxZoomFactor, maximumZoomRatio);`
`101`	`101`	`// Check if desiredZoomFactor fits required range from 1.0 to activeFormat.videoMaxZoomFactor`
`102`		`- var zoomFactor = (nfloat)Math.Max(1.0,`
`103`		`- Math.Min(desiredZoomFactor, maxZoomFactor));`
	`102`	`+ var zoomFactor = (nfloat)Math.Max(1.0, Math.Min(desiredZoomFactor, maxZoomFactor));`
`104`	`103`	`captureDevice.VideoZoomFactor = zoomFactor;`
`105`	`104`
`106`	`105`	`OnZoomChanged?.Invoke((float)zoomFactor);`