react-native-screens 5.0.0-alpha.2 → 5.0.0-alpha.4

package/android/src/main/java/com/swmansion/rnscreens/core/modals/formsheet/presentation/FormSheetPresentationManager.kt

@@ -0,0 +1,290 @@
+package com.swmansion.rnscreens.core.modals.formsheet.presentation
+
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.util.Log
+import android.view.View
+import androidx.core.view.doOnPreDraw
+import com.google.android.material.bottomsheet.BottomSheetBehavior
+import com.swmansion.rnscreens.common.event.ViewAppearanceEventEmitter
+
+internal class FormSheetPresentationManager(
+    private val presentationFactory: () -> FormSheetPresentation,
+    private val dimmingManager: FormSheetDimmingManager,
+    private val onNativeDismiss: () -> Unit,
+    private val onDismiss: () -> Unit,
+) {
+    internal var appearanceEventEmitter: ViewAppearanceEventEmitter? = null
+
+    internal var currentPresentation: FormSheetPresentation? = null
+        private set
+
+    private val bottomSheetView: View?
+        get() = currentPresentation?.bottomSheetView
+
+    private var state = FormSheetPresentationState.DISMISSED
+    private var shouldBeOpen = false
+    private var shouldSkipExitAnimation = false
+
+    private var dismissalOrigin = FormSheetDismissalOrigin.UNSPECIFIED
+
+    private val animatorFactory = FormSheetAnimatorFactory(dimmingManager)
+    private var currentSheetAnimator: Animator? = null
+
+    internal fun requestProgrammaticStateUpdate(shouldBeOpen: Boolean) {
+        if (shouldBeOpen) {
+            handlePresent()
+        } else {
+            handleProgrammaticDismiss()
+        }
+    }
+
+    private fun handlePresent() {
+        updatePresentationState(shouldBeOpen = true, origin = FormSheetDismissalOrigin.UNSPECIFIED)
+    }
+
+    private fun handleProgrammaticDismiss() {
+        updatePresentationState(shouldBeOpen = false, origin = FormSheetDismissalOrigin.PROGRAMMATIC_JS)
+    }
+
+    internal fun handleNativeDismiss() {
+        if (state == FormSheetPresentationState.DISMISSING || state == FormSheetPresentationState.DISMISSED) {
+            return
+        }
+
+        updatePresentationState(shouldBeOpen = false, origin = FormSheetDismissalOrigin.USER)
+    }
+
+    private fun updatePresentationState(
+        shouldBeOpen: Boolean,
+        origin: FormSheetDismissalOrigin,
+    ) {
+        // The origin belongs to the request that transitioned the target to closed -
+        // a repeated close request must not override it. Once a dismissal is in flight,
+        // it keeps the origin that started it until the completion events are emitted.
+        val isRepeatCloseRequest = !shouldBeOpen && !this.shouldBeOpen
+        if (state != FormSheetPresentationState.DISMISSING && !isRepeatCloseRequest) {
+            dismissalOrigin = origin
+        }
+        this.shouldBeOpen = shouldBeOpen
+        resolvePresentationState()
+    }
+
+    private fun resolvePresentationState() {
+        if (shouldBeOpen) {
+            presentIfNeeded()
+        } else {
+            dismissIfNeeded()
+        }
+    }
+
+    private fun presentIfNeeded() {
+        if (state != FormSheetPresentationState.DISMISSED) {
+            return
+        }
+
+        state = FormSheetPresentationState.PRESENTING
+        val presentation = presentationFactory().also { currentPresentation = it }
+        presentation.sheetBehavior?.let(dimmingManager::attachToBehavior)
+
+        FormSheetStackRegistry.register(this)
+        appearanceEventEmitter?.emitOnWillAppear()
+        presentation.bottomSheetView?.let(::keepOffscreenUntilEnterAnimation)
+        presentation.dialog.setOnShowListener {
+            presentation.dialog.setOnShowListener(null)
+
+            // Every sheet dims the surface inside the window below, attaching an overlay to the sheet
+            // directly below in the stack, or to the DecorView when this sheet is the
+            // bottom-most one.
+            dimmingManager.attachDimming(FormSheetStackRegistry.sheetBelow(this)?.bottomSheetView)
+
+            startEnterAnimation()
+        }
+        presentation.dialog.show()
+    }
+
+    private fun dismissIfNeeded() {
+        if (state != FormSheetPresentationState.PRESENTED) {
+            return
+        }
+
+        state = FormSheetPresentationState.DISMISSING
+        currentPresentation?.setKeyboardTrackingEnabled(false)
+        dismissSheetsAbove()
+        // Leaving the stack immediately is deliberate, if another sheet is presented during this exit animation,
+        // it must stack on a "stable" sheet - the one we don't intend to dismiss. This window is about to be
+        // torn down.
+        FormSheetStackRegistry.unregister(this)
+        appearanceEventEmitter?.emitOnWillDisappear()
+
+        val isSheetHidden =
+            bottomSheetView?.let {
+                BottomSheetBehavior.from(it).state == BottomSheetBehavior.STATE_HIDDEN
+            } ?: true
+
+        if (isSheetHidden) {
+            performDismiss()
+            return
+        }
+
+        if (shouldSkipExitAnimation) {
+            performInstantDismiss()
+            return
+        }
+
+        startExitAnimation()
+    }
+
+    // Dismissing a sheet from the middle of the stack should dismiss all sheets above it,
+    // mirroring the iOS presentation chain teardown. Sheets are dismissed top-down.
+    private fun dismissSheetsAbove() {
+        FormSheetStackRegistry.sheetsAbove(this).asReversed().forEach {
+            it.handleDismissFromCascade()
+        }
+    }
+
+    private fun handleDismissFromCascade() {
+        if (state == FormSheetPresentationState.DISMISSING || state == FormSheetPresentationState.DISMISSED) {
+            return
+        }
+
+        shouldSkipExitAnimation = true
+        updatePresentationState(false, FormSheetDismissalOrigin.USER)
+    }
+
+    private fun performInstantDismiss() {
+        currentSheetAnimator?.removeAllListeners()
+        currentSheetAnimator?.cancel()
+        currentSheetAnimator = null
+
+        performDismiss()
+    }
+
+    /**
+     * `Dialog.show()` **posts** the show message behind the sync barrier of the traversal scheduled while
+     * adding the decor to the window, so the Dialog always draws its first frame before `OnShowListener`
+     * (with our custom enter animation) runs. A freshly created sheet rests at `translationY = 0`, so that
+     * frame would show it at its final position and the enter animator would then snap it back
+     * off-screen.
+     *
+     * Applying the translation on the first pre-draw - after the layout, when the sheet height is
+     * already known, but before anything is drawn - keeps the sheet off-screen from the very first frame.
+     */
+    private fun keepOffscreenUntilEnterAnimation(view: View) {
+        view.doOnPreDraw {
+            if (currentSheetAnimator == null) {
+                view.translationY = view.height.toFloat()
+            }
+        }
+    }
+
+    private fun startEnterAnimation() {
+        val bottomSheetView = bottomSheetView
+        if (bottomSheetView == null) {
+            onPresentationComplete()
+            return
+        }
+
+        val isInterrupting = currentSheetAnimator?.isRunning == true
+        currentSheetAnimator?.removeAllListeners()
+        currentSheetAnimator?.cancel()
+
+        dimmingManager.isTransitionAnimationRunning = true
+
+        currentSheetAnimator =
+            animatorFactory.createEnterAnimator(bottomSheetView, isInterrupting).apply {
+                addListener(
+                    object : AnimatorListenerAdapter() {
+                        override fun onAnimationEnd(animation: Animator) {
+                            dimmingManager.isTransitionAnimationRunning = false
+
+                            if (currentSheetAnimator == this@apply) currentSheetAnimator = null
+                            onPresentationComplete()
+                        }
+                    },
+                )
+                start()
+            }
+    }
+
+    private fun startExitAnimation() {
+        val bottomSheetView = bottomSheetView
+        if (bottomSheetView == null) {
+            performDismiss()
+            return
+        }
+
+        val isInterrupting = currentSheetAnimator?.isRunning == true
+        currentSheetAnimator?.removeAllListeners()
+        currentSheetAnimator?.cancel()
+
+        dimmingManager.isTransitionAnimationRunning = true
+
+        currentSheetAnimator =
+            animatorFactory.createExitAnimator(bottomSheetView, isInterrupting).apply {
+                addListener(
+                    object : AnimatorListenerAdapter() {
+                        override fun onAnimationEnd(animation: Animator) {
+                            dimmingManager.isTransitionAnimationRunning = false
+
+                            if (currentSheetAnimator == this@apply) currentSheetAnimator = null
+                            performDismiss()
+                        }
+                    },
+                )
+                start()
+            }
+    }
+
+    private fun performDismiss() {
+        shouldSkipExitAnimation = false
+        dimmingManager.detachDimming()
+        currentPresentation?.destroy()
+        currentPresentation = null
+        onDismissComplete()
+    }
+
+    private fun onPresentationComplete() {
+        if (state == FormSheetPresentationState.PRESENTING) {
+            state = FormSheetPresentationState.PRESENTED
+            currentPresentation?.setKeyboardTrackingEnabled(true)
+            appearanceEventEmitter?.emitOnDidAppear()
+            // ensure state hasn't updated during presentation
+            resolvePresentationState()
+        }
+    }
+
+    private fun onDismissComplete() {
+        if (state == FormSheetPresentationState.DISMISSING) {
+            state = FormSheetPresentationState.DISMISSED
+            appearanceEventEmitter?.emitOnDidDisappear()
+
+            when (dismissalOrigin) {
+                FormSheetDismissalOrigin.USER -> onNativeDismiss()
+                FormSheetDismissalOrigin.PROGRAMMATIC_JS -> onDismiss()
+                FormSheetDismissalOrigin.UNSPECIFIED ->
+                    Log.e(
+                        "[RNScreens]",
+                        "FormSheet dismissal completed without a recorded origin; no dismissal event emitted",
+                    )
+            }
+            dismissalOrigin = FormSheetDismissalOrigin.UNSPECIFIED
+
+            // ensure state hasn't updated during dismissal
+            resolvePresentationState()
+        }
+    }
+
+    internal fun destroy() {
+        FormSheetStackRegistry.unregister(this)
+        dimmingManager.detachDimming()
+
+        currentSheetAnimator?.cancel()
+        currentSheetAnimator = null
+
+        currentPresentation?.destroy()
+        currentPresentation = null
+
+        state = FormSheetPresentationState.DISMISSED
+    }
+}

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

@@ -1,4 +1,4 @@
-package com.swmansion.rnscreens.modals.formsheet.native.presentation
+package com.swmansion.rnscreens.core.modals.formsheet.presentation
 
 internal enum class FormSheetPresentationState {
     /**
@@ -27,7 +27,7 @@ internal enum class FormSheetPresentationState {
     /**
      * The manager is actively preparing to show the sheet. `presentIfNeeded()` has been called.
      * During this state, `dialog.show()` is executed. The manager waits for the `onShowListener`
-     * to fire, requests DimmingView attachment from `dimmingManager` and runs starts entrance animation.
+     * to fire, attaches the dimming through `dimmingManager` and starts the entrance animation.
      * Once the enter animator finishes, the state moves to [PRESENTED].
      * **Transitional state** from [DISMISSED] to [PRESENTED].
      */

package/android/src/main/java/com/swmansion/rnscreens/core/modals/formsheet/presentation/FormSheetStackRegistry.kt

@@ -0,0 +1,28 @@
+package com.swmansion.rnscreens.core.modals.formsheet.presentation
+
+internal object FormSheetStackRegistry {
+    private val stack = mutableListOf<FormSheetPresentationManager>()
+
+    internal fun register(sheet: FormSheetPresentationManager) {
+        if (!stack.contains(sheet)) {
+            stack.add(sheet)
+        }
+    }
+
+    internal fun unregister(sheet: FormSheetPresentationManager) {
+        stack.remove(sheet)
+    }
+
+    internal fun sheetsAbove(sheet: FormSheetPresentationManager): List<FormSheetPresentationManager> {
+        val index = stack.indexOf(sheet)
+        if (index < 0) {
+            return emptyList()
+        }
+        return stack.drop(index + 1)
+    }
+
+    internal fun sheetBelow(sheet: FormSheetPresentationManager): FormSheetPresentationManager? {
+        val index = stack.indexOf(sheet)
+        return if (index > 0) stack[index - 1] else null
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/ext/FragmentManagerExt.kt

@@ -0,0 +1,6 @@
+package com.swmansion.rnscreens.ext
+
+import androidx.fragment.app.FragmentManager
+import androidx.fragment.app.FragmentTransaction
+
+internal fun FragmentManager.createTransactionWithReordering(): FragmentTransaction = this.beginTransaction().setReorderingAllowed(true)

package/android/src/main/java/com/swmansion/rnscreens/helpers/FragmentManagerHelper.kt

@@ -6,7 +6,6 @@ import android.view.ViewParent
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentActivity
 import androidx.fragment.app.FragmentManager
-import androidx.fragment.app.FragmentTransaction
 import com.facebook.react.ReactRootView
 import com.swmansion.rnscreens.common.FragmentProviding
 
@@ -75,5 +74,3 @@ object FragmentManagerHelper {
         }
     }
 }
-
-internal fun FragmentManager.createTransactionWithReordering(): FragmentTransaction = this.beginTransaction().setReorderingAllowed(true)

package/android/src/main/java/com/swmansion/rnscreens/helpers/NoTintDrawable.kt

@@ -0,0 +1,31 @@
+package com.swmansion.rnscreens.helpers
+
+import android.content.res.ColorStateList
+import android.content.res.Resources
+import android.graphics.PorterDuff
+import android.graphics.drawable.Drawable
+import androidx.appcompat.graphics.drawable.DrawableWrapperCompat
+
+// Ignores tinting so the wrapped icon keeps its own colors even when a host view
+// (e.g. BottomNavigationView) applies an itemIconTintList.
+internal class NoTintDrawable(
+    drawable: Drawable,
+) : DrawableWrapperCompat(drawable) {
+    override fun setTintList(tint: ColorStateList?) = Unit
+
+    override fun setTint(tintColor: Int) = Unit
+
+    override fun setTintMode(tintMode: PorterDuff.Mode?) = Unit
+
+    override fun getConstantState(): ConstantState? = drawable?.constantState?.let(::NoTintConstantState)
+
+    private class NoTintConstantState(
+        private val wrappedState: ConstantState,
+    ) : ConstantState() {
+        override fun newDrawable(): Drawable = NoTintDrawable(wrappedState.newDrawable())
+
+        override fun newDrawable(res: Resources?): Drawable = NoTintDrawable(wrappedState.newDrawable(res))
+
+        override fun getChangingConfigurations(): Int = wrappedState.changingConfigurations
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/helpers/PropIconResolver.kt

@@ -1,6 +1,5 @@
 package com.swmansion.rnscreens.helpers
 
-import android.content.Context
 import android.graphics.drawable.Drawable
 
 /**
@@ -21,27 +20,28 @@ internal sealed interface IconResolution {
 
 /**
  * Stateful, latest-wins icon resolver for a single declaratively-driven icon slot — a `toolbarMenu`
- * prop menu item, or the back button — that is re-evaluated on every prop transaction. It
- * deduplicates unchanged sources ([IconResolution.Unchanged]) to avoid needless reloads/flicker,
- * and drops stale async results so a slow load cannot clobber a newer source.
+ * prop menu item, or the back button — that is re-evaluated on every source change. It deduplicates
+ * unchanged sources ([IconResolution.Unchanged]) to avoid needless reloads/flicker, and drops stale
+ * async results so a slow load cannot clobber a newer source.
+ *
+ * [load] must invoke its completion callback exactly once — synchronously or asynchronously,
+ * always on the main thread — with the loaded drawable, or `null` when the source resolves to
+ * no icon or fails to load (see e.g. [resolveImage]).
  */
-internal class PropIconResolver {
+internal class PropIconResolver(
+    private val load: (drawableIconResourceName: String?, imageIconUri: String?, onComplete: (Drawable?) -> Unit) -> Unit,
+) {
     private var lastDrawableName: String? = null
     private var lastImageUri: String? = null
     private var lastEmittedDrawableName: String? = null
     private var lastEmittedImageUri: String? = null
 
     /**
-     * Resolves an icon from a drawable resource name or an image uri.
-     *
-     * The result is delivered to [onResult] synchronously for drawable resources and empty sources,
-     * and asynchronously for image uris. For image uris, the callback is only invoked if the
-     * resolved uri is still the latest requested source (stale requests are dropped). On a failed
-     * image load the latest request still emits [IconResolution.Resolved] with a `null` drawable, so
-     * the icon is cleared rather than left stale.
+     * Resolves an icon from a drawable resource name or an image uri. The result is delivered
+     * to [onResult] only if the requested source is still the latest one (stale async results
+     * are dropped).
      */
     fun resolve(
-        context: Context,
         drawableIconResourceName: String?,
         imageIconUri: String?,
         onResult: (IconResolution) -> Unit,
@@ -56,16 +56,10 @@ internal class PropIconResolver {
         }
         lastEmittedDrawableName = drawableIconResourceName
         lastEmittedImageUri = imageIconUri
-        when {
-            drawableIconResourceName != null ->
-                onResult(IconResolution.Resolved(getSystemDrawableResource(context, drawableIconResourceName)))
-            imageIconUri != null ->
-                loadImage(context, imageIconUri) { drawable ->
-                    if (imageIconUri == lastImageUri && lastDrawableName == null) {
-                        onResult(IconResolution.Resolved(drawable))
-                    }
-                }
-            else -> onResult(IconResolution.Resolved(null))
+        load(drawableIconResourceName, imageIconUri) { drawable ->
+            if (drawableIconResourceName == lastDrawableName && imageIconUri == lastImageUri) {
+                onResult(IconResolution.Resolved(drawable))
+            }
         }
     }
 }

package/android/src/main/java/com/swmansion/rnscreens/helpers/ViewFinder.kt

@@ -5,7 +5,6 @@ import android.view.ViewGroup
 import android.widget.ScrollView
 import androidx.core.view.isNotEmpty
 import androidx.core.widget.NestedScrollView
-import com.swmansion.rnscreens.legacy.ScreenStack
 
 object ViewFinder {
     fun findScrollViewInFirstDescendantChain(view: View): ViewGroup? {
@@ -23,20 +22,4 @@ object ViewFinder {
 
         return null
     }
-
-    fun findScreenStackInFirstDescendantChain(view: View): ScreenStack? {
-        var currentView: View? = view
-
-        while (currentView != null) {
-            if (currentView is ScreenStack) {
-                return currentView
-            } else if (currentView is ViewGroup && currentView.isNotEmpty()) {
-                currentView = currentView.getChildAt(0)
-            } else {
-                break
-            }
-        }
-
-        return null
-    }
 }

package/android/src/main/java/com/swmansion/rnscreens/legacy/Screen.kt

@@ -27,6 +27,9 @@ import com.google.android.material.shape.CornerFamily
 import com.google.android.material.shape.MaterialShapeDrawable
 import com.google.android.material.shape.ShapeAppearanceModel
 import com.swmansion.rnscreens.common.FragmentProviding
+import com.swmansion.rnscreens.common.container.Container
+import com.swmansion.rnscreens.common.container.ContainerItem
+import com.swmansion.rnscreens.common.container.ContainerItemSupport
 import com.swmansion.rnscreens.legacy.bottomsheet.SheetAnimationCoordinator
 import com.swmansion.rnscreens.legacy.bottomsheet.SheetDetents
 import com.swmansion.rnscreens.legacy.bottomsheet.fitToContentsSheetHeight
@@ -46,7 +49,10 @@ class Screen(
     val reactContext: ThemedReactContext,
 ) : FabricEnabledViewGroup(reactContext),
     ScreenContentWrapper.OnLayoutCallback,
-    FragmentProviding {
+    FragmentProviding,
+    ContainerItem {
+    private val containerItemSupport = ContainerItemSupport()
+
     val fragment: Fragment?
         get() = fragmentWrapper?.fragment
 
@@ -236,7 +242,7 @@ class Screen(
     ) {
         // In case of form sheet we get layout notification a bit later, in `onBottomSheetBehaviorDidLayout`
         // after the attached behaviour laid out this view.
-        if (changed && isNativeStackScreen && !usesFormSheetPresentation()) {
+        if ((changed || isStateInvalidated) && isNativeStackScreen && !usesFormSheetPresentation()) {
             val width = r - l
             val height = b - t
 
@@ -495,8 +501,10 @@ class Screen(
                     // It has a custom `getChildDrawingOrder` method which returns
                     // wrong index if we called `startViewTransition` on the views on new arch.
                     // We add a simple View to bump the number of children to make it work.
+                    // Appended, not inserted at `i`: a filler before the circle inflates the
+                    // index `onMeasure` caches for it, which then outlives the child it points at.
                     // TODO: find a better way to handle this scenario
-                    it.addView(View(context), i)
+                    it.addView(View(context))
                 } else {
                     child?.let { view -> it.startViewTransition(view) }
                 }
@@ -563,6 +571,13 @@ class Screen(
         updateShadowNodeScreenSize(width, height, top + translationY.toInt())
     }
 
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        // Rotation may reset the shadow state while this screen is covered. Republish it on the
+        // next layout, even if the native frame is identical to the one before detaching.
+        invalidateState()
+    }
+
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
 
@@ -617,6 +632,20 @@ class Screen(
         }
     }
 
+    // region ContainerItem
+
+    override fun registerNestedContainer(container: Container) = containerItemSupport.registerNestedContainer(container)
+
+    override fun unregisterNestedContainer(container: Container) = containerItemSupport.unregisterNestedContainer(container)
+
+    override fun resolveNestedContainer(): Container? = containerItemSupport.resolveNestedContainer()
+
+    override fun findContentScrollView(): ViewGroup? = containerItemSupport.findContentScrollView(this)
+
+    override fun wantsToPreventStackNativeDismiss(): ContainerItem? = resolveNestedContainer()?.wantsToPreventStackNativeDismiss()
+
+    // endregion
+
     enum class StackPresentation {
         PUSH,
         MODAL,

package/android/src/main/java/com/swmansion/rnscreens/legacy/ScreenContainer.kt

@@ -17,11 +17,15 @@ import com.facebook.react.modules.core.ReactChoreographer
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.swmansion.rnscreens.common.FragmentProviding
+import com.swmansion.rnscreens.common.container.Container
+import com.swmansion.rnscreens.common.container.ContainerItem
+import com.swmansion.rnscreens.common.container.ParentContainerItemRegistry
 import com.swmansion.rnscreens.legacy.events.ScreenDismissedEvent
 
 open class ScreenContainer(
     context: Context?,
-) : ViewGroup(context) {
+) : ViewGroup(context),
+    Container {
     @JvmField
     protected val screenWrappers = ArrayList<ScreenFragmentWrapper>()
 
@@ -43,6 +47,10 @@ open class ScreenContainer(
         }
     private var parentScreenWrapper: ScreenFragmentWrapper? = null
 
+    private val parentContainerRegistry = ParentContainerItemRegistry()
+
+    override fun shouldDelayChildPressedState(): Boolean = false
+
     override fun onLayout(
         changed: Boolean,
         l: Int,
@@ -275,16 +283,27 @@ open class ScreenContainer(
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
+        parentContainerRegistry.attach(this)
         isAttached = true
         setupFragmentManager()
     }
 
-    /** Removes fragments from fragment manager that are attached to this container  */
+    /**
+     * Removes fragments from fragment manager that are attached to this container, including
+     * fragments of screens already removed from it whose deferred removal hasn't run yet.
+     */
     private fun removeMyFragments(fragmentManager: FragmentManager) {
         val transaction = fragmentManager.beginTransaction()
         var hasFragments = false
         for (fragment in fragmentManager.fragments) {
-            if (fragment is ScreenFragment && fragment.screen.container === this) {
+            // `removeScreenAt` / `removeAllScreens` clear `screen.container` immediately but defer
+            // the fragment removal, so also match such orphans by the container view id.
+            if (fragment is ScreenFragment &&
+                (
+                    fragment.screen.container === this ||
+                        (fragment.screen.container == null && fragment.id == id)
+                )
+            ) {
                 transaction.remove(fragment)
                 hasFragments = true
             }
@@ -310,6 +329,7 @@ open class ScreenContainer(
 
         parentScreenWrapper?.removeChildScreenContainer(this)
         parentScreenWrapper = null
+        parentContainerRegistry.detach(this)
 
         super.onDetachedFromWindow()
         isAttached = false
@@ -444,4 +464,16 @@ open class ScreenContainer(
     protected open fun notifyContainerUpdate() {
         topScreen?.fragmentWrapper?.onContainerUpdate()
     }
+
+    // region Container
+
+    // Only the currently shown (top) screen is consulted.
+    override fun resolveCurrentContentScrollView(): ViewGroup? = topScreen?.findContentScrollView()
+
+    override fun wantsToPreventStackNativeDismiss(): ContainerItem? = topScreen?.wantsToPreventStackNativeDismiss()
+
+    // Nothing to pop here - the request goes to the shown screen's nested container.
+    override fun requestPopToRoot(): Boolean = topScreen?.resolveNestedContainer()?.requestPopToRoot() == true
+
+    // endregion
 }

package/android/src/main/java/com/swmansion/rnscreens/legacy/ScreenStack.kt

@@ -6,6 +6,7 @@ import android.os.Build
 import android.view.View
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.rnscreens.common.container.ContainerItem
 import com.swmansion.rnscreens.legacy.bottomsheet.requiresEnterTransitionPostponing
 import com.swmansion.rnscreens.legacy.bottomsheet.sheetShouldUseDimmingView
 import com.swmansion.rnscreens.legacy.bottomsheet.usesFormSheetPresentation
@@ -282,6 +283,8 @@ class ScreenStack(
                 screenWrappers
                     .asSequence()
                     .dropWhile { it !== visibleBottom } // ignore all screens beneath the visible bottom
+                    // dismissed screens are already removed above & preloaded ones must stay detached
+                    .filter { !dismissedWrappers.contains(it) && it.screen.activityState !== Screen.ActivityState.INACTIVE }
                     .forEach { wrapper ->
                         // TODO: It should be enough to dispatch this on commit action once.
                         transaction.add(id, wrapper.fragment).runOnCommit {
@@ -438,6 +441,18 @@ class ScreenStack(
         }
     }
 
+    // region Container
+
+    override fun wantsToPreventStackNativeDismiss(): ContainerItem? =
+        screenWrappers
+            .asReversed()
+            .filter { !dismissedWrappers.contains(it) }
+            .firstNotNullOfOrNull { it.screen.wantsToPreventStackNativeDismiss() }
+
+    override fun requestPopToRoot(): Boolean = popToRoot() || super.requestPopToRoot()
+
+    // endregion
+
     companion object {
         const val TAG = "ScreenStack"