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

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/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/template/MapTemplate.kt

@@ -86,10 +86,6 @@ class MapTemplate(
             if (isNavigating) {
                 navigationInfo?.let {
                     setNavigationInfo(it)
-                } ?: run {
-                    setNavigationInfo(RoutingInfo.Builder().apply {
-                        setLoading(true)
-                    }.build())
                 }
             }
             config.onDidChangePanningInterface?.let {
@@ -309,13 +305,19 @@ class MapTemplate(
 
             val routingInfo = maneuvers.asFirstOrNull()
             val messageInfo = maneuvers.asSecondOrNull()
+            val loadingInfo = maneuvers.asThirdOrNull()
 
-            if (routingInfo.isNullOrEmpty() && messageInfo == null) {
+            if (routingInfo.isNullOrEmpty() && messageInfo == null && loadingInfo == null) {
                 navigationInfo = null
                 AndroidAutoScreen.invalidateSurfaceScreens()
                 return
             }
 
+            if (loadingInfo != null) {
+                navigationInfo = RoutingInfo.Builder().setLoading(true).build()
+                return
+            }
+
             if (messageInfo != null) {
                 val backgroundColor =
                     if (context.isDarkMode) messageInfo.cardBackgroundColor.darkColor else messageInfo.cardBackgroundColor.lightColor
@@ -359,7 +361,9 @@ class MapTemplate(
 
                 val notificationText = currentStep.cue?.toString()
 
-                val notificationTitle = "${currentDistance.displayDistance.toInt()} ${Parser.parseDistanceUnit(currentDistance.displayUnit)}"
+                val notificationTitle = "${currentDistance.displayDistance.toInt()} ${
+                    Parser.parseDistanceUnit(currentDistance.displayUnit)
+                }"
 
                 it.notify(
                     notificationTitle, notificationText, notificationIcon

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

@@ -670,6 +670,9 @@ object Parser {
             setManeuver(parseManeuver(context, nitroManeuver))
             nitroManeuver.linkedLaneGuidance?.let { laneGuidance ->
                 val lanes = laneGuidance.lanes.mapNotNull { it.asFirstOrNull() }
+                if (lanes.isEmpty()) {
+                    return@let
+                }
                 lanes.forEach { lane ->
                     addLane(Lane.Builder().apply {
                         addDirection(

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
+        return Promise.async {
+            guard
+                let template = TemplateStore.getTemplate(templateId: templateId)
+                    as? MapTemplate
+            else {
+                throw AutoPlayError.invalidTemplateError(
+                    "\(templateId) is not a MapTemplate"
+                )
+            }
 
-            template.config.mapButtons = buttons
-            template.invalidate()
+            await MainActor.run {
+                template.config.mapButtons = buttons
+                template.invalidate()
+            }
         }
     }
 
@@ -133,6 +141,13 @@ class HybridMapTemplate: HybridMapTemplateSpec {
                 {
                     template.updateManeuvers(messageManeuver: messageManeuver)
                 }()
+            case .third(let loadingManeuver):
+                {
+                    template.navigationSession?.pauseTrip(
+                        for: .loading,
+                        description: nil
+                    )
+                }()
             }
 
         }

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) {