@iternio/react-native-auto-play 0.5.14-beta.1 → 0.6.1

package/ios/templates/GridTemplate.swift

@@ -8,92 +8,92 @@
 import CarPlay
 
 class GridTemplate: AutoPlayHeaderProviding {
-    let template: CPGridTemplate
+    /// `nil` when this template renders as a map panel instead (see `mapPanel`).
+    private(set) var template: CPGridTemplate?
     var config: GridTemplateConfig
 
     var buttons: [NitroGridButton]
 
+    /// Boxed as `Any` since `CPMapPanel` itself is only available on iOS 27+ while this class supports a much lower deployment target.
+    private var mapPanel: Any?
+
+    /// `CPMapPanel.delegate` is `weak`, so this keeps the shared delegate alive for as long as the panel exists. Boxed as `Any` for the same reason as `mapPanel`.
+    private var mapPanelDelegate: Any?
+
     override var autoDismissMs: Double? {
         return config.autoDismissMs
     }
 
-    override func getTemplate() -> CPTemplate {
+    override func getTemplate() throws -> CPTemplate {
+        guard let template else {
+            throw AutoPlayError.templateIsMapPanel(config.id)
+        }
         return template
     }
 
+    override func getPanel() -> Any? {
+        return mapPanel
+    }
+
+    override func getPanelHeaderActions() -> [NitroAction]? {
+        return barButtons
+    }
+
+    override func getPanelMapButtons() -> [NitroMapButton]? {
+        return config.mapConfig?.mapButtons
+    }
+
     init(config: GridTemplateConfig) {
         self.config = config
         buttons = config.buttons
 
-        template = CPGridTemplate(
-            title: Parser.parseText(text: config.title),
-            gridButtons: GridTemplate.parseButtons(buttons: buttons),
-            id: config.id
-        )
+        let title = Parser.parseText(text: config.title)
+
+        if #available(iOS 27.0, *), config.mapConfig != nil {
+            mapPanel = CPMapPanel(
+                title: title,
+                sections: [CPMapPanelSection(title: nil, items: [])],
+                buttonConfiguration: nil
+            )
+        }
+        else {
+            template = CPGridTemplate(
+                title: title,
+                gridButtons: GridTemplate.parseButtons(buttons: buttons),
+                id: config.id
+            )
+        }
 
         super.init()
 
         barButtons = config.headerActions
 
+        if #available(iOS 27.0, *), let mapPanel = mapPanel as? CPMapPanel {
+            let delegate = AutoPlayMapPanelDelegate(template: self, templateId: config.id)
+            mapPanelDelegate = delegate
+            mapPanel.delegate = delegate
+        }
     }
 
     static func parseButtons(buttons: [NitroGridButton]) -> [CPGridButton] {
-        let gridButtonHeight: CGFloat
-
-        if #available(iOS 26.0, *) {
-            gridButtonHeight = CPGridTemplate.maximumGridButtonImageSize.height
-        }
-        else {
-            gridButtonHeight = 44
-        }
-
-        guard let traitCollection = SceneStore.getRootTraitCollection() else {
-            return []
-        }
-
-        return buttons.compactMap { button in
-            var image: UIImage?
-
-            if let glyphImage = button.image.glyphImage {
-                image = SymbolFont.imageFromNitroImage(
-                    image: glyphImage,
-                    size: gridButtonHeight,
-                    traitCollection: traitCollection
-                )
-            }
-
-            if let assetImage = button.image.assetImage {
-                image = Parser.parseAssetImage(
-                    assetImage: assetImage,
-                    traitCollection: traitCollection
-                )
-            }
-
-            if let remoteImage = button.image.remoteImage {
-                image = Parser.parseRemoteImage(
-                    remoteImage: remoteImage,
-                    traitCollection: traitCollection
-                )
-            }
-
-            guard let image = image else { return nil }
-            guard let title = Parser.parseText(text: button.title) else { return nil }
-
-            return CPGridButton(
-                titleVariants: [title],
-                image: image
-            ) { _ in
-                button.onPress()
-            }
-        }
+        guard let traitCollection = SceneStore.getRootTraitCollection() else { return [] }
+        return Parser.parseGridButtons(buttons: buttons, traitCollection: traitCollection)
     }
 
     @MainActor
     override func _invalidate() {
+        if #available(iOS 27.0, *), let mapPanel = mapPanel as? CPMapPanel {
+            let parsedButtons = GridTemplate.parseButtons(buttons: buttons)
+            mapPanel.sections.first?.items = [CPMapPanelItem(gridButtons: parsedButtons)]
+            reapplyPanelBarIfVisible(self, templateId: config.id)
+            return
+        }
+
+        guard let template else { return }
+
         setBarButtons(template: template, barButtons: barButtons)
 
-        let buttons = GridTemplate.parseButtons(buttons: buttons)
-        template.updateGridButtons(buttons)
+        template.updateGridButtons(GridTemplate.parseButtons(buttons: buttons))
     }
 
     override func onWillAppear(animated: Bool) {

package/ios/templates/InformationTemplate.swift

@@ -8,31 +8,69 @@
 import CarPlay
 
 class InformationTemplate: AutoPlayHeaderProviding {
-    let template: CPInformationTemplate
+    /// `nil` when this template renders as a map panel instead (see `mapPanel`).
+    private(set) var template: CPInformationTemplate?
     var config: InformationTemplateConfig
 
     var section: NitroSection
 
+    /// Whether this template renders as a `CPMapPanel` instead of a plain `CPInformationTemplate`.
+    private let usesMapPanel: Bool
+
+    /// Built lazily on the first `_invalidate()` call rather than in `init()`: `CPMapPanel.buttonConfiguration`
+    /// is readonly, so unlike sections it can't be patched in later, and building it needs
+    /// `traitCollection` for the optional symbol button image — only safe to fetch on the
+    /// main thread, which `init()` isn't guaranteed to run on. Boxed as `Any` since `CPMapPanel`
+    /// itself is only available on iOS 27+ while this class supports a much lower deployment target.
+    private var mapPanel: Any?
+
+    /// `CPMapPanel.delegate` is `weak`, so this keeps the shared delegate alive for as long as the panel exists. Boxed as `Any` for the same reason as `mapPanel`.
+    private var mapPanelDelegate: Any?
+
     override var autoDismissMs: Double? {
         return config.autoDismissMs
     }
 
-    override func getTemplate() -> CPTemplate {
+    override func getTemplate() throws -> CPTemplate {
+        guard let template else {
+            throw AutoPlayError.templateIsMapPanel(config.id)
+        }
         return template
     }
 
+    override func getPanel() -> Any? {
+        return mapPanel
+    }
+
+    override func getPanelHeaderActions() -> [NitroAction]? {
+        return barButtons
+    }
+
+    override func getPanelMapButtons() -> [NitroMapButton]? {
+        return config.mapConfig?.mapButtons
+    }
+
     init(config: InformationTemplateConfig) {
         self.config = config
 
         section = config.section
 
-        template = CPInformationTemplate(
-            title: Parser.parseText(text: config.title)!,
-            layout: .leading,
-            items: Parser.parseInformationItems(section: section),
-            actions: Parser.parseInformationActions(actions: config.actions),
-            id: config.id
-        )
+        if #available(iOS 27.0, *) {
+            usesMapPanel = config.mapConfig != nil
+        }
+        else {
+            usesMapPanel = false
+        }
+
+        if !usesMapPanel {
+            template = CPInformationTemplate(
+                title: Parser.parseText(text: config.title)!,
+                layout: .leading,
+                items: Parser.parseInformationItems(section: section),
+                actions: Parser.parseInformationActions(actions: config.actions),
+                id: config.id
+            )
+        }
 
         super.init()
 
@@ -41,6 +79,43 @@ class InformationTemplate: AutoPlayHeaderProviding {
 
     @MainActor
     override func _invalidate() {
+        if usesMapPanel, #available(iOS 27.0, *) {
+            guard let mapPanel = mapPanel as? CPMapPanel else {
+                guard let traitCollection = SceneStore.getRootTraitCollection() else { return }
+
+                // InformationTemplate's actions are only ever set once and never updated
+                // afterwards, so there's nothing to keep in sync with buttonConfiguration later.
+                let panel = CPMapPanel(
+                    title: Parser.parseText(text: config.title),
+                    sections: [
+                        CPMapPanelSection(
+                            title: nil,
+                            items: Parser.parseInformationPanelItems(section: section)
+                        )
+                    ],
+                    buttonConfiguration: Parser.parsePanelButtonConfiguration(
+                        actions: config.actions,
+                        traitCollection: traitCollection
+                    )
+                )
+
+                mapPanel = panel
+
+                let delegate = AutoPlayMapPanelDelegate(template: self, templateId: config.id)
+                mapPanelDelegate = delegate
+                panel.delegate = delegate
+
+                reapplyPanelBarIfVisible(self, templateId: config.id)
+                return
+            }
+
+            mapPanel.sections.first?.items = Parser.parseInformationPanelItems(section: section)
+            reapplyPanelBarIfVisible(self, templateId: config.id)
+            return
+        }
+
+        guard let template else { return }
+
         setBarButtons(template: template, barButtons: barButtons)
         template.items = Parser.parseInformationItems(section: section)
     }

package/ios/templates/ListTemplate.swift

@@ -8,44 +8,99 @@
 import CarPlay
 
 class ListTemplate: AutoPlayHeaderProviding {
-    let template: CPListTemplate
+    /// `nil` when this template renders as a map panel instead (see `mapPanel`).
+    private(set) var template: CPListTemplate?
     var config: ListTemplateConfig
 
     var sections: [NitroSection]?
 
+    /// Boxed as `Any` since `CPMapPanel` itself is only available on
+    /// iOS 27+ while this class supports a much lower deployment target.
+    private var mapPanel: Any?
+
+    /// `CPMapPanel.delegate` is `weak`, so this keeps the shared delegate alive for as long as
+    /// the panel exists. Boxed as `Any` for the same reason as `mapPanel`.
+    private var mapPanelDelegate: Any?
+
     override var autoDismissMs: Double? {
         return config.autoDismissMs
     }
 
-    override func getTemplate() -> CPTemplate {
+    override func getTemplate() throws -> CPTemplate {
+        guard let template else {
+            throw AutoPlayError.templateIsMapPanel(config.id)
+        }
         return template
     }
 
+    override func getPanel() -> Any? {
+        return mapPanel
+    }
+
+    override func getPanelHeaderActions() -> [NitroAction]? {
+        return barButtons
+    }
+
+    override func getPanelMapButtons() -> [NitroMapButton]? {
+        return config.mapConfig?.mapButtons
+    }
+
     init(config: ListTemplateConfig) {
         self.config = config
 
         sections = config.sections
-
-        template = CPListTemplate(
-            title: Parser.parseText(text: config.title),
-            sections: [],
-            assistantCellConfiguration: nil,
-            id: config.id
-        )
+        let title = Parser.parseText(text: config.title)
+
+        if #available(iOS 27.0, *), config.mapConfig != nil {
+            mapPanel = CPMapPanel(
+                title: title,
+                sections: (config.sections ?? []).map { section in
+                    CPMapPanelSection(title: section.title, items: [])
+                },
+                buttonConfiguration: nil
+            )
+        }
+        else {
+            template = CPListTemplate(
+                title: title,
+                sections: [],
+                assistantCellConfiguration: nil,
+                id: config.id
+            )
+        }
 
         super.init()
 
         barButtons = config.headerActions
+
+        if #available(iOS 27.0, *), let mapPanel = mapPanel as? CPMapPanel {
+            let delegate = AutoPlayMapPanelDelegate(template: self, templateId: config.id)
+            mapPanelDelegate = delegate
+            mapPanel.delegate = delegate
+        }
     }
 
     @MainActor
     override func _invalidate() {
-        setBarButtons(template: template, barButtons: barButtons)
-
         guard let traitCollection = SceneStore.getRootTraitCollection() else {
             return
         }
 
+        if #available(iOS 27.0, *), let mapPanel = mapPanel as? CPMapPanel {
+            mapPanel.sections = Parser.parseMapPanelSections(
+                sections: sections,
+                updateSection: self.updateSection(section:sectionIndex:),
+                traitCollection: traitCollection
+            )
+
+            reapplyPanelBarIfVisible(self, templateId: config.id)
+            return
+        }
+
+        guard let template else { return }
+
+        setBarButtons(template: template, barButtons: barButtons)
+
         template.updateSections(
             Parser.parseSections(
                 sections: sections,

package/ios/templates/MapTemplate.swift

@@ -22,6 +22,8 @@ class MapTemplate: AutoPlayHeaderProviding,
     var mapButtons: [NitroMapButton]?
     var visibleTravelEstimate: VisibleTravelEstimate?
 
+    private var optionsPanel: NitroOptionsPanelConfig?
+
     override var autoDismissMs: Double? {
         return config.autoDismissMs
     }
@@ -92,67 +94,6 @@ class MapTemplate: AutoPlayHeaderProviding,
         }
     }
 
-    func parseMapButtons(mapButtons: [NitroMapButton]) -> [CPMapButton] {
-        guard let traitCollection = SceneStore.getRootTraitCollection() else {
-            return []
-        }
-
-        return mapButtons.map { button in
-            if let glyphImage = button.image.glyphImage,
-                let icon = SymbolFont.imageFromNitroImage(
-                    image: glyphImage,
-                    size: CPButtonMaximumImageSize.height,
-                    traitCollection: traitCollection
-                )
-            {
-                return CPMapButton(image: icon) { _ in
-                    if button.type == .pan {
-                        self.onPanButtonPress()
-                        return
-                    }
-                    button.onPress?()
-                }
-            }
-            if let assetImage = button.image.assetImage,
-                let icon = Parser.parseAssetImage(
-                    assetImage: assetImage,
-                    traitCollection: traitCollection
-                )
-            {
-                return CPMapButton(image: icon) { _ in
-                    if button.type == .pan {
-                        self.onPanButtonPress()
-                        return
-                    }
-                    button.onPress?()
-                }
-            }
-            if let remoteImage = button.image.remoteImage,
-                let icon = Parser.parseRemoteImage(
-                    remoteImage: remoteImage,
-                    traitCollection: traitCollection
-                )
-            {
-                return CPMapButton(image: icon) { _ in
-                    if button.type == .pan {
-                        self.onPanButtonPress()
-                        return
-                    }
-                    button.onPress?()
-                }
-            }
-
-            return CPMapButton { _ in
-                if button.type == .pan {
-                    self.onPanButtonPress()
-                    return
-                }
-                button.onPress?()
-            }
-        }
-
-    }
-
     @MainActor
     override func _invalidate() {
         if tripSelectorVisible {
@@ -176,15 +117,35 @@ class MapTemplate: AutoPlayHeaderProviding,
                     button.type != .pan
                 } ?? []
 
-            template.mapButtons = parseMapButtons(mapButtons: mapButtons)
+            template.mapButtons = Parser.parseMapButtons(
+                mapButtons: mapButtons,
+                onPanButtonPress: onPanButtonPress
+            )
 
             return
         }
 
-        setBarButtons(template: template, barButtons: barButtons)
+        // A panel owns the bar buttons while it exists; keep barButtons up to date but don't apply it.
+        let hasPanel: Bool = {
+            if #available(iOS 27.0, *) {
+                return SceneStore.getRootScene()?.interfaceController?.hasPanel ?? false
+            }
+            return false
+        }()
+
+        if !hasPanel {
+            // Restore CarPlay's default auto-hide (disabled while a panel is shown, see panelDidShow).
+            template.automaticallyHidesNavigationBar = true
+            template.hidesButtonsWithNavigationBar = true
+
+            setBarButtons(template: template, barButtons: barButtons)
 
-        if let mapButtons = mapButtons {
-            template.mapButtons = parseMapButtons(mapButtons: mapButtons)
+            if let mapButtons = mapButtons {
+                template.mapButtons = Parser.parseMapButtons(
+                    mapButtons: mapButtons,
+                    onPanButtonPress: onPanButtonPress
+                )
+            }
         }
     }
 
@@ -222,7 +183,7 @@ class MapTemplate: AutoPlayHeaderProviding,
 
         template.tripEstimateStyle = isDark ? .dark : .light
 
-        invalidate()
+        super.traitCollectionDidChange()
     }
 
     // MARK: gestures
@@ -428,6 +389,10 @@ class MapTemplate: AutoPlayHeaderProviding,
             duration: alertConfig.durationMs / 1000
         )
 
+        if #available(iOS 27.0, *) {
+            alert.showsCloseButton = false
+        }
+
         func setNavigationAlert() {
             self.navigationAlert = .init(alert: alert, config: alertConfig)
             template.present(navigationAlert: alert, animated: true)
@@ -496,8 +461,9 @@ class MapTemplate: AutoPlayHeaderProviding,
 
             self.template.leadingNavigationBarButtons = []
             self.template.trailingNavigationBarButtons = []
-            self.template.mapButtons = self.parseMapButtons(
-                mapButtons: mapButtons
+            self.template.mapButtons = Parser.parseMapButtons(
+                mapButtons: mapButtons,
+                onPanButtonPress: self.onPanButtonPress
             )
         }
 
@@ -846,6 +812,7 @@ class MapTemplate: AutoPlayHeaderProviding,
         }
 
         self.navigationSession = template.startNavigationSession(for: trip)
+        applyOptionsPanel()
     }
 
     func stopNavigation() {
@@ -853,6 +820,54 @@ class MapTemplate: AutoPlayHeaderProviding,
         navigationSession = nil
     }
 
+    func updateOptionsPanel(config: NitroOptionsPanelConfig?) {
+        optionsPanel = config
+        applyOptionsPanel()
+    }
+
+    @available(iOS 27.0, *)
+    private func updateOptionsPanelSection(section: NitroSection, sectionIndex: Int) {
+        guard var sections = optionsPanel?.sections, sectionIndex < sections.count else { return }
+
+        // `.first` is the `NitroSection` (list) case of `NitroOptionsPanelSection` — matches
+        // whatever nitrogen assigned the last time `yarn specs` ran, see the ordering note on
+        // `Parser.parseOptionsPanelSections`.
+        sections[sectionIndex] = .first(section)
+        optionsPanel = NitroOptionsPanelConfig(
+            title: optionsPanel?.title,
+            sections: sections,
+            actions: optionsPanel?.actions
+        )
+        applyOptionsPanel()
+    }
+
+    private func applyOptionsPanel() {
+        guard #available(iOS 27.0, *) else { return }
+        guard let navigationSession else { return }
+        guard let optionsPanel else {
+            navigationSession.optionsPanel = nil
+            return
+        }
+        guard let traitCollection = SceneStore.getRootTraitCollection() else { return }
+
+        let sections = Parser.parseOptionsPanelSections(
+            sections: optionsPanel.sections,
+            updateSection: { [weak self] section, sectionIndex in
+                self?.updateOptionsPanelSection(section: section, sectionIndex: sectionIndex)
+            },
+            traitCollection: traitCollection
+        )
+
+        navigationSession.optionsPanel = CPMapPanel(
+            title: Parser.parseText(text: optionsPanel.title),
+            sections: sections,
+            buttonConfiguration: Parser.parsePanelButtonConfiguration(
+                actions: optionsPanel.actions,
+                traitCollection: traitCollection
+            )
+        )
+    }
+
     func setManeuverState(state: ManeuverState) {
         guard #available(iOS 17.4, *) else { return }
         guard let navigationSession = navigationSession else { return }

package/ios/templates/MessageTemplate.swift

@@ -8,25 +8,91 @@
 import CarPlay
 
 class MessageTemplate: AutoPlayTemplate {
-    let template: CPAlertTemplate
+    /// `nil` when this template renders as a map panel instead (see `mapPanel`).
+    private(set) var template: CPAlertTemplate?
     var config: MessageTemplateConfig
 
+    /// Whether this template renders as a `CPMapPanel` instead of a plain `CPAlertTemplate`.
+    private let usesMapPanel: Bool
+
+    /// Built lazily on the first `_invalidate()` call rather than in `init()`, same reasoning as `InformationTemplate`: `CPMapPanel.buttonConfiguration` is readonly and needs `traitCollection` for its optional symbol button image, which isn't safe to fetch off the main thread that `init()` isn't guaranteed to run on. Boxed as `Any` since `CPMapPanel` itself is only available on iOS 27+ while this class supports a much lower deployment target.
+    private var mapPanel: Any?
+
+    /// `CPMapPanel.delegate` is `weak`, so this keeps the shared delegate alive for as long as the panel exists. Boxed as `Any` for the same reason as `mapPanel`.
+    private var mapPanelDelegate: Any?
+
     override var autoDismissMs: Double? {
         return config.autoDismissMs
     }
 
-    override func getTemplate() -> CPTemplate {
+    override func getTemplate() throws -> CPTemplate {
+        guard let template else {
+            throw AutoPlayError.templateIsMapPanel(config.id)
+        }
         return template
     }
 
+    override func getPanel() -> Any? {
+        return mapPanel
+    }
+
+    override func getPanelHeaderActions() -> [NitroAction]? {
+        return config.headerActions
+    }
+
+    override func getPanelMapButtons() -> [NitroMapButton]? {
+        return config.mapConfig?.mapButtons
+    }
+
     init(config: MessageTemplateConfig) {
         self.config = config
 
-        template = CPAlertTemplate(
-            titleVariants: [Parser.parseText(text: config.message)!],
-            actions: Parser.parseAlertActions(alertActions: config.actions),
-            id: config.id
+        if #available(iOS 27.0, *) {
+            usesMapPanel = config.mapConfig != nil
+        }
+        else {
+            usesMapPanel = false
+        }
+
+        if !usesMapPanel {
+            template = CPAlertTemplate(
+                titleVariants: [Parser.parseText(text: config.message)!],
+                actions: Parser.parseAlertActions(alertActions: config.actions),
+                id: config.id
+            )
+        }
+    }
+
+    @MainActor
+    override func _invalidate() {
+        guard usesMapPanel, #available(iOS 27.0, *), mapPanel == nil else { return }
+        guard let traitCollection = SceneStore.getRootTraitCollection() else { return }
+
+        // The message and its actions are only ever set once and never updated afterwards,
+        // so there's nothing to keep in sync with the panel's content later.
+        let panel = CPMapPanel(
+            title: Parser.parseText(text: config.title),
+            sections: [
+                CPMapPanelSection(
+                    title: nil,
+                    items: [
+                        CPMapPanelItem(
+                            listItem: CPListItem(text: Parser.parseText(text: config.message), detailText: nil)
+                        )
+                    ]
+                )
+            ],
+            buttonConfiguration: Parser.parsePanelButtonConfiguration(
+                actions: config.actions,
+                traitCollection: traitCollection
+            )
         )
+
+        mapPanel = panel
+
+        let delegate = AutoPlayMapPanelDelegate(template: self, templateId: config.id)
+        mapPanelDelegate = delegate
+        panel.delegate = delegate
     }
 
     override func onWillAppear(animated: Bool) {