@iternio/react-native-auto-play 0.0.1

package/ios/ReactHelpers/NitroConvert.h

@@ -0,0 +1,19 @@
+//
+//  NitroConvert.h
+//  Pods
+//
+//  Created by Manuel Auer on 04.11.25.
+//
+
+// this is required for old architecture support since the React pod can not be imported
+
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface NitroConvert : NSObject
++ (UIColor *)uiColor:(id)json;
++ (UIImage *)uiImage:(id)json;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/ReactHelpers/NitroConvert.m

@@ -0,0 +1,21 @@
+//
+//  NitroConvert.m
+//  Pods
+//
+//  Created by Manuel Auer on 04.11.25.
+//
+
+// this is required for old architecture support since the React pod can not be imported
+
+#import "NitroConvert.h"
+#import <React/RCTConvert.h>
+
+@implementation NitroConvert
++ (UIColor *)uiColor:(id)json {
+    return [RCTConvert UIColor:json];
+}
+
++ (nonnull UIImage *)uiImage:(nonnull id)json {
+    return [RCTConvert UIImage:json];
+}
+@end

package/ios/ReactHelpers/RCTRootView.h

@@ -0,0 +1,29 @@
+//
+//  RootView.h
+//  Pods
+//
+//  Created by Manuel Auer on 07.11.25.
+//
+
+// this is required for old architecture support since the React pod can not be imported
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#else
+
+#import <Foundation/Foundation.h>
+
+@protocol RCTInvalidating <NSObject>
+
+- (void)invalidate;
+
+@end
+
+@interface RCTRootView : UIView
+/**
+ * The React-managed contents view of the root view.
+ */
+@property(nonatomic, strong, readonly) UIView *contentView;
+@end
+
+#endif

package/ios/Types.swift

@@ -0,0 +1,20 @@
+//
+//  Types.swift
+//  Pods
+//
+//  Created by Manuel Auer on 03.10.25.
+//
+
+struct TemplateEventPayload {
+    let animated: Bool
+    let state: VisibilityState
+}
+
+enum AutoPlayError: Error {
+    case templateNotFound(String)
+    case sceneNotFound(String)
+    case interfaceControllerNotFound(String)
+    case invalidTemplateError(String)
+    case propertyNotFoundError(String)
+    case unsupportedVersion(String)
+}

package/ios/extensions/CarPlayExtensions.swift

@@ -0,0 +1,145 @@
+//
+//  CPTemplate+Extensions.swift
+//  Pods
+//
+//  Created by Manuel Auer on 14.10.25.
+//
+
+import CarPlay
+
+extension CPMapButton {
+    convenience init(
+        image: UIImage,
+        handler: @escaping (CPMapButton) -> Void
+    ) {
+        self.init(handler: handler)
+        self.image = image
+    }
+}
+
+extension CPRouteChoice {
+    convenience init(
+        summaryVariants: [String],
+        additionalInformationVariants: [String],
+        selectionSummaryVariants: [String],
+        id: String,
+        travelEstimates: [CPTravelEstimates]
+    ) {
+        self.init(
+            summaryVariants: summaryVariants,
+            additionalInformationVariants: additionalInformationVariants,
+            selectionSummaryVariants: selectionSummaryVariants
+        )
+        var info: [String: Any] = [:]
+        info["id"] = id
+        info["travelEstimates"] = travelEstimates
+        self.userInfo = info
+    }
+    var id: String {
+        return (self.userInfo as? [String: Any])?["id"] as! String
+    }
+    var travelEstimates: [CPTravelEstimates] {
+        return (self.userInfo as? [String: Any])?["travelEstimates"]
+            as! [CPTravelEstimates]
+    }
+}
+
+extension CPTrip {
+    convenience init(
+        origin: MKMapItem,
+        destination: MKMapItem,
+        routeChoices: [CPRouteChoice],
+        id: String
+    ) {
+        self.init(
+            origin: origin,
+            destination: destination,
+            routeChoices: routeChoices
+        )
+        var info: [String: Any] = [:]
+        info["id"] = id
+        self.userInfo = info
+    }
+    var id: String {
+        return (self.userInfo as? [String: Any])?["id"] as! String
+    }
+}
+
+extension CPManeuver {
+    convenience init(id: String, isSecondary: Bool = false) {
+        self.init()
+        var info: [String: Any] = [:]
+        info["id"] = id
+        info["isSecondary"] = isSecondary
+        self.userInfo = info
+    }
+    var id: String {
+        return (self.userInfo as? [String: Any])?["id"] as! String
+    }
+    @available(iOS 17.4, *)
+    var laneGuidance: CPLaneGuidance? {
+        // iOS does not store the actual CPLaneGuidance type but some NSConcreteMutableAttributedString so we store it in userInfo so we can access it later on
+        get {
+            return (self.userInfo as? [String: Any])?["laneGuidance"]
+                as? CPLaneGuidance
+        }
+        set {
+            var info = (self.userInfo as? [String: Any]) ?? [:]
+            info["laneGuidance"] = newValue
+            self.userInfo = info
+        }
+    }
+    var laneImages: [NitroImage]? {
+        get {
+            return (self.userInfo as? [String: Any])?["laneImages"]
+                as? [NitroImage]
+        }
+        set {
+            var info = (self.userInfo as? [String: Any]) ?? [:]
+            info["laneImages"] = newValue
+            self.userInfo = info
+        }
+    }
+    var isSecondary: Bool {
+        return (self.userInfo as? [String: Any])?["isSecondary"]
+            as! Bool
+    }
+}
+
+@available(iOS 17.4, *)
+extension CPLaneGuidance {
+    convenience init(instructionVariants: [String], lanes: [CPLane]) {
+        self.init()
+        self.instructionVariants = instructionVariants
+        self.lanes = lanes
+    }
+}
+
+@available(iOS 17.4, *)
+extension CPLane {
+    convenience init(
+        angles: [Measurement<UnitAngle>],
+        highlightedAngle: Measurement<UnitAngle>?,
+        isPreferred: Bool
+    ) {
+        if #available(iOS 18.0, *) {
+            if let highlightedAngle = highlightedAngle {
+                self.init(
+                    angles: angles,
+                    highlightedAngle: highlightedAngle,
+                    isPreferred: isPreferred
+                )
+            } else {
+                self.init(angles: angles)
+            }
+        } else {
+            self.init()
+            if let highlightedAngle = highlightedAngle {
+                self.primaryAngle = highlightedAngle
+            }
+            self.secondaryAngles = angles
+            self.status =
+                isPreferred ? CPLaneStatus.preferred : CPLaneStatus.notGood
+        }
+    }
+}

package/ios/extensions/CarPlayTemplateExtensions.swift

@@ -0,0 +1,87 @@
+//
+//  CarPlayTemplateExtensions.swift
+//  Pods
+//
+//  Created by Manuel Auer on 22.10.25.
+//
+
+import CarPlay
+
+func initTemplate(template: CPTemplate, id: String) {
+    var info: [String: Any] = [:]
+    info["id"] = id
+    template.userInfo = info
+}
+
+extension CPTemplate {
+    convenience init(id: String) {
+        self.init()
+        initTemplate(template: self, id: id)
+    }
+    @objc var id: String {
+        return (self.userInfo as? [String: Any])?["id"] as! String
+    }
+}
+
+extension CPGridTemplate {
+    convenience init(title: String?, gridButtons: [CPGridButton], id: String) {
+        self.init(title: title, gridButtons: gridButtons)
+        initTemplate(template: self, id: id)
+    }
+}
+
+extension CPInformationTemplate {
+    convenience init(
+        title: String,
+        layout: CPInformationTemplateLayout,
+        items: [CPInformationItem],
+        actions: [CPTextButton],
+        id: String
+    ) {
+        self.init(title: title, layout: layout, items: items, actions: actions)
+        initTemplate(template: self, id: id)
+    }
+}
+
+extension CPListTemplate {
+    convenience init(
+        title: String?,
+        sections: [CPListSection],
+        assistantCellConfiguration: CPAssistantCellConfiguration?,
+        id: String
+    ) {
+        self.init(
+            title: title,
+            sections: sections,
+            assistantCellConfiguration: assistantCellConfiguration
+        )
+        initTemplate(template: self, id: id)
+    }
+    @available(iOS 26.0, *)
+    convenience init(
+        title: String?,
+        sections: [CPListSection],
+        assistantCellConfiguration: CPAssistantCellConfiguration?,
+        headerGridButtons: [CPGridButton]?,
+        id: String
+    ) {
+        self.init(
+            title: title,
+            sections: sections,
+            assistantCellConfiguration: assistantCellConfiguration,
+            headerGridButtons: headerGridButtons
+        )
+        initTemplate(template: self, id: id)
+    }
+}
+
+extension CPAlertTemplate {
+    convenience init(
+        titleVariants: [String],
+        actions: [CPAlertAction],
+        id: String
+    ) {
+        self.init(titleVariants: titleVariants, actions: actions)
+        initTemplate(template: self, id: id)
+    }
+}

package/ios/extensions/NitroImageExtensions.swift

@@ -0,0 +1,33 @@
+//
+//  NitroImage.swift
+//  Pods
+//
+//  Created by Manuel Auer on 04.11.25.
+//
+
+protocol ImageProtocol {
+    var glyphImage: GlyphImage? { get }
+    var assetImage: AssetImage? { get }
+}
+
+extension NitroImage: ImageProtocol {
+    var glyphImage: GlyphImage? {
+        if case let .first(glyph) = self { return glyph }
+        return nil
+    }
+    var assetImage: AssetImage? {
+        if case let .second(asset) = self { return asset }
+        return nil
+    }
+}
+
+extension Variant_GlyphImage_AssetImage: ImageProtocol {
+    var glyphImage: GlyphImage? {
+        if case let .first(glyph) = self { return glyph }
+        return nil
+    }
+    var assetImage: AssetImage? {
+        if case let .second(asset) = self { return asset }
+        return nil
+    }
+}

package/ios/extensions/UIImage+Toggle.swift

@@ -0,0 +1,58 @@
+//
+//  UIImage+Drawables.swift
+//  Pods
+//
+//  Created by Manuel Auer on 10.10.25.
+//
+
+import UIKit
+
+extension UIImage {
+    static func makeToggleImage(
+        enabled: Bool,
+        maximumImageSize: CGSize
+    ) -> UIImage {
+        let renderer = UIGraphicsImageRenderer(size: maximumImageSize)
+        return renderer.image { ctx in
+            // Draw the track as a pill, centered vertically
+            let trackHeight = maximumImageSize.height * 0.5
+            let trackY = (maximumImageSize.height - trackHeight) / 2
+            let trackRect = CGRect(
+                x: 0,
+                y: trackY,
+                width: maximumImageSize.width,
+                height: trackHeight
+            )
+            let trackRadius = trackHeight / 2
+            let trackColor = enabled ? UIColor.systemGreen : UIColor.systemGray
+            let trackPath = UIBezierPath(
+                roundedRect: trackRect,
+                cornerRadius: trackRadius
+            )
+            trackColor.setFill()
+            trackPath.fill()
+
+            // Draw the thumb as rounded rectangle taking half the width of the track
+            let thumbWidth = maximumImageSize.width / 2
+            let thumbHeight = trackHeight - 5
+            let thumbY = trackY + (trackHeight - thumbHeight) / 2
+            let thumbX =
+                enabled
+                ? maximumImageSize.width - thumbWidth - 3
+                : 3.0
+            let thumbRect = CGRect(
+                x: thumbX,
+                y: thumbY,
+                width: thumbWidth,
+                height: thumbHeight
+            )
+            let thumbCornerRadius = thumbHeight / 2
+            let thumbPath = UIBezierPath(
+                roundedRect: thumbRect,
+                cornerRadius: thumbCornerRadius
+            )
+            UIColor.white.setFill()
+            thumbPath.fill()
+        }
+    }
+}

package/ios/hybrid/HybridAutoPlay.swift

@@ -0,0 +1,293 @@
+import CarPlay
+import NitroModules
+
+struct StateListener {
+    let id: UUID
+    let callback: () -> Void
+}
+
+struct RenderStateListener {
+    let id: UUID
+    let callback: (VisibilityState) -> Void
+}
+
+struct SafeAreaListener {
+    let id: UUID
+    let callback: (SafeAreaInsets) -> Void
+}
+
+class HybridAutoPlay: HybridAutoPlaySpec {
+    private static var listeners = [EventName: [StateListener]]()
+    private static var renderStateListeners = [String: [RenderStateListener]]()
+    private static var safeAreaInsetsListeners = [String: [SafeAreaListener]]()
+
+    func addListener(eventType: EventName, callback: @escaping () -> Void)
+        throws -> () -> Void
+    {
+        let listener = StateListener(id: UUID(), callback: callback)
+
+        HybridAutoPlay.listeners[eventType, default: []].append(listener)
+
+        if eventType == .didconnect && SceneStore.isRootModuleConnected() {
+            callback()
+        }
+
+        return {
+            HybridAutoPlay.listeners[eventType]?.removeAll {
+                $0.id == listener.id
+            }
+            if HybridAutoPlay.listeners[eventType]?.isEmpty ?? false {
+                HybridAutoPlay.listeners.removeValue(forKey: eventType)
+            }
+        }
+    }
+
+    func addListenerRenderState(
+        moduleName: String,
+        callback: @escaping (VisibilityState) -> Void
+    ) throws -> () -> Void {
+        let listener = RenderStateListener(id: UUID(), callback: callback)
+
+        HybridAutoPlay.renderStateListeners[moduleName, default: []].append(
+            listener
+        )
+
+        if let state = SceneStore.getState(moduleName: moduleName) {
+            callback(state)
+        }
+
+        return {
+            HybridAutoPlay.renderStateListeners[moduleName]?.removeAll {
+                $0.id == listener.id
+            }
+            if HybridAutoPlay.renderStateListeners[moduleName]?.isEmpty
+                ?? false
+            {
+                HybridAutoPlay.renderStateListeners.removeValue(
+                    forKey: moduleName
+                )
+            }
+        }
+    }
+
+    func isConnected() throws -> Bool {
+        return SceneStore.isRootModuleConnected()
+    }
+
+    func addSafeAreaInsetsListener(
+        moduleName: String,
+        callback: @escaping (SafeAreaInsets) -> Void
+    ) throws -> () -> Void {
+        let listener = SafeAreaListener(id: UUID(), callback: callback)
+
+        HybridAutoPlay.safeAreaInsetsListeners[moduleName, default: []].append(
+            listener
+        )
+
+        if let safeAreaInsets = SceneStore.getScene(moduleName: moduleName)?
+            .safeAreaInsets
+        {
+            let insets = HybridAutoPlay.getSafeAreaInsets(
+                safeAreaInsets: safeAreaInsets
+            )
+            callback(insets)
+        }
+
+        return {
+            HybridAutoPlay.safeAreaInsetsListeners[moduleName]?.removeAll {
+                $0.id == listener.id
+            }
+            if HybridAutoPlay.safeAreaInsetsListeners[moduleName]?.isEmpty
+                ?? false
+            {
+                HybridAutoPlay.safeAreaInsetsListeners.removeValue(
+                    forKey: moduleName
+                )
+            }
+        }
+    }
+
+    // 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 {
+                    await MainActor.run {
+                        scene.initRootView()
+                    }
+                }
+
+                let _ = try await interfaceController.setRootTemplate(
+                    template,
+                    animated: false
+                )
+            }
+        }
+    }
+
+    func pushTemplate(templateId: String) throws
+        -> NitroModules.Promise<Void>
+    {
+        return Promise.async {
+            return try await RootModule.withSceneTemplateAndInterfaceController(
+                templateId: templateId
+            ) { template, scene, interfaceController in
+                if template is CPAlertTemplate {
+                    let animated = try await
+                        !interfaceController.dismissTemplate(
+                            animated: false
+                        )
+
+                    let _ = try await interfaceController.presentTemplate(
+                        template,
+                        animated: animated
+                    )
+                } else {
+                    let _ = try await interfaceController.pushTemplate(
+                        template,
+                        animated: true
+                    )
+                }
+
+                if let autoDismissMs = await scene.templateStore.getTemplate(
+                    templateId: templateId
+                )?.autoDismissMs {
+                    Task { @MainActor in
+                        try await Task.sleep(
+                            nanoseconds: UInt64(autoDismissMs) * 1_000_000
+                        )
+
+                        if interfaceController.topTemplateId == templateId
+                            || interfaceController.interfaceController
+                                .presentedTemplate?.id == templateId
+                        {
+                            try await self.popTemplate(animate: true).await()
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    func popTemplate(animate: Bool?) throws -> NitroModules.Promise<Void> {
+        return Promise.async {
+            return try await RootModule.withInterfaceController {
+                interfaceController in
+
+                if try await interfaceController.dismissTemplate(
+                    animated: animate ?? true
+                ) {
+                    return
+                }
+
+                guard
+                    let templateId = try await interfaceController.popTemplate(
+                        animated: true
+                    )
+                else { return }
+                HybridAutoPlay.removeListeners(templateId: templateId)
+            }
+        }
+    }
+
+    func popToRootTemplate(animate: Bool?) throws -> NitroModules.Promise<Void>
+    {
+        return Promise.async {
+            try await RootModule.withInterfaceController {
+                interfaceController in
+
+                let hasPresentedTemplate =
+                    try await interfaceController.dismissTemplate(
+                        animated: false
+                    )
+
+                let templateIds =
+                    try await interfaceController.popToRootTemplate(
+                        animated: !hasPresentedTemplate && (animate ?? true)
+                    )
+                for templateId in templateIds {
+                    HybridAutoPlay.removeListeners(templateId: templateId)
+                }
+            }
+        }
+    }
+
+    func popToTemplate(templateId: String, animate: Bool?) throws -> Promise<
+        Void
+    > {
+        return Promise.async {
+            return try await RootModule.withInterfaceController {
+                interfaceController in
+
+                let _ = try await interfaceController.dismissTemplate(
+                    animated: animate ?? true
+                )
+
+                let templateIds = try await interfaceController.popToTemplate(
+                    templateId: templateId,
+                    animated: true
+                )
+                templateIds.forEach { templateId in
+                    HybridAutoPlay.removeListeners(templateId: templateId)
+                }
+            }
+        }
+    }
+
+    // MARK: generic template updates
+    func setTemplateHeaderActions(
+        templateId: String,
+        headerActions: [NitroAction]?
+    ) throws {
+        try RootModule.withTemplate(templateId: templateId) {
+            template in
+            template.barButtons = headerActions
+            template.invalidate()
+        }
+    }
+
+    // MARK: events
+    static func emit(event: EventName) {
+        HybridAutoPlay.listeners[event]?.forEach { listener in
+            listener.callback()
+        }
+    }
+
+    static func emitRenderState(moduleName: String, state: VisibilityState) {
+        HybridAutoPlay.renderStateListeners[moduleName]?.forEach {
+            listener in
+            listener.callback(state)
+        }
+    }
+
+    static func emitSafeAreaInsets(
+        moduleName: String,
+        safeAreaInsets: UIEdgeInsets
+    ) {
+        let insets = HybridAutoPlay.getSafeAreaInsets(
+            safeAreaInsets: safeAreaInsets
+        )
+        HybridAutoPlay.safeAreaInsetsListeners[moduleName]?.forEach {
+            listener in listener.callback(insets)
+        }
+    }
+
+    static func removeListeners(templateId: String) {
+        HybridAutoPlay.renderStateListeners.removeValue(forKey: templateId)
+        HybridAutoPlay.safeAreaInsetsListeners.removeValue(forKey: templateId)
+    }
+
+    static func getSafeAreaInsets(safeAreaInsets: UIEdgeInsets)
+        -> SafeAreaInsets
+    {
+        return SafeAreaInsets(
+            top: safeAreaInsets.top,
+            left: safeAreaInsets.left,
+            bottom: safeAreaInsets.bottom,
+            right: safeAreaInsets.right,
+            isLegacyLayout: nil
+        )
+    }
+}