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

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