@iternio/react-native-auto-play 0.0.1

package/ios/templates/MapTemplate.swift

@@ -0,0 +1,640 @@
+//
+//  MapTemplate.swift
+//  Pods
+//
+//  Created by Manuel Auer on 03.10.25.
+//
+import CarPlay
+
+struct NavigationAlertWrapper {
+    let alert: CPNavigationAlert
+    let config: NitroNavigationAlert
+}
+
+class MapTemplate: AutoPlayTemplate, CPMapTemplateDelegate {
+    var config: MapTemplateConfig
+
+    var onTripSelected: ((_ tripId: String, _ routeId: String) -> Void)?
+    var onTripStarted: ((_ tripId: String, _ routeId: String) -> Void)?
+
+    var navigationSession: CPNavigationSession?
+
+    var navigationAlert: NavigationAlertWrapper?
+
+    var tripSelectorVisible = false {
+        didSet {
+            if !tripSelectorVisible && oldValue {
+                // this makes sure the latest config updates are applied when the trip selector is gone again
+                invalidate()
+            }
+        }
+    }
+
+    init(config: MapTemplateConfig) {
+        self.config = config
+
+        super.init(
+            template: CPMapTemplate(id: config.id),
+            header: config.headerActions,
+            autoDismissMs: config.autoDismissMs
+        )
+
+        if let template = self.template as? CPMapTemplate {
+            template.mapDelegate = self
+        }
+
+        invalidate()
+    }
+
+    func parseMapButtons(mapButtons: [NitroMapButton]) -> [CPMapButton] {
+        return mapButtons.map { button in
+            if let glyphImage = button.image?.glyphImage,
+                let icon = SymbolFont.imageFromNitroImage(
+                    image: glyphImage,
+                    size: CPButtonMaximumImageSize.height,
+                    traitCollection: SceneStore.getRootTraitCollection()
+                )
+            {
+                return CPMapButton(image: icon) { _ in
+                    button.onPress()
+                }
+            }
+            if let assetImage = button.image?.assetImage,
+                let icon = Parser.parseAssetImage(
+                    assetImage: assetImage,
+                    traitCollection: SceneStore.getRootTraitCollection()
+                )
+            {
+                return CPMapButton(image: icon) { _ in
+                    button.onPress()
+                }
+            }
+
+            return CPMapButton { _ in
+                button.onPress()
+            }
+        }
+
+    }
+
+    override func invalidate() {
+        if tripSelectorVisible {
+            // ignore invalidate calls to not break the trip selectors back button
+            return
+        }
+
+        guard let template = self.template as? CPMapTemplate else { return }
+
+        setBarButtons()
+
+        if let mapButtons = config.mapButtons {
+            template.mapButtons = parseMapButtons(mapButtons: mapButtons)
+        }
+    }
+
+    override func onWillAppear(animated: Bool) {
+        config.onWillAppear?(animated)
+    }
+
+    override func onDidAppear(animated: Bool) {
+        config.onDidAppear?(animated)
+    }
+
+    override func onWillDisappear(animated: Bool) {
+        config.onWillDisappear?(animated)
+    }
+
+    override func onDidDisappear(animated: Bool) {
+        config.onDidDisappear?(animated)
+    }
+
+    override func onPopped() {
+        config.onPopped?()
+    }
+
+    override func traitCollectionDidChange() {
+        let traitCollection = SceneStore.getRootTraitCollection()
+        let isDark = traitCollection.userInterfaceStyle == .dark
+
+        self.config.onAppearanceDidChange?(
+            isDark ? .dark : .light
+        )
+        self.invalidate()
+
+        guard let template = self.template as? CPMapTemplate else { return }
+
+        template.tripEstimateStyle = isDark ? .dark : .light
+    }
+
+    // MARK: gestures
+    func mapTemplate(
+        _ mapTemplate: CPMapTemplate,
+        didUpdatePanGestureWithTranslation: CGPoint,
+        velocity: CGPoint
+    ) {
+        config.onDidUpdatePanGestureWithTranslation?(
+            Point(
+                x: didUpdatePanGestureWithTranslation.x,
+                y: didUpdatePanGestureWithTranslation.y
+            ),
+            Point(x: velocity.x, y: velocity.y)
+        )
+    }
+
+    func mapTemplate(
+        _ mapTemplate: CPMapTemplate,
+        didUpdateZoomGestureWithCenter center: CGPoint,
+        scale: CGFloat,
+        velocity: CGFloat
+    ) {
+        if scale == 1 && velocity == 1 {
+            config.onDoubleClick?(Point(x: center.x, y: center.y))
+            return
+        }
+
+        config.onDidUpdateZoomGestureWithCenter?(
+            Point(x: center.x, y: center.y),
+            1 - velocity * 0.1
+        )
+    }
+
+    // MARK: maneuver style
+    func mapTemplate(
+        _ mapTemplate: CPMapTemplate,
+        displayStyleFor maneuver: CPManeuver
+    ) -> CPManeuverDisplayStyle {
+        if maneuver.attributedInstructionVariants.count == 0
+            && maneuver.instructionVariants.count == 0
+        {
+            return .symbolOnly
+        }
+        return .leadingSymbol
+    }
+
+    // MARK: navigation events
+    func mapTemplateDidCancelNavigation(_ mapTemplate: CPMapTemplate) {
+        config.onStopNavigation()
+    }
+
+    func mapTemplateShouldProvideNavigationMetadata(
+        _ mapTemplate: CPMapTemplate
+    ) -> Bool {
+        // this enables the "standard cluster" & "head up display" maneuvers
+        return true
+    }
+
+    //MARK: notifications
+    func mapTemplate(
+        _ mapTemplate: CPMapTemplate,
+        shouldShowNotificationFor maneuver: CPManeuver
+    ) -> Bool {
+        return false
+    }
+
+    func mapTemplate(
+        _ mapTemplate: CPMapTemplate,
+        shouldUpdateNotificationFor maneuver: CPManeuver,
+        with travelEstimates: CPTravelEstimates
+    ) -> Bool {
+        return false
+    }
+
+    func mapTemplate(
+        _ mapTemplate: CPMapTemplate,
+        shouldShowNotificationFor navigationAlert: CPNavigationAlert
+    ) -> Bool {
+        return false
+    }
+
+    // MARK: alerts
+    func mapTemplate(
+        _ mapTemplate: CPMapTemplate,
+        willShow navigationAlert: CPNavigationAlert
+    ) {
+        self.navigationAlert?.config.onWillShow?()
+    }
+
+    func mapTemplate(
+        _ mapTemplate: CPMapTemplate,
+        didDismiss navigationAlert: CPNavigationAlert,  // this seems to be currentNavigationAlert when an alert is dismissed due to pushing a new one
+        dismissalContext: CPNavigationAlert.DismissalContext
+    ) {
+        // Helper to get dismissal reason from context
+        let dismissalReason: AlertDismissalReason = {
+            switch dismissalContext {
+            case .userDismissed: return .user
+            case .timeout: return .timeout
+            case .systemDismissed: return .system
+            }
+        }()
+
+        self.navigationAlert?.config.onDidDismiss?(dismissalReason)
+        self.navigationAlert = nil
+    }
+
+    func showAlert(alertConfig: NitroNavigationAlert) {
+        guard let template = self.template as? CPMapTemplate else { return }
+
+        if let priority = self.navigationAlert?.config.priority,
+            priority > alertConfig.priority
+        {
+            return
+        }
+
+        let title = Parser.parseText(text: alertConfig.title)!
+        let subtitle = alertConfig.subtitle.map { subtitle in
+            [Parser.parseText(text: subtitle)!]
+        }
+
+        let image = Parser.parseNitroImage(
+            image: alertConfig.image,
+            traitCollection: SceneStore.getRootTraitCollection()
+        )
+
+        let style = Parser.parseActionAlertStyle(
+            style: alertConfig.primaryAction.style
+        )
+        let primaryAction = CPAlertAction(
+            title: alertConfig.primaryAction.title,
+            style: style
+        ) { _ in
+            alertConfig.primaryAction.onPress()
+        }
+
+        let secondaryAction = alertConfig.secondaryAction.map { action in
+            let style = Parser.parseActionAlertStyle(style: action.style)
+            return CPAlertAction(title: action.title, style: style) { _ in
+                action.onPress()
+            }
+        }
+
+        let alert = CPNavigationAlert(
+            titleVariants: [title],
+            subtitleVariants: subtitle,
+            image: image,
+            primaryAction: primaryAction,
+            secondaryAction: secondaryAction,
+            duration: alertConfig.durationMs / 1000,
+        )
+
+        func setNavigationAlert() {
+            self.navigationAlert = .init(alert: alert, config: alertConfig)
+            template.present(navigationAlert: alert, animated: true)
+        }
+
+        if template.currentNavigationAlert != nil {
+            template.dismissNavigationAlert(animated: true) { _ in
+                setNavigationAlert()
+            }
+        } else {
+            setNavigationAlert()
+        }
+    }
+    
+    func updateNavigationAlert(alertId: Double, title: AutoText, subtitle: AutoText?) {
+        guard let alert = self.navigationAlert?.alert else {
+            return
+        }
+        
+        if self.navigationAlert?.config.id != alertId {
+            return
+        }
+        
+        let title = Parser.parseText(text: title)!
+        let subtitle = subtitle.map { subtitle in
+            [Parser.parseText(text: subtitle)!]
+        } ?? []
+        
+        alert.updateTitleVariants([title], subtitleVariants: subtitle)
+    }
+
+    func dismissNavigationAlert(alertId: Double) {
+        if let id = self.navigationAlert?.config.id, id != alertId {
+            return
+        }
+
+        guard let template = self.template as? CPMapTemplate else { return }
+        template.dismissNavigationAlert(animated: true) { _ in }
+    }
+
+    // MARK: trip selection
+    func showTripSelector(
+        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 {
+        guard let template = self.template as? CPMapTemplate else {
+            throw AutoPlayError.invalidTemplateError(
+                template.id + " template not of type map template"
+            )
+        }
+
+        self.onTripSelected = onTripSelected
+        self.onTripStarted = onTripStarted
+
+        let textConfiguration = Parser.parseTripPreviewTextConfig(
+            textConfig: textConfig
+        )
+
+        let tripPreviews = Parser.parseTrips(trips: trips)
+        let selectedTrip = selectedTripId.flatMap { tripId in
+            tripPreviews.first(where: { $0.id == tripId })
+        }
+
+        template.backButton = CPBarButton(title: "") { _ in
+            self.hideTripSelector()
+
+            onBackPressed()
+        }
+        template.leadingNavigationBarButtons = []
+        template.trailingNavigationBarButtons = []
+        template.mapButtons = parseMapButtons(mapButtons: mapButtons)
+
+        template.showTripPreviews(
+            tripPreviews,
+            selectedTrip: selectedTrip,
+            textConfiguration: textConfiguration
+        )
+
+        tripSelectorVisible = true
+
+        tripPreviews.forEach { trip in
+            guard
+                let travelEstimates = trip.routeChoices.first?
+                    .travelEstimates.last
+            else { return }
+
+            template.updateEstimates(travelEstimates, for: trip)
+        }
+
+        let callback = TripSelectorCallback { tripId in
+            let selectedTrip = tripPreviews.first { trip in
+                trip.id == tripId
+            }
+            template.showTripPreviews(
+                tripPreviews,
+                selectedTrip: selectedTrip,
+                textConfiguration: textConfiguration
+            )
+        }
+
+        return callback
+    }
+
+    func hideTripSelector() {
+        guard let template = self.template as? CPMapTemplate else { return }
+
+        template.hideTripPreviews()
+
+        self.tripSelectorVisible = false
+        self.onTripSelected = nil
+        self.onTripStarted = nil
+    }
+
+    func mapTemplate(
+        _ mapTemplate: CPMapTemplate,
+        selectedPreviewFor trip: CPTrip,
+        using routeChoice: CPRouteChoice
+    ) {
+        let tripId = trip.id
+        let routeId = routeChoice.id
+        self.onTripSelected?(tripId, routeId)
+
+        if let travelEstimates = trip.routeChoices.first(where: {
+            $0.id == routeId
+        })?.travelEstimates.last {
+            mapTemplate.updateEstimates(travelEstimates, for: trip)
+        }
+    }
+
+    func mapTemplate(
+        _ mapTemplate: CPMapTemplate,
+        startedTrip trip: CPTrip,
+        using routeChoice: CPRouteChoice
+    ) {
+        if let onTripStarted = self.onTripStarted {
+            let tripId = trip.id
+            let routeId = routeChoice.id
+
+            onTripStarted(tripId, routeId)
+        }
+
+        hideTripSelector()
+
+        let trip = CPTrip(
+            origin: trip.origin,
+            destination: trip.destination,
+            routeChoices: [routeChoice],
+            id: trip.id
+        )
+
+        startNavigation(trip: trip)
+    }
+
+    func updateVisibleTravelEstimate(
+        visibleTravelEstimate: VisibleTravelEstimate?
+    ) {
+        guard let template = self.template as? CPMapTemplate else { return }
+
+        if let visibleTravelEstimate = visibleTravelEstimate {
+            config.visibleTravelEstimate = visibleTravelEstimate
+        }
+
+        guard let trip = navigationSession?.trip else { return }
+
+        let travelEstaimtes = trip.routeChoices.first?
+            .travelEstimates
+        if let estimates = config.visibleTravelEstimate == .first
+            ? travelEstaimtes?.first : travelEstaimtes?.last
+        {
+            template.updateEstimates(estimates, for: trip)
+        }
+
+    }
+
+    func updateTravelEstimates(steps: [TripPoint]) {
+        guard let route = navigationSession?.trip.routeChoices.first else {
+            return
+        }
+
+        if var userInfo = route.userInfo as? [String: Any?] {
+            userInfo["travelEstimates"] = steps.map { step in
+                Parser.parseTravelEstiamtes(
+                    travelEstimates: step.travelEstimates
+                )
+            }
+            route.userInfo = userInfo
+        }
+
+        updateVisibleTravelEstimate(visibleTravelEstimate: nil)
+    }
+
+    func updateManeuvers(messageManeuver: NitroMessageManeuver) {
+        guard let template = template as? CPMapTemplate else { return }
+        guard let navigationSession = navigationSession else { return }
+
+        let color = messageManeuver.cardBackgroundColor
+        let cardBackgroundColor = Parser.parseColor(color: color)
+
+        let maneuver = CPManeuver(id: messageManeuver.title)
+
+        if #available(iOS 15.4, *) {
+            maneuver.cardBackgroundColor = cardBackgroundColor
+        } else {
+            template.guidanceBackgroundColor = cardBackgroundColor
+        }
+
+        maneuver.instructionVariants = [messageManeuver.title]
+
+        if let symbolImage = Parser.parseNitroImage(
+            image: messageManeuver.image,
+            traitCollection: SceneStore.getRootTraitCollection()
+        ) {
+            maneuver.symbolImage = symbolImage
+        }
+
+        if #available(iOS 17.4, *) {
+            navigationSession.add([maneuver])
+        }
+
+        navigationSession.upcomingManeuvers = [maneuver]
+    }
+
+    func updateManeuvers(maneuvers: [NitroRoutingManeuver]) {
+        guard let template = template as? CPMapTemplate else { return }
+        guard let navigationSession = navigationSession else { return }
+
+        if #unavailable(iOS 15.4),
+            let color = maneuvers.first?.cardBackgroundColor
+        {
+            // before iOS 15.4 the color had to be set on the template
+            // later on the maneuer which Parser.parseManeuver does
+            template.guidanceBackgroundColor = Parser.parseColor(color: color)
+        }
+
+        var upcomingManeuvers: [CPManeuver] = []
+
+        let sessionManeuvers = navigationSession.upcomingManeuvers.filter {
+            maneuver in
+            !maneuver.isSecondary
+        }
+
+        for (index, nitroManeuver) in maneuvers.enumerated() {
+            if let maneuverIndex =
+                sessionManeuvers
+                .firstIndex(where: { $0.id == nitroManeuver.id })
+            {
+                navigationSession.updateEstimates(
+                    Parser.parseTravelEstiamtes(
+                        travelEstimates: nitroManeuver.travelEstimates
+                    ),
+                    for: navigationSession.upcomingManeuvers[maneuverIndex]
+                )
+
+                if index != maneuverIndex {
+                    let maneuver = navigationSession.upcomingManeuvers.first(
+                        where: { $0.id == nitroManeuver.id }
+                    )!
+                    upcomingManeuvers.append(maneuver)
+                }
+                continue
+            }
+
+            let maneuver = Parser.parseManeuver(
+                nitroManeuver: nitroManeuver,
+                traitCollection: SceneStore.getRootTraitCollection()
+            )
+            upcomingManeuvers.append(maneuver)
+        }
+
+        if upcomingManeuvers.count > 0 {
+            if #available(iOS 17.4, *) {
+                upcomingManeuvers = upcomingManeuvers.flatMap { maneuver in
+                    if let laneImages = maneuver.laneImages {
+                        // CarPlay has a limitation of 120x18 for the symbolImage on secondaryManeuver that shows lanes only
+                        let secondarySymbolImage = Parser.imageFromLanes(
+                            laneImages: laneImages.prefix(Int(120 / 18)),
+                            traitCollection: SceneStore.getRootTraitCollection()
+                        )
+
+                        let secondaryManeuver = CPManeuver(
+                            id: maneuver.id + "-lanes",
+                            isSecondary: true
+                        )
+                        secondaryManeuver.symbolImage = secondarySymbolImage
+                        secondaryManeuver.cardBackgroundColor =
+                            maneuver.cardBackgroundColor
+                        return [maneuver, secondaryManeuver]
+                    } else {
+                        return [maneuver]
+                    }
+                }
+
+                navigationSession.add(
+                    upcomingManeuvers.filter({ maneuver in
+                        !navigationSession.upcomingManeuvers.contains(where: {
+                            $0.id == maneuver.id
+                        })
+                    })
+                )
+
+                let laneGuidances = upcomingManeuvers.compactMap {
+                    $0.laneGuidance
+                }
+                if laneGuidances.isEmpty {
+                    navigationSession.currentLaneGuidance = nil
+                } else {
+                    navigationSession.add(laneGuidances)
+                    navigationSession.currentLaneGuidance = laneGuidances.first
+                }
+
+                if let roadFollowingManeuverVariants = upcomingManeuvers.first?
+                    .roadFollowingManeuverVariants
+                {
+                    navigationSession.currentRoadNameVariants =
+                        roadFollowingManeuverVariants
+                }
+            }
+
+            navigationSession.upcomingManeuvers = upcomingManeuvers
+        }
+    }
+
+    func startNavigation(trip: CPTrip) {
+        guard let template = self.template as? CPMapTemplate else { return }
+
+        let routeChoice = trip.routeChoices.first
+
+        if let travelEstimates = config.visibleTravelEstimate == .first
+            ? routeChoice?.travelEstimates.first
+            : routeChoice?.travelEstimates.last
+        {
+            template.updateEstimates(travelEstimates, for: trip)
+        }
+
+        if let navigationSession = self.navigationSession {
+            let knownTripIds = navigationSession.trip.routeChoices.map { $0.id }
+            let incomingTripIds = trip.routeChoices.map { $0.id }
+
+            if navigationSession.trip.id == trip.id
+                && knownTripIds == incomingTripIds
+            {
+                // in case startNavigation is called with the exact same ids we can ignore the call
+                return
+            }
+
+            navigationSession.finishTrip()
+        }
+
+        self.navigationSession = template.startNavigationSession(for: trip)
+    }
+
+    func stopNavigation() {
+        navigationSession?.finishTrip()
+        navigationSession = nil
+    }
+}

package/ios/templates/MessageTemplate.swift

@@ -0,0 +1,48 @@
+//
+//  MessageTemplate.swift
+//  Pods
+//
+//  Created by Samuel Brucksch on 17.10.25.
+//
+
+import CarPlay
+
+class MessageTemplate: AutoPlayTemplate {
+    var config: MessageTemplateConfig
+
+    init(config: MessageTemplateConfig) {
+        self.config = config
+
+        let template = CPAlertTemplate(
+            titleVariants: [Parser.parseText(text: config.message)!],
+            actions: Parser.parseAlertActions(alertActions: config.actions),
+            id: config.id
+        )
+
+        super.init(
+            template: template,
+            header: config.headerActions,
+            autoDismissMs: config.autoDismissMs
+        )
+    }
+
+    override func onWillAppear(animated: Bool) {
+        config.onWillAppear?(animated)
+    }
+
+    override func onDidAppear(animated: Bool) {
+        config.onDidAppear?(animated)
+    }
+
+    override func onWillDisappear(animated: Bool) {
+        config.onWillDisappear?(animated)
+    }
+
+    override func onDidDisappear(animated: Bool) {
+        config.onDidDisappear?(animated)
+    }
+
+    override func onPopped() {
+        config.onPopped?()
+    }
+}