@iternio/react-native-auto-play 0.0.1

package/ios/scenes/AutoPlayInterfaceController.swift

@@ -0,0 +1,221 @@
+//
+//  AutoPlayInterfaceController.swift
+//  Pods
+//
+//  Created by Manuel Auer on 12.10.25.
+//
+
+import CarPlay
+
+@MainActor
+class AutoPlayInterfaceController: NSObject, CPInterfaceControllerDelegate {
+    let interfaceController: CPInterfaceController
+    let templateStore: TemplateStore
+
+    init(
+        interfaceController: CPInterfaceController,
+        templateStore: TemplateStore
+    ) {
+        self.interfaceController = interfaceController
+        self.templateStore = templateStore
+
+        super.init()
+
+        self.interfaceController.delegate = self
+    }
+
+    var carTraitCollection: UITraitCollection {
+        return interfaceController.carTraitCollection
+    }
+
+    var rootTemplate: CPTemplate {
+        interfaceController.rootTemplate
+    }
+
+    var topTemplate: CPTemplate? {
+        interfaceController.topTemplate
+    }
+
+    var templates: [CPTemplate] {
+        interfaceController.templates
+    }
+
+    var topTemplateId: String? {
+        return interfaceController.topTemplate?.id
+    }
+
+    var rootTemplateId: String? {
+        return interfaceController.rootTemplate.id
+    }
+    
+    func pushTemplate(
+        _ templateToPush: CPTemplate,
+        animated: Bool
+    ) async throws -> Bool {
+        return try await interfaceController.pushTemplate(
+            templateToPush,
+            animated: animated
+        )
+    }
+
+    func setRootTemplate(
+        _ rootTemplate: CPTemplate,
+        animated: Bool
+    ) async throws -> Bool {
+        return try await interfaceController.setRootTemplate(
+            rootTemplate,
+            animated: animated
+        )
+    }
+
+    func popTemplate(
+        animated: Bool
+    ) async throws -> String? {
+        guard let templateId = topTemplateId else { return nil }
+
+        try await interfaceController.popTemplate(
+            animated: animated
+        )
+
+        self.templateStore.removeTemplate(templateId: templateId)
+
+        return templateId
+    }
+
+    func popToRootTemplate(
+        animated: Bool
+    ) async throws -> [String] {
+        var templateIds: [String] = []
+
+        templates.forEach { template in
+            let templateId = template.id
+
+            if templateId == rootTemplateId {
+                return
+            }
+            templateIds.append(templateId)
+        }
+
+        try await interfaceController.popToRootTemplate(
+            animated: animated
+        )
+
+        self.templateStore.removeTemplates(templateIds: templateIds)
+
+        return templateIds
+    }
+
+    func popToTemplate(templateId: String, animated: Bool) async throws
+        -> [String]
+    {
+        guard
+            let template = interfaceController.templates.first(
+                where: {
+                    templateId == $0.id
+                })
+        else { return [] }
+
+        var templateIds: [String] = interfaceController.templates.map {
+            template in template.id
+        }
+
+        if let startIndex = templateIds.firstIndex(where: {
+            $0 == templateId
+        }),
+            let endIndex = templateIds.firstIndex(where: {
+                $0 == topTemplateId
+            })
+        {
+            templateIds = Array(templateIds[(startIndex)..<endIndex])
+        }
+
+        try await interfaceController.pop(
+            to: template,
+            animated: animated
+        )
+
+        return templateIds
+    }
+
+    func presentTemplate(
+        _ templateToPresent: CPTemplate,
+        animated: Bool
+    ) async throws -> Bool {
+        return try await interfaceController.presentTemplate(
+            templateToPresent,
+            animated: animated
+        )
+    }
+
+    func dismissTemplate(
+        animated: Bool
+    ) async throws -> Bool {
+        if interfaceController.presentedTemplate == nil {
+            return false
+        }
+
+        try await interfaceController.dismissTemplate(
+            animated: animated
+        )
+        
+        return true
+    }
+
+    // MARK: CPInterfaceControllerDelegate
+    func templateWillAppear(
+        _ aTemplate: CPTemplate,
+        animated: Bool
+    ) {
+        let templateId = aTemplate.id
+
+        templateStore.getTemplate(templateId: templateId)?.onWillAppear(
+            animated: animated
+        )
+    }
+
+    func templateDidAppear(
+        _ aTemplate: CPTemplate,
+        animated: Bool
+    ) {
+        let templateId = aTemplate.id
+
+        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.getTemplate(templateId: templateId)?.onDidAppear(
+            animated: animated
+        )
+    }
+
+    func templateWillDisappear(
+        _ aTemplate: CPTemplate,
+        animated: Bool
+    ) {
+        let templateId = aTemplate.id
+
+        templateStore.getTemplate(templateId: templateId)?.onWillDisappear(
+            animated: animated
+        )
+    }
+
+    func templateDidDisappear(
+        _ aTemplate: CPTemplate,
+        animated: Bool
+    ) {
+        let templateId = aTemplate.id
+
+        templateStore.getTemplate(templateId: templateId)?.onDidDisappear(
+            animated: animated
+        )
+
+        if aTemplate is CPAlertTemplate {
+            templateStore.removeTemplate(templateId: templateId)
+
+            HybridAutoPlay.removeListeners(
+                templateId: templateId
+            )
+        }
+    }
+}

package/ios/scenes/AutoPlayScene.swift

@@ -0,0 +1,126 @@
+//
+//  AutoPlayScene.swift
+//  Pods
+//
+//  Created by Manuel Auer on 02.10.25.
+//
+
+import CarPlay
+
+#if RCT_NEW_ARCH_ENABLED
+    import React
+#endif
+
+class AutoPlayScene: UIResponder {
+    public private(set) var state: VisibilityState = .diddisappear
+
+    var initialProperties: [String: Any] = [:]
+    var moduleName: String?
+    var window: UIWindow?
+    var isConnected = false
+    var interfaceController: AutoPlayInterfaceController?
+    var templateStore = TemplateStore()
+    var traitCollection = UIScreen.main.traitCollection
+    var safeAreaInsets = UIEdgeInsets(top: 0, left: 0, bottom: 0, right: 0)
+
+    override init() {}
+
+    init(moduleName: String) {
+        self.moduleName = moduleName
+        initialProperties["id"] = moduleName
+
+        super.init()
+
+        SceneStore.addScene(moduleName: moduleName, scene: self)
+    }
+
+    func connect(props: [String: Any]) {
+        isConnected = true
+
+        initialProperties = initialProperties.merging(props) { current, _ in
+            current
+        }
+
+        if let window = self.window {
+            ViewUtils.showLaunchScreen(window: window)
+            safeAreaInsets = window.safeAreaInsets
+        }
+    }
+
+    func disconnect() {
+        #if RCT_NEW_ARCH_ENABLED
+            if let rootView = self.window?.rootViewController?.view
+                as? RCTSurfaceHostingProxyRootView
+            {
+                rootView.surface.stop()
+            }
+        #else
+            if let rootView = self.window?.rootViewController?.view
+                as? RCTRootView
+            {
+                if let contentView = rootView.contentView as? RCTInvalidating {
+                    contentView.invalidate()
+                }
+            }
+        #endif
+
+        self.window = nil
+        isConnected = false
+
+        guard let moduleName = self.moduleName else {
+            return
+        }
+
+        SceneStore.removeScene(moduleName: moduleName)
+    }
+
+    func setState(state: VisibilityState) {
+        self.state = state
+
+        guard let moduleName = self.moduleName else {
+            return
+        }
+
+        HybridAutoPlay.emitRenderState(
+            moduleName: moduleName,
+            state: state
+        )
+    }
+
+    func initRootView() {
+        DispatchQueue.main.async {
+            guard let window = self.window else {
+                return
+            }
+            guard let moduleName = self.moduleName else {
+                return
+            }
+
+            guard
+                let rootView = ViewUtils.getRootView(
+                    moduleName: moduleName,
+                    initialProps: self.initialProperties
+                )
+            else { return }
+
+            window.rootViewController = AutoPlaySceneViewController(
+                view: rootView,
+                moduleName: moduleName
+            )
+            window.makeKeyAndVisible()
+        }
+    }
+
+    open func traitCollectionDidChange(traitCollection: UITraitCollection) {
+        self.traitCollection = traitCollection
+        self.templateStore.traitCollectionDidChange()
+    }
+
+    open func safeAreaInsetsDidChange(safeAreaInsets: UIEdgeInsets) {
+        self.safeAreaInsets = safeAreaInsets
+        HybridAutoPlay.emitSafeAreaInsets(
+            moduleName: moduleName!,
+            safeAreaInsets: safeAreaInsets
+        )
+    }
+}

package/ios/scenes/AutoPlaySceneViewController.swift

@@ -0,0 +1,36 @@
+//
+//  CarPlayViewController.swift
+//
+//  Created by Manuel Auer on 30.09.25.
+//
+
+class AutoPlaySceneViewController: UIViewController {
+    let moduleName: String
+
+    public init(view: UIView, moduleName: String) {
+        self.moduleName = moduleName
+
+        super.init(nibName: nil, bundle: nil)
+
+        self.view = view
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func traitCollectionDidChange(
+        _ previousTraitCollection: UITraitCollection?
+    ) {
+        SceneStore.getScene(moduleName: moduleName)!.traitCollectionDidChange(
+            traitCollection: traitCollection
+        )
+    }
+
+    override func viewDidLayoutSubviews() {
+        super.viewDidLayoutSubviews()
+        SceneStore.getScene(moduleName: moduleName)!.safeAreaInsetsDidChange(
+            safeAreaInsets: self.view.safeAreaInsets
+        )
+    }
+}

package/ios/scenes/ClusterSceneDelegate.swift

@@ -0,0 +1,174 @@
+//
+//  ClusterScene.swift
+//
+//  Created by Manuel Auer on 28.09.25.
+//
+
+import CarPlay
+import UIKit
+
+@available(iOS 15.4, *)
+@objc(ClusterSceneDelegate)
+class ClusterSceneDelegate: AutoPlayScene,
+    CPTemplateApplicationInstrumentClusterSceneDelegate,
+    CPInstrumentClusterControllerDelegate
+{
+    var clusterId = UUID().uuidString
+    var instrumentClusterController: CPInstrumentClusterController?
+    var attributedInactiveDescriptionVariants: [NitroAttributedString] = []
+
+    override init() {
+        super.init(moduleName: clusterId)
+    }
+
+    // MARK: CPTemplateApplicationInstrumentClusterSceneDelegate
+    func templateApplicationInstrumentClusterScene(
+        _ templateApplicationInstrumentClusterScene:
+            CPTemplateApplicationInstrumentClusterScene,
+        didConnect instrumentClusterController: CPInstrumentClusterController
+    ) {
+        instrumentClusterController.delegate = self
+        self.instrumentClusterController = instrumentClusterController
+        self.traitCollection = UITraitCollection(
+            userInterfaceStyle: templateApplicationInstrumentClusterScene
+                .contentStyle
+        )
+        HybridCluster.emit(event: .didconnect, clusterId: clusterId)
+    }
+
+    func templateApplicationInstrumentClusterScene(
+        _ templateApplicationInstrumentClusterScene:
+            CPTemplateApplicationInstrumentClusterScene,
+        didDisconnectInstrumentClusterController instrumentClusterController:
+            CPInstrumentClusterController
+    ) {
+        disconnect()
+        HybridCluster.emit(event: .diddisconnect, clusterId: clusterId)
+    }
+
+    func contentStyleDidChange(_ contentStyle: UIUserInterfaceStyle) {
+        traitCollection = UITraitCollection(userInterfaceStyle: contentStyle)
+        applyAttributedInactiveDescriptionVariants()
+        HybridCluster.emitColorScheme(
+            clusterId: clusterId,
+            colorScheme: traitCollection.userInterfaceStyle == .dark
+                ? .dark : .light
+        )
+    }
+
+    // MARK: CPInstrumentClusterControllerDelegate
+    func instrumentClusterControllerDidConnect(
+        _ instrumentClusterWindow: UIWindow
+    ) {
+        self.window = instrumentClusterWindow
+
+        let isCompassEnabled =
+            instrumentClusterController?.compassSetting != .disabled
+        let isSpeedLimitEnabled =
+            instrumentClusterController?.speedLimitSetting != .disabled
+
+        self.traitCollection = UITraitCollection(
+            userInterfaceStyle: instrumentClusterWindow.traitCollection
+                .userInterfaceStyle
+        )
+
+        let props: [String: Any] = [
+            "colorScheme": self.traitCollection.userInterfaceStyle == .dark
+                ? "dark" : "light",
+            "window": [
+                "height": instrumentClusterWindow.screen.bounds.size.height.rounded(),
+                "width": instrumentClusterWindow.screen.bounds.size.width.rounded(),
+                "scale": instrumentClusterWindow.screen.scale,
+            ],
+            "compass": isCompassEnabled,
+            "speedLimit": isSpeedLimitEnabled,
+        ]
+
+        connect(props: props)
+        HybridCluster.emit(event: .didconnectwithwindow, clusterId: clusterId)
+    }
+
+    func instrumentClusterControllerDidDisconnectWindow(
+        _ instrumentClusterWindow: UIWindow
+    ) {
+        // only the window disconnected but it could come back so do not call disconnect in here
+        self.window = nil
+        HybridCluster.emit(
+            event: .diddisconnectfromwindow,
+            clusterId: clusterId
+        )
+    }
+
+    func instrumentClusterControllerDidZoom(
+        in instrumentClusterController: CPInstrumentClusterController
+    ) {
+        HybridCluster.emitZoom(clusterId: clusterId, payload: .in)
+    }
+
+    func instrumentClusterControllerDidZoomOut(
+        _ instrumentClusterController: CPInstrumentClusterController
+    ) {
+        HybridCluster.emitZoom(clusterId: clusterId, payload: .out)
+    }
+
+    func instrumentClusterController(
+        _ instrumentClusterController: CPInstrumentClusterController,
+        didChangeCompassSetting compassSetting: CPInstrumentClusterSetting
+    ) {
+        let isEnabled = compassSetting != .disabled
+        HybridCluster.emitCompass(clusterId: clusterId, payload: isEnabled)
+    }
+
+    func instrumentClusterController(
+        _ instrumentClusterController: CPInstrumentClusterController,
+        didChangeSpeedLimitSetting speedLimitSetting: CPInstrumentClusterSetting
+    ) {
+        let isEnabled = speedLimitSetting != .disabled
+        HybridCluster.emitSpeedLimit(clusterId: clusterId, payload: isEnabled)
+    }
+
+    // MARK: AutoPlayScene
+    override func traitCollectionDidChange(traitCollection: UITraitCollection) {
+        super.traitCollectionDidChange(traitCollection: traitCollection)
+        applyAttributedInactiveDescriptionVariants()
+        HybridCluster.emitColorScheme(
+            clusterId: clusterId,
+            colorScheme: traitCollection.userInterfaceStyle == .dark
+                ? .dark : .light
+        )
+    }
+
+    func sceneWillResignActive(_ scene: UIScene) {
+        setState(state: .willdisappear)
+    }
+
+    func sceneDidEnterBackground(_ scene: UIScene) {
+        setState(state: .diddisappear)
+    }
+
+    func sceneWillEnterForeground(_ scene: UIScene) {
+        setState(state: .willappear)
+    }
+
+    func sceneDidBecomeActive(_ scene: UIScene) {
+        setState(state: .didappear)
+    }
+
+    // MARK: ClusterSceneDelegate
+    func setAttributedInactiveDescriptionVariants(
+        attributedInactiveDescriptionVariants:
+            [NitroAttributedString]
+    ) {
+        self.attributedInactiveDescriptionVariants =
+            attributedInactiveDescriptionVariants
+        applyAttributedInactiveDescriptionVariants()
+    }
+
+    func applyAttributedInactiveDescriptionVariants() {
+        instrumentClusterController?.attributedInactiveDescriptionVariants =
+            Parser.parseAttributedStrings(
+                attributedStrings: attributedInactiveDescriptionVariants,
+                traitCollection: traitCollection
+            )
+    }
+}

package/ios/scenes/DashboardSceneDelegate.swift

@@ -0,0 +1,128 @@
+//
+//  DashboardSceneDelegate.swift
+//
+//  Created by Manuel Auer on 28.09.25.
+//
+
+import CarPlay
+import UIKit
+
+@objc(DashboardSceneDelegate)
+class DashboardSceneDelegate: AutoPlayScene,
+    CPTemplateApplicationDashboardSceneDelegate
+{
+    var dashboardController: CPDashboardController?
+    var templateApplicationDashboardScene: CPTemplateApplicationDashboardScene?
+    let launchHeadUnitSceneUrl: URL?
+
+    override init() {
+        if let bundleIdentifier = Bundle.main.bundleIdentifier {
+            launchHeadUnitSceneUrl = URL(
+                string: "\(bundleIdentifier)://\(UUID())"
+            )
+        } else {
+            launchHeadUnitSceneUrl = nil
+        }
+
+        super.init(moduleName: SceneStore.dashboardModuleName)
+    }
+
+    func templateApplicationDashboardScene(
+        _ templateApplicationDashboardScene:
+            CPTemplateApplicationDashboardScene,
+        didConnect dashboardController: CPDashboardController,
+        to window: UIWindow
+    ) {
+        self.window = window
+        self.dashboardController = dashboardController
+        self.templateApplicationDashboardScene =
+            templateApplicationDashboardScene
+        self.traitCollection =
+            templateApplicationDashboardScene.dashboardWindow
+            .traitCollection
+
+        let props: [String: Any] = [
+            "colorScheme": traitCollection
+                .userInterfaceStyle == .dark ? "dark" : "light",
+            "window": [
+                // TODO: height & with reported from main screen it seems...
+                "height": window.screen.bounds.size.height.rounded(),
+                "width": window.screen.bounds.size.width.rounded(),
+                "scale": traitCollection.displayScale,
+            ],
+        ]
+
+        connect(props: props)
+        HybridCarPlayDashboard.emit(event: .didconnect)
+    }
+
+    func templateApplicationDashboardScene(
+        _ templateApplicationDashboardScene:
+            CPTemplateApplicationDashboardScene,
+        didDisconnect dashboardController: CPDashboardController,
+        from window: UIWindow
+    ) {
+        disconnect()
+        HybridCarPlayDashboard.emit(event: .diddisconnect)
+
+        self.dashboardController = nil
+    }
+
+    func sceneWillResignActive(_ scene: UIScene) {
+        setState(state: .willdisappear)
+    }
+
+    func sceneDidEnterBackground(_ scene: UIScene) {
+        setState(state: .diddisappear)
+    }
+
+    func sceneWillEnterForeground(_ scene: UIScene) {
+        setState(state: .willappear)
+    }
+
+    func sceneDidBecomeActive(_ scene: UIScene) {
+        setState(state: .didappear)
+    }
+
+    @MainActor
+    func setButtons(buttons: [NitroCarPlayDashboardButton]) {
+        guard
+            let traitCollection = templateApplicationDashboardScene?
+                .dashboardWindow.traitCollection
+        else { return }
+
+        dashboardController?.shortcutButtons = buttons.map { button in
+            CPDashboardButton(
+                titleVariants: button.titleVariants,
+                subtitleVariants: button.subtitleVariants,
+                image: Parser.parseNitroImage(
+                    image: button.image,
+                    traitCollection: traitCollection
+                )!
+            ) { _ in
+                button.onPress()
+                if button.launchHeadUnitScene == true {
+                    guard let url = self.launchHeadUnitSceneUrl
+                    else { return }
+                    self.templateApplicationDashboardScene?.open(
+                        url,
+                        options: .none
+                    )
+                }
+            }
+        }
+    }
+
+    override func traitCollectionDidChange(traitCollection: UITraitCollection) {
+        super.traitCollectionDidChange(traitCollection: traitCollection)
+        HybridCarPlayDashboard.emitColorScheme(
+            colorScheme: traitCollection.userInterfaceStyle == .dark
+                ? .dark : .light
+        )
+
+        // dashboard and root run on the same screen so the trait collection needs to be synced
+        SceneStore.getRootScene()?.traitCollectionDidChange(
+            traitCollection: traitCollection
+        )
+    }
+}