@soundtrackio/react-native-bottom-tabs 1.4.0

package/android/src/main/java/com/rcttabview/RCTTabViewManager.kt

@@ -0,0 +1,222 @@
+package com.rcttabview
+
+import android.content.res.ColorStateList
+import android.view.View
+import android.view.ViewGroup
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.RNCTabViewManagerDelegate
+import com.facebook.react.viewmanagers.RNCTabViewManagerInterface
+import com.rcttabview.events.OnNativeLayoutEvent
+import com.rcttabview.events.OnTabBarMeasuredEvent
+import com.rcttabview.events.PageSelectedEvent
+import com.rcttabview.events.TabLongPressEvent
+
+data class TabInfo(
+  val key: String,
+  val title: String,
+  val badge: String?,
+  val badgeBackgroundColor: Int?,
+  val badgeTextColor: Int?,
+  val activeTintColor: Int?,
+  val iconRenderingMode: String?,
+  val hidden: Boolean,
+  val testID: String?
+)
+
+
+@ReactModule(name = RCTTabViewManager.NAME)
+class RCTTabViewManager(context: ReactApplicationContext) :
+  ViewGroupManager<ReactBottomNavigationView>(),
+  RNCTabViewManagerInterface<ReactBottomNavigationView> {
+
+  private val delegate: RNCTabViewManagerDelegate<ReactBottomNavigationView, RCTTabViewManager> =
+    RNCTabViewManagerDelegate(this)
+
+  override fun createViewInstance(context: ThemedReactContext): ReactBottomNavigationView {
+    val view = RCTTabViewPrewarm.take(context) ?: ReactBottomNavigationView(context)
+    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+    view.onTabSelectedListener = { key ->
+      eventDispatcher?.dispatchEvent(PageSelectedEvent(viewTag = view.id, key))
+    }
+
+    view.onTabLongPressedListener = { key ->
+      eventDispatcher?.dispatchEvent(TabLongPressEvent(viewTag = view.id, key))
+    }
+
+    view.onNativeLayoutListener = { width, height ->
+      eventDispatcher?.dispatchEvent(OnNativeLayoutEvent(viewTag = view.id, width, height))
+    }
+    view.onTabBarMeasuredListener = { height ->
+      eventDispatcher?.dispatchEvent(OnTabBarMeasuredEvent(viewTag = view.id, height))
+    }
+    return view
+
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  override fun getChildCount(parent: ReactBottomNavigationView): Int {
+    return parent.layoutHolder.childCount ?: 0
+  }
+
+  override fun getChildAt(parent: ReactBottomNavigationView, index: Int): View? {
+    return parent.layoutHolder.getChildAt(index)
+  }
+
+  override fun removeView(parent: ReactBottomNavigationView, view: View) {
+    parent.layoutHolder.removeView(view)
+  }
+
+  override fun removeAllViews(parent: ReactBottomNavigationView) {
+    parent.layoutHolder.removeAllViews()
+  }
+
+  override fun removeViewAt(parent: ReactBottomNavigationView, index: Int) {
+    parent.layoutHolder.removeViewAt(index)
+  }
+
+  override fun needsCustomLayoutForChildren(): Boolean {
+    return true
+  }
+
+  override fun setItems(view: ReactBottomNavigationView?, value: ReadableArray?) {
+    if (view != null && value != null) {
+      val itemsArray = mutableListOf<TabInfo>()
+      for (i in 0 until value.size()) {
+        value.getMap(i)?.let { item ->
+            itemsArray.add(
+              TabInfo(
+                key = item.getString("key") ?: "",
+                title = item.getString("title") ?: "",
+                badge = if (item.hasKey("badge")) item.getString("badge") else null,
+                badgeBackgroundColor = if (item.hasKey("badgeBackgroundColor")) item.getInt("badgeBackgroundColor") else null,
+                badgeTextColor = if (item.hasKey("badgeTextColor")) item.getInt("badgeTextColor") else null,
+                activeTintColor = if (item.hasKey("activeTintColor")) item.getInt("activeTintColor") else null,
+                iconRenderingMode = if (item.hasKey("iconRenderingMode")) item.getString("iconRenderingMode") else null,
+                hidden = if (item.hasKey("hidden")) item.getBoolean("hidden") else false,
+                testID = item.getString("testID")
+              )
+            )
+        }
+      }
+      view.updateItems(itemsArray)
+    }
+  }
+
+  override fun setSelectedPage(view: ReactBottomNavigationView?, value: String?) {
+    if (view != null && value != null)
+      view.setSelectedItem(value)
+  }
+
+  override fun setIcons(view: ReactBottomNavigationView?, value: ReadableArray?) {
+    if (view != null)
+      view.setIcons(value)
+  }
+
+  override fun setFocusedIcons(view: ReactBottomNavigationView?, value: ReadableArray?) {
+  }
+
+  override fun setLabeled(view: ReactBottomNavigationView?, value: Boolean) {
+    if (view != null)
+      view.setLabeled(value)
+  }
+
+  override fun setRippleColor(view: ReactBottomNavigationView?, value: Int?) {
+    if (view != null && value != null) {
+      val color = ColorStateList.valueOf(value)
+      view.setRippleColor(color)
+    }
+  }
+
+  override fun setBarTintColor(view: ReactBottomNavigationView?, value: Int?) {
+    if (view != null && value != null)
+      view.setBarTintColor(value)
+  }
+
+  override fun setActiveTintColor(view: ReactBottomNavigationView?, value: Int?) {
+    if (view != null && value != null)
+      view.setActiveTintColor(value)
+  }
+
+  override fun setInactiveTintColor(view: ReactBottomNavigationView?, value: Int?) {
+    if (view != null && value != null)
+      view.setInactiveTintColor(value)
+  }
+
+  override fun setExperimentalBakedTintColors(view: ReactBottomNavigationView?, value: Boolean) {
+  }
+
+  override fun setActiveIndicatorColor(view: ReactBottomNavigationView?, value: Int?) {
+    if (view != null && value != null) {
+      val color = ColorStateList.valueOf(value)
+      view.setActiveIndicatorColor(color)
+    }
+  }
+
+  override fun getDelegate(): ViewManagerDelegate<ReactBottomNavigationView> {
+    return delegate
+  }
+
+  override fun setHapticFeedbackEnabled(view: ReactBottomNavigationView?, value: Boolean) {
+    if (view != null)
+      view.isHapticFeedbackEnabled = value
+  }
+
+  override fun setLayoutDirection(view: ReactBottomNavigationView, value: String?) {
+      val direction = when (value) {
+          "rtl" -> View.LAYOUT_DIRECTION_RTL
+          "ltr" -> View.LAYOUT_DIRECTION_LTR
+          else -> View.LAYOUT_DIRECTION_LOCALE
+      }
+      view.applyDirection(direction)
+  }
+
+  override fun setFontFamily(view: ReactBottomNavigationView?, value: String?) {
+    view?.setFontFamily(value)
+  }
+
+  override fun setFontWeight(view: ReactBottomNavigationView?, value: String?) {
+    view?.setFontWeight(value)
+  }
+
+  override fun setFontSize(view: ReactBottomNavigationView?, value: Int) {
+    view?.setFontSize(value)
+  }
+
+  override fun setDisablePageAnimations(view: ReactBottomNavigationView?, value: Boolean) {
+    view?.disablePageAnimations = value
+  }
+
+  override fun setTabBarHidden(view: ReactBottomNavigationView?, value: Boolean) {
+    view?.setTabBarHidden(value)
+  }
+
+  override fun setTabBarHideOnKeyboard(view: ReactBottomNavigationView?, value: Boolean) {
+    view?.setTabBarHideOnKeyboard(value)
+  }
+
+  // iOS Methods
+  override fun setTranslucent(view: ReactBottomNavigationView?, value: Boolean) {
+  }
+
+  override fun setSidebarAdaptable(view: ReactBottomNavigationView?, value: Boolean) {
+  }
+
+  override fun setScrollEdgeAppearance(view: ReactBottomNavigationView?, value: String?) {
+  }
+
+  override fun setMinimizeBehavior(view: ReactBottomNavigationView?, value: String?) {
+  }
+
+  companion object {
+    const val NAME = "RNCTabView"
+  }
+}

package/android/src/main/java/com/rcttabview/RCTTabViewPackage.kt

@@ -0,0 +1,19 @@
+package com.rcttabview
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import java.util.ArrayList
+
+class RCTTabViewPackage : ReactPackage {
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    val viewManagers: MutableList<ViewManager<*, *>> = ArrayList()
+    viewManagers.add(RCTTabViewManager(reactContext))
+    return viewManagers
+  }
+
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return emptyList()
+  }
+}

package/android/src/main/java/com/rcttabview/RCTTabViewPrewarm.kt

@@ -0,0 +1,40 @@
+package com.rcttabview
+
+import android.app.Activity
+import android.os.Looper
+import com.facebook.react.uimanager.ThemedReactContext
+import java.lang.ref.WeakReference
+
+/**
+ * Builds a tab bar for an Activity ahead of time, while the main thread is idle during startup,
+ * so mounting the real one does not pay Material's inflation inside the frame that shows the
+ * first screen. Call [prewarm] from the Activity, e.g. posted right after `onCreate`:
+ *
+ * ```kotlin
+ * Handler(Looper.getMainLooper()).post { RCTTabViewPrewarm.prewarm(this) }
+ * ```
+ */
+object RCTTabViewPrewarm {
+  private var activity: WeakReference<Activity>? = null
+  private var view: ReactBottomNavigationView? = null
+
+  /** Call on the main thread; [itemCount] placeholder tabs are inflated up front. */
+  @JvmStatic
+  @JvmOverloads
+  fun prewarm(activity: Activity, itemCount: Int = 5) {
+    check(Looper.myLooper() == Looper.getMainLooper()) { "prewarm must run on the main thread" }
+    val prebuilt = ReactBottomNavigationView(activity)
+    prebuilt.prewarmItems(itemCount)
+    this.activity = WeakReference(activity)
+    view = prebuilt
+  }
+
+  /** The prebuilt view for [context]'s Activity, handed out at most once. */
+  internal fun take(context: ThemedReactContext): ReactBottomNavigationView? {
+    val prebuilt = view ?: return null
+    view = null
+    val owner = activity?.get()
+    activity = null
+    return if (owner != null && owner === context.currentActivity) prebuilt else null
+  }
+}

package/android/src/main/java/com/rcttabview/RebuildBatch.kt

@@ -0,0 +1,31 @@
+package com.rcttabview
+
+/**
+ * Holds back rebuilds requested while a batch of changes is applied, so a rebuild that
+ * would otherwise run after every change runs once when the batch ends.
+ */
+class RebuildBatch {
+  private var batching = false
+  private var pending = false
+
+  /** Whether a rebuild requested now should run. Otherwise it runs when the batch ends. */
+  fun shouldRebuildNow(): Boolean {
+    if (batching) {
+      pending = true
+      return false
+    }
+    return true
+  }
+
+  fun begin() {
+    batching = true
+  }
+
+  /** Ends the batch. True when a rebuild was held back and has to run now. */
+  fun end(): Boolean {
+    batching = false
+    val rebuild = pending
+    pending = false
+    return rebuild
+  }
+}

package/android/src/main/java/com/rcttabview/TabBarVisibility.kt

@@ -0,0 +1,14 @@
+package com.rcttabview
+
+/**
+ * Combines the reasons the tab bar can be hidden: the `tabBarHidden` prop and, when
+ * `tabBarHideOnKeyboard` is set, a visible keyboard.
+ */
+class TabBarVisibility {
+  var hidden = false
+  var hideOnKeyboard = false
+  var keyboardVisible = false
+
+  val isVisible: Boolean
+    get() = !hidden && !(hideOnKeyboard && keyboardVisible)
+}

package/android/src/main/java/com/rcttabview/Utils.kt

@@ -0,0 +1,31 @@
+package com.rcttabview
+
+import android.content.Context
+import android.graphics.Typeface
+import android.util.TypedValue
+import androidx.appcompat.content.res.AppCompatResources
+
+class Utils {
+  companion object {
+    fun convertPixelsToDp(context: Context, value: Int): Double {
+      val displayDensity = context.resources.displayMetrics.density
+      return (value / displayDensity).toDouble()
+    }
+
+    fun getTypefaceStyle(weight: Int?) = when (weight) {
+      700 -> Typeface.BOLD
+      else -> Typeface.NORMAL
+    }
+
+    fun getDefaultColorFor(context: Context, baseColorThemeAttr: Int): Int? {
+      val value = TypedValue()
+      if (!context.theme.resolveAttribute(baseColorThemeAttr, value, true)) {
+        return null
+      }
+      val baseColor = AppCompatResources.getColorStateList(
+        context, value.resourceId
+      )
+      return baseColor.defaultColor
+    }
+  }
+}

package/android/src/main/java/com/rcttabview/events/OnNativeLayoutEvent.kt

@@ -0,0 +1,25 @@
+package com.rcttabview.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.RCTEventEmitter
+
+class OnNativeLayoutEvent(viewTag: Int, private val width: Double, private val height: Double) :
+  Event<TabLongPressEvent>(viewTag) {
+
+  companion object {
+    const val EVENT_NAME = "onNativeLayout"
+  }
+
+  override fun getEventName(): String {
+    return EVENT_NAME
+  }
+
+  override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+    val event = Arguments.createMap().apply {
+      putDouble("width", width)
+      putDouble("height", height)
+    }
+    rctEventEmitter.receiveEvent(viewTag, eventName, event)
+  }
+}

package/android/src/main/java/com/rcttabview/events/OnTabBarMeasuredEvent.kt

@@ -0,0 +1,24 @@
+package com.rcttabview.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.RCTEventEmitter
+
+class OnTabBarMeasuredEvent(viewTag: Int, private val height: Int) :
+  Event<TabLongPressEvent>(viewTag) {
+
+  companion object {
+    const val EVENT_NAME = "onTabBarMeasured"
+  }
+
+  override fun getEventName(): String {
+    return EVENT_NAME
+  }
+
+  override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+    val event = Arguments.createMap().apply {
+      putInt("height", height)
+    }
+    rctEventEmitter.receiveEvent(viewTag, eventName, event)
+  }
+}

package/android/src/main/java/com/rcttabview/events/PageSelectedEvent.kt

@@ -0,0 +1,32 @@
+package com.rcttabview.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.RCTEventEmitter
+
+
+class PageSelectedEvent(viewTag: Int, private val key: String) : Event<PageSelectedEvent>(viewTag) {
+  override fun getEventName(): String {
+    return EVENT_NAME
+  }
+
+  override fun canCoalesce(): Boolean {
+    return false
+  }
+
+  override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+    rctEventEmitter.receiveEvent(viewTag, eventName, serializeEventData())
+  }
+
+  private fun serializeEventData(): WritableMap {
+    val eventData = Arguments.createMap()
+    eventData.putString("key", key)
+    return eventData
+  }
+
+  companion object {
+    const val EVENT_NAME = "topPageSelected"
+  }
+
+}

package/android/src/main/java/com/rcttabview/events/TabLongPressedEvent.kt

@@ -0,0 +1,24 @@
+package com.rcttabview.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.RCTEventEmitter
+
+class TabLongPressEvent(viewTag: Int, private val key: String) :
+  Event<TabLongPressEvent>(viewTag) {
+
+  companion object {
+    const val EVENT_NAME = "onTabLongPress"
+  }
+
+  override fun getEventName(): String {
+    return EVENT_NAME
+  }
+
+  override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+    val event = Arguments.createMap().apply {
+      putString("key", key)
+    }
+    rctEventEmitter.receiveEvent(viewTag, eventName, event)
+  }
+}

package/android/src/test/java/com/rcttabview/LatestRequestTrackerTest.kt

@@ -0,0 +1,37 @@
+package com.rcttabview
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class LatestRequestTrackerTest {
+  private val tracker = LatestRequestTracker<Int>()
+
+  @Test
+  fun `the only request for a key is the latest`() {
+    val id = tracker.begin(0)
+    assertTrue(tracker.isLatest(0, id))
+  }
+
+  @Test
+  fun `a newer request supersedes an older one for the same key`() {
+    val first = tracker.begin(0)
+    val second = tracker.begin(0)
+    assertFalse(tracker.isLatest(0, first))
+    assertTrue(tracker.isLatest(0, second))
+  }
+
+  @Test
+  fun `requests for other keys do not supersede each other`() {
+    val home = tracker.begin(0)
+    val search = tracker.begin(1)
+    assertTrue(tracker.isLatest(0, home))
+    assertTrue(tracker.isLatest(1, search))
+  }
+
+  @Test
+  fun `an id is never the latest for a key it was not issued for`() {
+    val home = tracker.begin(0)
+    assertFalse(tracker.isLatest(1, home))
+  }
+}

package/android/src/test/java/com/rcttabview/RebuildBatchTest.kt

@@ -0,0 +1,44 @@
+package com.rcttabview
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class RebuildBatchTest {
+  private val batch = RebuildBatch()
+
+  @Test
+  fun `rebuilds run at once outside a batch`() {
+    assertTrue(batch.shouldRebuildNow())
+  }
+
+  @Test
+  fun `rebuilds requested inside a batch are held back`() {
+    batch.begin()
+    assertFalse(batch.shouldRebuildNow())
+    assertFalse(batch.shouldRebuildNow())
+  }
+
+  @Test
+  fun `ending a batch releases one rebuild for any number held back`() {
+    batch.begin()
+    batch.shouldRebuildNow()
+    batch.shouldRebuildNow()
+    assertTrue(batch.end())
+    assertFalse(batch.end())
+  }
+
+  @Test
+  fun `ending a batch without requests releases nothing`() {
+    batch.begin()
+    assertFalse(batch.end())
+  }
+
+  @Test
+  fun `rebuilds run at once again after a batch`() {
+    batch.begin()
+    batch.shouldRebuildNow()
+    batch.end()
+    assertTrue(batch.shouldRebuildNow())
+  }
+}

package/android/src/test/java/com/rcttabview/TabBarVisibilityTest.kt

@@ -0,0 +1,58 @@
+package com.rcttabview
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class TabBarVisibilityTest {
+  private val visibility = TabBarVisibility()
+
+  @Test
+  fun `is visible by default`() {
+    assertTrue(visibility.isVisible)
+  }
+
+  @Test
+  fun `tabBarHidden hides the bar`() {
+    visibility.hidden = true
+    assertFalse(visibility.isVisible)
+  }
+
+  @Test
+  fun `keyboard alone does not hide the bar`() {
+    visibility.keyboardVisible = true
+    assertTrue(visibility.isVisible)
+  }
+
+  @Test
+  fun `keyboard hides the bar when hideOnKeyboard is set`() {
+    visibility.hideOnKeyboard = true
+    visibility.keyboardVisible = true
+    assertFalse(visibility.isVisible)
+  }
+
+  @Test
+  fun `bar returns when the keyboard is dismissed`() {
+    visibility.hideOnKeyboard = true
+    visibility.keyboardVisible = true
+    visibility.keyboardVisible = false
+    assertTrue(visibility.isVisible)
+  }
+
+  @Test
+  fun `disabling hideOnKeyboard restores the bar while the keyboard is shown`() {
+    visibility.hideOnKeyboard = true
+    visibility.keyboardVisible = true
+    visibility.hideOnKeyboard = false
+    assertTrue(visibility.isVisible)
+  }
+
+  @Test
+  fun `tabBarHidden keeps the bar hidden after the keyboard is dismissed`() {
+    visibility.hidden = true
+    visibility.hideOnKeyboard = true
+    visibility.keyboardVisible = true
+    visibility.keyboardVisible = false
+    assertFalse(visibility.isVisible)
+  }
+}

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./lib/module/expo');

package/common/cpp/react/renderer/components/RNCTabView/RNCTabViewComponentDescriptor.h

@@ -0,0 +1,33 @@
+#ifdef __cplusplus
+
+#pragma once
+
+#include <react/renderer/components/RNCTabView/RNCTabViewShadowNode.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+
+namespace facebook::react {
+
+class RNCTabViewComponentDescriptor final
+    : public ConcreteComponentDescriptor<RNCTabViewShadowNode> {
+ public:
+    using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+
+  void adopt(ShadowNode& shadowNode) const override {
+    ConcreteComponentDescriptor::adopt(shadowNode);
+
+#if !defined(ANDROID)
+    auto &tabViewShadowNode =
+        static_cast<RNCTabViewShadowNode&>(shadowNode);
+
+    std::weak_ptr<void> imageLoader =
+        contextContainer_->at<std::shared_ptr<void>>("RCTImageLoader");
+    tabViewShadowNode.setImageLoader(imageLoader);
+#endif
+  }
+};
+
+
+} // namespace facebook::react
+
+#endif

package/common/cpp/react/renderer/components/RNCTabView/RNCTabViewShadowNode.cpp

@@ -0,0 +1,19 @@
+#include <react/renderer/components/RNCTabView/RNCTabViewShadowNode.h>
+
+namespace facebook::react {
+
+extern const char RNCTabViewComponentName[] = "RNCTabView";
+
+void RNCTabViewShadowNode::setImageLoader(
+    std::weak_ptr<void> imageLoader) {
+  getStateDataMutable().setImageLoader(imageLoader);
+}
+
+RNCTabViewShadowNode::StateData &
+RNCTabViewShadowNode::getStateDataMutable() {
+  ensureUnsealed();
+  return const_cast<RNCTabViewShadowNode::StateData &>(getStateData());
+}
+
+
+} // namespace facebook::react