react-native-navigation 8.8.1 → 8.8.2-snapshot.2425

package/android/build.gradle

@@ -130,6 +130,7 @@ dependencies {
     implementation "androidx.constraintlayout:constraintlayout:2.0.4"
 
     implementation 'androidx.appcompat:appcompat:1.7.0'
+    implementation 'androidx.activity:activity:1.9.0'
     implementation 'androidx.annotation:annotation:1.2.0'
     implementation 'com.google.android.material:material:1.2.0-alpha03'
 

package/android/src/main/java/com/reactnativenavigation/NavigationActivity.java

@@ -7,6 +7,7 @@ import android.os.Build;
 import android.os.Bundle;
 import android.view.KeyEvent;
 import android.view.View;
+import android.view.ViewGroup;
 
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 import com.facebook.react.modules.core.PermissionAwareActivity;
@@ -17,10 +18,12 @@ import com.reactnativenavigation.viewcontrollers.viewcontroller.RootPresenter;
 import com.reactnativenavigation.react.JsDevReloadHandler;
 import com.reactnativenavigation.react.ReactGateway;
 import com.reactnativenavigation.react.CommandListenerAdapter;
+import com.reactnativenavigation.utils.SystemUiUtils;
 import com.reactnativenavigation.viewcontrollers.child.ChildControllersRegistry;
 import com.reactnativenavigation.viewcontrollers.modal.ModalStack;
 import com.reactnativenavigation.viewcontrollers.navigator.Navigator;
 
+import androidx.activity.EdgeToEdge;
 import androidx.activity.OnBackPressedCallback;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -36,6 +39,7 @@ public class NavigationActivity extends AppCompatActivity implements DefaultHard
 
     @Override
     protected void onCreate(@Nullable Bundle savedInstanceState) {
+        enableEdgeToEdge();
         super.onCreate(savedInstanceState);
         if (isFinishing()) {
             return;
@@ -63,7 +67,19 @@ public class NavigationActivity extends AppCompatActivity implements DefaultHard
     @Override
     public void onPostCreate(@Nullable Bundle savedInstanceState) {
         super.onPostCreate(savedInstanceState);
-        navigator.setContentLayout(findViewById(android.R.id.content));
+        ViewGroup contentLayout = findViewById(android.R.id.content);
+        navigator.setContentLayout(contentLayout);
+        SystemUiUtils.setupSystemBarBackgrounds(this, contentLayout);
+        applyThemeStatusBarColor();
+    }
+
+    private void applyThemeStatusBarColor() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM
+                && SystemUiUtils.needsManualStatusBarBackground()) {
+            //noinspection deprecation
+            getWindow().setStatusBarColor(android.graphics.Color.TRANSPARENT);
+            SystemUiUtils.setStatusBarColor(getWindow(), android.graphics.Color.TRANSPARENT);
+        }
     }
 
     @Override
@@ -88,6 +104,7 @@ public class NavigationActivity extends AppCompatActivity implements DefaultHard
     @Override
     protected void onDestroy() {
         super.onDestroy();
+        SystemUiUtils.tearDown();
         if (navigator != null) {
             navigator.destroy();
         }
@@ -146,6 +163,36 @@ public class NavigationActivity extends AppCompatActivity implements DefaultHard
         navigator.destroyViews();
     }
 
+    /**
+     * Controls when edge-to-edge is enabled. Override to customize the decision logic.
+     * Call {@link #activateEdgeToEdge()} from your override to enable edge-to-edge.
+     * <p>
+     * The default implementation enables edge-to-edge only if the app theme sets
+     * {@code windowOptOutEdgeToEdgeEnforcement} to {@code false} (API 35+).
+     * Called at the start of onCreate, before super.onCreate.
+     */
+    protected void enableEdgeToEdge() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM) {
+            android.content.res.TypedArray a = getTheme().obtainStyledAttributes(
+                    new int[]{android.R.attr.windowOptOutEdgeToEdgeEnforcement});
+            boolean optOut = a.getBoolean(0, true);
+            a.recycle();
+            if (!optOut) {
+                activateEdgeToEdge();
+            }
+        }
+    }
+
+    /**
+     * Enables edge-to-edge display and notifies the navigation framework.
+     * Call this from {@link #enableEdgeToEdge()} overrides instead of
+     * calling {@code EdgeToEdge.enable()} directly.
+     */
+    protected void activateEdgeToEdge() {
+        EdgeToEdge.enable(this);
+        SystemUiUtils.activateEdgeToEdge();
+    }
+
     protected void addDefaultSplashLayout() {
         View view = new View(this);
         setContentView(view);

package/android/src/main/java/com/reactnativenavigation/react/modal/ModalHostLayout.kt

@@ -34,8 +34,8 @@ open class ModalHostLayout(reactContext: ThemedReactContext) : ViewGroup(reactCo
     }
 
     @TargetApi(23)
-    override fun dispatchProvideStructure(structure: ViewStructure) {
-        mHostView.dispatchProvideStructure(structure)
+    override fun dispatchProvideStructure(structure: ViewStructure?) {
+        structure?.let { mHostView.dispatchProvideStructure(it) }
     }
 
     override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {}

package/android/src/main/java/com/reactnativenavigation/utils/ReactTypefaceUtils.java

@@ -18,9 +18,8 @@ import android.graphics.Typeface;
 import android.text.TextUtils;
 import androidx.annotation.Nullable;
 import com.facebook.react.bridge.ReadableArray;
-import com.facebook.react.common.ReactConstants;
 import com.facebook.react.views.text.ReactFontManager;
-import com.facebook.react.views.text.ReactTextShadowNode;
+import com.facebook.react.common.ReactConstants;
 import java.util.ArrayList;
 import java.util.List;
 

package/android/src/main/java/com/reactnativenavigation/utils/SystemUiUtils.kt

@@ -3,10 +3,14 @@ package com.reactnativenavigation.utils
 import android.app.Activity
 import android.graphics.Color
 import android.graphics.Rect
+import android.graphics.drawable.ColorDrawable
+import android.view.Gravity
 import android.view.View
+import android.view.ViewGroup
 import android.view.Window
+import android.widget.FrameLayout
 import androidx.annotation.ColorInt
-import androidx.core.view.WindowCompat
+import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
 import kotlin.math.abs
@@ -16,8 +20,18 @@ object SystemUiUtils {
     private const val STATUS_BAR_HEIGHT_M = 24
     internal const val STATUS_BAR_HEIGHT_TRANSLUCENCY = 0.65f
     private var statusBarHeight = -1
-    var navigationBarDefaultColor = -1
+
+    const val DEFAULT_NAV_BAR_COLOR = Color.BLACK
+    private const val THREE_BUTTON_NAV_BAR_OPACITY = 0.8f
+
+    private var statusBarBackgroundView: View? = null
+    private var statusBarBackgroundActivity: java.lang.ref.WeakReference<Activity>? = null
+    private var navBarBackgroundView: View? = null
+    @JvmStatic
+    var isEdgeToEdgeActive = false
         private set
+    private var isThreeButtonNav = false
+    private var lastExplicitNavBarColor: Int? = null
 
     @JvmStatic
     fun getStatusBarHeight(activity: Activity?): Int {
@@ -45,98 +59,222 @@ object SystemUiUtils {
         statusBarHeight = height
     }
 
-
     @JvmStatic
     fun getStatusBarHeightDp(activity: Activity?): Int {
-        return UiUtils.pxToDp(activity, getStatusBarHeight(activity).toFloat())
-            .toInt()
+        return UiUtils.pxToDp(activity, getStatusBarHeight(activity).toFloat()).toInt()
     }
 
+    // region Setup
+
+    /**
+     * Initializes view-based system bar backgrounds for edge-to-edge.
+     * Call from Activity.onPostCreate after the navigator content layout is set.
+     *
+     * Status bar: reuses the system's android:id/statusBarBackground DecorView child
+     * when available. On API 35+ with EdgeToEdge, this view may not exist, so a
+     * manual view is created in the content layout, sized by status bar insets.
+     * Navigation bar: creates a view in [contentLayout] sized by WindowInsets,
+     * since the system's navigationBarBackground is not available with EdgeToEdge.
+     */
     @JvmStatic
-    fun hideNavigationBar(window: Window?, view: View) {
-        window?.let {
-            WindowCompat.setDecorFitsSystemWindows(window, false)
-            WindowInsetsControllerCompat(window, view).let { controller ->
-                controller.hide(WindowInsetsCompat.Type.navigationBars())
-                controller.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+    fun setupSystemBarBackgrounds(activity: Activity, contentLayout: ViewGroup) {
+        setupStatusBarBackground(activity)
+        setupNavigationBarBackground(contentLayout)
+    }
+
+    private fun setupStatusBarBackground(activity: Activity) {
+        if (statusBarBackgroundView != null) return
+        val sbView = activity.window.decorView.findViewById<View>(android.R.id.statusBarBackground)
+        if (sbView != null) {
+            statusBarBackgroundView = sbView
+        } else {
+            statusBarBackgroundActivity = java.lang.ref.WeakReference(activity)
+        }
+    }
+
+    private fun ensureStatusBarBackgroundView(): View? {
+        statusBarBackgroundView?.let { return it }
+        val activity = statusBarBackgroundActivity?.get() ?: return null
+        val contentLayout = activity.findViewById<ViewGroup>(android.R.id.content) ?: return null
+        val view = View(activity)
+        val params = FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT, 0, Gravity.TOP
+        )
+        contentLayout.addView(view, params)
+        statusBarBackgroundView = view
+        statusBarBackgroundActivity = null
+
+        ViewCompat.setOnApplyWindowInsetsListener(view) { v, insets ->
+            val sbHeight = insets.getInsets(WindowInsetsCompat.Type.statusBars()).top
+            val lp = v.layoutParams
+            if (lp.height != sbHeight) {
+                lp.height = sbHeight
+                v.layoutParams = lp
             }
+            insets
         }
+        view.requestApplyInsets()
+        return view
     }
 
-    @JvmStatic
-    fun showNavigationBar(window: Window?, view: View) {
-        window?.let {
-            WindowCompat.setDecorFitsSystemWindows(window, true)
-            WindowInsetsControllerCompat(window, view).show(WindowInsetsCompat.Type.navigationBars())
+    private fun setupNavigationBarBackground(contentLayout: ViewGroup) {
+        if (navBarBackgroundView != null) return
+        val view = View(contentLayout.context).apply {
+            setBackgroundColor(Color.BLACK)
         }
+        val params = FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT, 0, Gravity.BOTTOM
+        )
+        contentLayout.addView(view, params)
+        navBarBackgroundView = view
+
+        ViewCompat.setOnApplyWindowInsetsListener(view) { v, insets ->
+            val navBarHeight = insets.getInsets(WindowInsetsCompat.Type.navigationBars()).bottom
+            val tappableHeight = insets.getInsets(WindowInsetsCompat.Type.tappableElement()).bottom
+            val wasThreeButton = isThreeButtonNav
+            isThreeButtonNav = tappableHeight > 0
+            if (isThreeButtonNav != wasThreeButton) {
+                val color = lastExplicitNavBarColor ?: getDefaultNavBarColor()
+                v.setBackgroundColor(color)
+            }
+            val lp = v.layoutParams
+            if (lp.height != navBarHeight) {
+                lp.height = navBarHeight
+                v.layoutParams = lp
+            }
+            insets
+        }
+        view.requestApplyInsets()
+    }
+
+    /**
+     * Returns the default navigation bar color, applying 80% opacity for 3-button navigation.
+     * Gesture navigation gets a fully opaque color since the bar is minimal.
+     */
+    @JvmStatic
+    fun getDefaultNavBarColor(): Int {
+        if (!isThreeButtonNav) return DEFAULT_NAV_BAR_COLOR
+        val alpha = (THREE_BUTTON_NAV_BAR_OPACITY * 255).toInt()
+        return Color.argb(alpha, Color.red(DEFAULT_NAV_BAR_COLOR), Color.green(DEFAULT_NAV_BAR_COLOR), Color.blue(DEFAULT_NAV_BAR_COLOR))
+    }
+
+    /**
+     * Returns true when the system statusBarBackground view was not found during setup,
+     * meaning a manual view will be lazily created on the first setStatusBarColor call.
+     * Use this to decide whether to apply a theme-based initial status bar color.
+     */
+    @JvmStatic
+    fun needsManualStatusBarBackground(): Boolean = statusBarBackgroundActivity != null
+
+    /**
+     * Marks edge-to-edge as active. Call after EdgeToEdge.enable() in the activity.
+     * This flag controls whether navigation bar insets are forwarded to SafeAreaView
+     * and whether the view-based nav bar background is used for color changes.
+     */
+    @JvmStatic
+    fun activateEdgeToEdge() {
+        isEdgeToEdgeActive = true
+    }
+
+    /**
+     * Clears references to system bar background views.
+     * Call from Activity.onDestroy to avoid leaking views across activity recreation.
+     */
+    @JvmStatic
+    fun tearDown() {
+        statusBarBackgroundView = null
+        statusBarBackgroundActivity = null
+        navBarBackgroundView = null
+        isEdgeToEdgeActive = false
+        isThreeButtonNav = false
+        lastExplicitNavBarColor = null
+        statusBarHeight = -1
     }
 
+    // endregion
+
+    // region Status Bar
+
     @JvmStatic
     fun setStatusBarColorScheme(window: Window?, view: View, isDark: Boolean) {
         window?.let {
             WindowInsetsControllerCompat(window, view).isAppearanceLightStatusBars = isDark
-           // Workaround: on devices with api 30 status bar icons flickers or get hidden when removing view
-            //turns out it is a bug on such devices, fixed by using system flags until it is fixed.
-            var flags = view.systemUiVisibility
-            flags = if (isDark) {
-                flags or View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
-            } else {
-                flags and View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR.inv()
-            }
-
-            view.systemUiVisibility = flags
         }
     }
 
     @JvmStatic
     fun setStatusBarTranslucent(window: Window?) {
-        window?.let {
-            setStatusBarColor(window, window.statusBarColor, true)
+        getStatusBarColor(window)?.let { currentColor ->
+            setStatusBarColor(window, currentColor, true)
         }
     }
 
     @JvmStatic
     fun isTranslucent(window: Window?): Boolean {
-        return window?.let {
-            Color.alpha(it.statusBarColor) < 255
-        } ?: false
+        val color = getStatusBarColor(window) ?: return false
+        return Color.alpha(color) < 255
     }
 
     @JvmStatic
     fun clearStatusBarTranslucency(window: Window?) {
-        window?.let {
-            setStatusBarColor(it, it.statusBarColor, false)
+        getStatusBarColor(window)?.let { currentColor ->
+            setStatusBarColor(window, currentColor, false)
         }
     }
 
     @JvmStatic
-    fun setStatusBarColor(
-        window: Window?,
-        @ColorInt color: Int,
-        translucent: Boolean
-    ) {
+    fun setStatusBarColor(window: Window?, @ColorInt color: Int, translucent: Boolean) {
         val colorAlpha = Color.alpha(color)
-        val alpha = if (translucent && colorAlpha == 255) STATUS_BAR_HEIGHT_TRANSLUCENCY else colorAlpha/255.0f
-        val red: Int = Color.red(color)
-        val green: Int = Color.green(color)
-        val blue: Int = Color.blue(color)
-        val opaqueColor = Color.argb(ceil(alpha * 255).toInt(), red, green, blue)
-        setStatusBarColor(window, opaqueColor)
+        val alpha = if (translucent && colorAlpha == 255) STATUS_BAR_HEIGHT_TRANSLUCENCY else colorAlpha / 255.0f
+        val opaqueColor = Color.argb(
+            ceil(alpha * 255).toInt(),
+            Color.red(color),
+            Color.green(color),
+            Color.blue(color)
+        )
+        applyStatusBarColor(window, opaqueColor)
     }
 
+    /**
+     * Sets the status bar background color, lazily creating a manual view on API 35+
+     * if the system view wasn't available at setup time. Use this for explicit app-level
+     * color requests (e.g. from MainActivity or NavigationActivity).
+     */
+    @JvmStatic
     fun setStatusBarColor(window: Window?, color: Int) {
-        window?.statusBarColor = color
+        val view = ensureStatusBarBackgroundView()
+        if (view != null) {
+            view.setBackgroundColor(color)
+        } else {
+            @Suppress("DEPRECATION")
+            window?.statusBarColor = color
+        }
     }
 
+    private fun applyStatusBarColor(window: Window?, color: Int) {
+        statusBarBackgroundView?.setBackgroundColor(color) ?: run {
+            @Suppress("DEPRECATION")
+            window?.statusBarColor = color
+        }
+    }
+
+    /**
+     * Gets the current status bar background color.
+     * Reads from the view-based background when available,
+     * falls back to the deprecated window API on older configurations.
+     */
     @JvmStatic
     fun getStatusBarColor(window: Window?): Int? {
+        statusBarBackgroundView?.let { view ->
+            (view.background as? ColorDrawable)?.let { return it.color }
+        }
+        @Suppress("DEPRECATION")
         return window?.statusBarColor
     }
 
     @JvmStatic
     fun hideStatusBar(window: Window?, view: View) {
         window?.let {
-            WindowCompat.setDecorFitsSystemWindows(window, false)
             WindowInsetsControllerCompat(window, view).let { controller ->
                 controller.hide(WindowInsetsCompat.Type.statusBars())
                 controller.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
@@ -147,22 +285,49 @@ object SystemUiUtils {
     @JvmStatic
     fun showStatusBar(window: Window?, view: View) {
         window?.let {
-            WindowCompat.setDecorFitsSystemWindows(window, true)
             WindowInsetsControllerCompat(window, view).show(WindowInsetsCompat.Type.statusBars())
         }
     }
 
+    // endregion
+
+    // region Navigation Bar
+
     @JvmStatic
-    fun setNavigationBarBackgroundColor(window: Window?, color: Int, lightColor: Boolean) {
+    fun hideNavigationBar(window: Window?, view: View) {
         window?.let {
-            if (navigationBarDefaultColor == -1) {
-                navigationBarDefaultColor = window.navigationBarColor
-            }
-            WindowInsetsControllerCompat(window, window.decorView).let { controller ->
-                controller.isAppearanceLightNavigationBars = lightColor
+            WindowInsetsControllerCompat(window, view).let { controller ->
+                controller.hide(WindowInsetsCompat.Type.navigationBars())
+                controller.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
             }
-            window.navigationBarColor = color
         }
     }
 
+    @JvmStatic
+    fun showNavigationBar(window: Window?, view: View) {
+        window?.let {
+            WindowInsetsControllerCompat(window, view).show(WindowInsetsCompat.Type.navigationBars())
+        }
+    }
+
+    /**
+     * Sets the navigation bar background color and icon appearance.
+     * Uses the view-based background when available (edge-to-edge),
+     * falls back to the deprecated window API on older configurations.
+     */
+    @JvmStatic
+    fun setNavigationBarBackgroundColor(window: Window?, color: Int, lightColor: Boolean) {
+        lastExplicitNavBarColor = color
+        window?.let {
+            WindowInsetsControllerCompat(window, window.decorView).isAppearanceLightNavigationBars = lightColor
+        }
+        if (isEdgeToEdgeActive) {
+            navBarBackgroundView?.setBackgroundColor(color)
+        } else {
+            @Suppress("DEPRECATION")
+            window?.navigationBarColor = color
+        }
+    }
+
+    // endregion
 }

package/android/src/main/java/com/reactnativenavigation/viewcontrollers/bottomtabs/BottomTabsController.java

@@ -254,12 +254,13 @@ public class BottomTabsController extends ParentController<BottomTabsLayout> imp
 
     @Override
     public int getBottomInset(ViewController<?> child) {
-        return presenter.getBottomInset(resolveChildOptions(child)) + perform(getParentController(), 0, p -> p.getBottomInset(this));
+        return presenter.getChildrenBottomInset(resolveChildOptions(child)) + perform(getParentController(), 0, p -> p.getBottomInset(this));
     }
 
     @Override
     public void applyBottomInset() {
-        presenter.applyBottomInset(getBottomInset());
+        presenter.applyChildrenInset(getBottomInset());
+        presenter.applySelfInset(getBottomInset());
         super.applyBottomInset();
     }
 

package/android/src/main/java/com/reactnativenavigation/viewcontrollers/bottomtabs/BottomTabsPresenter.kt

@@ -1,6 +1,7 @@
 package com.reactnativenavigation.viewcontrollers.bottomtabs
 
 import android.animation.Animator
+import android.app.Activity
 import android.graphics.Color
 import android.view.ViewGroup
 import android.view.ViewGroup.LayoutParams.WRAP_CONTENT
@@ -12,6 +13,8 @@ import com.reactnativenavigation.RNNToggles.TAB_BAR_TRANSLUCENCE
 import com.reactnativenavigation.options.Options
 import com.reactnativenavigation.options.params.BottomTabsLayoutStyle
 import com.reactnativenavigation.options.params.Fraction
+import com.reactnativenavigation.utils.ColorUtils.isColorLight
+import com.reactnativenavigation.utils.SystemUiUtils
 import com.reactnativenavigation.utils.UiUtils
 import com.reactnativenavigation.viewcontrollers.viewcontroller.ViewController
 import com.reactnativenavigation.views.bottomtabs.BottomTabs
@@ -92,7 +95,9 @@ class BottomTabsPresenter(
 
         // Keep this before the translucent check below
         if (bottomTabsOptions.backgroundColor.hasValue()) {
-            bottomTabsContainer.setBackgroundColor(bottomTabsOptions.backgroundColor.get())
+            val color = bottomTabsOptions.backgroundColor.get()
+            bottomTabsContainer.setBackgroundColor(color)
+            syncNavigationBarColor(options, color)
         }
 
         if (RNNFeatureToggles.isEnabled(TAB_BAR_TRANSLUCENCE)) {
@@ -212,7 +217,9 @@ class BottomTabsPresenter(
             bottomTabsContainer.enableBackgroundBlur()
         } else {
             bottomTabsContainer.disableBackgroundBlur()
-            bottomTabsContainer.setBackgroundColor(bottomTabsOptions.backgroundColor.get(Color.WHITE)!!)
+            val color = bottomTabsOptions.backgroundColor.get(Color.WHITE)!!
+            bottomTabsContainer.setBackgroundColor(color)
+            syncNavigationBarColor(options, color)
         }
 
         bottomTabs.setLayoutDirection(options.layout.direction)
@@ -282,13 +289,17 @@ class BottomTabsPresenter(
         bottomTabs.setBehaviorTranslationEnabled(bottomTabsOptions.hideOnScroll[false])
     }
 
-    fun applyBottomInset(bottomInset: Int) {
+    fun applyChildrenInset(bottomInset: Int) {
         (bottomTabsContainer.layoutParams as ViewGroup.MarginLayoutParams).updateMargins(bottom = bottomInset)
         bottomTabsContainer.requestLayout()
     }
 
-    fun getBottomInset(resolvedOptions: Options): Int {
-        return if (resolvedOptions.withDefaultOptions(defaultOptions).bottomTabsOptions.isHiddenOrDrawBehind) 0 else bottomTabs.height
+    fun getChildrenBottomInset(resolvedOptions: Options): Int {
+        return if (resolvedOptions.withDefaultOptions(defaultOptions).bottomTabsOptions.isHiddenOrDrawBehind) 0 else (bottomTabsContainer.height)
+    }
+
+    fun applySelfInset(bottomInset: Int) {
+        bottomTabsContainer.setBottomInset(bottomInset)
     }
 
     fun getPushAnimation(appearingOptions: Options): Animator? {
@@ -351,7 +362,9 @@ class BottomTabsPresenter(
             bottomTabsContainer.disableBackgroundBlur()
 
             // TODO Change to bottomTabsContainer.setBackgroundColor()?
-            bottomTabs.setBackgroundColor(bottomTabsOptions.backgroundColor.get(Color.WHITE)!!)
+            val color = bottomTabsOptions.backgroundColor.get(Color.WHITE)!!
+            bottomTabs.setBackgroundColor(color)
+            syncNavigationBarColor(options, color)
         }
 
         if (bottomTabsOptions.shadowOptions.hasValue()) {
@@ -376,4 +389,11 @@ class BottomTabsPresenter(
         val margin = UiUtils.dpToPx(bottomTabsContainer.context, marginDp.toFloat()).roundToInt()
         return margin
     }
+
+    private fun syncNavigationBarColor(options: Options, tabsColor: Int) {
+        val resolved = options.copy().withDefaultOptions(defaultOptions)
+        if (resolved.navigationBar.backgroundColor.hasValue()) return
+        val window = (bottomTabsContainer.context as? Activity)?.window ?: return
+        SystemUiUtils.setNavigationBarBackgroundColor(window, tabsColor, isColorLight(tabsColor))
+    }
 }

package/android/src/main/java/com/reactnativenavigation/viewcontrollers/component/ComponentViewController.java

@@ -172,9 +172,12 @@ public class ComponentViewController extends ChildController<ComponentLayout> {
         int systemWindowInsetTop = insets.getInsets(WindowInsetsCompat.Type.statusBars()).top +
                 insets.getInsets(WindowInsetsCompat.Type.navigationBars()).top -
                 systemBarsInsets.top;
-        int systemWindowInsetBottom = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom +
-                insets.getInsets(WindowInsetsCompat.Type.navigationBars()).bottom -
-                systemBarsInsets.bottom;
+
+        int navBarBottom = insets.getInsets(WindowInsetsCompat.Type.navigationBars()).bottom;
+        int imeBottom = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom;
+        int systemWindowInsetBottom = SystemUiUtils.isEdgeToEdgeActive()
+                ? Math.max(imeBottom, navBarBottom)
+                : imeBottom;
 
         WindowInsetsCompat finalInsets = new WindowInsetsCompat.Builder()
                 .setInsets(WindowInsetsCompat.Type.systemBars() | WindowInsetsCompat.Type.ime(),

package/android/src/main/java/com/reactnativenavigation/viewcontrollers/viewcontroller/LayoutDirectionApplier.kt

@@ -1,7 +1,6 @@
 package com.reactnativenavigation.viewcontrollers.viewcontroller
 
 import android.annotation.SuppressLint
-import com.facebook.react.ReactInstanceManager
 import com.facebook.react.modules.i18nmanager.I18nUtil
 import com.reactnativenavigation.options.Options
 
@@ -16,4 +15,4 @@ class LayoutDirectionApplier {
             I18nUtil.instance.forceRTL(currentContext, options.layout.direction.isRtl)
         }
     }
-}
+}

package/android/src/main/java/com/reactnativenavigation/viewcontrollers/viewcontroller/Presenter.java

@@ -136,14 +136,12 @@ public class Presenter {
     }
 
     private void setNavigationBarBackgroundColor(NavigationBarOptions navigationBar) {
-        int navigationBarDefaultColor = SystemUiUtils.INSTANCE.getNavigationBarDefaultColor();
-        navigationBarDefaultColor = navigationBarDefaultColor == -1 ? Color.BLACK : navigationBarDefaultColor;
+        int defaultColor = SystemUiUtils.getDefaultNavBarColor();
         if (navigationBar.backgroundColor.canApplyValue()) {
-            int color = navigationBar.backgroundColor.get(navigationBarDefaultColor);
+            int color = navigationBar.backgroundColor.get(defaultColor);
             SystemUiUtils.setNavigationBarBackgroundColor(activity.getWindow(), color, isColorLight(color));
         } else {
-            SystemUiUtils.setNavigationBarBackgroundColor(activity.getWindow(), navigationBarDefaultColor, isColorLight(navigationBarDefaultColor));
-
+            SystemUiUtils.setNavigationBarBackgroundColor(activity.getWindow(), defaultColor, isColorLight(defaultColor));
         }
     }
 

package/android/src/main/java/com/reactnativenavigation/viewcontrollers/viewcontroller/ViewController.java

@@ -430,17 +430,13 @@ public abstract class ViewController<T extends ViewGroup> implements ViewTreeObs
         return false;
     }
 
-    public void applyTopInset() {
-
-    }
+    public void applyTopInset() {}
 
     public int getTopInset() {
         return 0;
     }
 
-    public void applyBottomInset() {
-
-    }
+    public void applyBottomInset() {}
 
     public int getBottomInset() {
         return perform(parentController, 0, p -> p.getBottomInset(this));

package/android/src/main/java/com/reactnativenavigation/views/bottomtabs/BottomTabsContainer.kt

@@ -12,6 +12,7 @@ import android.widget.FrameLayout.LayoutParams.WRAP_CONTENT
 import android.widget.LinearLayout
 import androidx.annotation.RestrictTo
 import androidx.core.graphics.ColorUtils
+import androidx.core.view.updatePadding
 import com.reactnativenavigation.options.params.Fraction
 import com.reactnativenavigation.utils.UiUtils.dpToPx
 import eightbitlab.com.blurview.BlurTarget
@@ -176,4 +177,8 @@ class BottomTabsContainer(context: Context, val bottomTabs: BottomTabs) : Shadow
     fun setElevation(elevation: Fraction) {
         setElevation(dpToPx(context, elevation.get().toFloat()))
     }
+
+    fun setBottomInset(bottomInset: Int) {
+        blurringView.updatePadding(bottom = bottomInset)
+    }
 }