@amazon-devices/react-native-screens 2.0.1759135970 → 3.0.9000000000

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

@@ -0,0 +1,299 @@
+package com.swmansion.rnscreens
+
+import android.annotation.SuppressLint
+import android.view.View
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsAnimationCompat
+import androidx.core.view.WindowInsetsCompat
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.views.view.ReactViewGroup
+import com.google.android.material.bottomsheet.BottomSheetBehavior
+import com.google.android.material.bottomsheet.BottomSheetBehavior.BottomSheetCallback
+import com.google.android.material.bottomsheet.BottomSheetBehavior.STATE_COLLAPSED
+import com.google.android.material.bottomsheet.BottomSheetBehavior.STATE_EXPANDED
+import com.google.android.material.bottomsheet.BottomSheetBehavior.STATE_HALF_EXPANDED
+import com.google.android.material.bottomsheet.BottomSheetBehavior.STATE_HIDDEN
+import com.google.android.material.math.MathUtils
+import com.swmansion.rnscreens.bottomsheet.SheetUtils
+import kotlin.math.max
+
+@SuppressLint("ViewConstructor")
+class ScreenFooter(
+    val reactContext: ReactContext,
+) : ReactViewGroup(reactContext) {
+    private var lastContainerHeight: Int = 0
+    private var lastStableSheetState: Int = STATE_HIDDEN
+    private var isAnimationControlledByKeyboard = false
+    private var lastSlideOffset = 0.0f
+    private var lastBottomInset = 0
+    private var isCallbackRegistered = false
+
+    // ScreenFooter is supposed to be direct child of Screen
+    private val screenParent
+        get() = parent as? Screen
+
+    private val sheetBehavior
+        get() = requireScreenParent().sheetBehavior
+
+    private val hasReceivedInitialLayoutFromParent get() = lastContainerHeight > 0
+
+    // Due to Android restrictions on layout flow, particularly
+    // the fact that onMeasure must set `measuredHeight` & `measuredWidth` React calls `measure` on every
+    // view group with accurate dimensions computed by Yoga. This is our entry point to get current view dimensions.
+    private val reactHeight
+        get() = measuredHeight
+
+    private val reactWidth
+        get() = measuredWidth
+
+    // Main goal of this callback implementation is to handle keyboard appearance. We use it to make sure
+    // that the footer respects keyboard during layout.
+    // Note `DISPATCH_MODE_STOP` is used here to avoid propagation of insets callback to footer subtree.
+    private val insetsAnimation =
+        object : WindowInsetsAnimationCompat.Callback(DISPATCH_MODE_STOP) {
+            override fun onStart(
+                animation: WindowInsetsAnimationCompat,
+                bounds: WindowInsetsAnimationCompat.BoundsCompat,
+            ): WindowInsetsAnimationCompat.BoundsCompat {
+                isAnimationControlledByKeyboard = true
+                return super.onStart(animation, bounds)
+            }
+
+            override fun onProgress(
+                insets: WindowInsetsCompat,
+                runningAnimations: MutableList<WindowInsetsAnimationCompat>,
+            ): WindowInsetsCompat {
+                val imeBottomInset = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom
+                val navigationBarBottomInset =
+                    insets.getInsets(WindowInsetsCompat.Type.navigationBars()).bottom
+
+                // **It looks like** when keyboard is presented its inset does include navigation bar
+                // bottom inset, while it is already accounted for somewhere (dunno where).
+                // That is why we subtract navigation bar bottom inset here.
+                //
+                // Situations where keyboard is not visible and navigation bar is present are handled
+                // directly in layout function by not allowing lastBottomInset to contribute value less
+                // than 0. Alternative would be write logic specific to keyboard animation direction (hide / show).
+                lastBottomInset = imeBottomInset - navigationBarBottomInset
+                layoutFooterOnYAxis(
+                    lastContainerHeight,
+                    reactHeight,
+                    sheetTopWhileDragging(lastSlideOffset),
+                    lastBottomInset,
+                )
+
+                // Please note that we do *not* consume any insets here, so that we do not interfere with
+                // any other view.
+                return insets
+            }
+
+            override fun onEnd(animation: WindowInsetsAnimationCompat) {
+                isAnimationControlledByKeyboard = false
+            }
+        }
+
+    init {
+        val rootView =
+            checkNotNull(reactContext.currentActivity) {
+                "[RNScreens] Context detached from activity while creating ScreenFooter"
+            }.window.decorView
+
+        // Note that we do override insets animation on given view. I can see it interfering e.g.
+        // with reanimated keyboard or even other places in our code. Need to test this.
+        ViewCompat.setWindowInsetsAnimationCallback(rootView, insetsAnimation)
+    }
+
+    private fun requireScreenParent(): Screen = requireNotNull(screenParent)
+
+    private fun requireSheetBehavior(): BottomSheetBehavior<Screen> = requireNotNull(sheetBehavior)
+
+    // React calls `layout` function to set view dimensions, thus this is our entry point for
+    // fixing layout up after Yoga repositions it.
+    override fun onLayout(
+        changed: Boolean,
+        left: Int,
+        top: Int,
+        right: Int,
+        bottom: Int,
+    ) {
+        super.onLayout(changed, left, top, right, bottom)
+        if (!hasReceivedInitialLayoutFromParent) {
+            return
+        }
+        layoutFooterOnYAxis(
+            lastContainerHeight,
+            bottom - top,
+            sheetTopInStableState(requireSheetBehavior().state),
+            lastBottomInset,
+        )
+    }
+
+    private var footerCallback =
+        object : BottomSheetCallback() {
+            override fun onStateChanged(
+                bottomSheet: View,
+                newState: Int,
+            ) {
+                if (!SheetUtils.isStateStable(newState)) {
+                    return
+                }
+
+                when (newState) {
+                    STATE_COLLAPSED,
+                    STATE_HALF_EXPANDED,
+                    STATE_EXPANDED,
+                    ->
+                        layoutFooterOnYAxis(
+                            lastContainerHeight,
+                            reactHeight,
+                            sheetTopInStableState(newState),
+                            lastBottomInset,
+                        )
+
+                    else -> {}
+                }
+                lastStableSheetState = newState
+            }
+
+            override fun onSlide(
+                bottomSheet: View,
+                slideOffset: Float,
+            ) {
+                lastSlideOffset = max(slideOffset, 0.0f)
+                if (!isAnimationControlledByKeyboard) {
+                    layoutFooterOnYAxis(
+                        lastContainerHeight,
+                        reactHeight,
+                        sheetTopWhileDragging(lastSlideOffset),
+                        lastBottomInset,
+                    )
+                }
+            }
+        }
+
+    // Important to keep this method idempotent! We attempt to (un)register
+    // our callback in different places depending on whether the behavior is already created.
+    fun registerWithSheetBehavior(behavior: BottomSheetBehavior<Screen>) {
+        if (!isCallbackRegistered) {
+            behavior.addBottomSheetCallback(footerCallback)
+            isCallbackRegistered = true
+        }
+    }
+
+    // Important to keep this method idempotent! We attempt to (un)register
+    // our callback in different places depending on whether the behavior is already created.
+    fun unregisterWithSheetBehavior(behavior: BottomSheetBehavior<Screen>) {
+        if (isCallbackRegistered) {
+            behavior.removeBottomSheetCallback(footerCallback)
+            isCallbackRegistered = false
+        }
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        sheetBehavior?.let { registerWithSheetBehavior(it) }
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        sheetBehavior?.let { unregisterWithSheetBehavior(it) }
+    }
+
+    /**
+     * Calculate position of sheet's top while it is in stable state given concrete sheet state.
+     *
+     * This method should not be used for sheet in unstable state.
+     *
+     * @param state sheet state as defined in [BottomSheetBehavior]
+     * @return position of sheet's top **relative to container**
+     */
+    private fun sheetTopInStableState(state: Int): Int {
+        val behavior = requireSheetBehavior()
+        return when (state) {
+            STATE_COLLAPSED -> lastContainerHeight - behavior.peekHeight
+            STATE_HALF_EXPANDED -> (lastContainerHeight * (1 - behavior.halfExpandedRatio)).toInt()
+            STATE_EXPANDED -> behavior.expandedOffset
+            STATE_HIDDEN -> lastContainerHeight
+            else -> throw IllegalArgumentException("[RNScreens] use of stable-state method for unstable state")
+        }
+    }
+
+    /**
+     * Calculate position of sheet's top while it is in dragging / settling state given concrete slide offset
+     * as reported by [BottomSheetCallback.onSlide].
+     *
+     * This method should not be used for sheet in stable state.
+     *
+     * Currently the implementation assumes that the Screen's (sheet's) container starts at y: 0
+     * in global coordinates. Then we can use simply sheet's top. If that is for some reason
+     * unavailable, then we fallback to interpolation basing on values provided by sheet behaviour.
+     *
+     * We don't want to primarily rely on interpolation, because due to division rounding errors the footer
+     * will "flicker" (jump up / down a single pixel).
+     *
+     * @param slideOffset sheet offset as reported by [BottomSheetCallback.onSlide]
+     * @return position of sheet's top **relative to container**
+     */
+    private fun sheetTopWhileDragging(slideOffset: Float): Int =
+        screenParent?.top ?: MathUtils
+            .lerp(
+                sheetTopInStableState(STATE_COLLAPSED).toFloat(),
+                sheetTopInStableState(
+                    STATE_EXPANDED,
+                ).toFloat(),
+                slideOffset,
+            ).toInt()
+
+    /**
+     * Parent Screen will call this on it's layout. We need to be notified on any update to Screen's content
+     * or its container dimensions change. This is also our entrypoint to acquiring container height.
+     */
+    fun onParentLayout(
+        changed: Boolean,
+        left: Int,
+        top: Int,
+        right: Int,
+        bottom: Int,
+        containerHeight: Int,
+    ) {
+        lastContainerHeight = containerHeight
+        layoutFooterOnYAxis(
+            containerHeight,
+            reactHeight,
+            sheetTopInStableState(requireSheetBehavior().state),
+        )
+    }
+
+    /**
+     * Layouts this component within parent screen. It takes care only of vertical axis, leaving
+     * horizontal axis solely for React to handle.
+     *
+     * This is a bit against Android rules, that parents should layout their children,
+     * however I wanted to keep this logic away from Screen component to avoid introducing
+     * complexity there and have footer logic as much separated as it is possible.
+     *
+     * Please note that React has no clue about updates enforced in below method.
+     *
+     * @param containerHeight this should be the height of the screen (sheet) container used
+     * to calculate sheet properties when configuring behavior (pixels)
+     * @param footerHeight summarized height of this component children (pixels)
+     * @param sheetTop current bottom sheet top (Screen top) **relative to container** (pixels)
+     * @param bottomInset current bottom inset, used to offset the footer by keyboard height (pixels)
+     */
+    fun layoutFooterOnYAxis(
+        containerHeight: Int,
+        footerHeight: Int,
+        sheetTop: Int,
+        bottomInset: Int = 0,
+    ) {
+        // max(bottomInset, 0) is just a hack to avoid double offset of navigation bar.
+        val newTop = containerHeight - footerHeight - sheetTop - max(bottomInset, 0)
+        val heightBeforeUpdate = reactHeight
+        this.top = max(newTop, 0)
+        this.bottom = this.top + heightBeforeUpdate
+    }
+
+    companion object {
+        const val TAG = "ScreenFooter"
+    }
+}

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

@@ -0,0 +1,25 @@
+package com.swmansion.rnscreens
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.RNSScreenFooterManagerDelegate
+import com.facebook.react.viewmanagers.RNSScreenFooterManagerInterface
+
+@ReactModule(name = ScreenFooterManager.REACT_CLASS)
+class ScreenFooterManager :
+    ViewGroupManager<ScreenFooter>(),
+    RNSScreenFooterManagerInterface<ScreenFooter> {
+    private val delegate: ViewManagerDelegate<ScreenFooter> = RNSScreenFooterManagerDelegate(this)
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext) = ScreenFooter(context)
+
+    override fun getDelegate(): ViewManagerDelegate<ScreenFooter> = delegate
+
+    companion object {
+        const val REACT_CLASS = "RNSScreenFooter"
+    }
+}

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

@@ -15,6 +15,7 @@ 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.bottomsheet.DimmingFragment
 import com.swmansion.rnscreens.events.HeaderBackButtonClickedEvent
 import com.swmansion.rnscreens.events.ScreenAppearEvent
 import com.swmansion.rnscreens.events.ScreenDisappearEvent
@@ -22,12 +23,18 @@ 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 com.swmansion.rnscreens.ext.recycle
 import kotlin.math.max
 import kotlin.math.min
 
-open class ScreenFragment : Fragment, ScreenFragmentWrapper {
+open class ScreenFragment :
+    Fragment,
+    ScreenFragmentWrapper {
     enum class ScreenLifecycleEvent {
-        Appear, WillAppear, Disappear, WillDisappear
+        DID_APPEAR,
+        WILL_APPEAR,
+        DID_DISAPPEAR,
+        WILL_DISAPPEAR,
     }
 
     override val fragment: Fragment
@@ -36,11 +43,14 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
     // 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()
+
+    override val childScreenContainers: 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
+    private var transitionProgress = -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.
@@ -55,7 +65,7 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
 
     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."
+            "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.",
         )
     }
 
@@ -75,14 +85,17 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
     override fun onCreateView(
         inflater: LayoutInflater,
         container: ViewGroup?,
-        savedInstanceState: Bundle?
+        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))
-        }
+        screen.layoutParams =
+            FrameLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT,
+            )
+        val wrapper =
+            context?.let { ScreensFrameLayout(it) }?.apply {
+                addView(screen.recycle())
+            }
         return wrapper
     }
 
@@ -152,57 +165,59 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
         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 canDispatchLifecycleEvent(event: ScreenLifecycleEvent): Boolean =
+        when (event) {
+            ScreenLifecycleEvent.WILL_APPEAR -> canDispatchWillAppear
+            ScreenLifecycleEvent.DID_APPEAR -> canDispatchAppear
+            ScreenLifecycleEvent.WILL_DISAPPEAR -> !canDispatchWillAppear
+            ScreenLifecycleEvent.DID_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
+            ScreenLifecycleEvent.WILL_APPEAR -> canDispatchWillAppear = false
+            ScreenLifecycleEvent.DID_APPEAR -> canDispatchAppear = false
+            ScreenLifecycleEvent.WILL_DISAPPEAR -> canDispatchWillAppear = true
+            ScreenLifecycleEvent.DID_DISAPPEAR -> canDispatchAppear = true
         }
     }
 
     private fun dispatchOnWillAppear() {
-        dispatchLifecycleEvent(ScreenLifecycleEvent.WillAppear, this)
+        dispatchLifecycleEvent(ScreenLifecycleEvent.WILL_APPEAR, this)
         dispatchTransitionProgressEvent(0.0f, false)
     }
 
     private fun dispatchOnAppear() {
-        dispatchLifecycleEvent(ScreenLifecycleEvent.Appear, this)
+        dispatchLifecycleEvent(ScreenLifecycleEvent.DID_APPEAR, this)
         dispatchTransitionProgressEvent(1.0f, false)
     }
 
     private fun dispatchOnWillDisappear() {
-        dispatchLifecycleEvent(ScreenLifecycleEvent.WillDisappear, this)
+        dispatchLifecycleEvent(ScreenLifecycleEvent.WILL_DISAPPEAR, this)
         dispatchTransitionProgressEvent(0.0f, true)
     }
 
     private fun dispatchOnDisappear() {
-        dispatchLifecycleEvent(ScreenLifecycleEvent.Disappear, this)
+        dispatchLifecycleEvent(ScreenLifecycleEvent.DID_DISAPPEAR, this)
         dispatchTransitionProgressEvent(1.0f, true)
     }
 
-    override fun dispatchLifecycleEvent(event: ScreenLifecycleEvent, fragmentWrapper: ScreenFragmentWrapper) {
+    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 lifecycleEvent: Event<*> =
+                    when (event) {
+                        ScreenLifecycleEvent.WILL_APPEAR -> ScreenWillAppearEvent(surfaceId, it.id)
+                        ScreenLifecycleEvent.DID_APPEAR -> ScreenAppearEvent(surfaceId, it.id)
+                        ScreenLifecycleEvent.WILL_DISAPPEAR -> ScreenWillDisappearEvent(surfaceId, it.id)
+                        ScreenLifecycleEvent.DID_DISAPPEAR -> ScreenDisappearEvent(surfaceId, it.id)
+                    }
                 val screenContext = screen.context as ReactContext
                 val eventDispatcher: EventDispatcher? =
                     UIManagerHelper.getEventDispatcherForReactTag(screenContext, screen.id)
@@ -213,7 +228,7 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
     }
 
     override fun dispatchLifecycleEventInChildContainers(event: ScreenLifecycleEvent) {
-        mChildScreenContainers.filter { it.screenCount > 0 }.forEach {
+        childScreenContainers.filter { it.screenCount > 0 }.forEach {
             it.topScreen?.fragmentWrapper?.let { fragment -> dispatchLifecycleEvent(event, fragment) }
         }
     }
@@ -226,16 +241,14 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
             ?.dispatchEvent(HeaderBackButtonClickedEvent(surfaceId, screen.id))
     }
 
-    override fun dispatchTransitionProgressEvent(alpha: Float, closing: Boolean) {
+    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()
+            if (transitionProgress != alpha) {
+                transitionProgress = max(0.0f, min(1.0f, alpha))
+                val coalescingKey = getCoalescingKey(transitionProgress)
                 val container: ScreenContainer? = screen.container
                 val goingForward = if (container is ScreenStack) container.goingForward else false
                 val screenContext = screen.context as ReactContext
@@ -244,19 +257,23 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
                     ?.dispatchEvent(
                         ScreenTransitionProgressEvent(
                             UIManagerHelper.getSurfaceId(screenContext),
-                            screen.id, mProgress, closing, goingForward, coalescingKey
-                        )
+                            screen.id,
+                            transitionProgress,
+                            closing,
+                            goingForward,
+                            coalescingKey,
+                        ),
                     )
             }
         }
     }
 
     override fun addChildScreenContainer(container: ScreenContainer) {
-        mChildScreenContainers.add(container)
+        childScreenContainers.add(container)
     }
 
     override fun removeChildScreenContainer(container: ScreenContainer) {
-        mChildScreenContainers.remove(container)
+        childScreenContainers.remove(container)
     }
 
     override fun onViewAnimationStart() {
@@ -273,7 +290,12 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
         // 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
+        val parent =
+            if (parentFragment is DimmingFragment) {
+                parentFragment?.parentFragment
+            } else {
+                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
@@ -297,7 +319,7 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
     override fun onDestroy() {
         super.onDestroy()
         val container = screen.container
-        if (container == null || !container.hasScreen(this)) {
+        if (container == null || !container.hasScreen(this.screen.fragmentWrapper)) {
             // we only send dismissed even when the screen has been removed from its container
             val screenContext = screen.context
             if (screenContext is ReactContext) {
@@ -307,25 +329,27 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
                     ?.dispatchEvent(ScreenDismissedEvent(surfaceId, screen.id))
             }
         }
-        mChildScreenContainers.clear()
+        childScreenContainers.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)
-            }
+        const val TAG = "ScreenFragment"
 
-            // 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
+        fun getCoalescingKey(progress: Float): Short {
+            /* 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
+             */
+            return (
+                if (progress == 0.0f) {
+                    1
+                } else if (progress == 1.0f) {
+                    2
+                } else {
+                    3
+                }
+            ).toShort()
         }
     }
 }

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

@@ -3,20 +3,31 @@ package com.swmansion.rnscreens
 import android.app.Activity
 import com.facebook.react.bridge.ReactContext
 
-interface ScreenFragmentWrapper : FragmentHolder, ScreenEventDispatcher {
+interface ScreenFragmentWrapper :
+    FragmentHolder,
+    ScreenEventDispatcher {
     var screen: Screen
 
     // Communication with container
     val childScreenContainers: List<ScreenContainer>
+
     fun addChildScreenContainer(container: ScreenContainer)
+
     fun removeChildScreenContainer(container: ScreenContainer)
+
+    /**
+     * Container that this fragment belongs to calls it to notify the fragment,
+     * that the container has updated.
+     */
     fun onContainerUpdate()
 
     // Animation phase callbacks
     fun onViewAnimationStart()
+
     fun onViewAnimationEnd()
 
     // Helpers
     fun tryGetActivity(): Activity?
+
     fun tryGetContext(): ReactContext?
 }