@iternio/react-native-auto-play 0.0.1

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

@@ -0,0 +1,92 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay.template
+
+import androidx.car.app.CarContext
+import androidx.car.app.model.GridItem
+import androidx.car.app.model.GridTemplate
+import androidx.car.app.model.ItemList
+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.GridTemplateConfig
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroAction
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroGridButton
+
+class GridTemplate(context: CarContext, config: GridTemplateConfig) :
+    AndroidAutoTemplate<GridTemplateConfig>(context, config) {
+
+    override val isRenderTemplate = false
+    override val templateId: String
+        get() = config.id
+    override val autoDismissMs = config.autoDismissMs
+
+    override fun parse(): Template {
+        val template = GridTemplate.Builder().apply {
+            setHeader(Parser.parseHeader(context, config.title, config.headerActions))
+
+            if (config.buttons.isEmpty()) {
+                setLoading(true)
+                return@apply
+            }
+
+            setSingleList(ItemList.Builder().apply {
+                config.buttons.forEachIndexed { index, button ->
+                    addItem(GridItem.Builder().apply {
+                        setTitle(Parser.parseText(button.title))
+                        setOnClickListener(button.onPress)
+                        button.image.let { image ->
+                            setImage(Parser.parseImage(context, image))
+                        }
+                    }.build())
+                }
+            }.build())
+        }.build()
+
+        return this.config.mapConfig?.let {
+            MapWithContentTemplate.Builder().apply {
+                setContentTemplate(template)
+                it.mapButtons?.let { mapButtons ->
+                    setMapController(
+                        MapController.Builder()
+                            .setMapActionStrip(Parser.parseMapActions(context, mapButtons)).build()
+                    )
+                }
+                it.headerActions?.let { headerActions ->
+                    setActionStrip(Parser.parseMapHeaderActions(context, headerActions))
+                }
+            }.build()
+        } ?: run {
+            template
+        }
+    }
+
+    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)
+    }
+
+    fun updateButtons(buttons: Array<NitroGridButton>) {
+        config = config.copy(buttons = buttons)
+        super.applyConfigUpdate()
+    }
+}

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

@@ -0,0 +1,98 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay.template
+
+import androidx.car.app.CarContext
+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 com.margelo.nitro.swe.iternio.reactnativeautoplay.InformationTemplateConfig
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroAction
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroSection
+
+class InformationTemplate(context: CarContext, config: InformationTemplateConfig) :
+    AndroidAutoTemplate<InformationTemplateConfig>(context, config) {
+
+    override val isRenderTemplate = false
+    override val templateId: String
+        get() = config.id
+    override val autoDismissMs = config.autoDismissMs
+
+
+    override fun parse(): Template {
+        val pane = Pane.Builder().apply {
+            if (config.section.items.isEmpty()) {
+                setLoading(true)
+            } else {
+                config.section.items.forEach { item ->
+                    addRow(Row.Builder().apply {
+                        setTitle(Parser.parseText(item.title))
+                        item.detailedText?.let { detailedText ->
+                            addText(Parser.parseText(detailedText))
+                        }
+                        item.image?.let {
+                            setImage(Parser.parseImage(context, item.image))
+                        }
+                    }.build())
+                }
+            }
+
+            config.actions?.let {
+                it.forEach { action ->
+                    addAction(Parser.parseAction(context, action))
+                }
+            }
+        }
+
+        val template = PaneTemplate.Builder(pane.build()).apply {
+            setHeader(Parser.parseHeader(context, config.title, config.headerActions))
+        }.build()
+
+        return this.config.mapConfig?.let {
+            MapWithContentTemplate.Builder().apply {
+                setContentTemplate(template)
+                it.mapButtons?.let { mapButtons ->
+                    setMapController(
+                        MapController.Builder()
+                            .setMapActionStrip(Parser.parseMapActions(context, mapButtons)).build()
+                    )
+                }
+                it.headerActions?.let { headerActions ->
+                    setActionStrip(Parser.parseMapHeaderActions(context, headerActions))
+                }
+            }.build()
+        } ?: template
+    }
+
+    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)
+    }
+
+    fun updateSection(section: NitroSection) {
+        config = config.copy(section = section)
+        super.applyConfigUpdate()
+    }
+}

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

@@ -0,0 +1,101 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay.template
+
+import androidx.car.app.CarContext
+import androidx.car.app.model.ListTemplate
+import androidx.car.app.model.SectionedItemList
+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.ListTemplateConfig
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroAction
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroSection
+
+class ListTemplate(context: CarContext, config: ListTemplateConfig) :
+    AndroidAutoTemplate<ListTemplateConfig>(context, config) {
+
+    override val isRenderTemplate = false
+    override val templateId: String
+        get() = config.id
+    override val autoDismissMs = config.autoDismissMs
+
+    override fun parse(): Template {
+        val template = ListTemplate.Builder().apply {
+            setHeader(Parser.parseHeader(context, config.title, config.headerActions))
+
+            config.sections?.let { sections ->
+                if (sections.isEmpty()) {
+                    setLoading(true)
+                } else if (sections.size == 1 && sections.first().title == null) {
+                    val section = sections[0]
+                    setSingleList(
+                        Parser.parseRows(
+                            context, section.items, 0, config.id, section.type
+                        )
+                    )
+                } else {
+                    sections.forEachIndexed { index, section ->
+                        addSectionedList(
+                            SectionedItemList.create(
+                                Parser.parseRows(
+                                    context, section.items, index, config.id, section.type
+                                ), section.title!!
+                            )
+                        )
+                    }
+                }
+            } ?: run {
+                setLoading(true)
+            }
+        }.build()
+
+        return this.config.mapConfig?.let {
+            MapWithContentTemplate.Builder().apply {
+                setContentTemplate(template)
+                it.mapButtons?.let { mapButtons ->
+                    setMapController(
+                        MapController.Builder()
+                            .setMapActionStrip(Parser.parseMapActions(context, mapButtons)).build()
+                    )
+                }
+                it.headerActions?.let { headerActions ->
+                    setActionStrip(Parser.parseMapHeaderActions(context, headerActions))
+                }
+            }.build()
+        } ?: template
+    }
+
+    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)
+    }
+
+    fun updateSections(sections: Array<NitroSection>?) {
+        config = config.copy(sections = sections)
+        super.applyConfigUpdate()
+    }
+
+    companion object {
+
+    }
+}

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

@@ -0,0 +1,365 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay.template
+
+import android.graphics.Color
+import androidx.car.app.AppManager
+import androidx.car.app.CarContext
+import androidx.car.app.model.Action
+import androidx.car.app.model.Alert
+import androidx.car.app.model.AlertCallback
+import androidx.car.app.model.CarColor
+import androidx.car.app.model.Template
+import androidx.car.app.navigation.NavigationManager
+import androidx.car.app.navigation.NavigationManagerCallback
+import androidx.car.app.navigation.model.Destination
+import androidx.car.app.navigation.model.MessageInfo
+import androidx.car.app.navigation.model.NavigationTemplate
+import androidx.car.app.navigation.model.RoutingInfo
+import androidx.car.app.navigation.model.TravelEstimate
+import androidx.car.app.navigation.model.Trip
+import com.facebook.react.bridge.UiThreadUtil
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.AlertActionStyle
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.AlertDismissalReason
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.AndroidAutoScreen
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.AndroidAutoSession
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.MapTemplateConfig
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroAction
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroManeuver
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroMapButton
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroNavigationAlert
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.TripConfig
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.TripPoint
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.VisibleTravelEstimate
+import java.security.InvalidParameterException
+
+class MapTemplate(
+    context: CarContext, config: MapTemplateConfig, initNavigationManager: Boolean = false
+) : AndroidAutoTemplate<MapTemplateConfig>(context, config) {
+
+    override val isRenderTemplate = true
+    override val templateId: String
+        get() = config.id
+    override val autoDismissMs = config.autoDismissMs
+
+    private var alertPriority = 0
+    private var alertIds: HashSet<Int> = HashSet()
+
+
+    init {
+        if (initNavigationManager) {
+            val navigationManagerCallback = object : NavigationManagerCallback {
+                override fun onAutoDriveEnabled() {
+                    config.onAutoDriveEnabled?.let {
+                        it()
+                    }
+                }
+
+                override fun onStopNavigation() {
+                    navigationEnded()
+                    config.onStopNavigation()
+                }
+            }
+
+            UiThreadUtil.runOnUiThread {
+                navigationManager = context.getCarService(NavigationManager::class.java)
+                navigationManager.setNavigationManagerCallback(navigationManagerCallback)
+            }
+        }
+    }
+
+    override fun parse(): Template {
+        return NavigationTemplate.Builder().apply {
+            setBackgroundColor(cardBackgroundColor)
+            config.mapButtons?.let { buttons ->
+                setMapActionStrip(Parser.parseMapActions(context, buttons))
+            }
+            config.headerActions?.let { headerActions ->
+                setActionStrip(Parser.parseMapHeaderActions(context, headerActions))
+            }
+            val travelEstimates =
+                if (config.visibleTravelEstimate == VisibleTravelEstimate.FIRST) destinationTravelEstimates.firstOrNull() else destinationTravelEstimates.lastOrNull()
+            travelEstimates?.let {
+                setDestinationTravelEstimate(
+                    Parser.parseTravelEstimates(it.travelEstimates)
+                )
+            }
+            if (isNavigating) {
+                navigationInfo?.let {
+                    setNavigationInfo(it)
+                } ?: run {
+                    setNavigationInfo(RoutingInfo.Builder().apply {
+                        setLoading(true)
+                    }.build())
+                }
+            }
+        }.build()
+    }
+
+    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)
+    }
+
+    fun setMapActions(buttons: Array<NitroMapButton>?) {
+        config = config.copy(mapButtons = buttons)
+        applyConfigUpdate()
+    }
+
+    fun showAlert(alertConfig: NitroNavigationAlert) {
+        if (alertPriority > alertConfig.priority) {
+            // ignore alerts with lower priority than current alert
+            return
+        }
+
+        val title = Parser.parseText(alertConfig.title)
+        val durationMillis = alertConfig.durationMs.toLong()
+
+        val alert = Alert.Builder(alertConfig.id.toInt(), title, durationMillis).apply {
+            var isAutoDismissal = false
+
+            alertConfig.subtitle?.let { subtitle -> setSubtitle(Parser.parseText(subtitle)) }
+            alertConfig.image?.let { image -> setIcon(Parser.parseImage(context, image)) }
+            addAction(Action.Builder().apply {
+                setTitle(alertConfig.primaryAction.title)
+                setFlags(Action.FLAG_PRIMARY)
+                setFlags(Action.FLAG_DEFAULT)
+                setOnClickListener(alertConfig.primaryAction.onPress)
+                alertConfig.primaryAction.style?.let { style ->
+                    if (style == AlertActionStyle.DESTRUCTIVE) {
+                        setBackgroundColor(CarColor.RED)
+                    }
+                }
+            }.build())
+            alertConfig.secondaryAction?.let { action ->
+                addAction(Action.Builder().apply {
+                    setTitle(action.title)
+                    setOnClickListener(action.onPress)
+                    action.style?.let { style ->
+                        if (style == AlertActionStyle.DESTRUCTIVE) {
+                            setBackgroundColor(CarColor.RED)
+                        }
+                    }
+                }.build())
+            }
+            setCallback(object : AlertCallback {
+                override fun onCancel(reason: Int) {
+                    isAutoDismissal = true
+                    when (reason) {
+                        AlertCallback.REASON_TIMEOUT -> alertConfig.onDidDismiss?.let {
+                            it(
+                                AlertDismissalReason.TIMEOUT
+                            )
+                        }
+
+                        AlertCallback.REASON_USER_ACTION -> alertConfig.onDidDismiss?.let {
+                            it(AlertDismissalReason.USER)
+                        }
+
+                        AlertCallback.REASON_NOT_SUPPORTED -> {
+                            // we make sure that this can be called on navigation templates already so this should never happen
+                        }
+                    }
+                }
+
+                override fun onDismiss() {
+                    alertIds.remove(alertConfig.id.toInt())
+                    if (alertIds.isEmpty()) {
+                        alertPriority = 0
+                    }
+
+                    if (!isAutoDismissal) {
+                        alertConfig.onDidDismiss?.let {
+                            it(AlertDismissalReason.USER)
+                        }
+                    }
+                }
+            })
+        }.build()
+
+        if (!alertIds.contains(alert.id)) {
+            alertConfig.onWillShow?.let { it() }
+            alertIds.add(alert.id)
+            alertPriority = alertConfig.priority.toInt()
+        }
+
+        context.getCarService(AppManager::class.java).showAlert(alert)
+    }
+
+    fun updateVisibleTravelEstimate(
+        visibleTravelEstimate: VisibleTravelEstimate
+    ) {
+        config = config.copy(visibleTravelEstimate = visibleTravelEstimate)
+        applyConfigUpdate()
+    }
+
+    companion object {
+        private lateinit var navigationManager: NavigationManager
+        var isNavigating = false
+        var navigationInfo: NavigationTemplate.NavigationInfo? = null
+        var cardBackgroundColor: CarColor = CarColor.createCustom(Color.BLACK, Color.BLACK)
+
+        private var destinationTravelEstimates: Array<TripPoint> = arrayOf()
+
+        fun getTripDestinations(): Map<Destination, TravelEstimate> {
+            return mutableMapOf<Destination, TravelEstimate>().apply {
+                destinationTravelEstimates.forEach { step ->
+                    val destination = Destination.Builder().apply {
+                        setName(step.name)
+                    }.build()
+
+                    val travelEstimates = Parser.parseTravelEstimates(step.travelEstimates)
+
+                    put(destination, travelEstimates)
+                }
+            }
+        }
+
+        fun updateTripDestinations() {
+            val tripDestinations = getTripDestinations()
+            UiThreadUtil.runOnUiThread {
+                navigationManager.updateTrip(Trip.Builder().apply {
+                    tripDestinations.forEach {
+                        addDestination(it.key, it.value)
+                    }
+                }.build())
+            }
+        }
+
+        fun startNavigation(trip: TripConfig) {
+            isNavigating = true
+            val steps = trip.routeChoice.steps
+
+            destinationTravelEstimates = steps
+
+            AndroidAutoScreen.invalidateSurfaceScreens()
+
+            UiThreadUtil.runOnUiThread {
+                navigationManager.navigationStarted()
+
+                updateTripDestinations()
+            }
+        }
+
+        fun updateTravelEstimates(steps: Array<TripPoint>) {
+            destinationTravelEstimates = steps
+
+            AndroidAutoScreen.invalidateSurfaceScreens()
+        }
+
+        fun stopNavigation() {
+            if (!this::navigationManager.isInitialized) {
+                return
+            }
+
+            UiThreadUtil.runOnUiThread {
+                navigationManager.navigationEnded()
+            }
+            navigationEnded()
+        }
+
+        fun navigationEnded() {
+            isNavigating = false
+            destinationTravelEstimates = arrayOf()
+            navigationInfo = null
+
+            AndroidAutoScreen.invalidateSurfaceScreens()
+        }
+
+        fun updateManeuvers(maneuvers: NitroManeuver) {
+            if (!isNavigating) {
+                return
+            }
+
+            val context = AndroidAutoSession.getRootContext()
+                ?: throw InvalidParameterException("updateManeuvers, could not get root car context")
+
+            if (!this::navigationManager.isInitialized) {
+                throw InvalidParameterException("updateManeuvers, navigationManager not initialized, did you call startNavigation?")
+            }
+
+            val routingInfo = maneuvers.asFirstOrNull()
+            val messageInfo = maneuvers.asSecondOrNull()
+
+            if (routingInfo.isNullOrEmpty() && messageInfo == null) {
+                navigationInfo = null
+                AndroidAutoScreen.invalidateSurfaceScreens()
+                return
+            }
+
+            if (messageInfo != null) {
+                val backgroundColor =
+                    if (context.isDarkMode) messageInfo.cardBackgroundColor.darkColor else messageInfo.cardBackgroundColor.lightColor
+                cardBackgroundColor = Parser.parseColor(backgroundColor)
+
+                navigationInfo = MessageInfo.Builder(messageInfo.title).apply {
+                    messageInfo.text?.let {
+                        setText(it)
+                    }
+                    messageInfo.image?.let {
+                        setImage(Parser.parseImage(context, it))
+                    }
+                }.build()
+
+                AndroidAutoScreen.invalidateSurfaceScreens()
+                return
+            }
+
+            val current = routingInfo?.getOrNull(0)
+            val next = routingInfo?.getOrNull(1)
+
+            if (current == null) {
+                return
+            }
+
+            val backgroundColor =
+                if (context.isDarkMode) current.cardBackgroundColor.darkColor else current.cardBackgroundColor.lightColor
+            cardBackgroundColor = Parser.parseColor(backgroundColor)
+
+            val currentStep = Parser.parseStep(context, current)
+            val nextStep = next?.let { Parser.parseStep(context, it) }
+
+            navigationInfo = RoutingInfo.Builder().apply {
+                setCurrentStep(
+                    currentStep, Parser.parseDistance(current.travelEstimates.distanceRemaining)
+                )
+                nextStep?.let { setNextStep(it) }
+            }.build()
+
+            AndroidAutoScreen.invalidateSurfaceScreens()
+
+            UiThreadUtil.runOnUiThread {
+                navigationManager.updateTrip(Trip.Builder().apply {
+                    addStep(
+                        currentStep, Parser.parseTravelEstimates(current.travelEstimates)
+                    )
+                    nextStep?.let {
+                        addStep(it, Parser.parseTravelEstimates(next.travelEstimates))
+                    }
+                    getTripDestinations().forEach {
+                        addDestination(it.key, it.value)
+                    }
+                }.build())
+            }
+        }
+    }
+}