Fix static analyzer warnings

- Remove dead field, async-without-await, GC.SuppressFinalize without
  finalizer, unused volatile compound op, off-by-one in mip selection
- XML doc: missing params, ambiguous crefs, unescaped angle brackets,
  stale symbol names
- field keyword, auto-property, local function, partial for CsWinRT1028
- Null guard for missing IHDR chunk in PNG parser

Author: riyasy

Src/FlyPhotos/Display/Animators/PngAnimator.cs

@@ -27,7 +27,7 @@ namespace FlyPhotos.Display.Animators;
 ///     <para>
 ///         <b>Why PNG re-assembly per frame?</b>
 ///         The Windows WIC PNG codec decodes complete PNG files, not raw chunk sequences.
-///         APNG frame data is stored as sequences of raw IDAT/fdAT chunks — not standalone files.
+///         APNG frame data is stored as sequences of raw IDAT/fdAT chunks � not standalone files.
 ///         To decode each frame, a minimal valid PNG is assembled in memory from the frame's
 ///         chunks plus the shared global chunks (PLTE, tRNS, etc.) and the IHDR with updated
 ///         dimensions, then handed to <c>CanvasBitmap.LoadAsync</c> for decoding.
@@ -195,7 +195,7 @@ private class ApngFrameMetadata
 
     /// <summary>
     ///     Reusable 13-byte IHDR data buffer. IHDR is always exactly 13 bytes per the PNG spec.
-    ///     The width and height fields (bytes 0–3 and 4–7) are overwritten in-place for each
+    ///     The width and height fields (bytes 0�3 and 4�7) are overwritten in-place for each
     ///     frame with the current patch dimensions, avoiding a new array allocation per frame.
     /// </summary>
     private readonly byte[] _ihdrBuffer = new byte[13];
@@ -295,7 +295,7 @@ public static async Task<PngAnimator> CreateAsync(byte[] apngData, ICanvasResour
         {
             var parsedData = await Parser.ParseApngStreamAsync(randomAccessStream);
 
-            // APNG spec (§4.4): delay = DelayNum / (DelayDen == 0 ? 100 : DelayDen) seconds.
+            // APNG spec (�4.4): delay = DelayNum / (DelayDen == 0 ? 100 : DelayDen) seconds.
             // DelayNum == 0 means zero delay, which browsers treat as 100 ms.
             var metadata = parsedData.FrameControls.Select(fc => new ApngFrameMetadata
             {
@@ -361,7 +361,7 @@ public async Task UpdateAsync(TimeSpan totalElapsedTime)
         {
             // Loop wrap-around: instead of clearing _compositedSurface here, we set the previous-frame
             // disposal state to cover the full canvas. RenderFrameAsync(0) will then apply the clear
-            // atomically inside its drawing session — immediately before drawing frame 0's patch —
+            // atomically inside its drawing session � immediately before drawing frame 0's patch �
             // eliminating the async gap between clear and draw that caused a visible flash on loop restart.
 
             _currentFrameIndex = -1;
@@ -389,7 +389,7 @@ private async Task RenderFrameAsync(int frameIndex)
         var metadata = _frameMetadata[frameIndex];
 
         // Reconstruct a minimal valid PNG from the frame's raw chunk data and decode it.
-        // CanvasBitmap.LoadAsync allocates a new GPU texture per frame — unavoidable without
+        // CanvasBitmap.LoadAsync allocates a new GPU texture per frame � unavoidable without
         // a decoded frame cache. _reusableStream and _reusableWriter avoid the per-frame
         // stream and writer allocations that would otherwise occur here.
         using var patchBitmap = await Parser.ReconstructAndLoadCanvasBitmapAsync(
@@ -398,7 +398,7 @@ private async Task RenderFrameAsync(int frameIndex)
             _canvas.Device);
 
         // If this frame specifies dispose-to-previous, snapshot the full compositor surface
-        // now — before we draw — so it can be restored on the next iteration's disposal step.
+        // now � before we draw � so it can be restored on the next iteration's disposal step.
         if (metadata.DisposeOp == APNG_DISPOSE_OP_PREVIOUS)
         {
             using var backupDs = _previousFrameBackup.CreateDrawingSession();
@@ -407,7 +407,7 @@ private async Task RenderFrameAsync(int frameIndex)
 
         using (var ds = _compositedSurface.CreateDrawingSession())
         {
-            // Step 1 — Apply the PREVIOUS frame's dispose operation.
+            // Step 1 � Apply the PREVIOUS frame's dispose operation.
             if (_previousFrameDisposal == APNG_DISPOSE_OP_BACKGROUND)
             {
                 // Clear the previous frame's region to transparent.
@@ -432,7 +432,7 @@ private async Task RenderFrameAsync(int frameIndex)
                     CanvasComposite.Copy);
             }
 
-            // Step 2 — Draw the current frame patch using its specified blend operation.
+            // Step 2 � Draw the current frame patch using its specified blend operation.
             var patchSourceRect = new Rect(0, 0, patchBitmap.SizeInPixels.Width, patchBitmap.SizeInPixels.Height);
 
             if (metadata.BlendOp == APNG_BLEND_OP_SOURCE)
@@ -549,7 +549,7 @@ public class ApngData
             public bool IsDefaultImageFirstFrame;
         }
 
-        /// <summary>Standard 8-byte PNG file signature, per PNG spec §5.2.</summary>
+        /// <summary>Standard 8-byte PNG file signature, per PNG spec �5.2.</summary>
         private static readonly byte[] PngSig = [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
 
         /// <summary>
@@ -596,10 +596,12 @@ public static async Task<ApngData> ParseApngStreamAsync(IRandomAccessStream stre
                     else if (c.Type != "IEND" && c.Type != "acTL")
                     {
                         // Collect global ancillary chunks (PLTE, tRNS, gAMA, cHRM, etc.).
-                        // acTL is intentionally skipped — it merely signals "this is an APNG".
+                        // acTL is intentionally skipped � it merely signals "this is an APNG".
                         global.Add(c);
                     }
 
+                if (ihdr == null) throw new ArgumentException("PNG missing IHDR chunk");
+
                 var ordered = fcs.OrderBy(f => f.SequenceNumber).ToList();
                 bool defaultIsFirst = false;
 
@@ -672,7 +674,7 @@ private static List<PngChunk> ReadAllChunks(BinaryReader r)
                 var len = ReadU32BE(r);
                 var type = Encoding.ASCII.GetString(r.ReadBytes(4));
                 var data = r.ReadBytes((int)len);
-                r.ReadBytes(4); // CRC — verified by the PNG decoder; skipped here for speed.
+                r.ReadBytes(4); // CRC � verified by the PNG decoder; skipped here for speed.
                 res.Add(new PngChunk { Type = type, Data = data });
                 if (type == "IEND") break;
             }
@@ -713,14 +715,14 @@ private static PngChunk ConvertFdat(PngChunk f)
         /// <summary>
         ///     Writes a complete PNG chunk to <paramref name="w" />:
         ///     4-byte big-endian length, 4-byte type, data bytes, 4-byte CRC32.
-        ///     CRC covers the type and data fields, per PNG spec §5.3.
+        ///     CRC covers the type and data fields, per PNG spec �5.3.
         ///     <para>
         ///         <paramref name="crcBuf" /> is a caller-owned scratch buffer grown in place
         ///         via <see cref="Array.Resize{T}" /> only when the chunk (4 type bytes + data)
         ///         exceeds its current capacity. It is never shrunk, so it converges to the size
         ///         of the largest chunk seen and causes no further allocations at steady state.
         ///         The CRC is computed over a <see cref="ReadOnlySpan{T}" /> slice of
-        ///         <paramref name="crcBuf" /> so only the relevant bytes are hashed — no trimmed
+        ///         <paramref name="crcBuf" /> so only the relevant bytes are hashed � no trimmed
         ///         array copy is allocated regardless of whether the buffer is larger than needed.
         ///     </para>
         /// </summary>
@@ -731,7 +733,7 @@ private static void WriteChunk(BinaryWriter w, string t, byte[] d, ref byte[] cr
             if (crcBuf.Length < needed)
                 Array.Resize(ref crcBuf, needed);
 
-            // Encode the 4-byte chunk type directly into the scratch buffer — no temp array.
+            // Encode the 4-byte chunk type directly into the scratch buffer � no temp array.
             Encoding.ASCII.GetBytes(t, 0, 4, crcBuf, 0);
             if (d.Length > 0) Buffer.BlockCopy(d, 0, crcBuf, 4, d.Length);
 

Src/FlyPhotos/Display/Controllers/CanvasController.cs

@@ -13,7 +13,6 @@
 using FlyPhotos.Display.State;
 using FlyPhotos.Infra.Configuration;
 using FlyPhotos.Infra.Utils;
-using Microsoft.Graphics.Canvas;
 using Microsoft.Graphics.Canvas.Brushes;
 using Microsoft.Graphics.Canvas.UI.Xaml;
 using Microsoft.UI;
@@ -35,7 +34,7 @@ namespace FlyPhotos.Display.Controllers;
 ///
 /// All public methods must be called on the UI (DispatcherQueue) thread.
 /// </summary>
-internal class CanvasController : ICanvasController
+internal partial class CanvasController : ICanvasController
 {
     public event Action<int> OnZoomChanged;
     public event Action<bool> OnFitToScreenStateChanged;
@@ -76,7 +75,6 @@ internal class CanvasController : ICanvasController
     private bool _isMultiPageActive;
 
     // W2D-owned: set inside the ZoomOutOnExit action, read in WaitForPanZoomAnimationAsync.
-    private bool _isGoingToExit;
 
     // W2D-owned: true while ZoomAtPointPrecision ticks are arriving (right-click continuous zoom).
     // Treated as animating so Draw uses mip-based quality. Cleared 700 ms after the last tick.
@@ -367,7 +365,6 @@ public void ZoomOutOnExit(double exitAnimationDuration)
         var canvasSize = _d2dCanvas.GetSize();
         EnqueueW2dAction(() =>
         {
-            _isGoingToExit = true;
             _canvasViewManager.ZoomOutOnExit(exitAnimationDuration, canvasSize);
         });
     }
@@ -555,12 +552,11 @@ private void D2dCanvas_SizeChanged(object sender, SizeChangedEventArgs args)
     public Task WaitForPanZoomAnimationAsync(int timeoutMs)
     {
         var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
-        Action handler = null;
-        handler = () =>
+        void handler()
         {
             _canvasViewManager.AnimationCompleted -= handler;
             tcs.TrySetResult();
-        };
+        }
         // Subscribe on the W2D thread so the add is ordered relative to animation ticks and the
         // permanent subscriber — no cross-thread race on the event delegate.
         EnqueueW2dAction(() => _canvasViewManager.AnimationCompleted += handler);

Src/FlyPhotos/Display/Controllers/CanvasViewManager.cs

@@ -876,6 +876,9 @@ private void StartZoomAnimation(float targetScale, Point zoomAnchor)
     /// Starts (or re-targets) a spring that drives scale and pan together (fit / 100% / step).
     /// Velocity carries forward across re-targets, as with <see cref="StartZoomAnimation"/>.
     /// </summary>
+    /// <param name="targetScale">The scale the spring should settle at.</param>
+    /// <param name="targetPosition">The image-centre position the spring should settle at.</param>
+    /// <param name="targetCanvasSize">Canvas size used to compute the settled layout.</param>
     /// <param name="forceReseed">
     /// When true, the spring's internal scale AND pan state are re-seeded from the live view even if a
     /// spring is already running, and velocities are zeroed. Used by the launch open-zoom, which is a

Src/FlyPhotos/Display/Controllers/PhotoDisplayController.cs

@@ -13,7 +13,6 @@
 using FlyPhotos.Display.ImageReading;
 using FlyPhotos.Display.State;
 using FlyPhotos.Infra.Configuration;
-using FlyPhotos.Infra.Utils;
 using FlyPhotos.Services;
 using Microsoft.Graphics.Canvas;
 using Microsoft.Graphics.Canvas.UI.Xaml;
@@ -29,7 +28,7 @@ internal partial class PhotoDisplayController
 
     private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
 
-    private sealed class PhotoCacheTier : IDisposable
+    private sealed partial class PhotoCacheTier : IDisposable
     {
         public readonly ConcurrentStack<int>            Queue    = new();
         public readonly AutoResetEvent                  Signal   = new(false);
@@ -503,7 +502,7 @@ private static async Task<RandomAccessStreamReference> GetCanvasBitmapAsAccessSt
 
     public async Task Fly(NavDirection direction)
     {
-        _keyPressCounter++;
+        Interlocked.Increment(ref _keyPressCounter);
         var keys = _sortedPhotoKeys;
         if (keys.Count <= 1) return;
         int currentPosition = _photoSessionState.CurrentPhotoListPosition;

Src/FlyPhotos/Display/ImageReading/GifReader.cs

@@ -25,7 +25,7 @@ internal static class GifReader
 {
     private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
 
-    // Identity transform reused across calls — avoids a COM object allocation per decode.
+    // Identity transform reused across calls � avoids a COM object allocation per decode.
     private static readonly BitmapTransform IdentityTransform = new();
 
     /// <summary>
@@ -62,17 +62,17 @@ internal static class GifReader
     /// <returns>
     ///     A tuple of (<c>success</c>, <see cref="HqDisplayItem" />):
     ///     <list type="bullet">
-    ///         <item><see cref="StaticHqDisplayItem" /> — for single-frame GIF files.</item>
+    ///         <item><see cref="StaticHqDisplayItem" /> � for single-frame GIF files.</item>
     ///         <item>
-    ///             <see cref="AnimatedHqDisplayItem" /> — for multi-frame (animated) GIF files,
+    ///             <see cref="AnimatedHqDisplayItem" /> � for multi-frame (animated) GIF files,
     ///             carrying the first decoded frame and the raw file bytes for the animator.
     ///         </item>
     ///     </list>
     ///     On failure, returns <c>(false, HqDisplayItem.Empty())</c> and logs the error.
     /// </returns>
     /// <remarks>
-    ///     Frame 0 pixels are decoded via <see cref="BitmapFrame.GetPixelDataAsync" /> on the
-    ///     same decoder instance used for the frame-count check — no second decode pass needed.
+    ///     Frame 0 pixels are decoded via <see cref="BitmapFrame.GetPixelDataAsync()" /> on the
+    ///     same decoder instance used for the frame-count check � no second decode pass needed.
     ///     EXIF orientation is applied so the resulting bitmap is always correctly oriented.
     ///     For animated files, the stream is rewound and re-read as a raw byte array for the
     ///     animator; this is cheaper than a second full pixel decode.
@@ -85,7 +85,7 @@ internal static class GifReader
 
             // One decoder, one stream read.
             // GetPixelDataAsync extracts frame 0 pixels directly from the decoder we already
-            // have — no second BitmapDecoder or second CanvasBitmap.LoadAsync needed.
+            // have � no second BitmapDecoder or second CanvasBitmap.LoadAsync needed.
             var decoder = await BitmapDecoder.CreateAsync(BitmapDecoder.GifDecoderId, stream);
             var frame0 = await decoder.GetFrameAsync(0);
             var pixelProvider = await frame0.GetPixelDataAsync(
@@ -105,7 +105,7 @@ internal static class GifReader
 
             if (decoder.FrameCount > 1) // Animated GIF
             {
-                // Seeking back to read the raw bytes is a simple memcpy — far cheaper
+                // Seeking back to read the raw bytes is a simple memcpy � far cheaper
                 // than a second pixel decode pass.
                 stream.Seek(0);
                 var bytes = await StorageOps.GetInMemByteArray(stream);

Src/FlyPhotos/Display/ImageReading/NativeAvifReader.cs

@@ -24,7 +24,7 @@ internal static class NativeAvifReader
     ///     By extracting the file into a Byte Array immediately, we ensure the file is unlocked from the filesystem for
     ///     subsequent deletion.
     /// </summary>
-    /// <param name="ctrl">The ICanvasResourceCreatorWithDpi surface context used for creating Win2D bitmaps.</param>
+    /// <param name="canvas">The ICanvasResourceCreatorWithDpi surface context used for creating Win2D bitmaps.</param>
     /// <param name="inputPath">The absolute path to the .avif or .heic file.</param>
     /// <returns>A tuple of (success, HqDisplayItem).</returns>
     public static async Task<(bool, HqDisplayItem)> GetHq(ICanvasResourceCreatorWithDpi canvas, string inputPath)

Src/FlyPhotos/Display/ImageReading/WebpReader.cs

@@ -72,7 +72,7 @@ internal static class WebpReader
     /// On failure, returns <c>(false, HqDisplayItem.Empty())</c> and logs the error.
     /// </returns>
     /// <remarks>
-    /// Frame 0 pixels are decoded via <see cref="BitmapFrame.GetPixelDataAsync"/> on the
+    /// Frame 0 pixels are decoded via <see cref="BitmapFrame.GetPixelDataAsync()"/> on the
     /// same decoder instance used for the frame-count check — no second decode pass needed.
     /// EXIF orientation is applied so the resulting bitmap is always correctly oriented.
     /// For animated files, the stream is rewound and re-read as a raw byte array for the

Src/FlyPhotos/Display/ImageRendering/StaticImageRenderer.cs

@@ -55,10 +55,10 @@ private void KickOffMipGeneration()
     {
         _mipGenCts = new CancellationTokenSource();
         var token = _mipGenCts.Token;
-        _ = Task.Run(() => GenerateMipChainAsync(token), token);
+        _ = Task.Run(() => GenerateMipChain(token), token);
     }
 
-    private async Task GenerateMipChainAsync(CancellationToken token)
+    private void GenerateMipChain(CancellationToken token)
     {
         const int MaxLevels = 5;
         const float MinDimension = 64f;

Src/FlyPhotos/Infra/Interop/NativeRustBridge.cs

@@ -41,7 +41,7 @@ internal static partial class NativeRustBridge
     /// <summary>
     /// Returns a heap-allocated array of null-terminated C strings listing every
     /// RAW file extension that rawler can decode (e.g. "ARW", "CR2", …).
-    /// The number of entries is written to <paramref name="count"/>.
+    /// The number of entries is written to <paramref name="size"/>.
     /// </summary>
     /// <remarks>
     /// The returned strings are UPPER-CASE and do NOT include a leading dot.
@@ -52,7 +52,7 @@ internal static partial class NativeRustBridge
     internal static partial nint rawler_get_supported_formats(out int size);
 
     /// <summary>
-    /// Frees a buffer previously returned by <see cref="get_supported_formats"/>.
+    /// Frees a buffer previously returned by <see cref="rawler_get_supported_formats"/>.
     /// <paramref name="size"/> MUST be the same value that was written to the
     /// <c>size</c> out-param of <c>get_supported_formats</c>.
     /// </summary>

Src/FlyPhotos/Infra/Interop/Win32Methods.cs

@@ -291,7 +291,7 @@ internal struct WINDOWPLACEMENT
     /// <see cref="System.Runtime.InteropServices.Marshal.Release"/> on this pointer after use.
     /// </param>
     /// <returns>
-    /// An HRESULT. Pass to <see cref="System.Runtime.InteropServices.Marshal.ThrowExceptionForHR"/>
+    /// An HRESULT. Pass to <see cref="System.Runtime.InteropServices.Marshal.ThrowExceptionForHR(int)"/>
     /// to convert failures into managed exceptions.
     /// </returns>
     [LibraryImport("shcore.dll", StringMarshalling = StringMarshalling.Utf16)]