react-native-screens 5.0.0-alpha.1 → 5.0.0-alpha.3

package/Package.swift

@@ -0,0 +1,87 @@
+// swift-tools-version: 6.0
+import PackageDescription
+
+// Header search paths for quoted cross-directory imports (SPM has no CocoaPods header maps).
+// Keep in sync when adding new ios/ subdirectories that contain headers.
+let headerSearchPaths: [String] = [
+    "ios",
+    "ios/bridging",
+    "ios/conversion",
+    "ios/helpers/container",
+    "ios/helpers/image",
+    "ios/helpers/scroll-view",
+    "ios/legacy",
+    "ios/legacy/events",
+    "ios/legacy/integrations",
+    "ios/legacy/utils",
+    "ios/modals/form-sheet",
+    "ios/modals/utils",
+    "ios/safe-area",
+    "ios/scroll-to-top-guard",
+    "ios/scroll-view-marker",
+    "ios/scroll-view-marker/conversion",
+    "ios/split",
+    "ios/split/conversion",
+    "ios/stack",
+    "ios/stack/conversion",
+    "ios/stack/header",
+    "ios/stack/host",
+    "ios/stack/screen",
+    "ios/tabs",
+    "ios/tabs/bottom-accessory",
+    "ios/tabs/conversion",
+    "ios/tabs/extensions",
+    "ios/tabs/host",
+    "ios/tabs/screen",
+    "ios/utils",
+    "ios/utils/extensions",
+    "common/cpp",
+    "cpp/legacy",
+]
+
+let cSettings: [CSetting] = headerSearchPaths.map { .headerSearchPath($0) }
+
+let cxxSettings: [CXXSetting] = [
+    .define("DEBUG", .when(configuration: .debug)),
+    .define("NDEBUG", .when(configuration: .release)),
+] + headerSearchPaths.map { .headerSearchPath($0) }
+
+let package = Package(
+    name: "RNScreens",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(name: "RNScreens", targets: ["RNScreens"]),
+    ],
+    dependencies: [
+        // Resolved from the autolinker symlink `<app>/ios/build/generated/autolinking/libs/RNScreens`,
+        // not from node_modules: `../../../../xcframeworks` -> `<app>/ios/build/xcframeworks`,
+        // `../../../ios` -> `<app>/ios/build/generated/ios`. Same layout `npx react-native spm scaffold` emits.
+        // Making this self-contained (remote RN package URL + shipping our own codegen output) is blocked
+        // on RN publishing a remote SPM package and would require `codegenConfig.includesGeneratedCode`, see:
+        // https://github.com/react/react-native/blob/v0.87.1/packages/react-native/scripts/spm/__docs__/spm-header-paths-contract.md#hand-authored-community-library-contract
+        .package(name: "ReactNative", path: "../../../../xcframeworks"),
+        .package(name: "React-GeneratedCode", path: "../../../ios"),
+    ],
+    targets: [
+        .target(
+            name: "RNScreens",
+            dependencies: [
+                .product(name: "ReactHeaders", package: "ReactNative"),
+                .product(name: "ReactNativeHeaders", package: "ReactNative"),
+                .product(name: "ReactNativeDependenciesHeaders", package: "ReactNative"),
+                .product(name: "ReactAppHeaders", package: "React-GeneratedCode"),
+            ],
+            path: ".",
+            exclude: ["ios/RNScreens.xcodeproj"],
+            sources: ["ios", "common/cpp", "cpp"],
+            publicHeadersPath: "ios",
+            cSettings: cSettings,
+            cxxSettings: cxxSettings,
+            linkerSettings: [
+                .linkedFramework("UIKit"),
+                .linkedFramework("Foundation"),
+            ]
+        ),
+    ],
+    cxxLanguageStandard: .cxx20
+)

package/README.md

@@ -254,14 +254,6 @@ There are many ways to contribute to this project. See [CONTRIBUTING](https://gi
 
 React native screens library is licensed under [The MIT License](LICENSE).
 
-## Credits
-
-This project has been build and is maintained thanks to the support from [Shopify](https://shopify.com), [Expo.io](https://expo.io), and [Software Mansion](https://swmansion.com).
-
-[![shopify](https://avatars1.githubusercontent.com/u/8085?v=3&s=100 'Shopify.com')](https://shopify.com)
-[![expo](https://avatars2.githubusercontent.com/u/12504344?v=3&s=100 'Expo.io')](https://expo.io)
-[![swm](https://logo.swmansion.com/logo?color=white&variant=desktop&width=150&tag=react-native-reanimated-github 'Software Mansion')](https://swmansion.com)
-
 ## React Native Screens is created by Software Mansion
 
 Since 2012 [Software Mansion](https://swmansion.com) is a software agency with experience in building web and mobile apps. We are Core React Native Contributors and experts in dealing with all kinds of React Native issues. We can help you build your next dream product – [Hire us](https://swmansion.com/contact/projects?utm_source=screens&utm_medium=readme).

package/RNScreens.podspec

@@ -6,7 +6,7 @@ debug_logging_enabled = ENV['RNS_DEBUG_LOGGING'] == '1'
 use_cxxbridge = ENV['RNS_USE_CXXBRIDGE'] == '1'
 
 
-source_files_exts = '{h,m,mm,cpp,swift}'
+source_files_exts = '{h,m,mm,cpp}'
 source_files = ["ios/**/*.#{source_files_exts}"]
 
 min_supported_ios_version = "15.1"
@@ -14,17 +14,14 @@ min_supported_tvos_version = "15.1"
 min_supported_visionos_version = "1.0"
 
 rnscreens_cpp_flags = []
-rnscreens_swift_flags = []
 
 if debug_logging_enabled
   rnscreens_cpp_flags << "-DRNS_DEBUG_LOGGING=1"
-  rnscreens_swift_flags << "-DRNS_DEBUG_LOGGING"
 end
 rnscreens_cpp_flags << "-DRNS_USE_CXXBRIDGE=1" if use_cxxbridge
 
 rnscreens_config  =  {
-  'OTHER_CPLUSPLUSFLAGS' => rnscreens_cpp_flags.join(" "),
-  'OTHER_SWIFT_FLAGS' => rnscreens_swift_flags.join(" ")
+  'OTHER_CPLUSPLUSFLAGS' => rnscreens_cpp_flags.join(" ")
 }
 
 rnscreens_config['DEFINES_MODULE'] = 'YES'
@@ -42,7 +39,6 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => min_supported_ios_version, :tvos => min_supported_tvos_version, :visionos => min_supported_visionos_version }
   s.source       = { :git => "https://github.com/software-mansion/react-native-screens.git", :tag => "#{s.version}" }
   s.source_files = source_files
-  s.project_header_files = "ios/bridging/Swift-Bridging.h"
   s.requires_arc = true
 
   if debug_logging_enabled

package/android/build.gradle

@@ -82,7 +82,27 @@ if (isRunningInContextOfScreensRepo()) {
     apply plugin: "com.facebook.react"
 }
 apply plugin: 'com.android.library'
-apply plugin: 'kotlin-android'
+
+// AGP 9 ships built-in Kotlin support enabled by default. When it is active, AGP compiles 
+// our Kotlin sources itself and *additionally* applying the Kotlin Android plugin fails the build.
+// Consuming apps may opt out with `android.builtInKotlin=false` in which case AGP does NOT
+// provide Kotlin and we MUST apply the plugin ourselves.
+// AGP < 9 had no built-in Kotlin at all, so we always apply it there.
+def shouldEnableAgpFallback() {
+    def agpMajorVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')[0].toInteger()
+    if (agpMajorVersion <= 8) {
+        return true
+    }
+
+    def propertyVal = providers.gradleProperty("android.builtInKotlin").orNull
+    def isBuiltInKotlinEnabled = propertyVal != null ? propertyVal.toBoolean() : true
+
+    return !isBuiltInKotlinEnabled
+}
+
+if (shouldEnableAgpFallback()) {
+    apply plugin: 'kotlin-android'
+}
 
 def reactNativeArchitectures() {
     def value = project.getProperties().get("reactNativeArchitectures")
@@ -165,6 +185,11 @@ android {
     }
     sourceSets.main {
         ext.androidResDir = "src/main/res"
+        kotlin {
+            srcDirs += [
+                "src/fabric/java",
+            ]
+        }
         java {
             srcDirs += [
                 "src/fabric/java",

package/android/src/fabric/java/com/swmansion/rnscreens/NativeProxy.kt

@@ -64,6 +64,11 @@ class NativeProxy {
 
         val screen = weakScreeRef.get()
         if (screen is Screen) {
+            // Fabric's mounting transaction removes the screen on a Choreographer frame callback,
+            // which can execute before `startRemovalTransition` (scheduled via `Handler.post`).
+            // To prevent `Screen.isBeingRemoved` from being read as false during teardown,
+            // we must set this flag synchronously here.
+            screen.markAsBeingRemoved()
             val isScheduled =
                 screen.post {
                     screen.startRemovalTransition()

package/android/src/main/cpp/NativeProxy.cpp

@@ -2,6 +2,7 @@
 #include <react/fabric/Binding.h>
 #include <react/renderer/scheduler/Scheduler.h>
 
+#include <memory>
 #include <string>
 
 #include "NativeProxy.h"
@@ -11,6 +12,19 @@ using namespace react;
 
 namespace rnscreens {
 
+namespace {
+// Keep this listener process-lifetime to avoid races during initialization,
+// when nativeAddMutationsListener() can be called concurrently from different
+// threads. A function-local static initializes thread-safely, and an immortal
+// instance suits core's delegate list, which is append-only. For more details:
+// https://github.com/software-mansion/react-native-screens/pull/4413
+const std::shared_ptr<RNSScreenRemovalListener> &removalListener() {
+  static const std::shared_ptr<RNSScreenRemovalListener> instance =
+      std::make_shared<RNSScreenRemovalListener>();
+  return instance;
+}
+} // namespace
+
 NativeProxy::NativeProxy(jni::alias_ref<NativeProxy::javaobject> jThis)
     : javaPart_(jni::make_global(jThis)) {}
 
@@ -32,13 +46,18 @@ void NativeProxy::nativeAddMutationsListener(
   auto uiManager =
       fabricUIManager->getBinding()->getScheduler()->getUIManager();
 
-  if (!screenRemovalListener_) {
-    screenRemovalListener_ =
-        std::make_shared<RNSScreenRemovalListener>([this](int tag) {
+  {
+    // Capture a copy of the global ref, never `this`: the listener outlives
+    // this NativeProxy, and the old live read of javaPart_ at call time raced
+    // invalidateNative(). installMutex_ keeps the copy from racing the
+    // invalidation write and keeps the stored token matching the last install.
+    std::lock_guard<std::mutex> lock(installMutex_);
+    removalListenerToken_ =
+        removalListener()->setListener([javaPart = javaPart_](int tag) {
           static const auto method =
-              javaPart_->getClass()->getMethod<void(jint)>(
+              javaPart->getClass()->getMethod<void(jint)>(
                   "notifyScreenRemoved");
-          method(javaPart_, tag);
+          method(javaPart, tag);
         });
   }
 
@@ -79,7 +98,7 @@ void NativeProxy::addMountingCoordinatorIfNeeded(
       });
 
   if (!wasRegistered) {
-    coordinator->setMountingOverrideDelegate(screenRemovalListener_);
+    coordinator->setMountingOverrideDelegate(removalListener());
     coordinatorsWithMountingOverrides_.push_back(coordinator);
   }
 }
@@ -90,6 +109,11 @@ jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
 }
 
 void NativeProxy::invalidateNative() {
+  // Disarm before the hybrid is collected; also releases the captured global
+  // ref so the Java NativeProxy stays collectable. Serialized with the install
+  // path so the token is never stale and javaPart_ is not nulled mid-capture.
+  std::lock_guard<std::mutex> lock(installMutex_);
+  removalListener()->clearListener(removalListenerToken_);
   javaPart_ = nullptr;
 }
 

package/android/src/main/cpp/NativeProxy.h

@@ -4,6 +4,7 @@
 #include <react/fabric/JFabricUIManager.h>
 #include "RNSScreenRemovalListener.h"
 
+#include <cstdint>
 #include <mutex>
 #include <string>
 
@@ -13,7 +14,6 @@ using namespace facebook::jni;
 
 class NativeProxy : public jni::HybridClass<NativeProxy> {
  public:
-  std::shared_ptr<RNSScreenRemovalListener> screenRemovalListener_;
   std::vector<std::weak_ptr<const facebook::react::MountingCoordinator>>
       coordinatorsWithMountingOverrides_;
   static auto constexpr kJavaDescriptor =
@@ -28,6 +28,12 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
 
   std::mutex coordinatorsMutex_;
 
+  // Serializes callback install (nativeAddMutationsListener) with
+  // invalidateNative: the install-time copy of javaPart_ must not race the
+  // invalidation write, and the stored token must match the last install.
+  std::mutex installMutex_;
+  uint64_t removalListenerToken_{0};
+
   explicit NativeProxy(jni::alias_ref<NativeProxy::javaobject> jThis);
 
   void nativeAddMutationsListener(

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

@@ -18,8 +18,8 @@ import com.swmansion.rnscreens.legacy.ScreenStackViewManager
 import com.swmansion.rnscreens.legacy.ScreenViewManager
 import com.swmansion.rnscreens.legacy.SearchBarManager
 import com.swmansion.rnscreens.legacy.utils.ScreenDummyLayoutHelper
-import com.swmansion.rnscreens.modals.formsheet.FormSheetContentWrapperViewManager
-import com.swmansion.rnscreens.modals.formsheet.FormSheetHostViewManager
+import com.swmansion.rnscreens.modals.formsheet.react.contentwrapper.FormSheetContentWrapperViewManager
+import com.swmansion.rnscreens.modals.formsheet.react.host.FormSheetHostViewManager
 import com.swmansion.rnscreens.safearea.SafeAreaViewManager
 import com.swmansion.rnscreens.scrollviewmarker.ScrollViewMarkerViewManager
 import com.swmansion.rnscreens.stack.header.config.StackHeaderConfigViewManager

package/android/src/main/java/com/swmansion/rnscreens/common/container/Container.kt

@@ -9,4 +9,12 @@ interface Container {
      * (if any).
      */
     fun resolveCurrentContentScrollView(): ViewGroup?
+
+    /**
+     * Asked when this container's whole subtree is about to be natively dismissed,
+     * e.g. the screen hosting this container is popped. Returns the item that
+     * vetoes the dismissal via `preventNativeDismiss`, or null when nothing
+     * in the subtree does.
+     */
+    fun wantsToPreventStackNativeDismiss(): ContainerItem?
 }

package/android/src/main/java/com/swmansion/rnscreens/common/container/ContainerItem.kt

@@ -2,7 +2,7 @@ package com.swmansion.rnscreens.common.container
 
 import android.view.ViewGroup
 
-internal interface ContainerItem {
+interface ContainerItem {
     // region Nested Container handling
 
     /**
@@ -27,4 +27,16 @@ internal interface ContainerItem {
     fun findContentScrollView(): ViewGroup?
 
     // endregion
+
+    // region Native dismissal
+
+    /**
+     * Asked when this item (screen) is about to be natively dismissed together
+     * with its subtree. The nested container (if any) is consulted first; its
+     * non-null answer wins, otherwise the item answers for itself, returning
+     * itself when it vetoes the dismissal or null otherwise.
+     */
+    fun wantsToPreventStackNativeDismiss(): ContainerItem?
+
+    // endregion
 }

package/android/src/main/java/com/swmansion/rnscreens/common/text/ReactTextAppearance.kt

@@ -0,0 +1,62 @@
+package com.swmansion.rnscreens.common.text
+
+import android.content.res.AssetManager
+import android.graphics.Typeface
+import android.os.Build
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.common.assets.ReactFontManager.TypefaceStyle
+import com.facebook.react.views.text.ReactTypefaceUtils
+import kotlin.properties.Delegates
+import kotlin.properties.ReadWriteProperty
+
+/**
+ * [TextAppearance] driven by React props. Font family, weight and style are kept as the raw
+ * React values and turned into a [Typeface]. [onChanged] is invoked whenever a property
+ * actually changes value.
+ */
+internal class ReactTextAppearance(
+    private val assets: AssetManager,
+    onChanged: () -> Unit,
+) : TextAppearance {
+    override var color: Int? by changeNotifying(onChanged)
+    override var fontSize: Float? by changeNotifying(onChanged)
+    internal var fontFamily: String? by changeNotifying(onChanged)
+    internal var fontWeight: String? by changeNotifying(onChanged)
+    internal var fontStyle: String? by changeNotifying(onChanged)
+
+    override fun resolveTypeface(base: Typeface): Typeface {
+        val weight = ReactTypefaceUtils.parseFontWeight(fontWeight)
+        val style = ReactTypefaceUtils.parseFontStyle(fontStyle)
+
+        if (fontFamily == null && weight == ReactConstants.UNSET && style == ReactConstants.UNSET) {
+            return base
+        }
+
+        // ReactFontManager.TypefaceStyle turns an unset weight into 400 and an unset style into
+        // "not italic" rather than deriving them from the base. This would drop default styling
+        // from base typeface. Resolve both up front so it never receives UNSET style or weight.
+        return ReactTypefaceUtils.applyStyles(
+            base,
+            if (style != ReactConstants.UNSET) style else base.resolveStyle(),
+            if (weight != ReactConstants.UNSET) weight else base.resolveWeight(),
+            fontFamily,
+            assets,
+        )
+    }
+}
+
+private fun <T> changeNotifying(onChanged: () -> Unit): ReadWriteProperty<Any?, T?> =
+    Delegates.observable(null) { _, old, new -> if (old != new) onChanged() }
+
+/**
+ * Numeric weight of this typeface. [Typeface.getWeight] requires API 28; below it only bold
+ * can be told apart from regular.
+ */
+private fun Typeface.resolveWeight(): Int =
+    when {
+        Build.VERSION.SDK_INT >= Build.VERSION_CODES.P -> weight
+        isBold -> TypefaceStyle.BOLD
+        else -> TypefaceStyle.NORMAL
+    }
+
+private fun Typeface.resolveStyle(): Int = if (isItalic) Typeface.ITALIC else Typeface.NORMAL

package/android/src/main/java/com/swmansion/rnscreens/common/text/TextAppearance.kt

@@ -0,0 +1,20 @@
+package com.swmansion.rnscreens.common.text
+
+import android.graphics.Typeface
+
+/**
+ * Provides text styling for some given part of the interface. Interface is React-agnostic. A `null`
+ * value means "keep the default".
+ */
+internal interface TextAppearance {
+    val color: Int?
+
+    /** Font size in SP. */
+    val fontSize: Float?
+
+    /**
+     * Returns the modified typeface based on [base] typeface. Properties that are not overridden
+     * are inherited from [base], which is returned unchanged when there are no overrides at all.
+     */
+    fun resolveTypeface(base: Typeface): Typeface
+}

package/android/src/main/java/com/swmansion/rnscreens/common/text/TextAppearanceDefaults.kt

@@ -0,0 +1,65 @@
+package com.swmansion.rnscreens.common.text
+
+import android.content.Context
+import android.graphics.Typeface
+import androidx.annotation.AttrRes
+import com.swmansion.rnscreens.utils.resolveColorAttr
+import com.swmansion.rnscreens.utils.resolveStyleResAttr
+
+/**
+ * Default text styling of a single title/subtitle slot, resolved from the M3 type-scale
+ * style behind [textAppearanceAttr] and the color behind [textColorAttr].
+ *
+ * Resolved from the style rather than read back from the widget: Material resolves a slot's
+ * default typeface asynchronously, so until that lands the widget reports [Typeface.DEFAULT].
+ */
+internal class TextAppearanceDefaults(
+    val color: Int,
+    val textSizePx: Float,
+    val typeface: Typeface,
+) {
+    companion object {
+        fun resolve(
+            context: Context,
+            @AttrRes textAppearanceAttr: Int,
+            @AttrRes textColorAttr: Int,
+        ): TextAppearanceDefaults {
+            val appearanceRes = resolveStyleResAttr(context, textAppearanceAttr)
+            val attrs = context.obtainStyledAttributes(appearanceRes, APPEARANCE_ATTRS)
+            try {
+                val textSizePx = attrs.getDimension(IDX_TEXT_SIZE, 0f)
+                require(textSizePx > 0f) { "[RNScreens] Text appearance defines no text size." }
+
+                // android:fontFamily is either a font resource (@font/…, resolvable only
+                // asynchronously) or a family name. The M3 type scale always declares a family
+                // name (@string/m3_ref_typeface_* — "sans-serif" / "sans-serif-medium"),
+                // so we can unconditionally take the synchronous path (Material's own fallback and
+                // AppCompatTextHelper do the same).
+                val textStyle = attrs.getInt(IDX_TEXT_STYLE, Typeface.NORMAL)
+                val typeface =
+                    attrs.getString(IDX_FONT_FAMILY)?.let { Typeface.create(it, textStyle) }
+                        ?: Typeface.defaultFromStyle(textStyle)
+
+                return TextAppearanceDefaults(
+                    resolveColorAttr(context, textColorAttr),
+                    textSizePx,
+                    typeface,
+                )
+            } finally {
+                attrs.recycle()
+            }
+        }
+
+        // Framework attr ids are compile-time constants; the array must stay sorted
+        // ascending (obtainStyledAttributes requirement).
+        private val APPEARANCE_ATTRS =
+            intArrayOf(
+                android.R.attr.textSize,
+                android.R.attr.textStyle,
+                android.R.attr.fontFamily,
+            )
+        private const val IDX_TEXT_SIZE = 0
+        private const val IDX_TEXT_STYLE = 1
+        private const val IDX_FONT_FAMILY = 2
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/helpers/PropIconResolver.kt

@@ -1,6 +1,5 @@
 package com.swmansion.rnscreens.helpers
 
-import android.content.Context
 import android.graphics.drawable.Drawable
 
 /**
@@ -21,27 +20,28 @@ internal sealed interface IconResolution {
 
 /**
  * Stateful, latest-wins icon resolver for a single declaratively-driven icon slot — a `toolbarMenu`
- * prop menu item, or the back button — that is re-evaluated on every prop transaction. It
- * deduplicates unchanged sources ([IconResolution.Unchanged]) to avoid needless reloads/flicker,
- * and drops stale async results so a slow load cannot clobber a newer source.
+ * prop menu item, or the back button — that is re-evaluated on every source change. It deduplicates
+ * unchanged sources ([IconResolution.Unchanged]) to avoid needless reloads/flicker, and drops stale
+ * async results so a slow load cannot clobber a newer source.
+ *
+ * [load] must invoke its completion callback exactly once — synchronously or asynchronously,
+ * always on the main thread — with the loaded drawable, or `null` when the source resolves to
+ * no icon or fails to load (see e.g. [resolveImage]).
  */
-internal class PropIconResolver {
+internal class PropIconResolver(
+    private val load: (drawableIconResourceName: String?, imageIconUri: String?, onComplete: (Drawable?) -> Unit) -> Unit,
+) {
     private var lastDrawableName: String? = null
     private var lastImageUri: String? = null
     private var lastEmittedDrawableName: String? = null
     private var lastEmittedImageUri: String? = null
 
     /**
-     * Resolves an icon from a drawable resource name or an image uri.
-     *
-     * The result is delivered to [onResult] synchronously for drawable resources and empty sources,
-     * and asynchronously for image uris. For image uris, the callback is only invoked if the
-     * resolved uri is still the latest requested source (stale requests are dropped). On a failed
-     * image load the latest request still emits [IconResolution.Resolved] with a `null` drawable, so
-     * the icon is cleared rather than left stale.
+     * Resolves an icon from a drawable resource name or an image uri. The result is delivered
+     * to [onResult] only if the requested source is still the latest one (stale async results
+     * are dropped).
      */
     fun resolve(
-        context: Context,
         drawableIconResourceName: String?,
         imageIconUri: String?,
         onResult: (IconResolution) -> Unit,
@@ -56,16 +56,10 @@ internal class PropIconResolver {
         }
         lastEmittedDrawableName = drawableIconResourceName
         lastEmittedImageUri = imageIconUri
-        when {
-            drawableIconResourceName != null ->
-                onResult(IconResolution.Resolved(getSystemDrawableResource(context, drawableIconResourceName)))
-            imageIconUri != null ->
-                loadImage(context, imageIconUri) { drawable ->
-                    if (imageIconUri == lastImageUri && lastDrawableName == null) {
-                        onResult(IconResolution.Resolved(drawable))
-                    }
-                }
-            else -> onResult(IconResolution.Resolved(null))
+        load(drawableIconResourceName, imageIconUri) { drawable ->
+            if (drawableIconResourceName == lastDrawableName && imageIconUri == lastImageUri) {
+                onResult(IconResolution.Resolved(drawable))
+            }
         }
     }
 }

package/android/src/main/java/com/swmansion/rnscreens/legacy/Screen.kt

@@ -71,7 +71,14 @@ class Screen(
         private set
     var screenId: String? = null
     var isStatusBarAnimated: Boolean? = null
+
+    // Can be set on the mounting coordinator's thread (see `markAsBeingRemoved`), read on the UI thread.
+    @Volatile
     var isBeingRemoved = false
+        private set
+
+    // Keeps `startTransitionRecursive` / `endTransitionRecursive` calls paired. Should be used on UI thread only.
+    private var isRemovalTransitionStarted = false
 
     // Props for controlling modal presentation
     var isSheetGrabberVisible: Boolean = false
@@ -439,19 +446,28 @@ class Screen(
 
     var nativeBackButtonDismissalEnabled: Boolean = true
 
+    /**
+     * Marks this screen as being removed from the native stack. Safe to call off the UI thread;
+     * must run before the mount transaction removing this screen executes.
+     */
+    fun markAsBeingRemoved() {
+        isBeingRemoved = true
+    }
+
     fun startRemovalTransition() {
-        if (!isBeingRemoved) {
-            isBeingRemoved = true
+        isBeingRemoved = true
+        if (!isRemovalTransitionStarted) {
+            isRemovalTransitionStarted = true
             startTransitionRecursive(this)
         }
     }
 
     fun endRemovalTransition() {
-        if (!isBeingRemoved) {
-            return
+        if (isRemovalTransitionStarted) {
+            isRemovalTransitionStarted = false
+            isBeingRemoved = false
+            endTransitionRecursive(this)
         }
-        isBeingRemoved = false
-        endTransitionRecursive(this)
     }
 
     private fun endTransitionRecursive(parent: ViewGroup) {
@@ -479,8 +495,10 @@ class Screen(
                     // It has a custom `getChildDrawingOrder` method which returns
                     // wrong index if we called `startViewTransition` on the views on new arch.
                     // We add a simple View to bump the number of children to make it work.
+                    // Appended, not inserted at `i`: a filler before the circle inflates the
+                    // index `onMeasure` caches for it, which then outlives the child it points at.
                     // TODO: find a better way to handle this scenario
-                    it.addView(View(context), i)
+                    it.addView(View(context))
                 } else {
                     child?.let { view -> it.startViewTransition(view) }
                 }

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

@@ -282,6 +282,8 @@ class ScreenStack(
                 screenWrappers
                     .asSequence()
                     .dropWhile { it !== visibleBottom } // ignore all screens beneath the visible bottom
+                    // dismissed screens are already removed above & preloaded ones must stay detached
+                    .filter { !dismissedWrappers.contains(it) && it.screen.activityState !== Screen.ActivityState.INACTIVE }
                     .forEach { wrapper ->
                         // TODO: It should be enough to dispatch this on commit action once.
                         transaction.add(id, wrapper.fragment).runOnCommit {