@capgo/capacitor-pretty-toast 8.1.0

package/android/src/main/java/com/toast/anim/CutoutMorphAnimator.kt

@@ -0,0 +1,235 @@
+package com.toast.anim
+
+import android.animation.ValueAnimator
+import android.graphics.drawable.GradientDrawable
+import android.view.View
+import android.widget.LinearLayout
+import com.toast.cutout.CutoutInfo
+import com.toast.util.Density
+import com.toast.util.ToastConstants.MORPH_DURATION_MS
+import com.toast.util.ToastConstants.MORPH_EASING
+
+/**
+ * Dynamic-Island-style morph animation. The pill scales + translates
+ * between the expanded capsule and a tight footprint over the cutout,
+ * while cornerRadii morph so the on-screen corner stays circular
+ * throughout the anisotropic scale.
+ */
+class CutoutMorphAnimator(
+    private val pill: LinearLayout,
+    private val content: View,
+    private val info: CutoutInfo,
+    private val expandedCornerRadius: Float,
+    private val density: Density,
+    private val onBeforeShow: () -> Unit = {},
+    private val onBeforeDismiss: () -> Unit = {},
+) : ToastAnimator {
+
+    private var cornerAnimator: ValueAnimator? = null
+    private val cornerRadiiBuf = FloatArray(8)
+
+    /**
+     * Lower bound for the measured pill height — guards against racing
+     * the layout pass, where `pill.height` can briefly read as 0.
+     */
+    private val heightFloor: Float get() = density.dp(70f)
+
+    private fun expandedHeight(): Float = pill.height.toFloat().coerceAtLeast(heightFloor)
+
+    override fun show() {
+        onBeforeShow()
+
+        val expandedWidth = pill.layoutParams.width.toFloat()
+        val scaleX = info.collapsedWidth / expandedWidth
+        val scaleY = info.collapsedHeight / expandedHeight()
+
+        pill.pivotX = expandedWidth / 2f
+        pill.pivotY = 0f
+        pill.scaleX = scaleX
+        pill.scaleY = scaleY
+        // Translate so the collapsed pill starts centered over the cutout
+        // (zero offset for centered holes, non-zero for corner cameras).
+        pill.translationX = info.horizontalOffset
+        pill.translationY = 0f
+        pill.alpha = 1f
+        content.alpha = 0f
+        // Start with fully-capsule corners so the initial frame reads as a
+        // pill hugging the camera, not a tiny rectangle.
+        applyMorphCorners(1f)
+
+        // Material standard ease-in-out — gentle accel, soft landing.
+        // Duration matches iOS's `.bouncy(duration: 0.3)`.
+        pill.animate()
+            .scaleX(1f)
+            .scaleY(1f)
+            .translationX(0f)
+            .setDuration(MORPH_DURATION_MS)
+            .setInterpolator(MORPH_EASING)
+            .start()
+        animateMorphCorners(fromProgress = 1f, toProgress = 0f, durationMs = MORPH_DURATION_MS)
+
+        content.animate()
+            .alpha(1f)
+            .setDuration(210)
+            .setStartDelay(80)
+            .start()
+    }
+
+    override fun dismiss(onEnd: () -> Unit) {
+        onBeforeDismiss()
+
+        val expandedWidth = pill.width.toFloat().coerceAtLeast(1f)
+        val expandedHeight = expandedHeight()
+        val scaleX = info.collapsedWidth / expandedWidth
+        val scaleY = info.collapsedHeight / expandedHeight
+
+        // Clear any stale drag translation and align pivots with show()
+        // so the morph collapses exactly onto the cutout.
+        pill.translationY = 0f
+        pill.pivotX = expandedWidth / 2f
+        pill.pivotY = 0f
+
+        content.animate()
+            .alpha(0f)
+            .setDuration(140)
+            .start()
+
+        // Infer current progress from pill.scaleY so the corner animation
+        // picks up from wherever the drag left it.
+        val minScaleY = info.collapsedHeight / expandedHeight
+        val currentProgress = if (minScaleY < 1f)
+            ((1f - pill.scaleY) / (1f - minScaleY)).coerceIn(0f, 1f)
+        else 0f
+
+        // Scale down and fade out simultaneously — no two-step pop.
+        pill.animate()
+            .scaleX(scaleX)
+            .scaleY(scaleY)
+            .translationX(info.horizontalOffset)
+            .alpha(0f)
+            .setDuration(MORPH_DURATION_MS)
+            .setInterpolator(MORPH_EASING)
+            .withEndAction {
+                resetPillToExpandedResting()
+                onEnd()
+            }
+            .start()
+        animateMorphCorners(fromProgress = currentProgress, toProgress = 1f, durationMs = MORPH_DURATION_MS)
+    }
+
+    override fun applyDrag(dy: Float, translationYOnDown: Float) {
+        if (dy >= 0f) return // drag morph is upward-only
+        applyDragMorph(-dy)
+    }
+
+    override fun snapBack() {
+        // Release-without-dismiss during a morph drag: spring back to full
+        // size and restore content opacity.
+        pill.animate().cancel()
+        pill.animate()
+            .scaleX(1f)
+            .scaleY(1f)
+            .translationX(0f)
+            .setDuration(MORPH_DURATION_MS)
+            .setInterpolator(MORPH_EASING)
+            .start()
+
+        val minScaleY = info.collapsedHeight / expandedHeight()
+        val currentProgress = if (minScaleY < 1f)
+            ((1f - pill.scaleY) / (1f - minScaleY)).coerceIn(0f, 1f)
+        else 0f
+        animateMorphCorners(currentProgress, 0f, MORPH_DURATION_MS)
+
+        content.animate().cancel()
+        content.animate()
+            .alpha(1f)
+            .setDuration(220)
+            .start()
+    }
+
+    /**
+     * Interpolates the pill's scale from fully expanded toward the cutout
+     * footprint. `upwardDistance` is positive px of finger travel up.
+     */
+    private fun applyDragMorph(upwardDistance: Float) {
+        val expandedWidth = pill.width.toFloat().coerceAtLeast(1f)
+        val expandedHeight = expandedHeight()
+        val collapsedScaleX = info.collapsedWidth / expandedWidth
+        val collapsedScaleY = info.collapsedHeight / expandedHeight
+
+        val fullCollapseDistance = density.dp(140f)
+        val progress = (upwardDistance / fullCollapseDistance).coerceIn(0f, 1f)
+
+        pill.pivotX = expandedWidth / 2f
+        pill.pivotY = 0f
+        pill.scaleX = 1f - progress * (1f - collapsedScaleX)
+        pill.scaleY = 1f - progress * (1f - collapsedScaleY)
+        pill.translationX = info.horizontalOffset * progress
+
+        cornerAnimator?.cancel()
+        applyMorphCorners(progress)
+        // Fade content out quickly in the first half so the morph reads
+        // as a shape change, not text squeezing.
+        content.alpha = (1f - progress * 2f).coerceIn(0f, 1f)
+    }
+
+    /**
+     * Sets cornerRadii so the visually-rendered corners stay circular
+     * throughout the anisotropic scale. With a single cornerRadius,
+     * non-uniform scale turns corners into squished ellipses — we
+     * compensate by feeding pre-scale x/y radii that project to the
+     * desired visible radius after scaleX/scaleY.
+     *
+     * progress: 0 = fully expanded, 1 = fully collapsed to cutout.
+     */
+    private fun applyMorphCorners(progress: Float) {
+        val bg = pill.background as? GradientDrawable ?: return
+        val pillW = pill.layoutParams.width.toFloat().coerceAtLeast(1f)
+        val pillH = expandedHeight()
+        val scaleX = 1f - progress * (1f - info.collapsedWidth / pillW)
+        val scaleY = 1f - progress * (1f - info.collapsedHeight / pillH)
+
+        val collapsedCap = minOf(info.collapsedWidth, info.collapsedHeight) / 2f
+        val visibleCap = expandedCornerRadius + (collapsedCap - expandedCornerRadius) * progress
+
+        val rx = visibleCap / scaleX
+        val ry = visibleCap / scaleY
+        // Reuse the buffer — applyMorphCorners runs per-frame during drag.
+        cornerRadiiBuf[0] = rx; cornerRadiiBuf[1] = ry
+        cornerRadiiBuf[2] = rx; cornerRadiiBuf[3] = ry
+        cornerRadiiBuf[4] = rx; cornerRadiiBuf[5] = ry
+        cornerRadiiBuf[6] = rx; cornerRadiiBuf[7] = ry
+        bg.cornerRadii = cornerRadiiBuf
+    }
+
+    /**
+     * Drives `applyMorphCorners` in lockstep with the scale/translation
+     * animation — same duration + interpolator so the two stay in sync
+     * frame-for-frame.
+     */
+    private fun animateMorphCorners(fromProgress: Float, toProgress: Float, durationMs: Long) {
+        cornerAnimator?.cancel()
+        cornerAnimator = ValueAnimator.ofFloat(fromProgress, toProgress).apply {
+            duration = durationMs
+            interpolator = MORPH_EASING
+            addUpdateListener { applyMorphCorners(it.animatedValue as Float) }
+            start()
+        }
+    }
+
+    private fun resetPillToExpandedResting() {
+        pill.scaleX = 1f
+        pill.scaleY = 1f
+        pill.translationX = 0f
+        pill.alpha = 1f
+        content.alpha = 1f
+        (pill.background as? GradientDrawable)?.apply {
+            cornerRadii = null
+            cornerRadius = expandedCornerRadius
+        }
+    }
+
+    fun cancelPendingCallbacks() {
+        cornerAnimator?.cancel()
+    }
+}

package/android/src/main/java/com/toast/anim/SlideAnimator.kt

@@ -0,0 +1,64 @@
+package com.toast.anim
+
+import android.widget.LinearLayout
+import androidx.dynamicanimation.animation.DynamicAnimation
+import androidx.dynamicanimation.animation.SpringAnimation
+import androidx.dynamicanimation.animation.SpringForce
+import com.toast.util.Density
+
+/**
+ * Fallback animation for devices without a top cutout — a spring-based
+ * drop-down from offscreen, with matching spring on snap-back and a
+ * faster damped spring on dismiss.
+ */
+class SlideAnimator(
+    private val pill: LinearLayout,
+    private val density: Density,
+) : ToastAnimator {
+
+    private fun offscreenY(): Float = -density.dp(200f)
+
+    override fun show() {
+        pill.translationY = offscreenY()
+        pill.alpha = 1f
+
+        SpringAnimation(pill, DynamicAnimation.TRANSLATION_Y, 0f).apply {
+            spring.apply {
+                dampingRatio = 0.75f
+                stiffness = SpringForce.STIFFNESS_MEDIUM
+            }
+            start()
+        }
+    }
+
+    override fun dismiss(onEnd: () -> Unit) {
+        val spring = SpringAnimation(pill, DynamicAnimation.TRANSLATION_Y, offscreenY()).apply {
+            spring.apply {
+                dampingRatio = SpringForce.DAMPING_RATIO_NO_BOUNCY
+                stiffness = SpringForce.STIFFNESS_MEDIUM
+            }
+            addEndListener { _, _, _, _ -> onEnd() }
+        }
+        spring.start()
+
+        pill.animate()
+            .alpha(0f)
+            .setDuration(250)
+            .start()
+    }
+
+    override fun applyDrag(dy: Float, translationYOnDown: Float) {
+        if (dy >= 0f) return // upward drag only
+        pill.translationY = translationYOnDown + dy
+    }
+
+    override fun snapBack() {
+        SpringAnimation(pill, DynamicAnimation.TRANSLATION_Y, 0f).apply {
+            spring.apply {
+                dampingRatio = 0.75f
+                stiffness = SpringForce.STIFFNESS_MEDIUM
+            }
+            start()
+        }
+    }
+}

package/android/src/main/java/com/toast/anim/ToastAnimator.kt

@@ -0,0 +1,23 @@
+package com.toast.anim
+
+/**
+ * Common surface for the two toast animation strategies (cutout-morph
+ * and slide-spring) so the gesture handler doesn't branch on which one
+ * is active.
+ */
+interface ToastAnimator {
+    fun show()
+    fun dismiss(onEnd: () -> Unit)
+
+    /**
+     * Called on every ACTION_MOVE of an in-progress pill drag.
+     *
+     * @param dy raw finger delta since ACTION_DOWN (negative = upward).
+     * @param translationYOnDown pill.translationY captured at ACTION_DOWN
+     *        — used by the slide animator to resume relative translation.
+     */
+    fun applyDrag(dy: Float, translationYOnDown: Float)
+
+    /** Release without dismiss: restore to the resting expanded state. */
+    fun snapBack()
+}

package/android/src/main/java/com/toast/backdrop/BackdropSampler.kt

@@ -0,0 +1,142 @@
+package com.toast.backdrop
+
+import android.app.Activity
+import android.graphics.Bitmap
+import android.graphics.Rect
+import android.os.Handler
+import android.os.Looper
+import android.view.PixelCopy
+import com.toast.util.Density
+import java.lang.ref.WeakReference
+
+enum class BackdropTint { COLORED, GRAY }
+
+/**
+ * Samples the pixels beneath the toast pill on a 250 ms tick and flips
+ * [onTintChanged] between [BackdropTint.COLORED] (dark backdrop — use the
+ * toast's accent colour as the outline) and [BackdropTint.GRAY] (everything
+ * lighter — a faint neutral white outline).
+ *
+ * Mirrors the iOS sampler in `PassThroughWindow.swift`: a 32×8 px bitmap,
+ * Rec. 601 luminance, and flip points at 0.050 / 0.060 with hysteresis. iOS
+ * uses `CALayer.render(in:)`; we use [PixelCopy.request] against the
+ * activity's window, which reads the actual GPU-rendered surface (including
+ * our overlay — the self-captured black pill biases the average towards
+ * `COLORED` on dark backdrops, which is the correct outcome, and stays well
+ * above the flip threshold on any light backdrop where the surrounding
+ * pixels dominate the average).
+ */
+class BackdropSampler(
+    activity: Activity,
+    density: Density,
+    private val onTintChanged: (BackdropTint) -> Unit,
+) {
+    private val activityRef = WeakReference(activity)
+    private val stripHeightPx = density.dpInt(SAMPLE_STRIP_HEIGHT_DP)
+    private val handler = Handler(Looper.getMainLooper())
+    private var bitmap: Bitmap? =
+        Bitmap.createBitmap(BITMAP_WIDTH, BITMAP_HEIGHT, Bitmap.Config.ARGB_8888)
+    private val pixels = IntArray(BITMAP_WIDTH * BITMAP_HEIGHT)
+    private val srcRect = Rect()
+
+    private var tickRunnable: Runnable? = null
+    private var inflight = false
+    private var stopped = false
+    private var currentTint: BackdropTint = BackdropTint.GRAY
+
+    fun start() {
+        stop()
+        stopped = false
+        sample()
+        val r = object : Runnable {
+            override fun run() {
+                sample()
+                handler.postDelayed(this, SAMPLE_INTERVAL_MS)
+            }
+        }
+        tickRunnable = r
+        handler.postDelayed(r, SAMPLE_INTERVAL_MS)
+    }
+
+    /**
+     * Stops the tick loop and releases the backing bitmap. Safe to call
+     * multiple times. If a [PixelCopy] request is still in flight the
+     * bitmap is recycled inside the callback instead — recycling it here
+     * would crash the native copy.
+     */
+    fun stop() {
+        stopped = true
+        tickRunnable?.let { handler.removeCallbacks(it) }
+        tickRunnable = null
+        if (!inflight) {
+            bitmap?.recycle()
+            bitmap = null
+        }
+    }
+
+    /** Current tint, so the overlay can sync a freshly-built pill. */
+    val tint: BackdropTint get() = currentTint
+
+    private fun sample() {
+        if (inflight || stopped) return
+        val activity = activityRef.get() ?: return
+        val window = activity.window ?: return
+        val decorView = window.decorView ?: return
+        val w = decorView.width
+        val h = decorView.height
+        if (w <= 0 || h <= 0) return
+        val dst = bitmap ?: return
+        srcRect.set(0, 0, w, stripHeightPx.coerceAtMost(h))
+
+        inflight = true
+        try {
+            PixelCopy.request(window, srcRect, dst, { result ->
+                inflight = false
+                // If stop() was called while the copy was in flight it
+                // deferred the recycle to us — do it now, and bail out of
+                // any further processing.
+                if (stopped) {
+                    bitmap?.recycle()
+                    bitmap = null
+                    return@request
+                }
+                if (result == PixelCopy.SUCCESS) processBitmap(dst)
+            }, handler)
+        } catch (_: IllegalArgumentException) {
+            inflight = false
+        }
+    }
+
+    private fun processBitmap(src: Bitmap) {
+        src.getPixels(pixels, 0, BITMAP_WIDTH, 0, 0, BITMAP_WIDTH, BITMAP_HEIGHT)
+
+        var total = 0.0
+        for (p in pixels) {
+            val r = ((p shr 16) and 0xFF) / 255.0
+            val g = ((p shr 8) and 0xFF) / 255.0
+            val b = (p and 0xFF) / 255.0
+            total += 0.299 * r + 0.587 * g + 0.114 * b
+        }
+        val avg = total / pixels.size
+
+        // Single flip point at ~#0E (≈0.055), matching Apple's DI. ±0.005
+        // hysteresis stops backdrops right on the boundary flickering.
+        val next = when (currentTint) {
+            BackdropTint.COLORED -> if (avg > FLIP_HIGH) BackdropTint.GRAY else BackdropTint.COLORED
+            BackdropTint.GRAY -> if (avg < FLIP_LOW) BackdropTint.COLORED else BackdropTint.GRAY
+        }
+        if (next != currentTint) {
+            currentTint = next
+            onTintChanged(next)
+        }
+    }
+
+    companion object {
+        private const val SAMPLE_INTERVAL_MS = 250L
+        private const val BITMAP_WIDTH = 32
+        private const val BITMAP_HEIGHT = 8
+        private const val SAMPLE_STRIP_HEIGHT_DP = 80f
+        private const val FLIP_LOW = 0.050
+        private const val FLIP_HIGH = 0.060
+    }
+}

package/android/src/main/java/com/toast/backdrop/OutlineController.kt

@@ -0,0 +1,100 @@
+package com.toast.backdrop
+
+import android.animation.ArgbEvaluator
+import android.animation.ValueAnimator
+import android.graphics.Color
+import android.graphics.drawable.GradientDrawable
+import android.view.animation.AccelerateDecelerateInterpolator
+
+/**
+ * Drives the outline colour on the toast pill's [GradientDrawable] stroke.
+ *
+ * Mirrors the iOS renderer in `PrettyToastView.swift`: on `.colored` tint the
+ * stroke takes the toast's accent at 20% alpha; on `.gray` it falls back to a
+ * near-invisible white at 6%. Tint changes crossfade over 300 ms via a
+ * `ValueAnimator` + `ArgbEvaluator`, matching the iOS
+ * `.animation(.easeInOut(duration: 0.3))` on stroke opacity.
+ */
+class OutlineController(
+    private val pillBackground: GradientDrawable,
+    private val strokeWidthPx: Int,
+) {
+    private var accentColor: Int = Color.WHITE
+    private var currentTint: BackdropTint = BackdropTint.GRAY
+    private var currentStrokeColor: Int = Color.TRANSPARENT
+    private var animator: ValueAnimator? = null
+    /**
+     * When non-null, overrides the sampler-driven stroke with a fixed color.
+     * Used by the JS-facing `strokeColor` prop; treated as the full ARGB
+     * value (alpha included — no further opacity derivation).
+     */
+    private var override: Int? = null
+
+    init {
+        applyStroke(strokeColorFor(currentTint))
+    }
+
+    fun setAccent(accent: Int) {
+        if (accent == accentColor) return
+        accentColor = accent
+        val target = strokeColorFor(currentTint)
+        animator?.cancel()
+        applyStroke(target)
+    }
+
+    fun setTint(tint: BackdropTint, animated: Boolean) {
+        if (tint == currentTint) return
+        currentTint = tint
+        if (override != null) return
+        val target = strokeColorFor(tint)
+        if (!animated) {
+            animator?.cancel()
+            applyStroke(target)
+            return
+        }
+        animateStrokeTo(target)
+    }
+
+    fun setOverride(color: Int?) {
+        if (override == color) return
+        override = color
+        animator?.cancel()
+        applyStroke(color ?: strokeColorFor(currentTint))
+    }
+
+    private fun strokeColorFor(tint: BackdropTint): Int = override ?: when (tint) {
+        BackdropTint.COLORED -> withAlpha(accentColor, ACCENT_ALPHA_255)
+        BackdropTint.GRAY -> withAlpha(Color.WHITE, GRAY_ALPHA_255)
+    }
+
+    private fun withAlpha(color: Int, alpha: Int): Int =
+        (color and 0x00FFFFFF) or ((alpha and 0xFF) shl 24)
+
+    private fun applyStroke(color: Int) {
+        currentStrokeColor = color
+        pillBackground.setStroke(strokeWidthPx, color)
+    }
+
+    private fun animateStrokeTo(target: Int) {
+        animator?.cancel()
+        val start = currentStrokeColor
+        animator = ValueAnimator.ofObject(ArgbEvaluator(), start, target).apply {
+            duration = CROSSFADE_MS
+            interpolator = AccelerateDecelerateInterpolator()
+            addUpdateListener { a -> applyStroke(a.animatedValue as Int) }
+            start()
+        }
+    }
+
+    fun cancel() {
+        animator?.cancel()
+        animator = null
+    }
+
+    companion object {
+        // 0.20 × 255 = 51, 0.06 × 255 ≈ 15 — match iOS stroke alphas.
+        private const val ACCENT_ALPHA_255 = 51
+        private const val GRAY_ALPHA_255 = 15
+        private const val CROSSFADE_MS = 300L
+    }
+}

package/android/src/main/java/com/toast/cutout/CutoutDetector.kt

@@ -0,0 +1,88 @@
+package com.toast.cutout
+
+import android.app.Activity
+import android.graphics.Rect
+import android.os.Build
+import android.view.RoundedCorner
+import android.view.View
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import com.toast.util.ToastConstants.COLLAPSED_CUTOUT_FACTOR
+
+/**
+ * Reads DisplayCutout + rounded-corner insets off the decor view and
+ * packages them into an immutable [CutoutInfo] snapshot.
+ */
+object CutoutDetector {
+
+    fun detect(activity: Activity, decorView: View, useDynamicIsland: Boolean): CutoutInfo {
+        val screenWidth = activity.resources.displayMetrics.widthPixels
+        val density = activity.resources.displayMetrics.density
+        val insets = ViewCompat.getRootWindowInsets(decorView)
+
+        val statusBarHeight = resolveStatusBarHeight(activity, insets)
+        val screenCornerRadius = resolveScreenCornerRadius(decorView)
+
+        val cutoutRect = if (useDynamicIsland) {
+            detectTopCutoutRect(decorView, statusBarHeight)
+        } else {
+            null
+        }
+
+        val hasCutout = cutoutRect != null
+
+        val collapsedWidth: Float
+        val collapsedHeight: Float
+        val horizontalOffset: Float
+        if (cutoutRect != null) {
+            collapsedWidth = cutoutRect.width() * COLLAPSED_CUTOUT_FACTOR
+            collapsedHeight = cutoutRect.height() * COLLAPSED_CUTOUT_FACTOR
+            val screenCenterX = screenWidth / 2f
+            horizontalOffset = cutoutRect.centerX() - screenCenterX
+        } else {
+            collapsedWidth = 120f * density
+            collapsedHeight = 36f * density
+            horizontalOffset = 0f
+        }
+
+        return CutoutInfo(
+            hasCutout = hasCutout,
+            rect = cutoutRect,
+            collapsedWidth = collapsedWidth,
+            collapsedHeight = collapsedHeight,
+            horizontalOffset = horizontalOffset,
+            screenCornerRadius = screenCornerRadius,
+            statusBarHeight = statusBarHeight,
+        )
+    }
+
+    private fun detectTopCutoutRect(decorView: View, statusBarHeight: Int): Rect? {
+        val insets = ViewCompat.getRootWindowInsets(decorView) ?: return null
+        val cutout = insets.displayCutout ?: return null
+
+        // Enable Dynamic-Island-style behavior for any top cutout —
+        // centered punch-hole, corner camera, or notch. The morph
+        // animation uses horizontal translation so it lands correctly
+        // on off-center holes.
+        val topRect = cutout.boundingRects.firstOrNull { it.top == 0 || it.top < statusBarHeight }
+        return topRect?.takeIf { !it.isEmpty }
+    }
+
+    private fun resolveStatusBarHeight(activity: Activity, insets: WindowInsetsCompat?): Int {
+        val fromInsets = insets?.getInsets(WindowInsetsCompat.Type.statusBars())?.top ?: 0
+        if (fromInsets > 0) return fromInsets
+        val resourceId = activity.resources.getIdentifier("status_bar_height", "dimen", "android")
+        return if (resourceId > 0) activity.resources.getDimensionPixelSize(resourceId) else 0
+    }
+
+    private fun resolveScreenCornerRadius(decorView: View): Int {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            val insets = decorView.rootWindowInsets
+            val topLeft = insets?.getRoundedCorner(RoundedCorner.POSITION_TOP_LEFT)
+            val topRight = insets?.getRoundedCorner(RoundedCorner.POSITION_TOP_RIGHT)
+            val radius = maxOf(topLeft?.radius ?: 0, topRight?.radius ?: 0)
+            if (radius > 0) return radius
+        }
+        return 0
+    }
+}

package/android/src/main/java/com/toast/cutout/CutoutInfo.kt

@@ -0,0 +1,28 @@
+package com.toast.cutout
+
+import android.graphics.Rect
+
+/**
+ * Snapshot of cutout/screen geometry captured once per toast show.
+ *
+ * Replaces the per-access computed properties the old monolithic overlay
+ * had for `collapsedWidth`, `collapsedHeight`, `cutoutHorizontalOffset`,
+ * etc. — we read these many times per animation frame, so paying the
+ * measurement cost once up-front matters.
+ */
+data class CutoutInfo(
+    val hasCutout: Boolean,
+    val rect: Rect?,
+    /** Width the pill morphs to when collapsed onto the cutout. */
+    val collapsedWidth: Float,
+    /** Height the pill morphs to when collapsed onto the cutout. */
+    val collapsedHeight: Float,
+    /**
+     * Horizontal translation (px) needed to slide a centered pill so
+     * its center aligns with the cutout. Zero for centered punch-holes,
+     * non-zero for corner cameras.
+     */
+    val horizontalOffset: Float,
+    val screenCornerRadius: Int,
+    val statusBarHeight: Int,
+)