Car App: essence of CarPlay and Android Auto development

What is a Car App

Car App is an application that runs on an in-vehicle infotainment system (IVI) through smartphone projection — Apple CarPlay for iOS and Android Auto for Android. Unlike Android Automotive OS (built-in OS in the car), CarPlay and Android Auto are extensions of a mobile app that run on the phone and project the interface onto the car screen. A Car App is your existing iOS/Android app that implements CarPlay or Android Auto protocols.

Key Car App categories: navigation (Apple Maps, Google Maps, Waze, Sygic), audio (Spotify, Apple Music, YouTube Music, Audible, Castbox), messaging (reading aloud and dictation via Siri/Google Assistant), automotive features (EV charging, parking, vehicle status), VOIP calls (WhatsApp, Zoom). Each category has its own interface template — ListTemplate, MapTemplate, AudioTemplate. The system itself determines which category the app supports based on registered Intents.

Car App limitations: Apple and Google strictly control UX for safety — minimal number of elements, large buttons (minimum 48x48 pt), no text input (voice only), automatic interface dimming while driving, no video. Response time to press must be less than 100 ms. All apps undergo mandatory moderation (App Review for CarPlay, Google Play Console + CTS for Android Auto).

Apple CarPlay: CarPlay framework and SiriKit

CarPlay framework (formerly CPKit) is Apple's framework for creating CarPlay applications in Swift. The key class is CPInterfaceController, which manages template navigation. CPInterfaceController contains a template stack: CPListTemplate (lists), CPMapTemplate (navigation), CPNowPlayingTemplate (audio), CPVoiceControlTemplate (voice control). CPListTemplate contains CPListItem — list items with an icon, text, and action.

SiriKit for CarPlay — a SiriKit extension for voice control of the app in the car. The app registers Intents (INPlayMediaIntent — playback, INStartWorkoutIntent — workout, INSendMessageIntent — messages). Siri automatically activates when CarPlay connects and is available via the voice control button on the steering wheel. SiriKit CarPlay supports CarPlay Dashboard — widgets on the CarPlay home screen for displaying information from the app (destination, current track).

CarPlay connection process: iPhone connects to the car via Lightning/USB-C cable or wirelessly (CarPlay Wireless, starting with iOS 9). After connection, iOS automatically starts a CarPlay session if the app implements CPApplicationDelegate. The developer does not control the connection moment — the system calls delegate methods when the session starts and ends. CarPlay supports multitasking: navigation works in the background when switching to music, and voice prompts continue to sound.

Android Auto: Car App Library

Android Car App Library — an Android library for creating apps compatible with Android Auto. Basic components: CarAppService — entry point for Android Auto; Session — session lifecycle management; Screen — each app screen; CarScreenManager — display management. The app supports MediaBrowserService for media content and NavigationManager for navigation prompts.

MediaBrowserService — a key component for audio apps. The app implements MediaBrowserService and MediaSession to manage playback. Android Auto automatically displays controls (Play/Pause, Next, Previous) and the track list. NavigationManager is used for navigation apps — it relays turn instructions, route status, and alerts. NavigationManager supports CarNotification for displaying navigation prompts in the Android Auto status bar.

Android Auto requirements: the app must have category="android.intent.category.APP_AUTO" in the manifest; it must use AndroidX and minimum SDK 26+; support dark theme (DayNight); support touch and voice control; comply with the Android Auto Compatibility Test Suite (CTS). Google Play checks every app for compliance with safety and UX requirements. The certification process takes 1–4 weeks.

Code Examples: Swift and Kotlin

Example of a navigation app for CarPlay in Swift using the CarPlay framework.

import CarPlay

class CarPlaySceneDelegate: CPTemplateApplicationSceneDelegate {

    func templateApplicationScene(
        _ templateApplicationScene: CPTemplateApplicationScene,
        didConnect interfaceController: CPInterfaceController
    ) {
        let searchItem = CPListItem(
            text: "Search address",
            detailText: "Enter destination"
        )
        searchItem.handler = { _, completion in
            // Open the search screen
            completion()
        }

        let favoritesItem = CPListItem(
            text: "Favorites",
            detailText: "Saved addresses"
        )
        favoritesItem.handler = { _, completion in
            showFavorites()
            completion()
        }

        let section = CPListSection(items: [searchItem, favoritesItem])
        let listTemplate = CPListTemplate(
            title: "Navigation",
            sections: [section]
        )

        interfaceController.setRootTemplate(listTemplate, animated: true)
    }

    func showFavorites() {
        // Display a list of favorite addresses
    }
}

// SiriKit Intent for voice control
class NavigationIntentHandler: NSObject, INSearchForMessagesIntentHandling {
    func handle(intent: INSearchForMessagesIntent,
                completion: @escaping (INSearchForMessagesIntentResponse) -> Void) {
        // Processing a voice command via Siri
        let response = INSearchForMessagesIntentResponse(
            code: .success, userActivity: nil
        )
        completion(response)
    }
}

Key points: CPTemplateApplicationSceneDelegate — entry point for the CarPlay session; CPInterfaceController manages the template stack; CPListTemplate and CPListItem — basic UI components; .handler — click handler for each list item.

Example of a navigation app for Android Auto in Kotlin with Car App Library:

// CarAppService — entry point for Android Auto
class NavigationCarAppService : CarAppService() {
    override fun createSession(): Session = NavigationSession()
}

// Session — session lifecycle management
class NavigationSession : Session() {
    override fun onCreateScreen(manager: ScreenManager): Screen {
        return MainScreen(carContext)
    }
}

// MainScreen — main screen with navigation
class MainScreen(carContext: CarContext) : Screen(carContext) {
    override fun onGetTemplate(): Template {
        val searchAction = Action.Builder()
            .setTitle("Search address")
            .setOnClickListener { showSearchScreen() }
            .build()

        val favoritesAction = Action.Builder()
            .setTitle("Favorites")
            .setOnClickListener { showFavorites() }
            .build()

        return ListTemplate.Builder()
            .setTitle("Navigation")
            .setHeaderAction(Action.APP_ICON)
            .addAction(searchAction)
            .addAction(favoritesAction)
            .build()
    }

    private fun showSearchScreen() {
        screenManager.push(SearchScreen(carContext))
    }

    private fun showFavorites() {
        screenManager.push(FavoritesScreen(carContext))
    }
}

// AndroidManifest — service registration
<service
    android:name=".NavigationCarAppService"
    android:exported="true">
    <intent-filter>
        <action
            android:name="androidx.car.app.action.NAVIGATION" />
    </intent-filter>
    <category
        android:name="android.intent.category.APP_AUTO" />
</service>

Key points: CarAppService — entry point for Android Auto; Session — lifecycle management; Screen — each app screen, returns a Template; ListTemplate — list template with Action; category.APP_AUTO — required category in the manifest.

Requirements and Publishing

Apple CarPlay requirements: the app must comply with CarPlay Distraction Design Guidelines — minimum button size 48x48 pt, text contrast 4.5:1, no animation or video, VoiceOver support. Publishing — via App Store Connect, the app goes through standard Apple moderation. You must specify CarPlay support in App Store Connect and provide CarPlay interface screenshots. CarPlay apps cannot be free without ads — Apple charges a 30% commission (15% for small businesses) on in-app purchases.

Android Auto requirements: the app must comply with Android Auto Design Guidelines and pass the Android Auto Compatibility Test Suite (CTS). Publishing — via Google Play Console, you must specify the "Android Auto" category in the compatible devices list. Google Play checks: dark theme support (DayNight), correct behavior on connection loss, screen rotation handling, voice control support via Google Assistant. Android Auto apps do not require additional commission — the standard Google Play model (15-30%).

Wireless connection support: CarPlay Wireless is available since iOS 9 and requires Wi-Fi + Bluetooth. Android Auto Wireless is available since Android 11. For wireless connection, the car must support the corresponding standard. The developer does not need to write additional code — the OS handles the connection automatically.