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

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

@@ -2,63 +2,73 @@ package com.swmansion.rnscreens
 
 import android.content.Context
 import android.graphics.Canvas
+import android.os.Build
 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.DimmingFragment
 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()
+class ScreenStack(
+    context: Context?,
+) : ScreenContainer(context) {
+    private val stack = ArrayList<ScreenStackFragmentWrapper>()
+    private val dismissedWrappers: 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 topScreenWrapper: ScreenStackFragmentWrapper? = null
+    private var removalTransitionStarted = false
     private var isDetachingCurrentScreen = false
     private var reverseLastTwoChildren = false
     private var previousChildrenCount = 0
     var goingForward = false
 
+    /**
+     * Marks given fragment as to-be-dismissed and performs updates on container
+     *
+     * @param fragmentWrapper to-be-dismissed wrapper
+     */
     fun dismiss(screenFragment: ScreenStackFragmentWrapper) {
-        mDismissed.add(screenFragment)
+        dismissedWrappers.add(screenFragment)
         performUpdatesNow()
     }
 
     override val topScreen: Screen?
-        get() = mTopScreen?.screen
+        get() = topScreenWrapper?.screen
+
+    val fragments: ArrayList<ScreenStackFragmentWrapper>
+        get() = stack
 
     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")
+        get() =
+            screenWrappers.firstOrNull { !dismissedWrappers.contains(it) }?.screen
+                ?: throw IllegalStateException("[RNScreens] Stack has no root screen set")
+
+    override fun adapt(screen: Screen): ScreenStackFragmentWrapper =
+        when (screen.stackPresentation) {
+            Screen.StackPresentation.FORM_SHEET -> DimmingFragment(ScreenStackFragment(screen))
+            else -> ScreenStackFragment(screen)
         }
 
-    override fun adapt(screen: Screen) = ScreenStackFragment(screen)
-
     override fun startViewTransition(view: View) {
         super.startViewTransition(view)
-        mRemovalTransitionStarted = true
+        removalTransitionStarted = true
     }
 
     override fun endViewTransition(view: View) {
         super.endViewTransition(view)
-        if (mRemovalTransitionStarted) {
-            mRemovalTransitionStarted = false
+        if (removalTransitionStarted) {
+            removalTransitionStarted = false
             dispatchOnFinishTransitioning()
         }
     }
 
     fun onViewAppearTransitionEnd() {
-        if (!mRemovalTransitionStarted) {
+        if (!removalTransitionStarted) {
             dispatchOnFinishTransitioning()
         }
     }
@@ -71,63 +81,66 @@ class ScreenStack(context: Context?) : ScreenContainer(context) {
     }
 
     override fun removeScreenAt(index: Int) {
-        mDismissed.remove(getScreenFragmentWrapperAt(index))
+        dismissedWrappers.remove(getScreenFragmentWrapperAt(index))
         super.removeScreenAt(index)
     }
 
     override fun removeAllScreens() {
-        mDismissed.clear()
+        dismissedWrappers.clear()
         super.removeAllScreens()
     }
 
     override fun hasScreen(screenFragmentWrapper: ScreenFragmentWrapper?): Boolean =
-        super.hasScreen(screenFragmentWrapper) && !mDismissed.contains(screenFragmentWrapper)
+        super.hasScreen(screenFragmentWrapper) && !dismissedWrappers.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
+        var visibleBottom: ScreenFragmentWrapper? =
+            null // this is only set if newTop has one of transparent presentation modes
         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)) {
+
+        for (i in screenWrappers.indices.reversed()) {
+            val screenWrapper = getScreenFragmentWrapperAt(i)
+            if (!dismissedWrappers.contains(screenWrapper) && screenWrapper.screen.activityState !== Screen.ActivityState.INACTIVE) {
                 if (newTop == null) {
-                    newTop = screen
+                    newTop = screenWrapper
                 } else {
-                    visibleBottom = screen
+                    visibleBottom = screenWrapper
                 }
-                if (!isTransparent(screen)) {
+                if (!screenWrapper.screen.isTransparent()) {
                     break
                 }
             }
         }
+
         var shouldUseOpenAnimation = true
         var stackAnimation: StackAnimation? = null
-        if (!mStack.contains(newTop)) {
+        if (!stack.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) {
+            if (topScreenWrapper != 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 containsTopScreen = topScreenWrapper?.let { screenWrappers.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) {
+                stackAnimation = if (shouldUseOpenAnimation) newTop.screen.stackAnimation else topScreenWrapper?.screen?.stackAnimation
+            } else if (topScreenWrapper == 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) {
+        } else if (topScreenWrapper != null && topScreenWrapper != newTop) {
             // otherwise if we are performing top screen change we do "close animation"
             shouldUseOpenAnimation = false
-            stackAnimation = mTopScreen?.screen?.stackAnimation
+            stackAnimation = topScreenWrapper?.screen?.stackAnimation
         }
 
         createTransaction().let {
@@ -135,27 +148,97 @@ class ScreenStack(context: Context?) : ScreenContainer(context) {
             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.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)
+                        StackAnimation.IOS_FROM_RIGHT ->
+                            it.setCustomAnimations(
+                                R.anim.rns_ios_from_right_foreground_open,
+                                R.anim.rns_ios_from_right_background_open,
+                            )
+                        StackAnimation.IOS_FROM_LEFT ->
+                            it.setCustomAnimations(
+                                R.anim.rns_ios_from_left_foreground_open,
+                                R.anim.rns_ios_from_left_background_open,
+                            )
                     }
                 } 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.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)
+                        StackAnimation.IOS_FROM_RIGHT ->
+                            it.setCustomAnimations(
+                                R.anim.rns_ios_from_right_background_close,
+                                R.anim.rns_ios_from_right_foreground_close,
+                            )
+                        StackAnimation.IOS_FROM_LEFT ->
+                            it.setCustomAnimations(
+                                R.anim.rns_ios_from_left_background_close,
+                                R.anim.rns_ios_from_left_foreground_close,
+                            )
                     }
                 }
             }
@@ -164,7 +247,8 @@ class ScreenStack(context: Context?) : ScreenContainer(context) {
             goingForward = shouldUseOpenAnimation
 
             if (shouldUseOpenAnimation &&
-                newTop != null && needsDrawReordering(newTop) &&
+                newTop != null &&
+                needsDrawReordering(newTop) &&
                 visibleBottom == null
             ) {
                 // When using an open animation in which two screens overlap (eg. fade_from_bottom or
@@ -178,19 +262,21 @@ class ScreenStack(context: Context?) : ScreenContainer(context) {
             }
 
             // remove all screens previously on stack
-            for (fragmentWrapper in mStack) {
-                if (!mScreenFragments.contains(fragmentWrapper) || mDismissed.contains(fragmentWrapper)) {
+            for (fragmentWrapper in stack) {
+                if (!screenWrappers.contains(fragmentWrapper) || dismissedWrappers.contains(fragmentWrapper)) {
                     it.remove(fragmentWrapper.fragment)
                 }
             }
-            for (fragmentWrapper in mScreenFragments) {
+            for (fragmentWrapper in screenWrappers) {
                 // 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)) {
+                if ((fragmentWrapper !== newTop && !dismissedWrappers.contains(fragmentWrapper)) ||
+                    fragmentWrapper.screen.activityState === Screen.ActivityState.INACTIVE
+                ) {
                     it.remove(fragmentWrapper.fragment)
                 }
             }
@@ -199,22 +285,27 @@ class ScreenStack(context: Context?) : ScreenContainer(context) {
             if (visibleBottom != null && !visibleBottom.fragment.isAdded) {
                 val top = newTop
                 var beneathVisibleBottom = true
-                for (fragmentWrapper in mScreenFragments) {
+                for (fragmentWrapper in screenWrappers) {
                     // ignore all screens beneath the visible bottom
                     if (beneathVisibleBottom) {
-                        beneathVisibleBottom = if (fragmentWrapper === visibleBottom) {
-                            false
-                        } else continue
+                        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() }
+                    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 })
+            topScreenWrapper = newTop as? ScreenStackFragmentWrapper
+            stack.clear()
+            stack.addAll(screenWrappers.map { it as ScreenStackFragmentWrapper })
 
             turnOffA11yUnderTransparentScreen(visibleBottom)
 
@@ -224,13 +315,15 @@ class ScreenStack(context: Context?) : ScreenContainer(context) {
 
     // 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()
+        if (screenWrappers.size > 1 && visibleBottom != null) {
+            topScreenWrapper?.let {
+                if (it.screen.isTransparent()) {
+                    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(IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS)
+                        fragmentWrapper.screen.changeAccessibilityMode(
+                            IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS,
+                        )
 
                         // don't change a11y below non-transparent screens
                         if (fragmentWrapper == visibleBottom) {
@@ -245,7 +338,7 @@ class ScreenStack(context: Context?) : ScreenContainer(context) {
     }
 
     override fun notifyContainerUpdate() {
-        mStack.forEach { it.onContainerUpdate() }
+        stack.forEach { it.onContainerUpdate() }
     }
 
     // below methods are taken from
@@ -292,13 +385,17 @@ class ScreenStack(context: Context?) : ScreenContainer(context) {
         drawAndRelease()
     }
 
-    override fun drawChild(canvas: Canvas, child: View, drawingTime: Long): Boolean {
+    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
     }
@@ -309,8 +406,9 @@ class ScreenStack(context: Context?) : ScreenContainer(context) {
         super.drawChild(op.canvas!!, op.child, op.drawingTime)
     }
 
-    private fun obtainDrawingOp(): DrawingOp =
-        if (drawingOpPool.isEmpty()) DrawingOp() else drawingOpPool.removeLast()
+    // Can't use `drawingOpPool.removeLast` here due to issues with static name resolution in Android SDK 35+.
+    // See: https://developer.android.com/about/versions/15/behavior-changes-15?hl=en#openjdk-api-changes
+    private fun obtainDrawingOp(): DrawingOp = if (drawingOpPool.isEmpty()) DrawingOp() else drawingOpPool.removeAt(drawingOpPool.lastIndex)
 
     private inner class DrawingOp {
         var canvas: Canvas? = null
@@ -326,11 +424,16 @@ class ScreenStack(context: Context?) : ScreenContainer(context) {
     }
 
     companion object {
-        private fun isTransparent(fragmentWrapper: ScreenFragmentWrapper): Boolean =
-            fragmentWrapper.screen.stackPresentation === Screen.StackPresentation.TRANSPARENT_MODAL
+        const val TAG = "ScreenStack"
 
         private fun needsDrawReordering(fragmentWrapper: ScreenFragmentWrapper): Boolean =
-            fragmentWrapper.screen.stackAnimation === StackAnimation.SLIDE_FROM_BOTTOM ||
-                fragmentWrapper.screen.stackAnimation === StackAnimation.FADE_FROM_BOTTOM
+            // 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.
+            Build.VERSION.SDK_INT >= 33 ||
+                fragmentWrapper.screen.stackAnimation === StackAnimation.SLIDE_FROM_BOTTOM ||
+                fragmentWrapper.screen.stackAnimation === StackAnimation.FADE_FROM_BOTTOM ||
+                fragmentWrapper.screen.stackAnimation === StackAnimation.IOS_FROM_RIGHT ||
+                fragmentWrapper.screen.stackAnimation === StackAnimation.IOS_FROM_LEFT
     }
 }