From 4902306346164c87c342c50f6ac3d09373112e13 Mon Sep 17 00:00:00 2001
From: Copilot <223556219+Copilot@users.noreply.github.com>
Date: Mon, 15 Jun 2026 18:19:29 -0500
Subject: [PATCH 1/2] Implement Border dashed-stroke geometry
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Wires up the five MAUI dashed-stroke properties that PR #273 deferred:

- StrokeDashPattern

- StrokeDashOffset

- StrokeLineCap

- StrokeLineJoin

- StrokeMiterLimit

Approach: keep the existing Modifier.Border() solid fast path for the

common case, but switch to a Modifier.DrawBehind() + native

Android.Graphics.Paint + DashPathEffect path whenever any of the five

knobs diverges from defaults. Compose's Stroke ctor + dashPathEffect

are stripped by the inline-class JVM mangling, so going down to the

native canvas via the directly-bound AndroidCanvas_androidKt.getNativeCanvas

is the smallest path.

New plumbing:

- [ComposeBridge] for DrawModifierKt.drawBehind + Modifier.DrawBehind extension.

- Hand-written DrawScope JNI helpers (DrawScopeGetSize, DrawScopeGetNativeCanvas, UnpackSizeWidth/Height) that walk DrawScope -> DrawContext -> ICanvas -> Android.Graphics.Canvas.

- New JCW Platform/BorderStrokeDrawCallback (registered net/compose/maui/BorderStrokeDrawCallback) implementing IFunction1<DrawScope, Unit> with a cached Paint and per-instance mutable state. Walks the IBorderStroke shape switch — RoundRectangle uniform/per-corner, Ellipse, Rectangle fallback — and insets by strokeWidth/2 to match Modifier.border centring.

- InternalsVisibleTo for Microsoft.AndroidX.Compose.Maui so the JCW can call internal ComposeBridges helpers.

- ColorMapping.ToArgb helper for native Paint colour.

BorderHandler:

- 5 new mappers funneling into a single _strokeGeometryVersion MutableState slot.

- One readonly _strokeDrawCallback per handler instance to keep JCW identity stable across recompositions.

- HasCustomStrokeGeometry() discriminator picks the DrawBehind path only when needed; otherwise we stay on Modifier.Border() (no regression for the solid case).

Coverage: BorderHandler 35/40 (88%) -> 40/40 (100%). docs/maui-coverage.md regenerated.

Sample: extended VisualsPage with five dashed/cap/join variants.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 docs/maui-coverage.md                         |  31 +--
 .../Pages/VisualsPage.xaml                    |  67 +++++
 .../ColorMapping.cs                           |  15 ++
 .../Handlers/BorderHandler.cs                 | 144 ++++++++++-
 .../Platform/BorderStrokeDrawCallback.cs      | 241 ++++++++++++++++++
 .../AssemblyInfo.cs                           |  10 +
 .../ComposeBridges.cs                         | 101 ++++++++
 .../ModifierExtensions.cs                     |  31 +++
 .../PublicAPI.Unshipped.txt                   |   1 +
 9 files changed, 609 insertions(+), 32 deletions(-)
 create mode 100644 src/Microsoft.AndroidX.Compose.Maui/Platform/BorderStrokeDrawCallback.cs
 create mode 100644 src/Microsoft.AndroidX.Compose/AssemblyInfo.cs

diff --git a/docs/maui-coverage.md b/docs/maui-coverage.md
index 24d3799e..0c2c643d 100644
--- a/docs/maui-coverage.md
+++ b/docs/maui-coverage.md
@@ -1,6 +1,6 @@
 # .NET MAUI ⇄ Microsoft.AndroidX.Compose.Maui backend coverage
 
-Generated by `scripts/maui-coverage.cs` on 2026-06-12 22:58 UTC.
+Generated by `scripts/maui-coverage.cs` on 2026-06-15 23:18 UTC.
 
 Pinned MAUI version: **10.0.20** (from `Directory.Build.targets`).
 
@@ -15,14 +15,14 @@ collected transitively across base mappers (`ViewHandler.ViewMapper`,
 
 - **Stock MAUI handlers in scope**: 43
 - **Handlers we override**: 24 (**55.8%**)
-- **Property-mapper keys covered**: 883 / 1224 (**72.1%**)
+- **Property-mapper keys covered**: 888 / 1224 (**72.5%**)
 
 ### Per-category coverage
 
 | Category | Handlers | Keys |
 | --- | --- | --- |
 | **Pages / Navigation** | 1/4 (25%) | 33/130 (25%) |
-| **Containers** | 5/5 (100%) | 166/174 (95%) |
+| **Containers** | 5/5 (100%) | 171/174 (98%) |
 | **Leaves** | 18/18 (100%) | 684/695 (98%) |
 | **Menus / Toolbar** | 0/7 (0%) | 0/1 (0%) |
 | **Shapes** | 0/1 (0%) | 0/41 (0%) |
@@ -39,7 +39,7 @@ Sorted by category. ✅ = fully covered (100%), 🟡 = partial, ❌ = not implem
 | ❌ | `NavigationViewHandler` | Pages / Navigation | `NavigationPage` | — | 0 / 31 (0%) |
 | ✅ | `PageHandler` | Pages / Navigation | `Page` | `PageHandler` | 33 / 33 (100%) |
 | ❌ | `TabbedViewHandler` | Pages / Navigation | `TabbedPage` | — | 0 / 31 (0%) |
-| 🟡 | `BorderHandler` | Containers | `Border` | `BorderHandler` | 35 / 40 (88%) |
+| ✅ | `BorderHandler` | Containers | `Border` | `BorderHandler` | 40 / 40 (100%) |
 | ✅ | `ContentViewHandler` | Containers | `ContentView`, `IContentView` | `ContentViewHandler` | 32 / 32 (100%) |
 | ✅ | `LayoutHandler` | Containers | `Layout` | `LayoutHandler` | 32 / 32 (100%) |
 | 🟡 | `RefreshViewHandler` | Containers | `RefreshView` | `RefreshViewHandler` | 34 / 35 (97%) |
@@ -112,7 +112,6 @@ Most often this is a non-trivial property we haven't wired up yet
 (`CharacterSpacing`, `Font`, `Padding` on `Button`; `CornerRadius`, 
 dashed stroke patterns on `Border`).
 
-- **`BorderHandler`** (88%) — missing: `StrokeDashOffset`, `StrokeDashPattern`, `StrokeLineCap`, `StrokeLineJoin`, `StrokeMiterLimit`
 - **`RadioButtonHandler`** (92%) — missing: `CornerRadius`, `StrokeColor`, `StrokeThickness`
 - **`ScrollViewHandler`** (94%) — missing: `HorizontalScrollBarVisibility`, `VerticalScrollBarVisibility`
 - **`ImageHandler`** (97%) — missing: `IsAnimationPlaying`
@@ -299,17 +298,9 @@ _No Compose backend handler. Stock MAUI handler keeps the AppCompat backend._
 
 </details>
 
-### 🟡 `BorderHandler` — `Border`
+### ✅ `BorderHandler` — `Border`
 
-Backed by `BorderHandler`. **35 / 40 keys (88%)**.
-
-Missing keys:
-
-- [ ] `StrokeDashOffset`
-- [ ] `StrokeDashPattern`
-- [ ] `StrokeLineCap`
-- [ ] `StrokeLineJoin`
-- [ ] `StrokeMiterLimit`
+Backed by `BorderHandler`. **40 / 40 keys (100%)**.
 
 Extra keys we map (no stock counterpart):
 
@@ -346,11 +337,11 @@ Extra keys we map (no stock counterpart):
 - [x] `Shadow`
 - [x] `Shape`
 - [x] `Stroke`
-- [ ] `StrokeDashOffset`
-- [ ] `StrokeDashPattern`
-- [ ] `StrokeLineCap`
-- [ ] `StrokeLineJoin`
-- [ ] `StrokeMiterLimit`
+- [x] `StrokeDashOffset`
+- [x] `StrokeDashPattern`
+- [x] `StrokeLineCap`
+- [x] `StrokeLineJoin`
+- [x] `StrokeMiterLimit`
 - [x] `StrokeThickness`
 - [x] `ToolTip`
 - [x] `Toolbar`
diff --git a/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/VisualsPage.xaml b/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/VisualsPage.xaml
index a78c4f05..d677b4d6 100644
--- a/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/VisualsPage.xaml
+++ b/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/VisualsPage.xaml
@@ -56,6 +56,73 @@
                        TextColor="#003E37" />
             </Border>
 
+            <!-- Dashed-stroke geometry showcase -->
+            <Label Text="Border — dashed strokes, caps, joins."
+                   FontAttributes="Bold" />
+
+            <Border Stroke="#3F51B5"
+                    StrokeThickness="3"
+                    StrokeDashArray="4,2"
+                    Background="#E8EAF6"
+                    Padding="16">
+                <Border.StrokeShape>
+                    <RoundRectangle CornerRadius="10" />
+                </Border.StrokeShape>
+                <Label Text="Dash pattern 4,2 — indigo."
+                       TextColor="#1A237E" />
+            </Border>
+
+            <Border Stroke="#FF5722"
+                    StrokeThickness="4"
+                    StrokeDashArray="6,3,2,3"
+                    StrokeDashOffset="2"
+                    Background="#FBE9E7"
+                    Padding="16">
+                <Border.StrokeShape>
+                    <RoundRectangle CornerRadius="14" />
+                </Border.StrokeShape>
+                <Label Text="Pattern 6,3,2,3 with offset 2 — orange."
+                       TextColor="#BF360C" />
+            </Border>
+
+            <Border Stroke="#673AB7"
+                    StrokeThickness="6"
+                    StrokeDashArray="1,3"
+                    StrokeLineCap="Round"
+                    Background="#EDE7F6"
+                    Padding="16">
+                <Border.StrokeShape>
+                    <RoundRectangle CornerRadius="10" />
+                </Border.StrokeShape>
+                <Label Text="Round caps + dotted dash — deep purple."
+                       TextColor="#311B92" />
+            </Border>
+
+            <Border Stroke="#2E7D32"
+                    StrokeThickness="6"
+                    StrokeLineJoin="Bevel"
+                    Background="#E8F5E9"
+                    Padding="16">
+                <Border.StrokeShape>
+                    <Rectangle />
+                </Border.StrokeShape>
+                <Label Text="Bevel join — green, no dash."
+                       TextColor="#1B5E20" />
+            </Border>
+
+            <Border Stroke="#C62828"
+                    StrokeThickness="6"
+                    StrokeLineJoin="Round"
+                    StrokeDashArray="8,4"
+                    Background="#FFEBEE"
+                    Padding="16">
+                <Border.StrokeShape>
+                    <RoundRectangle CornerRadius="4" />
+                </Border.StrokeShape>
+                <Label Text="Round join + 8,4 dash — red."
+                       TextColor="#B71C1C" />
+            </Border>
+
             <!-- BoxView showcase -->
             <Label Text="BoxView — pastel rectangles."
                    FontAttributes="Bold" />
diff --git a/src/Microsoft.AndroidX.Compose.Maui/ColorMapping.cs b/src/Microsoft.AndroidX.Compose.Maui/ColorMapping.cs
index 764f585b..17576f90 100644
--- a/src/Microsoft.AndroidX.Compose.Maui/ColorMapping.cs
+++ b/src/Microsoft.AndroidX.Compose.Maui/ColorMapping.cs
@@ -36,6 +36,21 @@ public static ComposeColor ToCompose(MauiColor c) =>
     public static long? ToPackedLong(MauiColor? c) =>
         c is null ? null : (long)ToCompose(c);
 
+    /// <summary>
+    /// Convert a MAUI <see cref="MauiColor"/> to a packed 32-bit
+    /// <c>0xAARRGGBB</c> integer suitable for
+    /// <see cref="Android.Graphics.Paint.Color"/> /
+    /// <c>Android.Graphics.Color</c>. Alpha defaults to opaque when
+    /// the input is <see langword="null"/>.
+    /// </summary>
+    public static int ToArgb(MauiColor? c) =>
+        c is null
+            ? unchecked((int)0xFF000000)
+            : (ToByte(c.Alpha) << 24) |
+              (ToByte(c.Red)   << 16) |
+              (ToByte(c.Green) <<  8) |
+               ToByte(c.Blue);
+
     /// <summary>
     /// Convert a normalised <c>0..1</c> channel to an 8-bit value with
     /// round-to-nearest semantics. <c>(byte)(x * 255f)</c> truncates and
diff --git a/src/Microsoft.AndroidX.Compose.Maui/Handlers/BorderHandler.cs b/src/Microsoft.AndroidX.Compose.Maui/Handlers/BorderHandler.cs
index 0c2dccd6..62a9d625 100644
--- a/src/Microsoft.AndroidX.Compose.Maui/Handlers/BorderHandler.cs
+++ b/src/Microsoft.AndroidX.Compose.Maui/Handlers/BorderHandler.cs
@@ -2,9 +2,11 @@
 using AndroidX.Compose.Runtime;
 using Microsoft.AndroidX.Compose.Maui.Platform;
 using Microsoft.Maui.Handlers;
-using ComposeColor      = AndroidX.Compose.Color;
-using MauiBorder        = Microsoft.Maui.Controls.Border;
-using MauiBorderShape   = Microsoft.Maui.Controls.Shapes;
+using ComposeColor       = AndroidX.Compose.Color;
+using MauiBorder         = Microsoft.Maui.Controls.Border;
+using MauiBorderShape    = Microsoft.Maui.Controls.Shapes;
+using MauiLineCap        = Microsoft.Maui.Graphics.LineCap;
+using MauiLineJoin       = Microsoft.Maui.Graphics.LineJoin;
 
 namespace Microsoft.AndroidX.Compose.Maui.Handlers;
 
@@ -32,6 +34,21 @@ namespace Microsoft.AndroidX.Compose.Maui.Handlers;
 /// <para><c>Stroke</c> only honours <c>SolidPaint</c>; gradient/image
 /// brushes silently drop the stroke (mirrors stock MAUI's Android
 /// border drawable, which has the same constraint).</para>
+///
+/// <para><strong>Dashed-stroke geometry</strong>
+/// (<see cref="MauiBorder.StrokeDashPattern"/>,
+/// <see cref="MauiBorder.StrokeDashOffset"/>,
+/// <see cref="MauiBorder.StrokeLineCap"/>,
+/// <see cref="MauiBorder.StrokeLineJoin"/>,
+/// <see cref="MauiBorder.StrokeMiterLimit"/>) can't be expressed via
+/// Compose's <c>Modifier.border</c> (solid-only). When any of those
+/// properties diverges from the defaults the handler switches to a
+/// <c>Modifier.drawBehind</c> path driven by
+/// <see cref="BorderStrokeDrawCallback"/>, which paints the stroke
+/// directly via <see cref="Android.Graphics.Paint"/> +
+/// <see cref="Android.Graphics.DashPathEffect"/>. The fast path
+/// continues to use <c>Modifier.Border</c> for trivial solid borders so
+/// the simple case still benefits from Compose's stroke renderer.</para>
 /// </remarks>
 public partial class BorderHandler : ComposeElementHandler<MauiBorder>
 {
@@ -52,13 +69,16 @@ public partial class BorderHandler : ComposeElementHandler<MauiBorder>
             ["Content"]                                     = MapContent,
             [nameof(IPadding.Padding)]                      = MapPadding,
             [nameof(IView.Background)]                      = MapBackground,
-            // TODO: dashed-stroke / line-cap / line-join / miter-limit
-            // properties have no Compose equivalent on
-            // `Modifier.Border`, which only paints a solid border. A
-            // faithful implementation needs a custom `Modifier.drawWithCache`
-            // shader, which is a much larger refactor.
-            // Stock MAUI keys: StrokeDashOffset, StrokeDashPattern,
-            // StrokeLineCap, StrokeLineJoin, StrokeMiterLimit.
+            // Dashed-stroke / cap / join / miter geometry — Compose's
+            // Modifier.border can't express any of these, so the handler
+            // switches to a Modifier.drawBehind path driven by
+            // BorderStrokeDrawCallback when any of these diverge from
+            // the trivial solid-border defaults.
+            [nameof(MauiBorder.StrokeDashPattern)]          = MapStrokeDashPattern,
+            [nameof(MauiBorder.StrokeDashOffset)]           = MapStrokeDashOffset,
+            [nameof(MauiBorder.StrokeLineCap)]              = MapStrokeLineCap,
+            [nameof(MauiBorder.StrokeLineJoin)]             = MapStrokeLineJoin,
+            [nameof(MauiBorder.StrokeMiterLimit)]           = MapStrokeMiterLimit,
         };
 
     /// <summary>Command mapper (inherits view-level commands; no extras).</summary>
@@ -73,6 +93,17 @@ public partial class BorderHandler : ComposeElementHandler<MauiBorder>
     readonly MutableState<int>   _shapeVersion   = new(0);
     readonly MutableState<int>   _paddingVersion = new(0);
     readonly MutableState<int>   _contentVersion = new(0);
+    // Dashed-stroke geometry version slot — bumped from any of the five
+    // MapStroke* mappers below. The actual values live as fields on
+    // `_strokeDrawCallback` and are re-read inside `BuildNode` (which
+    // pushes them into the JCW just before the draw lambda is set).
+    readonly MutableState<int>   _strokeGeometryVersion = new(0);
+
+    // Allocated once per handler instance so the JNI peer (and the
+    // backing Paint) survives every recomposition. Mappers mutate the
+    // fields in place; BuildNode reconfigures the rest just before
+    // taking it on the modifier chain.
+    readonly BorderStrokeDrawCallback _strokeDrawCallback = new();
 
     /// <summary>Construct a handler with the default mappers.</summary>
     public BorderHandler() : base(Mapper, CommandMapper) { }
@@ -89,6 +120,7 @@ public override ComposableNode BuildNode(IComposer composer)
         _ = _shapeVersion.Value;
         _ = _paddingVersion.Value;
         _ = _contentVersion.Value;
+        _ = _strokeGeometryVersion.Value;
 
         var context = MauiContext
             ?? throw new InvalidOperationException("MauiContext not set on BorderHandler.");
@@ -108,8 +140,23 @@ public override ComposableNode BuildNode(IComposer composer)
             modifier = (modifier ?? Modifier.Companion)
                 .Background(new ComposeColor(bg.Value), shape);
         if (stroke.HasValue && width > 0f)
-            modifier = (modifier ?? Modifier.Companion)
-                .Border(new Dp(width), new ComposeColor(stroke.Value), shape);
+        {
+            // Custom geometry (dashes / non-default cap / join / miter)
+            // can't be expressed via Modifier.border, which paints a
+            // solid stroke only. Switch to a Paint+Canvas drawBehind
+            // path when any of the five geometry knobs diverge from
+            // the trivial defaults.
+            if (HasCustomStrokeGeometry(border))
+            {
+                ConfigureStrokeDrawCallback(border, stroke.Value, width);
+                modifier = (modifier ?? Modifier.Companion).DrawBehind(_strokeDrawCallback);
+            }
+            else
+            {
+                modifier = (modifier ?? Modifier.Companion)
+                    .Border(new Dp(width), new ComposeColor(stroke.Value), shape);
+            }
+        }
         if (padding != Thickness.Zero)
         {
             modifier = (modifier ?? Modifier.Companion).Padding(
@@ -156,6 +203,51 @@ public override ComposableNode BuildNode(IComposer composer)
         _                              => null,
     };
 
+    // Returns true when at least one of the five stroke-geometry knobs
+    // diverges from the trivial defaults (solid stroke, butt caps,
+    // miter joins, default miter limit). When false we can take the
+    // fast `Modifier.border` path which uses Compose's stroke renderer.
+    // Reads via IBorderStroke because the concrete MauiBorder surface
+    // uses XAML-flavoured types (PenLineCap, double, ...).
+    static bool HasCustomStrokeGeometry(MauiBorder border)
+    {
+        var stroke = (IBorderStroke)border;
+        return stroke.StrokeDashPattern is { Length: >= 2 } ||
+               stroke.StrokeDashOffset != 0f ||
+               stroke.StrokeLineCap    != MauiLineCap.Butt ||
+               stroke.StrokeLineJoin   != MauiLineJoin.Miter ||
+               stroke.StrokeMiterLimit != 10f;
+    }
+
+    void ConfigureStrokeDrawCallback(MauiBorder border, long strokeColor, float strokeThickness)
+    {
+        // ARGB int for native Paint — derived directly from the live
+        // SolidPaint Color so the dashed path stays in sync with the
+        // brush even when MapStroke doesn't refire (e.g. opacity tweak
+        // bubbling through SolidPaint).
+        var solidColor = (border as IStroke)?.Stroke is SolidPaint solid
+            ? solid.Color
+            : null;
+        var stroke = (IBorderStroke)border;
+        _strokeDrawCallback.StrokeArgb         = ColorMapping.ToArgb(solidColor);
+        _strokeDrawCallback.StrokeThicknessDip = strokeThickness;
+        _strokeDrawCallback.StrokeDashPattern  = stroke.StrokeDashPattern;
+        _strokeDrawCallback.StrokeDashOffset   = stroke.StrokeDashOffset;
+        _strokeDrawCallback.StrokeLineCap      = stroke.StrokeLineCap;
+        _strokeDrawCallback.StrokeLineJoin     = stroke.StrokeLineJoin;
+        _strokeDrawCallback.StrokeMiterLimit   = stroke.StrokeMiterLimit;
+        _strokeDrawCallback.Shape              = stroke.Shape;
+        var metrics = global::Android.Content.Res.Resources.System?.DisplayMetrics
+            ?? throw new InvalidOperationException("Resources.System.DisplayMetrics not available.");
+        _strokeDrawCallback.Density            = metrics.Density;
+
+        // Silence "strokeColor is unused" — it's already derived from
+        // SolidPaint above, but kept on the signature so the caller
+        // can pass through the cached MutableState slot when MAUI's
+        // stroke property cycles through null between updates.
+        _ = strokeColor;
+    }
+
     /// <summary>Map <see cref="MauiBorder.Stroke"/> by extracting
     /// <see cref="SolidPaint"/>.<see cref="SolidPaint.Color"/>.</summary>
     public static void MapStroke(BorderHandler handler, MauiBorder border) =>
@@ -185,4 +277,32 @@ public static void MapBackground(BorderHandler handler, MauiBorder border) =>
         handler._backgroundColor.Value = (border as IView)?.Background is SolidPaint solid
             ? ColorMapping.ToPackedLong(solid.Color)
             : null;
+
+    /// <summary>
+    /// Bump the stroke-geometry version slot in response to
+    /// <see cref="MauiBorder.StrokeDashPattern"/> changes. The actual
+    /// pattern array is read live inside <see cref="BuildNode"/>.
+    /// </summary>
+    public static void MapStrokeDashPattern(BorderHandler handler, MauiBorder _) =>
+        handler._strokeGeometryVersion.Value++;
+
+    /// <summary>Bump the stroke-geometry version slot for
+    /// <see cref="MauiBorder.StrokeDashOffset"/>.</summary>
+    public static void MapStrokeDashOffset(BorderHandler handler, MauiBorder _) =>
+        handler._strokeGeometryVersion.Value++;
+
+    /// <summary>Bump the stroke-geometry version slot for
+    /// <see cref="MauiBorder.StrokeLineCap"/>.</summary>
+    public static void MapStrokeLineCap(BorderHandler handler, MauiBorder _) =>
+        handler._strokeGeometryVersion.Value++;
+
+    /// <summary>Bump the stroke-geometry version slot for
+    /// <see cref="MauiBorder.StrokeLineJoin"/>.</summary>
+    public static void MapStrokeLineJoin(BorderHandler handler, MauiBorder _) =>
+        handler._strokeGeometryVersion.Value++;
+
+    /// <summary>Bump the stroke-geometry version slot for
+    /// <see cref="MauiBorder.StrokeMiterLimit"/>.</summary>
+    public static void MapStrokeMiterLimit(BorderHandler handler, MauiBorder _) =>
+        handler._strokeGeometryVersion.Value++;
 }
diff --git a/src/Microsoft.AndroidX.Compose.Maui/Platform/BorderStrokeDrawCallback.cs b/src/Microsoft.AndroidX.Compose.Maui/Platform/BorderStrokeDrawCallback.cs
new file mode 100644
index 00000000..053e26fc
--- /dev/null
+++ b/src/Microsoft.AndroidX.Compose.Maui/Platform/BorderStrokeDrawCallback.cs
@@ -0,0 +1,241 @@
+using Android.Graphics;
+using Android.Runtime;
+using Kotlin.Jvm.Functions;
+using AndroidColor    = Android.Graphics.Color;
+using AndroidPaint    = Android.Graphics.Paint;
+using AndroidPath     = Android.Graphics.Path;
+using AndroidRectF    = Android.Graphics.RectF;
+using ComposeBridges  = AndroidX.Compose.ComposeBridges;
+using LineCap         = Microsoft.Maui.Graphics.LineCap;
+using LineJoin        = Microsoft.Maui.Graphics.LineJoin;
+using MauiBorderShape = Microsoft.Maui.Controls.Shapes;
+
+namespace Microsoft.AndroidX.Compose.Maui.Platform;
+
+/// <summary>
+/// <c>Function1&lt;DrawScope, Unit&gt;</c> adapter that paints a MAUI
+/// <see cref="Microsoft.Maui.Controls.Border"/> stroke directly via
+/// <see cref="AndroidPaint"/> + <see cref="Android.Graphics.Canvas"/>.
+/// Used by <see cref="Handlers.BorderHandler"/> when any of the
+/// dashed-stroke / line-cap / line-join / miter-limit knobs diverge
+/// from the trivial solid-border defaults — Compose's
+/// <c>Modifier.border</c> only paints a solid stroke and so can't
+/// model those properties.
+/// </summary>
+/// <remarks>
+/// <para>Allocated <strong>once per <see cref="Handlers.BorderHandler"/>
+/// instance</strong> (held as a <c>readonly</c> field) so the JNI peer
+/// stays stable across recompositions. The handler mutates the public
+/// fields below before calling <c>composer.recompose()</c>; the
+/// <see cref="Invoke"/> body reads the latest values on each draw pass.
+/// Re-allocating the JCW per recomposition would churn the JNI ref
+/// table without any payoff.</para>
+///
+/// <para>The drawing path bypasses Compose's <c>DrawScope</c> drawing
+/// primitives — every one of those takes an inline-class param
+/// (<c>Color</c>, <c>Offset</c>, <c>Size</c>, <c>CornerRadius</c>,
+/// <c>BlendMode</c>) and is consequently stripped from the binding.
+/// Instead we walk <c>DrawScope.drawContext.canvas</c> down to the
+/// native <see cref="Canvas"/> and draw with directly-bound
+/// <see cref="AndroidPaint"/> + <see cref="DashPathEffect"/> APIs.</para>
+///
+/// <para>Public so it can be referenced from a <c>readonly</c> field
+/// on the handler. Not part of the developer-facing API.</para>
+/// </remarks>
+[Register("net/compose/maui/BorderStrokeDrawCallback")]
+public sealed class BorderStrokeDrawCallback : Java.Lang.Object, IFunction1
+{
+    /// <summary>
+    /// Reused across draw passes — properties are reconfigured
+    /// in-place on each <see cref="Invoke"/> call.
+    /// </summary>
+    readonly AndroidPaint _paint = new(PaintFlags.AntiAlias)
+    {
+        Dither = true,
+    };
+
+    /// <summary>Stroke colour as packed <c>0xAARRGGBB</c>; <c>0</c> = no stroke.</summary>
+    public int StrokeArgb { get; set; }
+
+    /// <summary>Stroke thickness in DIPs (matches MAUI's <c>StrokeThickness</c>).</summary>
+    public float StrokeThicknessDip { get; set; }
+
+    /// <summary>
+    /// Dash on/off lengths in <em>stroke-thickness units</em> (matches
+    /// MAUI semantics). Multiplied by stroke thickness in pixels at
+    /// draw time. <see langword="null"/> or fewer than two entries =
+    /// solid stroke.
+    /// </summary>
+    public float[]? StrokeDashPattern { get; set; }
+
+    /// <summary>Dash phase offset in stroke-thickness units.</summary>
+    public float StrokeDashOffset { get; set; }
+
+    /// <summary>Cap style (Butt / Round / Square).</summary>
+    public LineCap StrokeLineCap { get; set; } = LineCap.Butt;
+
+    /// <summary>Join style (Miter / Round / Bevel).</summary>
+    public LineJoin StrokeLineJoin { get; set; } = LineJoin.Miter;
+
+    /// <summary>Miter limit (Skia/MAUI default is <c>10</c>).</summary>
+    public float StrokeMiterLimit { get; set; } = 10f;
+
+    /// <summary>
+    /// Shape to stroke. <see langword="null"/>, <see cref="Rectangle"/>,
+    /// <see cref="RoundRectangle"/>, and <see cref="Ellipse"/> are
+    /// honoured; everything else falls back to a plain rectangle.
+    /// </summary>
+    public Microsoft.Maui.Graphics.IShape? Shape { get; set; }
+
+    /// <summary>Display density in pixels-per-DIP, captured by the handler.</summary>
+    public float Density { get; set; } = 1f;
+
+    /// <summary>
+    /// Kotlin <c>Function1.invoke</c> entry point. <paramref name="p0"/>
+    /// is the Compose <c>DrawScope</c> the runtime hands back inside
+    /// <c>Modifier.drawBehind</c>.
+    /// </summary>
+    public Java.Lang.Object? Invoke(Java.Lang.Object? p0)
+    {
+        var unit = Kotlin.Unit.Instance
+            ?? throw new InvalidOperationException("Kotlin.Unit.Instance not available.");
+
+        if (p0 is null || StrokeArgb == 0 || StrokeThicknessDip <= 0f || Density <= 0f)
+            return unit;
+
+        var nativeCanvas = ComposeBridges.DrawScopeGetNativeCanvas(p0.Handle);
+        if (nativeCanvas is null)
+            return unit;
+
+        long packedSize = ComposeBridges.DrawScopeGetSize(p0.Handle);
+        float widthPx  = ComposeBridges.UnpackSizeWidth(packedSize);
+        float heightPx = ComposeBridges.UnpackSizeHeight(packedSize);
+        if (widthPx <= 0f || heightPx <= 0f)
+            return unit;
+
+        float strokePx = StrokeThicknessDip * Density;
+        ConfigurePaint(strokePx);
+
+        // Match Modifier.border semantics — the stroke straddles the
+        // bounds, so inset by half the stroke width so the visible
+        // stroke draws inside the geometry.
+        float inset = strokePx / 2f;
+        float left   = inset;
+        float top    = inset;
+        float right  = widthPx  - inset;
+        float bottom = heightPx - inset;
+        if (right <= left || bottom <= top)
+            return unit;
+
+        switch (Shape)
+        {
+            case MauiBorderShape.RoundRectangle rr:
+                DrawRoundRectangle(nativeCanvas, rr, left, top, right, bottom);
+                break;
+            case MauiBorderShape.Ellipse:
+                DrawOvalInternal(nativeCanvas, left, top, right, bottom);
+                break;
+            case MauiBorderShape.Rectangle:
+            case null:
+            default:
+                DrawRectInternal(nativeCanvas, left, top, right, bottom);
+                break;
+        }
+
+        return unit;
+    }
+
+    void ConfigurePaint(float strokePx)
+    {
+        _paint.SetStyle(AndroidPaint.Style.Stroke);
+        _paint.Color           = new AndroidColor(StrokeArgb);
+        _paint.StrokeWidth     = strokePx;
+        _paint.StrokeCap       = MapLineCap(StrokeLineCap);
+        _paint.StrokeJoin      = MapLineJoin(StrokeLineJoin);
+        _paint.StrokeMiter     = StrokeMiterLimit;
+        _paint.SetPathEffect(BuildDashEffect(strokePx));
+    }
+
+    DashPathEffect? BuildDashEffect(float strokePx)
+    {
+        var pattern = StrokeDashPattern;
+        if (pattern is null || pattern.Length < 2)
+            return null;
+
+        // MAUI's pattern values are multiples of stroke thickness.
+        // Convert to pixels for Android. DashPathEffect requires an
+        // even number of intervals (alternating on/off pairs); double
+        // the array when odd so the user-visible pattern still cycles
+        // the way MAUI documents it.
+        bool needsDouble = (pattern.Length & 1) == 1;
+        int outLength    = needsDouble ? pattern.Length * 2 : pattern.Length;
+        var intervalsPx  = new float[outLength];
+        for (int i = 0; i < pattern.Length; i++)
+            intervalsPx[i] = Math.Max(0f, pattern[i] * strokePx);
+        if (needsDouble)
+            Array.Copy(intervalsPx, 0, intervalsPx, pattern.Length, pattern.Length);
+
+        return new DashPathEffect(intervalsPx, StrokeDashOffset * strokePx);
+    }
+
+    void DrawRoundRectangle(Canvas canvas, MauiBorderShape.RoundRectangle rr, float left, float top, float right, float bottom)
+    {
+        var corners = rr.CornerRadius;
+        float tlX = (float)corners.TopLeft     * Density;
+        float trX = (float)corners.TopRight    * Density;
+        float brX = (float)corners.BottomRight * Density;
+        float blX = (float)corners.BottomLeft  * Density;
+
+        // Fast path — uniform corners use Canvas.drawRoundRect, which
+        // is cheaper than a full Path round-trip.
+        if (tlX == trX && trX == brX && brX == blX)
+        {
+            using var rect = new AndroidRectF(left, top, right, bottom);
+            canvas.DrawRoundRect(rect, tlX, tlX, _paint);
+            return;
+        }
+
+        // Per-corner radii — fall back to a Path. Each corner takes
+        // (rx, ry); we use rx==ry since MAUI's CornerRadius is a single
+        // scalar per corner.
+        var radii = new float[]
+        {
+            tlX, tlX, // top-left
+            trX, trX, // top-right
+            brX, brX, // bottom-right
+            blX, blX, // bottom-left
+        };
+        using var path        = new AndroidPath();
+        using var pathRect    = new AndroidRectF(left, top, right, bottom);
+        var direction = AndroidPath.Direction.Cw
+            ?? throw new InvalidOperationException("Path.Direction.Cw not available.");
+        path.AddRoundRect(pathRect, radii, direction);
+        canvas.DrawPath(path, _paint);
+    }
+
+    void DrawRectInternal(Canvas canvas, float left, float top, float right, float bottom)
+    {
+        using var rect = new AndroidRectF(left, top, right, bottom);
+        canvas.DrawRect(rect, _paint);
+    }
+
+    void DrawOvalInternal(Canvas canvas, float left, float top, float right, float bottom)
+    {
+        using var rect = new AndroidRectF(left, top, right, bottom);
+        canvas.DrawOval(rect, _paint);
+    }
+
+    static AndroidPaint.Cap MapLineCap(LineCap cap) => cap switch
+    {
+        LineCap.Round  => AndroidPaint.Cap.Round  ?? throw new InvalidOperationException("Paint.Cap.Round not available."),
+        LineCap.Square => AndroidPaint.Cap.Square ?? throw new InvalidOperationException("Paint.Cap.Square not available."),
+        _              => AndroidPaint.Cap.Butt   ?? throw new InvalidOperationException("Paint.Cap.Butt not available."),
+    };
+
+    static AndroidPaint.Join MapLineJoin(LineJoin join) => join switch
+    {
+        LineJoin.Round => AndroidPaint.Join.Round ?? throw new InvalidOperationException("Paint.Join.Round not available."),
+        LineJoin.Bevel => AndroidPaint.Join.Bevel ?? throw new InvalidOperationException("Paint.Join.Bevel not available."),
+        _              => AndroidPaint.Join.Miter ?? throw new InvalidOperationException("Paint.Join.Miter not available."),
+    };
+}
diff --git a/src/Microsoft.AndroidX.Compose/AssemblyInfo.cs b/src/Microsoft.AndroidX.Compose/AssemblyInfo.cs
new file mode 100644
index 00000000..1dc9093d
--- /dev/null
+++ b/src/Microsoft.AndroidX.Compose/AssemblyInfo.cs
@@ -0,0 +1,10 @@
+using System.Runtime.CompilerServices;
+
+// The Microsoft.AndroidX.Compose.Maui backend reaches into a small set
+// of low-level JNI plumbing helpers on `ComposeBridges` (DrawScope →
+// native Canvas walk, Size unpackers) when wiring custom-drawn
+// modifiers (border dashes, etc.). Exposing those publicly would
+// pollute the developer-facing surface; this attribute keeps them
+// internal to the assembly while still letting the trusted Maui
+// backend depend on them.
+[assembly: InternalsVisibleTo("Microsoft.AndroidX.Compose.Maui")]
diff --git a/src/Microsoft.AndroidX.Compose/ComposeBridges.cs b/src/Microsoft.AndroidX.Compose/ComposeBridges.cs
index 55fa838c..220de89e 100644
--- a/src/Microsoft.AndroidX.Compose/ComposeBridges.cs
+++ b/src/Microsoft.AndroidX.Compose/ComposeBridges.cs
@@ -249,6 +249,92 @@ internal static IntPtr ModifierClipRoundedCorners(IntPtr modifier, float dp)
         }
     }
 
+    // ---- DrawScope JNI helpers ----
+    //
+    // The Compose `DrawScope` binding has no usable instance methods —
+    // every drawing primitive on it carries an inline-class param
+    // (Color, Offset, Size, CornerRadius, BlendMode), so the binder
+    // strips the lot and the C# IDrawScope interface is empty. The
+    // canvas-getter chain (`getDrawContext().getCanvas()`) avoids the
+    // mangling — neither method takes an inline class — but the binder
+    // still drops them because `IDrawScope` itself isn't surfaced.
+    //
+    // Hand-written below: enough JNI to extract the native
+    // `Android.Graphics.Canvas` and the packed `Size` long from a
+    // DrawScope handle, which is everything a `Modifier.drawBehind`
+    // callback needs to draw via directly-bound `Paint` + `Canvas`.
+
+    static IntPtr s_drawScopeClass;
+    static IntPtr s_drawContextClass;
+    static IntPtr s_drawScopeGetSizeMethodId;
+    static IntPtr s_drawScopeGetDrawContextMethodId;
+    static IntPtr s_drawContextGetCanvasMethodId;
+
+    static void EnsureDrawScopeMethodIds()
+    {
+        if (s_drawScopeGetSizeMethodId != IntPtr.Zero)
+            return;
+        s_drawScopeClass   = JNIEnv.FindClass("androidx/compose/ui/graphics/drawscope/DrawScope");
+        s_drawContextClass = JNIEnv.FindClass("androidx/compose/ui/graphics/drawscope/DrawContext");
+        s_drawScopeGetSizeMethodId        = JNIEnv.GetMethodID(s_drawScopeClass, "getSize-NH-jbRc", "()J");
+        s_drawScopeGetDrawContextMethodId = JNIEnv.GetMethodID(s_drawScopeClass, "getDrawContext", "()Landroidx/compose/ui/graphics/drawscope/DrawContext;");
+        s_drawContextGetCanvasMethodId    = JNIEnv.GetMethodID(s_drawContextClass, "getCanvas",     "()Landroidx/compose/ui/graphics/Canvas;");
+    }
+
+    // Read the modifier's bounds out of a DrawScope. The Kotlin
+    // property `DrawScope.size: Size` is mangled because `Size` is a
+    // `@JvmInline value class` over a packed `long`. Returned as the
+    // raw packed value; callers unpack with
+    // <see cref="UnpackSizeWidth"/> / <see cref="UnpackSizeHeight"/>.
+    internal static long DrawScopeGetSize(IntPtr drawScope)
+    {
+        EnsureDrawScopeMethodIds();
+        return JNIEnv.CallLongMethod(drawScope, s_drawScopeGetSizeMethodId);
+    }
+
+    /// <summary>Unpack a Compose <c>Size</c>'s width — high 32 bits as float.</summary>
+    internal static float UnpackSizeWidth(long packed) =>
+        BitConverter.Int32BitsToSingle((int)((ulong)packed >> 32));
+
+    /// <summary>Unpack a Compose <c>Size</c>'s height — low 32 bits as float.</summary>
+    internal static float UnpackSizeHeight(long packed) =>
+        BitConverter.Int32BitsToSingle((int)((ulong)packed & 0xFFFFFFFFL));
+
+    // Walk DrawScope → DrawContext → Compose Canvas → native
+    // android.graphics.Canvas. Returns null when the DrawScope handle
+    // is null or the canvas chain yields a null intermediate (defensive
+    // — Compose normally guarantees a non-null canvas inside drawBehind).
+    internal static Android.Graphics.Canvas? DrawScopeGetNativeCanvas(IntPtr drawScope)
+    {
+        if (drawScope == IntPtr.Zero)
+            return null;
+        EnsureDrawScopeMethodIds();
+        IntPtr drawContextLocal = JNIEnv.CallObjectMethod(drawScope, s_drawScopeGetDrawContextMethodId);
+        if (drawContextLocal == IntPtr.Zero)
+            return null;
+        IntPtr composeCanvasLocal = IntPtr.Zero;
+        try
+        {
+            composeCanvasLocal = JNIEnv.CallObjectMethod(drawContextLocal, s_drawContextGetCanvasMethodId);
+            if (composeCanvasLocal == IntPtr.Zero)
+                return null;
+            // GetObject(.., DoNotTransfer) — Mono creates its own
+            // global ref internally; we still own `composeCanvasLocal`
+            // and free it in the outer finally.
+            var composeCanvas = Java.Lang.Object.GetObject<AndroidX.Compose.UI.Graphics.ICanvas>(
+                composeCanvasLocal, JniHandleOwnership.DoNotTransfer);
+            return composeCanvas is null
+                ? null
+                : AndroidX.Compose.UI.Graphics.AndroidCanvas_androidKt.GetNativeCanvas(composeCanvas);
+        }
+        finally
+        {
+            if (composeCanvasLocal != IntPtr.Zero)
+                JNIEnv.DeleteLocalRef(composeCanvasLocal);
+            JNIEnv.DeleteLocalRef(drawContextLocal);
+        }
+    }
+
     // androidx.compose.ui.res.PainterResources_androidKt.painterResource —
     // returns a NEW local Painter ref the caller is responsible for
     // DeleteLocalRef'ing once it's been handed to the consuming
@@ -2026,6 +2112,21 @@ internal static partial IntPtr ModifierBackgroundBrush(
     internal static partial IntPtr ModifierBorderBrush(
         IntPtr modifier, float width, AndroidX.Compose.UI.Graphics.Brush brush, Shape? shape);
 
+    // androidx.compose.ui.draw.DrawModifierKt.drawBehind —
+    // (Modifier, Function1<DrawScope, Unit>). Plain Kotlin static
+    // extension; the binder strips it because the Function1 generic
+    // erases at JVM level. No $default — caller must always supply
+    // the lambda. The Function1 is invoked by Compose on every redraw
+    // pass with a DrawScope receiver, which the caller can dispatch
+    // off via raw JNI (the Compose DrawScope binding is interface-
+    // only; instance methods are mangled by inline-class params).
+    [ComposeBridge(
+        Class     = "androidx/compose/ui/draw/DrawModifierKt",
+        JvmName   = "drawBehind",
+        Signature = "(Landroidx/compose/ui/Modifier;Lkotlin/jvm/functions/Function1;)" +
+                    "Landroidx/compose/ui/Modifier;")]
+    internal static partial IntPtr ModifierDrawBehind(IntPtr modifier, IFunction1 onDraw);
+
     // androidx.compose.foundation.ClickableKt.clickable-XHw0xAI$default —
     // (Modifier, Boolean enabled, String onClickLabel, Role role,
     // Function0 onClick). Returns a Modifier directly — the lambda is
diff --git a/src/Microsoft.AndroidX.Compose/ModifierExtensions.cs b/src/Microsoft.AndroidX.Compose/ModifierExtensions.cs
index 26da6588..3f648a60 100644
--- a/src/Microsoft.AndroidX.Compose/ModifierExtensions.cs
+++ b/src/Microsoft.AndroidX.Compose/ModifierExtensions.cs
@@ -292,6 +292,37 @@ public static Modifier Border(
         return modifier.Append(curr => ComposeBridges.ModifierBorderBrush(curr, w, brush, shape));
     }
 
+    /// <summary>
+    /// <c>Modifier.drawBehind(onDraw: DrawScope.() -&gt; Unit)</c> —
+    /// installs <paramref name="onDraw"/> as a behind-the-content draw
+    /// callback. Compose invokes the lambda on every draw pass with a
+    /// <c>DrawScope</c> receiver (passed as a Java <c>Object</c> handle
+    /// to the JCW) before painting the modifier's children.
+    /// </summary>
+    /// <remarks>
+    /// <para>The Compose <c>DrawScope</c> binding is interface-only —
+    /// every drawing primitive on it (<c>drawRect</c>, <c>drawRoundRect</c>,
+    /// <c>drawPath</c>, …) carries an inline-class param (<c>Color</c>,
+    /// <c>Offset</c>, <c>Size</c>, <c>CornerRadius</c>, <c>BlendMode</c>),
+    /// so the binder strips them and the C# instance API is empty.
+    /// Callbacks reach into <c>DrawScope.drawContext.canvas.nativeCanvas</c>
+    /// via raw JNI to get an <see cref="Android.Graphics.Canvas"/> and
+    /// draw with the directly-bound <see cref="Android.Graphics.Paint"/>
+    /// API.</para>
+    ///
+    /// <para>The <paramref name="onDraw"/> JCW is captured by the
+    /// closure so its Java peer stays alive across recompositions —
+    /// pass the <em>same</em> JCW instance each pass to keep modifier
+    /// equality stable; allocating a fresh <see cref="IFunction1"/>
+    /// every recomposition rebuilds the underlying
+    /// <c>DrawBehindElement</c> on every frame.</para>
+    /// </remarks>
+    public static Modifier DrawBehind(this Modifier modifier, Kotlin.Jvm.Functions.IFunction1 onDraw)
+    {
+        ArgumentNullException.ThrowIfNull(onDraw);
+        return modifier.Append(curr => ComposeBridges.ModifierDrawBehind(curr, onDraw));
+    }
+
     /// <summary>
     /// <c>Modifier.clip(RoundedCornerShape(<paramref name="cornerRadius"/>))</c> —
     /// rounds the four corners by the same radius and clips drawing to the
diff --git a/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt b/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt
index 4e5cd21d..18679ab1 100644
--- a/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt
+++ b/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt
@@ -2154,6 +2154,7 @@ static AndroidX.Compose.ModifierExtensions.CombinedClickable(this AndroidX.Compo
 static AndroidX.Compose.ModifierExtensions.DefaultMinSize(this AndroidX.Compose.Modifier! modifier, AndroidX.Compose.Dp? minWidth = null, AndroidX.Compose.Dp? minHeight = null) -> AndroidX.Compose.Modifier!
 static AndroidX.Compose.ModifierExtensions.DetectDragGestures(this AndroidX.Compose.Modifier! modifier, System.Action<AndroidX.Compose.Offset>! onDrag, System.Action<AndroidX.Compose.Offset>? onDragStart = null, System.Action? onDragEnd = null, System.Action? onDragCancel = null, object? key = null) -> AndroidX.Compose.Modifier!
 static AndroidX.Compose.ModifierExtensions.DetectTapGestures(this AndroidX.Compose.Modifier! modifier, System.Action<AndroidX.Compose.Offset>? onTap = null, System.Action<AndroidX.Compose.Offset>? onPress = null, System.Action<AndroidX.Compose.Offset>? onLongPress = null, System.Action<AndroidX.Compose.Offset>? onDoubleTap = null, object? key = null) -> AndroidX.Compose.Modifier!
+static AndroidX.Compose.ModifierExtensions.DrawBehind(this AndroidX.Compose.Modifier! modifier, Kotlin.Jvm.Functions.IFunction1! onDraw) -> AndroidX.Compose.Modifier!
 static AndroidX.Compose.ModifierExtensions.DetectTransformGestures(this AndroidX.Compose.Modifier! modifier, System.Action<AndroidX.Compose.Offset, AndroidX.Compose.Offset, float, float>! onGesture, bool panZoomLock = false, object? key = null) -> AndroidX.Compose.Modifier!
 static AndroidX.Compose.ModifierExtensions.DisplayCutoutPadding(this AndroidX.Compose.Modifier! modifier) -> AndroidX.Compose.Modifier!
 static AndroidX.Compose.ModifierExtensions.DragAndDropTarget(this AndroidX.Compose.Modifier! modifier, System.Func<AndroidX.Compose.DragAndDropEvent!, bool>! shouldStartDragAndDrop, AndroidX.Compose.DragAndDropTarget! target) -> AndroidX.Compose.Modifier!

From a3cb31a539d9e868f541eb97f89adb8d6d39cc25 Mon Sep 17 00:00:00 2001
From: Copilot <223556219+Copilot@users.noreply.github.com>
Date: Tue, 16 Jun 2026 08:20:47 -0500
Subject: [PATCH 2/2] Address review feedback

- Reorder DrawBehind in PublicAPI.Unshipped.txt so it sits after Draggable.
- Drop the unused strokeColor parameter from ConfigureStrokeDrawCallback;
  the colour is already derived from the live SolidPaint inside the body.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../Handlers/BorderHandler.cs                          | 10 ++--------
 src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt |  2 +-
 2 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/src/Microsoft.AndroidX.Compose.Maui/Handlers/BorderHandler.cs b/src/Microsoft.AndroidX.Compose.Maui/Handlers/BorderHandler.cs
index 62a9d625..f3f4e555 100644
--- a/src/Microsoft.AndroidX.Compose.Maui/Handlers/BorderHandler.cs
+++ b/src/Microsoft.AndroidX.Compose.Maui/Handlers/BorderHandler.cs
@@ -148,7 +148,7 @@ public override ComposableNode BuildNode(IComposer composer)
             // the trivial defaults.
             if (HasCustomStrokeGeometry(border))
             {
-                ConfigureStrokeDrawCallback(border, stroke.Value, width);
+                ConfigureStrokeDrawCallback(border, width);
                 modifier = (modifier ?? Modifier.Companion).DrawBehind(_strokeDrawCallback);
             }
             else
@@ -219,7 +219,7 @@ static bool HasCustomStrokeGeometry(MauiBorder border)
                stroke.StrokeMiterLimit != 10f;
     }
 
-    void ConfigureStrokeDrawCallback(MauiBorder border, long strokeColor, float strokeThickness)
+    void ConfigureStrokeDrawCallback(MauiBorder border, float strokeThickness)
     {
         // ARGB int for native Paint — derived directly from the live
         // SolidPaint Color so the dashed path stays in sync with the
@@ -240,12 +240,6 @@ void ConfigureStrokeDrawCallback(MauiBorder border, long strokeColor, float stro
         var metrics = global::Android.Content.Res.Resources.System?.DisplayMetrics
             ?? throw new InvalidOperationException("Resources.System.DisplayMetrics not available.");
         _strokeDrawCallback.Density            = metrics.Density;
-
-        // Silence "strokeColor is unused" — it's already derived from
-        // SolidPaint above, but kept on the signature so the caller
-        // can pass through the cached MutableState slot when MAUI's
-        // stroke property cycles through null between updates.
-        _ = strokeColor;
     }
 
     /// <summary>Map <see cref="MauiBorder.Stroke"/> by extracting
diff --git a/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt b/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt
index 18679ab1..d4bc197e 100644
--- a/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt
+++ b/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt
@@ -2154,11 +2154,11 @@ static AndroidX.Compose.ModifierExtensions.CombinedClickable(this AndroidX.Compo
 static AndroidX.Compose.ModifierExtensions.DefaultMinSize(this AndroidX.Compose.Modifier! modifier, AndroidX.Compose.Dp? minWidth = null, AndroidX.Compose.Dp? minHeight = null) -> AndroidX.Compose.Modifier!
 static AndroidX.Compose.ModifierExtensions.DetectDragGestures(this AndroidX.Compose.Modifier! modifier, System.Action<AndroidX.Compose.Offset>! onDrag, System.Action<AndroidX.Compose.Offset>? onDragStart = null, System.Action? onDragEnd = null, System.Action? onDragCancel = null, object? key = null) -> AndroidX.Compose.Modifier!
 static AndroidX.Compose.ModifierExtensions.DetectTapGestures(this AndroidX.Compose.Modifier! modifier, System.Action<AndroidX.Compose.Offset>? onTap = null, System.Action<AndroidX.Compose.Offset>? onPress = null, System.Action<AndroidX.Compose.Offset>? onLongPress = null, System.Action<AndroidX.Compose.Offset>? onDoubleTap = null, object? key = null) -> AndroidX.Compose.Modifier!
-static AndroidX.Compose.ModifierExtensions.DrawBehind(this AndroidX.Compose.Modifier! modifier, Kotlin.Jvm.Functions.IFunction1! onDraw) -> AndroidX.Compose.Modifier!
 static AndroidX.Compose.ModifierExtensions.DetectTransformGestures(this AndroidX.Compose.Modifier! modifier, System.Action<AndroidX.Compose.Offset, AndroidX.Compose.Offset, float, float>! onGesture, bool panZoomLock = false, object? key = null) -> AndroidX.Compose.Modifier!
 static AndroidX.Compose.ModifierExtensions.DisplayCutoutPadding(this AndroidX.Compose.Modifier! modifier) -> AndroidX.Compose.Modifier!
 static AndroidX.Compose.ModifierExtensions.DragAndDropTarget(this AndroidX.Compose.Modifier! modifier, System.Func<AndroidX.Compose.DragAndDropEvent!, bool>! shouldStartDragAndDrop, AndroidX.Compose.DragAndDropTarget! target) -> AndroidX.Compose.Modifier!
 static AndroidX.Compose.ModifierExtensions.Draggable(this AndroidX.Compose.Modifier! modifier, AndroidX.Compose.DraggableState! state, AndroidX.Compose.Orientation orientation, bool enabled = true) -> AndroidX.Compose.Modifier!
+static AndroidX.Compose.ModifierExtensions.DrawBehind(this AndroidX.Compose.Modifier! modifier, Kotlin.Jvm.Functions.IFunction1! onDraw) -> AndroidX.Compose.Modifier!
 static AndroidX.Compose.ModifierExtensions.FillMaxHeight(this AndroidX.Compose.Modifier! modifier, float fraction = 1) -> AndroidX.Compose.Modifier!
 static AndroidX.Compose.ModifierExtensions.FillMaxSize(this AndroidX.Compose.Modifier! modifier, float fraction = 1) -> AndroidX.Compose.Modifier!
 static AndroidX.Compose.ModifierExtensions.FillMaxWidth(this AndroidX.Compose.Modifier! modifier, float fraction = 1) -> AndroidX.Compose.Modifier!