@iternio/react-native-auto-play 0.0.1

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

@@ -0,0 +1,126 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import android.annotation.SuppressLint
+import android.content.ComponentName
+import android.content.Intent
+import android.content.ServiceConnection
+import android.content.pm.ApplicationInfo
+import android.os.IBinder
+import androidx.car.app.CarAppService
+import androidx.car.app.Session
+import androidx.car.app.SessionInfo
+import androidx.car.app.validation.HostValidator
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactContext
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.utils.ReactContextResolver
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class AndroidAutoService : CarAppService() {
+    private lateinit var reactContext: ReactContext
+
+    private var isServiceBound = false
+    private var isSessionStarted = false
+    private var isReactAppStarted = false
+
+    @SuppressLint("PrivateResource")
+    override fun createHostValidator(): HostValidator {
+        return if ((applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
+            HostValidator.ALLOW_ALL_HOSTS_VALIDATOR
+        } else {
+            HostValidator.Builder(applicationContext)
+                .addAllowedHosts(androidx.car.app.R.array.hosts_allowlist_sample).build()
+        }
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+
+        CoroutineScope(Dispatchers.Main).launch {
+            reactContext = ReactContextResolver.getReactContext(application as ReactApplication)
+            reactContext.addLifecycleEventListener(reactLifecycleObserver)
+        }
+    }
+
+    override fun onCreateSession(sessionInfo: SessionInfo): Session {
+        val session = AndroidAutoSession(sessionInfo, application as ReactApplication)
+
+        if (sessionInfo.displayType == SessionInfo.DISPLAY_TYPE_CLUSTER) {
+            return session
+        }
+
+        session.lifecycle.addObserver(sessionLifecycleObserver)
+
+        return session
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+
+        stopForeground(STOP_FOREGROUND_REMOVE)
+
+        if (!this::reactContext.isInitialized) {
+            return
+        }
+
+        reactContext.removeLifecycleEventListener(reactLifecycleObserver)
+    }
+
+    private val reactLifecycleObserver = object : LifecycleEventListener {
+        override fun onHostResume() {
+            isReactAppStarted = true
+        }
+
+        override fun onHostPause() {
+            isReactAppStarted = false
+        }
+
+        override fun onHostDestroy() {
+            stopSelf()
+        }
+    }
+
+    private val sessionLifecycleObserver = object : DefaultLifecycleObserver {
+        override fun onCreate(owner: LifecycleOwner) {
+            val serviceIntent = Intent(applicationContext, HeadlessTaskService::class.java)
+            bindService(serviceIntent, connection, BIND_AUTO_CREATE)
+        }
+
+        override fun onResume(owner: LifecycleOwner) {
+            isSessionStarted = true
+        }
+
+        override fun onPause(owner: LifecycleOwner) {
+            isSessionStarted = false
+        }
+
+        override fun onDestroy(owner: LifecycleOwner) {
+            if (isServiceBound) {
+                unbindService(connection)
+                isServiceBound = false
+            }
+
+            this@AndroidAutoService.stopForeground(STOP_FOREGROUND_REMOVE)
+        }
+    }
+
+    private val connection: ServiceConnection = object : ServiceConnection {
+        override fun onServiceConnected(
+            className: ComponentName, service: IBinder
+        ) {
+            isServiceBound = true
+        }
+
+        override fun onServiceDisconnected(arg0: ComponentName) {
+            isServiceBound = false
+        }
+    }
+
+    companion object {
+        const val TAG = "AndroidAutoService"
+    }
+}

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

@@ -0,0 +1,213 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import android.content.Intent
+import android.content.res.Configuration
+import androidx.car.app.CarContext
+import androidx.car.app.Screen
+import androidx.car.app.Session
+import androidx.car.app.SessionInfo
+import androidx.car.app.model.CarIcon
+import androidx.car.app.model.MessageTemplate
+import androidx.car.app.model.Template
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactContext
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.AndroidAutoTemplate
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.MapTemplate
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.utils.AppInfo
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.utils.ReactContextResolver
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import java.util.UUID
+
+class AndroidAutoSession(sessionInfo: SessionInfo, private val reactApplication: ReactApplication) :
+    Session() {
+
+    private val isCluster = sessionInfo.displayType == SessionInfo.DISPLAY_TYPE_CLUSTER
+    private val clusterId = if (isCluster) UUID.randomUUID().toString() else null
+    private val moduleName = clusterId ?: ROOT_SESSION
+
+    private fun getInitialTemplate(): Template {
+        if (isCluster) {
+
+            // clusters can not display any actions but still need one to not crash...
+            val action =
+                NitroAction(null, null, null, {}, NitroActionType.APPICON, null, null, null)
+
+            // clusters can host NavigationTemplate only which is a MapTemplate on AutoPlay
+            val config = MapTemplateConfig(
+                moduleName,
+                null,
+                null,
+                null,
+                null,
+                null,
+                null,
+                null,
+                null,
+                null,
+                null,
+                null,
+                null,
+                {},
+                null,
+                null,
+                arrayOf(action),
+            )
+
+            val template = MapTemplate(context = carContext, config, initNavigationManager = false)
+            AndroidAutoTemplate.setTemplate(moduleName, template)
+
+            return template.parse()
+        }
+
+        val appName = AppInfo.getApplicationLabel(carContext)
+
+        return MessageTemplate.Builder(appName).apply {
+            setIcon(CarIcon.APP_ICON)
+        }.build()
+    }
+
+    override fun onCreateScreen(intent: Intent): Screen {
+        val initialTemplate = getInitialTemplate()
+        val screen = AndroidAutoScreen(carContext, moduleName, initialTemplate)
+
+        sessions[moduleName] = ScreenContext(
+            carContext = carContext, session = this, state = VisibilityState.DIDDISAPPEAR
+        )
+
+        clusterId?.let {
+            clusterSessions.add(it)
+        }
+
+        lifecycle.addObserver(sessionLifecycleObserver)
+
+        CoroutineScope(Dispatchers.Main).launch {
+            reactContext = ReactContextResolver.getReactContext(reactApplication)
+            reactContext.addLifecycleEventListener(reactLifecycleObserver)
+
+            // TODO this is not required for templates that host a component, check if we need this for non-rendering templates
+            /*
+            val appRegistry = reactContext.getJSModule(AppRegistry::class.java)
+                ?: throw ClassNotFoundException("could not get AppRegistry instance")
+            val jsAppModuleName = if (isCluster) "AndroidAutoCluster" else "AndroidAuto"
+            val appParams = WritableNativeMap().apply {
+                putMap("initialProps", Arguments.createMap().apply {
+                    putString("id", clusterTemplateId)
+                })
+            }
+
+            appRegistry.runApplication(jsAppModuleName, appParams)
+            */
+
+            if (clusterId != null) {
+                HybridCluster.emit(ClusterEventName.DIDCONNECTWITHWINDOW, clusterId)
+                return@launch
+            }
+
+            HybridAutoPlay.emit(EventName.DIDCONNECT)
+        }
+
+        return screen
+    }
+
+    override fun onCarConfigurationChanged(configuration: Configuration) {
+        val colorScheme = if (carContext.isDarkMode) ColorScheme.DARK else ColorScheme.LIGHT
+
+        if (clusterId != null) {
+            HybridCluster.emitColorScheme(clusterId, colorScheme)
+            AndroidAutoScreen.getScreen(clusterId)?.applyConfigUpdate(invalidate = true)
+            return
+        }
+
+        val marker = AndroidAutoScreen.getScreen(ROOT_SESSION)?.marker ?: return
+        val config = AndroidAutoTemplate.getConfig(marker) as MapTemplateConfig? ?: return
+
+        if (config.onAppearanceDidChange != null) {
+            config.onAppearanceDidChange(colorScheme)
+        }
+
+        AndroidAutoScreen.invalidateScreens()
+    }
+
+    private val sessionLifecycleObserver = object : DefaultLifecycleObserver {
+        override fun onCreate(owner: LifecycleOwner) {
+            sessions[moduleName]?.state = VisibilityState.WILLAPPEAR
+            HybridAutoPlay.emitRenderState(moduleName, VisibilityState.WILLAPPEAR)
+        }
+
+        override fun onResume(owner: LifecycleOwner) {
+            sessions[moduleName]?.state = VisibilityState.DIDAPPEAR
+            HybridAutoPlay.emitRenderState(moduleName, VisibilityState.DIDAPPEAR)
+        }
+
+        override fun onPause(owner: LifecycleOwner) {
+            sessions[moduleName]?.state = VisibilityState.WILLDISAPPEAR
+            HybridAutoPlay.emitRenderState(moduleName, VisibilityState.WILLDISAPPEAR)
+        }
+
+        override fun onStop(owner: LifecycleOwner) {
+            sessions[moduleName]?.state = VisibilityState.DIDDISAPPEAR
+            HybridAutoPlay.emitRenderState(moduleName, VisibilityState.DIDDISAPPEAR)
+        }
+
+        override fun onDestroy(owner: LifecycleOwner) {
+            sessions.remove(moduleName)
+            VirtualRenderer.removeRenderer(moduleName)
+            clusterId?.let {
+                HybridCluster.emit(ClusterEventName.DIDDISCONNECT, clusterId)
+                clusterSessions.remove(it)
+                return
+            }
+
+            HybridAutoPlay.emit(EventName.DIDDISCONNECT)
+        }
+    }
+
+    private val reactLifecycleObserver = object : LifecycleEventListener {
+        override fun onHostResume() {}
+
+        override fun onHostPause() {}
+
+        override fun onHostDestroy() {
+            carContext.finishCarApp()
+        }
+    }
+
+    data class ScreenContext(
+        val carContext: CarContext, val session: AndroidAutoSession, var state: VisibilityState
+    )
+
+    companion object {
+        const val TAG = "AndroidAutoSession"
+        const val ROOT_SESSION = "AutoPlayRoot"
+
+        private lateinit var reactContext: ReactContext
+        private val sessions = mutableMapOf<String, ScreenContext>()
+
+        private val clusterSessions = mutableListOf<String>()
+
+        fun getIsConnected(): Boolean {
+            return sessions.containsKey(ROOT_SESSION)
+        }
+
+        fun getState(marker: String): VisibilityState? {
+            return sessions[marker]?.state
+        }
+
+        fun getCarContext(marker: String): CarContext? {
+            return sessions.get(marker)?.carContext
+        }
+
+        fun getRootContext(): CarContext? {
+            return sessions[ROOT_SESSION]?.carContext
+        }
+
+        fun getClusterSessions(): Array<String> {
+            return clusterSessions.toTypedArray()
+        }
+    }
+}

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

@@ -0,0 +1,133 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import androidx.car.app.hardware.common.CarValue
+import androidx.car.app.hardware.info.Model
+
+class AndroidAutoTelemetryHolder {
+    private var isDirty = false
+    private val lock = Any()
+
+    private var batteryLevel: Float? = null
+    private var batteryLevelTimestamp: Int? = null
+
+    private var fuelLevel: Float? = null
+    private var fuelLevelTimestamp: Int? = null
+
+    private var range: Float? = null
+    private var rangeTimestamp: Int? = null
+
+    private var speed: Float? = null
+    private var speedTimestamp: Int? = null
+
+    private var odometer: Float? = null
+    private var odometerTimestamp: Int? = null
+
+    private var name: String? = null
+    private var manufacturer: String? = null
+    private var year: Int? = null
+
+    fun updateVehicle(model: Model) = synchronized(lock) {
+        name = if (model.name.status == CarValue.STATUS_SUCCESS) {
+            model.name.value
+        } else null
+
+        manufacturer = if (model.manufacturer.status == CarValue.STATUS_SUCCESS) {
+            model.manufacturer.value
+        } else null
+
+        year = if (model.year.status == CarValue.STATUS_SUCCESS) {
+            model.year.value
+        } else null
+
+        isDirty = true
+    }
+
+    fun updateBatteryLevel(value: Float) = synchronized(lock) {
+        if (batteryLevel == value) {
+            return
+        }
+
+        batteryLevel = value
+        batteryLevelTimestamp = (System.currentTimeMillis() / 1000L).toInt()
+        isDirty = true
+    }
+
+    fun updateFuelLevel(value: Float) = synchronized(lock) {
+        if (fuelLevel == value) {
+            return
+        }
+
+        fuelLevel = value
+        fuelLevelTimestamp = (System.currentTimeMillis() / 1000L).toInt()
+        isDirty = true
+    }
+
+    fun updateRange(value: Float) = synchronized(lock) {
+        if (range == value) {
+            return
+        }
+
+        range = value
+        rangeTimestamp = (System.currentTimeMillis() / 1000L).toInt()
+        isDirty = true
+    }
+
+    fun updateSpeed(value: Float?) = synchronized(lock) {
+        if (speed == value) {
+            return
+        }
+
+        speed = value
+        speedTimestamp = (System.currentTimeMillis() / 1000L).toInt()
+        isDirty = true
+    }
+
+    fun updateOdometer(value: Float?) = synchronized(lock) {
+        if (odometer == value) {
+            return
+        }
+
+        odometer = value
+        odometerTimestamp = (System.currentTimeMillis() / 1000L).toInt()
+        isDirty = true
+    }
+
+    fun toTelemetry(): Telemetry? {
+        synchronized(lock) {
+            if (!isDirty) {
+                return null
+            }
+
+            isDirty = false
+
+            return Telemetry(
+                batteryLevel = createNumericTelemetryItem(batteryLevel, batteryLevelTimestamp),
+                fuelLevel = createNumericTelemetryItem(fuelLevel, fuelLevelTimestamp),
+                range = createNumericTelemetryItem(range, rangeTimestamp),
+                speed = createNumericTelemetryItem(speed, speedTimestamp),
+                odometer = createNumericTelemetryItem(odometer, odometerTimestamp),
+                vehicle = VehicleTelemetryItem(
+                    name = createStringTelemetryItem(name),
+                    manufacturer = createStringTelemetryItem(manufacturer),
+                    year = createNumericTelemetryItem(year?.toFloat(), 0)
+                )
+            )
+        }
+    }
+}
+
+private fun createNumericTelemetryItem(value: Float?, timestamp: Int?): NumericTelemetryItem? {
+    if (value == null || timestamp == null) {
+        return null
+    }
+
+    return NumericTelemetryItem(timestamp.toDouble(), value.toDouble())
+}
+
+private fun createStringTelemetryItem(value: String?): StringTelemetryItem? {
+    if (value == null) {
+        return null
+    }
+
+    return StringTelemetryItem(0.0, value)
+}

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

@@ -0,0 +1,201 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.car.app.CarContext
+import androidx.car.app.hardware.CarHardwareManager
+import androidx.car.app.hardware.common.CarValue
+import androidx.car.app.hardware.common.OnCarDataAvailableListener
+import androidx.car.app.hardware.info.EnergyLevel
+import androidx.car.app.hardware.info.Mileage
+import androidx.car.app.hardware.info.Model
+import androidx.car.app.hardware.info.Speed
+import androidx.car.app.versioning.CarAppApiLevels
+import androidx.core.content.ContextCompat
+
+object AndroidAutoTelemetryObserver {
+    private var telemetryCallbacks: MutableList<(telemetry: Telemetry?, error: String?) -> Unit> =
+        ArrayList();
+
+    private var isRunning = false
+    private var carContext: CarContext? = null
+
+    private val telemetryHolder = AndroidAutoTelemetryHolder()
+    private val handler = Handler(Looper.getMainLooper())
+
+    private val mModelListener = OnCarDataAvailableListener<Model> {
+        telemetryHolder.updateVehicle(it)
+
+        val tlm = telemetryHolder.toTelemetry()
+        tlm?.let {
+            telemetryCallbacks.forEach { callback ->
+                callback(tlm, null)
+            }
+        }
+    }
+
+    private val mEnergyLevelListener = OnCarDataAvailableListener<EnergyLevel> { carEnergyLevel ->
+        if (carEnergyLevel.batteryPercent.status == CarValue.STATUS_SUCCESS) {
+            carEnergyLevel.batteryPercent.value?.let {
+                telemetryHolder.updateBatteryLevel(it)
+            }
+        }
+
+        if (carEnergyLevel.fuelPercent.status == CarValue.STATUS_SUCCESS) {
+            carEnergyLevel.fuelPercent.value?.let {
+                telemetryHolder.updateFuelLevel(it)
+            }
+        }
+
+        if (carEnergyLevel.rangeRemainingMeters.status == CarValue.STATUS_SUCCESS) {
+            carEnergyLevel.rangeRemainingMeters.value?.let {
+                telemetryHolder.updateRange(it.div(1000f)) //m->km
+            }
+        }
+    }
+
+    private val mSpeedListener = OnCarDataAvailableListener<Speed> { carSpeed ->
+        if (carSpeed.displaySpeedMetersPerSecond.status == CarValue.STATUS_SUCCESS) {
+            telemetryHolder.updateSpeed(carSpeed.displaySpeedMetersPerSecond.value?.times(3.6f)) //m/s->km/h
+        }
+    }
+
+    private val mMileageListener = OnCarDataAvailableListener<Mileage> { carMileage ->
+        if (carMileage.odometerMeters.status == CarValue.STATUS_SUCCESS) {
+            // although this property is called Meters, it is actually km, see https://android-review.googlesource.com/c/platform/frameworks/support/+/3490009
+            // will be fixed properly with 1.8.0
+            telemetryHolder.updateOdometer(carMileage.odometerMeters.value)
+        }
+    }
+
+    private val emitter = object : Runnable {
+        override fun run() {
+            val tlm = telemetryHolder.toTelemetry()
+
+            if (tlm != null) {
+                telemetryCallbacks.forEach { callback ->
+                    callback(tlm, null)
+                }
+            }
+
+            handler.postDelayed(this, BuildConfig.TELEMETRY_UPDATE_INTERVAL)
+        }
+    }
+
+    fun addListener(callback: (Telemetry?, String?) -> Unit): () -> Unit {
+        telemetryCallbacks.add(callback)
+
+
+        // start is called every time a new listener is registered, so the single shot values are still requested and returned immediately
+        try {
+            startTelemetryObserver()
+        } catch (err: Exception) {
+            callback(null, err.message)
+        }
+
+
+        return {
+            telemetryCallbacks.remove(callback)
+            if (telemetryCallbacks.isEmpty()) {
+                stopTelemetryObserver()
+            }
+        }
+    }
+
+
+    fun startTelemetryObserver(
+    ) {
+        val carContext =
+            AndroidAutoSession.Companion.getCarContext(AndroidAutoSession.Companion.ROOT_SESSION)
+                ?: throw IllegalArgumentException(
+                    "Car context not available, failed to start telemetry"
+                )
+
+
+        AndroidAutoTelemetryObserver.carContext = carContext
+        if (carContext.carAppApiLevel < CarAppApiLevels.LEVEL_3) {
+            throw UnsupportedOperationException("Telemetry not supported for this API level ${carContext.carAppApiLevel}")
+        }
+
+        val carHardwareExecutor = ContextCompat.getMainExecutor(carContext)
+
+        val carHardwareManager = carContext.getCarService(
+            CarHardwareManager::class.java
+        )
+        val carInfo = carHardwareManager.carInfo
+
+        // Request any single shot values.
+        try {
+            carInfo.fetchModel(carHardwareExecutor, mModelListener)
+        } catch (_: SecurityException) {
+        } catch (_: NullPointerException) {
+        }
+
+        if (isRunning) {
+            // we stop here to not re-register multiple listeners, only the single shot values can be requested multiple times by registering another tlm listener on RN side
+            Log.d(
+                AndroidAutoTelemetryObserver.javaClass.name,
+                "Telemetry observer is already running"
+            )
+            return
+        }
+
+        try {
+            carInfo.addEnergyLevelListener(carHardwareExecutor, mEnergyLevelListener)
+        } catch (_: SecurityException) {
+        } catch (_: NullPointerException) {
+        }
+
+        try {
+            carInfo.addSpeedListener(carHardwareExecutor, mSpeedListener)
+        } catch (_: SecurityException) {
+        } catch (_: NullPointerException) {
+        }
+
+        try {
+            carInfo.addMileageListener(carHardwareExecutor, mMileageListener)
+        } catch (_: SecurityException) {
+        } catch (_: NullPointerException) {
+        }
+
+        handler.post(emitter)
+
+        isRunning = true
+
+        Log.d(AndroidAutoTelemetryObserver.javaClass.name, "Telemetry observer started")
+    }
+
+    fun stopTelemetryObserver() {
+        if (!isRunning) {
+            return
+        }
+
+        isRunning = false
+
+        carContext?.let {
+            val carHardwareManager = it.getCarService(
+                CarHardwareManager::class.java
+            )
+            val carInfo = carHardwareManager.carInfo
+
+            try {
+                carInfo.removeEnergyLevelListener(mEnergyLevelListener)
+            } catch (_: SecurityException) {
+            }
+
+            try {
+                carInfo.removeSpeedListener(mSpeedListener)
+            } catch (_: SecurityException) {
+            }
+
+            try {
+                carInfo.removeMileageListener(mMileageListener)
+            } catch (_: SecurityException) {
+            }
+        }
+
+        handler.removeCallbacks(emitter)
+    }
+}

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

@@ -0,0 +1,36 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import android.content.Intent
+import android.os.Binder
+import android.os.IBinder
+import com.facebook.react.HeadlessJsTaskService
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.jstasks.HeadlessJsTaskConfig
+
+class HeadlessTaskService : HeadlessJsTaskService() {
+    // we use a bound service so it will never be killed when Android Auto is active
+    inner class LocalBinder : Binder() {
+        fun getService() = this@HeadlessTaskService
+    }
+
+    private val mBinder = LocalBinder()
+
+    override fun getTaskConfig(intent: Intent?): HeadlessJsTaskConfig {
+        val data = intent?.extras?.let {
+            Arguments.fromBundle(it)
+        } ?: Arguments.createMap()
+
+        return HeadlessJsTaskConfig(
+            taskKey = "AndroidAutoHeadlessJsTask", data = data, isAllowedInForeground = true
+        )
+    }
+
+    override fun onBind(intent: Intent): IBinder? {
+        // Start the headless task when bound
+        UiThreadUtil.runOnUiThread {
+            startTask(getTaskConfig(intent))
+        }
+        return mBinder
+    }
+}