Merge pull request #27 from bengavin/bugfix/android-reattach

Fix Android Viewer showing blank screen when target of back navigation

Author: michaelstonis

src/MauiNativePdfView/Abstractions/PdfSource.cs

@@ -142,14 +142,145 @@ public UriPdfSource(Uri uri)
 /// <summary>
 /// PDF source from a stream.
 /// </summary>
+/// <remarks>
+/// The view reads the stream again whenever it reloads the document — a setting change,
+/// <see cref="IPdfView.Reload"/>, or on Android returning to a page another one covered.
+/// A seekable stream is re-read from where it stood on the first load, so keep it open for
+/// as long as the view shows it; a forward-only stream is buffered in memory on the first
+/// load instead. The view never closes the stream: disposing it stays with the caller.
+/// </remarks>
 public sealed class StreamPdfSource : PdfSource
 {
+    private readonly object _gate = new();
+    private long? _startPosition;
+    private byte[]? _buffer;
+
     public Stream Stream { get; }
 
     public StreamPdfSource(Stream stream)
     {
         Stream = stream ?? throw new ArgumentNullException(nameof(stream));
     }
+
+    /// <summary>
+    /// Opens the document from its first byte, however many times the view needs to load it.
+    /// </summary>
+    /// <remarks>
+    /// Each call returns a fresh stream the caller owns and may dispose without touching
+    /// <see cref="Stream"/>. That matters on Android: AhmerPdfViewer closes whatever stream
+    /// it is handed once it has read it, and reads it on a background thread — so handing it
+    /// <see cref="Stream"/> itself would dispose the caller's stream on the first load, and a
+    /// reload could seek it out from under a read still in flight.
+    ///
+    /// A seekable stream is shared rather than copied, so a large document isn't held in
+    /// memory twice; only a forward-only stream, which can't be read a second time, is.
+    /// </remarks>
+    internal Stream OpenDocument()
+    {
+        lock (_gate)
+        {
+            if (_buffer != null)
+                return new MemoryStream(_buffer, writable: false);
+
+            if (_startPosition is { } start)
+            {
+                // A disposed stream reports CanSeek false. Say why the reload failed, rather
+                // than let it surface as an ObjectDisposedException from the native loader.
+                if (!Stream.CanSeek)
+                    throw new InvalidOperationException(
+                        "The stream behind this StreamPdfSource was closed after the document first loaded, " +
+                        "so the document can't be reloaded. Keep the stream open for as long as the view shows it, " +
+                        "or use PdfSource.FromBytes.");
+
+                return new SharedStreamReader(Stream, start, _gate);
+            }
+
+            if (Stream.CanSeek)
+            {
+                _startPosition = Stream.Position;
+                return new SharedStreamReader(Stream, _startPosition.Value, _gate);
+            }
+
+            using var copy = new MemoryStream();
+            Stream.CopyTo(copy);
+            _buffer = copy.ToArray();
+            return new MemoryStream(_buffer, writable: false);
+        }
+    }
+
+    /// <summary>
+    /// A read-only view onto the shared source stream that keeps its own cursor, seeking the
+    /// source to it under the source's lock on every read. Two loads in flight at once — a
+    /// reload racing a cancelled decode that is still reading — each see the whole document.
+    /// Disposing it leaves the source stream open.
+    /// </summary>
+    private sealed class SharedStreamReader : Stream
+    {
+        private readonly Stream _source;
+        private readonly long _start;
+        private readonly object _gate;
+        private long _position;
+
+        public SharedStreamReader(Stream source, long start, object gate)
+        {
+            _source = source;
+            _start = start;
+            _gate = gate;
+        }
+
+        public override bool CanRead => true;
+        public override bool CanSeek => true;
+        public override bool CanWrite => false;
+
+        public override long Length
+        {
+            get
+            {
+                lock (_gate)
+                    return Math.Max(_source.Length - _start, 0);
+            }
+        }
+
+        public override long Position
+        {
+            get => _position;
+            set => _position = value >= 0 ? value : throw new ArgumentOutOfRangeException(nameof(value));
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+            => Read(buffer.AsSpan(offset, count));
+
+        public override int Read(Span<byte> buffer)
+        {
+            lock (_gate)
+            {
+                _source.Position = _start + _position;
+                int read = _source.Read(buffer);
+                _position += read;
+                return read;
+            }
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            Position = origin switch
+            {
+                SeekOrigin.Begin => offset,
+                SeekOrigin.Current => _position + offset,
+                SeekOrigin.End => Length + offset,
+                _ => throw new ArgumentOutOfRangeException(nameof(origin)),
+            };
+            return _position;
+        }
+
+        public override void Flush()
+        {
+        }
+
+        public override void SetLength(long value) => throw new NotSupportedException();
+
+        public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+    }
 }
 
 /// <summary>

src/MauiNativePdfView/Platforms/Android/PdfViewAndroid.cs

@@ -37,8 +37,12 @@ public class PdfViewAndroid : IPdfView, IDisposable
     private int _currentPage = 0;
     private int _pageCount = 0;
     private bool _disposed;
+    private bool _wasDetached;
     private float _zoom = 1.0f;
     private bool _zoomNeedsApply;
+    private float _offsetX;
+    private float _offsetY;
+    private bool _positionNeedsApply;
     private readonly HashSet<int> _openedPages = new();
     private float _lastReportedZoom = 1.0f;
 
@@ -50,6 +54,7 @@ public class PdfViewAndroid : IPdfView, IDisposable
 
     private TapListener? _tapListener;
     private DrawListener? _drawListener;
+    private AttachStateListener? _attachStateListener;
 
     public PdfViewAndroid(Context context)
     {
@@ -58,6 +63,12 @@ public PdfViewAndroid(Context context)
         // sharing the PdfView's grid cell. Start transparent so an unset MAUI BackgroundColor
         // composites the way callers expect.
         _pdfView.SetBackgroundColor(global::Android.Graphics.Color.Transparent);
+
+        // PDFView releases its document when detached from the window - which happens whenever
+        // another page covers this one, not just on a real teardown - and never reloads on its
+        // own. Reload on genuine reattach instead of relying on callers to notice and ask for it.
+        _attachStateListener = new AttachStateListener(this);
+        _pdfView.AddOnAttachStateChangeListener(_attachStateListener);
     }
 
     /// <summary>
@@ -175,8 +186,8 @@ private void ReclampZoom()
     }
 
     /// <summary>
-    /// Pushes <see cref="_zoom"/> back to the control once it can accept one. Posted so it
-    /// runs after the layout pass that follows a load.
+    /// Pushes <see cref="_zoom"/> (and, after a reattach, the pan position) back to the
+    /// control. Posted so it runs after the layout pass that follows a load.
     /// </summary>
     private void SyncZoom()
     {
@@ -185,8 +196,11 @@ private void SyncZoom()
 
         _pdfView.Post(() =>
         {
-            if (!_disposed && _zoomNeedsApply && TryApplyZoom(_zoom))
+            if (!_disposed && _zoomNeedsApply && TryRestoreZoomAndPosition())
+            {
                 _zoomNeedsApply = false;
+                _positionNeedsApply = false;
+            }
         });
     }
 
@@ -217,16 +231,43 @@ private bool TryApplyZoom(float zoom)
         if (Math.Abs(_pdfView.Zoom - zoom) > float.Epsilon)
         {
             _pdfView.ZoomCenteredTo(zoom, new global::Android.Graphics.PointF(_pdfView.Width / 2f, _pdfView.Height / 2f));
-            _pdfView.LoadPages();
-            // Re-settles the page under a snapping display mode, as the animated path does.
-            _pdfView.PerformPageSnap();
-            // The viewport now covers a different set of pages.
-            EnsureVisiblePagesOpen();
+            RefreshRenderState();
         }
 
         return true;
     }
 
+    /// <summary>
+    /// Reapplies zoom and pan after a reload. After a reattach, the saved zoom and offset are
+    /// a consistent pair, so ZoomTo + MoveTo restores both. Otherwise defers to
+    /// <see cref="TryApplyZoom"/>, which keeps the offset consistent with the zoom.
+    /// </summary>
+    private bool TryRestoreZoomAndPosition()
+    {
+        if (!_positionNeedsApply)
+            return TryApplyZoom(_zoom);
+
+        if (_pageCount == 0 || _pdfView.Width <= 0 || _pdfView.Height <= 0)
+            return false;
+
+        _pdfView.ZoomTo(_zoom);
+        _pdfView.MoveTo(_offsetX, _offsetY);
+        RefreshRenderState();
+
+        return true;
+    }
+
+    /// <summary>
+    /// Re-renders after a zoom or move: reloads visible tiles, re-snaps the page, and opens
+    /// the pages now in view.
+    /// </summary>
+    private void RefreshRenderState()
+    {
+        _pdfView.LoadPages();
+        _pdfView.PerformPageSnap();
+        EnsureVisiblePagesOpen();
+    }
+
     /// <summary>
     /// Opens every page a touch inside the current viewport could resolve to.
     ///
@@ -543,6 +584,27 @@ public void Reload()
 
     #endregion
 
+    private void OnDetachedFromWindow()
+    {
+        _wasDetached = true;
+
+        // Native state is already reset here, so rely on what ReportZoomIfChanged tracked -
+        // and only restore position if that tracking was live (not mid-load).
+        _positionNeedsApply |= !_zoomNeedsApply && _pageCount > 0;
+        _zoomNeedsApply = true;
+    }
+
+    // Only reload on a genuine reattach after a real detach - not the initial attach every
+    // view gets when it's first created, which this would otherwise also fire on.
+    private void OnReattachedToWindow()
+    {
+        if (_disposed || !_wasDetached)
+            return;
+
+        _wasDetached = false;
+        LoadDocument();
+    }
+
     private void LoadDocument(bool preserveZoom = true)
     {
         if (_source == null)
@@ -555,9 +617,15 @@ private void LoadDocument(bool preserveZoom = true)
         // settle on the level to replay afterwards — the same treatment the current page
         // gets — and mark it unapplied.
         if (preserveZoom)
+        {
             CaptureZoom();
+        }
         else
+        {
             _zoom = Math.Clamp(1.0f, _minZoom, _maxZoom);
+            // New document: don't restore the previous one's position.
+            _positionNeedsApply = false;
+        }
 
         _zoomNeedsApply = true;
 
@@ -570,7 +638,7 @@ private void LoadDocument(bool preserveZoom = true)
             {
                 FilePdfSource fileSource => _pdfView.FromFile(new Java.IO.File(fileSource.FilePath)),
                 UriPdfSource uriSource => _pdfView.FromUri(global::Android.Net.Uri.Parse(uriSource.Uri.ToString())),
-                StreamPdfSource streamSource => _pdfView.FromStream(streamSource.Stream),
+                StreamPdfSource streamSource => _pdfView.FromStream(streamSource.OpenDocument()),
                 BytesPdfSource bytesSource => _pdfView.FromBytes(bytesSource.Data),
                 AssetPdfSource assetSource => _pdfView.FromAsset(assetSource.AssetName),
                 _ => throw new NotSupportedException($"PDF source type {_source.GetType().Name} is not supported.")
@@ -670,11 +738,11 @@ private void OnDocumentLoadedWithPageRestore(int pageCount, int pageToRestore)
 
     /// <summary>
     /// Publishes the level the control is actually showing, so a caller bound to Zoom sees a
-    /// pinch or double-tap.
+    /// pinch or double-tap. Also records the pan offset for a reattach restore.
     ///
     /// 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.
+    /// zoom genuinely moved it is three property reads 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,
@@ -688,6 +756,10 @@ private void ReportZoomIfChanged()
         if (_disposed || _zoomNeedsApply || _pageCount == 0)
             return;
 
+        // Before the zoom check - a pan changes the offset without changing zoom.
+        _offsetX = _pdfView.CurrentXOffset;
+        _offsetY = _pdfView.CurrentYOffset;
+
         var zoom = Math.Clamp(_pdfView.Zoom, _minZoom, _maxZoom);
 
         if (Math.Abs(zoom - _lastReportedZoom) < ZoomReportThreshold)
@@ -732,17 +804,6 @@ private void OnRendered(int pageCount)
         Rendered?.Invoke(this, new RenderedEventArgs(pageCount));
     }
 
-    #region Helper Methods
-
-    private PDFView.Configurator FromStream(Stream stream)
-    {
-        var memoryStream = new MemoryStream();
-        stream.CopyTo(memoryStream);
-        return _pdfView.FromBytes(memoryStream.ToArray());
-    }
-
-    #endregion
-
     #region Listener Implementations
 
     private class LoadCompleteListener : Java.Lang.Object, IOnLoadCompleteListener
@@ -900,6 +961,32 @@ public void OnInitiallyRendered(int nbPages)
         }
     }
 
+    private class AttachStateListener : Java.Lang.Object, global::Android.Views.View.IOnAttachStateChangeListener
+    {
+        private readonly WeakReference<PdfViewAndroid> _viewRef;
+
+        public AttachStateListener(PdfViewAndroid view)
+        {
+            _viewRef = new WeakReference<PdfViewAndroid>(view);
+        }
+
+        public void OnViewAttachedToWindow(global::Android.Views.View attachedView)
+        {
+            if (_viewRef.TryGetTarget(out var view))
+            {
+                view.OnReattachedToWindow();
+            }
+        }
+
+        public void OnViewDetachedFromWindow(global::Android.Views.View detachedView)
+        {
+            if (_viewRef.TryGetTarget(out var view))
+            {
+                view.OnDetachedFromWindow();
+            }
+        }
+    }
+
     #endregion
 
     public void Dispose()
@@ -912,6 +999,13 @@ public void Dispose()
         // a disposed Java object and throw on the UI thread.
         _disposed = true;
 
+        if (_attachStateListener != null)
+        {
+            _pdfView?.RemoveOnAttachStateChangeListener(_attachStateListener);
+            _attachStateListener.Dispose();
+            _attachStateListener = null;
+        }
+
         if (_tapListener != null)
         {
             _tapListener.Dispose();