@amazon-devices/react-native-screens 2.0.1758683737

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

@@ -0,0 +1,372 @@
+package com.swmansion.rnscreens
+
+import android.content.Context
+import android.content.ContextWrapper
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewParent
+import android.view.inputmethod.InputMethodManager
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.FragmentManager
+import androidx.fragment.app.FragmentTransaction
+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.swmansion.rnscreens.Screen.ActivityState
+
+open class ScreenContainer(context: Context?) : ViewGroup(context) {
+    @JvmField
+    protected val mScreenFragments = 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)
+        }
+    }
+    private var mParentScreenFragment: ScreenFragmentWrapper? = null
+
+    override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+        var i = 0
+        val size = childCount
+        while (i < size) {
+            getChildAt(i).layout(0, 0, width, height)
+            i++
+        }
+    }
+
+    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
+        // 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
+        // the keyboard open).
+        if (view === focusedChild) {
+            (context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager)
+                .hideSoftInputFromWindow(windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
+        }
+        super.removeView(view)
+    }
+
+    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
+            // 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()
+                .postFrameCallback(
+                    ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE, mLayoutCallback
+                )
+        }
+    }
+
+    val isNested: Boolean
+        get() = mParentScreenFragment != null
+
+    fun notifyChildUpdate() {
+        performUpdatesNow()
+    }
+
+    protected open fun adapt(screen: Screen): ScreenFragmentWrapper = ScreenFragment(screen)
+
+    fun addScreen(screen: Screen, index: Int) {
+        val fragment = adapt(screen)
+        screen.fragmentWrapper = fragment
+        mScreenFragments.add(index, fragment)
+        screen.container = this
+        onScreenChanged()
+    }
+
+    open fun removeScreenAt(index: Int) {
+        mScreenFragments[index].screen.container = null
+        mScreenFragments.removeAt(index)
+        onScreenChanged()
+    }
+
+    open fun removeAllScreens() {
+        for (screenFragment in mScreenFragments) {
+            screenFragment.screen.container = null
+        }
+        mScreenFragments.clear()
+        onScreenChanged()
+    }
+
+    val screenCount: Int
+        get() = mScreenFragments.size
+
+    fun getScreenAt(index: Int): Screen = mScreenFragments[index].screen
+
+    fun getScreenFragmentWrapperAt(index: Int): ScreenFragmentWrapper = mScreenFragments[index]
+
+    open val topScreen: Screen?
+        get() = mScreenFragments.firstOrNull { getActivityState(it) === ActivityState.ON_TOP }?.screen
+
+    private fun setFragmentManager(fm: FragmentManager) {
+        mFragmentManager = fm
+        performUpdatesNow()
+    }
+
+    private fun findFragmentManagerForReactRootView(rootView: ReactRootView): FragmentManager {
+        var context = rootView.context
+
+        // ReactRootView is expected to be initialized with the main React Activity as a context but
+        // in case of Expo the activity is wrapped in ContextWrapper and we need to unwrap it
+        while (context !is FragmentActivity && context is ContextWrapper) {
+            context = context.baseContext
+        }
+
+        check(context is FragmentActivity) {
+            "In order to use RNScreens components your app's activity need to extend ReactActivity"
+        }
+
+        // In case React Native is loaded on a Fragment (not directly in activity) we need to find
+        // fragment manager whose fragment's view is ReactRootView. As of now, we detect such case by
+        // checking whether any fragments are attached to activity which hosts ReactRootView.
+        // See: https://github.com/software-mansion/react-native-screens/issues/1506 on why the cases
+        // must be treated separately.
+        return if (context.supportFragmentManager.fragments.isEmpty()) {
+            // We are in standard React Native application w/o custom native navigation based on fragments.
+            context.supportFragmentManager
+        } else {
+            // We are in some custom setup & we want to use the closest fragment manager in hierarchy.
+            // `findFragment` method throws IllegalStateException when it fails to resolve appropriate
+            // fragment. It might happen when e.g. React Native is loaded directly in Activity
+            // but some custom fragments are still used. Such use case seems highly unlikely
+            // so, as for now we fallback to activity's FragmentManager in hope for the best.
+            try {
+                FragmentManager.findFragment<Fragment>(rootView).childFragmentManager
+            } catch (ex: IllegalStateException) {
+                context.supportFragmentManager
+            }
+        }
+    }
+
+    private fun setupFragmentManager() {
+        var parent: ViewParent = this
+        // We traverse view hierarchy up until we find screen parent or a root view
+        while (!(parent is ReactRootView || parent is Screen) &&
+            parent.parent != null
+        ) {
+            parent = parent.parent
+        }
+        // If parent is of type Screen it means we are inside a nested fragment structure.
+        // Otherwise we expect to connect directly with root view and get root fragment manager
+        if (parent is Screen) {
+            checkNotNull(
+                parent.fragmentWrapper?.let { fragmentWrapper ->
+                    mParentScreenFragment = 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
+            // order to find root view we test if parent is null. This could potentially happen also when
+            // the view is detached from the hierarchy and that test would not correctly indicate the root
+            // view. So in order to make sure we indeed reached the root we test if it is of a correct type.
+            // This allows us to provide a more descriptive error message for the aforementioned case.
+            check(parent is ReactRootView) { "ScreenContainer is not attached under ReactRootView" }
+            setFragmentManager(findFragmentManagerForReactRootView(parent))
+        }
+    }
+
+    protected fun createTransaction(): FragmentTransaction {
+        return requireNotNull(mFragmentManager) { "mFragmentManager is null when creating transaction" }
+            .beginTransaction()
+            .setReorderingAllowed(true)
+    }
+
+    private fun attachScreen(transaction: FragmentTransaction, fragment: Fragment) {
+        transaction.add(id, fragment)
+    }
+
+    private fun detachScreen(transaction: FragmentTransaction, fragment: Fragment) {
+        transaction.remove(fragment)
+    }
+
+    private fun getActivityState(screenFragmentWrapper: ScreenFragmentWrapper): ActivityState? =
+        screenFragmentWrapper.screen.activityState
+
+    open fun hasScreen(screenFragmentWrapper: ScreenFragmentWrapper?): Boolean =
+        mScreenFragments.contains(screenFragmentWrapper)
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        mIsAttached = true
+        setupFragmentManager()
+    }
+
+    /** Removes fragments from fragment manager that are attached to this container  */
+    private fun removeMyFragments(fragmentManager: FragmentManager) {
+        val transaction = fragmentManager.beginTransaction()
+        var hasFragments = false
+        for (fragment in fragmentManager.fragments) {
+            if (fragment is ScreenFragment && fragment.screen.container === this) {
+                transaction.remove(fragment)
+                hasFragments = true
+            }
+        }
+
+        if (hasFragments) {
+            transaction.commitNowAllowingStateLoss()
+        }
+    }
+
+    override fun onDetachedFromWindow() {
+        // if there are pending transactions and this view is about to get detached we need to perform
+        // them here as otherwise fragment manager will crash because it won't be able to find container
+        // 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 {
+            if (!it.isDestroyed) {
+                removeMyFragments(it)
+                it.executePendingTransactions()
+            }
+        }
+
+        mParentScreenFragment?.removeChildScreenContainer(this)
+        mParentScreenFragment = null
+
+        super.onDetachedFromWindow()
+        mIsAttached = 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
+        // may choose not to remove the view despite the parent container being completely detached
+        // from the view hierarchy until the transition is over. In such a case when the container gets
+        // re-attached while the transition is ongoing, the child view would still be there and we'd
+        // attempt to re-attach it to with a misconfigured fragment. This would result in a crash. To
+        // avoid it we clear all the children here as we attach all the child fragments when the
+        // container is reattached anyways. We don't use `removeAllViews` since it does not check if the
+        // children are not already detached, which may lead to calling `onDetachedFromWindow` on them
+        // twice.
+        // We also get the size earlier, because we will be removing child views in `for` loop.
+        for (i in childCount - 1 downTo 0) {
+            removeViewAt(i)
+        }
+    }
+
+    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec)
+        for (i in 0 until childCount) {
+            getChildAt(i).measure(widthMeasureSpec, heightMeasureSpec)
+        }
+    }
+
+    private fun onScreenChanged() {
+        // we perform update in `onBeforeLayout` of `ScreensShadowNode` by adding an UIBlock
+        // which is called after updating children of the ScreenContainer.
+        // We do it there because `onUpdate` logic requires all changes of children to be already
+        // made in order to provide proper animation for fragment transition for ScreenStack
+        // and this in turn makes nested ScreenContainers detach too early and disappear
+        // 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 {
+            // 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,
+            // this code will do nothing since it will run after the UIBlock when `mNeedUpdate`
+            // will already be false.
+            performUpdates()
+        }
+    }
+
+    protected fun performUpdatesNow() {
+        // 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
+        performUpdates()
+    }
+
+    fun performUpdates() {
+        if (!mNeedUpdate || !mIsAttached || mFragmentManager == null || mFragmentManager?.isDestroyed == true) {
+            return
+        }
+        mNeedUpdate = false
+        onUpdate()
+        notifyContainerUpdate()
+    }
+
+    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) {
+                if (getActivityState(fragmentWrapper) === ActivityState.INACTIVE &&
+                    fragmentWrapper.fragment.isAdded
+                ) {
+                    detachScreen(it, fragmentWrapper.fragment)
+                }
+                orphaned.remove(fragmentWrapper.fragment)
+            }
+            if (orphaned.isNotEmpty()) {
+                val orphanedAry = orphaned.toTypedArray()
+                for (fragment in orphanedAry) {
+                    if (fragment is ScreenFragment) {
+                        if (fragment.screen.container == null) {
+                            detachScreen(it, fragment)
+                        }
+                    }
+                }
+            }
+
+            // if there is an "onTop" screen it means the transition has ended
+            val transitioning = topScreen == null
+
+            // attach newly activated screens
+            var addedBefore = false
+            val pendingFront: ArrayList<ScreenFragmentWrapper> = ArrayList()
+
+            for (fragmentWrapper in mScreenFragments) {
+                val activityState = getActivityState(fragmentWrapper)
+                if (activityState !== ActivityState.INACTIVE && !fragmentWrapper.fragment.isAdded) {
+                    addedBefore = true
+                    attachScreen(it, fragmentWrapper.fragment)
+                } else if (activityState !== ActivityState.INACTIVE && addedBefore) {
+                    // we detach the screen and then reattach it later to make it appear on front
+                    detachScreen(it, fragmentWrapper.fragment)
+                    pendingFront.add(fragmentWrapper)
+                }
+                fragmentWrapper.screen.setTransitioning(transitioning)
+            }
+
+            for (screenFragment in pendingFront) {
+                attachScreen(it, screenFragment.fragment)
+            }
+
+            it.commitNowAllowingStateLoss()
+        }
+    }
+
+    protected open fun notifyContainerUpdate() {
+        topScreen?.fragmentWrapper?.onContainerUpdate()
+    }
+}

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

@@ -0,0 +1,40 @@
+package com.swmansion.rnscreens
+
+import android.view.View
+import com.facebook.react.bridge.ReactApplicationContext
+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
+
+@ReactModule(name = ScreenContainerViewManager.REACT_CLASS)
+class ScreenContainerViewManager : ViewGroupManager<ScreenContainer>() {
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(reactContext: ThemedReactContext): ScreenContainer = ScreenContainer(reactContext)
+
+    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) {
+        parent.removeScreenAt(index)
+    }
+
+    override fun removeAllViews(parent: ScreenContainer) {
+        parent.removeAllScreens()
+    }
+
+    override fun getChildCount(parent: ScreenContainer): Int = parent.screenCount
+
+    override fun getChildAt(parent: ScreenContainer, index: Int): View = parent.getScreenAt(index)
+
+    override fun createShadowNodeInstance(context: ReactApplicationContext): LayoutShadowNode = ScreensShadowNode(context)
+
+    override fun needsCustomLayoutForChildren(): Boolean = true
+
+    companion object {
+        const val REACT_CLASS = "RNSScreenContainer"
+    }
+}

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

@@ -0,0 +1,21 @@
+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)
+
+    /**
+     * Dispatches given screen lifecycle event from all non-empty child containers to JS
+     */
+    fun dispatchLifecycleEventInChildContainers(event: ScreenFragment.ScreenLifecycleEvent)
+
+    fun dispatchHeaderBackButtonClickedEvent()
+    fun dispatchTransitionProgressEvent(alpha: Float, closing: Boolean)
+
+    // Concrete dispatchers
+}