@iternio/react-native-auto-play 0.0.1

package/ios/templates/SearchTemplate.swift

@@ -0,0 +1,170 @@
+//
+//  SearchTemplate.swift
+//  Pods
+//
+//  Created by Samuel Brucksch on 28.10.25.
+//
+
+import CarPlay
+
+class SearchTemplate: AutoPlayTemplate, CPSearchTemplateDelegate {
+    var config: SearchTemplateConfig
+
+    var completionHandler: (([CPListItem]) -> Void)?
+
+    var pushedListTemplate: ListTemplate?
+
+    var searchText = ""
+
+    var isInitialized = false
+
+    init(config: SearchTemplateConfig) {
+        self.config = config
+        let template = CPSearchTemplate(id: config.id)
+
+        super.init(
+            template: template,
+            header: config.headerActions,
+            autoDismissMs: config.autoDismissMs
+        )
+    }
+
+    func updateSearchResults(results: NitroSection) {
+        config.results = results
+        invalidate()
+    }
+
+    override func invalidate() {
+        // if we have pushed a list template update it
+        if let listTemplate = pushedListTemplate {
+            listTemplate.updateSections(sections: [config.results])
+        }
+
+        // otherwise update the search results on the search template
+        guard let completionHandler = self.completionHandler else {
+            return
+        }
+
+        let listItems = Parser.parseSearchResults(
+            section: config.results,
+            traitCollection: SceneStore.getRootTraitCollection()
+        )
+        completionHandler(listItems)
+
+        self.completionHandler = nil
+    }
+
+    override func onWillAppear(animated: Bool) {
+        self.pushedListTemplate = nil
+        config.onWillAppear?(animated)
+    }
+
+    override func onDidAppear(animated: Bool) {
+        config.onDidAppear?(animated)
+
+        guard let template = self.template as? CPSearchTemplate else {
+            return
+        }
+        template.delegate = self
+    }
+
+    override func onWillDisappear(animated: Bool) {
+        config.onWillDisappear?(animated)
+
+        guard let template = self.template as? CPSearchTemplate else {
+            return
+        }
+        template.delegate = nil
+    }
+
+    override func onDidDisappear(animated: Bool) {
+        config.onDidDisappear?(animated)
+    }
+
+    override func onPopped() {
+        config.onPopped?()
+    }
+
+    // MARK: - CPSearchTemplateDelegate
+
+    func searchTemplate(
+        _ searchTemplate: CPSearchTemplate,
+        updatedSearchText searchText: String,
+        completionHandler: @escaping ([CPListItem]) -> Void
+    ) {
+        self.completionHandler = completionHandler
+
+        if !isInitialized {
+            // this makes sure we show the initial items when opening up the template
+            invalidate()
+            isInitialized = true
+            return
+        }
+
+        if searchText == self.searchText {
+            return
+        }
+
+        self.searchText = searchText
+
+        if pushedListTemplate != nil {
+            return
+        }
+
+        config.onSearchTextChanged(searchText)
+    }
+
+    func searchTemplate(
+        _ searchTemplate: CPSearchTemplate,
+        selectedResult item: CPListItem,
+        completionHandler: @escaping () -> Void
+    ) {
+        item.handler?(item, completionHandler)
+    }
+
+    func searchTemplateSearchButtonPressed(
+        _ searchTemplate: CPSearchTemplate
+    ) {
+
+        // Create a new ListTemplate with the search results
+        let listConfig = ListTemplateConfig(
+            id: "\(config.id)-results",
+            onWillAppear: nil,
+            onWillDisappear: nil,
+            onDidAppear: nil,
+            onDidDisappear: nil,
+            onPopped: nil,
+            autoDismissMs: nil,
+            headerActions: config.headerActions,
+            title: config.title,
+            sections: [config.results],
+            mapConfig: nil
+        )
+
+        let listTemplate = ListTemplate(config: listConfig)
+        self.pushedListTemplate = listTemplate
+
+        // execute callback after creating the template to avoid race condition in updateSearchResults
+        config.onSearchTextSubmitted(searchText)
+
+        // Push the template
+        Task { @MainActor in
+            do {
+                try await RootModule.withSceneAndInterfaceController {
+                    scene,
+                    interfaceController in
+                    scene.templateStore.addTemplate(
+                        template: listTemplate,
+                        templateId: listConfig.id
+                    )
+                    let _ = try await interfaceController.pushTemplate(
+                        listTemplate.template,
+                        animated: true
+                    )
+                }
+            } catch {
+                print("Failed to push list template: \(error)")
+            }
+        }
+    }
+}

package/ios/templates/TemplateStore.swift

@@ -0,0 +1,45 @@
+//
+//  TemplateStore.swift
+//  Pods
+//
+//  Created by Manuel Auer on 03.10.25.
+//
+import CarPlay
+
+class TemplateStore {
+    private var store: [String: AutoPlayTemplate] = [:]
+
+    func getCPTemplate(templateId key: String) -> CPTemplate? {
+        return store[key]?.template
+    }
+
+    func getTemplate(templateId: String) -> AutoPlayTemplate? {
+        return store[templateId]
+    }
+
+    func addTemplate(template: AutoPlayTemplate, templateId: String) {
+        store[templateId] = template
+    }
+
+    func removeTemplate(templateId: String) {
+        store[templateId]?.onPopped()
+
+        store.removeValue(forKey: templateId)
+    }
+
+    func removeTemplates(templateIds: [String]) {
+        templateIds.forEach { templateId in
+            store[templateId]?.onPopped()
+        }
+
+        store = store.filter { !templateIds.contains($0.key) }
+    }
+    
+    func purge() {
+        store = store.filter { !($0.value.template is CPSearchTemplate) }
+    }
+
+    func traitCollectionDidChange() {
+        store.values.forEach { template in template.traitCollectionDidChange() }
+    }
+}

package/ios/utils/RootModule.swift

@@ -0,0 +1,136 @@
+//
+//  RootModule.swift
+//  Pods
+//
+//  Created by Manuel Auer on 09.10.25.
+//
+
+import CarPlay
+
+class RootModule {
+    static func withScene(perform action: @escaping (AutoPlayScene) throws -> Void) throws {
+        guard
+            let scene = SceneStore.getScene(
+                moduleName: SceneStore.rootModuleName
+            )
+        else {
+            throw AutoPlayError.sceneNotFound(
+                "operation failed, \(SceneStore.rootModuleName) scene not found"
+            )
+        }
+        
+        try action(scene)
+    }
+    
+    static func withTemplate(templateId: String, perform action: @escaping (AutoPlayTemplate) throws -> Void) throws {
+        try withScene { scene in
+            guard
+                let template = scene.templateStore.getTemplate(templateId: templateId)
+            else {
+                throw AutoPlayError.templateNotFound(templateId)
+            }
+            
+            try action(template)
+        }
+    }
+    
+    static func withMapTemplate(templateId: String, perform action: @escaping (MapTemplate) throws -> Void) throws {
+        try withTemplate(templateId: templateId) { template in
+            guard let template = template as? MapTemplate else {
+                throw AutoPlayError.invalidTemplateError(
+                    "showNavigationAlert failed, \(templateId) not of instance MapTemplate"
+                )
+            }
+            try action(template)
+        }
+    }
+    
+    @MainActor
+    static func withScene<T>(
+        perform action:
+            @escaping (AutoPlayScene) async throws -> T
+    ) async throws -> T {
+        guard
+            let scene = SceneStore.getScene(
+                moduleName: SceneStore.rootModuleName
+            )
+        else {
+            throw AutoPlayError.sceneNotFound(
+                "operation failed, \(SceneStore.rootModuleName) scene not found"
+            )
+        }
+
+        return try await action(scene)
+    }
+
+    @MainActor
+    static func withSceneAndInterfaceController<T>(
+        perform action:
+            @escaping (AutoPlayScene, AutoPlayInterfaceController) async throws -> T
+    ) async throws -> T {
+        return try await withScene { scene in
+            guard let interfaceController = scene.interfaceController else {
+                throw AutoPlayError.interfaceControllerNotFound(
+                    "operation failed, \(SceneStore.rootModuleName) interfaceController not found"
+                )
+            }
+
+            return try await action(scene, interfaceController)
+        }
+    }
+
+    @MainActor
+    static func withInterfaceController<T>(
+        perform action: @escaping (AutoPlayInterfaceController) async throws -> T
+    ) async throws -> T {
+        try await withSceneAndInterfaceController { _, interfaceController in
+            try await action(interfaceController)
+        }
+    }
+
+    @MainActor
+    static func withTemplateAndInterfaceController<T>(
+        templateId: String,
+        perform action:
+            @escaping (CPTemplate, AutoPlayInterfaceController) async throws -> T
+    ) async throws -> T {
+        return try await withSceneAndInterfaceController {
+            scene,
+            interfaceController in
+            guard
+                let template = scene.templateStore.getCPTemplate(
+                    templateId: templateId
+                )
+            else {
+                throw AutoPlayError.templateNotFound(
+                    "operation failed, \(templateId) template not found"
+                )
+            }
+            return try await action(template, interfaceController)
+        }
+    }
+
+    @MainActor
+    static func withSceneTemplateAndInterfaceController<T>(
+        templateId: String,
+        perform action:
+            @escaping (CPTemplate, AutoPlayScene, AutoPlayInterfaceController)
+            async throws -> T
+    ) async throws -> T {
+        return try await withSceneAndInterfaceController {
+            scene,
+            interfaceController in
+
+            guard
+                let template = scene.templateStore.getCPTemplate(
+                    templateId: templateId
+                )
+            else {
+                throw AutoPlayError.templateNotFound(
+                    "operation failed, \(templateId) template not found"
+                )
+            }
+            return try await action(template, scene, interfaceController)
+        }
+    }
+}

package/ios/utils/SymbolFont.swift

@@ -0,0 +1,199 @@
+//
+//  MaterialSymbols.swift
+//  Pods
+//
+//  Created by Manuel Auer on 04.10.25.
+//
+
+import CoreText
+import UIKit
+
+class SymbolFont {
+    private static let defaultCanvasSize = 32
+
+    private static var isRegistered = false
+    private static var fontName: String?
+
+    static func loadFont() {
+        let podBundle = Bundle(for: SymbolFont.self)
+
+        guard
+            let bundleURL = podBundle.url(
+                forResource: "ReactNativeAutoPlay",
+                withExtension: "bundle"
+            ),
+            let resourceBundle = Bundle(url: bundleURL),
+            let fontURL = resourceBundle.url(
+                forResource: "MaterialSymbolsOutlined-Regular",
+                withExtension: "ttf"
+            )
+        else {
+            return
+        }
+
+        guard let fontData = try? Data(contentsOf: fontURL) as CFData,
+            let provider = CGDataProvider(data: fontData),
+            let font = CGFont(provider)
+        else {
+            return
+        }
+
+        var error: Unmanaged<CFError>?
+        CTFontManagerRegisterGraphicsFont(font, &error)
+        if let error = error?.takeUnretainedValue() {
+            print("Failed to register font: \(error)")
+        } else {
+            print("Font \(font.fullName as String? ?? "unknown") registered")
+        }
+
+        SymbolFont.fontName = font.fullName as? String
+        SymbolFont.isRegistered = true
+    }
+
+    // creates a single color UIImage
+    static func imageFromGlyph(
+        glyph: Double,
+        foregroundColor: UIColor,
+        backgroundColor: UIColor,
+        size: CGFloat,
+        fontScale: CGFloat
+    ) -> UIImage? {
+        if !SymbolFont.isRegistered {
+            SymbolFont.loadFont()
+        }
+
+        guard let fontName = SymbolFont.fontName,
+            let font = UIFont(name: fontName, size: size * fontScale)
+        else {
+            return nil
+        }
+
+        let codepoint = String(UnicodeScalar(UInt32(glyph))!)
+        let canvasSize = CGSize(width: size, height: size)
+        let rect = CGRect(origin: .zero, size: canvasSize)
+
+        let attributes: [NSAttributedString.Key: Any] = [
+            .font: font,
+            .foregroundColor: foregroundColor,
+        ]
+
+        let attrString = NSAttributedString(
+            string: codepoint,
+            attributes: attributes
+        )
+
+        // Start drawing
+        UIGraphicsBeginImageContextWithOptions(canvasSize, false, 0)
+        guard let context = UIGraphicsGetCurrentContext() else {
+            return nil
+        }
+
+        // Fill circular background
+        context.setFillColor(backgroundColor.cgColor)
+        context.fillEllipse(in: rect)
+
+        // Draw glyph
+        let textSize = attrString.size()
+        let x = (canvasSize.width - textSize.width) / 2
+        let y = (canvasSize.height - textSize.height) / 2
+        attrString.draw(at: CGPoint(x: x, y: y))
+
+        let image = UIGraphicsGetImageFromCurrentImageContext()
+        UIGraphicsEndImageContext()
+
+        return image
+    }
+
+    static func imageFromGlyph(
+        glyph: Double,
+        size: CGFloat,
+        foregroundColor: NitroColor,
+        backgroundColor: NitroColor,
+        fontScale: CGFloat,
+        traitCollection: UITraitCollection
+    ) -> UIImage? {
+        guard
+            let lightImage = imageFromGlyph(
+                glyph: glyph,
+                foregroundColor: Parser.doubleToColor(
+                    value: foregroundColor.lightColor
+                ),
+                backgroundColor: Parser.doubleToColor(
+                    value: backgroundColor.lightColor
+                ),
+                size: size,
+                fontScale: fontScale
+            ),
+            let darkImage = imageFromGlyph(
+                glyph: glyph,
+                foregroundColor: Parser.doubleToColor(
+                    value: foregroundColor.darkColor
+                ),
+                backgroundColor: Parser.doubleToColor(
+                    value: backgroundColor.darkColor
+                ),
+                size: size,
+                fontScale: fontScale
+            )
+        else {
+            return nil
+        }
+
+        // Create a UIImageAsset that contains both light and dark variants
+        let imageAsset = UIImageAsset()
+
+        // Register the light image for light trait collection
+        let lightTraits = UITraitCollection(traitsFrom: [
+            UITraitCollection(userInterfaceStyle: .light)
+        ])
+        imageAsset.register(lightImage, with: lightTraits)
+
+        // Register the dark image for dark trait collection
+        let darkTraits = UITraitCollection(traitsFrom: [
+            UITraitCollection(userInterfaceStyle: .dark)
+        ])
+        imageAsset.register(darkImage, with: darkTraits)
+
+        // Return an image from the asset that will automatically switch based on the interface style
+        return imageAsset.image(with: traitCollection)
+    }
+
+    static func imageFromNitroImage(
+        image: GlyphImage?,
+        size: CGFloat = 32,
+        noImageAsset: Bool = false,
+        traitCollection: UITraitCollection
+    ) -> UIImage? {
+        guard let image else { return nil }
+
+        if noImageAsset {
+            let foregroundColor = Parser.doubleToColor(
+                value: traitCollection.userInterfaceStyle == .light
+                    ? image.color.lightColor : image.color.darkColor
+            )
+
+            let backgroundColor = Parser.doubleToColor(
+                value: traitCollection.userInterfaceStyle == .light
+                    ? image.backgroundColor.lightColor
+                    : image.backgroundColor.darkColor
+            )
+
+            return SymbolFont.imageFromGlyph(
+                glyph: image.glyph,
+                foregroundColor: foregroundColor,
+                backgroundColor: backgroundColor,
+                size: size,
+                fontScale: image.fontScale ?? 1.0
+            )
+        }
+
+        return SymbolFont.imageFromGlyph(
+            glyph: image.glyph,
+            size: size,
+            foregroundColor: image.color,
+            backgroundColor: image.backgroundColor,
+            fontScale: image.fontScale ?? 1.0,
+            traitCollection: traitCollection
+        )!
+    }
+}

package/ios/utils/ViewUtils.swift

@@ -0,0 +1,39 @@
+//
+//  RootViewProvider.swift
+//  Pods
+//
+//  Created by Manuel Auer on 01.10.25.
+//
+
+class ViewUtils {
+    // we use reflection to find the method that provides us root views from the app delegate
+    // to avoid issues when importing React_AppDelegate (glog imports break)
+    // or using a common protocol on AppDelegate and react-native-autoplay (c++ interoperability not the same)
+    static func getRootView(moduleName: String, initialProps: [String: Any]) -> UIView? {
+        if let appDelegate = UIApplication.shared.delegate as? NSObject {
+            let selector = NSSelectorFromString("getRootViewForAutoplayWithModuleName:initialProperties:")
+            if appDelegate.responds(to: selector), let methodIMP = appDelegate.method(for: selector) {
+                typealias Func = @convention(c) (AnyObject, Selector, NSString, NSDictionary?) -> UIView?
+                let function = unsafeBitCast(methodIMP, to: Func.self)
+
+                return function(appDelegate, selector, moduleName as NSString, initialProps as NSDictionary)
+            }
+        }
+        
+        return nil
+    }
+    
+    static func showLaunchScreen(window: UIWindow) {
+        if let name = Bundle.main.object(
+            forInfoDictionaryKey: "UILaunchStoryboardName"
+        ) as? String,
+            Bundle.main.path(forResource: name, ofType: "storyboardc")
+                != nil
+        {
+            let storyboard = UIStoryboard(name: name, bundle: nil)
+            window.rootViewController =
+                storyboard.instantiateInitialViewController()
+            window.makeKeyAndVisible()
+        }
+    }
+}

package/lib/AutoPlayHeadlessJsTask.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    registerHeadlessTask: () => void;
+};
+export default _default;

package/lib/AutoPlayHeadlessJsTask.js

@@ -0,0 +1,15 @@
+import { AppRegistry, Platform } from 'react-native';
+import { HybridAutoPlay } from '.';
+const taskProvider = () => () => new Promise((resolve) => {
+    const remove = HybridAutoPlay.addListener('didDisconnect', () => {
+        resolve();
+        remove();
+    });
+});
+const registerHeadlessTask = () => {
+    if (Platform.OS !== 'android') {
+        return;
+    }
+    AppRegistry.registerHeadlessTask('AndroidAutoHeadlessJsTask', taskProvider);
+};
+export default { registerHeadlessTask };

package/lib/components/MapTemplateContext.d.ts

@@ -0,0 +1,7 @@
+import type React from 'react';
+import type { MapTemplate } from '..';
+export declare const MapTemplateContext: React.Context<MapTemplate | null>;
+export declare function MapTemplateProvider({ children, mapTemplate, }: {
+    children: React.ReactNode;
+    mapTemplate: MapTemplate;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/components/MapTemplateContext.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext } from 'react';
+export const MapTemplateContext = createContext(null);
+export function MapTemplateProvider({ children, mapTemplate, }) {
+    return _jsx(MapTemplateContext.Provider, { value: mapTemplate, children: children });
+}

package/lib/components/SafeAreaInsetsContext.d.ts

@@ -0,0 +1,7 @@
+import type React from 'react';
+import { type SafeAreaInsets } from '..';
+export declare const SafeAreaInsetsContext: React.Context<SafeAreaInsets>;
+export declare function SafeAreaInsetsProvider({ children, moduleName, }: {
+    children: React.ReactNode;
+    moduleName: string;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/components/SafeAreaInsetsContext.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useEffect, useState } from 'react';
+import { HybridAutoPlay } from '..';
+const DEFAULT = { top: 0, bottom: 0, left: 0, right: 0 };
+export const SafeAreaInsetsContext = createContext(DEFAULT);
+export function SafeAreaInsetsProvider({ children, moduleName, }) {
+    const [insets, setInsets] = useState(DEFAULT);
+    useEffect(() => {
+        const removeSafeAreaInsetsListener = HybridAutoPlay.addSafeAreaInsetsListener(moduleName, (safeAreaInsets) => {
+            setInsets(safeAreaInsets);
+        });
+        return () => {
+            removeSafeAreaInsetsListener();
+        };
+    }, [moduleName]);
+    return _jsx(SafeAreaInsetsContext.Provider, { value: insets, children: children });
+}

package/lib/components/SafeAreaView.d.ts

@@ -0,0 +1,2 @@
+import { type ViewProps } from 'react-native';
+export declare const SafeAreaView: (props: ViewProps) => import("react/jsx-runtime").JSX.Element;

package/lib/components/SafeAreaView.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { StyleSheet, View } from 'react-native';
+import { useSafeAreaInsets } from '../hooks/useSafeAreaInsets';
+export const SafeAreaView = (props) => {
+    const { style, ...rest } = props;
+    const safeAreaInsets = useSafeAreaInsets();
+    return (_jsx(View, { style: [
+            style,
+            {
+                ...StyleSheet.absoluteFillObject,
+                paddingTop: safeAreaInsets.top,
+                paddingBottom: safeAreaInsets.bottom,
+                paddingRight: safeAreaInsets.right,
+                paddingLeft: safeAreaInsets.left,
+                pointerEvents: 'box-none',
+            },
+        ], ...rest }));
+};