react-native-screens 5.0.0-alpha.2 → 5.0.0-alpha.4

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

@@ -2,18 +2,25 @@ package com.swmansion.rnscreens.stack.host
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.content.res.Configuration
 import android.util.Log
 import android.view.ViewGroup
 import android.widget.FrameLayout
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentManager
+import com.swmansion.rnscreens.common.colorscheme.ColorScheme
+import com.swmansion.rnscreens.common.colorscheme.ColorSchemeCoordinator
+import com.swmansion.rnscreens.common.colorscheme.ColorSchemeListener
+import com.swmansion.rnscreens.common.colorscheme.ColorSchemeProviding
 import com.swmansion.rnscreens.common.container.Container
+import com.swmansion.rnscreens.common.container.ContainerItem
 import com.swmansion.rnscreens.common.container.ParentContainerItemRegistry
 import com.swmansion.rnscreens.ext.isMeasured
-import com.swmansion.rnscreens.helpers.FragmentManagerHelper
 import com.swmansion.rnscreens.helpers.ViewIdGenerator
+import com.swmansion.rnscreens.stack.header.StackHeaderBackPressHandler
 import com.swmansion.rnscreens.stack.screen.StackScreen
 import com.swmansion.rnscreens.stack.screen.StackScreenFragment
+import com.swmansion.rnscreens.stack.screen.StackScreenFragmentDelegate
 import com.swmansion.rnscreens.utils.RNSLog
 import java.lang.ref.WeakReference
 
@@ -23,7 +30,11 @@ internal class StackContainer(
     private val delegate: WeakReference<StackContainerDelegate>,
 ) : FrameLayout(context),
     Container,
-    FragmentManager.OnBackStackChangedListener {
+    FragmentManager.OnBackStackChangedListener,
+    ColorSchemeProviding,
+    StackHeaderBackPressHandler,
+    StackScreenFragmentDelegate,
+    StackUpdateBatchStateProviding {
     private var fragmentManager: FragmentManager? = null
 
     private fun requireFragmentManager(): FragmentManager =
@@ -51,6 +62,20 @@ internal class StackContainer(
     private val fragmentOpExecutor: FragmentOperationExecutor = FragmentOperationExecutor()
     private val fragmentOps: MutableList<FragmentOperation> = arrayListOf()
 
+    // region Color Scheme
+
+    private val colorSchemeCoordinator = ColorSchemeCoordinator()
+
+    internal var colorScheme: ColorScheme by colorSchemeCoordinator::colorScheme
+
+    override fun getResolvedUiNightMode() = colorSchemeCoordinator.getResolvedUiNightMode()
+
+    override fun addColorSchemeListener(listener: ColorSchemeListener) = colorSchemeCoordinator.addColorSchemeListener(listener)
+
+    override fun removeColorSchemeListener(listener: ColorSchemeListener) = colorSchemeCoordinator.removeColorSchemeListener(listener)
+
+    // endregion
+
     init {
         id = ViewIdGenerator.generateViewId()
     }
@@ -60,7 +85,11 @@ internal class StackContainer(
         super.onAttachedToWindow()
 
         parentContainerRegistry.attach(this)
-        setupFragmentManger()
+        setupFragmentManager()
+
+        // StackContainer only provides container-level color scheme configuration for its screens
+        // but doesn't use any color scheme-dependent views, so we don't need the callback.
+        colorSchemeCoordinator.setup(this, null)
 
         // Following line works with a couple of assumptions.
         // First, that this view is laid out by our parent view, which is a component view.
@@ -81,27 +110,60 @@ internal class StackContainer(
         requireFragmentManager().removeOnBackStackChangedListener(this)
         fragmentManager = null
         parentContainerRegistry.detach(this)
+        colorSchemeCoordinator.teardown()
     }
 
-    internal fun setupFragmentManger() {
+    override fun onConfigurationChanged(newConfig: Configuration?) {
+        super.onConfigurationChanged(newConfig)
+        colorSchemeCoordinator.onConfigurationChanged(newConfig)
+    }
+
+    override fun onFragmentConfigurationChanged(config: Configuration) = onConfigurationChanged(config)
+
+    internal fun setupFragmentManager() {
         fragmentManager =
-            checkNotNull(FragmentManagerHelper.findFragmentManagerForView(this)) {
-                "[RNScreens] Nullish fragment manager - can't run container operations"
-            }.also {
+            checkNotNull(delegate.get()) {
+                "[RNScreens] StackContainer has no delegate to resolve the fragment manager from"
+            }.resolveFragmentManager().also {
                 it.addOnBackStackChangedListener(this)
             }
     }
 
+    // region Update batch
+
+    override var isUpdatePending: Boolean = false
+        private set
+
+    /**
+     * Announces that more updates are coming. Header updates raised until [endUpdateBatch]
+     * are held and applied together with the navigation operations of the batch.
+     */
+    internal fun beginUpdateBatch() {
+        isUpdatePending = true
+    }
+
+    internal fun endUpdateBatch() {
+        isUpdatePending = false
+        performContainerUpdateIfNeeded()
+    }
+
+    // endregion
+
     /**
-     * Call this function to trigger container update
+     * Applies pending navigation operations and then pending header updates of the screens
+     * remaining in the stack.
      */
     internal fun performContainerUpdateIfNeeded() {
         // If container update is requested before container is attached to window, we ignore
         // the call because we don't have valid fragmentManager yet.
         // Update will be eventually executed in onAttachedToWindow().
-        if (hasPendingOperations && isAttachedToWindow) {
+        if (!isAttachedToWindow) {
+            return
+        }
+        if (hasPendingOperations) {
             performOperations(requireFragmentManager())
         }
+        stackModel.forEach { it.flushPendingHeaderUpdates() }
     }
 
     internal fun enqueuePushOperation(stackScreen: StackScreen) {
@@ -164,13 +226,15 @@ internal class StackContainer(
         }
 
         pendingPushOperations.forEach { operation ->
-            val newFragment = createFragmentForScreen(operation.screen, canNavigateBack = stackModel.isNotEmpty())
+            val newFragment =
+                createFragmentForScreen(operation.screen, canNavigateBack = stackModel.isNotEmpty())
 
             fragmentOps.add(
                 AddAndSetAsPrimaryOp(
                     newFragment,
                     containerViewId = this.id,
                     addToBackStack = stackModel.isNotEmpty(),
+                    coveredFragment = stackModel.lastOrNull(),
                 ),
             )
             stackModel.add(newFragment)
@@ -195,9 +259,9 @@ internal class StackContainer(
     }
 
     private fun dumpStackModel() {
-        Log.d(TAG, "StackContainer [$id] MODEL BEGIN")
+        RNSLog.d(TAG, "StackContainer [$id] MODEL BEGIN")
         stackModel.forEach {
-            Log.d(TAG, "${it.stackScreen.screenKey}")
+            RNSLog.d(TAG, "${it.stackScreen.screenKey}")
         }
     }
 
@@ -205,21 +269,27 @@ internal class StackContainer(
         screen: StackScreen,
         canNavigateBack: Boolean,
     ): StackScreenFragment =
-        StackScreenFragment(screen, canNavigateBack).also {
-            Log.d(TAG, "Created Fragment $it for screen ${screen.screenKey}")
+        StackScreenFragment(
+            screen,
+            canNavigateBack,
+            WeakReference(this),
+            backPressHandler = WeakReference(this),
+            updateBatchStateProvider = WeakReference(this),
+            colorSchemeProvider = WeakReference(this),
+        ).also {
+            RNSLog.d(TAG, "Created Fragment $it for screen ${screen.screenKey}")
         }
 
     private fun updateTopFragment() {
-        // We try to handle situation where other fragments might be present.
-        val fragmentManager = requireFragmentManager()
-        val fragments = fragmentManager.fragments.filterIsInstance<StackScreenFragment>()
-        check(fragments.isNotEmpty()) { "[RNScreens] Empty fragment manager while attempting to update top fragment" }
-        fragments.forEach { it.onResignTopFragment() }
-        fragments.last().onBecomeTopFragment()
+        // Covered fragments are detached, so FragmentManager's added list holds only the top
+        // fragment - the model is the only place all of them can be resigned from.
+        check(stackModel.isNotEmpty()) { "[RNScreens] Empty stack model while attempting to update top fragment" }
+        stackModel.forEach { it.onResignTopFragment() }
+        stackModel.last().onBecomeTopFragment()
 
         // This assumes that the updateTopFragment is called already after primary nav frag. is updated.
         // If this needs to be changed in the future, just remove this assertion.
-        check(fragmentManager.primaryNavigationFragment === fragments.last()) {
+        check(requireFragmentManager().primaryNavigationFragment === stackModel.last()) {
             "[RNScreens] Top fragment different from primary navigation fragment"
         }
     }
@@ -290,6 +360,74 @@ internal class StackContainer(
             ?.stackScreen
             ?.findContentScrollView()
 
+    // Asked when this container's whole subtree is about to be dismissed (the screen
+    // hosting this container is popped) - every item gets a vote, back-to-front, so
+    // the deepest preventing screen wins.
+    override fun wantsToPreventStackNativeDismiss(): ContainerItem? =
+        stackModel
+            .asReversed()
+            .firstNotNullOfOrNull { it.stackScreen.wantsToPreventStackNativeDismiss() }
+
+    // Pop-to-root is not implemented for the v5 stack yet - the request is forwarded to the top screen's
+    // nested container.
+    override fun requestPopToRoot(): Boolean {
+        RNSLog.w(TAG, "[RNScreens] Pop-to-root special effect is not implemented for v5 stack yet")
+        return stackModel
+            .lastOrNull()
+            ?.stackScreen
+            ?.resolveNestedContainer()
+            ?.requestPopToRoot() == true
+    }
+
+    // endregion
+
+    // region Header back button
+
+    override fun handleHeaderBackButtonPress(pressedScreen: StackScreen) {
+        val fragmentManager = fragmentManager
+        if (fragmentManager == null) {
+            Log.w(TAG, "[RNScreens] Ignoring header back button press - container is detached")
+            return
+        }
+
+        val topScreen = stackModel.lastOrNull()?.stackScreen
+        if (topScreen !== pressedScreen || stackModel.size <= 1) {
+            Log.w(
+                TAG,
+                "[RNScreens] Ignoring header back button press for non-top screen ${pressedScreen.screenKey}",
+            )
+            return
+        }
+
+        // This pop dismisses only the top screen (together with its subtree), therefore
+        // only the top item is asked - screens below the top get no vote at this level.
+        val vetoingItem = topScreen.wantsToPreventStackNativeDismiss()
+        if (vetoingItem != null) {
+            // Only a StackScreen can veto - TabsScreen has no own flag and only forwards.
+            val vetoingScreen = vetoingItem as? StackScreen
+            if (vetoingScreen != null) {
+                vetoingScreen.onNativeDismissPrevented()
+            } else {
+                Log.w(
+                    TAG,
+                    "[RNScreens] Unexpected vetoing item type: ${vetoingItem.javaClass.simpleName}",
+                )
+            }
+            return
+        }
+
+        // Mirrors FragmentManager's internal OnBackPressedCallback, which also runs
+        // popBackStackImmediate. The synchronous pop makes the top-screen guard above
+        // reliable against double taps: onBackStackChangeCommitted -> onNativeFragmentPop
+        // updates stackModel before this call returns.
+        fragmentManager.popBackStackImmediate(
+            // key MUST BE present, otherwise the navigation action will be delegated to child primary navigation
+            // fragment.
+            checkNotNull(pressedScreen.screenKey) { "[RNScreens] Screen key is required" },
+            FragmentManager.POP_BACK_STACK_INCLUSIVE,
+        )
+    }
+
     // endregion
 
     companion object {

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

@@ -1,7 +1,14 @@
 package com.swmansion.rnscreens.stack.host
 
+import androidx.fragment.app.FragmentManager
 import com.swmansion.rnscreens.stack.screen.StackScreen
 
 internal interface StackContainerDelegate {
     fun onScreenDismissCommitted(stackScreen: StackScreen)
+
+    /**
+     * Resolves the fragment manager the container should run its operations on. Called every time the container
+     * is attached to a window, as the result may differ between attachments.
+     */
+    fun resolveFragmentManager(): FragmentManager
 }

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

@@ -16,7 +16,11 @@ internal class StackContainerUpdateCoordinator {
         pendingPopOperations.add(PopOperation(stackScreen))
     }
 
-    internal fun executePendingOperationsIfNeeded(
+    /**
+     * Hands the pending operations to the container in stack order. The container applies
+     * them on its next update.
+     */
+    internal fun enqueuePendingOperations(
         container: StackContainer,
         renderedScreens: List<StackScreen>,
     ) {
@@ -35,8 +39,6 @@ internal class StackContainerUpdateCoordinator {
             .sortedBy { it.first }
             .forEach { (_, operation) -> container.enqueuePushOperation(operation.screen) }
 
-        container.performContainerUpdateIfNeeded()
-
         pendingPopOperations.clear()
         pendingPushOperations.clear()
     }

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

@@ -1,13 +1,15 @@
 package com.swmansion.rnscreens.stack.host
 
 import android.annotation.SuppressLint
-import android.util.Log
 import android.view.ViewGroup
+import androidx.fragment.app.FragmentManager
 import com.facebook.react.bridge.UIManager
 import com.facebook.react.bridge.UIManagerListener
 import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.rnscreens.common.colorscheme.ColorScheme
+import com.swmansion.rnscreens.helpers.FragmentManagerHelper
 import com.swmansion.rnscreens.helpers.getFabricUIManagerNotNull
 import com.swmansion.rnscreens.stack.screen.StackScreen
 import com.swmansion.rnscreens.utils.RNSLog
@@ -26,6 +28,8 @@ class StackHost(
     private val containerUpdateCoordinator = StackContainerUpdateCoordinator()
     private var isLayoutEnqueued = false
 
+    internal var colorScheme: ColorScheme by container::colorScheme
+
     init {
         addView(container)
 
@@ -77,7 +81,7 @@ class StackHost(
             // 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")
+            RNSLog.d(TAG, "Ignoring pop operation of ${stackScreen.screenKey}, already not attached or natively dismissed")
         }
     }
 
@@ -94,6 +98,11 @@ class StackHost(
         }
     }
 
+    override fun resolveFragmentManager(): FragmentManager =
+        checkNotNull(FragmentManagerHelper.findFragmentManagerForView(this)) {
+            "[RNScreens] Nullish fragment manager - can't run container operations"
+        }
+
     override fun onMeasure(
         widthMeasureSpec: Int,
         heightMeasureSpec: Int,
@@ -119,6 +128,16 @@ class StackHost(
         refreshLayout()
     }
 
+    // On window configuration changes ViewRootImpl calls forceLayout() recursively on every view
+    // in the hierarchy, bypassing requestLayout(). React views never lay out their children during
+    // framework traversals, so nothing would clear the force-layout flags in our subtree — and once
+    // they are set, any subsequent requestLayout() from a descendant short-circuits before reaching
+    // the override above, permanently disabling the manual pass. Schedule it from here as well.
+    override fun forceLayout() {
+        super.forceLayout()
+        refreshLayout()
+    }
+
     private fun refreshLayout() {
         if (!isLayoutEnqueued) {
             isLayoutEnqueued = true
@@ -148,14 +167,17 @@ class StackHost(
         container.layout(left, top, right, bottom)
     }
 
+    override fun willMountItems(uiManager: UIManager) {
+        container.beginUpdateBatch()
+    }
+
     override fun didMountItems(uiManager: UIManager) {
-        containerUpdateCoordinator.executePendingOperationsIfNeeded(container, renderedScreens)
+        containerUpdateCoordinator.enqueuePendingOperations(container, renderedScreens)
+        container.endUpdateBatch()
     }
 
     override fun willDispatchViewUpdates(uiManager: UIManager) = Unit
 
-    override fun willMountItems(uiManager: UIManager) = Unit
-
     override fun didDispatchMountItems(uiManager: UIManager) = Unit
 
     override fun didScheduleMountItems(uiManager: UIManager) = Unit

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

@@ -1,12 +1,14 @@
 package com.swmansion.rnscreens.stack.host
 
 import android.view.View
+import com.facebook.react.bridge.JSApplicationIllegalArgumentException
 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.RNSStackHostManagerDelegate
 import com.facebook.react.viewmanagers.RNSStackHostManagerInterface
+import com.swmansion.rnscreens.common.colorscheme.ColorScheme
 import com.swmansion.rnscreens.stack.screen.StackScreen
 
 @ReactModule(name = StackHostViewManager.REACT_CLASS)
@@ -70,6 +72,18 @@ class StackHostViewManager :
      */
     override fun needsCustomLayoutForChildren() = true
 
+    override fun setColorScheme(
+        view: StackHost,
+        value: String?,
+    ) {
+        when (value) {
+            null, "inherit" -> view.colorScheme = ColorScheme.INHERIT
+            "light" -> view.colorScheme = ColorScheme.LIGHT
+            "dark" -> view.colorScheme = ColorScheme.DARK
+            else -> throw JSApplicationIllegalArgumentException("[RNScreens] Invalid color scheme: $value.")
+        }
+    }
+
     companion object {
         const val REACT_CLASS = "RNSStackHost"
     }

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

@@ -0,0 +1,10 @@
+package com.swmansion.rnscreens.stack.host
+
+/**
+ * Tells whether the owner has begun an update batch that has not ended yet.
+ * Consumers hold their pending updates while it is `true`; the owner applies
+ * them all in one pass when the batch ends.
+ */
+internal interface StackUpdateBatchStateProviding {
+    val isUpdatePending: Boolean
+}

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

@@ -1,10 +1,10 @@
 package com.swmansion.rnscreens.stack.screen
 
-import android.util.Log
 import androidx.activity.OnBackPressedCallback
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
 import androidx.lifecycle.LifecycleOwner
+import com.swmansion.rnscreens.utils.RNSLog
 
 internal class PreventNativeDismissCallback(
     lifecycleOwner: LifecycleOwner,
@@ -31,7 +31,7 @@ internal class PreventNativeDismissCallback(
     }
 
     override fun handleOnBackPressed() {
-        Log.i("RNScreens", "PreventNativeDismissCallback called for screen ${screen.screenKey}")
+        RNSLog.i("RNScreens", "PreventNativeDismissCallback called for screen ${screen.screenKey}")
         screen.onNativeDismissPrevented()
     }
 

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

@@ -175,4 +175,8 @@ class StackScreen(
     override fun resolveNestedContainer(): Container? = containerItemSupport.resolveNestedContainer()
 
     override fun findContentScrollView(): ViewGroup? = containerItemSupport.findContentScrollView(this)
+
+    override fun wantsToPreventStackNativeDismiss(): ContainerItem? =
+        resolveNestedContainer()?.wantsToPreventStackNativeDismiss()
+            ?: takeIf { isPreventNativeDismissEnabled }
 }

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

@@ -1,20 +1,37 @@
 package com.swmansion.rnscreens.stack.screen
 
+import android.content.res.Configuration
 import android.os.Bundle
+import android.util.Log
 import android.view.Gravity
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import androidx.fragment.app.Fragment
 import androidx.transition.Slide
+import com.swmansion.rnscreens.common.colorscheme.ColorSchemeProviding
+import com.swmansion.rnscreens.stack.header.StackHeaderBackPressHandler
 import com.swmansion.rnscreens.stack.header.StackHeaderCoordinatorLayout
+import com.swmansion.rnscreens.stack.host.StackUpdateBatchStateProviding
+import java.lang.ref.WeakReference
 
 internal class StackScreenFragment(
     internal val stackScreen: StackScreen,
     private val canNavigateBack: Boolean,
+    private val delegate: WeakReference<StackScreenFragmentDelegate>,
+    private val backPressHandler: WeakReference<StackHeaderBackPressHandler>,
+    private val updateBatchStateProvider: WeakReference<StackUpdateBatchStateProviding>,
+    private val colorSchemeProvider: WeakReference<ColorSchemeProviding>,
 ) : Fragment() {
     private var screenLifecycleEventEmitter: StackScreenAppearanceEventsEmitter? = null
 
+    /**
+     * Retained across fragment view destruction (e.g. tab switches detaching the fragment), so that
+     * the app bar scroll offset and the built header survive reattachment. FragmentManager removes
+     * the view from its container before `onDestroyView`, so `onCreateView` can return it as-is.
+     */
+    private var headerCoordinatorLayout: StackHeaderCoordinatorLayout? = null
+
     /**
      * This holds the screen strongly for now. Beware of retain cycle.
      *
@@ -35,17 +52,34 @@ internal class StackScreenFragment(
         allowEnterTransitionOverlap = true
         allowReturnTransitionOverlap = true
 
-        enterTransition = Slide(Gravity.RIGHT)
-        exitTransition = Slide(Gravity.LEFT)
-        returnTransition = Slide(Gravity.RIGHT)
-        reenterTransition = Slide(Gravity.LEFT)
+        enterTransition = Slide(Gravity.END)
+        exitTransition = Slide(Gravity.START)
+        returnTransition = Slide(Gravity.END)
+        reenterTransition = Slide(Gravity.START)
     }
 
     override fun onCreateView(
         inflater: LayoutInflater,
         container: ViewGroup?,
         savedInstanceState: Bundle?,
-    ): View = StackHeaderCoordinatorLayout(requireContext(), stackScreen, canNavigateBack)
+    ): View {
+        headerCoordinatorLayout?.let { return it }
+
+        return StackHeaderCoordinatorLayout(
+            requireContext(),
+            stackScreen,
+            canNavigateBack,
+            updateBatchStateProvider,
+            colorSchemeProvider,
+        ) { pressedScreen ->
+            backPressHandler.get()?.handleHeaderBackButtonPress(pressedScreen)
+                ?: Log.w(TAG, "[RNScreens] Header back button press dropped - handler is gone")
+        }.also { headerCoordinatorLayout = it }
+    }
+
+    internal fun flushPendingHeaderUpdates() {
+        headerCoordinatorLayout?.flushPendingUpdates()
+    }
 
     override fun onViewCreated(
         view: View,
@@ -56,21 +90,23 @@ internal class StackScreenFragment(
     }
 
     override fun onDestroyView() {
-        val coordinatorLayout = view
-        check(coordinatorLayout is StackHeaderCoordinatorLayout) {
-            "[RNScreens] Unexpected fragment view type: $view"
-        }
-        coordinatorLayout.tearDown()
         super.onDestroyView()
         screenLifecycleEventEmitter = null
     }
 
     override fun onDestroy() {
         super.onDestroy()
+        headerCoordinatorLayout?.tearDown()
+        headerCoordinatorLayout = null
         stackScreen.onDismiss()
         teardownPreventNativeDismissCallback()
     }
 
+    override fun onConfigurationChanged(newConfig: Configuration) {
+        super.onConfigurationChanged(newConfig)
+        delegate.get()?.onFragmentConfigurationChanged(newConfig)
+    }
+
     /**
      * Notifies this fragment that it has become "top fragment" in its fragment manager.
      * Call this only if the lifecycle of the fragment is at least at CREATED.
@@ -109,4 +145,8 @@ internal class StackScreenFragment(
         requireNativeDismissBackPressedCallback.remove()
         preventNativeDismissBackPressedCallback = null
     }
+
+    companion object {
+        private const val TAG = "StackScreenFragment"
+    }
 }

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

@@ -0,0 +1,12 @@
+package com.swmansion.rnscreens.stack.screen
+
+import android.content.res.Configuration
+
+internal interface StackScreenFragmentDelegate {
+    /**
+     * Notifies the delegate that the fragment received a configuration update,
+     * e.g. theme change from JS via Appearance.setColorScheme. Fragments are
+     * the only place where such updates are delivered reliably.
+     */
+    fun onFragmentConfigurationChanged(config: Configuration)
+}