react-native-screens 4.11.0-beta.0 → 4.11.0-beta.2

package/RNScreens.podspec

@@ -4,6 +4,8 @@ package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
 new_arch_enabled = ENV['RCT_NEW_ARCH_ENABLED'] == '1'
 min_supported_ios_version = new_arch_enabled ? "15.1" : "15.1"
+min_supported_tvos_version = "15.1"
+min_supported_visionos_version = "1.0"
 source_files = new_arch_enabled ? 'ios/**/*.{h,m,mm,cpp}' : ["ios/**/*.{h,m,mm}", "cpp/RNScreensTurboModule.cpp", "cpp/RNScreensTurboModule.h"]
 
 Pod::Spec.new do |s|
@@ -16,7 +18,7 @@ Pod::Spec.new do |s|
   s.homepage     = "https://github.com/software-mansion/react-native-screens"
   s.license      = "MIT"
   s.author       = { "author" => "author@domain.cn" }
-  s.platforms    = { :ios => min_supported_ios_version, :tvos => "11.0", :visionos => "1.0" }
+  s.platforms    = { :ios => min_supported_ios_version, :tvos => min_supported_tvos_version, :visionos => min_supported_visionos_version }
   s.source       = { :git => "https://github.com/software-mansion/react-native-screens.git", :tag => "#{s.version}" }
   s.source_files = source_files
   s.project_header_files = "cpp/**/*.h" # Don't expose C++ headers publicly to allow importing framework into Swift files

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

@@ -32,7 +32,6 @@ import com.swmansion.rnscreens.bottomsheet.usesFormSheetPresentation
 import com.swmansion.rnscreens.events.HeaderHeightChangeEvent
 import com.swmansion.rnscreens.events.SheetDetentChangedEvent
 import com.swmansion.rnscreens.ext.parentAsViewGroup
-import java.lang.ref.WeakReference
 
 @SuppressLint("ViewConstructor") // Only we construct this view, it is never inflated.
 class Screen(
@@ -42,8 +41,6 @@ class Screen(
     val fragment: Fragment?
         get() = fragmentWrapper?.fragment
 
-    var contentWrapper = WeakReference<ScreenContentWrapper>(null)
-
     val sheetBehavior: BottomSheetBehavior<Screen>?
         get() = (layoutParams as? CoordinatorLayout.LayoutParams)?.behavior as? BottomSheetBehavior<Screen>
 
@@ -135,8 +132,10 @@ class Screen(
     ) {
         val height = bottom - top
 
-        if (isSheetFitToContents()) {
-            sheetBehavior?.useSingleDetent(height)
+        if (usesFormSheetPresentation()) {
+            if (isSheetFitToContents()) {
+                sheetBehavior?.useSingleDetent(height)
+            }
 
             if (!BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
                 // On old architecture we delay enter transition in order to wait for initial frame.
@@ -153,7 +152,6 @@ class Screen(
 
     fun registerLayoutCallbackForWrapper(wrapper: ScreenContentWrapper) {
         wrapper.delegate = this
-        this.contentWrapper = WeakReference(wrapper)
     }
 
     override fun dispatchSaveInstanceState(container: SparseArray<Parcelable>) {
@@ -187,22 +185,27 @@ class Screen(
     }
 
     internal fun onBottomSheetBehaviorDidLayout(coordinatorLayoutDidChange: Boolean) {
-        if (!usesFormSheetPresentation()) {
+        if (!usesFormSheetPresentation() || !isNativeStackScreen) {
             return
         }
-        if (coordinatorLayoutDidChange && isNativeStackScreen) {
+        if (coordinatorLayoutDidChange) {
             dispatchShadowStateUpdate(width, height, top)
         }
-        if (!BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
-            maybeTriggerPostponedTransition()
-        }
 
         footer?.onParentLayout(coordinatorLayoutDidChange, left, top, right, bottom, container!!.height)
+
+        if (!BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+            // When using form sheet presentation we want to delay enter transition **on Paper** in order
+            // to wait for initial layout from React, otherwise the animator-based animation will look
+            // glitchy. *This seems to not be needed on Fabric*.
+            triggerPostponedEnterTransitionIfNeeded()
+        }
     }
 
-    private fun maybeTriggerPostponedTransition() {
+    private fun triggerPostponedEnterTransitionIfNeeded() {
         if (shouldTriggerPostponedTransitionAfterLayout) {
             shouldTriggerPostponedTransitionAfterLayout = false
+            // This will trigger enter transition only if one was requested by ScreenStack
             fragment?.startPostponedEnterTransition()
         }
     }
@@ -240,6 +243,9 @@ class Screen(
     val headerConfig: ScreenStackHeaderConfig?
         get() = children.find { it is ScreenStackHeaderConfig } as? ScreenStackHeaderConfig
 
+    val contentWrapper: ScreenContentWrapper?
+        get() = children.find { it is ScreenContentWrapper } as? ScreenContentWrapper
+
     /**
      * While transitioning this property allows to optimize rendering behavior on Android and provide
      * a correct blending options for the animated screen. It is turned on automatically by the

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

@@ -7,78 +7,16 @@ 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.bottomsheet.isSheetFitToContents
+import com.swmansion.rnscreens.bottomsheet.requiresEnterTransitionPostponing
 import com.swmansion.rnscreens.events.StackFinishTransitioningEvent
+import com.swmansion.rnscreens.stack.views.ChildrenDrawingOrderStrategy
+import com.swmansion.rnscreens.stack.views.ReverseFromIndex
+import com.swmansion.rnscreens.stack.views.ReverseOrder
+import com.swmansion.rnscreens.stack.views.ScreensCoordinatorLayout
 import com.swmansion.rnscreens.utils.setTweenAnimations
-import java.util.Collections
 import kotlin.collections.ArrayList
 import kotlin.math.max
 
-internal interface ChildDrawingOrderStrategy {
-    /**
-     * Mutates the list of draw operations **in-place**.
-     */
-    fun apply(drawingOperations: MutableList<ScreenStack.DrawingOp>)
-
-    /**
-     * Enables the given strategy. When enabled - the strategy **might** mutate the operations
-     * list passed to `apply` method.
-     */
-    fun enable()
-
-    /**
-     * Disables the given strategy - even when `apply` is called it **must not** produce
-     * any side effect (it must not manipulate the drawing operations list passed to `apply` method).
-     */
-    fun disable()
-
-    fun isEnabled(): Boolean
-}
-
-internal abstract class ChildDrawingOrderStrategyBase(
-    var enabled: Boolean = false,
-) : ChildDrawingOrderStrategy {
-    override fun enable() {
-        enabled = true
-    }
-
-    override fun disable() {
-        enabled = false
-    }
-
-    override fun isEnabled() = enabled
-}
-
-internal class SwapLastTwo : ChildDrawingOrderStrategyBase() {
-    override fun apply(drawingOperations: MutableList<ScreenStack.DrawingOp>) {
-        if (!isEnabled()) {
-            return
-        }
-        if (drawingOperations.size >= 2) {
-            Collections.swap(drawingOperations, drawingOperations.lastIndex, drawingOperations.lastIndex - 1)
-        }
-    }
-}
-
-internal class ReverseOrderInRange(
-    val range: IntRange,
-) : ChildDrawingOrderStrategyBase() {
-    override fun apply(drawingOperations: MutableList<ScreenStack.DrawingOp>) {
-        if (!isEnabled()) {
-            return
-        }
-
-        var startRange = range.start
-        var endRange = range.endInclusive
-
-        while (startRange < endRange) {
-            Collections.swap(drawingOperations, startRange, endRange)
-            startRange += 1
-            endRange -= 1
-        }
-    }
-}
-
 class ScreenStack(
     context: Context?,
 ) : ScreenContainer(context) {
@@ -88,9 +26,9 @@ class ScreenStack(
     private var drawingOps: MutableList<DrawingOp> = ArrayList()
     private var topScreenWrapper: ScreenStackFragmentWrapper? = null
     private var removalTransitionStarted = false
-    private var previousChildrenCount = 0
 
-    private var childDrawingOrderStrategy: ChildDrawingOrderStrategy? = null
+    private var childrenDrawingOrderStrategy: ChildrenDrawingOrderStrategy? = null
+    private var disappearingTransitioningChildren: MutableList<View> = ArrayList()
 
     var goingForward = false
 
@@ -122,14 +60,25 @@ class ScreenStack(
         }
 
     override fun startViewTransition(view: View) {
+        check(view is ScreensCoordinatorLayout) { "[RNScreens] Unexpected type of ScreenStack direct subview ${view.javaClass}" }
         super.startViewTransition(view)
-        childDrawingOrderStrategy?.enable()
+        if (view.fragment.isRemoving) {
+            disappearingTransitioningChildren.add(view)
+        }
+        if (disappearingTransitioningChildren.isNotEmpty()) {
+            childrenDrawingOrderStrategy?.enable()
+        }
         removalTransitionStarted = true
     }
 
     override fun endViewTransition(view: View) {
         super.endViewTransition(view)
-        childDrawingOrderStrategy?.disable()
+
+        disappearingTransitioningChildren.remove(view)
+
+        if (disappearingTransitioningChildren.isEmpty()) {
+            childrenDrawingOrderStrategy?.disable()
+        }
         if (removalTransitionStarted) {
             removalTransitionStarted = false
             dispatchOnFinishTransitioning()
@@ -172,14 +121,17 @@ class ScreenStack(
         var visibleBottom: ScreenFragmentWrapper? = null
 
         // reset, to not use previously set strategy by mistake
-        childDrawingOrderStrategy = null
+        childrenDrawingOrderStrategy = null
 
         // Determine new first & last visible screens.
         val notDismissedWrappers =
             screenWrappers
                 .asReversed()
                 .asSequence()
-                .filter { !dismissedWrappers.contains(it) && it.screen.activityState !== Screen.ActivityState.INACTIVE }
+                .filter {
+                    !dismissedWrappers.contains(it) &&
+                        it.screen.activityState !== Screen.ActivityState.INACTIVE
+                }
 
         newTop = notDismissedWrappers.firstOrNull()
         visibleBottom =
@@ -202,11 +154,13 @@ class ScreenStack(
                 // 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 previousTopScreenRemainsInStack = topScreenWrapper?.let { screenWrappers.contains(it) } == true
+                val previousTopScreenRemainsInStack =
+                    topScreenWrapper?.let { screenWrappers.contains(it) } == true
                 val isPushReplace = newTop.screen.replaceAnimation === Screen.ReplaceAnimation.PUSH
                 shouldUseOpenAnimation = previousTopScreenRemainsInStack || 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 topScreenWrapper?.screen?.stackAnimation
+                stackAnimation =
+                    if (shouldUseOpenAnimation) newTop.screen.stackAnimation else topScreenWrapper?.screen?.stackAnimation
             } else {
                 // 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
@@ -226,16 +180,16 @@ class ScreenStack(
             needsDrawReordering(newTop, stackAnimation) &&
             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
+            // When using an open animation in which screens overlap (eg. fade_from_bottom or
+            // slide_from_bottom), we want to draw the previous screens under the new one,
+            // which is apparently not the default option. Android always draws the disappearing views
             // 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
+            // appears on top of the previous ones. 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
             // Note: This should not be set in case there is only a single screen in stack or animation `none` is used.
             // Atm needsDrawReordering implementation guards that assuming that first screen on stack uses `NONE` animation.
-            childDrawingOrderStrategy = SwapLastTwo()
+            childrenDrawingOrderStrategy = ReverseOrder()
         } else if (newTop != null &&
             newTopAlreadyInStack &&
             topScreenWrapper?.isTranslucent() == true &&
@@ -253,8 +207,8 @@ class ScreenStack(
                             it.isTranslucent()
                     }.count()
             if (dismissedTransparentScreenApproxCount > 1) {
-                childDrawingOrderStrategy =
-                    ReverseOrderInRange(max(stack.lastIndex - dismissedTransparentScreenApproxCount + 1, 0)..stack.lastIndex)
+                childrenDrawingOrderStrategy =
+                    ReverseFromIndex(max(stack.lastIndex - dismissedTransparentScreenApproxCount + 1, 0))
             }
         }
 
@@ -267,8 +221,12 @@ class ScreenStack(
             // no longer rendered or were dismissed natively.
             stack
                 .asSequence()
-                .filter { wrapper -> !screenWrappers.contains(wrapper) || dismissedWrappers.contains(wrapper) }
-                .forEach { wrapper -> transaction.remove(wrapper.fragment) }
+                .filter { wrapper ->
+                    !screenWrappers.contains(wrapper) ||
+                        dismissedWrappers.contains(
+                            wrapper,
+                        )
+                }.forEach { wrapper -> transaction.remove(wrapper.fragment) }
 
             // Remove all screens underneath visibleBottom && these marked for preload, but keep newTop.
             screenWrappers
@@ -290,14 +248,12 @@ class ScreenStack(
                         }
                     }
             } else if (newTop != null && !newTop.fragment.isAdded) {
-                if (!BuildConfig.IS_NEW_ARCHITECTURE_ENABLED && newTop.screen.isSheetFitToContents()) {
-                    // On old architecture the content wrapper might not have received its frame yet,
-                    // which is required to determine height of the sheet after animation. Therefore
-                    // we delay the transition and trigger it after views receive the layout.
+                if (newTop.screen.requiresEnterTransitionPostponing()) {
                     newTop.fragment.postponeEnterTransition()
                 }
                 transaction.add(id, newTop.fragment)
             }
+
             topScreenWrapper = newTop as? ScreenStackFragmentWrapper
             stack.clear()
             stack.addAll(screenWrappers.asSequence().map { it as ScreenStackFragmentWrapper })
@@ -312,7 +268,8 @@ class ScreenStack(
         if (screenWrappers.size > 1 && visibleBottom != null) {
             topScreenWrapper?.let {
                 if (it.isTranslucent()) {
-                    val screenFragmentsBeneathTop = screenWrappers.slice(0 until screenWrappers.size - 1).asReversed()
+                    val screenFragmentsBeneathTop =
+                        screenWrappers.slice(0 until screenWrappers.size - 1).asReversed()
                     // go from the top of the stack excluding the top screen
                     for (fragmentWrapper in screenFragmentsBeneathTop) {
                         fragmentWrapper.screen.changeAccessibilityMode(
@@ -351,13 +308,7 @@ class ScreenStack(
     override fun dispatchDraw(canvas: Canvas) {
         super.dispatchDraw(canvas)
 
-        // check the view removal is completed (by comparing the previous children count)
-        if (drawingOps.size < previousChildrenCount) {
-            childDrawingOrderStrategy = null
-        }
-        previousChildrenCount = drawingOps.size
-
-        childDrawingOrderStrategy?.apply(drawingOps)
+        childrenDrawingOrderStrategy?.apply(drawingOps)
 
         drawAndRelease()
     }
@@ -407,7 +358,7 @@ class ScreenStack(
             fragmentWrapper: ScreenFragmentWrapper,
             resolvedStackAnimation: StackAnimation?,
         ): Boolean {
-            val stackAnimation = if (resolvedStackAnimation != null) resolvedStackAnimation else fragmentWrapper.screen.stackAnimation
+            val stackAnimation = resolvedStackAnimation ?: fragmentWrapper.screen.stackAnimation
             // On Android sdk 33 and above the animation is different and requires draw reordering.
             // For React Native 0.70 and lower versions, `Build.VERSION_CODES.TIRAMISU` is not defined yet.
             // Hence, we're comparing numerical version here.

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

@@ -4,7 +4,6 @@ import android.animation.Animator
 import android.animation.AnimatorSet
 import android.animation.ValueAnimator
 import android.annotation.SuppressLint
-import android.content.Context
 import android.graphics.Color
 import android.graphics.drawable.ColorDrawable
 import android.os.Bundle
@@ -14,15 +13,11 @@ import android.view.MenuInflater
 import android.view.MenuItem
 import android.view.View
 import android.view.ViewGroup
-import android.view.WindowInsets
 import android.view.animation.Animation
-import android.view.animation.AnimationSet
-import android.view.animation.Transformation
 import android.widget.LinearLayout
 import androidx.appcompat.widget.Toolbar
 import androidx.coordinatorlayout.widget.CoordinatorLayout
 import com.facebook.react.uimanager.PixelUtil
-import com.facebook.react.uimanager.ReactPointerEventsView
 import com.facebook.react.uimanager.UIManagerHelper
 import com.google.android.material.appbar.AppBarLayout
 import com.google.android.material.appbar.AppBarLayout.ScrollingViewBehavior
@@ -37,6 +32,7 @@ import com.swmansion.rnscreens.events.ScreenAnimationDelegate
 import com.swmansion.rnscreens.events.ScreenDismissedEvent
 import com.swmansion.rnscreens.events.ScreenEventEmitter
 import com.swmansion.rnscreens.ext.recycle
+import com.swmansion.rnscreens.stack.views.ScreensCoordinatorLayout
 import com.swmansion.rnscreens.transition.ExternalBoundaryValuesEvaluator
 import com.swmansion.rnscreens.utils.DeviceUtils
 import com.swmansion.rnscreens.utils.resolveBackgroundColor
@@ -233,6 +229,8 @@ class ScreenStackFragment :
             dimmingDelegate.onViewHierarchyCreated(screen, coordinatorLayout)
             dimmingDelegate.onBehaviourAttached(screen, screen.sheetBehavior!!)
 
+            // Pre-layout the content for the sake of enter transition.
+
             val container = screen.container!!
             coordinatorLayout.measure(
                 View.MeasureSpec.makeMeasureSpec(container.width, View.MeasureSpec.EXACTLY),
@@ -341,7 +339,7 @@ class ScreenStackFragment :
             return screenColor
         }
 
-        val contentWrapper = screen.contentWrapper.get()
+        val contentWrapper = screen.contentWrapper
         if (contentWrapper == null) {
             return null
         }
@@ -471,122 +469,4 @@ class ScreenStackFragment :
         }
         return sheetDelegate!!
     }
-
-    private class ScreensCoordinatorLayout(
-        context: Context,
-        private val fragment: ScreenStackFragment,
-        private val pointerEventsImpl: ReactPointerEventsView,
-//    ) : CoordinatorLayout(context), ReactCompoundViewGroup, ReactHitSlopView {
-    ) : CoordinatorLayout(context),
-        ReactPointerEventsView by pointerEventsImpl {
-        constructor(context: Context, fragment: ScreenStackFragment) : this(
-            context,
-            fragment,
-            PointerEventsBoxNoneImpl(),
-        )
-
-        override fun onApplyWindowInsets(insets: WindowInsets?): WindowInsets = super.onApplyWindowInsets(insets)
-
-        private val animationListener: Animation.AnimationListener =
-            object : Animation.AnimationListener {
-                override fun onAnimationStart(animation: Animation) {
-                    fragment.onViewAnimationStart()
-                }
-
-                override fun onAnimationEnd(animation: Animation) {
-                    fragment.onViewAnimationEnd()
-                }
-
-                override fun onAnimationRepeat(animation: Animation) {}
-            }
-
-        override fun startAnimation(animation: Animation) {
-            // For some reason View##onAnimationEnd doesn't get called for
-            // exit transitions so we explicitly attach animation listener.
-            // We also have some animations that are an AnimationSet, so we don't wrap them
-            // in another set since it causes some visual glitches when going forward.
-            // We also set the listener only when going forward, since when going back,
-            // there is already a listener for dismiss action added, which would be overridden
-            // and also this is not necessary when going back since the lifecycle methods
-            // are correctly dispatched then.
-            // We also add fakeAnimation to the set of animations, which sends the progress of animation
-            val fakeAnimation = ScreensAnimation(fragment).apply { duration = animation.duration }
-
-            if (animation is AnimationSet && !fragment.isRemoving) {
-                animation
-                    .apply {
-                        addAnimation(fakeAnimation)
-                        setAnimationListener(animationListener)
-                    }.also {
-                        super.startAnimation(it)
-                    }
-            } else {
-                AnimationSet(true)
-                    .apply {
-                        addAnimation(animation)
-                        addAnimation(fakeAnimation)
-                        setAnimationListener(animationListener)
-                    }.also {
-                        super.startAnimation(it)
-                    }
-            }
-        }
-
-        /**
-         * 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 onLayout(
-            changed: Boolean,
-            l: Int,
-            t: Int,
-            r: Int,
-            b: Int,
-        ) {
-            super.onLayout(changed, l, t, r, b)
-
-            if (fragment.screen.usesFormSheetPresentation()) {
-                fragment.screen.onBottomSheetBehaviorDidLayout(changed)
-            }
-        }
-
-//        override fun reactTagForTouch(touchX: Float, touchY: Float): Int {
-//            throw IllegalStateException("Screen wrapper should never be asked for the view tag")
-//        }
-//
-//        override fun interceptsTouchEvent(touchX: Float, touchY: Float): Boolean {
-//            return false
-//        }
-//
-//        override fun getHitSlopRect(): Rect? {
-//            val screen: Screen = fragment.screen
-// //            left – The X coordinate of the left side of the rectangle
-// //            top – The Y coordinate of the top of the rectangle i
-// //            right – The X coordinate of the right side of the rectangle
-// //            bottom – The Y coordinate of the bottom of the rectangle
-//            return Rect(screen.x.toInt(), -screen.y.toInt(), screen.x.toInt() + screen.width, screen.y.toInt() + screen.height)
-//        }
-    }
-
-    private class ScreensAnimation(
-        private val mFragment: ScreenFragment,
-    ) : Animation() {
-        override fun applyTransformation(
-            interpolatedTime: Float,
-            t: Transformation,
-        ) {
-            super.applyTransformation(interpolatedTime, t)
-            // interpolated time should be the progress of the current transition
-            mFragment.dispatchTransitionProgressEvent(interpolatedTime, !mFragment.isResumed)
-        }
-    }
 }

package/android/src/main/java/com/swmansion/rnscreens/bottomsheet/SheetDelegate.kt

@@ -130,13 +130,13 @@ class SheetDelegate(
                         behavior.apply {
                             val height =
                                 if (screen.isSheetFitToContents()) {
-                                    screen.contentWrapper.get()?.let { contentWrapper ->
+                                    screen.contentWrapper?.let { contentWrapper ->
                                         contentWrapper.height.takeIf {
                                             // subtree might not be laid out, e.g. after fragment reattachment
                                             // and view recreation, however since it is retained by
                                             // react-native it has its height cached. We want to use it.
                                             // Otherwise we would have to trigger RN layout manually.
-                                            contentWrapper.isLaidOut || contentWrapper.height > 0
+                                            contentWrapper.isLaidOutOrHasCachedLayout()
                                         }
                                     }
                                 } else {

package/android/src/main/java/com/swmansion/rnscreens/bottomsheet/SheetUtils.kt

@@ -1,10 +1,12 @@
 package com.swmansion.rnscreens.bottomsheet
 
+import android.view.View
 import com.google.android.material.bottomsheet.BottomSheetBehavior
 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.swmansion.rnscreens.BuildConfig
 import com.swmansion.rnscreens.Screen
 
 object SheetUtils {
@@ -133,3 +135,24 @@ fun Screen.isSheetFitToContents(): Boolean =
         sheetDetents.first() == Screen.SHEET_FIT_TO_CONTENTS
 
 fun Screen.usesFormSheetPresentation(): Boolean = stackPresentation === Screen.StackPresentation.FORM_SHEET
+
+fun Screen.requiresEnterTransitionPostponing(): Boolean {
+    // On old architecture the content wrapper might not have received its frame yet,
+    // which is required to determine height of the sheet after animation. Therefore
+    // we delay the transition and trigger it after views receive the layout.
+    // This is used only for formSheet presentation, because we use value animators
+    // there. Tween animations have some magic way to make this work (maybe they
+    // postpone the transition internally, dunno).
+
+    if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED || !this.usesFormSheetPresentation()) {
+        return false
+    }
+    // Assumes that formSheet uses content wrapper
+    return !this.isLaidOutOrHasCachedLayout() || this.contentWrapper?.isLaidOutOrHasCachedLayout() != true
+}
+
+/**
+ * The view might not be laid out, but have cached dimensions e.g. when host fragment
+ * is reattached to container.
+ */
+fun View.isLaidOutOrHasCachedLayout() = this.isLaidOut || height > 0 || width > 0

package/android/src/main/java/com/swmansion/rnscreens/stack/anim/ScreensAnimation.kt

@@ -0,0 +1,18 @@
+package com.swmansion.rnscreens.stack.anim
+
+import android.view.animation.Animation
+import android.view.animation.Transformation
+import com.swmansion.rnscreens.ScreenFragment
+
+internal class ScreensAnimation(
+    private val mFragment: ScreenFragment,
+) : Animation() {
+    override fun applyTransformation(
+        interpolatedTime: Float,
+        t: Transformation,
+    ) {
+        super.applyTransformation(interpolatedTime, t)
+        // interpolated time should be the progress of the current transition
+        mFragment.dispatchTransitionProgressEvent(interpolatedTime, !mFragment.isResumed)
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/stack/views/ChildDrawingOrderStrategyImpl.kt

@@ -0,0 +1,48 @@
+package com.swmansion.rnscreens.stack.views
+
+import com.swmansion.rnscreens.ScreenStack
+import java.util.Collections
+
+internal abstract class ChildrenDrawingOrderStrategyBase(
+    var enabled: Boolean = false,
+) : ChildrenDrawingOrderStrategy {
+    override fun enable() {
+        enabled = true
+    }
+
+    override fun disable() {
+        enabled = false
+    }
+
+    override fun isEnabled() = enabled
+}
+
+
+internal class ReverseFromIndex(
+    val startIndex: Int,
+) : ChildrenDrawingOrderStrategyBase() {
+    override fun apply(drawingOperations: MutableList<ScreenStack.DrawingOp>) {
+        if (!isEnabled()) {
+            return
+        }
+
+        var currentLeftIndex = startIndex
+        var currentRightIndex = drawingOperations.lastIndex
+
+        while (currentLeftIndex < currentRightIndex) {
+            Collections.swap(drawingOperations, currentLeftIndex, currentRightIndex)
+            currentLeftIndex += 1
+            currentRightIndex -= 1
+        }
+    }
+}
+
+internal class ReverseOrder : ChildrenDrawingOrderStrategyBase() {
+    override fun apply(drawingOperations: MutableList<ScreenStack.DrawingOp>) {
+        if (!isEnabled()) {
+            return
+        }
+
+        drawingOperations.reverse()
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/stack/views/ChildrenDrawingOrderStrategy.kt

@@ -0,0 +1,24 @@
+package com.swmansion.rnscreens.stack.views
+
+import com.swmansion.rnscreens.ScreenStack
+
+internal interface ChildrenDrawingOrderStrategy {
+    /**
+     * Mutates the list of draw operations **in-place**.
+     */
+    fun apply(drawingOperations: MutableList<ScreenStack.DrawingOp>)
+
+    /**
+     * Enables the given strategy. When enabled - the strategy **might** mutate the operations
+     * list passed to `apply` method.
+     */
+    fun enable()
+
+    /**
+     * Disables the given strategy - even when `apply` is called it **must not** produce
+     * any side effect (it must not manipulate the drawing operations list passed to `apply` method).
+     */
+    fun disable()
+
+    fun isEnabled(): Boolean
+}