@amazon-devices/react-native-screens 2.0.1758683737

package/android/src/main/java/com/swmansion/rnscreens/ScreenFragment.kt

@@ -0,0 +1,331 @@
+package com.swmansion.rnscreens
+
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.content.Context
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewParent
+import android.widget.FrameLayout
+import androidx.fragment.app.Fragment
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.swmansion.rnscreens.events.HeaderBackButtonClickedEvent
+import com.swmansion.rnscreens.events.ScreenAppearEvent
+import com.swmansion.rnscreens.events.ScreenDisappearEvent
+import com.swmansion.rnscreens.events.ScreenDismissedEvent
+import com.swmansion.rnscreens.events.ScreenTransitionProgressEvent
+import com.swmansion.rnscreens.events.ScreenWillAppearEvent
+import com.swmansion.rnscreens.events.ScreenWillDisappearEvent
+import kotlin.math.max
+import kotlin.math.min
+
+open class ScreenFragment : Fragment, ScreenFragmentWrapper {
+    enum class ScreenLifecycleEvent {
+        Appear, WillAppear, Disappear, WillDisappear
+    }
+
+    override val fragment: Fragment
+        get() = this
+
+    // if we call empty constructor, there is no screen to be assigned so not sure why it is suggested
+    @Suppress("JoinDeclarationAndAssignment")
+    override lateinit var screen: Screen
+    private val mChildScreenContainers: MutableList<ScreenContainer> = ArrayList()
+    private var shouldUpdateOnResume = false
+    // if we don't set it, it will be 0.0f at the beginning so the progress will not be sent
+    // due to progress value being already 0.0f
+    private var mProgress = -1f
+
+    // those 2 vars are needed since sometimes the events would be dispatched twice in child containers
+    // (should only happen if parent has `NONE` animation) and we don't need too complicated logic.
+    // We just check if, after the event was dispatched, its "counter-event" has been also dispatched before sending the same event again.
+    // We do it for 'willAppear' -> 'willDisappear' and 'appear' -> 'disappear'
+    private var canDispatchWillAppear = true
+    private var canDispatchAppear = true
+
+    // we want to know if we are currently transitioning in order not to fire lifecycle events
+    // in nested fragments. See more explanation in dispatchViewAnimationEvent
+    private var isTransitioning = false
+
+    constructor() {
+        throw IllegalStateException(
+            "Screen fragments should never be restored. Follow instructions from https://github.com/software-mansion/react-native-screens/issues/17#issuecomment-424704067 to properly configure your main activity."
+        )
+    }
+
+    @SuppressLint("ValidFragment")
+    constructor(screenView: Screen) : super() {
+        screen = screenView
+    }
+
+    override fun onResume() {
+        super.onResume()
+        if (shouldUpdateOnResume) {
+            shouldUpdateOnResume = false
+            ScreenWindowTraits.trySetWindowTraits(screen, tryGetActivity(), tryGetContext())
+        }
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        screen.layoutParams = FrameLayout.LayoutParams(
+            ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT
+        )
+        val wrapper = context?.let { ScreensFrameLayout(it) }?.apply {
+            addView(recycleView(screen))
+        }
+        return wrapper
+    }
+
+    private class ScreensFrameLayout(
+        context: Context,
+    ) : FrameLayout(context) {
+        /**
+         * This method implements a workaround for RN's autoFocus functionality. Because of the way
+         * autoFocus is implemented it dismisses soft keyboard in fragment transition
+         * due to change of visibility of the view at the start of the transition. Here we override the
+         * call to `clearFocus` when the visibility of view is `INVISIBLE` since `clearFocus` triggers the
+         * hiding of the keyboard in `ReactEditText.java`.
+         */
+        override fun clearFocus() {
+            if (visibility != INVISIBLE) {
+                super.clearFocus()
+            }
+        }
+    }
+
+    override fun onContainerUpdate() {
+        updateWindowTraits()
+    }
+
+    private fun updateWindowTraits() {
+        val activity: Activity? = activity
+        if (activity == null) {
+            shouldUpdateOnResume = true
+            return
+        }
+        ScreenWindowTraits.trySetWindowTraits(screen, activity, tryGetContext())
+    }
+
+    override fun tryGetActivity(): Activity? {
+        activity?.let { return it }
+        val context = screen.context
+        if (context is ReactContext && context.currentActivity != null) {
+            return context.currentActivity
+        }
+        var parent: ViewParent? = screen.container
+        while (parent != null) {
+            if (parent is Screen) {
+                val fragment = parent.fragment
+                fragment?.activity?.let { return it }
+            }
+            parent = parent.parent
+        }
+        return null
+    }
+
+    override fun tryGetContext(): ReactContext? {
+        if (context is ReactContext) {
+            return context as ReactContext
+        }
+        if (screen.context is ReactContext) {
+            return screen.context as ReactContext
+        }
+        var parent: ViewParent? = screen.container
+        while (parent != null) {
+            if (parent is Screen) {
+                if (parent.context is ReactContext) {
+                    return parent.context as ReactContext
+                }
+            }
+            parent = parent.parent
+        }
+        return null
+    }
+
+    override val childScreenContainers: List<ScreenContainer>
+        get() = mChildScreenContainers
+
+    override fun canDispatchLifecycleEvent(event: ScreenLifecycleEvent): Boolean = when (event) {
+        ScreenLifecycleEvent.WillAppear -> canDispatchWillAppear
+        ScreenLifecycleEvent.Appear -> canDispatchAppear
+        ScreenLifecycleEvent.WillDisappear -> !canDispatchWillAppear
+        ScreenLifecycleEvent.Disappear -> !canDispatchAppear
+    }
+
+    override fun updateLastEventDispatched(event: ScreenLifecycleEvent) {
+        when (event) {
+            ScreenLifecycleEvent.WillAppear -> canDispatchWillAppear = false
+            ScreenLifecycleEvent.Appear -> canDispatchAppear = false
+            ScreenLifecycleEvent.WillDisappear -> canDispatchWillAppear = true
+            ScreenLifecycleEvent.Disappear -> canDispatchAppear = true
+        }
+    }
+
+    private fun dispatchOnWillAppear() {
+        dispatchLifecycleEvent(ScreenLifecycleEvent.WillAppear, this)
+        dispatchTransitionProgressEvent(0.0f, false)
+    }
+
+    private fun dispatchOnAppear() {
+        dispatchLifecycleEvent(ScreenLifecycleEvent.Appear, this)
+        dispatchTransitionProgressEvent(1.0f, false)
+    }
+
+    private fun dispatchOnWillDisappear() {
+        dispatchLifecycleEvent(ScreenLifecycleEvent.WillDisappear, this)
+        dispatchTransitionProgressEvent(0.0f, true)
+    }
+
+    private fun dispatchOnDisappear() {
+        dispatchLifecycleEvent(ScreenLifecycleEvent.Disappear, this)
+        dispatchTransitionProgressEvent(1.0f, true)
+    }
+
+    override fun dispatchLifecycleEvent(event: ScreenLifecycleEvent, fragmentWrapper: ScreenFragmentWrapper) {
+        val fragment = fragmentWrapper.fragment
+        if (fragment is ScreenStackFragment && fragment.canDispatchLifecycleEvent(event)) {
+            fragment.screen.let {
+                fragmentWrapper.updateLastEventDispatched(event)
+                val surfaceId = UIManagerHelper.getSurfaceId(it)
+                val lifecycleEvent: Event<*> = when (event) {
+                    ScreenLifecycleEvent.WillAppear -> ScreenWillAppearEvent(surfaceId, it.id)
+                    ScreenLifecycleEvent.Appear -> ScreenAppearEvent(surfaceId, it.id)
+                    ScreenLifecycleEvent.WillDisappear -> ScreenWillDisappearEvent(surfaceId, it.id)
+                    ScreenLifecycleEvent.Disappear -> ScreenDisappearEvent(surfaceId, it.id)
+                }
+                val screenContext = screen.context as ReactContext
+                val eventDispatcher: EventDispatcher? =
+                    UIManagerHelper.getEventDispatcherForReactTag(screenContext, screen.id)
+                eventDispatcher?.dispatchEvent(lifecycleEvent)
+                fragmentWrapper.dispatchLifecycleEventInChildContainers(event)
+            }
+        }
+    }
+
+    override fun dispatchLifecycleEventInChildContainers(event: ScreenLifecycleEvent) {
+        mChildScreenContainers.filter { it.screenCount > 0 }.forEach {
+            it.topScreen?.fragmentWrapper?.let { fragment -> dispatchLifecycleEvent(event, fragment) }
+        }
+    }
+
+    override fun dispatchHeaderBackButtonClickedEvent() {
+        val screenContext = screen.context as ReactContext
+        val surfaceId = UIManagerHelper.getSurfaceId(screenContext)
+        UIManagerHelper
+            .getEventDispatcherForReactTag(screenContext, screen.id)
+            ?.dispatchEvent(HeaderBackButtonClickedEvent(surfaceId, screen.id))
+    }
+
+    override fun dispatchTransitionProgressEvent(alpha: Float, closing: Boolean) {
+        if (this is ScreenStackFragment) {
+            if (mProgress != alpha) {
+                mProgress = max(0.0f, min(1.0f, alpha))
+                /* We want value of 0 and 1 to be always dispatched so we base coalescing key on the progress:
+                 - progress is 0 -> key 1
+                 - progress is 1 -> key 2
+                 - progress is between 0 and 1 -> key 3
+             */
+                val coalescingKey = (if (mProgress == 0.0f) 1 else if (mProgress == 1.0f) 2 else 3).toShort()
+                val container: ScreenContainer? = screen.container
+                val goingForward = if (container is ScreenStack) container.goingForward else false
+                val screenContext = screen.context as ReactContext
+                UIManagerHelper
+                    .getEventDispatcherForReactTag(screenContext, screen.id)
+                    ?.dispatchEvent(
+                        ScreenTransitionProgressEvent(
+                            UIManagerHelper.getSurfaceId(screenContext),
+                            screen.id, mProgress, closing, goingForward, coalescingKey
+                        )
+                    )
+            }
+        }
+    }
+
+    override fun addChildScreenContainer(container: ScreenContainer) {
+        mChildScreenContainers.add(container)
+    }
+
+    override fun removeChildScreenContainer(container: ScreenContainer) {
+        mChildScreenContainers.remove(container)
+    }
+
+    override fun onViewAnimationStart() {
+        dispatchViewAnimationEvent(false)
+    }
+
+    override fun onViewAnimationEnd() {
+        dispatchViewAnimationEvent(true)
+    }
+
+    private fun dispatchViewAnimationEvent(animationEnd: Boolean) {
+        isTransitioning = !animationEnd
+        // if parent fragment is transitioning, we do not want the events dispatched from the child,
+        // since we subscribe to parent's animation start/end and dispatch events in child from there
+        // check for `isTransitioning` should be enough since the child's animation should take only
+        // 20ms due to always being `StackAnimation.NONE` when nested stack being pushed
+        val parent = parentFragment
+        if (parent == null || (parent is ScreenFragment && !parent.isTransitioning)) {
+            // onViewAnimationStart/End is triggered from View#onAnimationStart/End method of the fragment's root
+            // view. We override an appropriate method of the StackFragment's
+            // root view in order to achieve this.
+            if (isResumed) {
+                // Android dispatches the animation start event for the fragment that is being added first
+                // however we want the one being dismissed first to match iOS. It also makes more sense from
+                // a navigation point of view to have the disappear event first.
+                // Since there are no explicit relationships between the fragment being added / removed the
+                // practical way to fix this is delaying dispatching the appear events at the end of the
+                // frame.
+                UiThreadUtil.runOnUiThread {
+                    if (animationEnd) dispatchOnAppear() else dispatchOnWillAppear()
+                }
+            } else {
+                if (animationEnd) dispatchOnDisappear() else dispatchOnWillDisappear()
+            }
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        val container = screen.container
+        if (container == null || !container.hasScreen(this)) {
+            // we only send dismissed even when the screen has been removed from its container
+            val screenContext = screen.context
+            if (screenContext is ReactContext) {
+                val surfaceId = UIManagerHelper.getSurfaceId(screenContext)
+                UIManagerHelper
+                    .getEventDispatcherForReactTag(screenContext, screen.id)
+                    ?.dispatchEvent(ScreenDismissedEvent(surfaceId, screen.id))
+            }
+        }
+        mChildScreenContainers.clear()
+    }
+
+    companion object {
+        @JvmStatic
+        protected fun recycleView(view: View): View {
+            // screen fragments reuse view instances instead of creating new ones. In order to reuse a given
+            // view it needs to be detached from the view hierarchy to allow the fragment to attach it back.
+            val parent = view.parent
+            if (parent != null) {
+                (parent as ViewGroup).endViewTransition(view)
+                parent.removeView(view)
+            }
+
+            // view detached from fragment manager get their visibility changed to GONE after their state is
+            // dumped. Since we don't restore the state but want to reuse the view we need to change
+            // visibility back to VISIBLE in order for the fragment manager to animate in the view.
+            view.visibility = View.VISIBLE
+            return view
+        }
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/ScreenFragmentWrapper.kt

@@ -0,0 +1,22 @@
+package com.swmansion.rnscreens
+
+import android.app.Activity
+import com.facebook.react.bridge.ReactContext
+
+interface ScreenFragmentWrapper : FragmentHolder, ScreenEventDispatcher {
+    var screen: Screen
+
+    // Communication with container
+    val childScreenContainers: List<ScreenContainer>
+    fun addChildScreenContainer(container: ScreenContainer)
+    fun removeChildScreenContainer(container: ScreenContainer)
+    fun onContainerUpdate()
+
+    // Animation phase callbacks
+    fun onViewAnimationStart()
+    fun onViewAnimationEnd()
+
+    // Helpers
+    fun tryGetActivity(): Activity?
+    fun tryGetContext(): ReactContext?
+}

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

@@ -0,0 +1,336 @@
+package com.swmansion.rnscreens
+
+import android.content.Context
+import android.graphics.Canvas
+import android.view.View
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.rnscreens.Screen.StackAnimation
+import com.swmansion.rnscreens.events.StackFinishTransitioningEvent
+import java.util.Collections
+import kotlin.collections.ArrayList
+import kotlin.collections.HashSet
+
+class ScreenStack(context: Context?) : ScreenContainer(context) {
+    private val mStack = ArrayList<ScreenStackFragmentWrapper>()
+    private val mDismissed: MutableSet<ScreenStackFragmentWrapper> = HashSet()
+    private val drawingOpPool: MutableList<DrawingOp> = ArrayList()
+    private var drawingOps: MutableList<DrawingOp> = ArrayList()
+    private var mTopScreen: ScreenStackFragmentWrapper? = null
+    private var mRemovalTransitionStarted = false
+    private var isDetachingCurrentScreen = false
+    private var reverseLastTwoChildren = false
+    private var previousChildrenCount = 0
+    var goingForward = false
+
+    fun dismiss(screenFragment: ScreenStackFragmentWrapper) {
+        mDismissed.add(screenFragment)
+        performUpdatesNow()
+    }
+
+    override val topScreen: Screen?
+        get() = mTopScreen?.screen
+
+    val rootScreen: Screen
+        get() {
+            for (i in 0 until screenCount) {
+                val screenWrapper = getScreenFragmentWrapperAt(i)
+                if (!mDismissed.contains(screenWrapper)) {
+                    return screenWrapper.screen
+                }
+            }
+            throw IllegalStateException("Stack has no root screen set")
+        }
+
+    override fun adapt(screen: Screen) = ScreenStackFragment(screen)
+
+    override fun startViewTransition(view: View) {
+        super.startViewTransition(view)
+        mRemovalTransitionStarted = true
+    }
+
+    override fun endViewTransition(view: View) {
+        super.endViewTransition(view)
+        if (mRemovalTransitionStarted) {
+            mRemovalTransitionStarted = false
+            dispatchOnFinishTransitioning()
+        }
+    }
+
+    fun onViewAppearTransitionEnd() {
+        if (!mRemovalTransitionStarted) {
+            dispatchOnFinishTransitioning()
+        }
+    }
+
+    private fun dispatchOnFinishTransitioning() {
+        val surfaceId = UIManagerHelper.getSurfaceId(this)
+        UIManagerHelper
+            .getEventDispatcherForReactTag((context as ReactContext), id)
+            ?.dispatchEvent(StackFinishTransitioningEvent(surfaceId, id))
+    }
+
+    override fun removeScreenAt(index: Int) {
+        mDismissed.remove(getScreenFragmentWrapperAt(index))
+        super.removeScreenAt(index)
+    }
+
+    override fun removeAllScreens() {
+        mDismissed.clear()
+        super.removeAllScreens()
+    }
+
+    override fun hasScreen(screenFragmentWrapper: ScreenFragmentWrapper?): Boolean =
+        super.hasScreen(screenFragmentWrapper) && !mDismissed.contains(screenFragmentWrapper)
+
+    override fun onUpdate() {
+        // When going back from a nested stack with a single screen on it, we may hit an edge case
+        // when all screens are dismissed and no screen is to be displayed on top. We need to gracefully
+        // handle the case of newTop being NULL, which happens in several places below
+        var newTop: ScreenFragmentWrapper? = null // newTop is nullable, see the above comment ^
+        var visibleBottom: ScreenFragmentWrapper? = null // this is only set if newTop has TRANSPARENT_MODAL presentation mode
+        isDetachingCurrentScreen = false // we reset it so the previous value is not used by mistake
+        for (i in mScreenFragments.indices.reversed()) {
+            val screen = getScreenFragmentWrapperAt(i)
+            if (!mDismissed.contains(screen)) {
+                if (newTop == null) {
+                    newTop = screen
+                } else {
+                    visibleBottom = screen
+                }
+                if (!isTransparent(screen)) {
+                    break
+                }
+            }
+        }
+        var shouldUseOpenAnimation = true
+        var stackAnimation: StackAnimation? = null
+        if (!mStack.contains(newTop)) {
+            // if new top screen wasn't on stack we do "open animation" so long it is not the very first
+            // screen on stack
+            if (mTopScreen != null && newTop != null) {
+                // there was some other screen attached before
+                // if the previous top screen does not exist anymore and the new top was not on the stack
+                // before, probably replace or reset was called, so we play the "close animation".
+                // Otherwise it's open animation
+                val containsTopScreen = mTopScreen?.let { mScreenFragments.contains(it) } == true
+                val isPushReplace = newTop.screen.replaceAnimation === Screen.ReplaceAnimation.PUSH
+                shouldUseOpenAnimation = containsTopScreen || isPushReplace
+                // if the replace animation is `push`, the new top screen provides the animation, otherwise the previous one
+                stackAnimation = if (shouldUseOpenAnimation) newTop.screen.stackAnimation else mTopScreen?.screen?.stackAnimation
+            } else if (mTopScreen == null && newTop != null) {
+                // mTopScreen was not present before so newTop is the first screen added to a stack
+                // and we don't want the animation when it is entering
+                stackAnimation = StackAnimation.NONE
+                goingForward = true
+            }
+        } else if (mTopScreen != null && mTopScreen != newTop) {
+            // otherwise if we are performing top screen change we do "close animation"
+            shouldUseOpenAnimation = false
+            stackAnimation = mTopScreen?.screen?.stackAnimation
+        }
+
+        createTransaction().let {
+            // animation logic start
+            if (stackAnimation != null) {
+                if (shouldUseOpenAnimation) {
+                    when (stackAnimation) {
+                        StackAnimation.DEFAULT -> it.setCustomAnimations(R.anim.rns_default_enter_in, R.anim.rns_default_enter_out)
+                        StackAnimation.NONE -> it.setCustomAnimations(R.anim.rns_no_animation_20, R.anim.rns_no_animation_20)
+                        StackAnimation.FADE -> it.setCustomAnimations(R.anim.rns_fade_in, R.anim.rns_fade_out)
+                        StackAnimation.SLIDE_FROM_RIGHT -> it.setCustomAnimations(R.anim.rns_slide_in_from_right, R.anim.rns_slide_out_to_left)
+                        StackAnimation.SLIDE_FROM_LEFT -> it.setCustomAnimations(R.anim.rns_slide_in_from_left, R.anim.rns_slide_out_to_right)
+                        StackAnimation.SLIDE_FROM_BOTTOM -> it.setCustomAnimations(
+                            R.anim.rns_slide_in_from_bottom, R.anim.rns_no_animation_medium
+                        )
+                        StackAnimation.FADE_FROM_BOTTOM -> it.setCustomAnimations(R.anim.rns_fade_from_bottom, R.anim.rns_no_animation_350)
+                    }
+                } else {
+                    when (stackAnimation) {
+                        StackAnimation.DEFAULT -> it.setCustomAnimations(R.anim.rns_default_exit_in, R.anim.rns_default_exit_out)
+                        StackAnimation.NONE -> it.setCustomAnimations(R.anim.rns_no_animation_20, R.anim.rns_no_animation_20)
+                        StackAnimation.FADE -> it.setCustomAnimations(R.anim.rns_fade_in, R.anim.rns_fade_out)
+                        StackAnimation.SLIDE_FROM_RIGHT -> it.setCustomAnimations(R.anim.rns_slide_in_from_left, R.anim.rns_slide_out_to_right)
+                        StackAnimation.SLIDE_FROM_LEFT -> it.setCustomAnimations(R.anim.rns_slide_in_from_right, R.anim.rns_slide_out_to_left)
+                        StackAnimation.SLIDE_FROM_BOTTOM -> it.setCustomAnimations(
+                            R.anim.rns_no_animation_medium, R.anim.rns_slide_out_to_bottom
+                        )
+                        StackAnimation.FADE_FROM_BOTTOM -> it.setCustomAnimations(R.anim.rns_no_animation_250, R.anim.rns_fade_to_bottom)
+                    }
+                }
+            }
+
+            // animation logic end
+            goingForward = shouldUseOpenAnimation
+
+            if (shouldUseOpenAnimation &&
+                newTop != null && needsDrawReordering(newTop) &&
+                visibleBottom == null
+            ) {
+                // When using an open animation in which two screens overlap (eg. fade_from_bottom or
+                // slide_from_bottom), we want to draw the previous screen under the new one,
+                // which is apparently not the default option. Android always draws the disappearing view
+                // on top of the appearing one. We then reverse the order of the views so the new screen
+                // appears on top of the previous one. You can read more about in the comment
+                // for the code we use to change that behavior:
+                // https://github.com/airbnb/native-navigation/blob/9cf50bf9b751b40778f473f3b19fcfe2c4d40599/lib/android/src/main/java/com/airbnb/android/react/navigation/ScreenCoordinatorLayout.java#L18
+                isDetachingCurrentScreen = true
+            }
+
+            // remove all screens previously on stack
+            for (fragmentWrapper in mStack) {
+                if (!mScreenFragments.contains(fragmentWrapper) || mDismissed.contains(fragmentWrapper)) {
+                    it.remove(fragmentWrapper.fragment)
+                }
+            }
+            for (fragmentWrapper in mScreenFragments) {
+                // Stop detaching screens when reaching visible bottom. All screens above bottom should be
+                // visible.
+                if (fragmentWrapper === visibleBottom) {
+                    break
+                }
+                // detach all screens that should not be visible
+                if (fragmentWrapper !== newTop && !mDismissed.contains(fragmentWrapper)) {
+                    it.remove(fragmentWrapper.fragment)
+                }
+            }
+
+            // attach screens that just became visible
+            if (visibleBottom != null && !visibleBottom.fragment.isAdded) {
+                val top = newTop
+                var beneathVisibleBottom = true
+                for (fragmentWrapper in mScreenFragments) {
+                    // ignore all screens beneath the visible bottom
+                    if (beneathVisibleBottom) {
+                        beneathVisibleBottom = if (fragmentWrapper === visibleBottom) {
+                            false
+                        } else continue
+                    }
+                    // when first visible screen found, make all screens after that visible
+                    it.add(id, fragmentWrapper.fragment).runOnCommit { top?.screen?.bringToFront() }
+                }
+            } else if (newTop != null && !newTop.fragment.isAdded) {
+                it.add(id, newTop.fragment)
+            }
+            mTopScreen = newTop as? ScreenStackFragmentWrapper
+            mStack.clear()
+            mStack.addAll(mScreenFragments.map { it as ScreenStackFragmentWrapper })
+
+            turnOffA11yUnderTransparentScreen(visibleBottom)
+
+            it.commitNowAllowingStateLoss()
+        }
+    }
+
+    // only top visible screen should be accessible
+    private fun turnOffA11yUnderTransparentScreen(visibleBottom: ScreenFragmentWrapper?) {
+        if (mScreenFragments.size > 1 && visibleBottom != null) {
+            mTopScreen?.let {
+                if (isTransparent(it)) {
+                    val screenFragmentsBeneathTop = mScreenFragments.slice(0 until mScreenFragments.size - 1).asReversed()
+                    // go from the top of the stack excluding the top screen
+                    for (fragmentWrapper in screenFragmentsBeneathTop) {
+                        fragmentWrapper.screen.changeAccessibilityMode(IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS)
+
+                        // don't change a11y below non-transparent screens
+                        if (fragmentWrapper == visibleBottom) {
+                            break
+                        }
+                    }
+                }
+            }
+        }
+
+        topScreen?.changeAccessibilityMode(IMPORTANT_FOR_ACCESSIBILITY_AUTO)
+    }
+
+    override fun notifyContainerUpdate() {
+        mStack.forEach { it.onContainerUpdate() }
+    }
+
+    // below methods are taken from
+    // https://github.com/airbnb/native-navigation/blob/9cf50bf9b751b40778f473f3b19fcfe2c4d40599/lib/android/src/main/java/com/airbnb/android/react/navigation/ScreenCoordinatorLayout.java#L43
+    // and are used to swap the order of drawing views when navigating forward with the transitions
+    // that are making transitioning fragments appear one on another. See more info in the comment to
+    // the linked class.
+    override fun removeView(view: View) {
+        // we set this property to reverse the order of drawing views
+        // when we want to push new fragment on top of the previous one and their animations collide.
+        // More information in:
+        // https://github.com/airbnb/native-navigation/blob/9cf50bf9b751b40778f473f3b19fcfe2c4d40599/lib/android/src/main/java/com/airbnb/android/react/navigation/ScreenCoordinatorLayout.java#L17
+        if (isDetachingCurrentScreen) {
+            isDetachingCurrentScreen = false
+            reverseLastTwoChildren = true
+        }
+        super.removeView(view)
+    }
+
+    private fun drawAndRelease() {
+        // We make a copy of the drawingOps and use it to dispatch draws in order to be sure
+        // that we do not modify the original list. There are cases when `op.draw` can call
+        // `drawChild` which would modify the list through which we are iterating. See more:
+        // https://github.com/software-mansion/react-native-screens/pull/1406
+        val drawingOpsCopy = drawingOps
+        drawingOps = ArrayList()
+        for (op in drawingOpsCopy) {
+            op.draw()
+            drawingOpPool.add(op)
+        }
+    }
+
+    override fun dispatchDraw(canvas: Canvas) {
+        super.dispatchDraw(canvas)
+
+        // check the view removal is completed (by comparing the previous children count)
+        if (drawingOps.size < previousChildrenCount) {
+            reverseLastTwoChildren = false
+        }
+        previousChildrenCount = drawingOps.size
+        if (reverseLastTwoChildren && drawingOps.size >= 2) {
+            Collections.swap(drawingOps, drawingOps.size - 1, drawingOps.size - 2)
+        }
+        drawAndRelease()
+    }
+
+    override fun drawChild(canvas: Canvas, child: View, drawingTime: Long): Boolean {
+        drawingOps.add(
+            obtainDrawingOp().apply {
+                this.canvas = canvas
+                this.child = child
+                this.drawingTime = drawingTime
+            }
+        )
+        return true
+    }
+
+    private fun performDraw(op: DrawingOp) {
+        // Canvas parameter can not be null here https://developer.android.com/reference/android/view/ViewGroup#drawChild(android.graphics.Canvas,%20android.view.View,%20long)
+        // So if we are passing null here, we would crash anyway
+        super.drawChild(op.canvas!!, op.child, op.drawingTime)
+    }
+
+    private fun obtainDrawingOp(): DrawingOp =
+        if (drawingOpPool.isEmpty()) DrawingOp() else drawingOpPool.removeLast()
+
+    private inner class DrawingOp {
+        var canvas: Canvas? = null
+        var child: View? = null
+        var drawingTime: Long = 0
+
+        fun draw() {
+            performDraw(this)
+            canvas = null
+            child = null
+            drawingTime = 0
+        }
+    }
+
+    companion object {
+        private fun isTransparent(fragmentWrapper: ScreenFragmentWrapper): Boolean =
+            fragmentWrapper.screen.stackPresentation === Screen.StackPresentation.TRANSPARENT_MODAL
+
+        private fun needsDrawReordering(fragmentWrapper: ScreenFragmentWrapper): Boolean =
+            fragmentWrapper.screen.stackAnimation === StackAnimation.SLIDE_FROM_BOTTOM ||
+                fragmentWrapper.screen.stackAnimation === StackAnimation.FADE_FROM_BOTTOM
+    }
+}