@iternio/react-native-auto-play 0.0.1

package/ios/hybrid/HybridCarPlayDashboard.swift

@@ -0,0 +1,73 @@
+//
+//  HybridCarPlayDashboard.swift
+//  Pods
+//
+//  Created by Manuel Auer on 24.10.25.
+//
+import NitroModules
+
+class HybridCarPlayDashboard: HybridCarPlayDashboardSpec {
+    private static var listeners = [EventName: [String: () -> Void]]()
+    private static var colorSchemeListeners = [
+        String: (_:ColorScheme) -> Void
+    ]()
+
+    func addListener(eventType: EventName, callback: @escaping () -> Void)
+        throws -> () -> Void
+    {
+        let uuid = UUID().uuidString
+        HybridCarPlayDashboard.listeners[eventType, default: [:]][uuid] =
+            callback
+
+        if eventType == .didconnect && SceneStore.isDashboardModuleConnected() {
+            callback()
+        }
+
+        return {
+            HybridCarPlayDashboard.listeners[eventType]?.removeValue(
+                forKey: uuid
+            )
+        }
+    }
+
+    func initRootView() throws {
+        let scene = try SceneStore.getDashboardScene()
+        scene?.initRootView()
+    }
+
+    func setButtons(buttons: [NitroCarPlayDashboardButton]) throws -> Promise<
+        Void
+    > {
+        return Promise.async {
+            try await MainActor.run {
+                let scene = try SceneStore.getDashboardScene()
+                scene?.setButtons(buttons: buttons)
+            }
+        }
+    }
+
+    func addListenerColorScheme(
+        callback: @escaping (_ payload: ColorScheme) -> Void
+    ) throws -> () -> Void {
+        let uuid = UUID().uuidString
+        HybridCarPlayDashboard.colorSchemeListeners[uuid] = callback
+
+        return {
+            HybridCarPlayDashboard.colorSchemeListeners.removeValue(
+                forKey: uuid
+            )
+        }
+    }
+
+    static func emit(event: EventName) {
+        HybridCarPlayDashboard.listeners[event]?.values.forEach {
+            $0()
+        }
+    }
+
+    static func emitColorScheme(colorScheme: ColorScheme) {
+        HybridCarPlayDashboard.colorSchemeListeners.values.forEach {
+            $0(colorScheme)
+        }
+    }
+}

package/ios/hybrid/HybridCluster.swift

@@ -0,0 +1,181 @@
+//
+//  HybridCluster.swift
+//  Pods
+//
+//  Created by Manuel Auer on 25.10.25.
+//
+import NitroModules
+
+class HybridCluster: HybridClusterSpec {
+    private static var listeners = [
+        ClusterEventName: [String: (_:String) -> Void]
+    ]()
+
+    private static var eventQueue = [
+        ClusterEventName: [String]  // clusterIds queued per event
+    ]()
+
+    private static var colorSchemeListeners = [
+        String: (_: String, _: ColorScheme) -> Void
+    ]()
+
+    private static var zoomListeners = [
+        String: (_: String, _: ZoomEvent) -> Void
+    ]()
+
+    private static var compassListeners = [
+        String: (_: String, _: Bool) -> Void
+    ]()
+
+    private static var speedLimitListeners = [
+        String: (_: String, _: Bool) -> Void
+    ]()
+
+    func addListener(
+        eventType: ClusterEventName,
+        callback: @escaping (_ clusterId: String) -> Void
+    ) throws -> () -> Void {
+        let uuid = UUID().uuidString
+        HybridCluster.listeners[eventType, default: [:]][uuid] =
+            callback
+
+        if let queuedClusterIds = HybridCluster.eventQueue[eventType] {
+            for clusterId in queuedClusterIds {
+                callback(clusterId)
+            }
+            HybridCluster.eventQueue[eventType] = nil
+        }
+
+        return {
+            HybridCluster.listeners[eventType]?.removeValue(
+                forKey: uuid
+            )
+        }
+    }
+
+    func initRootView(clusterId: String) throws -> Promise<Void> {
+        return Promise.async {
+            if #available(iOS 15.4, *) {
+                try await MainActor.run {
+                    let scene = try SceneStore.getClusterScene(
+                        clusterId: clusterId
+                    )
+                    scene?.initRootView()
+                }
+            } else {
+                throw AutoPlayError.unsupportedVersion(
+                    "Cluster support only available on iOS >= 15.4"
+                )
+            }
+        }
+    }
+
+    func setAttributedInactiveDescriptionVariants(
+        clusterId: String,
+        attributedInactiveDescriptionVariants:
+            [NitroAttributedString]
+    ) throws {
+        if #available(iOS 15.4, *) {
+            let scene = try SceneStore.getClusterScene(
+                clusterId: clusterId
+            )
+            scene?.setAttributedInactiveDescriptionVariants(
+                attributedInactiveDescriptionVariants:
+                    attributedInactiveDescriptionVariants
+            )
+        } else {
+            throw AutoPlayError.unsupportedVersion(
+                "Cluster support only available on iOS >= 15.4"
+            )
+        }
+    }
+
+    func addListenerColorScheme(
+        callback: @escaping (String, ColorScheme) -> Void
+    ) throws -> () -> Void {
+        let uuid = UUID().uuidString
+        HybridCluster.colorSchemeListeners[uuid] = callback
+
+        return {
+            HybridCluster.colorSchemeListeners.removeValue(
+                forKey: uuid
+            )
+        }
+    }
+
+    func addListenerZoom(
+        callback: @escaping (_ clusterId: String, _ payload: ZoomEvent) -> Void
+    ) throws -> () -> Void {
+        let uuid = UUID().uuidString
+        HybridCluster.zoomListeners[uuid] = callback
+
+        return {
+            HybridCluster.zoomListeners.removeValue(
+                forKey: uuid
+            )
+        }
+    }
+
+    func addListenerCompass(
+        callback: @escaping (_ clusterId: String, _ payload: Bool) -> Void
+    ) throws -> () -> Void {
+        let uuid = UUID().uuidString
+        HybridCluster.compassListeners[uuid] = callback
+
+        return {
+            HybridCluster.compassListeners.removeValue(
+                forKey: uuid
+            )
+        }
+    }
+
+    func addListenerSpeedLimit(
+        callback: @escaping (_ clusterId: String, _ payload: Bool) -> Void
+    ) throws -> () -> Void {
+        let uuid = UUID().uuidString
+        HybridCluster.speedLimitListeners[uuid] = callback
+
+        return {
+            HybridCluster.speedLimitListeners.removeValue(
+                forKey: uuid
+            )
+        }
+    }
+
+    static func emit(event: ClusterEventName, clusterId: String) {
+        guard let listeners = HybridCluster.listeners[event], !listeners.isEmpty
+        else {
+            // no listeners -> queue the event
+            HybridCluster.eventQueue[event, default: []].append(clusterId)
+            return
+        }
+
+        listeners.values.forEach {
+            $0(clusterId)
+        }
+    }
+
+    static func emitColorScheme(clusterId: String, colorScheme: ColorScheme) {
+        HybridCluster.colorSchemeListeners.values.forEach {
+            $0(clusterId, colorScheme)
+        }
+    }
+
+    static func emitZoom(clusterId: String, payload: ZoomEvent) {
+        HybridCluster.zoomListeners.values.forEach {
+            $0(clusterId, payload)
+        }
+    }
+
+    static func emitCompass(clusterId: String, payload: Bool) {
+        HybridCluster.compassListeners.values.forEach {
+            $0(clusterId, payload)
+        }
+    }
+
+    static func emitSpeedLimit(clusterId: String, payload: Bool) {
+        HybridCluster.speedLimitListeners.values.forEach {
+            $0(clusterId, payload)
+        }
+    }
+}

package/ios/hybrid/HybridGridTemplate.swift

@@ -0,0 +1,31 @@
+//
+//  HybridGridTemplate.swift
+//  Pods
+//
+//  Created by Manuel Auer on 15.10.25.
+//
+
+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
+            )
+        }
+    }
+
+    func updateGridTemplateButtons(
+        templateId: String,
+        buttons: [NitroGridButton]
+    ) throws {
+        try RootModule.withScene { scene in
+            if let template = scene.templateStore.getTemplate(
+                templateId: templateId
+            ) as? GridTemplate {
+                template.updateButtons(buttons: buttons)
+            }
+        }
+    }
+}

package/ios/hybrid/HybridInformationTemplate.swift

@@ -0,0 +1,29 @@
+//
+//  HybridInformationTemplate.swift
+//  Pods
+//
+//  Created by Samuel Brucksch on 05.11.25.
+//
+
+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
+            )
+        }
+    }
+    
+    func updateInformationTemplateSections(templateId: String, section: NitroSection) throws {
+        try RootModule.withScene { scene in
+            if let template = scene.templateStore.getTemplate(
+                templateId: templateId
+            ) as? InformationTemplate {
+                template.updateSection(section: section)
+            }
+        }
+    }
+}

package/ios/hybrid/HybridListTemplate.swift

@@ -0,0 +1,31 @@
+//
+//  HybridListTemplate.swift
+//  Pods
+//
+//  Created by Manuel Auer on 15.10.25.
+//
+
+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
+            )
+        }
+    }
+
+    func updateListTemplateSections(
+        templateId: String,
+        sections: [NitroSection]?
+    ) throws {
+        try RootModule.withScene { scene in
+            if let template = scene.templateStore.getTemplate(
+                templateId: templateId
+            ) as? ListTemplate {
+                template.updateSections(sections: sections)
+            }
+        }
+    }
+}

package/ios/hybrid/HybridMapTemplate.swift

@@ -0,0 +1,141 @@
+//
+//  HybridMapTemplate.swift
+//  Pods
+//
+//  Created by Manuel Auer on 15.10.25.
+//
+
+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
+            )
+        }
+    }
+
+    func setTemplateMapButtons(templateId: String, buttons: [NitroMapButton]?)
+        throws
+    {
+        try RootModule.withTemplate(templateId: templateId) {
+            template in
+            guard let template = template as? MapTemplate else {
+                return
+            }
+
+            template.config.mapButtons = buttons
+            template.invalidate()
+        }
+    }
+
+    func showNavigationAlert(templateId: String, alert: NitroNavigationAlert)
+        throws -> NavigationAlertCallbacks
+    {
+        var mapTemplate: MapTemplate?
+
+        try RootModule.withMapTemplate(templateId: templateId) { template in
+            template.showAlert(alertConfig: alert)
+            mapTemplate = template
+        }
+
+        return NavigationAlertCallbacks(
+            dismiss: {
+                mapTemplate?.dismissNavigationAlert(alertId: alert.id)
+            },
+            update: { title, subtitle in
+                mapTemplate?.updateNavigationAlert(
+                    alertId: alert.id,
+                    title: title,
+                    subtitle: subtitle
+                )
+            }
+        )
+    }
+
+    func showTripSelector(
+        templateId: String,
+        trips: [TripsConfig],
+        selectedTripId: String?,
+        textConfig: TripPreviewTextConfiguration,
+        onTripSelected: @escaping (_ tripId: String, _ routeId: String) -> Void,
+        onTripStarted: @escaping (_ tripId: String, _ routeId: String) -> Void,
+        onBackPressed: @escaping () -> Void,
+        mapButtons: [NitroMapButton]
+    ) throws -> TripSelectorCallback {
+        var callback: TripSelectorCallback?
+
+        try RootModule.withMapTemplate(templateId: templateId) { template in
+            callback = try template.showTripSelector(
+                trips: trips,
+                selectedTripId: selectedTripId,
+                textConfig: textConfig,
+                onTripSelected: onTripSelected,
+                onTripStarted: onTripStarted,
+                onBackPressed: onBackPressed,
+                mapButtons: mapButtons
+            )
+        }
+
+        guard let callback = callback else {
+            throw AutoPlayError.templateNotFound(templateId)
+        }
+
+        return callback
+    }
+
+    func hideTripSelector(templateId: String) throws {
+        try RootModule.withMapTemplate(templateId: templateId) { template in
+            template.hideTripSelector()
+        }
+    }
+
+    func updateVisibleTravelEstimate(
+        templateId: String,
+        visibleTravelEstimate: VisibleTravelEstimate
+    ) throws {
+        try RootModule.withMapTemplate(templateId: templateId) { template in
+            template.updateVisibleTravelEstimate(
+                visibleTravelEstimate: visibleTravelEstimate
+            )
+        }
+    }
+
+    func updateTravelEstimates(templateId: String, steps: [TripPoint]) throws {
+        try RootModule.withMapTemplate(templateId: templateId) { template in
+            template.updateTravelEstimates(steps: steps)
+        }
+    }
+
+    func updateManeuvers(templateId: String, maneuvers: NitroManeuver) throws {
+        try RootModule.withMapTemplate(templateId: templateId) {
+            template in
+            switch maneuvers {
+            case .first(let routingManeuvers):
+                {
+                    template.updateManeuvers(maneuvers: routingManeuvers)
+                }()
+            case .second(let messageManeuver):
+                {
+                    template.updateManeuvers(messageManeuver: messageManeuver)
+                }()
+            }
+
+        }
+    }
+
+    func startNavigation(templateId: String, trip: TripConfig) throws {
+        try RootModule.withMapTemplate(templateId: templateId) { template in
+            let trip = Parser.parseTrip(tripConfig: trip)
+            template.startNavigation(trip: trip)
+        }
+    }
+
+    func stopNavigation(templateId: String) throws {
+        try RootModule.withMapTemplate(templateId: templateId) { template in
+            template.stopNavigation()
+        }
+    }
+
+}

package/ios/hybrid/HybridMessageTemplate.swift

@@ -0,0 +1,19 @@
+//
+//  HybridMessageTemplate.swift
+//  Pods
+//
+//  Created by Samuel Brucksch on 17.10.25.
+//
+
+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
+            )
+        }
+    }
+}

package/ios/hybrid/HybridSearchTemplate.swift

@@ -0,0 +1,29 @@
+
+//
+//  HybridSearchTemplate.swift
+//  Pods
+//
+//  Created by Samuel Brucksch on 28.10.25.
+//
+
+class HybridSearchTemplate: HybridSearchTemplateSpec {
+    func updateSearchResults(templateId: String, results: NitroSection) throws {
+        try RootModule.withScene { scene in
+            if let template = scene.templateStore.getTemplate(
+                templateId: templateId
+            ) as? SearchTemplate {
+                template.updateSearchResults(results: results)
+            }
+        }
+    }
+    
+    func createSearchTemplate(config: SearchTemplateConfig) throws {
+        let template = SearchTemplate(config: config)
+        try RootModule.withScene { scene in
+            scene.templateStore.addTemplate(
+                template: template,
+                templateId: config.id
+            )
+        }
+    }
+}