react-native-screens 4.24.0 → 4.25.0-beta.2

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

@@ -0,0 +1,60 @@
+package com.swmansion.rnscreens.gamma.tabs.container
+
+import com.swmansion.rnscreens.gamma.tabs.container.TabsNavigationStateRejectionReason.REPEATED
+import com.swmansion.rnscreens.gamma.tabs.container.TabsNavigationStateRejectionReason.STALE
+
+/**
+ * Describes navigation state of a tabs container.
+ *
+ * @property selectedScreenKey Screen key of the currently selected tab.
+ * @property provenance Monotonically increasing number describing the history (generation) of the state.
+ *   State with provenance `N + 1` is derived from state with provenance `N`.
+ *   This allows detecting stale updates.
+ */
+data class TabsNavigationState(
+    val selectedScreenKey: String,
+    val provenance: Int,
+) {
+    internal fun isEmpty(): Boolean = this === EMPTY
+
+    internal fun isNotEmpty(): Boolean = !this.isEmpty()
+
+    companion object {
+        val EMPTY = TabsNavigationState("", Int.MIN_VALUE)
+    }
+}
+
+/**
+ * A request to change navigation state.
+ *
+ * Carries the target [selectedScreenKey], the [baseProvenance] of the state the request was derived from,
+ * and the [actionOrigin] (actor) that initiated it. Mirrors the public `TabsHostNavStateRequest` TS type
+ * plus an [actionOrigin] carried internally.
+ *
+ * @property selectedScreenKey Screen key of the requested tab.
+ * @property baseProvenance Provenance of the state this request was derived from. Used for staleness detection.
+ * @property actionOrigin Origin (actor) that initiated this request.
+ */
+data class TabsNavigationStateUpdateRequest(
+    val selectedScreenKey: String,
+    val baseProvenance: Int,
+    val actionOrigin: TabsActionOrigin,
+)
+
+/**
+ * Reason why a navigation state update was rejected by the container.
+ *
+ * - [STALE] — the update's provenance indicates that it is based on a stale state.
+ * - [REPEATED] — the requested tab is already selected.
+ */
+enum class TabsNavigationStateRejectionReason {
+    STALE,
+    REPEATED,
+    ;
+
+    override fun toString(): String =
+        when (this) {
+            STALE -> "stale"
+            REPEATED -> "repeated"
+        }
+}

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

@@ -0,0 +1,53 @@
+package com.swmansion.rnscreens.gamma.tabs.container
+
+/**
+ * Observer of navigation state changes on a [TabsContainer].
+ *
+ * Multiple observers may register against a single container via
+ * [TabsContainer.addNavigationStateObserver] / [TabsContainer.removeNavigationStateObserver].
+ * The host (`TabsHost` on Android) registers itself as an observer to relay events to JS;
+ * downstream native libraries integrating directly against [TabsContainer] may register
+ * additional observers.
+ */
+interface TabsNavigationStateObserver {
+    /**
+     * Called when the container accepts a navigation state change.
+     *
+     * @param navState The new navigation state after the change.
+     * @param isRepeated Whether the same tab that was already selected has been selected again.
+     * @param hasTriggeredSpecialEffect Whether a special effect (e.g. scroll-to-top) was triggered.
+     * @param actionOrigin Origin (actor) that requested this transition.
+     */
+    fun onNavigationStateUpdate(
+        navState: TabsNavigationState,
+        isRepeated: Boolean,
+        hasTriggeredSpecialEffect: Boolean,
+        actionOrigin: TabsActionOrigin,
+    )
+
+    /**
+     * Called when the container rejects a navigation state update.
+     *
+     * @param currentNavState The currently active navigation state that was kept.
+     * @param rejectedRequest The navigation state update request that was rejected.
+     * @param reason Why the update was rejected.
+     */
+    fun onNavigationStateUpdateRejected(
+        currentNavState: TabsNavigationState,
+        rejectedRequest: TabsNavigationStateUpdateRequest,
+        reason: TabsNavigationStateRejectionReason,
+    )
+
+    /**
+     * Called when a native user action (tap) attempts to select a tab that has
+     * [com.swmansion.rnscreens.gamma.tabs.screen.TabsScreen.preventNativeSelection] enabled.
+     * The navigation state remains unchanged.
+     *
+     * @param currentNavState The currently active navigation state that was kept.
+     * @param preventedScreenKey The screen key of the tab whose selection was prevented.
+     */
+    fun onNavigationStateUpdatePrevented(
+        currentNavState: TabsNavigationState,
+        preventedScreenKey: String,
+    )
+}

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

@@ -0,0 +1,88 @@
+package com.swmansion.rnscreens.gamma.tabs.container
+
+/**
+ * Holds the set of [TabsNavigationStateObserver]s registered against a [TabsContainer]
+ * and fans out container events to all of them.
+ *
+ * Observers are held with strong references; callers must explicitly call
+ * [TabsContainer.removeNavigationStateObserver] before observer dealloc, or rely on the
+ * host invoking [TabsContainer.tearDown] (which calls [clear]) on container teardown.
+ *
+ * # Reentrance
+ *
+ * Recursive emission is forbidden. While an `emit*` call is in flight:
+ * - additional `emit*` calls fail-fast with [IllegalStateException] (recursion is a
+ *   programmer error — it would deliver out-of-order events to later observers),
+ * - [add] / [remove] are rejected gracefully and return `false`.
+ *
+ * The registry is single-threaded — use it from a single thread (typically the UI
+ * thread on Android). It does not synchronize.
+ */
+internal class TabsNavigationStateObserverRegistry {
+    private val observers: MutableList<TabsNavigationStateObserver> = mutableListOf()
+    private var isEmitting: Boolean = false
+
+    /**
+     * Register an observer. Returns `false` if the observer is already registered or
+     * if called during an in-flight `emit*` (modifications during emission are rejected).
+     */
+    fun add(observer: TabsNavigationStateObserver): Boolean {
+        if (isEmitting) return false
+        if (observers.contains(observer)) return false
+        observers.add(observer)
+        return true
+    }
+
+    /**
+     * Unregister an observer. Returns `false` if the observer was not registered or
+     * if called during an in-flight `emit*` (modifications during emission are rejected).
+     */
+    fun remove(observer: TabsNavigationStateObserver): Boolean {
+        if (isEmitting) return false
+        return observers.remove(observer)
+    }
+
+    /**
+     * Drop all registered observers. Must not be called during an in-flight `emit*`.
+     */
+    fun clear() {
+        check(!isEmitting) { "[RNScreens] TabsNavigationStateObserverRegistry.clear during emission" }
+        observers.clear()
+    }
+
+    fun emitOnNavigationStateUpdate(
+        navState: TabsNavigationState,
+        isRepeated: Boolean,
+        hasTriggeredSpecialEffect: Boolean,
+        actionOrigin: TabsActionOrigin,
+    ) {
+        emitSignal { observer -> observer.onNavigationStateUpdate(navState, isRepeated, hasTriggeredSpecialEffect, actionOrigin) }
+    }
+
+    fun emitOnNavigationStateUpdateRejected(
+        currentNavState: TabsNavigationState,
+        rejectedRequest: TabsNavigationStateUpdateRequest,
+        reason: TabsNavigationStateRejectionReason,
+    ) {
+        emitSignal { observer -> observer.onNavigationStateUpdateRejected(currentNavState, rejectedRequest, reason) }
+    }
+
+    fun emitOnNavigationStateUpdatePrevented(
+        currentNavState: TabsNavigationState,
+        preventedScreenKey: String,
+    ) {
+        emitSignal { observer -> observer.onNavigationStateUpdatePrevented(currentNavState, preventedScreenKey) }
+    }
+
+    private fun emitSignal(emitBlock: (TabsNavigationStateObserver) -> Unit) {
+        check(!isEmitting) { "[RNScreens] Recursive emission on TabsNavigationStateObserverRegistry" }
+        isEmitting = true
+        try {
+            observers.forEach {
+                emitBlock(it)
+            }
+        } finally {
+            isEmitting = false
+        }
+    }
+}

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

@@ -0,0 +1,223 @@
+package com.swmansion.rnscreens.gamma.tabs.host
+
+import android.annotation.SuppressLint
+import android.view.Choreographer
+import android.widget.FrameLayout
+import androidx.core.graphics.drawable.toDrawable
+import com.facebook.react.bridge.UIManager
+import com.facebook.react.bridge.UIManagerListener
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.modules.core.ReactChoreographer
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.rnscreens.gamma.common.colorscheme.ColorScheme
+import com.swmansion.rnscreens.gamma.helpers.getFabricUIManagerNotNull
+import com.swmansion.rnscreens.gamma.tabs.container.TabsActionOrigin
+import com.swmansion.rnscreens.gamma.tabs.container.TabsContainer
+import com.swmansion.rnscreens.gamma.tabs.container.TabsNavigationState
+import com.swmansion.rnscreens.gamma.tabs.container.TabsNavigationStateObserver
+import com.swmansion.rnscreens.gamma.tabs.container.TabsNavigationStateRejectionReason
+import com.swmansion.rnscreens.gamma.tabs.container.TabsNavigationStateUpdateRequest
+import com.swmansion.rnscreens.gamma.tabs.screen.TabsScreen
+import com.swmansion.rnscreens.utils.RNSLog
+import kotlin.properties.Delegates
+
+@SuppressLint("ViewConstructor") // Only created by us. Should never be restored
+@OptIn(UnstableReactNativeAPI::class)
+class TabsHost(
+    val reactContext: ThemedReactContext,
+) : FrameLayout(reactContext),
+    TabsNavigationStateObserver,
+    UIManagerListener {
+    private val renderedScreens: ArrayList<TabsScreen> = arrayListOf()
+    private var jsNavStateRequest: TabsNavigationStateUpdateRequest? = null
+
+    private val container: TabsContainer =
+        TabsContainer(reactContext).apply {
+            layoutParams =
+                LayoutParams(
+                    LayoutParams.MATCH_PARENT,
+                    LayoutParams.MATCH_PARENT,
+                )
+        }
+
+    internal var rejectStaleNavigationStateUpdates: Boolean by container::rejectStaleNavigationStateUpdates
+
+    internal lateinit var eventEmitter: TabsHostEventEmitter
+
+    private var isLayoutEnqueued: Boolean = false
+
+    var tabBarHidden: Boolean by container::tabBarHidden
+
+    var nativeContainerBackgroundColor: Int? by Delegates.observable(null) { _, oldValue, newValue ->
+        if (newValue != oldValue) {
+            container.background = newValue?.toDrawable()
+        }
+    }
+
+    internal var colorScheme: ColorScheme by container::colorScheme
+    var tabBarRespectsIMEInsets: Boolean by container::tabBarRespectsIMEInsets
+
+    init {
+        addView(container)
+        check(container.addNavigationStateObserver(this)) {
+            "[RNScreens] Failed to register TabsHost as navigation state observer"
+        }
+        UIManagerHelper
+            .getFabricUIManagerNotNull(reactContext)
+            .addUIManagerEventListener(this)
+    }
+
+    override fun onAttachedToWindow() {
+        RNSLog.i(TAG, "TabsHost [$id] attached to window")
+        super.onAttachedToWindow()
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+    }
+
+    internal fun mountReactSubviewAt(
+        tabsScreen: TabsScreen,
+        index: Int,
+    ) {
+        val bottomNavigationViewMaxItemCount = container.bottomNavigationView.maxItemCount
+        require(index < bottomNavigationViewMaxItemCount) {
+            "[RNScreens] Attempt to insert TabsScreen at index $index; BottomNavigationView supports at most $bottomNavigationViewMaxItemCount items"
+        }
+
+        renderedScreens.add(index, tabsScreen)
+        tabsScreen.setTabsScreenDelegate(container)
+
+        container.addTabsScreenAt(index, tabsScreen)
+    }
+
+    internal fun unmountReactSubviewAt(index: Int) {
+        renderedScreens.removeAt(index).also { tabsScreen ->
+            container.removeTabsScreenAt(index)
+            tabsScreen.setTabsScreenDelegate(null)
+        }
+    }
+
+    internal fun unmountReactSubview(reactSubview: TabsScreen) {
+        if (renderedScreens.removeIf { it === reactSubview }) {
+            assert(container.removeTabsScreen(reactSubview))
+            reactSubview.setTabsScreenDelegate(null)
+        }
+    }
+
+    internal fun unmountAllReactSubviews() {
+        renderedScreens.forEach { it.setTabsScreenDelegate(null) }
+        renderedScreens.clear()
+
+        container.removeAllTabsScreens()
+    }
+
+    internal fun updateJSNavigationStateUpdateRequest(navStateRequest: TabsNavigationStateUpdateRequest) {
+        jsNavStateRequest = navStateRequest
+        container.setPendingNavigationStateUpdate(navStateRequest.copy())
+    }
+
+    private val layoutCallback =
+        Choreographer.FrameCallback {
+            isLayoutEnqueued = false
+            forceSubtreeMeasureAndLayoutPass()
+        }
+
+    private fun refreshLayout() {
+        @Suppress("SENSELESS_COMPARISON") // layoutCallback can be null here since this method can be called in init
+        if (!isLayoutEnqueued && layoutCallback != null) {
+            isLayoutEnqueued = true
+            // we use NATIVE_ANIMATED_MODULE choreographer queue because it allows us to catch the current
+            // looper loop instead of enqueueing the update in the next loop causing a one frame delay.
+            ReactChoreographer
+                .getInstance()
+                .postFrameCallback(
+                    ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
+                    layoutCallback,
+                )
+        }
+    }
+
+    override fun requestLayout() {
+        super.requestLayout()
+        refreshLayout()
+    }
+
+    private fun forceSubtreeMeasureAndLayoutPass() {
+        measure(
+            MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY),
+        )
+
+        layout(left, top, right, bottom)
+    }
+
+    internal fun onViewManagerAddEventEmitters() {
+        // When this is called from View Manager the view tag is already set
+        check(id != NO_ID) { "[RNScreens] TabsHost must have its tag set when registering event emitters" }
+        eventEmitter = TabsHostEventEmitter(reactContext, id)
+    }
+
+    override fun onNavigationStateUpdate(
+        navState: TabsNavigationState,
+        isRepeated: Boolean,
+        hasTriggeredSpecialEffect: Boolean,
+        actionOrigin: TabsActionOrigin,
+    ) {
+        eventEmitter.emitOnTabSelectedEvent(
+            navState.selectedScreenKey,
+            navState.provenance,
+            isRepeated,
+            hasTriggeredSpecialEffect,
+            actionOrigin,
+        )
+    }
+
+    override fun onNavigationStateUpdateRejected(
+        currentNavState: TabsNavigationState,
+        rejectedRequest: TabsNavigationStateUpdateRequest,
+        reason: TabsNavigationStateRejectionReason,
+    ) {
+        eventEmitter.emitOnTabSelectionRejectedEvent(
+            currentNavState,
+            rejectedRequest,
+            reason,
+        )
+    }
+
+    override fun onNavigationStateUpdatePrevented(
+        currentNavState: TabsNavigationState,
+        preventedScreenKey: String,
+    ) {
+        eventEmitter.emitOnTabSelectionPreventedEvent(currentNavState, preventedScreenKey)
+    }
+
+    override fun didMountItems(uiManager: UIManager) {
+        container.flushPendingUpdates()
+    }
+
+    /**
+     * Called by [TabsHostViewManager.onDropViewInstance] when this view is recycled.
+     * Idempotent: safe to call multiple times.
+     */
+    internal fun tearDown() {
+        container.removeNavigationStateObserver(this)
+        container.tearDown()
+        UIManagerHelper
+            .getFabricUIManagerNotNull(reactContext)
+            .removeUIManagerEventListener(this)
+    }
+
+    override fun willDispatchViewUpdates(uiManager: UIManager) = Unit
+
+    override fun willMountItems(uiManager: UIManager) = Unit
+
+    override fun didDispatchMountItems(uiManager: UIManager) = Unit
+
+    override fun didScheduleMountItems(uiManager: UIManager) = Unit
+
+    companion object {
+        const val TAG = "TabsHost"
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/{TabsHostA11yCoordinator.kt → host/TabsHostA11yCoordinator.kt}

@@ -1,10 +1,12 @@
-package com.swmansion.rnscreens.gamma.tabs
+package com.swmansion.rnscreens.gamma.tabs.host
 
 import android.os.Build
 import android.view.MenuItem
 import androidx.core.view.get
 import com.google.android.material.bottomnavigation.BottomNavigationView
 import com.google.android.material.navigation.NavigationBarItemView
+import com.swmansion.rnscreens.gamma.tabs.screen.TabsScreen
+import com.swmansion.rnscreens.gamma.tabs.screen.TabsScreenFragment
 
 class TabsHostA11yCoordinator(
     private val bottomNavigationView: BottomNavigationView,

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

@@ -0,0 +1,77 @@
+package com.swmansion.rnscreens.gamma.tabs.host
+
+import com.facebook.react.bridge.ReactContext
+import com.swmansion.rnscreens.gamma.common.event.BaseEventEmitter
+import com.swmansion.rnscreens.gamma.tabs.container.TabsActionOrigin
+import com.swmansion.rnscreens.gamma.tabs.container.TabsNavigationState
+import com.swmansion.rnscreens.gamma.tabs.container.TabsNavigationStateRejectionReason
+import com.swmansion.rnscreens.gamma.tabs.container.TabsNavigationStateUpdateRequest
+import com.swmansion.rnscreens.gamma.tabs.host.event.TabsHostTabSelectedEvent
+import com.swmansion.rnscreens.gamma.tabs.host.event.TabsHostTabSelectionPreventedEvent
+import com.swmansion.rnscreens.gamma.tabs.host.event.TabsHostTabSelectionRejectedEvent
+
+internal class TabsHostEventEmitter(
+    reactContext: ReactContext,
+    viewTag: Int,
+) : BaseEventEmitter(reactContext, viewTag) {
+    /**
+     * Emits `onTabSelected` event to JS with the current navigation state and selection context.
+     */
+    fun emitOnTabSelectedEvent(
+        selectedScreenKey: String,
+        provenance: Int,
+        isRepeated: Boolean,
+        hasTriggeredSpecialEffect: Boolean,
+        actionOrigin: TabsActionOrigin,
+    ) {
+        reactEventDispatcher.dispatchEvent(
+            TabsHostTabSelectedEvent(
+                surfaceId,
+                viewTag,
+                selectedScreenKey,
+                provenance,
+                isRepeated,
+                hasTriggeredSpecialEffect,
+                actionOrigin,
+            ),
+        )
+    }
+
+    /**
+     * Emits `onTabSelectionRejected` event to JS when a navigation state update is rejected.
+     * Carries both the active state and the rejected update so that JS can reconcile.
+     */
+    fun emitOnTabSelectionRejectedEvent(
+        currentNavState: TabsNavigationState,
+        rejectedRequest: TabsNavigationStateUpdateRequest,
+        rejectionReason: TabsNavigationStateRejectionReason,
+    ) {
+        reactEventDispatcher.dispatchEvent(
+            TabsHostTabSelectionRejectedEvent(
+                surfaceId,
+                viewTag,
+                currentNavState,
+                rejectedRequest,
+                rejectionReason,
+            ),
+        )
+    }
+
+    /**
+     * Emits `onTabSelectionPrevented` event to JS when a tab selection is prevented
+     * because the target screen has `preventNativeSelection` enabled.
+     */
+    fun emitOnTabSelectionPreventedEvent(
+        currentNavState: TabsNavigationState,
+        preventedScreenKey: String,
+    ) {
+        reactEventDispatcher.dispatchEvent(
+            TabsHostTabSelectionPreventedEvent(
+                surfaceId,
+                viewTag,
+                currentNavState,
+                preventedScreenKey,
+            ),
+        )
+    }
+}

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

@@ -0,0 +1,140 @@
+package com.swmansion.rnscreens.gamma.tabs.host
+
+import android.view.View
+import com.facebook.react.bridge.JSApplicationIllegalArgumentException
+import com.facebook.react.bridge.ReadableMap
+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.RNSTabsHostAndroidManagerDelegate
+import com.facebook.react.viewmanagers.RNSTabsHostAndroidManagerInterface
+import com.swmansion.rnscreens.gamma.common.colorscheme.ColorScheme
+import com.swmansion.rnscreens.gamma.helpers.makeEventRegistrationInfo
+import com.swmansion.rnscreens.gamma.tabs.container.TabsActionOrigin
+import com.swmansion.rnscreens.gamma.tabs.container.TabsNavigationStateUpdateRequest
+import com.swmansion.rnscreens.gamma.tabs.host.event.TabsHostTabSelectedEvent
+import com.swmansion.rnscreens.gamma.tabs.host.event.TabsHostTabSelectionPreventedEvent
+import com.swmansion.rnscreens.gamma.tabs.host.event.TabsHostTabSelectionRejectedEvent
+import com.swmansion.rnscreens.gamma.tabs.screen.TabsScreen
+
+@ReactModule(name = TabsHostViewManager.REACT_CLASS)
+class TabsHostViewManager :
+    ViewGroupManager<TabsHost>(),
+    RNSTabsHostAndroidManagerInterface<TabsHost> {
+    private val delegate: ViewManagerDelegate<TabsHost> = RNSTabsHostAndroidManagerDelegate<TabsHost, TabsHostViewManager>(this)
+
+    override fun getName() = REACT_CLASS
+
+    override fun createViewInstance(reactContext: ThemedReactContext) = TabsHost(reactContext)
+
+    protected override fun getDelegate(): ViewManagerDelegate<TabsHost> = delegate
+
+    override fun addView(
+        parent: TabsHost,
+        child: View,
+        index: Int,
+    ) {
+        require(child is TabsScreen) { "[RNScreens] Attempt to attach child that is not of type ${TabsScreen::javaClass.name}" }
+        parent.mountReactSubviewAt(child, index)
+    }
+
+    override fun removeView(
+        parent: TabsHost,
+        child: View,
+    ) {
+        require(child is TabsScreen) { "[RNScreens] Attempt to detach child that is not of type ${TabsScreen::javaClass.name}" }
+        parent.unmountReactSubview(child)
+    }
+
+    override fun removeViewAt(
+        parent: TabsHost,
+        index: Int,
+    ) {
+        parent.unmountReactSubviewAt(index)
+    }
+
+    override fun removeAllViews(parent: TabsHost) {
+        parent.unmountAllReactSubviews()
+    }
+
+    override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> =
+        mutableMapOf(
+            makeEventRegistrationInfo(TabsHostTabSelectedEvent),
+            makeEventRegistrationInfo(TabsHostTabSelectionPreventedEvent),
+            makeEventRegistrationInfo(TabsHostTabSelectionRejectedEvent),
+        )
+
+    override fun addEventEmitters(
+        reactContext: ThemedReactContext,
+        view: TabsHost,
+    ) {
+        super.addEventEmitters(reactContext, view)
+        view.onViewManagerAddEventEmitters()
+    }
+
+    override fun onDropViewInstance(view: TabsHost) {
+        view.tearDown()
+        super.onDropViewInstance(view)
+    }
+
+    override fun setNavStateRequest(
+        view: TabsHost,
+        value: ReadableMap?,
+    ) {
+        val navStateRequestMap = requireNotNull(value) { "[RNScreens] navStateRequest must not be nullish" }
+        val selectedScreenKey = requireNotNull(navStateRequestMap.getString("selectedScreenKey"))
+        val baseProvenance = requireNotNull(navStateRequestMap.getInt("baseProvenance"))
+        view.updateJSNavigationStateUpdateRequest(
+            TabsNavigationStateUpdateRequest(
+                selectedScreenKey = selectedScreenKey,
+                baseProvenance = baseProvenance,
+                actionOrigin = TabsActionOrigin.PROGRAMMATIC_JS,
+            ),
+        )
+    }
+
+    override fun setRejectStaleNavStateUpdates(
+        view: TabsHost,
+        value: Boolean,
+    ) {
+        view.rejectStaleNavigationStateUpdates = value
+    }
+
+    override fun setTabBarHidden(
+        view: TabsHost,
+        value: Boolean,
+    ) {
+        view.tabBarHidden = value
+    }
+
+    override fun setNativeContainerBackgroundColor(
+        view: TabsHost,
+        value: Int?,
+    ) {
+        view.nativeContainerBackgroundColor = value
+    }
+
+    override fun setTabBarRespectsIMEInsets(
+        view: TabsHost,
+        value: Boolean,
+    ) {
+        view.tabBarRespectsIMEInsets = value
+    }
+
+    override fun setColorScheme(
+        view: TabsHost,
+        value: String?,
+    ) {
+        when (value) {
+            "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 = "RNSTabsHostAndroid"
+    }
+}