La bibliothèque d'applications Android for Cars vous permet d'utiliser vos applications de navigation, de point d'intérêt (POI) et d'Internet des objets (IOT) dans votre voiture. Pour ce faire, elle fournit un ensemble de modèles conçus pour répondre aux normes de distraction des conducteurs et prend en charge des détails tels que les différents facteurs d'écran de la voiture et les modalités d'entrée.
Ce guide présente les fonctionnalités et concepts clés de la bibliothèque, et vous guide tout au long du processus de configuration d'une application de base.
Avant de commencer
- Consultez les pages Concevoir pour la conduite concernant la bibliothèque Car App.
- Présentations des catégories Applications de navigation et Autres applications liées à la conduite
- Présentation de la section Créer des applications avec des modèles
- Éléments de base couvrant les modèles et les composants de modèles
- Exemples de flux illustrant les modèles d'expérience utilisateur courants
- Exigences concernant les modèles d'applications
- Passez en revue les termes et concepts clés dans la section suivante.
- Familiarisez-vous avec l'UI du système Android Auto et la conception d'Android Automotive OS.
- Consultez les notes de version.
- Examinez les exemples.
Termes et concepts clés
- Modèles et modèles
- L'interface utilisateur est représentée par un graphique d'objets de modèle pouvant être organisés de différentes manières, selon le modèle auquel ils appartiennent. Les modèles sont un sous-ensemble des modèles pouvant servir de racine dans ces graphiques. Les modèles incluent les informations à présenter à l'utilisateur sous forme de texte et d'images, ainsi que des attributs permettant de configurer certains aspects de l'apparence visuelle de ces informations (par exemple, les couleurs du texte ou la taille des images). L'hôte convertit les modèles en vues conçues pour répondre aux normes de distraction des conducteurs et se charge de détails tels que la variété des facteurs d'écran de la voiture et les modalités d'entrée.
- Hôte
- L'hôte est le composant backend qui implémente les fonctionnalités proposées par les API de la bibliothèque afin que votre application puisse s'exécuter dans la voiture. Les responsabilités de l'hôte vont de la découverte de votre application à la gestion de son cycle de vie, en passant par la conversion de vos modèles en vues et la notification à votre application des interactions utilisateur. Sur les appareils mobiles, cet hôte est implémenté par Android Auto. Sur Android Automotive OS, cet hôte est installé en tant qu'application système.
- Restrictions liées aux modèles
- Différents modèles appliquent des restrictions quant au contenu de leurs modèles. Par exemple, les modèles de liste limitent le nombre d'éléments pouvant être présentés à l'utilisateur. Les modèles présentent également des restrictions concernant la façon dont ils peuvent être connectés pour former le flux d'une tâche. Par exemple, l'application ne peut envoyer que jusqu'à cinq modèles dans la pile de l'écran. Pour en savoir plus, consultez Restrictions liées aux modèles.
Screen
Screen
est une classe fournie par la bibliothèque que les applications implémentent pour gérer l'interface utilisateur présentée à l'utilisateur. UnScreen
comporte un cycle de vie et fournit à l'application le mécanisme permettant d'envoyer le modèle à afficher lorsque l'écran est visible. Les instancesScreen
peuvent également être transférées vers et depuis une pileScreen
, ce qui garantit qu'elles respectent les restrictions de flux de modèles.CarAppService
CarAppService
est une classeService
abstraite que votre application doit implémenter et exporter pour être détectée et gérée par l'hôte. LeCarAppService
de votre application est chargé de vérifier qu'une connexion hôte peut être approuvée à l'aide decreateHostValidator
, puis de fournir des instancesSession
pour chaque connexion à l'aide deonCreateSession
.Session
Session
est une classe abstraite que votre application doit implémenter et renvoyer à l'aide deCarAppService.onCreateSession
. Il sert de point d'entrée pour afficher des informations sur l'écran de la voiture. Son cycle de vie informe l'état actuel de votre application sur l'écran de la voiture, par exemple lorsqu'elle est visible ou masquée.Lorsqu'un
Session
est démarré, par exemple lorsque l'application est lancée pour la première fois, l'hôte demande que leScreen
initial s'affiche à l'aide de la méthodeonCreateScreen
.
Installer la bibliothèque Car App
Consultez la page des versions de la bibliothèque Jetpack pour savoir comment l'ajouter à votre application.
Configurer les fichiers manifestes de votre application
Avant de pouvoir créer votre application pour voiture, configurez ses fichiers manifestes comme suit.
Déclarer votre CarAppService
L'hôte se connecte à votre application via votre implémentation CarAppService
. Vous déclarez ce service dans votre fichier manifeste pour permettre à l'hôte de découvrir votre application et de s'y connecter.
Vous devez également déclarer la catégorie de votre application dans l'élément <category>
du filtre d'intent de votre application. Consultez la liste des catégories d'applications compatibles pour connaître les valeurs autorisées pour cet élément.
L'extrait de code suivant montre comment déclarer un service d'application pour voitures pour une application de point d'intérêt dans votre fichier manifeste:
<application>
...
<service
...
android:name=".MyCarAppService"
android:exported="true">
<intent-filter>
<action android:name="androidx.car.app.CarAppService"/>
<category android:name="androidx.car.app.category.POI"/>
</intent-filter>
</service>
...
<application>
Catégories d'applications compatibles
Déclarez la catégorie de votre application en ajoutant une ou plusieurs des valeurs de catégorie suivantes dans le filtre d'intent lorsque vous déclarez votre CarAppService
, comme décrit dans la section précédente:
androidx.car.app.category.NAVIGATION
: application qui fournit des instructions de navigation détaillées. Consultez Créer des applications de navigation pour voitures pour obtenir de la documentation supplémentaire sur cette catégorie.androidx.car.app.category.POI
: application qui fournit des fonctionnalités permettant de trouver des points d'intérêt tels que des places de parking, des stations de recharge et des stations-service. Pour en savoir plus sur cette catégorie, consultez Créer des applications de point d'intérêt pour voitures.androidx.car.app.category.IOT
: application qui permet aux utilisateurs d'effectuer des actions pertinentes sur des appareils connectés depuis leur voiture. Consultez Créer des applications Internet des objets pour voitures afin d'obtenir de la documentation supplémentaire sur cette catégorie.
Pour obtenir une description détaillée de chaque catégorie et les critères d'appartenance des applications, consultez Qualité des applications Android pour les voitures.
Spécifier le nom et l'icône de l'application
Vous devez spécifier un nom et une icône d'application que l'hôte peut utiliser pour représenter votre application dans l'UI du système.
Vous pouvez spécifier le nom et l'icône utilisés pour représenter votre application à l'aide des attributs label
et icon
de votre CarAppService
:
...
<service
android:name=".MyCarAppService"
android:exported="true"
android:label="@string/my_app_name"
android:icon="@drawable/my_app_icon">
...
</service>
...
Si le libellé ou l'icône ne sont pas déclarés dans l'élément <service>
, l'hôte utilise les valeurs spécifiées pour l'élément <application>
.
Définir un thème personnalisé
Pour définir un thème personnalisé pour votre application pour voitures, ajoutez un élément <meta-data>
dans le fichier manifeste, comme suit:
<meta-data android:name="androidx.car.app.theme" android:resource="@style/MyCarAppTheme />
Ensuite, déclarez votre ressource de style pour définir les attributs suivants pour votre thème d'application pour voitures personnalisée:
<resources> <style name="MyCarAppTheme"> <item name="carColorPrimary">@layout/my_primary_car_color</item> <item name="carColorPrimaryDark">@layout/my_primary_dark_car_color</item> <item name="carColorSecondary">@layout/my_secondary_car_color</item> <item name="carColorSecondaryDark">@layout/my_secondary_dark_car_color</item> <item name="carPermissionActivityLayout">@layout/my_custom_background</item> </style> </resources>
Niveau d'API de Car App
La bibliothèque Car App définit ses propres niveaux d'API afin que vous puissiez savoir quelles fonctionnalités de la bibliothèque sont compatibles avec l'hôte du modèle sur un véhicule.
Pour récupérer le niveau d'API Car App le plus élevé accepté par un hôte, utilisez la méthode getCarAppApiLevel()
.
Déclarez le niveau d'API minimal Car App compatible avec votre application dans le fichier AndroidManifest.xml
:
<manifest ...>
<application ...>
<meta-data
android:name="androidx.car.app.minCarApiLevel"
android:value="1"/>
</application>
</manifest>
Consultez la documentation sur l'annotation RequiresCarApi
pour savoir comment maintenir la rétrocompatibilité et déclarer le niveau d'API minimal requis pour utiliser une fonctionnalité. Pour déterminer le niveau d'API requis pour utiliser une fonctionnalité donnée de la bibliothèque Car App, consultez la documentation de référence sur CarAppApiLevels
.
Créer votre CarAppService et votre session
Votre application doit étendre la classe CarAppService
et implémenter sa méthode onCreateSession
, qui renvoie une instance Session
correspondant à la connexion actuelle à l'hôte:
Kotlin
class HelloWorldService : CarAppService() { ... override fun onCreateSession(): Session { return HelloWorldSession() } ... }
Java
public final class HelloWorldService extends CarAppService { ... @Override @NonNull public Session onCreateSession() { return new HelloWorldSession(); } ... }
L'instance Session
est chargée de renvoyer l'instance Screen
à utiliser lors du premier démarrage de l'application:
Kotlin
class HelloWorldSession : Session() { ... override fun onCreateScreen(intent: Intent): Screen { return HelloWorldScreen(carContext) } ... }
Java
public final class HelloWorldSession extends Session { ... @Override @NonNull public Screen onCreateScreen(@NonNull Intent intent) { return new HelloWorldScreen(getCarContext()); } ... }
Pour gérer les scénarios dans lesquels votre application pour voiture doit démarrer à partir d'un écran qui n'est pas l'écran d'accueil ou de destination de votre application (par exemple, pour gérer des liens profonds), vous pouvez précharger une pile "Retour" d'écrans à l'aide de ScreenManager.push
avant de revenir depuis onCreateScreen
.
Le préremplissage permet aux utilisateurs de revenir aux écrans précédents à partir du premier écran affiché par votre application.
Créer votre écran de démarrage
Pour créer les écrans affichés par votre application, définissez des classes qui étendent la classe Screen
et implémentez sa méthode onGetTemplate
, qui renvoie l'instance Template
représentant l'état de l'UI à afficher sur l'écran de la voiture.
L'extrait de code suivant montre comment déclarer un Screen
qui utilise un modèle PaneTemplate
pour afficher une chaîne "Hello world!" simple:
Kotlin
class HelloWorldScreen(carContext: CarContext) : Screen(carContext) { override fun onGetTemplate(): Template { val row = Row.Builder().setTitle("Hello world!").build() val pane = Pane.Builder().addRow(row).build() return PaneTemplate.Builder(pane) .setHeaderAction(Action.APP_ICON) .build() } }
Java
public class HelloWorldScreen extends Screen { @NonNull @Override public Template onGetTemplate() { Row row = new Row.Builder().setTitle("Hello world!").build(); Pane pane = new Pane.Builder().addRow(row).build(); return new PaneTemplate.Builder(pane) .setHeaderAction(Action.APP_ICON) .build(); } }
La classe CarContext
La classe CarContext
est une sous-classe ContextWrapper
accessible à vos instances Session
et Screen
. Elle permet d'accéder à des services automobiles, tels que ScreenManager
pour gérer la pile d'écran, AppManager
pour les fonctionnalités générales liées à l'application, comme l'accès à l'objet Surface
pour dessiner des cartes, et aux événements NavigationManager
utilisés par les applications de navigation détaillée pour communiquer les métadonnées de navigation et d'autres métadonnées de navigation.
Consultez Accéder aux modèles de navigation pour obtenir une liste complète des fonctionnalités de bibliothèque disponibles pour les applications de navigation.
CarContext
offre également d'autres fonctionnalités, comme vous permettre de charger des ressources drawables à l'aide de la configuration depuis l'écran de la voiture, de démarrer une application dans la voiture à l'aide d'intents et de signaler si votre application doit afficher sa carte en thème sombre.
Implémenter la navigation à l'écran
Les applications présentent souvent un certain nombre d'écrans différents, chacun utilisant différents modèles que l'utilisateur peut parcourir lorsqu'il interagit avec l'interface affichée à l'écran.
La classe ScreenManager
fournit une pile d'écran que vous pouvez utiliser pour pousser les écrans qui peuvent s'afficher automatiquement lorsque l'utilisateur sélectionne un bouton "Retour" sur l'écran de la voiture ou utilise le bouton "Retour" disponible dans certaines voitures.
L'extrait de code suivant montre comment ajouter une action "Retour" à un modèle de message, ainsi qu'une action qui transfère un nouvel écran lorsque l'utilisateur la sélectionne:
Kotlin
val template = MessageTemplate.Builder("Hello world!") .setHeaderAction(Action.BACK) .addAction( Action.Builder() .setTitle("Next screen") .setOnClickListener { screenManager.push(NextScreen(carContext)) } .build()) .build()
Java
MessageTemplate template = new MessageTemplate.Builder("Hello world!") .setHeaderAction(Action.BACK) .addAction( new Action.Builder() .setTitle("Next screen") .setOnClickListener( () -> getScreenManager().push(new NextScreen(getCarContext()))) .build()) .build();
L'objet Action.BACK
est un Action
standard qui appelle automatiquement ScreenManager.pop
.
Ce comportement peut être ignoré à l'aide de l'instance OnBackPressedDispatcher
disponible à partir de CarContext
.
Pour vous assurer que l'application peut être utilisée en toute sécurité pendant la conduite, la pile d'écrans peut avoir une profondeur maximale de cinq écrans. Pour en savoir plus, consultez la section Restrictions liées aux modèles.
Actualiser le contenu d'un modèle
Votre application peut demander que le contenu d'un Screen
soit invalidé en appelant la méthode Screen.invalidate
.
L'hôte rappelle ensuite la méthode Screen.onGetTemplate
de votre application pour récupérer le modèle avec le nouveau contenu.
Lors de l'actualisation d'un Screen
, il est important de comprendre le contenu spécifique du modèle pouvant être mis à jour afin que l'hôte ne compte pas le nouveau modèle dans le quota de modèles.
Pour en savoir plus, consultez la section Restrictions liées aux modèles.
Nous vous recommandons de structurer vos écrans de sorte qu'il existe un mappage "un à un" entre un Screen
et le type de modèle qu'il renvoie via son implémentation onGetTemplate
.
Dessiner des cartes
Les applications de navigation et de point d'intérêt (POI) utilisant les modèles suivants peuvent dessiner des cartes en accédant à un Surface
:
Template | Autorisation du modèle | Conseils sur les catégories |
---|---|---|
NavigationTemplate |
androidx.car.app.NAVIGATION_TEMPLATES |
Navigation |
MapWithContentTemplate |
androidx.car.app.NAVIGATION_TEMPLATES OU androidx.car.app.MAP_TEMPLATES |
Navigation, POI |
MapTemplate (obsolète) |
androidx.car.app.NAVIGATION_TEMPLATES |
Navigation |
PlaceListNavigationTemplate (obsolète) |
androidx.car.app.NAVIGATION_TEMPLATES |
Navigation |
RoutePreviewNavigationTemplate (obsolète) |
androidx.car.app.NAVIGATION_TEMPLATES |
Navigation |
Déclarer l'autorisation de surface
En plus de l'autorisation requise pour le modèle utilisé par votre application, celle-ci doit déclarer l'autorisation androidx.car.app.ACCESS_SURFACE
dans son fichier AndroidManifest.xml
pour accéder à la surface:
<manifest ...>
...
<uses-permission android:name="androidx.car.app.ACCESS_SURFACE" />
...
</manifest>
Accédez à la surface
Pour accéder au Surface
fourni par l'hôte, vous devez implémenter un SurfaceCallback
et fournir cette implémentation au service automobile AppManager
. Le Surface
actuel est transmis à votre SurfaceCallback
dans le paramètre SurfaceContainer
des rappels onSurfaceAvailable()
et onSurfaceDestroyed()
.
Kotlin
carContext.getCarService(AppManager::class.java).setSurfaceCallback(surfaceCallback)
Java
carContext.getCarService(AppManager.class).setSurfaceCallback(surfaceCallback);
Comprendre la zone visible de la surface
L'hôte peut dessiner des éléments d'interface utilisateur pour les modèles situés au-dessus de la carte. En appelant la méthode SurfaceCallback.onVisibleAreaChanged
, l'hôte communique la zone de la surface qui sera non obstruée et entièrement visible par l'utilisateur. En outre, pour minimiser le nombre de modifications, l'hôte appelle la méthode SurfaceCallback.onStableAreaChanged
avec le plus petit rectangle, qui est toujours visible en fonction du modèle actuel.
Par exemple, lorsqu'une application de navigation utilise le NavigationTemplate
avec une bande d'actions en haut, celle-ci peut se masquer lorsque l'utilisateur n'a pas interagi avec l'écran pendant un certain temps afin de faire plus d'espace pour la carte. Dans ce cas, il y a un rappel à onStableAreaChanged
et onVisibleAreaChanged
avec le même rectangle. Lorsque la bande d'actions est masquée, seul onVisibleAreaChanged
est appelé avec la plus grande zone. Si l'utilisateur interagit avec l'écran, seul onVisibleAreaChanged
est appelé avec le premier rectangle.
Prendre en charge le thème sombre
Les applications doivent redessiner leur carte sur l'instance Surface
avec les couleurs sombres appropriées lorsque l'hôte détermine que les conditions le justifient, comme décrit dans la section Qualité des applications Android pour les voitures.
Pour décider si vous devez dessiner une carte sombre, vous pouvez utiliser la méthode CarContext.isDarkMode
. Chaque fois que l'état du thème sombre change, vous recevez un appel à Session.onCarConfigurationChanged
.
Permettre aux utilisateurs d'interagir avec votre carte
Lorsque vous utilisez les modèles suivants, vous pouvez permettre aux utilisateurs d'interagir avec les cartes que vous dessinez, par exemple en leur permettant de voir différentes parties d'une carte en effectuant un zoom et un panoramique.
Template | Interactivité prise en charge depuis le niveau d'API de Car App |
---|---|
NavigationTemplate |
2 |
PlaceListNavigationTemplate (obsolète) |
4 |
RoutePreviewNavigationTemplate (obsolète) |
4 |
MapTemplate (obsolète) |
5 (introduction du modèle) |
MapWithContentTemplate |
7 (introduction du modèle) |
Implémenter des rappels d'interactivité
L'interface SurfaceCallback
comporte plusieurs méthodes de rappel que vous pouvez implémenter pour ajouter de l'interactivité aux cartes créées avec les modèles de la section précédente:
Interactions | Méthode SurfaceCallback |
Prise en charge depuis le niveau d'API de Car App |
---|---|---|
Appuyer | onClick |
5 |
Pincer pour zoomer | onScale |
2 |
Faire glisser d'un simple geste | onScroll |
2 |
Faire glisser d'un simple geste vif | onFling |
2 |
Appuyer deux fois | onScale (avec un facteur de scaling déterminé par l'hôte du modèle) |
2 |
Geste de rotation en mode panoramique | onScroll (avec le facteur de distance déterminé par l'hôte du modèle) |
2 |
Ajouter une bande d'actions sur la carte
Ces modèles peuvent comporter une bande d'actions sur la carte pour les actions liées à la carte (zoom avant et arrière, recentrage, affichage d'une boussole, etc.). La bande d'actions sur la carte peut comporter jusqu'à quatre boutons ne contenant qu'une icône, qui peuvent être actualisés sans affecter la profondeur de la tâche. Elle est masquée pendant l'état inactif et réapparaît à l'état actif.
Pour recevoir des rappels d'interactivité sur la carte, vous devez ajouter un bouton Action.PAN
dans la bande d'actions de la carte. Lorsque l'utilisateur appuie sur le bouton panoramique, l'hôte passe en mode panoramique, comme décrit dans la section suivante.
Si votre application omet le bouton Action.PAN
dans la bande d'actions de la carte, elle ne reçoit pas les entrées utilisateur provenant des méthodes SurfaceCallback
, et l'hôte quittera tout mode panoramique précédemment activé.
Sur un écran tactile, le bouton panoramique n'est pas affiché.
Comprendre le mode panoramique
En mode panoramique, l'hôte du modèle traduit les entrées utilisateur des appareils d'entrées non tactiles, tels que les contrôleurs rotatifs et les pavés tactiles dans les méthodes SurfaceCallback
appropriées. Répondez à l'action de l'utilisateur visant à ouvrir ou quitter le mode panoramique à l'aide de la méthode setPanModeListener
dans le NavigationTemplate.Builder
. L'hôte peut masquer d'autres composants d'interface utilisateur dans le modèle lorsque l'utilisateur est en mode panoramique.
Interagir avec l'utilisateur
Votre application peut interagir avec l'utilisateur à l'aide de modèles semblables à ceux d'une application mobile.
Gérer les entrées utilisateur
Votre application peut répondre aux entrées utilisateur en transmettant les écouteurs appropriés aux modèles qui les prennent en charge. L'extrait de code suivant montre comment créer un modèle Action
qui définit un élément OnClickListener
qui rappelle une méthode définie par le code de votre application:
Kotlin
val action = Action.Builder() .setTitle("Navigate") .setOnClickListener(::onClickNavigate) .build()
Java
Action action = new Action.Builder() .setTitle("Navigate") .setOnClickListener(this::onClickNavigate) .build();
La méthode onClickNavigate
peut ensuite démarrer l'application pour voiture de navigation par défaut à l'aide de la méthode CarContext.startCarApp
:
Kotlin
private fun onClickNavigate() { val intent = Intent(CarContext.ACTION_NAVIGATE, Uri.parse("geo:0,0?q=" + address)) carContext.startCarApp(intent) }
Java
private void onClickNavigate() { Intent intent = new Intent(CarContext.ACTION_NAVIGATE, Uri.parse("geo:0,0?q=" + address)); getCarContext().startCarApp(intent); }
Pour en savoir plus sur le démarrage d'applications, y compris sur le format de l'intent ACTION_NAVIGATE
, consultez la section Démarrer une application pour voitures avec un intent.
Certaines actions, telles que celles qui nécessitent de demander à l'utilisateur de poursuivre l'interaction sur son appareil mobile, ne sont autorisées que lorsque la voiture est à l'arrêt.
Vous pouvez utiliser ParkedOnlyOnClickListener
pour implémenter ces actions. Si la voiture n'est pas garée, l'hôte indique à l'utilisateur que l'action n'est pas autorisée dans ce cas. Si la voiture est à l'arrêt, le code s'exécute normalement. L'extrait de code suivant montre comment utiliser ParkedOnlyOnClickListener
pour ouvrir un écran de paramètres sur l'appareil mobile:
Kotlin
val row = Row.Builder() .setTitle("Open Settings") .setOnClickListener(ParkedOnlyOnClickListener.create(::openSettingsOnPhone)) .build()
Java
Row row = new Row.Builder() .setTitle("Open Settings") .setOnClickListener(ParkedOnlyOnClickListener.create(this::openSettingsOnPhone)) .build();
Afficher les notifications
Les notifications envoyées à l'appareil mobile ne s'affichent sur l'écran de la voiture que si elles sont étendues avec un CarAppExtender
.
Certains attributs de notification, tels que le titre du contenu, le texte, l'icône et les actions, peuvent être définis dans CarAppExtender
, remplaçant les attributs de notification lorsqu'ils s'affichent sur l'écran de la voiture.
L'extrait de code suivant montre comment envoyer sur l'écran de la voiture une notification dont le titre est différent de celui affiché sur l'appareil mobile:
Kotlin
val notification = NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID) .setContentTitle(titleOnThePhone) .extend( CarAppExtender.Builder() .setContentTitle(titleOnTheCar) ... .build()) .build()
Java
Notification notification = new NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID) .setContentTitle(titleOnThePhone) .extend( new CarAppExtender.Builder() .setContentTitle(titleOnTheCar) ... .build()) .build();
Les notifications peuvent affecter les parties suivantes de l'interface utilisateur:
- Une notification prioritaire peut s'afficher à l'attention de l'utilisateur.
- Vous pouvez ajouter une entrée dans le centre de notifications, éventuellement avec un badge visible dans le rail.
- Pour les applications de navigation, la notification peut s'afficher dans le widget de rail, comme décrit dans la section Notifications de navigation détaillée.
Vous pouvez choisir comment configurer les notifications de votre application pour qu'elles affectent chacun de ces éléments de l'interface utilisateur en utilisant la priorité de la notification, comme décrit dans la documentation CarAppExtender
.
Si NotificationCompat.Builder.setOnlyAlertOnce
est appelé avec la valeur true
, une notification à priorité élevée ne s'affiche qu'une seule fois en tant que notification prioritaire.
Pour en savoir plus sur la conception des notifications de votre application de voiture, consultez le guide Notifications sur la conception de Google pour la conduite.
Afficher les toasts
Votre application peut afficher un toast à l'aide de CarToast
, comme indiqué dans cet extrait:
Kotlin
CarToast.makeText(carContext, "Hello!", CarToast.LENGTH_SHORT).show()
Java
CarToast.makeText(getCarContext(), "Hello!", CarToast.LENGTH_SHORT).show();
Demander des autorisations
Si votre application a besoin d'accéder à des données ou à des actions limitées, telles que la localisation, les règles standards des autorisations Android s'appliquent. Pour demander une autorisation, vous pouvez utiliser la méthode CarContext.requestPermissions()
.
L'avantage d'utiliser CarContext.requestPermissions()
par rapport aux API Android standards est que vous n'avez pas besoin de lancer votre propre Activity
pour créer la boîte de dialogue des autorisations. De plus, vous pouvez utiliser le même code sur Android Auto et sur Android Automotive OS, au lieu de devoir créer des flux dépendants de la plate-forme.
Appliquer un style à la boîte de dialogue des autorisations dans Android Auto
Sur Android Auto, la boîte de dialogue des autorisations de l'utilisateur s'affiche sur le téléphone.
Par défaut, aucun arrière-plan ne s'affiche derrière la boîte de dialogue. Pour définir un arrière-plan personnalisé, déclarez un thème d'application pour voitures dans votre fichier AndroidManifest.xml
et définissez l'attribut carPermissionActivityLayout
pour le thème de votre application pour voitures.
<meta-data android:name="androidx.car.app.theme" android:resource="@style/MyCarAppTheme />
Définissez ensuite l'attribut carPermissionActivityLayout
pour le thème de votre application pour voitures :
<resources> <style name="MyCarAppTheme"> <item name="carPermissionActivityLayout">@layout/my_custom_background</item> </style> </resources>
Démarrer une application pour voitures avec un intent
Vous pouvez appeler la méthode CarContext.startCarApp
pour effectuer l'une des actions suivantes:
- Ouvrez le clavier pour passer un appel téléphonique.
- Démarrez la navigation détaillée vers un lieu à l'aide de l'application de navigation par défaut pour voiture.
- Démarrez votre propre application avec un intent.
L'exemple suivant montre comment créer une notification avec une action qui ouvre votre application avec un écran affichant les détails d'une réservation de stationnement.
Vous allez étendre l'instance de notification avec un intent de contenu contenant un élément PendingIntent
encapsulant un intent explicite dans l'action de votre application:
Kotlin
val notification = notificationBuilder ... .extend( CarAppExtender.Builder() .setContentIntent( PendingIntent.getBroadcast( context, ACTION_VIEW_PARKING_RESERVATION.hashCode(), Intent(ACTION_VIEW_PARKING_RESERVATION) .setComponent(ComponentName(context, MyNotificationReceiver::class.java)), 0)) .build())
Java
Notification notification = notificationBuilder ... .extend( new CarAppExtender.Builder() .setContentIntent( PendingIntent.getBroadcast( context, ACTION_VIEW_PARKING_RESERVATION.hashCode(), new Intent(ACTION_VIEW_PARKING_RESERVATION) .setComponent(new ComponentName(context, MyNotificationReceiver.class)), 0)) .build());
Votre application doit également déclarer un BroadcastReceiver
qui est appelé pour traiter l'intent lorsque l'utilisateur sélectionne l'action dans l'interface de notification et appelle CarContext.startCarApp
avec un intent incluant l'URI de données:
Kotlin
class MyNotificationReceiver : BroadcastReceiver() { override fun onReceive(context: Context, intent: Intent) { val intentAction = intent.action if (ACTION_VIEW_PARKING_RESERVATION == intentAction) { CarContext.startCarApp( intent, Intent(Intent.ACTION_VIEW) .setComponent(ComponentName(context, MyCarAppService::class.java)) .setData(Uri.fromParts(MY_URI_SCHEME, MY_URI_HOST, intentAction))) } } }
Java
public class MyNotificationReceiver extends BroadcastReceiver { @Override public void onReceive(Context context, Intent intent) { String intentAction = intent.getAction(); if (ACTION_VIEW_PARKING_RESERVATION.equals(intentAction)) { CarContext.startCarApp( intent, new Intent(Intent.ACTION_VIEW) .setComponent(new ComponentName(context, MyCarAppService.class)) .setData(Uri.fromParts(MY_URI_SCHEME, MY_URI_HOST, intentAction))); } } }
Enfin, la méthode Session.onNewIntent
de votre application gère cet intent en plaçant l'écran de réservation de stationnement sur la pile, s'il ne se trouve pas déjà en haut:
Kotlin
override fun onNewIntent(intent: Intent) { val screenManager = carContext.getCarService(ScreenManager::class.java) val uri = intent.data if (uri != null && MY_URI_SCHEME == uri.scheme && MY_URI_HOST == uri.schemeSpecificPart && ACTION_VIEW_PARKING_RESERVATION == uri.fragment ) { val top = screenManager.top if (top !is ParkingReservationScreen) { screenManager.push(ParkingReservationScreen(carContext)) } } }
Java
@Override public void onNewIntent(@NonNull Intent intent) { ScreenManager screenManager = getCarContext().getCarService(ScreenManager.class); Uri uri = intent.getData(); if (uri != null && MY_URI_SCHEME.equals(uri.getScheme()) && MY_URI_HOST.equals(uri.getSchemeSpecificPart()) && ACTION_VIEW_PARKING_RESERVATION.equals(uri.getFragment()) ) { Screen top = screenManager.getTop(); if (!(top instanceof ParkingReservationScreen)) { screenManager.push(new ParkingReservationScreen(getCarContext())); } } }
Consultez la section Afficher les notifications pour savoir comment gérer les notifications pour l'application pour voiture.
Restrictions liées aux modèles
L'hôte limite le nombre de modèles à afficher pour une tâche donnée à cinq au maximum, dont le dernier modèle doit correspondre à l'un des types suivants:
Notez que cette limite s'applique au nombre de modèles, et non au nombre d'instances Screen
dans la pile. Par exemple, si une application envoie deux modèles sur l'écran A, puis transfère l'écran B, elle peut désormais envoyer trois modèles supplémentaires. Si chaque écran est structuré pour envoyer un seul modèle, l'application peut également transférer cinq instances d'écran dans la pile ScreenManager
.
Ces restrictions peuvent s'appliquer dans certains cas particuliers: actualisations de modèles, et opérations précédentes et réinitialisées.
Le modèle est actualisé
Certaines mises à jour de contenu ne sont pas comptabilisées dans la limite des modèles. En général, si une application transfère un nouveau modèle du même type et comportant le même contenu principal que le modèle précédent, le nouveau modèle n'est pas comptabilisé dans le quota. Par exemple, la mise à jour de l'état d'activation d'une ligne dans un objet ListTemplate
n'est pas comptabilisée dans le quota. Consultez la documentation des modèles individuels pour en savoir plus sur les types de mises à jour de contenu pouvant être considérées comme une actualisation.
Opérations de retour
Pour activer les sous-flux dans une tâche, l'hôte détecte lorsqu'une application affiche un Screen
à partir de la pile ScreenManager
et met à jour le quota restant en fonction du nombre de modèles que l'application va revenir.
Par exemple, si l'application envoie deux modèles sur l'écran A, puis transfère l'écran B et envoie deux autres modèles, il lui reste un quota. Si l'application revient ensuite à l'écran A, l'hôte réinitialise le quota à trois, car l'application a reculé de deux modèles.
Notez que lorsque vous revenez à un écran, une application doit envoyer un modèle du même type que celui envoyé en dernier par cet écran. L'envoi d'un autre type de modèle entraîne une erreur. Toutefois, tant que le type reste identique lors d'une opération de retour, une application peut modifier librement le contenu du modèle sans affecter le quota.
Opérations de réinitialisation
Certains modèles ont une sémantique spéciale qui indique la fin d'une tâche. Par exemple, NavigationTemplate
est une vue qui doit rester à l'écran et être actualisée avec de nouvelles instructions de navigation détaillée pour la consommation de l'utilisateur. Lorsqu'il atteint l'un de ces modèles, l'hôte réinitialise le quota de modèles, en traitant ce modèle comme s'il s'agissait de la première étape d'une nouvelle tâche. Cela permet à l'application de commencer une nouvelle tâche.
Consultez la documentation des modèles individuels pour voir ceux qui déclenchent une réinitialisation sur l'hôte.
Si l'hôte reçoit un intent pour démarrer l'application à partir d'une action de notification ou du lanceur d'applications, le quota est également réinitialisé. Ce mécanisme permet à une application de lancer un nouveau flux de tâches à partir de notifications. Il s'applique même si une application est déjà liée et au premier plan.
Consultez la section Afficher les notifications pour découvrir comment afficher les notifications de votre application sur l'écran de la voiture. Consultez la section Démarrer une application pour voitures avec un intent pour découvrir comment démarrer votre application à partir d'une action de notification.
API Connection
Vous pouvez déterminer si votre application s'exécute sur Android Auto ou sur Android Automotive OS en utilisant l'API CarConnection
afin de récupérer les informations de connexion au moment de l'exécution.
Par exemple, dans le Session
de votre application pour voitures, initialisez un CarConnection
et abonnez-vous aux mises à jour de LiveData
:
Kotlin
CarConnection(carContext).type.observe(this, ::onConnectionStateUpdated)
Java
new CarConnection(getCarContext()).getType().observe(this, this::onConnectionStateUpdated);
Dans l'observateur, vous pouvez ensuite réagir aux changements d'état de la connexion:
Kotlin
fun onConnectionStateUpdated(connectionState: Int) { val message = when(connectionState) { CarConnection.CONNECTION_TYPE_NOT_CONNECTED -> "Not connected to a head unit" CarConnection.CONNECTION_TYPE_NATIVE -> "Connected to Android Automotive OS" CarConnection.CONNECTION_TYPE_PROJECTION -> "Connected to Android Auto" else -> "Unknown car connection type" } CarToast.makeText(carContext, message, CarToast.LENGTH_SHORT).show() }
Java
private void onConnectionStateUpdated(int connectionState) { String message; switch(connectionState) { case CarConnection.CONNECTION_TYPE_NOT_CONNECTED: message = "Not connected to a head unit"; break; case CarConnection.CONNECTION_TYPE_NATIVE: message = "Connected to Android Automotive OS"; break; case CarConnection.CONNECTION_TYPE_PROJECTION: message = "Connected to Android Auto"; break; default: message = "Unknown car connection type"; break; } CarToast.makeText(getCarContext(), message, CarToast.LENGTH_SHORT).show(); }
API Constraints
Différentes voitures peuvent permettre d'afficher un nombre différent d'instances Item
à la fois auprès de l'utilisateur. Utilisez ConstraintManager
pour vérifier la limite de contenu au moment de l'exécution et définir le nombre approprié d'éléments dans vos modèles.
Commencez par obtenir un ConstraintManager
à partir de CarContext
:
Kotlin
val manager = carContext.getCarService(ConstraintManager::class.java)
Java
ConstraintManager manager = getCarContext().getCarService(ConstraintManager.class);
Vous pouvez ensuite interroger l'objet ConstraintManager
récupéré pour connaître la limite de contenu appropriée. Par exemple, pour obtenir le nombre d'éléments pouvant être affichés dans une grille, appelez getContentLimit
avec CONTENT_LIMIT_TYPE_GRID
:
Kotlin
val gridItemLimit = manager.getContentLimit(ConstraintManager.CONTENT_LIMIT_TYPE_GRID)
Java
int gridItemLimit = manager.getContentLimit(ConstraintManager.CONTENT_LIMIT_TYPE_GRID);
Ajouter un flux de connexion
Si votre application propose aux utilisateurs une expérience de connexion, vous pouvez utiliser des modèles tels que SignInTemplate
et LongMessageTemplate
avec l'API Car App de niveau 2 ou supérieur pour gérer la connexion à votre application sur l'unité principale de la voiture.
Pour créer un SignInTemplate
, définissez un SignInMethod
. La bibliothèque Car App prend actuellement en charge les méthodes de connexion suivantes:
InputSignInMethod
pour la connexion par nom d'utilisateur/mot de passePinSignInMethod
pour la connexion par code, où l'utilisateur associe son compte depuis son téléphone à l'aide du code affiché sur l'unité principale.ProviderSignInMethod
pour la connexion au fournisseur, comme Google Sign-In et One TapQRCodeSignInMethod
pour se connecter par code QR, où l'utilisateur scanne ce code pour se connecter sur son téléphone. Cette fonctionnalité est disponible à partir du niveau d'API 4 de Car.
Par exemple, pour implémenter un modèle qui collecte le mot de passe de l'utilisateur, commencez par créer un InputCallback
pour traiter et valider les entrées utilisateur:
Kotlin
val callback = object : InputCallback { override fun onInputSubmitted(text: String) { // You will receive this callback when the user presses Enter on the keyboard. } override fun onInputTextChanged(text: String) { // You will receive this callback as the user is typing. The update // frequency is determined by the host. } }
Java
InputCallback callback = new InputCallback() { @Override public void onInputSubmitted(@NonNull String text) { // You will receive this callback when the user presses Enter on the keyboard. } @Override public void onInputTextChanged(@NonNull String text) { // You will receive this callback as the user is typing. The update // frequency is determined by the host. } };
Un InputCallback
est requis pour le Builder
InputSignInMethod
.
Kotlin
val passwordInput = InputSignInMethod.Builder(callback) .setHint("Password") .setInputType(InputSignInMethod.INPUT_TYPE_PASSWORD) ... .build()
Java
InputSignInMethod passwordInput = new InputSignInMethod.Builder(callback) .setHint("Password") .setInputType(InputSignInMethod.INPUT_TYPE_PASSWORD) ... .build();
Enfin, utilisez votre nouveau InputSignInMethod
pour créer un SignInTemplate
.
Kotlin
SignInTemplate.Builder(passwordInput) .setTitle("Sign in with username and password") .setInstructions("Enter your password") .setHeaderAction(Action.BACK) ... .build()
Java
new SignInTemplate.Builder(passwordInput) .setTitle("Sign in with username and password") .setInstructions("Enter your password") .setHeaderAction(Action.BACK) ... .build();
Utiliser AccountManager
Les applications Android Automotive OS avec authentification doivent utiliser AccountManager pour les raisons suivantes :
- Meilleure expérience utilisateur et gestion simplifiée du compte: les utilisateurs peuvent facilement gérer tous leurs comptes à partir du menu "Comptes" dans les paramètres système, y compris la connexion et la déconnexion.
- Expériences des invités: les voitures étant des appareils partagés, les OEM peuvent proposer des expériences invitées dans le véhicule, lorsque l'ajout de comptes n'est pas possible.
Ajouter des variantes de chaîne de texte
La quantité de texte peut varier selon la taille d'écran de la voiture. Avec le niveau 2 ou supérieur de l'API Car App, vous pouvez spécifier plusieurs variantes d'une chaîne de texte pour un ajustement optimal de l'écran. Pour savoir où les variantes de texte sont acceptées, recherchez des modèles et des composants qui utilisent un CarText
.
Vous pouvez ajouter des variantes de chaîne de texte à un CarText
avec la méthode CarText.Builder.addVariant()
:
Kotlin
val itemTitle = CarText.Builder("This is a very long string") .addVariant("Shorter string") ... .build()
Java
CarText itemTitle = new CarText.Builder("This is a very long string") .addVariant("Shorter string") ... .build();
Vous pouvez ensuite utiliser ce CarText
(par exemple, comme texte principal d'une GridItem
).
Kotlin
GridItem.Builder() .addTitle(itemTitle) ... .build()
Java
new GridItem.Builder() .addTitle(itemTitle) ... build();
Ajoutez les chaînes de la plus longue à la moins préférée, par exemple du plus long au plus court. L'hôte choisit la chaîne de longueur appropriée en fonction de l'espace disponible sur l'écran de la voiture.
Ajouter des éléments CarIcons intégrés pour les lignes
Vous pouvez ajouter des icônes alignées au texte pour enrichir l'attrait visuel de votre application à l'aide de CarIconSpan
.
Pour en savoir plus sur la création de ces délais, consultez la documentation de CarIconSpan.create
. Pour découvrir comment fonctionne l'application d'un style de texte avec des objets Span, consultez la section Appliquer un style spantastique aux objets Span.
Kotlin
val rating = SpannableString("Rating: 4.5 stars") rating.setSpan( CarIconSpan.create( // Create a CarIcon with an image of four and a half stars CarIcon.Builder(...).build(), // Align the CarIcon to the baseline of the text CarIconSpan.ALIGN_BASELINE ), // The start index of the span (index of the character '4') 8, // The end index of the span (index of the last 's' in "stars") 16, Spanned.SPAN_INCLUSIVE_INCLUSIVE ) val row = Row.Builder() ... .addText(rating) .build()
Java
SpannableString rating = new SpannableString("Rating: 4.5 stars"); rating.setSpan( CarIconSpan.create( // Create a CarIcon with an image of four and a half stars new CarIcon.Builder(...).build(), // Align the CarIcon to the baseline of the text CarIconSpan.ALIGN_BASELINE ), // The start index of the span (index of the character '4') 8, // The end index of the span (index of the last 's' in "stars") 16, Spanned.SPAN_INCLUSIVE_INCLUSIVE ); Row row = new Row.Builder() ... .addText(rating) .build();
API Car Hardware
À partir du niveau 3 de l'API Car App, la bibliothèque Car App contient des API que vous pouvez utiliser pour accéder aux propriétés et aux capteurs du véhicule.
Exigences
Pour utiliser les API avec Android Auto, commencez par ajouter une dépendance à androidx.car.app:app-projected
dans le fichier build.gradle
de votre module Android Auto. Pour Android Automotive OS, ajoutez une dépendance à androidx.car.app:app-automotive
dans le fichier build.gradle
de votre module Android Automotive OS.
En outre, dans votre fichier AndroidManifest.xml
, vous devez déclarer les autorisations pertinentes nécessaires pour demander les données sur la voiture que vous souhaitez utiliser. Notez que ces autorisations doivent également vous être accordées par l'utilisateur. Vous pouvez utiliser le même code sur Android Auto et sur Android Automotive OS, au lieu de devoir créer des flux dépendants de la plate-forme. Cependant, les autorisations nécessaires sont différentes.
CarInfo
Ce tableau décrit les propriétés mises en évidence par les API CarInfo
et les autorisations que vous devez demander pour les utiliser:
Méthodes | Propriétés | Autorisations Android Auto | Autorisations d'Android Automotive OS | Prise en charge depuis le niveau d'API de Car App |
---|---|---|---|---|
fetchModel |
Marque, modèle, année | android.car.permission.CAR_INFO |
3 | |
fetchEnergyProfile |
Types de connecteurs pour VE, types de carburant | com.google.android.gms.permission.CAR_FUEL |
android.car.permission.CAR_INFO |
3 |
fetchExteriorDimensions
Ces données ne sont disponibles que sur certains véhicules Android Automotive OS exécutant le niveau d'API 30 ou supérieur. |
Dimensions extérieures | N/A | android.car.permission.CAR_INFO |
7 |
addTollListener
removeTollListener |
État de la carte de péage, type de carte de péage | 3 | ||
addEnergyLevelListener
removeEnergyLevelListener |
Niveau de la batterie, niveau de carburant, niveau de carburant faible, autonomie restante | com.google.android.gms.permission.CAR_FUEL |
android.car.permission.CAR_ENERGY ,android.car.permission.CAR_ENERGY_PORTS ,android.car.permission.READ_CAR_DISPLAY_UNITS
|
3 |
addSpeedListener
removeSpeedListener |
Vitesse brute, vitesse d'affichage (affichées sur l'écran du cluster de la voiture) | com.google.android.gms.permission.CAR_SPEED |
android.car.permission.CAR_SPEED ,android.car.permission.READ_CAR_DISPLAY_UNITS |
3 |
addMileageListener
removeMileageListener |
Distance kilométrique | com.google.android.gms.permission.CAR_MILEAGE |
Ces données ne sont pas disponibles sur Android Automotive OS pour les applis installées depuis le Play Store. | 3 |
Par exemple, pour obtenir la plage restante, instanciez un objet CarInfo
, puis créez et enregistrez un OnCarDataAvailableListener
:
Kotlin
val carInfo = carContext.getCarService(CarHardwareManager::class.java).carInfo val listener = OnCarDataAvailableListener<EnergyLevel> { data -> if (data.rangeRemainingMeters.status == CarValue.STATUS_SUCCESS) { val rangeRemaining = data.rangeRemainingMeters.value } else { // Handle error } } carInfo.addEnergyLevelListener(carContext.mainExecutor, listener) … // Unregister the listener when you no longer need updates carInfo.removeEnergyLevelListener(listener)
Java
CarInfo carInfo = getCarContext().getCarService(CarHardwareManager.class).getCarInfo(); OnCarDataAvailableListener<EnergyLevel> listener = (data) -> { if(data.getRangeRemainingMeters().getStatus() == CarValue.STATUS_SUCCESS) { float rangeRemaining = data.getRangeRemainingMeters().getValue(); } else { // Handle error } }; carInfo.addEnergyLevelListener(getCarContext().getMainExecutor(), listener); … // Unregister the listener when you no longer need updates carInfo.removeEnergyLevelListener(listener);
Ne partez pas du principe que les données de la voiture sont disponibles en permanence.
Si vous recevez un message d'erreur, vérifiez l'état de la valeur que vous avez demandée afin de mieux comprendre pourquoi les données que vous avez demandées n'ont pas pu être récupérées. Reportez-vous à la documentation de référence pour obtenir la définition complète de la classe CarInfo
.
Capteurs de voiture
La classe CarSensors
vous donne accès à l'accéléromètre, au gyroscope, à la boussole et à la localisation du véhicule. La disponibilité de ces valeurs peut dépendre de l'OEM. Le format des données de l'accéléromètre, du gyroscope et de la boussole est le même que celui de l'API SensorManager
. Par exemple, pour vérifier la direction du véhicule:
Kotlin
val carSensors = carContext.getCarService(CarHardwareManager::class.java).carSensors val listener = OnCarDataAvailableListener<Compass> { data -> if (data.orientations.status == CarValue.STATUS_SUCCESS) { val orientation = data.orientations.value } else { // Data not available, handle error } } carSensors.addCompassListener(CarSensors.UPDATE_RATE_NORMAL, carContext.mainExecutor, listener) … // Unregister the listener when you no longer need updates carSensors.removeCompassListener(listener)
Java
CarSensors carSensors = getCarContext().getCarService(CarHardwareManager.class).getCarSensors(); OnCarDataAvailableListener<Compass> listener = (data) -> { if (data.getOrientations().getStatus() == CarValue.STATUS_SUCCESS) { List<Float> orientations = data.getOrientations().getValue(); } else { // Data not available, handle error } }; carSensors.addCompassListener(CarSensors.UPDATE_RATE_NORMAL, getCarContext().getMainExecutor(), listener); … // Unregister the listener when you no longer need updates carSensors.removeCompassListener(listener);
Pour accéder aux données de localisation depuis la voiture, vous devez également déclarer et demander l'autorisation android.permission.ACCESS_FINE_LOCATION
.
Tests
Pour simuler des données de capteurs lors des tests sur Android Auto, consultez les sections Capteurs et Configuration des capteurs du guide de l'unité principale pour ordinateur. Pour simuler les données de capteurs lors des tests sur Android Automotive OS, consultez la section Émuler l'état du matériel du guide de l'émulateur Android Automotive OS.
Cycles de vie des CarAppService, des sessions et des écrans
Les classes Session
et Screen
implémentent l'interface LifecycleOwner
. Lorsque l'utilisateur interagit avec l'application, les rappels du cycle de vie de vos objets Session
et Screen
sont appelés, comme décrit dans les schémas suivants.
Cycles de vie d'un CarAppService et d'une session
![](https://developer.android.google.cn/static/images/training/cars/carappservice-session-lifecycle.png?authuser=9&hl=fr)
Session
.Pour en savoir plus, consultez la documentation de la méthode Session.getLifecycle
.
Cycle de vie d'un écran
![](https://developer.android.google.cn/static/images/training/cars/screen-lifecycle.png?authuser=9&hl=fr)
Screen
.Pour en savoir plus, consultez la documentation de la méthode Screen.getLifecycle
.
Enregistrer depuis le micro de la voiture
À l'aide du CarAppService
et de l'API CarAudioRecord
de votre application, vous pouvez autoriser votre application à accéder au micro de la voiture de l'utilisateur. Les utilisateurs doivent autoriser votre application à accéder au micro de la voiture. Votre application peut enregistrer et traiter l'entrée utilisateur dans votre application.
Autorisation d'enregistrement
Avant d'enregistrer du contenu audio, vous devez d'abord déclarer l'autorisation d'enregistrement dans votre AndroidManifest.xml
et demander à l'utilisateur de vous l'accorder.
<manifest ...>
...
<uses-permission android:name="android.permission.RECORD_AUDIO" />
...
</manifest>
Vous devez demander l'autorisation d'enregistrer au moment de l'exécution. Consultez la section Demander des autorisations pour découvrir comment demander une autorisation dans votre application pour voitures.
Enregistrer un fichier audio
Une fois que l'utilisateur a donné son autorisation, vous pouvez enregistrer le contenu audio et traiter l'enregistrement.
Kotlin
val carAudioRecord = CarAudioRecord.create(carContext) carAudioRecord.startRecording() val data = ByteArray(CarAudioRecord.AUDIO_CONTENT_BUFFER_SIZE) while(carAudioRecord.read(data, 0, CarAudioRecord.AUDIO_CONTENT_BUFFER_SIZE) >= 0) { // Use data array // Potentially call carAudioRecord.stopRecording() if your processing finds end of speech } carAudioRecord.stopRecording()
Java
CarAudioRecord carAudioRecord = CarAudioRecord.create(getCarContext()); carAudioRecord.startRecording(); byte[] data = new byte[CarAudioRecord.AUDIO_CONTENT_BUFFER_SIZE]; while (carAudioRecord.read(data, 0, CarAudioRecord.AUDIO_CONTENT_BUFFER_SIZE) >= 0) { // Use data array // Potentially call carAudioRecord.stopRecording() if your processing finds end of speech } carAudioRecord.stopRecording();
Priorité audio
Lorsque vous enregistrez à partir du micro de la voiture, commencez par effectuer la mise au point audio pour vous assurer que tout contenu multimédia en cours est arrêté. Si vous perdez la priorité audio, arrêtez l'enregistrement.
Voici un exemple illustrant comment acquérir une priorité audio:
Kotlin
val carAudioRecord = CarAudioRecord.create(carContext) // Take audio focus so that user's media is not recorded val audioAttributes = AudioAttributes.Builder() .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH) // Use the most appropriate usage type for your use case .setUsage(AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE) .build() val audioFocusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE) .setAudioAttributes(audioAttributes) .setOnAudioFocusChangeListener { state: Int -> if (state == AudioManager.AUDIOFOCUS_LOSS) { // Stop recording if audio focus is lost carAudioRecord.stopRecording() } } .build() if (carContext.getSystemService(AudioManager::class.java) .requestAudioFocus(audioFocusRequest) != AudioManager.AUDIOFOCUS_REQUEST_GRANTED ) { // Don't record if the focus isn't granted return } carAudioRecord.startRecording() // Process the audio and abandon the AudioFocusRequest when done
Java
CarAudioRecord carAudioRecord = CarAudioRecord.create(getCarContext()); // Take audio focus so that user's media is not recorded AudioAttributes audioAttributes = new AudioAttributes.Builder() .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH) // Use the most appropriate usage type for your use case .setUsage(AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE) .build(); AudioFocusRequest audioFocusRequest = new AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE) .setAudioAttributes(audioAttributes) .setOnAudioFocusChangeListener(state -> { if (state == AudioManager.AUDIOFOCUS_LOSS) { // Stop recording if audio focus is lost carAudioRecord.stopRecording(); } }) .build(); if (getCarContext().getSystemService(AudioManager.class).requestAudioFocus(audioFocusRequest) != AUDIOFOCUS_REQUEST_GRANTED) { // Don't record if the focus isn't granted return; } carAudioRecord.startRecording(); // Process the audio and abandon the AudioFocusRequest when done
Bibliothèque de test
La bibliothèque de tests Android for Cars fournit des classes auxiliaires que vous pouvez utiliser pour valider le comportement de votre application dans un environnement de test.
Par exemple, SessionController
vous permet de simuler une connexion à l'hôte, et de vérifier que les propriétés Screen
et Template
appropriées sont créées et renvoyées.
Consultez la section Exemples pour découvrir des exemples d'utilisation.
Signaler un problème lié à la bibliothèque d'applications Android for Cars
Si vous constatez un problème au niveau de la bibliothèque, signalez-le à l'aide de l'outil Issue Tracker de Google. Veillez à fournir toutes les informations requises dans le modèle dédié.
Avant de signaler un nouveau problème, vérifiez s'il figure dans les notes de version de la bibliothèque ou s'il a été signalé dans la liste des problèmes. Vous pouvez vous abonner et voter pour des problèmes en cliquant sur l'étoile correspondant à un problème dans l'outil de suivi. Pour en savoir plus, consultez S'abonner à un problème.