@iternio/react-native-auto-play 0.0.1

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/template/RoutePreviewTemplate.kt

@@ -0,0 +1,75 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay.template
+
+import androidx.car.app.CarContext
+import androidx.car.app.Screen
+import androidx.car.app.model.Action
+import androidx.car.app.model.Header
+import androidx.car.app.model.ItemList
+import androidx.car.app.model.ListTemplate
+import androidx.car.app.model.Row
+import androidx.car.app.model.Template
+import androidx.car.app.navigation.model.MapController
+import androidx.car.app.navigation.model.MapWithContentTemplate
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.AutoText
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroMapButton
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.RouteChoice
+
+class RoutePreviewTemplate(
+    carContext: CarContext,
+    val tripId: String,
+    val routes: Array<RouteChoice>,
+    var selectedRouteIndex: Int,
+    val title: String,
+    val onTripSelected: (String, String) -> Unit,
+    val mapButtons: Array<NitroMapButton>
+) : Screen(carContext) {
+    init {
+        marker = TAG
+    }
+
+    override fun onGetTemplate(): Template {
+        return MapWithContentTemplate.Builder().apply {
+            setContentTemplate(ListTemplate.Builder().apply {
+                setHeader(Header.Builder().apply {
+                    setStartHeaderAction(Action.BACK)
+                    setTitle(title)
+                }.build())
+                setSingleList(ItemList.Builder().apply {
+                    setSelectedIndex(selectedRouteIndex)
+                    setOnSelectedListener {
+                        selectedRouteIndex = it
+                        onTripSelected(tripId, routes[it].id)
+                        setResult(it)
+                        invalidate()
+                    }
+                    routes.forEach { route ->
+                        addItem(Row.Builder().apply {
+                            setTitle(Parser.parseText(route.summaryVariants))
+                            addText(Parser.parseText(route.selectionSummaryVariants))
+                            addText(
+                                Parser.parseText(
+                                    AutoText(
+                                        "${Parser.PLACEHOLDER_DURATION} (${Parser.PLACEHOLDER_DISTANCE})",
+                                        route.steps.last().travelEstimates.distanceRemaining,
+                                        route.steps.last().travelEstimates.timeRemaining.seconds
+                                    )
+                                )
+                            )
+                        }.build())
+                    }
+                }.build())
+            }.build())
+
+            if (mapButtons.isNotEmpty()) {
+                setMapController(
+                    MapController.Builder()
+                        .setMapActionStrip(Parser.parseMapActions(carContext, mapButtons)).build()
+                )
+            }
+        }.build()
+    }
+
+    companion object {
+        const val TAG = "RoutePreviewTemplate"
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/template/SearchTemplate.kt

@@ -0,0 +1,91 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay.template
+
+import androidx.car.app.CarContext
+import androidx.car.app.model.ActionStrip
+import androidx.car.app.model.SearchTemplate
+import androidx.car.app.model.SearchTemplate.SearchCallback
+import androidx.car.app.model.Template
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroAction
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroAlignment
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroSection
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.SearchTemplateConfig
+
+class SearchTemplate(context: CarContext, config: SearchTemplateConfig) :
+    AndroidAutoTemplate<SearchTemplateConfig>(context, config) {
+
+    override val isRenderTemplate = false
+    override val templateId: String
+        get() = config.id
+    override val autoDismissMs = config.autoDismissMs
+
+    override fun parse(): Template {
+        return SearchTemplate.Builder(object : SearchCallback {
+            override fun onSearchTextChanged(searchText: String) {
+                config.onSearchTextChanged(searchText)
+            }
+            override fun onSearchSubmitted(searchText: String) {
+                config.onSearchTextSubmitted(searchText)
+            }
+        }).apply {
+            setItemList(Parser.parseSearchResult(context, config.results.items))
+            config.searchHint?.let {
+                setSearchHint(it)
+            }
+
+            config.initialSearchText?.let {
+                setInitialSearchText(it)
+            }
+
+            config.headerActions?.let { headerActions ->
+                headerActions.find {
+                    it.alignment == NitroAlignment.LEADING
+                }?.let { it ->
+                    setHeaderAction(Parser.parseAction(context, it))
+                }
+
+                val trailingActions = headerActions.filter { it ->
+                    it.alignment == NitroAlignment.TRAILING
+                }
+
+                if (trailingActions.isNotEmpty()) {
+                    val actionStripBuilder = ActionStrip.Builder()
+                    trailingActions.forEach { trailingAction ->
+                        actionStripBuilder.addAction(Parser.parseAction(context, trailingAction))
+                    }
+                    setActionStrip(actionStripBuilder.build())
+                }
+            }
+        }.build()
+    }
+
+    fun updateSearchResults(results: NitroSection) {
+        config = config.copy(results = results)
+        super.applyConfigUpdate()
+    }
+
+    override fun setTemplateHeaderActions(headerActions: Array<NitroAction>?) {
+        config = config.copy(headerActions = headerActions)
+        super.applyConfigUpdate()
+    }
+
+    override fun onWillAppear() {
+        config.onWillAppear?.let { it(null) }
+    }
+
+    override fun onWillDisappear() {
+        config.onWillDisappear?.let { it(null) }
+    }
+
+    override fun onDidAppear() {
+        config.onDidAppear?.let { it(null) }
+    }
+
+    override fun onDidDisappear() {
+        config.onDidDisappear?.let { it(null) }
+    }
+
+    override fun onPopped() {
+        config.onPopped?.let { it() }
+        templates.remove(templateId)
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/template/TripPreviewTemplate.kt

@@ -0,0 +1,196 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay.template
+
+import androidx.activity.OnBackPressedCallback
+import androidx.car.app.CarContext
+import androidx.car.app.OnScreenResultListener
+import androidx.car.app.Screen
+import androidx.car.app.model.Action
+import androidx.car.app.model.CarIcon
+import androidx.car.app.model.Header
+import androidx.car.app.model.Pane
+import androidx.car.app.model.PaneTemplate
+import androidx.car.app.model.Row
+import androidx.car.app.model.Template
+import androidx.car.app.navigation.model.MapController
+import androidx.car.app.navigation.model.MapWithContentTemplate
+import androidx.core.graphics.drawable.IconCompat
+import com.facebook.react.bridge.UiThreadUtil
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.AndroidAutoScreen
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.AutoText
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroMapButton
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.TripConfig
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.TripPreviewTextConfiguration
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.TripsConfig
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.R
+
+class TripPreviewTemplate(
+    carContext: CarContext,
+    val trips: Array<TripsConfig>,
+    selectedTripId: String?,
+    val textConfig: TripPreviewTextConfiguration,
+    val onTripSelected: (String, String) -> Unit,
+    val onTripStarted: (String, String) -> Unit,
+    val onBackPressed: () -> Unit,
+    val mapButtons: Array<NitroMapButton>
+) : Screen(carContext) {
+    var selectedTripIndex = selectedTripId?.let {
+        trips.indexOfFirst { trip -> trip.id == selectedTripId }
+    } ?: 0
+    var selectedRouteIndex = 0
+
+    init {
+        marker = TAG
+        // for whatever reason CarPlay fires this when opening up the trip selector so we do the same on AA
+        onTripSelected(
+            trips[selectedTripIndex].id, trips[selectedTripIndex].routeChoices.first().id
+        )
+
+        UiThreadUtil.runOnUiThread {
+            carContext.onBackPressedDispatcher.addCallback(
+                this, object : OnBackPressedCallback(true) {
+                    override fun handleOnBackPressed() {
+                        finish()
+                        onBackPressed()
+                    }
+                })
+        }
+    }
+
+
+    override fun onGetTemplate(): Template {
+        var selectedTrip = trips[selectedTripIndex]
+        var selectedRoute = selectedTrip.routeChoices[selectedRouteIndex]
+
+        return MapWithContentTemplate.Builder().apply {
+            val pane = Pane.Builder().apply {
+                addRow(Row.Builder().apply {
+                    setTitle(Parser.parseText(selectedRoute.additionalInformationVariants))
+                    addText(Parser.parseText(selectedRoute.selectionSummaryVariants))
+                }.build())
+                addRow(Row.Builder().apply {
+                    setTitle(
+                        "${textConfig.travelEstimatesTitle} ${
+                            Parser.formatToTimestamp(
+                                selectedRoute.steps.last().travelEstimates.timeRemaining
+                            )
+                        }"
+                    )
+                    addText(
+                        Parser.parseText(
+                            AutoText(
+                                "${Parser.PLACEHOLDER_DURATION} (${Parser.PLACEHOLDER_DISTANCE})",
+                                selectedRoute.steps.last().travelEstimates.distanceRemaining,
+                                selectedRoute.steps.last().travelEstimates.timeRemaining.seconds
+                            )
+                        )
+                    )
+                }.build())
+                addAction(Action.Builder().apply {
+                    setTitle(textConfig.startButtonTitle)
+                    setFlags(Action.FLAG_PRIMARY)
+                    setOnClickListener {
+                        // we have to slice away the first step since it is the origin
+                        val steps = selectedRoute.steps.slice(1 until selectedRoute.steps.size)
+                            .toTypedArray()
+                        val trip = TripConfig(selectedTrip.id, selectedRoute.copy(steps = steps))
+
+                        MapTemplate.startNavigation(trip)
+
+                        onTripStarted(selectedTrip.id, selectedRoute.id)
+                        finish()
+                    }
+                }.build())
+                if (selectedTrip.routeChoices.size > 1) {
+                    addAction(Action.Builder().apply {
+                        setIcon(
+                            CarIcon.Builder(
+                                IconCompat.createWithResource(
+                                    carContext, R.drawable.alt_route
+                                )
+                            ).build()
+                        )
+                        setOnClickListener {
+                            AndroidAutoScreen.getScreenManager()?.pushForResult(
+                                RoutePreviewTemplate(
+                                    carContext,
+                                    selectedTrip.id,
+                                    selectedTrip.routeChoices,
+                                    selectedRouteIndex,
+                                    textConfig.additionalRoutesButtonTitle,
+                                    onTripSelected,
+                                    mapButtons
+                                ), object : OnScreenResultListener {
+                                    override fun onScreenResult(result: Any?) {
+                                        if (result is Int) {
+                                            selectedRouteIndex = result
+                                        }
+                                    }
+                                })
+                        }
+                    }.build())
+                }
+            }.build()
+            setContentTemplate(PaneTemplate.Builder(pane).apply {
+                setHeader(Header.Builder().apply {
+                    setTitle(selectedRoute.steps.last().name)
+                    setStartHeaderAction(Action.BACK)
+                    if (trips.size > 1) {
+                        addEndHeaderAction(Action.Builder().apply {
+                            setEnabled(selectedTripIndex > 0)
+                            setIcon(
+                                CarIcon.Builder(
+                                    IconCompat.createWithResource(
+                                        carContext, R.drawable.ic_chevron_backward
+                                    )
+                                ).build()
+                            )
+                            setOnClickListener {
+                                selectedTripIndex--
+                                if (selectedTripIndex < 0) {
+                                    selectedTripIndex = trips.size - 1
+                                }
+                                selectedRouteIndex = 0
+                                selectedTrip = trips[selectedTripIndex]
+                                selectedRoute = selectedTrip.routeChoices.first()
+                                onTripSelected(selectedTrip.id, selectedRoute.id)
+                                invalidate()
+                            }
+                        }.build())
+                        addEndHeaderAction(Action.Builder().apply {
+                            setEnabled(selectedTripIndex < trips.size - 1)
+                            setIcon(
+                                CarIcon.Builder(
+                                    IconCompat.createWithResource(
+                                        carContext, R.drawable.ic_chevron_forward
+                                    )
+                                ).build()
+                            )
+                            setOnClickListener {
+                                selectedTripIndex++
+                                if (selectedTripIndex == trips.size) {
+                                    selectedTripIndex = 0
+                                }
+                                selectedRouteIndex = 0
+                                selectedTrip = trips[selectedTripIndex]
+                                selectedRoute = selectedTrip.routeChoices.first()
+                                onTripSelected(selectedTrip.id, selectedRoute.id)
+                                invalidate()
+                            }
+                        }.build())
+                    }
+                }.build())
+            }.build())
+
+            if (mapButtons.isNotEmpty()) {
+                setMapController(
+                    MapController.Builder()
+                        .setMapActionStrip(Parser.parseMapActions(carContext, mapButtons)).build()
+                )
+            }
+        }.build()
+    }
+
+    companion object {
+        const val TAG = "TripPreviewTemplate"
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/utils/AppInfo.kt

@@ -0,0 +1,34 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay.utils
+
+import android.content.Context
+import android.content.pm.PackageManager
+import android.graphics.drawable.Drawable
+import androidx.appcompat.content.res.AppCompatResources
+
+object AppInfo {
+    fun getApplicationLabel(context: Context): CharSequence {
+        val customLabelId = context.resources.getIdentifier(
+            "AutoPlayClusterSplashScreenLabel", "string", context.packageName
+        )
+
+        if (customLabelId > 0) {
+            return context.resources.getString(customLabelId)
+        }
+
+        val packageManager = context.packageManager
+        return try {
+            packageManager.getApplicationLabel(context.applicationInfo)
+        } catch (_: PackageManager.NameNotFoundException) {
+            "react-native-autoplay"
+        }
+    }
+
+    fun getApplicationIcon(context: Context): Drawable? {
+        val packageManager = context.packageManager
+        return try {
+            packageManager.getApplicationIcon(context.applicationInfo.packageName)
+        } catch (e: PackageManager.NameNotFoundException) {
+            AppCompatResources.getDrawable(context, android.R.mipmap.sym_def_app_icon)
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/utils/Debouncer.kt

@@ -0,0 +1,19 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay.utils
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+class Debouncer(private val delayMillis: Long = 300L) {
+  private var debounceJob: Job? = null
+
+  fun submit(action: () -> Unit) {
+    debounceJob?.cancel()
+    debounceJob = CoroutineScope(Dispatchers.Main).launch {
+      delay(delayMillis)
+      action()
+    }
+  }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/utils/ReactContextResolver.kt

@@ -0,0 +1,60 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay.utils
+
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactInstanceEventListener
+import com.facebook.react.ReactInstanceManager
+import com.facebook.react.bridge.ReactContext
+import com.margelo.nitro.BuildConfig
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+
+object ReactContextResolver {
+    suspend fun getReactContext(application: ReactApplication): ReactContext {
+        if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+            val host =
+                application.reactHost ?: throw IllegalArgumentException("application host null")
+            return suspendCancellableCoroutine { continuation ->
+                host.currentReactContext?.let {
+                    continuation.resume(it)
+                    return@suspendCancellableCoroutine
+                }
+
+                val listener = object : ReactInstanceEventListener {
+                    override fun onReactContextInitialized(context: ReactContext) {
+                        host.removeReactInstanceEventListener(this)
+                        continuation.resume(context)
+                    }
+                }
+                host.addReactInstanceEventListener(listener)
+
+                continuation.invokeOnCancellation {
+                    host.removeReactInstanceEventListener(listener)
+                }
+
+                host.start()
+            }
+        } else {
+            val reactInstanceManager = application.reactNativeHost.reactInstanceManager
+            return suspendCancellableCoroutine { continuation ->
+                reactInstanceManager.currentReactContext?.let {
+                    continuation.resume(it)
+                    return@suspendCancellableCoroutine
+                }
+
+                val listener = object : ReactInstanceManager.ReactInstanceEventListener {
+                    override fun onReactContextInitialized(context: ReactContext) {
+                        reactInstanceManager.removeReactInstanceEventListener(this)
+                        continuation.resume(context)
+                    }
+                }
+                reactInstanceManager.addReactInstanceEventListener(listener)
+
+                continuation.invokeOnCancellation {
+                    reactInstanceManager.removeReactInstanceEventListener(listener)
+                }
+
+                reactInstanceManager.createReactContextInBackground()
+            }
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/utils/SymbolFont.kt

@@ -0,0 +1,126 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay.utils
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Rect
+import android.graphics.RectF
+import android.graphics.Typeface
+import androidx.car.app.CarContext
+import androidx.core.content.res.ResourcesCompat
+import androidx.core.graphics.createBitmap
+import androidx.core.graphics.drawable.IconCompat
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.GlyphImage
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroImage
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.BuildConfig
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.R
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.Parser
+
+object SymbolFont {
+    const val TAG = "SymbolFont"
+
+    private var typeface: Typeface? = null
+
+    fun loadFont(context: Context) {
+        if (typeface != null) {
+            return
+        }
+
+        typeface = ResourcesCompat.getFont(context, R.font.materialsymbolsoutlined_regular)
+    }
+
+    fun imageFromGlyph(
+        context: Context,
+        glyph: Double,
+        color: Int = android.graphics.Color.BLACK,
+        backgroundColor: Int = android.graphics.Color.WHITE,
+        cornerRadius: Float = 8f,
+        fontScale: Float,
+    ): Bitmap? {
+        loadFont(context)
+
+        val font = typeface ?: run {
+            return null
+        }
+
+        val virtualScreenDensity = context.resources.displayMetrics.density
+        val scale = BuildConfig.SCALE_FACTOR * virtualScreenDensity
+
+        // Minimum recommended image size is 36dp according to https://developers.google.com/cars/design/create-apps/ux-requirements/templated-apps#navigation
+        val canvasSize = (36 * scale).toInt()
+        val bitmap = createBitmap(canvasSize, canvasSize)
+        val canvas = Canvas(bitmap)
+
+        val rectF = RectF(0f, 0f, canvasSize.toFloat(), canvasSize.toFloat())
+        var paint = Paint().apply {
+            this.color = backgroundColor
+            isAntiAlias = true
+        }
+        canvas.drawRoundRect(rectF, cornerRadius, cornerRadius, paint)
+
+        // Setup text paint
+        paint.reset()
+        paint = Paint().apply {
+            typeface = font
+            textSize = canvasSize.toFloat() * fontScale
+            this.color = color
+            isAntiAlias = true
+            textAlign = Paint.Align.LEFT
+        }
+
+        // Get the character from codepoint
+        val codepoint = glyph.toInt()
+        val text = String(Character.toChars(codepoint))
+
+        // Measure text
+        val bounds = Rect()
+        paint.getTextBounds(text, 0, text.length, bounds)
+
+        // Center the text
+        val x = (canvasSize - bounds.width()) / 2f - bounds.left
+        val y = (canvasSize - bounds.height()) / 2f - bounds.top
+
+        // Draw text
+        canvas.drawText(text, x, y, paint)
+
+        return bitmap
+    }
+
+    fun imageFromNitroImage(context: CarContext, image: GlyphImage): Bitmap? {
+        val color = if (context.isDarkMode) image.color.darkColor else image.color.lightColor
+        val backgroundColor =
+            if (context.isDarkMode) image.backgroundColor.darkColor else image.backgroundColor.lightColor
+
+        return imageFromGlyph(
+            context = context,
+            glyph = image.glyph,
+            color = color.toInt(),
+            backgroundColor = backgroundColor.toInt(),
+            fontScale = (image.fontScale ?: 1.0).toFloat()
+        )
+    }
+
+    fun imageFromNitroImages(
+        context: CarContext, images: List<NitroImage>
+    ): IconCompat {
+        val bitmaps = images.map {
+            Parser.parseImageToBitmap(
+                context, it.asFirstOrNull(), it.asSecondOrNull()
+            )!!
+        }
+
+        val height = bitmaps.maxOf { it.height }
+        val width = bitmaps.maxOf { it.width }
+        val totalWidth = width * images.size
+
+        val bitmap = createBitmap(totalWidth, height)
+        val canvas = Canvas(bitmap)
+
+        bitmaps.forEachIndexed { index, it ->
+            canvas.drawBitmap(it, (index * width).toFloat(), 0f, null)
+        }
+
+        return IconCompat.createWithBitmap(bitmap)
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/utils/ThreadUtil.kt

@@ -0,0 +1,19 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay.utils
+
+import com.facebook.react.bridge.UiThreadUtil
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+
+object ThreadUtil {
+    suspend fun <T> postOnUiAndAwait(block: () -> T): Result<T> =
+        suspendCancellableCoroutine { cont ->
+            UiThreadUtil.runOnUiThread {
+                try {
+                    val result = block()
+                    cont.resume(Result.success(result))
+                } catch (e: Exception) {
+                    cont.resume(Result.failure(e))
+                }
+            }
+        }
+}

package/android/src/main/res/drawable/alt_route.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960">
+  <path
+      android:pathData="M440,880v-200q0,-56 -17,-83t-45,-53l57,-57q12,11 23,23.5t22,26.5q14,-19 28.5,-33.5T538,475q38,-35 69,-81t33,-161l-63,63 -57,-56 160,-160 160,160 -56,56 -64,-63q-2,143 -44,203.5T592,535q-32,29 -52,56.5T520,680v200h-80ZM248,327q-4,-20 -5.5,-44t-2.5,-50l-64,63 -56,-56 160,-160 160,160 -57,56 -63,-62q0,21 2,39.5t4,34.5l-78,19ZM334,503q-20,-21 -38.5,-49T263,385l77,-19q10,27 23,46t28,34l-57,57Z"
+      android:fillColor="#ffffff"/>
+</vector>

package/android/src/main/res/drawable/ic_chevron_backward.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960">
+  <path
+      android:pathData="M560,720 L320,480l240,-240 56,56 -184,184 184,184 -56,56Z"
+      android:fillColor="#ffffff"/>
+</vector>

package/android/src/main/res/drawable/ic_chevron_forward.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960">
+  <path
+      android:pathData="M504,480 L320,296l56,-56 240,240 -240,240 -56,-56 184,-184Z"
+      android:fillColor="#ffffff"/>
+</vector>

package/android/src/main/res/xml/automotive_app_desc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<automotiveApp>
+  <uses name="template" />
+</automotiveApp>

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  NitroAutoplay
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#pragma once