react-native-screens 4.21.0 → 4.22.0

package/android/src/main/java/com/swmansion/rnscreens/ext/ViewExt.kt

@@ -3,6 +3,8 @@ package com.swmansion.rnscreens.ext
 import android.graphics.drawable.ColorDrawable
 import android.view.View
 import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.findFragment
 
 internal fun View.parentAsView() = this.parent as? View
 
@@ -37,3 +39,10 @@ internal fun View.maybeBgColor(): Int? {
 }
 
 internal fun View.asViewGroupOrNull(): ViewGroup? = this as? ViewGroup
+
+internal fun View.findFragmentOrNull(): Fragment? =
+    try {
+        this.findFragment()
+    } catch (_: IllegalStateException) {
+        null
+    }

package/android/src/main/java/com/swmansion/rnscreens/gamma/stack/host/FragmentOperation.kt

@@ -0,0 +1,69 @@
+package com.swmansion.rnscreens.gamma.stack.host
+
+import androidx.fragment.app.FragmentManager
+import com.swmansion.rnscreens.gamma.stack.screen.StackScreenFragment
+
+internal sealed class FragmentOperation {
+    internal abstract fun execute(
+        fragmentManager: FragmentManager,
+        executor: FragmentOperationExecutor,
+    )
+}
+
+internal class AddOp(
+    val fragment: StackScreenFragment,
+    val containerViewId: Int,
+    val addToBackStack: Boolean,
+    val allowStateLoss: Boolean = true,
+) : FragmentOperation() {
+    override fun execute(
+        fragmentManager: FragmentManager,
+        executor: FragmentOperationExecutor,
+    ) {
+        executor.executeAddOp(fragmentManager, this)
+    }
+}
+
+internal class PopBackStackOp(
+    val fragment: StackScreenFragment,
+) : FragmentOperation() {
+    override fun execute(
+        fragmentManager: FragmentManager,
+        executor: FragmentOperationExecutor,
+    ) {
+        executor.executePopBackStackOp(fragmentManager, this)
+    }
+}
+
+internal class RemoveOp(
+    val fragment: StackScreenFragment,
+    val allowStateLoss: Boolean = true,
+    val flushSync: Boolean = false,
+) : FragmentOperation() {
+    override fun execute(
+        fragmentManager: FragmentManager,
+        executor: FragmentOperationExecutor,
+    ) {
+        executor.executeRemoveOp(fragmentManager, this)
+    }
+}
+
+internal class FlushNowOp : FragmentOperation() {
+    override fun execute(
+        fragmentManager: FragmentManager,
+        executor: FragmentOperationExecutor,
+    ) {
+        executor.executeFlushOp(fragmentManager, this)
+    }
+}
+
+internal class SetPrimaryNavFragmentOp(
+    val fragment: StackScreenFragment,
+) : FragmentOperation() {
+    override fun execute(
+        fragmentManager: FragmentManager,
+        executor: FragmentOperationExecutor,
+    ) {
+        executor.executeSetPrimaryNavFragmentOp(fragmentManager, this)
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/stack/host/FragmentOperationExecutor.kt

@@ -0,0 +1,82 @@
+package com.swmansion.rnscreens.gamma.stack.host
+
+import androidx.fragment.app.FragmentManager
+import androidx.fragment.app.FragmentTransaction
+import com.swmansion.rnscreens.gamma.helpers.createTransactionWithReordering
+
+internal class FragmentOperationExecutor {
+    internal fun executeOperations(
+        fragmentManager: FragmentManager,
+        ops: List<FragmentOperation>,
+        flushSync: Boolean = false
+    ) {
+        ops.forEach { it.execute(fragmentManager, this) }
+
+        if (flushSync) {
+            fragmentManager.executePendingTransactions()
+        }
+    }
+
+    internal fun executeAddOp(fragmentManager: FragmentManager, op: AddOp) {
+        fragmentManager.createTransactionWithReordering().let { tx ->
+            tx.add(op.containerViewId, op.fragment)
+            if (op.addToBackStack) {
+                tx.addToBackStack(op.fragment.stackScreen.screenKey)
+            }
+            commitTransaction(tx, op.allowStateLoss)
+        }
+    }
+
+    internal fun executePopBackStackOp(fragmentManager: FragmentManager, op: PopBackStackOp) {
+        fragmentManager.popBackStack(
+            op.fragment.stackScreen.screenKey,
+            FragmentManager.POP_BACK_STACK_INCLUSIVE
+        )
+    }
+
+    internal fun executeRemoveOp(fragmentManager: FragmentManager, op: RemoveOp) {
+        fragmentManager.createTransactionWithReordering().let { tx ->
+            tx.remove(op.fragment)
+            commitTransaction(tx, op.allowStateLoss, op.flushSync)
+        }
+    }
+
+    internal fun executeFlushOp(fragmentManager: FragmentManager, op: FlushNowOp) {
+        fragmentManager.executePendingTransactions()
+    }
+
+    internal fun executeSetPrimaryNavFragmentOp(fragmentManager: FragmentManager, op: SetPrimaryNavFragmentOp) {
+        fragmentManager.createTransactionWithReordering().let { tx ->
+            tx.setPrimaryNavigationFragment(op.fragment)
+            commitTransaction(tx, allowStateLoss = true, flushSync = false)
+        }
+    }
+
+    private fun commitTransaction(
+        tx: FragmentTransaction,
+        allowStateLoss: Boolean,
+        flushSync: Boolean = false
+    ) {
+        if (flushSync) {
+            commitSync(tx, allowStateLoss)
+        } else {
+            commitAsync(tx, allowStateLoss)
+        }
+    }
+
+    private fun commitAsync(tx: FragmentTransaction, allowStateLoss: Boolean) {
+        if (allowStateLoss) {
+            tx.commitAllowingStateLoss()
+        } else {
+            tx.commit()
+        }
+    }
+
+    private fun commitSync(tx: FragmentTransaction, allowStateLoss: Boolean) {
+        if (allowStateLoss) {
+            tx.commitNowAllowingStateLoss()
+        } else {
+            tx.commitNow()
+        }
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/stack/host/StackContainer.kt

@@ -2,11 +2,12 @@ package com.swmansion.rnscreens.gamma.stack.host
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.util.Log
 import androidx.coordinatorlayout.widget.CoordinatorLayout
+import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentManager
 import com.swmansion.rnscreens.gamma.helpers.FragmentManagerHelper
 import com.swmansion.rnscreens.gamma.helpers.ViewIdGenerator
-import com.swmansion.rnscreens.gamma.helpers.createTransactionWithReordering
 import com.swmansion.rnscreens.gamma.stack.screen.StackScreen
 import com.swmansion.rnscreens.gamma.stack.screen.StackScreenFragment
 import com.swmansion.rnscreens.utils.RNSLog
@@ -16,16 +17,27 @@ import java.lang.ref.WeakReference
 internal class StackContainer(
     context: Context,
     private val delegate: WeakReference<StackContainerDelegate>,
-) : CoordinatorLayout(context) {
+) : CoordinatorLayout(context),
+    FragmentManager.OnBackStackChangedListener {
     private var fragmentManager: FragmentManager? = null
 
-    private val stackScreenFragments: MutableList<StackScreenFragment> = arrayListOf()
+    private fun requireFragmentManager(): FragmentManager =
+        checkNotNull(fragmentManager) { "[RNScreens] Attempt to use nullish FragmentManager" }
+
+    /**
+     * Describes most up-to-date view of the stack. It might be different from
+     * state kept by FragmentManager as this data structure is updated immediately,
+     * while operations on fragment manager are scheduled.
+     */
+    private val stackModel: MutableList<StackScreenFragment> = arrayListOf()
 
     private val pendingPopOperations: MutableList<PopOperation> = arrayListOf()
     private val pendingPushOperations: MutableList<PushOperation> = arrayListOf()
     private val hasPendingOperations: Boolean
         get() = pendingPushOperations.isNotEmpty() || pendingPopOperations.isNotEmpty()
 
+    private val fragmentOpExecutor: FragmentOperationExecutor = FragmentOperationExecutor()
+
     init {
         id = ViewIdGenerator.generateViewId()
     }
@@ -34,16 +46,28 @@ internal class StackContainer(
         RNSLog.d(TAG, "StackContainer [$id] attached to window")
         super.onAttachedToWindow()
 
-        fragmentManager =
-            checkNotNull(FragmentManagerHelper.findFragmentManagerForView(this)) {
-                "[RNScreens] Nullish fragment manager - can't run container operations"
-            }
+        setupFragmentManger()
 
         // We run container update to handle any pending updates requested before container was
         // attached to window.
         performContainerUpdateIfNeeded()
     }
 
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        requireFragmentManager().removeOnBackStackChangedListener(this)
+        fragmentManager = null
+    }
+
+    internal fun setupFragmentManger() {
+        fragmentManager =
+            checkNotNull(FragmentManagerHelper.findFragmentManagerForView(this)) {
+                "[RNScreens] Nullish fragment manager - can't run container operations"
+            }.also {
+                it.addOnBackStackChangedListener(this)
+            }
+    }
+
     /**
      * Call this function to trigger container update
      */
@@ -52,9 +76,7 @@ internal class StackContainer(
         // the call because we don't have valid fragmentManager yet.
         // Update will be eventually executed in onAttachedToWindow().
         if (hasPendingOperations && isAttachedToWindow) {
-            val fragmentManager =
-                checkNotNull(fragmentManager) { "[RNScreens] Fragment manager was null during stack container update" }
-            performOperations(fragmentManager)
+            performOperations(requireFragmentManager())
         }
     }
 
@@ -67,59 +89,107 @@ internal class StackContainer(
     }
 
     private fun performOperations(fragmentManager: FragmentManager) {
-        pendingPopOperations.forEach { performPopOperation(fragmentManager, it) }
-        pendingPushOperations.forEach { performPushOperation(fragmentManager, it) }
+        val fragmentOps = applyOperationsAndComputeFragmentManagerOperations()
+        fragmentOpExecutor.executeOperations(fragmentManager, fragmentOps, flushSync = false)
 
-        pendingPopOperations.clear()
-        pendingPushOperations.clear()
+        dumpStackModel()
     }
 
-    private fun performPushOperation(
-        fragmentManager: FragmentManager,
-        operation: PushOperation,
-    ) {
-        val transaction = fragmentManager.createTransactionWithReordering()
+    private fun applyOperationsAndComputeFragmentManagerOperations(): List<FragmentOperation> {
+        val fragmentOps = mutableListOf<FragmentOperation>()
 
-        val associatedFragment = StackScreenFragment(WeakReference(this), operation.screen)
-        stackScreenFragments.add(associatedFragment)
+        // Handle pop operations first.
+        // We don't care about pop/push duplicates, as long as we don't let the main loop progress
+        // before we commit all the transactions, FragmentManager will handle that for us.
 
-        transaction.add(this.id, associatedFragment)
+        pendingPopOperations.forEach { operation ->
+            val fragment =
+                checkNotNull(stackModel.find { it.stackScreen === operation.screen }) {
+                    "[RNScreens] Unable to find a fragment to pop"
+                }
 
-        // Don't add root screen to back stack to handle exiting from app.
-        if (fragmentManager.fragments.isNotEmpty()) {
-            transaction.addToBackStack(operation.screen.screenKey)
-        }
+            check(stackModel.size > 1) {
+                "[RNScreens] Attempt to pop last screen from the stack"
+            }
 
-        transaction.commitAllowingStateLoss()
-    }
+            fragmentOps.add(PopBackStackOp(fragment))
 
-    private fun performPopOperation(
-        fragmentManager: FragmentManager,
-        operation: PopOperation,
-    ) {
-        val associatedFragment = stackScreenFragments.find { it.stackScreen === operation.screen }
-        require(associatedFragment != null) {
-            "[RNScreens] Unable to find a fragment to pop."
+            check(stackModel.removeAt(stackModel.lastIndex) === fragment) {
+                "[RNScreens] Attempt to pop non-top screen"
+            }
         }
 
-        val backStackEntryCount = fragmentManager.backStackEntryCount
-        if (backStackEntryCount > 0) {
-            fragmentManager.popBackStack(
-                operation.screen.screenKey,
-                FragmentManager.POP_BACK_STACK_INCLUSIVE,
+        pendingPushOperations.forEach { operation ->
+            val newFragment = createFragmentForScreen(operation.screen)
+            fragmentOps.add(
+                AddOp(
+                    newFragment,
+                    containerViewId = this.id,
+                    addToBackStack = stackModel.isNotEmpty(),
+                ),
             )
-        } else {
-            // When fast refresh is used on root screen, we need to remove the screen manually.
-            val transaction = fragmentManager.createTransactionWithReordering()
-            transaction.remove(associatedFragment)
-            transaction.commitNowAllowingStateLoss()
+            stackModel.add(newFragment)
         }
 
-        stackScreenFragments.remove(associatedFragment)
+        check(stackModel.isNotEmpty()) { "[RNScreens] Stack should never be empty after updates" }
+
+        // Top fragment is the primary navigation fragment.
+        fragmentOps.add(SetPrimaryNavFragmentOp(stackModel.last()))
+
+        pendingPopOperations.clear()
+        pendingPushOperations.clear()
+
+        return fragmentOps
+    }
+
+    private fun onNativeFragmentPop(fragment: StackScreenFragment) {
+        Log.d(TAG, "StackContainer [$id] natively removed fragment ${fragment.stackScreen.screenKey}")
+        require(stackModel.remove(fragment)) { "[RNScreens] onNativeFragmentPop must be called with the fragment present in stack model" }
+        check(stackModel.isNotEmpty()) { "[RNScreens] Stack model should not be empty after a native pop" }
+
+        val fragmentManager = requireFragmentManager()
+        if (fragmentManager.primaryNavigationFragment === fragment) {
+            // We need to update the primary navigation fragment, otherwise the fragment manager
+            // will have invalid state, pointing to the dismissed fragment.
+            fragmentOpExecutor.executeOperations(
+                fragmentManager,
+                listOf(SetPrimaryNavFragmentOp(stackModel.last())),
+            )
+        }
     }
 
-    internal fun onFragmentDestroyView(fragment: StackScreenFragment) {
-        delegate.get()?.onScreenDismiss(fragment.stackScreen)
+    private fun dumpStackModel() {
+        Log.d(TAG, "StackContainer [$id] MODEL BEGIN")
+        stackModel.forEach {
+            Log.d(TAG, "${it.stackScreen.screenKey}")
+        }
+    }
+
+    private fun createFragmentForScreen(screen: StackScreen): StackScreenFragment =
+        StackScreenFragment(screen).also {
+            Log.d(TAG, "Created Fragment $it for screen ${screen.screenKey}")
+        }
+
+    // This is called after special effects (animations) are dispatched
+    override fun onBackStackChanged() = Unit
+
+    // This is called before the special effects (animations) are dispatched, however mid transaction!
+    // Therefore make sure to not execute any action that might cause synchronous transaction synchronously
+    // from this callback.
+    override fun onBackStackChangeCommitted(
+        fragment: Fragment,
+        pop: Boolean,
+    ) {
+        if (fragment !is StackScreenFragment) {
+            Log.w(TAG, "[RNScreens] Unexpected type of fragment: ${fragment.javaClass.simpleName}")
+            return
+        }
+        if (pop) {
+            delegate.get()?.onScreenDismiss(fragment.stackScreen)
+            if (stackModel.contains(fragment)) {
+                onNativeFragmentPop(fragment)
+            }
+        }
     }
 
     companion object {

package/android/src/main/java/com/swmansion/rnscreens/gamma/stack/host/StackHost.kt

@@ -1,6 +1,7 @@
 package com.swmansion.rnscreens.gamma.stack.host
 
 import android.annotation.SuppressLint
+import android.util.Log
 import android.view.ViewGroup
 import com.facebook.react.bridge.UIManager
 import com.facebook.react.bridge.UIManagerListener
@@ -75,6 +76,8 @@ class StackHost(
         if (stackScreen.activityMode == StackScreen.ActivityMode.ATTACHED && !stackScreen.isNativelyDismissed) {
             // This shouldn't happen in typical scenarios but it can happen with fast-refresh.
             containerUpdateCoordinator.addPopOperation(stackScreen)
+        } else {
+            Log.d(TAG, "Ignoring pop operation of ${stackScreen.screenKey}, already not attached or natively dismissed")
         }
     }
 
@@ -85,7 +88,11 @@ class StackHost(
         }
     }
 
-    override fun onScreenDismiss(stackScreen: StackScreen) = Unit
+    override fun onScreenDismiss(stackScreen: StackScreen) {
+        if (stackScreen.activityMode == StackScreen.ActivityMode.ATTACHED) {
+            stackScreen.isNativelyDismissed = true
+        }
+    }
 
     override fun onMeasure(
         widthMeasureSpec: Int,

package/android/src/main/java/com/swmansion/rnscreens/gamma/stack/screen/StackScreen.kt

@@ -2,8 +2,11 @@ package com.swmansion.rnscreens.gamma.stack.screen
 
 import android.annotation.SuppressLint
 import android.view.ViewGroup
+import androidx.fragment.app.Fragment
 import androidx.lifecycle.LifecycleOwner
 import com.facebook.react.uimanager.ThemedReactContext
+import com.swmansion.rnscreens.ext.findFragmentOrNull
+import com.swmansion.rnscreens.gamma.common.FragmentProviding
 import com.swmansion.rnscreens.gamma.stack.host.StackHost
 import java.lang.ref.WeakReference
 import kotlin.properties.Delegates
@@ -11,7 +14,7 @@ import kotlin.properties.Delegates
 @SuppressLint("ViewConstructor") // should never be restored
 class StackScreen(
     private val reactContext: ThemedReactContext,
-) : ViewGroup(reactContext) {
+) : ViewGroup(reactContext), FragmentProviding {
     enum class ActivityMode {
         DETACHED,
         ATTACHED,
@@ -65,4 +68,8 @@ class StackScreen(
         r: Int,
         b: Int,
     ) = Unit
+
+    override fun getAssociatedFragment(): Fragment? = this.findFragmentOrNull()?.also {
+        check(it is StackScreenFragment) { "[RNScreens] Unexpected fragment type: ${it.javaClass.simpleName}"}
+    }
 }

package/android/src/main/java/com/swmansion/rnscreens/gamma/stack/screen/StackScreenFragment.kt

@@ -1,15 +1,13 @@
 package com.swmansion.rnscreens.gamma.stack.screen
 
 import android.os.Bundle
+import android.util.Log
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import androidx.fragment.app.Fragment
-import com.swmansion.rnscreens.gamma.stack.host.StackContainer
-import java.lang.ref.WeakReference
 
 internal class StackScreenFragment(
-    private val stackContainer: WeakReference<StackContainer>,
     internal val stackScreen: StackScreen,
 ) : Fragment() {
     private var screenLifecycleEventEmitter: StackScreenAppearanceEventsEmitter? = null
@@ -30,8 +28,12 @@ internal class StackScreenFragment(
 
     override fun onDestroyView() {
         super.onDestroyView()
-        stackScreen.onDismiss()
-        stackContainer.get()?.onFragmentDestroyView(this)
         screenLifecycleEventEmitter = null
     }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        Log.i("StackScreenFragment", "onDestroy")
+        stackScreen.onDismiss()
+    }
 }

package/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/TabsHost.kt

@@ -382,8 +382,9 @@ class TabsHost(
     private fun updateSelectedTab() {
         val newFocusedTab = currentFocusedTab
 
-        check(requireFragmentManager.fragments.size <= 1) { "[RNScreens] There can be only a single focused tab" }
-        val oldFocusedTab = requireFragmentManager.fragments.firstOrNull()
+        val tabFragments = requireFragmentManager.fragments.filterIsInstance<TabScreenFragment>()
+        check(tabFragments.size <= 1) { "[RNScreens] There can be only a single focused tab" }
+        val oldFocusedTab = tabFragments.firstOrNull()
 
         if (newFocusedTab === oldFocusedTab) {
             return

package/ios/RNSScreen.mm

@@ -2097,6 +2097,9 @@ Class<RCTComponentViewProtocol> RNSScreenCls(void)
   if ([vc isKindOfClass:[RNSScreen class]]) {
     return ((RNSScreen *)vc).screenView.screenOrientation;
   }
+  if ([[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPad) {
+    return UIInterfaceOrientationMaskAll;
+  }
   return UIInterfaceOrientationMaskAllButUpsideDown;
 }
 

package/lib/typescript/components/helpers/prepareHeaderBarButtonItems.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prepareHeaderBarButtonItems.d.ts","sourceRoot":"","sources":["../../../../src/components/helpers/prepareHeaderBarButtonItems.ts"],"names":[],"mappings":"AACA,OAAO,EACL,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAkCpC,eAAO,MAAM,2BAA2B,GACtC,gBAAgB,mBAAmB,EAAE,EACrC,MAAM,MAAM,GAAG,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAoD47yC,CAAC;;uBAAwG,CAAC;wBAA+B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAD7lzC,CAAC"}
+{"version":3,"file":"prepareHeaderBarButtonItems.d.ts","sourceRoot":"","sources":["../../../../src/components/helpers/prepareHeaderBarButtonItems.ts"],"names":[],"mappings":"AACA,OAAO,EACL,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAkCpC,eAAO,MAAM,2BAA2B,GACtC,gBAAgB,mBAAmB,EAAE,EACrC,MAAM,MAAM,GAAG,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAoD89yC,CAAC;;uBAAwG,CAAC;wBAA+B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAD/nzC,CAAC"}

package/lib/typescript/types.d.ts

@@ -287,7 +287,7 @@ export interface ScreenProps extends ViewProps {
     /**
      * In which orientation should the screen appear.
      * The following values are currently supported:
-     * - "default" - resolves to "all" without "portrait_down" on iOS. On Android, this lets the system decide the best orientation.
+     * - "default" - resolves to "all" without "portrait_down" on iPhone devices, "all" on iPad devices. On Android, this lets the system decide the best orientation.
      * - "all" – all orientations are permitted
      * - "portrait" – portrait orientations are permitted
      * - "portrait_up" – right-side portrait orientation is permitted

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-screens",
-  "version": "4.21.0",
+  "version": "4.22.0",
   "description": "Native navigation primitives for your React Native app.",
   "scripts": {
     "submodules": "git submodule update --init --recursive && (cd react-navigation && yarn && yarn build && cd ../)",

package/src/types.tsx

@@ -378,7 +378,7 @@ export interface ScreenProps extends ViewProps {
   /**
    * In which orientation should the screen appear.
    * The following values are currently supported:
-   * - "default" - resolves to "all" without "portrait_down" on iOS. On Android, this lets the system decide the best orientation.
+   * - "default" - resolves to "all" without "portrait_down" on iPhone devices, "all" on iPad devices. On Android, this lets the system decide the best orientation.
    * - "all" – all orientations are permitted
    * - "portrait" – portrait orientations are permitted
    * - "portrait_up" – right-side portrait orientation is permitted