react-native-navigation 8.8.5 → 8.8.6-snapshot.2571

package/android/src/main/java/com/reactnativenavigation/customrow/BottomTabsCustomRowLayout.kt

@@ -0,0 +1,139 @@
+package com.reactnativenavigation.customrow
+
+import android.app.Activity
+import android.os.Build
+import android.util.TypedValue
+import android.view.View
+import android.view.ViewGroup
+import com.reactnativenavigation.views.bottomtabs.BottomTabs
+
+/**
+ * Resolves how the floating custom row should anchor and whether the bottom
+ * system-bar inset belongs inside the row or was already applied by RNN's
+ * [com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabsController].
+ *
+ * On most devices (including Pixel with gesture/3-button nav) RNN pads the
+ * bottom-tabs controller by `systemBars().bottom`, so the native bar already
+ * sits above the nav area — adding the same inset again creates a visible gap.
+ *
+ * With edge-to-edge (API 35+ theme opt-in) content can extend behind the nav
+ * bar; the row must pin to the overlay host bottom and reserve inset inside.
+ */
+internal object BottomTabsCustomRowLayout {
+
+    enum class AnchorMode {
+        /** Native bar bottom is already above system bars (RNN bottom padding). */
+        NATIVE_BAR_ABOVE_SYSTEM_BARS,
+        /** Row extends to the host bottom; inset is applied inside the row. */
+        EDGE_TO_EDGE,
+    }
+
+    data class Placement(
+        val anchorMode: AnchorMode,
+        /** Inset applied inside the row for cell/chrome layout (0 when native bar already cleared it). */
+        val rowSafeBottomInsetPx: Int,
+        val left: Int,
+        val top: Int,
+        val width: Int,
+        val height: Int,
+    )
+
+    fun resolvePlacement(
+        activity: Activity,
+        row: BottomTabsCustomRow,
+        bottomTabs: BottomTabs,
+        overlayHost: ViewGroup,
+        navBarInsetPx: Int,
+    ): Placement? {
+        val nativeHeight = bottomTabs.height
+        if (nativeHeight <= 0) return null
+
+        val horizontalMargin = row.effectiveHorizontalMarginPx()
+        val bottomMargin = row.effectiveBottomMarginPx()
+
+        val tabLeftInHost = tabLeftRelativeToHost(bottomTabs, overlayHost)
+        val tabRightInHost = tabLeftInHost + bottomTabs.width
+
+        // Row is hosted on `android.R.id.content`; anchor to `BottomTabs` bottom
+        // (above RNN's nav-bar padding). Never use decor.height — that draws over
+        // the system navigation buttons.
+        val anchorMode = resolveAnchorMode(activity, bottomTabs, overlayHost, navBarInsetPx)
+        val rowSafeBottom = 0
+
+        val contentHeight = row.effectiveContentHeightPx(nativeHeight)
+        val totalHeight = contentHeight + bottomMargin
+
+        val left = tabLeftInHost + horizontalMargin
+        val width = (tabRightInHost - horizontalMargin) - left
+
+        // RNN already lays out `BottomTabs` above its bottom padding — match that
+        // edge. Do not subtract `navBarInsetPx` again (that was lifting the bar).
+        val bottom = tabBottomRelativeToHost(bottomTabs, overlayHost) - bottomMargin
+        val top = bottom - totalHeight
+
+        return Placement(anchorMode, rowSafeBottom, left, top, width, totalHeight)
+    }
+
+    fun resolveAnchorMode(
+        activity: Activity,
+        bottomTabs: BottomTabs,
+        overlayHost: ViewGroup,
+        @Suppress("UNUSED_PARAMETER") navBarInsetPx: Int,
+    ): AnchorMode {
+        // RNN's bottom-tabs host ends at `android.R.id.content` bottom while the
+        // system nav bar sits below that — never treat "flush with content" as
+        // edge-to-edge or we reserve a phantom inset and leave a white gap.
+        if (!isEdgeToEdgeEnabled(activity)) {
+            return AnchorMode.NATIVE_BAR_ABOVE_SYSTEM_BARS
+        }
+        val decor = activity.window?.decorView ?: return AnchorMode.NATIVE_BAR_ABOVE_SYSTEM_BARS
+        val tolerancePx = dpToPx(activity, 4f)
+        val tabBottomOnScreen = screenBottom(bottomTabs)
+        val decorBottomOnScreen = screenBottom(decor)
+        return if (kotlin.math.abs(tabBottomOnScreen - decorBottomOnScreen) <= tolerancePx) {
+            AnchorMode.EDGE_TO_EDGE
+        } else {
+            AnchorMode.NATIVE_BAR_ABOVE_SYSTEM_BARS
+        }
+    }
+
+    private fun screenBottom(view: android.view.View): Int {
+        val loc = IntArray(2).also(view::getLocationOnScreen)
+        return loc[1] + view.height
+    }
+
+    fun isEdgeToEdgeEnabled(activity: Activity): Boolean {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.VANILLA_ICE_CREAM) {
+            return false
+        }
+        val typedValue = TypedValue()
+        val resolved = activity.theme.resolveAttribute(
+            android.R.attr.windowOptOutEdgeToEdgeEnforcement,
+            typedValue,
+            true
+        )
+        return resolved &&
+            typedValue.type == TypedValue.TYPE_INT_BOOLEAN &&
+            typedValue.data == 0
+    }
+
+    private fun tabLeftRelativeToHost(bottomTabs: BottomTabs, overlayHost: ViewGroup): Int {
+        val tabLoc = IntArray(2).also(bottomTabs::getLocationOnScreen)
+        val hostLoc = IntArray(2).also(overlayHost::getLocationOnScreen)
+        return tabLoc[0] - hostLoc[0]
+    }
+
+    private fun tabBottomRelativeToHost(bottomTabs: BottomTabs, overlayHost: ViewGroup): Int {
+        val tabLoc = IntArray(2).also(bottomTabs::getLocationOnScreen)
+        val hostLoc = IntArray(2).also(overlayHost::getLocationOnScreen)
+        val tabTopInHost = tabLoc[1] - hostLoc[1]
+        return tabTopInHost + bottomTabs.height
+    }
+
+    private fun dpToPx(activity: Activity, dp: Float): Int =
+        TypedValue.applyDimension(
+            TypedValue.COMPLEX_UNIT_DIP,
+            dp,
+            activity.resources.displayMetrics
+        ).toInt()
+}

package/android/src/main/java/com/reactnativenavigation/customrow/BottomTabsCustomRowModule.kt

@@ -0,0 +1,37 @@
+package com.reactnativenavigation.customrow
+
+import android.app.Application
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+
+/**
+ * RN bridge module that lets JS push the latest `bottomTabs.customRow`
+ * configuration to native. The JS-side `AndroidCustomRowForwarder`
+ * scans `Navigation.setRoot` / `setDefaultOptions` / `mergeOptions`
+ * payloads and calls [configure] whenever it finds a `customRow` block.
+ */
+@ReactModule(name = BottomTabsCustomRowModule.NAME)
+class BottomTabsCustomRowModule(
+    reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+
+    init {
+        val app = reactContext.applicationContext as? Application
+        if (app != null) BottomTabsCustomRowAttacher.registerOnce(app)
+    }
+
+    override fun getName(): String = NAME
+
+    @ReactMethod
+    fun configure(config: ReadableMap?) {
+        BottomTabsCustomRowConfigStore.update(BottomTabsCustomRowOptions.fromMap(config))
+        BottomTabsCustomRowAttacher.rescan()
+    }
+
+    companion object {
+        const val NAME = "RNNBottomTabsCustomRowModule"
+    }
+}

package/android/src/main/java/com/reactnativenavigation/customrow/BottomTabsCustomRowOptions.kt

@@ -0,0 +1,68 @@
+package com.reactnativenavigation.customrow
+
+import android.graphics.Color
+import com.facebook.react.bridge.ReadableMap
+
+/**
+ * Mirrors the iOS-side `RNNBottomTabsCustomRowOptions` data shape. All
+ * fields are optional. Defaults are chosen to give an Android equivalent
+ * of the iOS 26 floating glass pill on Android 12+ (RenderEffect blur),
+ * and an opaque material chrome on older versions.
+ */
+data class BottomTabsCustomRowOptions(
+    val height: Float? = null,
+    val backgroundColor: Int? = null,
+    val backgroundEffect: BackgroundEffect? = null,
+    val cornerRadius: Float? = null,
+    val horizontalMargin: Float? = null,
+    val bottomMargin: Float? = null,
+) {
+    enum class BackgroundEffect { Glass, Blur, None }
+
+    companion object {
+        fun fromMap(map: ReadableMap?): BottomTabsCustomRowOptions {
+            if (map == null) return BottomTabsCustomRowOptions()
+            return BottomTabsCustomRowOptions(
+                height = map.optFloat("height"),
+                backgroundColor = map.optColor("backgroundColor"),
+                backgroundEffect = map.optEffect("backgroundEffect"),
+                cornerRadius = map.optFloat("cornerRadius"),
+                horizontalMargin = map.optFloat("horizontalMargin"),
+                bottomMargin = map.optFloat("bottomMargin"),
+            )
+        }
+
+        private fun ReadableMap.optFloat(key: String): Float? {
+            if (!hasKey(key) || isNull(key)) return null
+            return getDouble(key).toFloat()
+        }
+
+        private fun ReadableMap.optColor(key: String): Int? {
+            if (!hasKey(key) || isNull(key)) return null
+            // Color may arrive as a number (Android-style int) or a wrapped
+            // theme-color object. Support both shallowly.
+            return when (getType(key)) {
+                com.facebook.react.bridge.ReadableType.Number -> getInt(key)
+                com.facebook.react.bridge.ReadableType.Map -> {
+                    val sub = getMap(key)
+                    val light = sub?.let { if (it.hasKey("light")) it.getInt("light") else null }
+                    light ?: sub?.let { if (it.hasKey("color")) it.getInt("color") else null }
+                }
+                com.facebook.react.bridge.ReadableType.String -> {
+                    runCatching { Color.parseColor(getString(key)) }.getOrNull()
+                }
+                else -> null
+            }
+        }
+
+        private fun ReadableMap.optEffect(key: String): BackgroundEffect? {
+            if (!hasKey(key) || isNull(key)) return null
+            return when (getString(key)?.lowercase()) {
+                "glass" -> BackgroundEffect.Glass
+                "blur" -> BackgroundEffect.Blur
+                "none" -> BackgroundEffect.None
+                else -> null
+            }
+        }
+    }
+}

package/android/src/main/java/com/reactnativenavigation/options/BottomTabOptions.java

@@ -44,6 +44,7 @@ public class BottomTabOptions {
         options.dotIndicator = DotIndicatorOptions.parse(context, json.optJSONObject("dotIndicator"));
         options.selectTabOnPress = BoolParser.parse(json, "selectTabOnPress");
         options.popToRoot = BoolParser.parse(json, "popToRoot");
+        options.component = ComponentOptions.parse(json.optJSONObject("component"));
 
         return options;
     }
@@ -67,6 +68,7 @@ public class BottomTabOptions {
     public Bool selectTabOnPress = new NullBool();
     public Bool popToRoot = new NullBool();
     public FontOptions font = new FontOptions();
+    public ComponentOptions component = new ComponentOptions();
 
 
     void mergeWith(final BottomTabOptions other) {
@@ -90,6 +92,7 @@ public class BottomTabOptions {
         if (other.dotIndicator.hasValue()) dotIndicator = other.dotIndicator;
         if (other.selectTabOnPress.hasValue()) selectTabOnPress = other.selectTabOnPress;
         if (other.popToRoot.hasValue()) popToRoot = other.popToRoot;
+        if (other.component.hasValue()) component = other.component;
     }
 
     void mergeWithDefault(final BottomTabOptions defaultOptions) {
@@ -113,7 +116,7 @@ public class BottomTabOptions {
         if (!dotIndicator.hasValue()) dotIndicator = defaultOptions.dotIndicator;
         if (!selectTabOnPress.hasValue()) selectTabOnPress = defaultOptions.selectTabOnPress;
         if (!popToRoot.hasValue()) popToRoot = defaultOptions.popToRoot;
-
+        if (!component.hasValue()) component = defaultOptions.component;
     }
 
 }

package/android/src/main/java/com/reactnativenavigation/options/NavigationBarOptions.java

@@ -17,20 +17,38 @@ public class NavigationBarOptions {
 
         result.backgroundColor = ThemeColour.parse(context, json.optJSONObject("backgroundColor"));
         result.isVisible = BoolParser.parse(json, "visible");
+        result.drawBehind = BoolParser.parse(json, "drawBehind");
 
         return result;
     }
 
     public ThemeColour backgroundColor = new NullThemeColour();
     public Bool isVisible = new NullBool();
+    public Bool drawBehind = new NullBool();
 
     public void mergeWith(NavigationBarOptions other) {
         if (other.isVisible.hasValue()) isVisible = other.isVisible;
         if (other.backgroundColor.hasValue()) backgroundColor = other.backgroundColor;
+        if (other.drawBehind.hasValue()) drawBehind = other.drawBehind;
     }
 
     public void mergeWithDefault(NavigationBarOptions defaultOptions) {
         if (!isVisible.hasValue()) isVisible = defaultOptions.isVisible;
         if (!backgroundColor.hasValue()) backgroundColor = defaultOptions.backgroundColor;
+        if (!drawBehind.hasValue()) drawBehind = defaultOptions.drawBehind;
     }
-}
+
+    public boolean shouldDrawBehind() {
+        if (drawBehind.isFalse()) return false;
+        if (drawBehind.isTrue()) return true;
+        return backgroundColor.hasTransparency();
+    }
+
+    public boolean isDrawBehindAndVisible() {
+        return shouldDrawBehind() && isVisible.isTrueOrUndefined();
+    }
+
+    public boolean hasAnyValue() {
+        return isVisible.hasValue() || drawBehind.hasValue() || backgroundColor.hasValue();
+    }
+}

package/android/src/main/java/com/reactnativenavigation/react/ReactView.java

@@ -16,6 +16,7 @@ import com.facebook.react.ReactApplication;
 import com.facebook.react.ReactHost;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.interfaces.fabric.ReactSurface;
+import com.facebook.react.runtime.ReactSurfaceImpl;
 import com.facebook.react.uimanager.UIManagerHelper;
 import com.facebook.react.uimanager.common.UIManagerType;
 import com.facebook.react.uimanager.events.EventDispatcher;
@@ -71,6 +72,18 @@ public class ReactView extends FrameLayout implements IReactView, Renderable {
         reactSurface.stop();
     }
 
+    /**
+     * Replace the surface's initial props. Useful for components that need to
+     * receive runtime updates from native (e.g. bottom tab item components).
+     * No-op when the underlying surface implementation does not support
+     * runtime prop updates.
+     */
+    public void setProps(Bundle props) {
+        if (reactSurface instanceof ReactSurfaceImpl) {
+            ((ReactSurfaceImpl) reactSurface).updateInitProps(props);
+        }
+    }
+
     public void sendComponentWillStart(ComponentType type) {
         this.post(() -> {
             ReactContext currentReactContext = getReactContext();

package/android/src/main/java/com/reactnativenavigation/react/events/ComponentType.java

@@ -4,7 +4,8 @@ public enum ComponentType {
     Component("Component"),
     Button("TopBarButton"),
     Title("TopBarTitle"),
-    Background("TopBarBackground");
+    Background("TopBarBackground"),
+    BottomTabItem("BottomTabItem");
 
     private String name;
 

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

@@ -4,6 +4,7 @@ import android.app.Activity
 import android.graphics.Color
 import android.graphics.Rect
 import android.graphics.drawable.ColorDrawable
+import android.os.Build
 import android.view.Gravity
 import android.view.View
 import android.view.ViewGroup
@@ -15,6 +16,7 @@ import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
 import kotlin.math.abs
 import kotlin.math.ceil
+import kotlin.math.max
 
 object SystemUiUtils {
     private const val STATUS_BAR_HEIGHT_M = 24
@@ -79,7 +81,7 @@ object SystemUiUtils {
     @JvmStatic
     fun setupSystemBarBackgrounds(activity: Activity, contentLayout: ViewGroup) {
         setupStatusBarBackground(activity)
-        setupNavigationBarBackground(contentLayout)
+        setupNavigationBarBackground(activity.window, contentLayout)
     }
 
     private fun setupStatusBarBackground(activity: Activity) {
@@ -117,10 +119,10 @@ object SystemUiUtils {
         return view
     }
 
-    private fun setupNavigationBarBackground(contentLayout: ViewGroup) {
+    private fun setupNavigationBarBackground(window: Window?, contentLayout: ViewGroup) {
         if (navBarBackgroundView != null) return
         val view = View(contentLayout.context).apply {
-            setBackgroundColor(Color.BLACK)
+            setBackgroundColor(getNavigationBarBackgroundColor(window))
         }
         val params = FrameLayout.LayoutParams(
             FrameLayout.LayoutParams.MATCH_PARENT, 0, Gravity.BOTTOM
@@ -134,7 +136,7 @@ object SystemUiUtils {
             val wasThreeButton = isThreeButtonNav
             isThreeButtonNav = tappableHeight > 0
             if (isThreeButtonNav != wasThreeButton) {
-                val color = lastExplicitNavBarColor ?: getDefaultNavBarColor()
+                val color = lastExplicitNavBarColor ?: getNavigationBarBackgroundColor(v)
                 v.setBackgroundColor(color)
             }
             val lp = v.layoutParams
@@ -147,6 +149,17 @@ object SystemUiUtils {
         view.requestApplyInsets()
     }
 
+    private fun getNavigationBarBackgroundColor(window: Window?): Int {
+        lastExplicitNavBarColor?.let { return it }
+        @Suppress("DEPRECATION")
+        return window?.navigationBarColor ?: getDefaultNavBarColor()
+    }
+
+    private fun getNavigationBarBackgroundColor(view: View): Int {
+        lastExplicitNavBarColor?.let { return it }
+        return (view.background as? ColorDrawable)?.color ?: getDefaultNavBarColor()
+    }
+
     /**
      * 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.
@@ -176,6 +189,29 @@ object SystemUiUtils {
         isEdgeToEdgeActive = true
     }
 
+    @JvmStatic
+    fun setNavigationBarContrastEnforced(window: Window?, enforced: Boolean) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            window?.isNavigationBarContrastEnforced = enforced
+        }
+    }
+
+    @JvmStatic
+    fun getContentBottomSystemBarInset(insets: WindowInsetsCompat, drawBehindNavigationBar: Boolean): Int {
+        val imeBottom = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom
+        if (!isEdgeToEdgeActive) return imeBottom
+        if (drawBehindNavigationBar) return imeBottom
+        val navBarBottom = insets.getInsets(WindowInsetsCompat.Type.navigationBars()).bottom
+        return max(imeBottom, navBarBottom)
+    }
+
+    @JvmStatic
+    fun getBottomTabsSystemBarPadding(insets: WindowInsetsCompat, drawBehindNavigationBar: Boolean): Int {
+        if (insets.getInsets(WindowInsetsCompat.Type.ime()).bottom > 0) return 0
+        if (isEdgeToEdgeActive && drawBehindNavigationBar) return 0
+        return insets.getInsets(WindowInsetsCompat.Type.systemBars()).bottom
+    }
+
     /**
      * Clears references to system bar background views.
      * Call from Activity.onDestroy to avoid leaking views across activity recreation.
@@ -316,18 +352,36 @@ object SystemUiUtils {
      * falls back to the deprecated window API on older configurations.
      */
     @JvmStatic
-    fun setNavigationBarBackgroundColor(window: Window?, color: Int, lightColor: Boolean) {
-        lastExplicitNavBarColor = color
+    fun setNavigationBarBackgroundColor(window: Window?, color: Int, lightColor: Boolean, hideOverlay: Boolean) {
         window?.let {
             WindowInsetsControllerCompat(window, window.decorView).isAppearanceLightNavigationBars = lightColor
         }
-        if (isEdgeToEdgeActive) {
-            navBarBackgroundView?.setBackgroundColor(color)
-        } else {
+        if (hideOverlay) {
+            lastExplicitNavBarColor = null
+            navBarBackgroundView?.apply {
+                visibility = View.GONE
+                setBackgroundColor(Color.TRANSPARENT)
+            }
+            @Suppress("DEPRECATION")
+            window?.navigationBarColor = Color.TRANSPARENT
+            return
+        }
+
+        lastExplicitNavBarColor = color
+        navBarBackgroundView?.apply {
+            visibility = View.VISIBLE
+            setBackgroundColor(color)
+        }
+        if (!isEdgeToEdgeActive) {
             @Suppress("DEPRECATION")
             window?.navigationBarColor = color
         }
     }
 
+    @JvmStatic
+    fun setNavigationBarBackgroundColor(window: Window?, color: Int, lightColor: Boolean) {
+        setNavigationBarBackgroundColor(window, color, lightColor, Color.alpha(color) == 0)
+    }
+
     // endregion
 }

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

@@ -20,7 +20,9 @@ import com.reactnativenavigation.utils.ImageLoadingListenerAdapter;
 import com.reactnativenavigation.utils.LateInit;
 import com.reactnativenavigation.viewcontrollers.viewcontroller.ViewController;
 import com.reactnativenavigation.views.bottomtabs.BottomTabs;
+import com.reactnativenavigation.views.bottomtabs.CustomBottomTabItemView;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class BottomTabPresenter {
@@ -33,6 +35,7 @@ public class BottomTabPresenter {
     private final LateInit<BottomTabs> bottomTabs = new LateInit<>();
     private final List<ViewController<?>> tabs;
     private final int defaultDotIndicatorSize;
+    private boolean useCustomItemViews;
 
     public BottomTabPresenter(Context context, List<ViewController<?>> tabs, ImageLoader imageLoader,  TypefaceLoader typefaceLoader, Options defaultOptions) {
         this.tabs = tabs;
@@ -53,10 +56,27 @@ public class BottomTabPresenter {
         this.bottomTabs.set(bottomTabs);
     }
 
+    /**
+     * When `true`, tabs whose options declare `bottomTab.component` are
+     * skipped during native icon/text application. The accompanying
+     * `CustomBottomTabItemView` overlay is responsible for visual rendering.
+     */
+    public void setUseCustomItemViews(boolean useCustomItemViews) {
+        this.useCustomItemViews = useCustomItemViews;
+    }
+
     public void applyOptions() {
         bottomTabs.perform(bottomTabs -> {
             for (int i = 0; i < tabs.size(); i++) {
                 BottomTabOptions tab = tabs.get(i).resolveCurrentOptions(defaultOptions).bottomTabOptions;
+                if (useCustomItemViews && tab.component.hasValue()) {
+                    if (tab.testId.hasValue()) bottomTabs.setTag(i, tab.testId.get());
+                    if (tab.badge.hasValue()) {
+                        CustomBottomTabItemView v = bottomTabs.getCustomItemView(i);
+                        if (v != null) v.setBadge(tab.badge.get(""));
+                    }
+                    continue;
+                }
                 bottomTabs.setIconWidth(i, tab.iconWidth.get(null));
                 bottomTabs.setIconHeight(i, tab.iconHeight.get(null));
                 bottomTabs.setTitleTypeface(i, tab.font.getTypeface(typefaceLoader, defaultTypeface));
@@ -86,6 +106,14 @@ public class BottomTabPresenter {
             int index = bottomTabFinder.findByControllerId(child.getId());
             if (index >= 0) {
                 BottomTabOptions tab = options.bottomTabOptions;
+                if (useCustomItemViews && bottomTabs.getCustomItemView(index) != null) {
+                    if (tab.badge.hasValue()) {
+                        CustomBottomTabItemView v = bottomTabs.getCustomItemView(index);
+                        if (v != null) v.setBadge(tab.badge.get(""));
+                    }
+                    if (tab.testId.hasValue()) bottomTabs.setTag(index, tab.testId.get());
+                    return;
+                }
                 if (tab.iconWidth.hasValue()) bottomTabs.setIconWidth(index, tab.iconWidth.get(null));
                 if (tab.iconHeight.hasValue()) bottomTabs.setIconHeight(index, tab.iconHeight.get(null));
                 if (tab.font.hasValue()) bottomTabs.setTitleTypeface(index, tab.font.getTypeface(typefaceLoader, defaultTypeface));