@neoskola/auto-play 0.1.0

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

@@ -0,0 +1,203 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.ComponentName
+import android.content.Intent
+import android.content.ServiceConnection
+import android.content.pm.ApplicationInfo
+import android.content.pm.PackageManager
+import android.graphics.Bitmap
+import android.os.IBinder
+import android.util.Log
+import androidx.car.app.CarAppService
+import androidx.car.app.Session
+import androidx.car.app.SessionInfo
+import androidx.car.app.notification.CarAppExtender
+import androidx.car.app.validation.HostValidator
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+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.AppInfo
+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 lateinit var notificationManager: NotificationManager
+
+    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()
+        instance = this
+
+        CoroutineScope(Dispatchers.Main).launch {
+            reactContext = ReactContextResolver.getReactContext(application as ReactApplication)
+            reactContext.addLifecycleEventListener(reactLifecycleObserver)
+        }
+
+        notificationManager = getSystemService(NotificationManager::class.java)
+        val appLabel = AppInfo.getApplicationLabel(this)
+
+        getSystemService(NotificationManager::class.java).createNotificationChannel(
+            NotificationChannel(
+                CHANNEL_ID, appLabel, NotificationManager.IMPORTANCE_DEFAULT
+            )
+        )
+    }
+
+    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()
+        instance = null
+
+        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
+        }
+    }
+
+    private fun createNotification(
+        title: String?, text: String?, largeIcon: Bitmap?
+    ): Notification {
+        return NotificationCompat.Builder(this, CHANNEL_ID)
+            .setSmallIcon(R.drawable.ic_notification).setOngoing(true)
+            .setCategory(NotificationCompat.CATEGORY_NAVIGATION).setOnlyAlertOnce(true)
+            .setWhen(System.currentTimeMillis()).setPriority(NotificationManager.IMPORTANCE_LOW)
+            .extend(
+                CarAppExtender.Builder().setImportance(NotificationManagerCompat.IMPORTANCE_LOW)
+                    .build()
+            ).apply {
+                title?.let {
+                    setContentTitle(it)
+                }
+                text?.let {
+                    setContentText(it)
+                    setTicker(it)
+                }
+                largeIcon?.let {
+                    setLargeIcon(it)
+                }
+            }.build()
+    }
+
+    fun startForeground() {
+        val isLocationPermissionGranted =
+            checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED || checkSelfPermission(
+                Manifest.permission.ACCESS_FINE_LOCATION
+            ) == PackageManager.PERMISSION_GRANTED
+
+        if (!isLocationPermissionGranted) {
+            Log.w(TAG, "location permission not granted, unable to start foreground service!")
+            return
+        }
+
+        try {
+            startForeground(
+                NOTIFICATION_ID, createNotification(null, null, null)
+            )
+        } catch (e: SecurityException) {
+            Log.e(TAG, "failed to start foreground service", e)
+        }
+    }
+
+    fun notify(title: String?, text: String?, icon: Bitmap?) {
+        val notification = createNotification(title, text, icon)
+        notificationManager.notify(NOTIFICATION_ID, notification)
+    }
+
+    companion object {
+        const val TAG = "AndroidAutoService"
+        private const val NOTIFICATION_ID = 1
+        private const val CHANNEL_ID = "AutoPlayServiceChannel"
+
+        var instance: AndroidAutoService? = null
+            private set
+    }
+}

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

@@ -0,0 +1,273 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import android.content.Intent
+import android.content.res.Configuration
+import android.util.Log
+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),
+                null,
+                null
+            )
+
+            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()
+    }
+
+    override fun onNewIntent(intent: Intent) {
+        val action = intent.action ?: return
+
+        if (action == CarContext.ACTION_NAVIGATE) {
+            intent.data?.schemeSpecificPart?.let { schemeSpecificPart ->
+                try {
+                    // Parse the geo URI format: lat,lon?q=query&mode=x&intent=y
+                    val queryIndex = schemeSpecificPart.indexOf("?q=")
+
+                    val location = if (queryIndex > 0) {
+                        val coordinatesPart = schemeSpecificPart.substring(0, queryIndex)
+                        parseCoordinates(coordinatesPart)
+                    } else {
+                        null
+                    }
+
+                    val query = if (queryIndex >= 0) {
+                        val queryPart = schemeSpecificPart.substring(queryIndex + 3) // Skip "?q="
+                        val additionalParamsIndex = queryPart.indexOf('&')
+
+                        if (additionalParamsIndex >= 0) {
+                            val rawQuery = queryPart.substring(0, additionalParamsIndex)
+                            java.net.URLDecoder.decode(rawQuery, "UTF-8")
+                        } else {
+                            java.net.URLDecoder.decode(queryPart, "UTF-8")
+                        }
+                    } else {
+                        java.net.URLDecoder.decode(schemeSpecificPart, "UTF-8")
+                    }
+
+                    HybridAutoPlay.emitVoiceInput(location, query)
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to parse navigation intent: ${e.message}")
+                }
+            }
+        }
+    }
+
+    /**
+     * Parses coordinates from a string in format "lat,lon".
+     * Returns null for invalid formats or 0,0 coordinates (which indicate "use geocoding").
+     */
+    private fun parseCoordinates(coordinatesPart: String): Location? {
+        val parts = coordinatesPart.split(",")
+        if (parts.size != 2) return null
+
+        val lat = parts[0].toDoubleOrNull() ?: return null
+        val lon = parts[1].toDoubleOrNull() ?: return null
+
+        // Treat 0,0 as "no coordinates" - it means use geocoding for the query
+        if (lat == 0.0 && lon == 0.0) {
+            return null
+        }
+
+        return Location(lat, lon)
+    }
+
+    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[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)
+}