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

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

@@ -14,29 +14,42 @@ import com.facebook.react.ReactRootView
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.modules.core.ChoreographerCompat
 import com.facebook.react.modules.core.ReactChoreographer
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
 import com.swmansion.rnscreens.Screen.ActivityState
+import com.swmansion.rnscreens.events.ScreenDismissedEvent
 
-open class ScreenContainer(context: Context?) : ViewGroup(context) {
+open class ScreenContainer(
+    context: Context?,
+) : ViewGroup(context) {
     @JvmField
-    protected val mScreenFragments = ArrayList<ScreenFragmentWrapper>()
+    protected val screenWrappers = ArrayList<ScreenFragmentWrapper>()
+
     @JvmField
-    protected var mFragmentManager: FragmentManager? = null
-    private var mIsAttached = false
-    private var mNeedUpdate = false
-    private var mLayoutEnqueued = false
-    private val mLayoutCallback: ChoreographerCompat.FrameCallback = object : ChoreographerCompat.FrameCallback() {
-        override fun doFrame(frameTimeNanos: Long) {
-            mLayoutEnqueued = false
-            measure(
-                MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
-                MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
-            )
-            layout(left, top, right, bottom)
+    protected var fragmentManager: FragmentManager? = null
+    private var isAttached = false
+    private var needsUpdate = false
+    private var isLayoutEnqueued = false
+    private val layoutCallback: ChoreographerCompat.FrameCallback =
+        object : ChoreographerCompat.FrameCallback() {
+            override fun doFrame(frameTimeNanos: Long) {
+                isLayoutEnqueued = false
+                measure(
+                    MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+                    MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY),
+                )
+                layout(left, top, right, bottom)
+            }
         }
-    }
-    private var mParentScreenFragment: ScreenFragmentWrapper? = null
-
-    override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+    private var parentScreenWrapper: ScreenFragmentWrapper? = null
+
+    override fun onLayout(
+        changed: Boolean,
+        l: Int,
+        t: Int,
+        r: Int,
+        b: Int,
+    ) {
         var i = 0
         val size = childCount
         while (i < size) {
@@ -48,16 +61,9 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
     override fun removeView(view: View) {
         // The below block is a workaround for an issue with keyboard handling within fragments. Despite
         // Android handles input focus on the fragments that leave the screen, the keyboard stays open
-        // in a number of cases. The issue can be best reproduced on Android 5 devices, before some
-        // changes in Android's InputMethodManager have been introduced (specifically around dismissing
-        // the keyboard in onDetachedFromWindow). However, we also noticed the keyboard issue happen
-        // intermittently on recent versions of Android as well. The issue hasn't been previously
-        // noticed as in React Native <= 0.61 there was a logic that'd trigger keyboard dismiss upon a
-        // blur event (the blur even gets dispatched properly, the keyboard just stays open despite
-        // that) – note the change in RN core here:
-        // https://github.com/facebook/react-native/commit/e9b4928311513d3cbbd9d875827694eab6cfa932
+        // in a number of cases.
         // The workaround is to force-hide keyboard when the screen that has focus is dismissed (we
-        // detect that in removeView as super.removeView causes the input view to un focus while keeping
+        // detect that in removeView as super.removeView causes the input view to un-focus while keeping
         // the keyboard open).
         if (view === focusedChild) {
             (context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager)
@@ -69,19 +75,21 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
     override fun requestLayout() {
         super.requestLayout()
         @Suppress("SENSELESS_COMPARISON") // mLayoutCallback can be null here since this method can be called in init
-        if (!mLayoutEnqueued && mLayoutCallback != null) {
-            mLayoutEnqueued = true
+        if (!isLayoutEnqueued && layoutCallback != null) {
+            isLayoutEnqueued = true
             // we use NATIVE_ANIMATED_MODULE choreographer queue because it allows us to catch the current
             // looper loop instead of enqueueing the update in the next loop causing a one frame delay.
-            ReactChoreographer.getInstance()
+            ReactChoreographer
+                .getInstance()
                 .postFrameCallback(
-                    ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE, mLayoutCallback
+                    ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
+                    layoutCallback,
                 )
         }
     }
 
     val isNested: Boolean
-        get() = mParentScreenFragment != null
+        get() = parentScreenWrapper != null
 
     fun notifyChildUpdate() {
         performUpdatesNow()
@@ -89,40 +97,43 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
 
     protected open fun adapt(screen: Screen): ScreenFragmentWrapper = ScreenFragment(screen)
 
-    fun addScreen(screen: Screen, index: Int) {
+    fun addScreen(
+        screen: Screen,
+        index: Int,
+    ) {
         val fragment = adapt(screen)
         screen.fragmentWrapper = fragment
-        mScreenFragments.add(index, fragment)
+        screenWrappers.add(index, fragment)
         screen.container = this
         onScreenChanged()
     }
 
     open fun removeScreenAt(index: Int) {
-        mScreenFragments[index].screen.container = null
-        mScreenFragments.removeAt(index)
+        screenWrappers[index].screen.container = null
+        screenWrappers.removeAt(index)
         onScreenChanged()
     }
 
     open fun removeAllScreens() {
-        for (screenFragment in mScreenFragments) {
+        for (screenFragment in screenWrappers) {
             screenFragment.screen.container = null
         }
-        mScreenFragments.clear()
+        screenWrappers.clear()
         onScreenChanged()
     }
 
     val screenCount: Int
-        get() = mScreenFragments.size
+        get() = screenWrappers.size
 
-    fun getScreenAt(index: Int): Screen = mScreenFragments[index].screen
+    fun getScreenAt(index: Int): Screen = screenWrappers[index].screen
 
-    fun getScreenFragmentWrapperAt(index: Int): ScreenFragmentWrapper = mScreenFragments[index]
+    fun getScreenFragmentWrapperAt(index: Int): ScreenFragmentWrapper = screenWrappers[index]
 
     open val topScreen: Screen?
-        get() = mScreenFragments.firstOrNull { getActivityState(it) === ActivityState.ON_TOP }?.screen
+        get() = screenWrappers.firstOrNull { getActivityState(it) === ActivityState.ON_TOP }?.screen
 
     private fun setFragmentManager(fm: FragmentManager) {
-        mFragmentManager = fm
+        fragmentManager = fm
         performUpdatesNow()
     }
 
@@ -174,10 +185,10 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
         if (parent is Screen) {
             checkNotNull(
                 parent.fragmentWrapper?.let { fragmentWrapper ->
-                    mParentScreenFragment = fragmentWrapper
+                    parentScreenWrapper = fragmentWrapper
                     fragmentWrapper.addChildScreenContainer(this)
                     setFragmentManager(fragmentWrapper.fragment.childFragmentManager)
-                }
+                },
             ) { "Parent Screen does not have its Fragment attached" }
         } else {
             // we expect top level view to be of type ReactRootView, this isn't really necessary but in
@@ -190,29 +201,64 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
         }
     }
 
-    protected fun createTransaction(): FragmentTransaction {
-        return requireNotNull(mFragmentManager) { "mFragmentManager is null when creating transaction" }
+    protected fun createTransaction(): FragmentTransaction =
+        requireNotNull(fragmentManager) { "fragment manager is null when creating transaction" }
             .beginTransaction()
             .setReorderingAllowed(true)
-    }
 
-    private fun attachScreen(transaction: FragmentTransaction, fragment: Fragment) {
+    private fun attachScreen(
+        transaction: FragmentTransaction,
+        fragment: Fragment,
+    ) {
         transaction.add(id, fragment)
     }
 
-    private fun detachScreen(transaction: FragmentTransaction, fragment: Fragment) {
+    fun attachBelowTop() {
+        if (screenWrappers.size < 2) {
+            throw RuntimeException("[RNScreens] Unable to run transition for less than 2 screens.")
+        }
+        val transaction = createTransaction()
+        val top = topScreen as Screen
+        // we have to reattach topScreen so it is on top of the one below
+        detachScreen(transaction, top.fragment as Fragment)
+        attachScreen(transaction, screenWrappers[screenWrappers.size - 2].fragment)
+        attachScreen(transaction, top.fragment as Fragment)
+        transaction.commitNowAllowingStateLoss()
+    }
+
+    fun detachBelowTop() {
+        if (screenWrappers.size < 2) {
+            throw RuntimeException("[RNScreens] Unable to run transition for less than 2 screens.")
+        }
+        val transaction = createTransaction()
+        detachScreen(transaction, screenWrappers[screenWrappers.size - 2].fragment)
+        transaction.commitNowAllowingStateLoss()
+    }
+
+    fun notifyTopDetached() {
+        val top = topScreen as Screen
+        if (context is ReactContext) {
+            val surfaceId = UIManagerHelper.getSurfaceId(context)
+            UIManagerHelper
+                .getEventDispatcherForReactTag(context as ReactContext, top.id)
+                ?.dispatchEvent(ScreenDismissedEvent(surfaceId, top.id))
+        }
+    }
+
+    private fun detachScreen(
+        transaction: FragmentTransaction,
+        fragment: Fragment,
+    ) {
         transaction.remove(fragment)
     }
 
-    private fun getActivityState(screenFragmentWrapper: ScreenFragmentWrapper): ActivityState? =
-        screenFragmentWrapper.screen.activityState
+    private fun getActivityState(screenFragmentWrapper: ScreenFragmentWrapper): ActivityState? = screenFragmentWrapper.screen.activityState
 
-    open fun hasScreen(screenFragmentWrapper: ScreenFragmentWrapper?): Boolean =
-        mScreenFragments.contains(screenFragmentWrapper)
+    open fun hasScreen(screenFragmentWrapper: ScreenFragmentWrapper?): Boolean = screenWrappers.contains(screenFragmentWrapper)
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
-        mIsAttached = true
+        isAttached = true
         setupFragmentManager()
     }
 
@@ -238,18 +284,18 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
         // view. We also need to make sure all the fragments attached to the given container are removed
         // from fragment manager as in some cases fragment manager may be reused and in such case it'd
         // attempt to reattach previously registered fragments that are not removed
-        mFragmentManager?.let {
+        fragmentManager?.let {
             if (!it.isDestroyed) {
                 removeMyFragments(it)
                 it.executePendingTransactions()
             }
         }
 
-        mParentScreenFragment?.removeChildScreenContainer(this)
-        mParentScreenFragment = null
+        parentScreenWrapper?.removeChildScreenContainer(this)
+        parentScreenWrapper = null
 
         super.onDetachedFromWindow()
-        mIsAttached = false
+        isAttached = false
         // When fragment container view is detached we force all its children to be removed.
         // It is because children screens are controlled by their fragments, which can often have a
         // delayed lifecycle (due to transitions). As a result due to ongoing transitions the fragment
@@ -267,7 +313,10 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
         }
     }
 
-    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+    override fun onMeasure(
+        widthMeasureSpec: Int,
+        heightMeasureSpec: Int,
+    ) {
         super.onMeasure(widthMeasureSpec, heightMeasureSpec)
         for (i in 0 until childCount) {
             getChildAt(i).measure(widthMeasureSpec, heightMeasureSpec)
@@ -283,8 +332,8 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
         // before transition if also not dispatched after children updates.
         // The exception to this rule is `updateImmediately` which is triggered by actions
         // not connected to React view hierarchy changes, but rather internal events
-        mNeedUpdate = true
-        (context as? ReactContext)?.runOnUiQueueThread {
+        needsUpdate = true
+        (context as ThemedReactContext).reactApplicationContext.runOnUiQueueThread {
             // We schedule the update here because LayoutAnimations of `react-native-reanimated`
             // sometimes attach/detach screens after the layout block of `ScreensShadowNode` has
             // already run, and we want to update the container then too. In the other cases,
@@ -298,15 +347,15 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
         // we want to update immediately when the fragment manager is set or native back button
         // dismiss is dispatched or Screen's activityState changes since it is not connected to React
         // view hierarchy changes and will not trigger `onBeforeLayout` method of `ScreensShadowNode`
-        mNeedUpdate = true
+        needsUpdate = true
         performUpdates()
     }
 
     fun performUpdates() {
-        if (!mNeedUpdate || !mIsAttached || mFragmentManager == null || mFragmentManager?.isDestroyed == true) {
+        if (!needsUpdate || !isAttached || fragmentManager == null || fragmentManager?.isDestroyed == true) {
             return
         }
-        mNeedUpdate = false
+        needsUpdate = false
         onUpdate()
         notifyContainerUpdate()
     }
@@ -314,12 +363,13 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
     open fun onUpdate() {
         createTransaction().let {
             // detach screens that are no longer active
-            val orphaned: MutableSet<Fragment> = HashSet(
-                requireNotNull(mFragmentManager) {
-                    "mFragmentManager is null when performing update in ScreenContainer"
-                }.fragments
-            )
-            for (fragmentWrapper in mScreenFragments) {
+            val orphaned: MutableSet<Fragment> =
+                HashSet(
+                    requireNotNull(fragmentManager) {
+                        "fragment manager is null when performing update in ScreenContainer"
+                    }.fragments,
+                )
+            for (fragmentWrapper in screenWrappers) {
                 if (getActivityState(fragmentWrapper) === ActivityState.INACTIVE &&
                     fragmentWrapper.fragment.isAdded
                 ) {
@@ -345,7 +395,7 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
             var addedBefore = false
             val pendingFront: ArrayList<ScreenFragmentWrapper> = ArrayList()
 
-            for (fragmentWrapper in mScreenFragments) {
+            for (fragmentWrapper in screenWrappers) {
                 val activityState = getActivityState(fragmentWrapper)
                 if (activityState !== ActivityState.INACTIVE && !fragmentWrapper.fragment.isAdded) {
                     addedBefore = true

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

@@ -6,19 +6,39 @@ import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.LayoutShadowNode
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.RNSScreenContainerManagerDelegate
+import com.facebook.react.viewmanagers.RNSScreenContainerManagerInterface
 
 @ReactModule(name = ScreenContainerViewManager.REACT_CLASS)
-class ScreenContainerViewManager : ViewGroupManager<ScreenContainer>() {
+class ScreenContainerViewManager :
+    ViewGroupManager<ScreenContainer>(),
+    RNSScreenContainerManagerInterface<ScreenContainer> {
+    private val delegate: ViewManagerDelegate<ScreenContainer>
+
+    init {
+        delegate = RNSScreenContainerManagerDelegate<ScreenContainer, ScreenContainerViewManager>(this)
+    }
+
+    protected override fun getDelegate(): ViewManagerDelegate<ScreenContainer> = delegate
+
     override fun getName(): String = REACT_CLASS
 
     override fun createViewInstance(reactContext: ThemedReactContext): ScreenContainer = ScreenContainer(reactContext)
 
-    override fun addView(parent: ScreenContainer, child: View, index: Int) {
+    override fun addView(
+        parent: ScreenContainer,
+        child: View,
+        index: Int,
+    ) {
         require(child is Screen) { "Attempt attach child that is not of type RNScreens" }
         parent.addScreen(child, index)
     }
 
-    override fun removeViewAt(parent: ScreenContainer, index: Int) {
+    override fun removeViewAt(
+        parent: ScreenContainer,
+        index: Int,
+    ) {
         parent.removeScreenAt(index)
     }
 
@@ -28,7 +48,10 @@ class ScreenContainerViewManager : ViewGroupManager<ScreenContainer>() {
 
     override fun getChildCount(parent: ScreenContainer): Int = parent.screenCount
 
-    override fun getChildAt(parent: ScreenContainer, index: Int): View = parent.getScreenAt(index)
+    override fun getChildAt(
+        parent: ScreenContainer,
+        index: Int,
+    ): View = parent.getScreenAt(index)
 
     override fun createShadowNodeInstance(context: ReactApplicationContext): LayoutShadowNode = ScreensShadowNode(context)
 

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

@@ -0,0 +1,38 @@
+package com.swmansion.rnscreens
+
+import android.annotation.SuppressLint
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.views.view.ReactViewGroup
+
+/**
+ * When we wrap children of the Screen component inside this component in JS code,
+ * we can later use it to get the enclosing frame size of our content as it is rendered by RN.
+ *
+ * This is useful when adapting form sheet height to its contents height.
+ */
+@SuppressLint("ViewConstructor")
+class ScreenContentWrapper(
+    reactContext: ReactContext,
+) : ReactViewGroup(reactContext) {
+    internal var delegate: OnLayoutCallback? = null
+
+    interface OnLayoutCallback {
+        fun onLayoutCallback(
+            changed: Boolean,
+            left: Int,
+            top: Int,
+            right: Int,
+            bottom: Int,
+        )
+    }
+
+    override fun onLayout(
+        changed: Boolean,
+        left: Int,
+        top: Int,
+        right: Int,
+        bottom: Int,
+    ) {
+        delegate?.onLayoutCallback(changed, left, top, right, bottom)
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/ScreenContentWrapperManager.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.RNSScreenContentWrapperManagerDelegate
+import com.facebook.react.viewmanagers.RNSScreenContentWrapperManagerInterface
+
+@ReactModule(name = ScreenContentWrapperManager.REACT_CLASS)
+class ScreenContentWrapperManager :
+    ViewGroupManager<ScreenContentWrapper>(),
+    RNSScreenContentWrapperManagerInterface<ScreenContentWrapper> {
+    private val delegate: ViewManagerDelegate<ScreenContentWrapper> = RNSScreenContentWrapperManagerDelegate(this)
+
+    companion object {
+        const val REACT_CLASS = "RNSScreenContentWrapper"
+    }
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(reactContext: ThemedReactContext): ScreenContentWrapper = ScreenContentWrapper(reactContext)
+
+    override fun getDelegate(): ViewManagerDelegate<ScreenContentWrapper> = delegate
+}

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

@@ -2,12 +2,16 @@ package com.swmansion.rnscreens
 
 interface ScreenEventDispatcher {
     fun canDispatchLifecycleEvent(event: ScreenFragment.ScreenLifecycleEvent): Boolean
+
     fun updateLastEventDispatched(event: ScreenFragment.ScreenLifecycleEvent)
 
     /**
      * Dispatches given screen lifecycle event to JS using screen from given fragment `fragmentWrapper`
      */
-    fun dispatchLifecycleEvent(event: ScreenFragment.ScreenLifecycleEvent, fragmentWrapper: ScreenFragmentWrapper)
+    fun dispatchLifecycleEvent(
+        event: ScreenFragment.ScreenLifecycleEvent,
+        fragmentWrapper: ScreenFragmentWrapper,
+    )
 
     /**
      * Dispatches given screen lifecycle event from all non-empty child containers to JS
@@ -15,7 +19,11 @@ interface ScreenEventDispatcher {
     fun dispatchLifecycleEventInChildContainers(event: ScreenFragment.ScreenLifecycleEvent)
 
     fun dispatchHeaderBackButtonClickedEvent()
-    fun dispatchTransitionProgressEvent(alpha: Float, closing: Boolean)
+
+    fun dispatchTransitionProgressEvent(
+        alpha: Float,
+        closing: Boolean,
+    )
 
     // Concrete dispatchers
 }