react-native-screens 5.0.0-alpha.1 → 5.0.0-alpha.3

package/android/src/main/java/com/swmansion/rnscreens/modals/formsheet/native/core/FormSheetDialog.kt

@@ -0,0 +1,115 @@
+package com.swmansion.rnscreens.modals.formsheet.native.core
+
+import android.content.Context
+import android.os.Bundle
+import android.util.Log
+import android.view.View
+import android.view.ViewGroup
+import android.view.Window
+import android.view.WindowManager
+import android.widget.FrameLayout
+import androidx.core.view.WindowCompat
+import com.google.android.material.bottomsheet.BottomSheetDialog
+
+/**
+ * A custom BottomSheetDialog override used to render the FormSheet native component.
+ *
+ * We enforce edge-to-edge rendering, bypassing standard Material checks.
+ * This is required because our custom dimming logic needs the Dialog to span
+ * the entire screen. The FormSheetContainer is sized manually against the system insets.
+ */
+internal class FormSheetDialog(
+    context: Context,
+) : BottomSheetDialog(context) {
+    internal fun interface CancelRequestInterceptor {
+        /**
+         * Invoked in place of the dialog's default cancellation whenever an interceptor is attached.
+         *
+         * The interceptor fully owns the outcome - either for native dismissal prevention or for driving
+         * a custom animated dismissal when allowed. Either way, the dialog skips
+         * [BottomSheetDialog.cancel], which would tear the window down synchronously.
+         */
+        fun handleCancelRequest()
+    }
+
+    internal var cancelRequestInterceptor: CancelRequestInterceptor? = null
+
+    /**
+     * Installed next to Material's content once the dialog is created. Reports the height the sheet
+     * is measured against so the sheet metrics can be resolved before the sheet itself is measured.
+     */
+    internal val availableHeightProvider = FormSheetAvailableHeightProvider(context)
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        hideNativeDimmingView(window)
+        disableNativeWindowAnimation(window)
+
+        setupBottomSheetHeight()
+        installAvailableHeightProvider()
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+
+        forceEdgeToEdge()
+    }
+
+    override fun cancel() {
+        val interceptor = cancelRequestInterceptor
+        if (interceptor == null) {
+            super.cancel()
+            return
+        }
+
+        interceptor.handleCancelRequest()
+    }
+
+    /**
+     * Material's [BottomSheetDialog] only draws edge-to-edge when its theme opts in via the
+     * `enableEdgeToEdge` attribute AND the navigation bar is translucent (see
+     * `BottomSheetDialog#onAttachedToWindow`).
+     *
+     * We force edge-to-edge on every API level so the window content always spans the whole
+     * screen.
+     */
+    private fun forceEdgeToEdge() {
+        val window = window ?: return
+        WindowCompat.setDecorFitsSystemWindows(window, false)
+        findViewById<View>(com.google.android.material.R.id.container)?.fitsSystemWindows = false
+        findViewById<View>(com.google.android.material.R.id.coordinator)?.fitsSystemWindows = false
+    }
+
+    private fun hideNativeDimmingView(window: Window?) = window?.clearFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND)
+
+    private fun disableNativeWindowAnimation(window: Window?) = window?.setWindowAnimations(0)
+
+    private fun setupBottomSheetHeight() {
+        val bottomSheetView = findViewById<FrameLayout>(com.google.android.material.R.id.design_bottom_sheet)
+        bottomSheetView?.layoutParams?.height = ViewGroup.LayoutParams.MATCH_PARENT
+    }
+
+    private fun installAvailableHeightProvider() {
+        if (availableHeightProvider.parent != null) {
+            return
+        }
+
+        val contentParent = findViewById<ViewGroup>(android.R.id.content)
+        if (contentParent == null) {
+            Log.e(TAG, "[RNScreens] Window content view not found; the sheet dimensions won't be resolved.")
+            return
+        }
+
+        // FrameLayout measures its children in order, so the provider reports the height before Material's container
+        contentParent.addView(
+            availableHeightProvider,
+            0,
+            FrameLayout.LayoutParams(0, ViewGroup.LayoutParams.MATCH_PARENT),
+        )
+    }
+
+    companion object {
+        private const val TAG = "FormSheetDialog"
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/modals/formsheet/native/core/FormSheetDialogManager.kt

@@ -0,0 +1,89 @@
+package com.swmansion.rnscreens.modals.formsheet.native.core
+
+import android.content.Context
+import android.view.ContextThemeWrapper
+import android.view.View
+import com.swmansion.rnscreens.modals.formsheet.native.interfaces.FormSheetContentSizeChangeDelegate
+import com.swmansion.rnscreens.modals.formsheet.native.interfaces.FormSheetDialogEventEmitter
+import com.swmansion.rnscreens.modals.formsheet.native.model.FormSheetConfig
+import com.swmansion.rnscreens.modals.formsheet.native.presentation.FormSheetDimmingManager
+import com.swmansion.rnscreens.modals.formsheet.native.presentation.FormSheetPresentation
+import com.swmansion.rnscreens.modals.formsheet.native.presentation.FormSheetPresentationManager
+import kotlin.properties.Delegates
+
+class FormSheetDialogManager(
+    context: Context,
+    private val contentView: View,
+) {
+    private var formSheetConfig = FormSheetConfig()
+
+    private val themedContext =
+        ContextThemeWrapper(
+            context,
+            com.google.android.material.R.style.Theme_Material3_DayNight_NoActionBar,
+        )
+
+    // Eagerly create the container so it's always ready for the provided content view
+    private val container = FormSheetContainer(themedContext, contentView)
+
+    // The React content only reports height changes, so a new presentation is seeded with the
+    // last known value.
+    private var lastContentHeight = 0
+
+    private val presentationCallbacks =
+        object : FormSheetPresentation.Callbacks {
+            override fun onDetentChanged(index: Int) {
+                eventEmitter?.emitOnDetentChanged(index)
+            }
+
+            override fun onNativeDismissAllowed() {
+                presentationManager.handleNativeDismiss()
+            }
+
+            override fun onNativeDismissPrevented() {
+                eventEmitter?.emitOnNativeDismissPreventedEvent()
+            }
+        }
+
+    private val dimmingManager = FormSheetDimmingManager(context)
+
+    private val presentationManager =
+        FormSheetPresentationManager(
+            presentationFactory = ::createPresentation,
+            dimmingManager = dimmingManager,
+            onNativeDismiss = { eventEmitter?.emitOnNativeDismissEvent() },
+            onDismiss = { eventEmitter?.emitOnDismissEvent() },
+        )
+
+    internal var eventEmitter: FormSheetDialogEventEmitter? by Delegates.observable(null) { _, _, newValue ->
+        presentationManager.appearanceEventEmitter = newValue
+    }
+
+    internal val contentSizeChangeDelegate: FormSheetContentSizeChangeDelegate =
+        object : FormSheetContentSizeChangeDelegate {
+            override fun onContentHeightChanged(newHeight: Int) {
+                lastContentHeight = newHeight
+                presentationManager.currentPresentation?.onContentHeightChanged(newHeight)
+            }
+        }
+
+    private fun createPresentation(): FormSheetPresentation =
+        FormSheetPresentation(themedContext, container, presentationCallbacks).also {
+            it.applyInitialConfig(formSheetConfig, lastContentHeight)
+        }
+
+    internal fun applyConfig(newConfig: FormSheetConfig) {
+        val oldConfig = formSheetConfig
+        formSheetConfig = newConfig
+
+        presentationManager.currentPresentation?.applyConfigUpdate(oldConfig, newConfig)
+
+        if (oldConfig.isOpen != newConfig.isOpen) {
+            presentationManager.requestProgrammaticStateUpdate(newConfig.isOpen)
+        }
+    }
+
+    internal fun destroy() {
+        presentationManager.destroy()
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/modals/formsheet/{FormSheetContentSizeChangeDelegate.kt → native/interfaces/FormSheetContentSizeChangeDelegate.kt}

@@ -1,4 +1,4 @@
-package com.swmansion.rnscreens.modals.formsheet
+package com.swmansion.rnscreens.modals.formsheet.native.interfaces
 
 interface FormSheetContentSizeChangeDelegate {
     fun onContentHeightChanged(newHeight: Int)

package/android/src/main/java/com/swmansion/rnscreens/modals/formsheet/{FormSheetContentSizeChangeProvider.kt → native/interfaces/FormSheetContentSizeChangeProvider.kt}

@@ -1,4 +1,4 @@
-package com.swmansion.rnscreens.modals.formsheet
+package com.swmansion.rnscreens.modals.formsheet.native.interfaces
 
 interface FormSheetContentSizeChangeProvider {
     fun setContentSizeChangeDelegate(delegate: FormSheetContentSizeChangeDelegate?)

package/android/src/main/java/com/swmansion/rnscreens/modals/formsheet/{FormSheetDialogEventEmitter.kt → native/interfaces/FormSheetDialogEventEmitter.kt}

@@ -1,9 +1,13 @@
-package com.swmansion.rnscreens.modals.formsheet
+package com.swmansion.rnscreens.modals.formsheet.native.interfaces
 
 import com.swmansion.rnscreens.common.event.ViewAppearanceEventEmitter
 
 internal interface FormSheetDialogEventEmitter : ViewAppearanceEventEmitter {
+    fun emitOnDismissEvent()
+
     fun emitOnNativeDismissEvent()
 
+    fun emitOnNativeDismissPreventedEvent()
+
     fun emitOnDetentChanged(index: Int)
 }

package/android/src/main/java/com/swmansion/rnscreens/modals/formsheet/{FormSheetConfig.kt → native/model/FormSheetConfig.kt}

@@ -1,4 +1,4 @@
-package com.swmansion.rnscreens.modals.formsheet
+package com.swmansion.rnscreens.modals.formsheet.native.model
 
 internal data class FormSheetConfig(
     val isOpen: Boolean = false,
@@ -6,8 +6,12 @@ internal data class FormSheetConfig(
     val prefersGrabberVisible: Boolean = false,
     val initialDetentIndex: Int = 0,
     val preferredCornerRadius: Float = SYSTEM_DEFAULT_CORNER_RADIUS,
+    val preventNativeDismiss: Boolean = false,
     val nativeContainerBackgroundColor: Int? = null,
 ) {
+    val shouldPreventNativeDismiss: Boolean
+        get() = preventNativeDismiss && isOpen
+
     companion object {
         const val SYSTEM_DEFAULT_CORNER_RADIUS = -1f
     }

package/android/src/main/java/com/swmansion/rnscreens/modals/formsheet/native/model/FormSheetDetents.kt

@@ -0,0 +1,152 @@
+package com.swmansion.rnscreens.modals.formsheet.native.model
+
+import kotlin.math.roundToInt
+
+internal class FormSheetDetents(
+    rawDetents: List<Double>,
+) {
+    private val detents: List<Double> = rawDetents.toList()
+
+    init {
+        require(detents.isNotEmpty()) { "[RNScreens] At least one detent must be provided." }
+        require(detents.size <= MAX_DETENTS) { "[RNScreens] Maximum of $MAX_DETENTS detents supported, got ${detents.size}." }
+
+        // Valid fitToContents configuration is a single detent with value -1.0.
+        // For any other configuration, we should validate provided detents array.
+        if (!isFitToContents) {
+            detents.forEach {
+                require(it in 0.0..1.0) {
+                    "[RNScreens] Detent values must be within 0.0 and 1.0, got $it."
+                }
+            }
+
+            require(detents == detents.distinct().sorted()) {
+                "[RNScreens] Detents must be sorted in strictly ascending order."
+            }
+        }
+    }
+
+    internal val isFitToContents: Boolean
+        get() = detents.size == 1 && detents[0] == FIT_TO_CONTENTS_DETENT_VALUE
+
+    internal val count: Int get() = detents.size
+
+    private fun heightFractionAt(index: Int): Double = detents[index]
+
+    // Height of the sheet resting at the given detent, measured down to the bottom edge of the container.
+    private fun heightAt(
+        index: Int,
+        containerHeight: Int,
+        keyboardLift: Int,
+    ): Int = ((heightFractionAt(index) * containerHeight).roundToInt() + keyboardLift).coerceAtMost(containerHeight)
+
+    /**
+     * Height handed to Material as `peekHeight`. Material treats the peek height as the content height above
+     * the bottom inset and adds that inset back (`BottomSheetBehavior.calculatePeekHeight`), while every
+     * other metric (`maxHeight`, `halfExpandedRatio`) describes the sheet down to the screen edge. The inset is
+     * subtracted here so the lowest detent is resolved against the same reference as the other ones.
+     * Material's inset covers the keyboard as well, so the lift is subtracted along with the system inset.
+     */
+    internal fun peekHeight(
+        containerHeight: Int,
+        bottomInset: Int,
+        keyboardLift: Int = 0,
+    ): Int = (heightAt(0, containerHeight, keyboardLift) - bottomInset - keyboardLift).coerceAtLeast(0)
+
+    internal fun maxAllowedHeight(
+        containerHeight: Int,
+        keyboardLift: Int = 0,
+    ): Int = heightAt(count - 1, containerHeight, keyboardLift)
+
+    internal fun maxAllowedHeightForFitToContents(
+        containerHeight: Int,
+        contentHeight: Int,
+        bottomInset: Int,
+        keyboardLift: Int = 0,
+    ): Int {
+        /*
+         * We add the `bottomInset` and the `keyboardLift` to the `contentHeight` so that the Material BottomSheet
+         * is laid out behind the system navigation bar or the keyboard. The sheet's container covers the insets,
+         * while the RN content is strictly constrained to `contentHeight`.
+         */
+        if (contentHeight <= 0) {
+            // Avoid collapsing the sheet before the React content has been laid out and measured.
+            return containerHeight
+        }
+        return (contentHeight + bottomInset + keyboardLift).coerceAtMost(containerHeight)
+    }
+
+    /**
+     * Ratio of the middle detent's sheet height to the container height, handed to Material as `halfExpandedRatio`.
+     * Material resolves the half-expanded position from it as `(int) (parentHeight * (1 - ratio))`.
+     *
+     * The keyboard lift can push both the middle and the largest detent to the top of the container. Material needs
+     * the half-expanded position strictly below the expanded one so the middle detent is kept at least
+     * [MIDDLE_DETENT_MIN_GAP] px shorter than the largest one.
+     */
+    internal fun halfExpandedRatio(
+        containerHeight: Int,
+        keyboardLift: Int = 0,
+    ): Float {
+        check(count == MAX_DETENTS) { "[RNScreens] Exactly $MAX_DETENTS detents are required for halfExpandedRatio." }
+        val middleDetentHeight =
+            heightAt(1, containerHeight, keyboardLift)
+                .coerceAtMost(maxAllowedHeight(containerHeight, keyboardLift) - MIDDLE_DETENT_MIN_GAP)
+                .coerceAtLeast(1)
+        return middleDetentHeight.toFloat() / containerHeight
+    }
+
+    internal fun expandedOffsetFromTop(
+        containerHeight: Int,
+        topInset: Int = 0,
+        keyboardLift: Int = 0,
+    ): Int {
+        check(count == MAX_DETENTS) { "[RNScreens] Exactly $MAX_DETENTS detents are required for expandedOffsetFromTop." }
+        return largestDetentTopOffset(containerHeight, keyboardLift) + topInset
+    }
+
+    // Distance from the top of the window to the top of the largest detent's surface.
+    private fun largestDetentTopOffset(
+        containerHeight: Int,
+        keyboardLift: Int,
+    ): Int = containerHeight - maxAllowedHeight(containerHeight, keyboardLift)
+
+    /**
+     * Material's BottomSheetDialog dynamically applies padding when its content overlaps
+     * system insets. To prevent recalculating the size, we pre-calculate a static height
+     * inside safe area bounds.
+     */
+    internal fun sheetContainerHeight(
+        containerHeight: Int,
+        topInset: Int,
+        bottomInset: Int,
+        contentHeight: Int = 0,
+        keyboardLift: Int = 0,
+    ): Int {
+        val bottomPadding = bottomInset + keyboardLift
+
+        if (isFitToContents) {
+            // Until we have a measured content height, fall back to a safe-area height so Yoga can lay out.
+            if (contentHeight <= 0) {
+                return (containerHeight - topInset - bottomPadding).coerceAtLeast(0)
+            }
+            // Content taller than the safe area is aligned with it.
+            return contentHeight.coerceAtMost((containerHeight - topInset - bottomPadding).coerceAtLeast(0))
+        }
+
+        // Bottom padding is always fully subtracted because the sheet is in its dedicated window and it's
+        // anchored to the bottom.
+        // Top inset is subtracted only by the amount the sheet actually overlaps it.
+        val topOverlap = (topInset - largestDetentTopOffset(containerHeight, keyboardLift)).coerceAtLeast(0)
+        return (maxAllowedHeight(containerHeight, keyboardLift) - topOverlap - bottomPadding).coerceAtLeast(0)
+    }
+
+    companion object {
+        const val MAX_DETENTS = 3
+        const val FIT_TO_CONTENTS_DETENT_VALUE = -1.0
+
+        // Material resolves the half-expanded position in float precision and the truncation to int can eat 1 px
+        // which would put the middle detent back on the expanded position.
+        private const val MIDDLE_DETENT_MIN_GAP = 2
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/modals/formsheet/{FormSheetAnimatorFactory.kt → native/presentation/FormSheetAnimatorFactory.kt}

@@ -1,14 +1,12 @@
-package com.swmansion.rnscreens.modals.formsheet
+package com.swmansion.rnscreens.modals.formsheet.native.presentation
 
 import android.animation.Animator
 import android.animation.AnimatorSet
 import android.animation.ValueAnimator
 import android.view.View
-import androidx.core.animation.doOnStart
-import com.swmansion.rnscreens.modals.dimmingview.DimmingViewManager
 
 internal class FormSheetAnimatorFactory(
-    private val dimmingManager: DimmingViewManager,
+    private val dimmingManager: FormSheetDimmingManager,
 ) {
     // TODO: @t0maboro - consider exposing as a prop
     val animationDuration = 250L
@@ -18,7 +16,7 @@ internal class FormSheetAnimatorFactory(
         isInterrupting: Boolean = false,
     ): Animator {
         val startY = if (isInterrupting) view.translationY else view.height.toFloat()
-        val startAlpha = if (isInterrupting) dimmingManager.dimmingViewAlpha else 0f
+        val startAlpha = if (isInterrupting) dimmingManager.dimmingAlpha else 0f
 
         val slideAnimator =
             ValueAnimator.ofFloat(startY, 0f).apply {
@@ -30,14 +28,13 @@ internal class FormSheetAnimatorFactory(
         val alphaAnimator =
             ValueAnimator.ofFloat(startAlpha, dimmingManager.maxAlpha).apply {
                 addUpdateListener { animation ->
-                    dimmingManager.dimmingViewAlpha = animation.animatedValue as Float
+                    dimmingManager.dimmingAlpha = animation.animatedValue as Float
                 }
             }
 
         return AnimatorSet().apply {
             playTogether(slideAnimator, alphaAnimator)
             duration = animationDuration
-            doOnStart { view.translationY = startY }
         }
     }
 
@@ -45,8 +42,10 @@ internal class FormSheetAnimatorFactory(
         view: View,
         isInterrupting: Boolean = false,
     ): Animator {
-        val startY = if (isInterrupting) view.translationY else 0f
-        val startAlpha = if (isInterrupting) dimmingManager.dimmingViewAlpha else dimmingManager.maxAlpha
+        // Always leave from the current translation: besides an interrupted enter animation, the sheet
+        // may be mid-way through tracking the keyboard animation when the dismissal starts.
+        val startY = view.translationY
+        val startAlpha = if (isInterrupting) dimmingManager.dimmingAlpha else dimmingManager.maxAlpha
 
         val slideAnimator =
             ValueAnimator.ofFloat(startY, view.height.toFloat()).apply {
@@ -58,7 +57,7 @@ internal class FormSheetAnimatorFactory(
         val alphaAnimator =
             ValueAnimator.ofFloat(startAlpha, 0f).apply {
                 addUpdateListener { animation ->
-                    dimmingManager.dimmingViewAlpha = animation.animatedValue as Float
+                    dimmingManager.dimmingAlpha = animation.animatedValue as Float
                 }
             }
 

package/android/src/main/java/com/swmansion/rnscreens/modals/formsheet/native/presentation/FormSheetDimmingManager.kt

@@ -0,0 +1,115 @@
+package com.swmansion.rnscreens.modals.formsheet.native.presentation
+
+import android.app.Activity
+import android.content.Context
+import android.content.ContextWrapper
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+import android.util.Log
+import android.view.View
+import com.facebook.react.bridge.ReactContext
+import com.google.android.material.bottomsheet.BottomSheetBehavior
+import kotlin.math.roundToInt
+
+internal class FormSheetDimmingManager(
+    private val context: Context,
+) {
+    // TODO: @t0maboro - consider exposing as a prop
+    internal val maxAlpha: Float = MAX_DIMMING_ALPHA_FRACTION
+
+    internal var isTransitionAnimationRunning: Boolean = false
+
+    // The drawable rendering this sheet's dimming, added to the overlay of dimmingHost which is
+    // Material's `design_bottom_sheet` component or the DecorView of the main application content.
+    private var dimmingDrawable: ColorDrawable? = null
+    private var dimmingHost: View? = null
+
+    private val dimmingHostLayoutListener =
+        View.OnLayoutChangeListener { view, _, _, _, _, _, _, _, _ ->
+            dimmingDrawable?.setBounds(0, 0, view.width, view.height)
+        }
+
+    internal var dimmingAlpha: Float = 0f
+        set(value) {
+            field = value
+            // We're transforming the value, because View.alpha is within [0.0, 1.0] range,
+            // while Drawable.alpha is an Integer in [0, 255] range.
+            dimmingDrawable?.alpha = (value * MAX_DRAWABLE_OVERLAY_ALPHA).roundToInt().coerceIn(0, MAX_DRAWABLE_OVERLAY_ALPHA)
+        }
+
+    /**
+     * Called when the sheet is presented. [belowSheetView] is the `design_bottom_sheet` of the
+     * sheet directly below in the stack, or null when this sheet is the bottom-most one - the
+     * dimming then goes onto the decor of the activity hosting the sheets.
+     */
+    internal fun attachDimming(belowSheetView: View?) {
+        val host = belowSheetView ?: resolveActivityDecorView()
+        if (host == null) {
+            Log.e(TAG, "[RNScreens] Neither a sheet below nor an activity decor found; the sheet will present undimmed.")
+            return
+        }
+
+        dimmingHost = host
+        dimmingDrawable =
+            ColorDrawable(Color.BLACK).apply {
+                alpha = 0
+                setBounds(0, 0, host.width, host.height)
+            }
+        host.overlay.add(dimmingDrawable!!)
+        host.addOnLayoutChangeListener(dimmingHostLayoutListener)
+    }
+
+    internal fun detachDimming() {
+        dimmingHost?.removeOnLayoutChangeListener(dimmingHostLayoutListener)
+        dimmingDrawable?.let { dimmingHost?.overlay?.remove(it) }
+        dimmingHost = null
+        dimmingDrawable = null
+    }
+
+    internal fun attachToBehavior(behavior: BottomSheetBehavior<*>) {
+        behavior.addBottomSheetCallback(
+            object : BottomSheetBehavior.BottomSheetCallback() {
+                override fun onStateChanged(
+                    bottomSheet: View,
+                    newState: Int,
+                ) = Unit
+
+                override fun onSlide(
+                    bottomSheet: View,
+                    slideOffset: Float,
+                ) {
+                    // Prevent system updates from overriding alpha while running custom enter/exit animation.
+                    // When initialDetentIndex is snapping to a high detent, BottomSheetBehavior fires onSlide
+                    // events that conflict with our manual alpha animator, causing the backdrop to flash.
+                    if (isTransitionAnimationRunning) {
+                        return
+                    }
+
+                    val fraction = if (slideOffset >= 0) 1f else 1f + slideOffset
+                    dimmingAlpha = fraction * maxAlpha
+                }
+            },
+        )
+    }
+
+    private fun resolveActivityDecorView(): View? {
+        var current: Context? = context
+        while (current is ContextWrapper) {
+            if (current is Activity) {
+                return current.window?.decorView
+            }
+            if (current is ReactContext) {
+                return current.currentActivity?.window?.decorView
+            }
+            current = current.baseContext
+        }
+        return null
+    }
+
+    companion object {
+        const val TAG = "FormSheetDimmingManager"
+
+        private const val MAX_DIMMING_ALPHA_FRACTION = 0.3f
+        private const val MAX_DRAWABLE_OVERLAY_ALPHA = 255
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/modals/formsheet/native/presentation/FormSheetDismissalOrigin.kt

@@ -0,0 +1,22 @@
+package com.swmansion.rnscreens.modals.formsheet.native.presentation
+
+internal enum class FormSheetDismissalOrigin {
+    /**
+     * No dismissal request is pending. Completing a dismissal with this
+     * origin should report an error.
+     */
+    UNSPECIFIED,
+
+    /**
+     * The dismissal was requested from JS by setting `isOpen = false`.
+     * Emits `onDismiss`.
+     */
+    PROGRAMMATIC_JS,
+
+    /**
+     * The dismissal was initiated by the user (swiping the sheet down,
+     * triggering the native back button, or tapping the backdrop).
+     * Emits `onNativeDismiss`.
+     */
+    USER,
+}