@iternio/react-native-auto-play 0.0.9 → 0.0.10

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

@@ -72,12 +72,14 @@ class HybridAutoPlay : HybridAutoPlaySpec() {
 
     override fun setTemplateHeaderActions(
         templateId: String, headerActions: Array<NitroAction>?
-    ) {
-        val template =
-            AndroidAutoTemplate.getTemplate(templateId) ?: throw IllegalArgumentException(
-                "setTemplateHeaderActions failed, template $templateId not found"
-            )
-        template.setTemplateHeaderActions(headerActions)
+    ): Promise<Unit> {
+        return Promise.async {
+            val template =
+                AndroidAutoTemplate.getTemplate(templateId) ?: throw IllegalArgumentException(
+                    "setTemplateHeaderActions failed, template $templateId not found"
+                )
+            template.setTemplateHeaderActions(headerActions)
+        }
     }
 
     override fun setRootTemplate(templateId: String): Promise<Unit> {
@@ -105,9 +107,8 @@ class HybridAutoPlay : HybridAutoPlaySpec() {
             } else {
                 val screenManager = AndroidAutoScreen.getScreenManager()
                     ?: throw IllegalArgumentException("setRootTemplate failed, screenManager not found")
-                val carContext =
-                    AndroidAutoSession.getCarContext(AndroidAutoSession.ROOT_SESSION)
-                        ?: throw IllegalArgumentException("setRootTemplate failed, carContext for $templateId template not found")
+                val carContext = AndroidAutoSession.getCarContext(AndroidAutoSession.ROOT_SESSION)
+                    ?: throw IllegalArgumentException("setRootTemplate failed, carContext for $templateId template not found")
 
                 val result = ThreadUtil.postOnUiAndAwait {
                     screenManager.popToRoot()

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

@@ -1,5 +1,6 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay
 
+import com.margelo.nitro.core.Promise
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.AndroidAutoTemplate
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.GridTemplate
 
@@ -14,8 +15,10 @@ class HybridGridTemplate : HybridGridTemplateSpec() {
 
     override fun updateGridTemplateButtons(
         templateId: String, buttons: Array<NitroGridButton>
-    ) {
-        val template = AndroidAutoTemplate.getTemplate<GridTemplate>(templateId)
-        template.updateButtons(buttons)
+    ): Promise<Unit> {
+        return Promise.async {
+            val template = AndroidAutoTemplate.getTemplate<GridTemplate>(templateId)
+            template.updateButtons(buttons)
+        }
     }
 }

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

@@ -1,5 +1,6 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay
 
+import com.margelo.nitro.core.Promise
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.AndroidAutoTemplate
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.InformationTemplate
 
@@ -13,10 +14,11 @@ class HybridInformationTemplate : HybridInformationTemplateSpec() {
     }
 
     override fun updateInformationTemplateSections(
-        templateId: String,
-        section: NitroSection
-    ) {
-        val template = AndroidAutoTemplate.getTemplate<InformationTemplate>(templateId)
-        template.updateSection(section)
+        templateId: String, section: NitroSection
+    ): Promise<Unit> {
+        return Promise.async {
+            val template = AndroidAutoTemplate.getTemplate<InformationTemplate>(templateId)
+            template.updateSection(section)
+        }
     }
 }

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

@@ -1,5 +1,6 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay
 
+import com.margelo.nitro.core.Promise
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.AndroidAutoTemplate
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.ListTemplate
 
@@ -15,8 +16,10 @@ class HybridListTemplate : HybridListTemplateSpec() {
 
     override fun updateListTemplateSections(
         templateId: String, sections: Array<NitroSection>?
-    ) {
-        val template = AndroidAutoTemplate.getTemplate<ListTemplate>(templateId)
-        template.updateSections(sections)
+    ): Promise<Unit> {
+        return Promise.async {
+            val template = AndroidAutoTemplate.getTemplate<ListTemplate>(templateId)
+            template.updateSections(sections)
+        }
     }
 }

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

@@ -2,6 +2,7 @@ package com.margelo.nitro.swe.iternio.reactnativeautoplay
 
 import androidx.car.app.AppManager
 import com.facebook.react.bridge.UiThreadUtil
+import com.margelo.nitro.core.Promise
 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.template.RoutePreviewTemplate
@@ -120,9 +121,11 @@ class HybridMapTemplate : HybridMapTemplateSpec() {
 
     override fun setTemplateMapButtons(
         templateId: String, buttons: Array<NitroMapButton>?
-    ) {
-        val template = AndroidAutoTemplate.getTemplate<MapTemplate>(templateId)
-        template.setMapActions(buttons)
+    ): Promise<Unit> {
+        return Promise.async {
+            val template = AndroidAutoTemplate.getTemplate<MapTemplate>(templateId)
+            template.setMapActions(buttons)
+        }
     }
 
     override fun updateVisibleTravelEstimate(

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

@@ -1,5 +1,6 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay
 
+import com.margelo.nitro.core.Promise
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.AndroidAutoTemplate
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.SearchTemplate
 
@@ -13,8 +14,10 @@ class HybridSearchTemplate : HybridSearchTemplateSpec() {
         AndroidAutoTemplate.setTemplate(config.id, template)
     }
 
-    override fun updateSearchResults(templateId: String, results: NitroSection) {
-        val template = AndroidAutoTemplate.getTemplate<SearchTemplate>(templateId)
-        template.updateSearchResults(results)
+    override fun updateSearchResults(templateId: String, results: NitroSection): Promise<Unit> {
+        return Promise.async {
+            val template = AndroidAutoTemplate.getTemplate<SearchTemplate>(templateId)
+            template.updateSearchResults(results)
+        }
     }
 }

package/ios/hybrid/HybridAutoPlay.swift

@@ -110,17 +110,29 @@ class HybridAutoPlay: HybridAutoPlaySpec {
     // MARK: set/push/pop templates
     func setRootTemplate(templateId: String) throws -> Promise<Void> {
         return Promise.async {
-            try await RootModule.withSceneTemplateAndInterfaceController(
-                templateId: templateId
-            ) { template, scene, interfaceController in
-                if template is CPMapTemplate {
+            guard
+                let template = TemplateStore.getTemplate(
+                    templateId: templateId
+                )
+            else {
+                throw AutoPlayError.templateNotFound(templateId)
+            }
+
+            try await RootModule.withSceneAndInterfaceController {
+                scene,
+                interfaceController in
+                let carPlayTemplate = template.getTemplate()
+                
+                if carPlayTemplate is CPMapTemplate {
                     await MainActor.run {
                         scene.initRootView()
                     }
                 }
 
+                await template.invalidate()
+
                 let _ = try await interfaceController.setRootTemplate(
-                    template,
+                    carPlayTemplate,
                     animated: false
                 )
             }
@@ -131,27 +143,39 @@ class HybridAutoPlay: HybridAutoPlaySpec {
         -> NitroModules.Promise<Void>
     {
         return Promise.async {
-            return try await RootModule.withSceneTemplateAndInterfaceController(
-                templateId: templateId
-            ) { template, scene, interfaceController in
-                if template is CPAlertTemplate {
+            guard
+                let template = TemplateStore.getTemplate(
+                    templateId: templateId
+                )
+            else {
+                throw AutoPlayError.templateNotFound(templateId)
+            }
+
+            await template.invalidate()
+
+            return try await RootModule.withInterfaceController {
+                interfaceController in
+                
+                let carPlayTemplate = template.getTemplate()
+                
+                if carPlayTemplate is CPAlertTemplate {
                     let animated = try await
                         !interfaceController.dismissTemplate(
                             animated: false
                         )
 
                     let _ = try await interfaceController.presentTemplate(
-                        template,
+                        carPlayTemplate,
                         animated: animated
                     )
                 } else {
                     let _ = try await interfaceController.pushTemplate(
-                        template,
+                        carPlayTemplate,
                         animated: true
                     )
                 }
 
-                if let autoDismissMs = await scene.templateStore.getTemplate(
+                if let autoDismissMs = TemplateStore.getTemplate(
                     templateId: templateId
                 )?.autoDismissMs {
                     Task { @MainActor in
@@ -240,10 +264,18 @@ class HybridAutoPlay: HybridAutoPlaySpec {
     func setTemplateHeaderActions(
         templateId: String,
         headerActions: [NitroAction]?
-    ) throws {
-        try RootModule.withAutoPlayTemplate(templateId: templateId) {
-            (template: AutoPlayTemplate) in
-            if var template = template as? AutoPlayHeaderProviding {
+    ) throws -> Promise<Void> {
+        return Promise.async {
+            try await MainActor.run {
+                guard
+                    var template = TemplateStore.getTemplate(
+                        templateId: templateId
+                    ) as? AutoPlayHeaderProviding
+                else {
+                    throw AutoPlayError.invalidTemplateType(
+                        "\(templateId) does not support header actions"
+                    )
+                }
                 template.barButtons = headerActions
             }
         }

package/ios/hybrid/HybridGridTemplate.swift

@@ -5,24 +5,31 @@
 //  Created by Manuel Auer on 15.10.25.
 //
 
+import NitroModules
+
 class HybridGridTemplate: HybridGridTemplateSpec {
     func createGridTemplate(config: GridTemplateConfig) throws {
         let template = GridTemplate(config: config)
-        try RootModule.withScene { scene in
-            scene.templateStore.addTemplate(
-                template: template,
-                templateId: config.id
-            )
-        }
+
+        TemplateStore.addTemplate(
+            template: template,
+            templateId: config.id
+        )
     }
 
     func updateGridTemplateButtons(
         templateId: String,
         buttons: [NitroGridButton]
-    ) throws {
-        try RootModule.withAutoPlayTemplate(templateId: templateId) {
-            (template: GridTemplate) in
-            template.updateButtons(buttons: buttons)
+    ) throws -> Promise<Void> {
+        return Promise.async {
+            guard
+                let template = TemplateStore.getTemplate(templateId: templateId)
+                    as? GridTemplate
+            else {
+                throw AutoPlayError.templateNotFound(templateId)
+            }
+
+            await template.updateButtons(buttons: buttons)
         }
     }
 }

package/ios/hybrid/HybridInformationTemplate.swift

@@ -5,25 +5,33 @@
 //  Created by Samuel Brucksch on 05.11.25.
 //
 
+import NitroModules
+
 class HybridInformationTemplate: HybridInformationTemplateSpec {
 
     func createInformationTemplate(config: InformationTemplateConfig) throws {
         let template = InformationTemplate(config: config)
-        try RootModule.withScene { scene in
-            scene.templateStore.addTemplate(
-                template: template,
-                templateId: config.id
-            )
-        }
+        TemplateStore.addTemplate(
+            template: template,
+            templateId: config.id
+        )
     }
 
     func updateInformationTemplateSections(
         templateId: String,
         section: NitroSection
-    ) throws {
-        try RootModule.withAutoPlayTemplate(templateId: templateId) {
-            (template: InformationTemplate) in
-            template.updateSection(section: section)
+    ) throws -> Promise<Void> {
+        return Promise.async {
+            guard
+                let template = TemplateStore.getTemplate(templateId: templateId)
+                    as? InformationTemplate
+            else {
+                throw AutoPlayError.invalidTemplateType(
+                    "\(templateId) is not an InformationTemplate"
+                )
+            }
+
+            await template.updateSection(section: section)
         }
     }
 }

package/ios/hybrid/HybridListTemplate.swift

@@ -5,24 +5,32 @@
 //  Created by Manuel Auer on 15.10.25.
 //
 
+import NitroModules
+
 class HybridListTemplate: HybridListTemplateSpec {
     func createListTemplate(config: ListTemplateConfig) throws {
         let template = ListTemplate(config: config)
-        try RootModule.withScene { scene in
-            scene.templateStore.addTemplate(
-                template: template,
-                templateId: config.id
-            )
-        }
+        TemplateStore.addTemplate(
+            template: template,
+            templateId: config.id
+        )
     }
 
     func updateListTemplateSections(
         templateId: String,
         sections: [NitroSection]?
-    ) throws {
-        try RootModule.withAutoPlayTemplate(templateId: templateId) {
-            (template: ListTemplate) in
-            template.updateSections(sections: sections)
+    ) throws -> Promise<Void> {
+        return Promise.async {
+            guard
+                let template = TemplateStore.getTemplate(templateId: templateId)
+                    as? ListTemplate
+            else {
+                throw AutoPlayError.invalidTemplateType(
+                    "\(templateId) is not a ListTemplate"
+                )
+            }
+
+            await template.updateSections(sections: sections)
         }
     }
 }

package/ios/hybrid/HybridMapTemplate.swift

@@ -6,26 +6,34 @@
 //
 
 import CarPlay
+import NitroModules
 
 class HybridMapTemplate: HybridMapTemplateSpec {
     func createMapTemplate(config: MapTemplateConfig) throws {
         let template = MapTemplate(config: config)
-        try RootModule.withScene { scene in
-            scene.templateStore.addTemplate(
-                template: template,
-                templateId: config.id
-            )
-        }
+        TemplateStore.addTemplate(
+            template: template,
+            templateId: config.id
+        )
     }
 
     func setTemplateMapButtons(templateId: String, buttons: [NitroMapButton]?)
-        throws
+        throws -> Promise<Void>
     {
-        try RootModule.withAutoPlayTemplate(templateId: templateId) {
-            (template: MapTemplate) in
-
-            template.config.mapButtons = buttons
-            template.invalidate()
+        return Promise.async {
+            guard
+                let template = TemplateStore.getTemplate(templateId: templateId)
+                    as? MapTemplate
+            else {
+                throw AutoPlayError.invalidTemplateError(
+                    "\(templateId) is not a MapTemplate"
+                )
+            }
+            
+            await MainActor.run {
+                template.config.mapButtons = buttons
+                template.invalidate()
+            }
         }
     }
 

package/ios/hybrid/HybridMessageTemplate.swift

@@ -8,12 +8,9 @@
 class HybridMessageTemplate: HybridMessageTemplateSpec {
     func createMessageTemplate(config: MessageTemplateConfig) throws {
         let template = MessageTemplate(config: config)
-        
-        try RootModule.withScene { scene in
-            scene.templateStore.addTemplate(
-                template: template,
-                templateId: config.id
-            )
-        }
+        TemplateStore.addTemplate(
+            template: template,
+            templateId: config.id
+        )
     }
 }

package/ios/hybrid/HybridSearchTemplate.swift

@@ -5,21 +5,31 @@
 //  Created by Samuel Brucksch on 28.10.25.
 //
 
+import NitroModules
+
 class HybridSearchTemplate: HybridSearchTemplateSpec {
     func createSearchTemplate(config: SearchTemplateConfig) throws {
         let template = SearchTemplate(config: config)
-        try RootModule.withScene { scene in
-            scene.templateStore.addTemplate(
-                template: template,
-                templateId: config.id
-            )
-        }
+        TemplateStore.addTemplate(
+            template: template,
+            templateId: config.id
+        )
     }
 
-    func updateSearchResults(templateId: String, results: NitroSection) throws {
-        try RootModule.withAutoPlayTemplate(templateId: templateId) {
-            (template: SearchTemplate) in
-            template.updateSearchResults(results: results)
+    func updateSearchResults(templateId: String, results: NitroSection) throws
+        -> Promise<Void>
+    {
+        return Promise.async {
+            guard
+                let template = TemplateStore.getTemplate(templateId: templateId)
+                    as? SearchTemplate
+            else {
+                throw AutoPlayError.invalidTemplateType(
+                    "\(templateId) is not a SearchTemplate"
+                )
+            }
+
+            await template.updateSearchResults(results: results)
         }
     }
 }

package/ios/scenes/AutoPlayInterfaceController.swift

@@ -10,14 +10,11 @@ import CarPlay
 @MainActor
 class AutoPlayInterfaceController: NSObject, CPInterfaceControllerDelegate {
     let interfaceController: CPInterfaceController
-    let templateStore: TemplateStore
 
     init(
-        interfaceController: CPInterfaceController,
-        templateStore: TemplateStore
+        interfaceController: CPInterfaceController
     ) {
         self.interfaceController = interfaceController
-        self.templateStore = templateStore
 
         super.init()
 
@@ -47,7 +44,7 @@ class AutoPlayInterfaceController: NSObject, CPInterfaceControllerDelegate {
     var rootTemplateId: String? {
         return interfaceController.rootTemplate.id
     }
-    
+
     func pushTemplate(
         _ templateToPush: CPTemplate,
         animated: Bool
@@ -77,7 +74,7 @@ class AutoPlayInterfaceController: NSObject, CPInterfaceControllerDelegate {
             animated: animated
         )
 
-        self.templateStore.removeTemplate(templateId: templateId)
+        TemplateStore.removeTemplate(templateId: templateId)
 
         return templateId
     }
@@ -100,7 +97,7 @@ class AutoPlayInterfaceController: NSObject, CPInterfaceControllerDelegate {
             animated: animated
         )
 
-        self.templateStore.removeTemplates(templateIds: templateIds)
+        TemplateStore.removeTemplates(templateIds: templateIds)
 
         return templateIds
     }
@@ -157,7 +154,7 @@ class AutoPlayInterfaceController: NSObject, CPInterfaceControllerDelegate {
         try await interfaceController.dismissTemplate(
             animated: animated
         )
-        
+
         return true
     }
 
@@ -168,7 +165,7 @@ class AutoPlayInterfaceController: NSObject, CPInterfaceControllerDelegate {
     ) {
         let templateId = aTemplate.id
 
-        templateStore.getTemplate(templateId: templateId)?.onWillAppear(
+        TemplateStore.getTemplate(templateId: templateId)?.onWillAppear(
             animated: animated
         )
     }
@@ -181,10 +178,10 @@ class AutoPlayInterfaceController: NSObject, CPInterfaceControllerDelegate {
 
         if rootTemplateId == templateId {
             // this makes sure we purge outdated CPSearchTemplate since that one can be popped on with a CarPlay native button we can not intercept
-            templateStore.purge()
+            TemplateStore.purge()
         }
 
-        templateStore.getTemplate(templateId: templateId)?.onDidAppear(
+        TemplateStore.getTemplate(templateId: templateId)?.onDidAppear(
             animated: animated
         )
     }
@@ -195,7 +192,7 @@ class AutoPlayInterfaceController: NSObject, CPInterfaceControllerDelegate {
     ) {
         let templateId = aTemplate.id
 
-        templateStore.getTemplate(templateId: templateId)?.onWillDisappear(
+        TemplateStore.getTemplate(templateId: templateId)?.onWillDisappear(
             animated: animated
         )
     }
@@ -206,12 +203,12 @@ class AutoPlayInterfaceController: NSObject, CPInterfaceControllerDelegate {
     ) {
         let templateId = aTemplate.id
 
-        templateStore.getTemplate(templateId: templateId)?.onDidDisappear(
+        TemplateStore.getTemplate(templateId: templateId)?.onDidDisappear(
             animated: animated
         )
 
         if aTemplate is CPAlertTemplate {
-            templateStore.removeTemplate(templateId: templateId)
+            TemplateStore.removeTemplate(templateId: templateId)
 
             HybridAutoPlay.removeListeners(
                 templateId: templateId

package/ios/scenes/AutoPlayScene.swift

@@ -106,7 +106,7 @@ class AutoPlayScene: UIResponder {
 
     open func traitCollectionDidChange(traitCollection: UITraitCollection) {
         self.traitCollection = traitCollection
-        self.templateStore.traitCollectionDidChange()
+        TemplateStore.traitCollectionDidChange()
     }
 
     open func safeAreaInsetsDidChange(safeAreaInsets: UIEdgeInsets) {

package/ios/scenes/HeadUnitSceneDelegate.swift

@@ -20,8 +20,7 @@ class HeadUnitSceneDelegate: AutoPlayScene, CPTemplateApplicationSceneDelegate {
     ) {
         self.window = window
         self.interfaceController = AutoPlayInterfaceController(
-            interfaceController: interfaceController,
-            templateStore: self.templateStore
+            interfaceController: interfaceController
         )
 
         let props: [String: Any] = [
@@ -45,8 +44,10 @@ class HeadUnitSceneDelegate: AutoPlayScene, CPTemplateApplicationSceneDelegate {
     ) {
         HybridAutoPlay.emit(event: .diddisconnect)
         disconnect()
-        
-        let mapTemplate = templateStore.getTemplate(templateId: SceneStore.rootModuleName) as? MapTemplate
+
+        let mapTemplate =
+            TemplateStore.getTemplate(templateId: SceneStore.rootModuleName)
+            as? MapTemplate
         mapTemplate?.stopNavigation()
     }
 

package/ios/templates/AutoPlayTemplate.swift

@@ -10,7 +10,7 @@ import CarPlay
 protocol AutoPlayTemplate {
     var autoDismissMs: Double? { get }
 
-    func invalidate()
+    @MainActor func invalidate()
     func onWillAppear(animated: Bool)
     func onDidAppear(animated: Bool)
     func onWillDisappear(animated: Bool)
@@ -27,9 +27,10 @@ extension AutoPlayTemplate {
 }
 
 protocol AutoPlayHeaderProviding {
-    var barButtons: [NitroAction]? { get set }
+    @MainActor var barButtons: [NitroAction]? { get set }
 }
 
+@MainActor
 func setBarButtons(template: CPTemplate, barButtons: [NitroAction]?) {
     guard let template = template as? CPBarButtonProviding else { return }
 

package/ios/templates/GridTemplate.swift

@@ -37,8 +37,6 @@ class GridTemplate: AutoPlayTemplate, AutoPlayHeaderProviding {
             gridButtons: GridTemplate.parseButtons(buttons: config.buttons),
             id: config.id
         )
-
-        setBarButtons(template: template, barButtons: barButtons)
     }
 
     static func parseButtons(buttons: [NitroGridButton]) -> [CPGridButton] {
@@ -104,6 +102,7 @@ class GridTemplate: AutoPlayTemplate, AutoPlayHeaderProviding {
         config.onPopped?()
     }
 
+    @MainActor
     func updateButtons(buttons: [NitroGridButton]) {
         config.buttons = buttons
         invalidate()