Car App : essence du développement pour CarPlay et Android Auto

Qu'est-ce que Car App

Car App est une application qui fonctionne sur le système d'info-divertissement du véhicule (IVI) via la projection du smartphone — Apple CarPlay pour iOS et Android Auto pour Android. Contrairement à Android Automotive OS (système d'exploitation intégré dans la voiture), CarPlay et Android Auto sont des extensions d'une application mobile qui s'exécutent sur le téléphone et projettent l'interface sur l'écran de la voiture. Une Car App est votre application iOS/Android existante qui implémente les protocoles CarPlay ou Android Auto.

Catégories clés de Car App : navigation (Apple Maps, Google Maps, Waze, Sygic), audio (Spotify, Apple Music, YouTube Music, Audible, Castbox), messagerie (lecture à haute voix et dictée via Siri/Google Assistant), fonctions automobiles (charge EV, stationnement, état du véhicule), appels VOIP (WhatsApp, Zoom). Chaque catégorie a son propre modèle d'interface — ListTemplate, MapTemplate, AudioTemplate. Le système lui-même détermine quelle catégorie l'application prend en charge en fonction des Intents enregistrés.

Limitations de Car App : Apple et Google contrôlent strictement l'UX pour la sécurité — nombre minimal d'éléments, grands boutons (minimum 48x48 pt), pas de saisie de texte (voix uniquement), atténuation automatique de l'interface en conduisant, interdiction de vidéo. Le temps de réponse à une pression doit être inférieur à 100 ms. Toutes les applications passent par une modération obligatoire (App Review pour CarPlay, Google Play Console + CTS pour Android Auto).

Apple CarPlay : CarPlay framework et SiriKit

CarPlay framework (anciennement CPKit) est le framework d'Apple pour créer des applications CarPlay en Swift. La classe clé est CPInterfaceController, qui gère la navigation par modèles. CPInterfaceController contient une pile de modèles : CPListTemplate (listes), CPMapTemplate (navigation), CPNowPlayingTemplate (audio), CPVoiceControlTemplate (contrôle vocal). CPListTemplate contient CPListItem — des éléments de liste avec icône, texte et action.

SiriKit pour CarPlay — une extension SiriKit pour le contrôle vocal de l'application dans la voiture. L'application enregistre des Intents (INPlayMediaIntent — lecture, INStartWorkoutIntent — entraînement, INSendMessageIntent — messages). Siri s'active automatiquement lors de la connexion CarPlay et est disponible via le bouton de contrôle vocal au volant. SiriKit CarPlay prend en charge CarPlay Dashboard — des widgets sur l'écran d'accueil CarPlay pour afficher les informations de l'application (destination, piste en cours).

Processus de connexion CarPlay : l'iPhone se connecte à la voiture via un câble Lightning/USB-C ou sans fil (CarPlay Wireless, depuis iOS 9). Après la connexion, iOS démarre automatiquement une session CarPlay si l'application implémente CPApplicationDelegate. Le développeur ne contrôle pas le moment de la connexion — le système appelle les méthodes delegate au début et à la fin de la session. CarPlay prend en charge le multitâche : la navigation fonctionne en arrière-plan lors du passage à la musique, et les instructions vocales continuent de retentir.

Android Auto : Car App Library

Android Car App Library — une bibliothèque Android pour créer des applications compatibles avec Android Auto. Composants de base : CarAppService — point d'entrée pour Android Auto ; Session — gestion du cycle de vie de la session ; Screen — chaque écran de l'application ; CarScreenManager — gestion de l'affichage. L'application prend en charge MediaBrowserService pour le contenu multimédia et NavigationManager pour les instructions de navigation.

MediaBrowserService — un composant clé pour les applications audio. L'application implémente MediaBrowserService et MediaSession pour gérer la lecture. Android Auto affiche automatiquement les contrôles (Play/Pause, Next, Previous) et la liste des pistes. NavigationManager est utilisé pour les applications de navigation — il relaie les instructions de virage, l'état de l'itinéraire et les alertes. NavigationManager prend en charge CarNotification pour afficher les instructions de navigation dans la barre d'état d'Android Auto.

Exigences d'Android Auto : l'application doit avoir category="android.intent.category.APP_AUTO" dans le manifeste ; elle doit utiliser AndroidX et un SDK minimum 26+ ; prendre en charge le thème sombre (DayNight) ; prendre en charge le contrôle tactile et vocal ; se conformer à l'Android Auto Compatibility Test Suite (CTS). Google Play vérifie chaque application pour la conformité aux exigences de sécurité et d'UX. Le processus de certification prend 1 à 4 semaines.

Exemples de code : Swift et Kotlin

Exemple d'une application de navigation pour CarPlay en Swift utilisant CarPlay framework.

import CarPlay

class CarPlaySceneDelegate: CPTemplateApplicationSceneDelegate {

    func templateApplicationScene(
        _ templateApplicationScene: CPTemplateApplicationScene,
        didConnect interfaceController: CPInterfaceController
    ) {
        let searchItem = CPListItem(
            text: "Rechercher une adresse",
            detailText: "Saisissez la destination"
        )
        searchItem.handler = { _, completion in
            // Ouvrir l'écran de recherche
            completion()
        }

        let favoritesItem = CPListItem(
            text: "Favoris",
            detailText: "Adresses sauvegardées"
        )
        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() {
        // Afficher la liste des adresses favorites
    }
}

// SiriKit Intent pour le contrôle vocal
class NavigationIntentHandler: NSObject, INSearchForMessagesIntentHandling {
    func handle(intent: INSearchForMessagesIntent,
                completion: @escaping (INSearchForMessagesIntentResponse) -> Void) {
        // Traitement d'une commande vocale via Siri
        let response = INSearchForMessagesIntentResponse(
            code: .success, userActivity: nil
        )
        completion(response)
    }
}

Points clés : CPTemplateApplicationSceneDelegate — point d'entrée pour la session CarPlay ; CPInterfaceController gère la pile de modèles ; CPListTemplate et CPListItem — composants d'interface de base ; .handler — gestionnaire de clic pour chaque élément de liste.

Exemple d'une application de navigation pour Android Auto en Kotlin avec Car App Library :

// CarAppService — point d'entrée pour Android Auto
class NavigationCarAppService : CarAppService() {
    override fun createSession(): Session = NavigationSession()
}

// Session — gestion du cycle de vie de la session
class NavigationSession : Session() {
    override fun onCreateScreen(manager: ScreenManager): Screen {
        return MainScreen(carContext)
    }
}

// MainScreen — écran principal avec navigation
class MainScreen(carContext: CarContext) : Screen(carContext) {
    override fun onGetTemplate(): Template {
        val searchAction = Action.Builder()
            .setTitle("Rechercher une adresse")
            .setOnClickListener { showSearchScreen() }
            .build()

        val favoritesAction = Action.Builder()
            .setTitle("Favoris")
            .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 — enregistrement du service
<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>

Points clés : CarAppService — point d'entrée pour Android Auto ; Session — gestion du cycle de vie ; Screen — chaque écran de l'application, retourne un Template ; ListTemplate — modèle pour les listes avec Action ; category.APP_AUTO — catégorie obligatoire dans le manifeste.

Exigences et publication

Exigences d'Apple CarPlay : l'application doit se conformer aux CarPlay Distraction Design Guidelines — taille minimale des boutons 48x48 pt, contraste du texte 4.5:1, pas d'animation ni de vidéo, prise en charge de VoiceOver. Publication — via App Store Connect, l'application passe par la modération standard d'Apple. Il faut indiquer la prise en charge de CarPlay dans App Store Connect et joindre des captures d'écran de l'interface CarPlay. Les applications CarPlay ne peuvent pas être gratuites sans publicité — Apple prélève une commission de 30% (15% pour les petites entreprises) sur les achats intégrés.

Exigences d'Android Auto : l'application doit se conformer aux Android Auto Design Guidelines et réussir l'Android Auto Compatibility Test Suite (CTS). Publication — via Google Play Console, il faut indiquer la catégorie "Android Auto" dans la liste des appareils compatibles. Google Play vérifie : la prise en charge du thème sombre (DayNight), le comportement correct en cas de perte de connexion, la gestion de la rotation de l'écran, la prise en charge du contrôle vocal via Google Assistant. Les applications Android Auto ne nécessitent pas de commission supplémentaire — le modèle standard Google Play (15-30%).

Prise en charge de la connexion sans fil : CarPlay Wireless est disponible depuis iOS 9 et nécessite Wi-Fi + Bluetooth. Android Auto Wireless est disponible depuis Android 11. Pour la connexion sans fil, la voiture doit prendre en charge la norme correspondante. Le développeur n'a pas besoin d'écrire de code supplémentaire — le système d'exploitation gère la connexion automatiquement.