@javascriptcommon/react-native-carplay 2.3.11 → 2.4.2

package/android/src/main/java/org/birkir/carplay/parser/RCTMapTemplate.kt

@@ -0,0 +1,128 @@
+package org.birkir.carplay.parser
+
+import androidx.car.app.CarContext
+import androidx.car.app.model.PlaceListMapTemplate
+import androidx.car.app.model.Template
+import androidx.car.app.navigation.model.MapController
+import androidx.car.app.navigation.model.MapTemplate
+import androidx.car.app.navigation.model.NavigationTemplate
+import androidx.car.app.navigation.model.PanModeListener
+import androidx.car.app.navigation.model.PlaceListNavigationTemplate
+import androidx.car.app.navigation.model.RoutePreviewNavigationTemplate
+import com.facebook.react.bridge.ReadableMap
+import org.birkir.carplay.screens.CarScreenContext
+
+class RCTMapTemplate(
+  context: CarContext,
+  carScreenContext: CarScreenContext
+) : RCTTemplate(context, carScreenContext) {
+
+  override fun parse(props: ReadableMap): Template {
+    val type = props.getString("type")
+    val actionStrip = props.getArray("actions")?.let {
+      parseActionStrip(it)
+    }
+    val header = props.getMap("header")?.let {
+      parseHeader(it)
+    }
+    val headerAction = props.getMap("headerAction")?.let {
+      parseAction(it)
+    }
+    val itemList = props.getArray("items")?.let {
+      parseItemList(it, "row")
+    }
+    val pane = props.getMap("pane")?.let {
+      parsePane(it)
+    }
+    val mapActionStrip = props.getArray("mapButtons")?.let {
+      parseActionStrip(it)
+    }
+    val panModeListener = PanModeListener { isInPanMode ->
+      if (isInPanMode) {
+        eventEmitter.didShowPanningInterface()
+      } else {
+        eventEmitter.didDismissPanningInterface()
+      }
+    }
+    val mapController = MapController.Builder().apply {
+      mapActionStrip?.let { setMapActionStrip(it); }
+      setPanModeListener(panModeListener)
+    }.build()
+    when (type) {
+      "navigation" -> {
+        return NavigationTemplate.Builder().apply {
+          actionStrip?.let { setActionStrip(it) }
+          props.getString("backgroundColor")?.let {
+            setBackgroundColor(parseColor(it))
+          }
+          props.getMap("travelEstimate")?.let {
+            setDestinationTravelEstimate(parseTravelEstimate(it))
+          }
+          props.getMap("navigationInfo")?.let {
+            setNavigationInfo(parseNavigationInfo(it))
+          }
+          mapActionStrip?.let { setMapActionStrip(it) }
+          setPanModeListener(panModeListener)
+        }.build()
+      }
+
+      "place-list-map" -> {
+        return PlaceListMapTemplate.Builder().apply {
+          actionStrip?.let { setActionStrip(it) }
+          props.getMap("anchor")?.let { setAnchor(parsePlace(it)) }
+          if (props.hasKey("currentLocationEnabled")) {
+            setCurrentLocationEnabled(props.getBoolean("currentLocationEnabled"))
+          }
+          headerAction?.let { setHeaderAction(it) }
+          itemList?.let { setItemList(it) }
+          setLoading(props.isLoading())
+          setOnContentRefreshListener {
+            // @todo eventEmitter?.contentDidRefresh
+          }
+          props.getString("title")?.let { setTitle(it) }
+        }.build()
+      }
+
+      "place-list-navigation" -> {
+        return PlaceListNavigationTemplate.Builder().apply {
+          actionStrip?.let { setActionStrip(it) }
+          header?.let { setHeader(it) }
+          itemList?.let { setItemList(it) }
+          setLoading(props.isLoading())
+          mapActionStrip?.let { setActionStrip(it) }
+          setOnContentRefreshListener {
+            // @todo eventEmitter?.contentDidRefresh
+          }
+          setPanModeListener(panModeListener)
+        }.build()
+      }
+
+      "route-preview" -> {
+        return RoutePreviewNavigationTemplate.Builder().apply {
+          actionStrip?.let { setActionStrip(it) }
+          header?.let { setHeader(it) }
+          headerAction?.let { setHeaderAction(headerAction) }
+          itemList?.let { setItemList(it) }
+          setLoading(props.isLoading())
+          mapActionStrip?.let { setMapActionStrip(it); }
+          props.getMap("navigateAction")?.let { setNavigateAction(parseAction(it)) }
+          setPanModeListener(panModeListener)
+        }.build()
+      }
+
+      else -> {
+        return MapTemplate.Builder().apply {
+          header?.let { setHeader(it) }
+          itemList?.let { setItemList(it) }
+          actionStrip?.let { setActionStrip(it) }
+          setMapController(mapController)
+          pane?.let { setPane(it) }
+        }.build()
+      }
+    }
+  }
+
+  companion object {
+    const val TAG = "RCTMapTemplate"
+  }
+}

package/android/src/main/java/org/birkir/carplay/parser/RCTMessageTemplate.kt

@@ -0,0 +1,28 @@
+package org.birkir.carplay.parser
+
+import androidx.car.app.CarContext
+import androidx.car.app.model.MessageTemplate
+import com.facebook.react.bridge.ReadableMap
+import org.birkir.carplay.screens.CarScreenContext
+
+class RCTMessageTemplate(
+  context: CarContext,
+  carScreenContext: CarScreenContext
+) : RCTTemplate(context, carScreenContext) {
+  override fun parse(props: ReadableMap): MessageTemplate {
+    val message = props.getString("message") ?: "No message"
+    val messageText = parseCarText(message, props)
+    return MessageTemplate.Builder(messageText).apply {
+      props.getArray("actions")?.let { setActionStrip(parseActionStrip(it)) }
+      props.getMap("headerAction")?.let { setHeaderAction(parseAction(it)) }
+      props.getMap("icon")?.let { setIcon(parseCarIcon(it)) }
+      props.getString("title")?.let { setTitle(it) }
+      props.getString("debugMessage")?.let { setDebugMessage(it) }
+      setLoading(props.isLoading())
+    }.build()
+  }
+
+  companion object {
+    const val TAG = "RCTMessageTemplate"
+  }
+}

package/android/src/main/java/org/birkir/carplay/parser/RCTPaneTemplate.kt

@@ -0,0 +1,24 @@
+package org.birkir.carplay.parser
+
+import androidx.car.app.CarContext
+import androidx.car.app.model.PaneTemplate
+import com.facebook.react.bridge.ReadableMap
+import org.birkir.carplay.screens.CarScreenContext
+
+class RCTPaneTemplate(
+  context: CarContext,
+  carScreenContext: CarScreenContext
+) : RCTTemplate(context, carScreenContext) {
+  override fun parse(props: ReadableMap): PaneTemplate {
+    val pane = parsePane(props.getMap("pane")!!)
+    return PaneTemplate.Builder(pane).apply {
+      props.getArray("actions")?.let { setActionStrip(parseActionStrip(it)) }
+      props.getMap("headerAction")?.let { setHeaderAction(parseAction(it)) }
+      props.getString("title")?.let { setTitle(it) }
+    }.build()
+  }
+
+  companion object {
+    const val TAG = "RCTPaneTemplate"
+  }
+}

package/android/src/main/java/org/birkir/carplay/parser/RCTSearchTemplate.kt

@@ -0,0 +1,41 @@
+package org.birkir.carplay.parser
+
+import androidx.car.app.CarContext
+import androidx.car.app.model.SearchTemplate
+import androidx.car.app.model.SearchTemplate.SearchCallback
+import com.facebook.react.bridge.ReadableMap
+import org.birkir.carplay.screens.CarScreenContext
+
+
+class RCTSearchTemplate(
+  context: CarContext,
+  carScreenContext: CarScreenContext
+) : RCTTemplate(context, carScreenContext) {
+  override fun parse(props: ReadableMap): SearchTemplate {
+    return SearchTemplate.Builder(object : SearchCallback {
+      override fun onSearchTextChanged(searchText: String) {
+        eventEmitter.updatedSearchText(searchText)
+      }
+
+      override fun onSearchSubmitted(searchText: String) {
+        eventEmitter.searchButtonPressed(searchText)
+      }
+    }).apply {
+      props.getArray("actions")?.let { setActionStrip(parseActionStrip(it)) }
+      props.getMap("headerAction")?.let { setHeaderAction(parseAction(it)) }
+      props.getString("initialSearchText")?.let {
+        setInitialSearchText(it)
+      }
+      props.getArray("items")?.let { setItemList(parseItemList(it, "row")) }
+      setLoading(props.isLoading())
+      props.getString("searchHint")?.let { setSearchHint(it) }
+      if (props.hasKey("showKeyboardByDefault")) {
+        setShowKeyboardByDefault(props.getBoolean("showKeyboardByDefault"))
+      }
+    }.build()
+  }
+
+  companion object {
+    const val TAG = "RCTSearchTemplate"
+  }
+}

package/android/src/main/java/org/birkir/carplay/parser/RCTTabTemplate.kt

@@ -0,0 +1,157 @@
+package org.birkir.carplay.parser
+
+import android.util.Log
+import androidx.car.app.CarContext
+import androidx.car.app.model.Action
+import androidx.car.app.model.CarIcon
+import androidx.car.app.model.ItemList
+import androidx.car.app.model.ListTemplate
+import androidx.car.app.model.Row
+import androidx.car.app.model.Tab
+import androidx.car.app.model.TabContents
+import androidx.car.app.model.TabTemplate
+import androidx.car.app.model.TabTemplate.TabCallback
+import com.facebook.react.bridge.ReadableMap
+import org.birkir.carplay.screens.CarScreenContext
+
+class RCTTabTemplate(
+  context: CarContext,
+  carScreenContext: CarScreenContext
+) : RCTTemplate(context, carScreenContext) {
+  private val tabContentsMap = mutableMapOf<String, TabContents>()
+  private val tabInfoMap = mutableMapOf<String, TabInfo>()
+  private var currentTemplate: TabTemplate? = null
+  private var activeTabId: String? = null
+  private var isLoading: Boolean = false
+
+  data class TabInfo(val title: String, val icon: CarIcon, val headerAction: Action)
+
+  private val tabCallback = object : TabCallback {
+    override fun onTabSelected(tabContentId: String) {
+      Log.d(TAG, "Tab selected: $tabContentId")
+      eventEmitter.didSelectTemplate(tabContentId)
+      updateContents(tabContentId)
+    }
+  }
+
+  override fun parse(props: ReadableMap): TabTemplate {
+    tabInfoMap.clear()
+    isLoading = props.isLoading()
+    val builder = TabTemplate.Builder(tabCallback)
+    builder.setLoading(isLoading)
+
+    props.getArray("templates")?.let { templatesArray ->
+      for (i in 0 until templatesArray.size()) {
+        try {
+          val tabProps = templatesArray.getMap(i)
+          parseTabInfo(tabProps, builder)
+        } catch (e: Exception) {
+          Log.e(TAG, "Error parsing tab at index $i", e)
+        }
+      }
+
+      // Set first tab as active
+      tabInfoMap.keys.firstOrNull()?.let { firstTabId ->
+        setActiveTab(builder, firstTabId)
+      }
+    }
+
+    currentTemplate = builder.build()
+    return currentTemplate!!
+  }
+
+  private fun parseTabInfo(tabProps: ReadableMap, builder: TabTemplate.Builder) {
+    val id = tabProps.getString("id") ?: return
+    val tab = parseTab(tabProps)
+    builder.addTab(tab)
+
+    val headerAction = tabProps.getMap("headerAction")?.let { parseAction(it) } ?: Action.APP_ICON
+    tabInfoMap[id] = TabInfo(tab.title.toString(), tab.icon, headerAction)
+  }
+
+  private fun setActiveTab(builder: TabTemplate.Builder, tabId: String) {
+    builder.setTabContents(getTabContents(tabId))
+    builder.setActiveTabContentId(tabId)
+    builder.setHeaderAction(tabInfoMap[tabId]?.headerAction ?: Action.APP_ICON)
+    activeTabId = tabId
+  }
+
+  private fun buildCurrentTemplate() {
+    val builder = TabTemplate.Builder(tabCallback).setLoading(isLoading)
+
+    tabInfoMap.forEach { (id, info) ->
+      builder.addTab(Tab.Builder()
+        .setTitle(info.title)
+        .setIcon(info.icon)
+        .setContentId(id)
+        .build())
+    }
+
+    activeTabId?.let { activeId ->
+      setActiveTab(builder, activeId)
+    }
+
+    currentTemplate = builder.build()
+  }
+
+  private fun parseTab(props: ReadableMap): Tab {
+    return Tab.Builder().apply {
+      props.getString("id")?.let { setContentId(it) }
+      val config = props.getMap("config")
+      when {
+        config != null -> {
+          setTitle(config.getString("tabTitle") ?: DEFAULT_TAB_TITLE)
+          setIcon(CarIcon.APP_ICON) // TODO: Parse custom icon if needed
+        }
+        else -> {
+          setTitle(DEFAULT_TAB_TITLE)
+          setIcon(CarIcon.APP_ICON)
+        }
+      }
+    }.build()
+  }
+
+  private fun getTabContents(templateId: String): TabContents {
+    return tabContentsMap.getOrPut(templateId) {
+      val screen = carScreenContext.screens[templateId]
+      val template = screen?.template
+
+      when {
+        template != null -> {
+          Log.d(TAG, "Template found for $templateId: $template")
+          TabContents.Builder(template).build()
+        }
+        else -> createDefaultTabContents(templateId)
+      }
+    }
+  }
+
+  private fun createDefaultTabContents(templateId: String): TabContents {
+    val defaultItemList = ItemList.Builder()
+      .addItem(Row.Builder().setTitle("No content available for $templateId").build())
+      .build()
+    val defaultTemplate = ListTemplate.Builder()
+      .setTitle(DEFAULT_CONTENT_TITLE)
+      .setSingleList(defaultItemList)
+      .build()
+    return TabContents.Builder(defaultTemplate).build()
+  }
+
+  private fun updateContents(tabContentId: String) {
+    Log.d(TAG, "Updating contents for tab: $tabContentId")
+    activeTabId = tabContentId
+    buildCurrentTemplate()
+    // Update the main tab screen with the new template
+    carScreenContext.screens[carScreenContext.screenMarker]?.apply {
+      setTemplate(currentTemplate, carScreenContext.screenMarker, null)
+      invalidate()
+    }
+    Log.d(TAG, "Template updated for tab $tabContentId")
+  }
+
+  companion object {
+    const val TAG = "RCTTabTemplate"
+    private const val DEFAULT_TAB_TITLE = "Untitled Tab"
+    private const val DEFAULT_CONTENT_TITLE = "Default Content"
+  }
+}