@iternio/react-native-auto-play 0.2.0-alpha.2 → 0.2.0-alpha.3

package/android/src/auto/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAndroidAutomotive.kt

@@ -0,0 +1,25 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+class InvalidPlatformException(message: String) : Exception(message)
+
+class HybridAndroidAutomotive : HybridAndroidAutomotiveSpec() {
+    override fun registerCarUxRestrictionsListener(callback: (restrictions: ActiveCarUxRestrictions) -> Unit): () -> Unit {
+        throw InvalidPlatformException("registerCarUxRestrictionsListener is supported on Android Automotive only!")
+    }
+
+    override fun getCarUxRestrictions(): ActiveCarUxRestrictions {
+        throw InvalidPlatformException("getCarUxRestrictions is supported on Android Automotive only!")
+    }
+
+    override fun registerAppFocusListener(callback: (state: AppFocusState) -> Unit): () -> Unit {
+        throw InvalidPlatformException("registerAppFocusListener is supported on Android Automotive only!")
+    }
+
+    override fun getAppFocusState(): AppFocusState {
+        throw InvalidPlatformException("getAppFocusState is supported on Android Automotive only!")
+    }
+
+    override fun requestAppFocus(): () -> Unit {
+        throw InvalidPlatformException("requestAppFocus is supported on Android Automotive only!")
+    }
+}

package/android/src/automotive/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/AndroidTelemetryObserver.kt

@@ -7,6 +7,7 @@ import android.car.VehiclePropertyIds
 import android.car.hardware.CarPropertyValue
 import android.car.hardware.property.CarPropertyManager
 import android.util.Log
+import com.margelo.nitro.NitroModules
 import kotlin.math.floor
 
 private val REQUIRED_VEHICLE_PROPERTY_IDS = listOf(
@@ -61,7 +62,18 @@ object AndroidTelemetryObserver : TelemetryObserver() {
                                     selectedGear = NumericTelemetryItem(
                                         timestamp = floor(System.currentTimeMillis() / 1000.0),
                                         value = selectedGear.toDouble()
-                                    )
+                                    ),
+                                    vehicle = null,
+                                    batteryLevel = null,
+                                    range = null,
+                                    speed = null,
+                                    odometer = null,
+                                    fuelLevel = null,
+                                    parkingBrakeOn = null,
+                                    evChargePortConnected = null,
+                                    envOutsideTemperature = null,
+                                    evBatteryInstantaneousChargeRate = null,
+                                    soe = null
                                 )
                             )
                         }
@@ -82,7 +94,18 @@ object AndroidTelemetryObserver : TelemetryObserver() {
                                     selectedGear = NumericTelemetryItem(
                                         timestamp = floor(System.currentTimeMillis() / 1000.0),
                                         value = selectedGear.toDouble()
-                                    )
+                                    ),
+                                    vehicle = null,
+                                    batteryLevel = null,
+                                    range = null,
+                                    speed = null,
+                                    odometer = null,
+                                    fuelLevel = null,
+                                    parkingBrakeOn = null,
+                                    evChargePortConnected = null,
+                                    envOutsideTemperature = null,
+                                    evBatteryInstantaneousChargeRate = null,
+                                    soe = null
                                 )
                             )
                         }
@@ -101,14 +124,8 @@ object AndroidTelemetryObserver : TelemetryObserver() {
 
                         VehiclePropertyIds.EV_BATTERY_LEVEL -> {
                             val capacity = batteryCapacity ?: return
-                            if (capacity <= 0f) {
-                                throw Exception("got invalid battery capacity $capacity")
-                            }
-                            val soc = getValue<Float>(p0) / capacity * 100
-                            if (!soc.isFinite() || floor(soc) < 0 || floor(soc) > 100) {
-                                throw Exception("got invalid soc $soc, expecting value from 0 to 100 EV_BATTERY_LEVEL: ${p0.value}, evBatteryCapacity: $capacity")
-                            }
-                            telemetryHolder.updateBatteryLevel(soc)
+                            val level: Float = getValue(p0)
+                            telemetryHolder.updateBatteryLevel(level, capacity)
                         }
 
                         VehiclePropertyIds.PERF_VEHICLE_SPEED -> telemetryHolder.updateSpeed(
@@ -140,14 +157,10 @@ object AndroidTelemetryObserver : TelemetryObserver() {
             return false
         }
 
-        val carContext = AndroidAutoSession.getRootContext() ?: throw IllegalArgumentException(
-            "Car context not available, failed to start telemetry"
-        )
-
         // create new instance so we can access all props after permissions were granted
         mCar?.disconnect()
 
-        val car = Car.createCar(carContext)
+        val car = Car.createCar(NitroModules.applicationContext)
         mCar = car
 
         fetchStaticData(car)

package/android/src/automotive/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAndroidAutomotive.kt

@@ -0,0 +1,190 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import android.car.Car
+import android.car.CarAppFocusManager
+import android.car.CarAppFocusManager.OnAppFocusChangedListener
+import android.car.CarAppFocusManager.OnAppFocusOwnershipCallback
+import android.car.drivingstate.CarUxRestrictionsManager
+import com.margelo.nitro.NitroModules
+import java.util.concurrent.CopyOnWriteArrayList
+
+class HybridAndroidAutomotive : HybridAndroidAutomotiveSpec() {
+    private lateinit var car: Car
+
+    private fun getCar(): Car {
+        if (!this::car.isInitialized) {
+            car = Car.createCar(NitroModules.applicationContext)
+        }
+        return car
+    }
+
+    private val onAppFocusOwnershipCallback = object : OnAppFocusOwnershipCallback {
+        override fun onAppFocusOwnershipGranted(appType: Int) {
+            isFocusOwned = true
+            notifyAppFocusListeners()
+        }
+
+        override fun onAppFocusOwnershipLost(appType: Int) {
+            isFocusOwned = false
+            notifyAppFocusListeners()
+        }
+    }
+
+    private val onAppFocusChangedListener = OnAppFocusChangedListener { appType, active ->
+        isFocusActive = active
+
+        val carAppFocusManager =
+            getCar().getCarManager(Car.APP_FOCUS_SERVICE) as CarAppFocusManager
+        // docs say we should not get an event when we receive our own app focus
+        // but we still do get it. so we do a check here again if we own it or not
+        isFocusOwned = carAppFocusManager.isOwningFocus(
+            onAppFocusOwnershipCallback, appType
+        )
+
+        notifyAppFocusListeners()
+    }
+
+    override fun registerCarUxRestrictionsListener(callback: (restrictions: ActiveCarUxRestrictions) -> Unit): () -> Unit {
+        if (uxRestrictionListeners.isEmpty()) {
+            val uxRestrictionManager =
+                getCar().getCarManager(Car.CAR_UX_RESTRICTION_SERVICE) as CarUxRestrictionsManager
+
+            uxRestrictionManager.registerListener {
+                notifyUxRestrictionListeners(it.toActiveCarUxRestrictions())
+            }
+        }
+
+        uxRestrictionListeners.add(callback)
+
+        return {
+            uxRestrictionListeners.remove(callback)
+
+            if (uxRestrictionListeners.isEmpty()) {
+                val uxRestrictionManager =
+                    getCar().getCarManager(Car.CAR_UX_RESTRICTION_SERVICE) as CarUxRestrictionsManager
+
+                uxRestrictionManager.unregisterListener()
+            }
+        }
+    }
+
+    override fun getCarUxRestrictions(): ActiveCarUxRestrictions {
+        val uxRestrictionManager =
+            getCar().getCarManager(Car.CAR_UX_RESTRICTION_SERVICE) as CarUxRestrictionsManager
+
+        return uxRestrictionManager.currentCarUxRestrictions.toActiveCarUxRestrictions()
+    }
+
+    override fun registerAppFocusListener(callback: (state: AppFocusState) -> Unit): () -> Unit {
+        if (appFocusListeners.isEmpty()) {
+            val carAppFocusManager =
+                getCar().getCarManager(Car.APP_FOCUS_SERVICE) as CarAppFocusManager
+
+            carAppFocusManager.addFocusListener(
+                onAppFocusChangedListener, CarAppFocusManager.APP_FOCUS_TYPE_NAVIGATION
+            )
+        }
+
+        appFocusListeners.add(callback)
+
+        return {
+            appFocusListeners.remove(callback)
+
+            if (appFocusListeners.isEmpty()) {
+                val carAppFocusManager =
+                    getCar().getCarManager(Car.APP_FOCUS_SERVICE) as CarAppFocusManager
+
+                carAppFocusManager.removeFocusListener(
+                    onAppFocusChangedListener, CarAppFocusManager.APP_FOCUS_TYPE_NAVIGATION
+                )
+            }
+        }
+    }
+
+    override fun getAppFocusState(): AppFocusState {
+        val carAppFocusManager = getCar().getCarManager(Car.APP_FOCUS_SERVICE) as CarAppFocusManager
+        isFocusOwned = carAppFocusManager.isOwningFocus(
+            onAppFocusOwnershipCallback, CarAppFocusManager.APP_FOCUS_TYPE_NAVIGATION
+        )
+
+        return AppFocusState(isFocusOwned, isFocusActive)
+    }
+
+    override fun requestAppFocus(): () -> Unit {
+        val carAppFocusManager = getCar().getCarManager(Car.APP_FOCUS_SERVICE) as CarAppFocusManager
+        carAppFocusManager.requestAppFocus(
+            CarAppFocusManager.APP_FOCUS_TYPE_NAVIGATION, onAppFocusOwnershipCallback
+        )
+
+        return {
+            carAppFocusManager.abandonAppFocus(
+                onAppFocusOwnershipCallback, CarAppFocusManager.APP_FOCUS_TYPE_NAVIGATION
+            )
+        }
+    }
+
+    companion object {
+        private var isFocusOwned: Boolean? = null
+        private var isFocusActive: Boolean? = null
+
+        private val uxRestrictionListeners =
+            CopyOnWriteArrayList<(ActiveCarUxRestrictions) -> Unit>()
+        private val appFocusListeners = CopyOnWriteArrayList<(AppFocusState) -> Unit>()
+
+        private fun notifyAppFocusListeners() {
+            val state = AppFocusState(isFocusOwned, isFocusActive)
+
+            appFocusListeners.forEach {
+                it(state)
+            }
+        }
+
+        private fun notifyUxRestrictionListeners(restrictions: ActiveCarUxRestrictions) {
+            uxRestrictionListeners.forEach {
+                it(restrictions)
+            }
+        }
+    }
+
+    fun android.car.drivingstate.CarUxRestrictions.toActiveCarUxRestrictions(): ActiveCarUxRestrictions {
+        val restrictions = mutableListOf<CarUxRestrictions>()
+
+        if ((activeRestrictions and android.car.drivingstate.CarUxRestrictions.UX_RESTRICTIONS_NO_DIALPAD) != 0) {
+            restrictions.add(CarUxRestrictions.UX_RESTRICTIONS_NO_DIALPAD)
+        }
+        if ((activeRestrictions and android.car.drivingstate.CarUxRestrictions.UX_RESTRICTIONS_NO_FILTERING) != 0) {
+            restrictions.add(CarUxRestrictions.UX_RESTRICTIONS_NO_FILTERING)
+        }
+        if ((activeRestrictions and android.car.drivingstate.CarUxRestrictions.UX_RESTRICTIONS_LIMIT_STRING_LENGTH) != 0) {
+            restrictions.add(CarUxRestrictions.UX_RESTRICTIONS_LIMIT_STRING_LENGTH)
+        }
+        if ((activeRestrictions and android.car.drivingstate.CarUxRestrictions.UX_RESTRICTIONS_NO_KEYBOARD) != 0) {
+            restrictions.add(CarUxRestrictions.UX_RESTRICTIONS_NO_KEYBOARD)
+        }
+        if ((activeRestrictions and android.car.drivingstate.CarUxRestrictions.UX_RESTRICTIONS_NO_VIDEO) != 0) {
+            restrictions.add(CarUxRestrictions.UX_RESTRICTIONS_NO_VIDEO)
+        }
+        if ((activeRestrictions and android.car.drivingstate.CarUxRestrictions.UX_RESTRICTIONS_LIMIT_CONTENT) != 0) {
+            restrictions.add(CarUxRestrictions.UX_RESTRICTIONS_LIMIT_CONTENT)
+        }
+        if ((activeRestrictions and android.car.drivingstate.CarUxRestrictions.UX_RESTRICTIONS_NO_SETUP) != 0) {
+            restrictions.add(CarUxRestrictions.UX_RESTRICTIONS_NO_SETUP)
+        }
+        if ((activeRestrictions and android.car.drivingstate.CarUxRestrictions.UX_RESTRICTIONS_NO_TEXT_MESSAGE) != 0) {
+            restrictions.add(CarUxRestrictions.UX_RESTRICTIONS_NO_TEXT_MESSAGE)
+        }
+        if ((activeRestrictions and android.car.drivingstate.CarUxRestrictions.UX_RESTRICTIONS_NO_VOICE_TRANSCRIPTION) != 0) {
+            restrictions.add(CarUxRestrictions.UX_RESTRICTIONS_NO_VOICE_TRANSCRIPTION)
+        }
+        if (activeRestrictions == android.car.drivingstate.CarUxRestrictions.UX_RESTRICTIONS_FULLY_RESTRICTED) {
+            restrictions.add(CarUxRestrictions.UX_RESTRICTIONS_FULLY_RESTRICTED)
+        }
+
+        return ActiveCarUxRestrictions(
+            maxContentDepth = maxContentDepth.toDouble(),
+            maxCumulativeContentItems = maxCumulativeContentItems.toDouble(),
+            maxRestrictedStringLength = maxRestrictedStringLength.toDouble(),
+            activeRestrictions = restrictions.toTypedArray()
+        )
+    }
+}

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

@@ -1,5 +1,7 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay
 
+import kotlin.math.floor
+
 class AndroidAutoTelemetryHolder {
     private var isDirty = false
     private val lock = Any()
@@ -34,6 +36,9 @@ class AndroidAutoTelemetryHolder {
     private var parkingBrakeOn: Boolean? = null
     private var parkingBrakeOnTimestamp: Int? = null
 
+    private var soe: Float? = null
+    private var soeTimestamp: Int? = null
+
     private var name: String? = null
     private var manufacturer: String? = null
     private var year: Int? = null
@@ -146,6 +151,30 @@ class AndroidAutoTelemetryHolder {
         isDirty = true
     }
 
+    fun updateBatteryLevel(levelWh: Float, capacityWh: Float) = synchronized(lock) {
+        if (soe == levelWh) {
+            return
+        }
+
+        if (capacityWh <= 0f) {
+            throw Exception("got invalid battery capacity $capacityWh")
+        }
+
+        val soc = levelWh / capacityWh * 100
+        if (!soc.isFinite() || floor(soc) < 0 || floor(soc) > 100) {
+            throw Exception("got invalid soc $soc, expecting value from 0 to 100 EV_BATTERY_LEVEL: ${levelWh}, evBatteryCapacity: $capacityWh")
+        }
+
+        soe = levelWh
+        batteryLevel = soc
+
+        val timestamp = (System.currentTimeMillis() / 1000L).toInt()
+        soeTimestamp = timestamp
+        batteryLevelTimestamp = timestamp
+
+        isDirty = true
+    }
+
     fun toTelemetry(): Telemetry? {
         synchronized(lock) {
             if (!isDirty) {
@@ -173,6 +202,9 @@ class AndroidAutoTelemetryHolder {
                 evBatteryInstantaneousChargeRate = createNumericTelemetryItem(
                     evBatteryInstantaneousChargeRate, evBatteryInstantaneousChargeRateTimeStamp
                 ),
+                soe = createNumericTelemetryItem(
+                    soe, soeTimestamp
+                ),
                 vehicle = VehicleTelemetryItem(
                     name = createStringTelemetryItem(name),
                     manufacturer = createStringTelemetryItem(manufacturer),

package/ios/hybrid/HybridAutoPlay.swift

@@ -278,6 +278,7 @@ class HybridAutoPlay: HybridAutoPlaySpec {
                     }
 
                     template.barButtons = headerActions
+                    setBarButtons(template: template.getTemplate(), barButtons: headerActions)
                 }
             }
         }

package/ios/hybrid/HybridMapTemplate.swift

@@ -27,7 +27,7 @@ class HybridMapTemplate: HybridMapTemplateSpec {
             try await MainActor.run {
                 try RootModule.withAutoPlayTemplate(templateId: templateId) {
                     (template: MapTemplate) in
-                    template.config.mapButtons = buttons
+                    template.mapButtons = buttons
                     template.invalidate()
                 }
             }

package/ios/templates/AutoPlayTemplate.swift

@@ -34,8 +34,8 @@ class AutoPlayTemplate: NSObject {
     func onPopped() {}
 }
 
-protocol AutoPlayHeaderProviding {
-    @MainActor var barButtons: [NitroAction]? { get set }
+class AutoPlayHeaderProviding: AutoPlayTemplate {
+    var barButtons: [NitroAction]?
 }
 
 @MainActor

package/ios/templates/GridTemplate.swift

@@ -7,19 +7,11 @@
 
 import CarPlay
 
-class GridTemplate: AutoPlayTemplate, AutoPlayHeaderProviding {
+class GridTemplate: AutoPlayHeaderProviding {
     let template: CPGridTemplate
     var config: GridTemplateConfig
 
-    var barButtons: [NitroAction]? {
-        get {
-            return config.headerActions
-        }
-        set {
-            config.headerActions = newValue
-            setBarButtons(template: template, barButtons: newValue)
-        }
-    }
+    var buttons: [NitroGridButton]
 
     override var autoDismissMs: Double? {
         return config.autoDismissMs
@@ -31,12 +23,18 @@ class GridTemplate: AutoPlayTemplate, AutoPlayHeaderProviding {
 
     init(config: GridTemplateConfig) {
         self.config = config
-
+        buttons = config.buttons
+        
         template = CPGridTemplate(
             title: Parser.parseText(text: config.title),
-            gridButtons: GridTemplate.parseButtons(buttons: config.buttons),
+            gridButtons: GridTemplate.parseButtons(buttons: buttons),
             id: config.id
         )
+                
+        super.init()
+        
+        barButtons = config.headerActions
+        
     }
 
     static func parseButtons(buttons: [NitroGridButton]) -> [CPGridButton] {
@@ -83,9 +81,9 @@ class GridTemplate: AutoPlayTemplate, AutoPlayHeaderProviding {
 
     @MainActor
     override func _invalidate() {
-        setBarButtons(template: template, barButtons: config.headerActions)
+        setBarButtons(template: template, barButtons: barButtons)
 
-        let buttons = GridTemplate.parseButtons(buttons: config.buttons)
+        let buttons = GridTemplate.parseButtons(buttons: buttons)
         template.updateGridButtons(buttons)
     }
 
@@ -111,7 +109,7 @@ class GridTemplate: AutoPlayTemplate, AutoPlayHeaderProviding {
 
     @MainActor
     func updateButtons(buttons: [NitroGridButton]) {
-        config.buttons = buttons
+        self.buttons = buttons
         invalidate()
     }
 }

package/ios/templates/InformationTemplate.swift

@@ -7,19 +7,11 @@
 
 import CarPlay
 
-class InformationTemplate: AutoPlayTemplate, AutoPlayHeaderProviding {
+class InformationTemplate: AutoPlayHeaderProviding {
     let template: CPInformationTemplate
     var config: InformationTemplateConfig
 
-    var barButtons: [NitroAction]? {
-        get {
-            return config.headerActions
-        }
-        set {
-            config.headerActions = newValue
-            setBarButtons(template: template, barButtons: newValue)
-        }
-    }
+    var section: NitroSection
 
     override var autoDismissMs: Double? {
         return config.autoDismissMs
@@ -31,20 +23,26 @@ class InformationTemplate: AutoPlayTemplate, AutoPlayHeaderProviding {
 
     init(config: InformationTemplateConfig) {
         self.config = config
+        
+        section = config.section
 
         template = CPInformationTemplate(
             title: Parser.parseText(text: config.title)!,
             layout: .leading,
-            items: Parser.parseInformationItems(section: config.section),
+            items: Parser.parseInformationItems(section: section),
             actions: Parser.parseInformationActions(actions: config.actions),
             id: config.id
         )
+        
+        super.init();
+        
+        barButtons = config.headerActions
     }
 
     @MainActor
     override func _invalidate() {
         setBarButtons(template: template, barButtons: barButtons)
-        template.items = Parser.parseInformationItems(section: config.section)
+        template.items = Parser.parseInformationItems(section: section)
     }
 
     override func onWillAppear(animated: Bool) {
@@ -69,7 +67,7 @@ class InformationTemplate: AutoPlayTemplate, AutoPlayHeaderProviding {
 
     @MainActor
     func updateSection(section: NitroSection) {
-        config.section = section
+        self.section = section
         invalidate()
     }
 }

package/ios/templates/ListTemplate.swift

@@ -7,19 +7,11 @@
 
 import CarPlay
 
-class ListTemplate: AutoPlayTemplate, AutoPlayHeaderProviding {
+class ListTemplate: AutoPlayHeaderProviding {
     let template: CPListTemplate
     var config: ListTemplateConfig
 
-    var barButtons: [NitroAction]? {
-        get {
-            return config.headerActions
-        }
-        set {
-            config.headerActions = newValue
-            setBarButtons(template: template, barButtons: newValue)
-        }
-    }
+    var sections: [NitroSection]?
 
     override var autoDismissMs: Double? {
         return config.autoDismissMs
@@ -31,6 +23,8 @@ class ListTemplate: AutoPlayTemplate, AutoPlayHeaderProviding {
 
     init(config: ListTemplateConfig) {
         self.config = config
+        
+        sections = config.sections
 
         template = CPListTemplate(
             title: Parser.parseText(text: config.title),
@@ -38,6 +32,10 @@ class ListTemplate: AutoPlayTemplate, AutoPlayHeaderProviding {
             assistantCellConfiguration: nil,
             id: config.id
         )
+        
+        super.init()
+        
+        barButtons = config.headerActions
     }
 
     @MainActor
@@ -46,7 +44,7 @@ class ListTemplate: AutoPlayTemplate, AutoPlayHeaderProviding {
 
         template.updateSections(
             Parser.parseSections(
-                sections: config.sections,
+                sections: sections,
                 updateSection: self.updateSection(section:sectionIndex:),
                 traitCollection: SceneStore.getRootTraitCollection()
             )
@@ -75,13 +73,13 @@ class ListTemplate: AutoPlayTemplate, AutoPlayHeaderProviding {
 
     @MainActor
     private func updateSection(section: NitroSection, sectionIndex: Int) {
-        config.sections?[sectionIndex] = section
+        self.sections?[sectionIndex] = section
         invalidate()
     }
 
     @MainActor
     func updateSections(sections: [NitroSection]?) {
-        config.sections = sections
+        self.sections = sections
         invalidate()
     }
 }