fix: report gesture-driven zoom changes back to the Zoom property

README.md

@@ -61,6 +61,7 @@ MauiNativePdfView brings native PDF viewing capabilities to your .NET MAUI appli
 
 - `DocumentLoaded` - Fires when PDF is loaded with page count and metadata
 - `PageChanged` - Current page and total page count updates
+- `ZoomChanged` - Zoom level updates, including pinch and double-tap
 - `LinkTapped` - Intercept link taps before navigation (set `e.Handled = true` to prevent)
 - `Tapped` - General tap events with page coordinates (requires `EnableTapGestures = true`)
 - `AnnotationTapped` - Annotation tap with type, content, and bounds (iOS)
@@ -280,6 +281,26 @@ size. So `1.0` is the fitted document, `2.0` is twice that size, and `MinZoom="1
 "never zoom out past fitted". Because the values are relative, they stay meaningful when the
 view resizes or the device rotates.
 
+#### Following the zoom the user sets
+
+`Zoom` reports gesture-driven changes as well as ones you assign, so it binds two-way and a
+pinch or double-tap updates the bound property:
+
+```xml
+<pdf:PdfView Zoom="{Binding ZoomLevel, Mode=TwoWay}" />
+```
+
+There is also a `ZoomChanged` event if you would rather not bind:
+
+```csharp
+private void OnZoomChanged(object sender, ZoomChangedEventArgs e)
+    => ZoomLabel.Text = $"{e.Zoom:P0}";
+```
+
+Both fire continuously while a gesture is in flight, not just when it ends — the same way
+the underlying platform controls report scale — so a bound label tracks the pinch rather than
+jumping at the end. Keep the handler cheap for that reason.
+
 ### PdfSource Types
 
 The `PdfSource` class supports automatic string conversion via implicit operators and TypeConverter, making it easy to use in both XAML and code.

samples/MauiPdfViewerSample/PdfTestPage.xaml

@@ -89,6 +89,7 @@
                          EnableAnnotationRendering="True"
                          DocumentLoaded="OnDocumentLoaded"
                          PageChanged="OnPageChanged"
+                         ZoomChanged="OnZoomChanged"
                          Error="OnError"
                          Tapped="OnPdfTapped"
                          Rendered="OnPdfRendered"

samples/MauiPdfViewerSample/PdfTestPage.xaml.cs

@@ -306,10 +306,16 @@ private void OnToggleZoomClicked(object? sender, EventArgs e)
     {
         _zoomIndex = (_zoomIndex + 1) % _zoomLevels.Length;
         PdfViewer.Zoom = _zoomLevels[_zoomIndex];
-        ToggleZoomButton.Text = $"{_zoomLevels[_zoomIndex]:0.0}x";
         StatusLabel.Text = $"Zoom: {_zoomLevels[_zoomIndex]:0.0}x — now tap the page";
     }
 
+    // The button label follows the control rather than the last value we assigned, so a
+    // pinch or double-tap keeps it honest.
+    private void OnZoomChanged(object? sender, ZoomChangedEventArgs e)
+    {
+        ToggleZoomButton.Text = $"{e.Zoom:0.0}x";
+    }
+
     private void OnToggleTapGesturesClicked(object? sender, EventArgs e)
     {
         PdfViewer.EnableTapGestures = !PdfViewer.EnableTapGestures;

src/MauiNativePdfView/Abstractions/EventArgs.cs

@@ -150,6 +150,23 @@ public RenderedEventArgs(int pageCount)
     }
 }
 
+/// <summary>
+/// Event arguments for the zoom changed event.
+/// </summary>
+public class ZoomChangedEventArgs : EventArgs
+{
+    /// <summary>
+    /// Gets the zoom level now being shown, as a multiple of the fit scale
+    /// (<c>1.0</c> is the fitted document).
+    /// </summary>
+    public float Zoom { get; }
+
+    public ZoomChangedEventArgs(float zoom)
+    {
+        Zoom = zoom;
+    }
+}
+
 /// <summary>
 /// Event arguments for annotation tapped event.
 /// </summary>

src/MauiNativePdfView/Abstractions/IPdfView.cs

@@ -145,6 +145,13 @@ public interface IPdfView
     /// </summary>
     event EventHandler<PageChangedEventArgs>? PageChanged;
 
+    /// <summary>
+    /// Occurs when the zoom level being shown changes, including changes the user drives
+    /// with a pinch or a double-tap. <see cref="Zoom"/> already reflects the new level when
+    /// this is raised.
+    /// </summary>
+    event EventHandler<ZoomChangedEventArgs>? ZoomChanged;
+
     /// <summary>
     /// Occurs when an error occurs during loading or rendering.
     /// </summary>

src/MauiNativePdfView/PdfView.cs

@@ -66,7 +66,8 @@ public class PdfView : View
             nameof(Zoom),
             typeof(float),
             typeof(PdfView),
-            1.0f);
+            1.0f,
+            propertyChanged: OnZoomPropertyChanged);
 
     /// <summary>
     /// Bindable property for minimum zoom level.
@@ -435,6 +436,13 @@ public int PageCount
     /// </summary>
     public event EventHandler<RenderedEventArgs>? Rendered;
 
+    /// <summary>
+    /// Occurs when the zoom level being shown changes, including changes the user drives
+    /// with a pinch or a double-tap. <see cref="Zoom"/> already holds the new level when
+    /// this is raised, so a <c>TwoWay</c> binding on <see cref="Zoom"/> has already updated.
+    /// </summary>
+    public event EventHandler<ZoomChangedEventArgs>? ZoomChanged;
+
     /// <summary>
     /// Occurs when an annotation is tapped in the PDF.
     /// Platform availability: iOS only. Android does not support annotation tap detection with the current library.
@@ -490,6 +498,25 @@ internal void RaiseRendered(RenderedEventArgs args)
         Rendered?.Invoke(this, args);
     }
 
+    internal void RaiseZoomChanged(ZoomChangedEventArgs args)
+    {
+        // Writing the bindable property is the whole point: it is what a TwoWay binding
+        // observes, and its property-changed callback is what raises ZoomChanged. Routing
+        // the event through the property rather than raising it here is what makes a level
+        // the caller assigned and a level the user pinched report identically. The handler's
+        // MapZoom compares against the native control before pushing anything back, so
+        // setting the level we were just told about stops here.
+        Zoom = args.Zoom;
+    }
+
+    private static void OnZoomPropertyChanged(BindableObject bindable, object oldValue, object newValue)
+    {
+        if (bindable is PdfView view)
+        {
+            view.ZoomChanged?.Invoke(view, new ZoomChangedEventArgs((float)newValue));
+        }
+    }
+
     internal void RaiseAnnotationTapped(AnnotationTappedEventArgs args)
     {
         AnnotationTapped?.Invoke(this, args);

src/MauiNativePdfView/Platforms/Android/PdfViewAndroid.cs

@@ -40,8 +40,16 @@ public class PdfViewAndroid : IPdfView, IDisposable
     private float _zoom = 1.0f;
     private bool _zoomNeedsApply;
     private readonly HashSet<int> _openedPages = new();
+    private float _lastReportedZoom = 1.0f;
+
+    /// <summary>
+    /// Smallest zoom movement worth publishing. A pinch redraws every frame, and without a
+    /// floor the last few bits of float noise would republish on every one of them.
+    /// </summary>
+    private const float ZoomReportThreshold = 0.001f;
 
     private TapListener? _tapListener;
+    private DrawListener? _drawListener;
 
     public PdfViewAndroid(Context context)
     {
@@ -512,6 +520,7 @@ private void ApplyPageAlignmentOnUiThread()
     public event EventHandler<LinkTappedEventArgs>? LinkTapped;
     public event EventHandler<PdfTappedEventArgs>? Tapped;
     public event EventHandler<RenderedEventArgs>? Rendered;
+    public event EventHandler<ZoomChangedEventArgs>? ZoomChanged;
 
     /// <summary>
     /// This event is not supported on Android with the current AhmerPdfium library.
@@ -611,6 +620,10 @@ private void ConfigureAndLoad(PDFView.Configurator configurator, int pageToResto
             .OnPageChange(new PageChangeListener(this))
             .OnError(new ErrorListener(this))
             .OnTap(_enableTapGestures ? _tapListener ??= new TapListener(this) : null)
+            // AhmerPdfViewer has no zoom listener of any kind and PDFView is sealed, so the
+            // per-draw callback is the only place a pinch or double-tap becomes observable.
+            // See ReportZoomIfChanged for why this is cheap enough to sit on the draw path.
+            .OnDraw(_drawListener ??= new DrawListener(this))
             .OnRender(new RenderListener(this));
 
         // Note: UseBestQuality sets rendering quality (ARGB_8888 vs RGB_565)
@@ -655,6 +668,36 @@ private void OnDocumentLoadedWithPageRestore(int pageCount, int pageToRestore)
         DocumentLoaded?.Invoke(this, new DocumentLoadedEventArgs(pageCount));
     }
 
+    /// <summary>
+    /// Publishes the level the control is actually showing, so a caller bound to Zoom sees a
+    /// pinch or double-tap.
+    ///
+    /// This runs on the draw path, so it has to stay cheap: on all but the frames where the
+    /// zoom genuinely moved it is a field read and a float compare, and it allocates only
+    /// when it actually publishes.
+    ///
+    /// The threshold is what keeps the round trip closed. Publishing sets Zoom on the virtual
+    /// view, whose handler compares against this same control before pushing anything back,
+    /// so the value we just read cannot bounce; the threshold additionally stops float noise
+    /// from republishing an unchanged level on every frame of a pinch.
+    /// </summary>
+    private void ReportZoomIfChanged()
+    {
+        // Mid-apply the control is still showing the old level, and a document that has not
+        // loaded has no meaningful zoom to report.
+        if (_disposed || _zoomNeedsApply || _pageCount == 0)
+            return;
+
+        var zoom = Math.Clamp(_pdfView.Zoom, _minZoom, _maxZoom);
+
+        if (Math.Abs(zoom - _lastReportedZoom) < ZoomReportThreshold)
+            return;
+
+        _lastReportedZoom = zoom;
+        _zoom = zoom;
+        ZoomChanged?.Invoke(this, new ZoomChangedEventArgs(zoom));
+    }
+
     private void OnPageChanged(int pageIndex, int pageCount)
     {
         _currentPage = pageIndex;
@@ -816,6 +859,29 @@ public bool OnTap(MotionEvent? e)
         }
     }
 
+    /// <summary>
+    /// AhmerPdfViewer exposes no zoom or scale listener — the library has none, and PDFView
+    /// is sealed so there is nothing to override either. The draw callback is the one hook
+    /// that runs after a pinch or double-tap has changed the scale.
+    /// </summary>
+    private class DrawListener : Java.Lang.Object, IOnDrawListener
+    {
+        private readonly WeakReference<PdfViewAndroid> _viewRef;
+
+        public DrawListener(PdfViewAndroid view)
+        {
+            _viewRef = new WeakReference<PdfViewAndroid>(view);
+        }
+
+        public void OnLayerDrawn(global::Android.Graphics.Canvas? canvas, float pageWidth, float pageHeight, int currentPage)
+        {
+            if (_viewRef.TryGetTarget(out var view))
+            {
+                view.ReportZoomIfChanged();
+            }
+        }
+    }
+
     private class RenderListener : Java.Lang.Object, IOnRenderListener
     {
         private readonly WeakReference<PdfViewAndroid> _viewRef;
@@ -852,6 +918,12 @@ public void Dispose()
             _tapListener = null;
         }
 
+        if (_drawListener != null)
+        {
+            _drawListener.Dispose();
+            _drawListener = null;
+        }
+
         _pdfView?.Dispose();
     }
 }

src/MauiNativePdfView/Platforms/Android/PdfViewHandler.cs

@@ -69,6 +69,7 @@ protected override PDFView CreatePlatformView()
         _pdfViewWrapper.LinkTapped += OnLinkTapped;
         _pdfViewWrapper.Tapped += OnTapped;
         _pdfViewWrapper.Rendered += OnRendered;
+        _pdfViewWrapper.ZoomChanged += OnZoomChanged;
 
         return _pdfViewWrapper.NativeView;
     }
@@ -110,6 +111,7 @@ protected override void DisconnectHandler(PDFView platformView)
             _pdfViewWrapper.LinkTapped -= OnLinkTapped;
             _pdfViewWrapper.Tapped -= OnTapped;
             _pdfViewWrapper.Rendered -= OnRendered;
+            _pdfViewWrapper.ZoomChanged -= OnZoomChanged;
             _pdfViewWrapper.Dispose();
             _pdfViewWrapper = null;
         }
@@ -149,6 +151,11 @@ private void OnRendered(object? sender, RenderedEventArgs e)
         VirtualView?.RaiseRendered(e);
     }
 
+    private void OnZoomChanged(object? sender, ZoomChangedEventArgs e)
+    {
+        VirtualView?.RaiseZoomChanged(e);
+    }
+
     #endregion
 
     #region Property Mappers

src/MauiNativePdfView/Platforms/iOS/PdfViewHandler.cs

@@ -60,6 +60,7 @@ protected override PdfKit.PdfView CreatePlatformView()
         _pdfViewWrapper.LinkTapped += OnLinkTapped;
         _pdfViewWrapper.Tapped += OnTapped;
         _pdfViewWrapper.Rendered += OnRendered;
+        _pdfViewWrapper.ZoomChanged += OnZoomChanged;
         _pdfViewWrapper.AnnotationTapped += OnAnnotationTapped;
 
         return _pdfViewWrapper.NativeView;
@@ -107,6 +108,7 @@ protected override void DisconnectHandler(PdfKit.PdfView platformView)
             _pdfViewWrapper.LinkTapped -= OnLinkTapped;
             _pdfViewWrapper.Tapped -= OnTapped;
             _pdfViewWrapper.Rendered -= OnRendered;
+            _pdfViewWrapper.ZoomChanged -= OnZoomChanged;
             _pdfViewWrapper.AnnotationTapped -= OnAnnotationTapped;
             _pdfViewWrapper.Dispose();
             _pdfViewWrapper = null;
@@ -145,6 +147,11 @@ private void OnRendered(object? sender, RenderedEventArgs e)
         VirtualView?.RaiseRendered(e);
     }
 
+    private void OnZoomChanged(object? sender, ZoomChangedEventArgs e)
+    {
+        VirtualView?.RaiseZoomChanged(e);
+    }
+
     private void OnAnnotationTapped(object? sender, AnnotationTappedEventArgs e)
     {
         VirtualView?.RaiseAnnotationTapped(e);