La bibliothèque d'applications Android for Cars vous permet d'utiliser vos fonctionnalités de navigation, de point d'intérêt (POI) et de l'Internet des objets (IOT) des applications à la voiture. Pour cela, elle fournit un ensemble de modèles conçus pour répondre à la distraction au volant. aux normes et s'occupe de certains détails, tels que la variété des facteurs d'écran de voiture et les modalités d'entrée.
Ce guide présente les principales fonctionnalités et concepts de la bibliothèque. vous guide tout au long du processus de configuration d'une application de base.
Avant de commencer
- Revoyez la conception pour la conduite.
Pages traitant de la bibliothèque Car App
<ph type="x-smartling-placeholder">
- </ph>
- Applications de navigation et Autres applis liées à la conduite résumés des catégories
- Présentation de la section Créer des applications avec des modèles
- Éléments de base sur les modèles et les composants de modèles
- Exemples de flux démontrant des modèles UX courants
- Exigences concernant les modèles d'applications
- Passez en revue les termes et concepts clés dans les articles suivants : .
- Familiarisez-vous avec le système Android Auto. UI et Android Automotive OS conception.
- 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 organisés différemment, selon le modèle auquel ils appartiennent. auxquelles vous souhaitez vous connecter. 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 dans les de texte et d'images, ainsi que des attributs pour configurer certains aspects L'apparence visuelle de ces informations, par exemple les couleurs du texte ou des images différentes tailles d'écran. L'hôte convertit les modèles en vues conçues pour répondre les normes de distraction du conducteur et s’occupe de détails comme la variété des facteurs d'écran de voiture et des modalités d'entrée.
- Hôte
- L'hôte est le composant backend qui implémente la fonctionnalité proposée par les API de la bibliothèque afin que votre application puisse s'exécuter en voiture. La les responsabilités de l'hôte vont de la découverte de l'application à la gestion de son cycle de vie à la conversion de vos modèles en vues et à la notification de votre application d'interactions utilisateur. Sur les appareils mobiles, cet hôte est implémenté par Android. Automatique. 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. Pour Par exemple, les modèles de liste limitent le nombre d'éléments pouvant être présentées à l’utilisateur. Les modèles sont également soumis à des restrictions être connectés pour former le flux d'une tâche. Par exemple, l'application ne peut transmettre jusqu'à cinq modèles à la pile de l'écran. Voir Restrictions liées aux modèles.
Screen
Screen
est une classe fournie par bibliothèque que les applications implémentent pour gérer l'interface utilisateur présentée au utilisateur. UnScreen
a une cycle de vie et fournit le mécanisme permettant à l'application envoyez le modèle à afficher lorsque l'écran est visible.Screen
instance peut également être transférée et transmis vers et depuis une pileScreen
, ce qui s'assure qu'ils respectent les restrictions de flux de modèle.CarAppService
CarAppService
est un classeService
abstraite que votre application doit implémenter et exporter pour être découvert et géré par l'hôte. LeCarAppService
de votre appli est de vérifier qu'une connexion hôte peut être approuvée à l'aide decreateHostValidator
et en fournissantSession
pour chaque connexion à l'aide deonCreateSession
.Session
Session
est une classe abstraite votre application doit implémenter et renvoyerCarAppService.onCreateSession
Il sert de point d'entrée pour afficher des informations sur l'écran de la voiture. Il présente un cycle de vie qui indique l'état actuel de votre application sur l'écran de la voiture, par exemple lorsque votre application est visibles ou masquées.Lorsqu'une
Session
est démarrée, par exemple Lorsque l'application est lancée pour la première fois, l'hôte demande l'autorisationScreen
à afficher à l'aide de laonCreateScreen
.
Installer la bibliothèque Car App
Consulter la bibliothèque Jetpack page des versions de des instructions pour ajouter la bibliothèque à votre application.
Configurer les fichiers manifestes de votre application
Avant de pouvoir créer votre application pour voiture, vous devez configurer fichiers manifestes comme indiqué ci-dessous.
Déclarer votre CarAppService
L'hôte se connecte à votre application via votre
Implémentation de CarAppService
. Toi
Déclarez ce service dans votre fichier manifeste pour permettre à l'hôte de découvrir et de s'y connecter.
à votre application.
Vous devez également déclarer la catégorie de votre application dans le
l'élément <category>
de l'attribut
filtre d'intent intégré. Voir la liste des
catégories d'applications compatibles pour les valeurs autorisées pour
pour cet élément.
L'extrait de code suivant montre comment déclarer un service d'application pour voitures pour un point de centre 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 catégories 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 une fonctionnalité de navigation détaillée des itinéraires de navigation. Découvrez Créer des applications de navigation pour voitures. pour en savoir plus sur cette catégorie.androidx.car.app.category.POI
: application qui fournit des fonctionnalités pertinentes pour trouver des points d'intérêt comme des places de parking, des bornes de recharge des stations-service. Départ Créer des applications de point d'intérêt pour voitures pour de la documentation supplémentaire sur cette catégorie.androidx.car.app.category.IOT
: application qui permet aux utilisateurs d'effectuer des actions sur les appareils connectés depuis la voiture. Départ Créer des applications IoT (Internet des objets) pour voitures de la documentation supplémentaire sur cette catégorie.
Consultez l'article Qualité des applications Android pour les voitures pour une description détaillée de chaque catégorie et les critères d'appartenance des applications.
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 dans l'UI du système.
Vous pouvez spécifier le nom et l'icône utilisés pour représenter votre application dans
les label
et
Attributs 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 le champ
l'élément <service>
, l'hôte
revient aux valeurs spécifiées pour
<application>
Définir un thème personnalisé
Pour définir un thème personnalisé pour votre application pour voiture, ajoutez un
l'élément <meta-data>
dans votre
fichier manifeste, comme suit:
<meta-data android:name="androidx.car.app.theme" android:resource="@style/MyCarAppTheme />
Ensuite, déclarez votre ressource de style dans Définissez les attributs suivants pour votre thème d'application pour voitures personnalisé:
<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
les 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 classe
getCarAppApiLevel()
.
Déclarez le niveau d'API minimal Car App compatible avec votre application dans votre
Fichier AndroidManifest.xml
:
<manifest ...>
<application ...>
<meta-data
android:name="androidx.car.app.minCarApiLevel"
android:value="1"/>
</application>
</manifest>
Consultez la documentation
RequiresCarApi
pour savoir comment maintenir la rétrocompatibilité et déclarer
niveau d'API minimal requis pour utiliser une fonctionnalité. Pour savoir quelle API
requis pour utiliser une fonctionnalité de la bibliothèque Car App, consultez
documentation de référence
CarAppApiLevels
Créer votre CarAppService et votre session
Votre application doit étendre
la classe CarAppService
et implémenter
son
onCreateSession
, qui renvoie un Session
instance 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 responsable
en renvoyant l'instance Screen
pour 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 en gérant les liens profonds,
pré-alimenter une pile "Retour" d'écrans à l'aide de
ScreenManager.push
avant de revenir
onCreateScreen
Le pré-seed 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, vous devez définir des classes qui étendent les
Screen
et implémenter sa
onGetTemplate
, qui renvoie la méthode
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
Screen
qui utilise un
modèle PaneTemplate
sur
un simple message "Hello world!" chaîne:
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
accessibles à vos Session
et
Screen
instances. Il donne accès
aux services automobiles,
ScreenManager
pour gérer
pile d'écran; la
AppManager
pour les événements généraux liés aux applications
une fonctionnalité, telle que l'accès à l'objet Surface
pour dessiner des cartes ;
et NavigationManager
utilisé par les applications de navigation détaillée pour communiquer la navigation
de métadonnées et d'autres
liés à la navigation
des événements avec
l'hôte.
Pour en savoir plus, consultez la section Accéder au panneau de navigation. modèles pour liste complète des fonctionnalités de bibliothèque disponibles pour les applications de navigation.
CarContext
propose aussi d'autres
comme la possibilité de charger des ressources drawables à l'aide du fichier de configuration
depuis l'écran de la voiture, démarrer une application dans la voiture à l'aide d'intents ;
et indiquant 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'écrans que vous pouvez utiliser pour transférer des écrans qui s'affichent automatiquement
Lorsque l'utilisateur sélectionne un bouton "Retour" sur l'écran de la voiture ou utilise le bouton Retour du matériel
disponible dans certaines voitures.
L'extrait de code suivant montre comment ajouter une action "Retour" à un modèle de message en tant que ainsi qu'une action qui déclenche l'affichage d'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, automatiquement,
appelle ScreenManager.pop
.
Vous pouvez contourner ce comportement en utilisant la méthode
OnBackPressedDispatcher
d'instance est disponible
CarContext
Pour s'assurer que l'application peut être utilisée en toute sécurité pendant la conduite, la pile d'écran peut avoir un maximum une profondeur de cinq écrans. Consultez Restrictions liées aux modèles. pour en savoir plus.
Actualiser le contenu d'un modèle
Votre application peut demander le contenu d'une
Screen
soit invalidée en appelant la
Screen.invalidate
.
L'hôte rappelle ensuite le numéro de téléphone
Screen.onGetTemplate
pour récupérer le modèle avec les nouveaux contenus.
Lors de l'actualisation d'un Screen
, il est
important de comprendre le contenu spécifique du modèle qui peut être mis à jour
L'hôte ne comptabilise donc 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 manière à ce qu'il y ait un
un mappage entre un Screen
et le type de
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 que votre application utilise,
votre application doit déclarer l'autorisation androidx.car.app.ACCESS_SURFACE
dans son
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 une
SurfaceCallback
et fournissez
cette implémentation au AppManager
un entretien automobile. Le Surface
actuel est transmis à votre
SurfaceCallback
dans le paramètre SurfaceContainer
de
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. L'hôte communique la zone de la surface dont la garantie est
n'est pas obstruée et entièrement visible pour l'utilisateur en appelant la
SurfaceCallback.onVisibleAreaChanged
. 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 masquer
lorsque l'utilisateur n'a pas interagi avec l'écran pendant un certain temps afin d'en faire plus
d'espace pour la carte. Dans ce cas, il y a un rappel à onStableAreaChanged
et
onVisibleAreaChanged
par 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, là encore, 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 le bon paramètre sombre
couleurs lorsque l'hôte détermine que les conditions le justifient, comme décrit dans
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 vers
Session.onCarConfigurationChanged
Permettre aux utilisateurs d'interagir avec votre carte
Avec 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 le zoom et le 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é
Interface SurfaceCallback
dispose de 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:
Interaction | 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 pour les actions sur la carte, comme de zoom avant ou arrière, de recentrage, d'affichage d'une boussole et d'autres actions que vous choisir d'afficher. La bande d'actions sur la carte peut comporter jusqu'à quatre boutons ne contenant qu'une icône qui peut être actualisée sans affecter la profondeur des tâches. Elle est masquée en cas d'inactivité. et réapparaît à l'état actif.
Pour recevoir des rappels d'interactivité sur la carte, vous devez
doit 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 ci-dessous :
.
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 à l'entrée utilisateur en transmettant les écouteurs appropriés au
modèles qui les prennent en charge. L'extrait de code suivant montre comment créer un
Action
qui définit une
OnClickListener
qui
à 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 le
appli navigation par défaut voiture
à l'aide de la commande
CarContext.startCarApp
méthode:
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 lancement d'applications, y compris sur le format du
ACTION_NAVIGATE
, consultez Démarrer une application pour voitures avec un intent.
.
Certaines actions, telles que celles qui nécessitent de demander à l'utilisateur de poursuivre
interactions sur leurs appareils mobiles, ne sont autorisées que lorsque la voiture est à l'arrêt.
Vous pouvez utiliser
ParkedOnlyOnClickListener
pour mettre en œuvre ces actions. Si la voiture n'est pas garée, l'organisateur affiche une
indique à l'utilisateur que l'action n'est pas autorisée dans ce cas. Si la voiture
est parqué, le code s'exécute normalement. L'extrait de code suivant montre comment
utiliser l'ParkedOnlyOnClickListener
pour ouvrir l'écran des paramètres de 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 complétées par un
CarAppExtender
Certains attributs de notification, tels que le titre du contenu, le texte, l'icône et les actions,
Peut être défini dans CarAppExtender
, remplaçant les attributs de la notification
lorsqu'elles s'affichent sur l'écran de la voiture.
L'extrait de code suivant montre comment envoyer une notification à l'écran de la voiture qui affiche un titre 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.
- Une entrée dans le centre de notifications peut être ajoutée, éventuellement avec un badge visible dans le rail.
- Pour les applications de navigation, la notification peut s'afficher dans le widget de rail comme suit : décrits dans 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 fonction de la priorité de la notification, comme décrit
dans
CarAppExtender
dans la documentation Google Cloud.
Si
NotificationCompat.Builder.setOnlyAlertOnce
est appelée avec la valeur true
, une notification à priorité élevée s'affiche sous la forme
Une seule fois.
Pour en savoir plus sur la conception des notifications de votre application pour voiture, consultez les Guide de la conception Google pour la conduite sur Notifications :
Afficher les toasts
Votre application peut afficher un toast avec
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, par exemple
les règles standards d'Android
autorisations
s'appliquent. Pour demander une autorisation, vous pouvez utiliser le
CarContext.requestPermissions()
.
L'avantage d'utiliser
CarContext.requestPermissions()
, par opposition à l'utilisation
les API Android standards, est
qu'il n'est pas nécessaire de lancer votre propre Activity
Créer la boîte de dialogue d'autorisations. De plus, vous pouvez utiliser le même code
Android Auto et Android Automotive OS, au lieu de créer
en fonction 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
d'arrière-plan, déclarez un thème d'application pour voitures dans votre
AndroidManifest.xml
et définir l'attribut carPermissionActivityLayout
pour le thème de votre application pour voiture.
<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 du 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
ouvre votre application avec un écran qui affiche les détails d'une réservation de stationnement.
Vous étendez l'instance de notification avec un intent de contenu contenant
PendingIntent
encapsulant un élément explicite
à 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
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 fonction
Session.onNewIntent
de votre application gère cet intent en envoyant l'écran de réservation de stationnement
sur la pile, si ce n'est pas déjà fait:
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())); } } }
Pour en savoir plus, consultez la section Afficher les notifications. des informations sur la gestion des notifications pour l'application pour voiture.
Restrictions liées aux modèles
L'hôte limite au maximum le nombre de modèles à afficher pour une tâche donnée 5, dont le dernier doit correspondre à l'un des types suivants:
Notez que cette limite s'applique au nombre de modèles, et non au nombre de
Screen
instances dans la pile. Pour
Exemple : si une application envoie deux modèles sur l'écran A, puis pousse l'écran
B, il peut maintenant envoyer trois autres modèles. Si chaque écran est structuré
pour envoyer un seul modèle, l'application peut transmettre cinq instances d'écran
ScreenManager
.
Il existe des cas particuliers pour ces restrictions: actualisations de modèle, retour et lors des opérations de réinitialisation.
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 qui contient
le même contenu principal que le modèle précédent, le nouveau modèle n'est pas
sont comptabilisés dans le quota. Par exemple, la mise à jour de l'état d'activation/de désactivation d'une ligne dans une
ListTemplate
ne compte pas
sur le quota. Pour en savoir plus, consultez la documentation des modèles individuels
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
de la pile ScreenManager
et met à jour
le quota restant en fonction du nombre de modèles que l'application
vers l'arrière.
Par exemple, si l'application envoie deux modèles sur l'écran A, puis transfère écran B et envoie deux autres modèles, il reste un quota à l'application. Si l'application revient ensuite à l'écran A, l'hôte réinitialise le quota à trois, car l'application est rétrogradée de deux modèles.
Notez que, lorsque vous revenez à un écran, une application doit envoyer un modèle du même type que celui qui a été envoyé en dernier par cet écran. Envoyer une autre cause une erreur. Cependant, tant que le type lors d'une opération de retour, l'application peut modifier librement le contenu du 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. Pour
exemple :
NavigationTemplate
est une vue qui doit rester à l'écran et être actualisée avec les nouveaux
des instructions détaillées
pour la consommation de l’utilisateur. Lorsqu'il atteint l'un de ces
l'hôte réinitialise le quota de modèles, en traitant ce modèle comme
c'est la première étape
d'une nouvelle tâche. Cela permet à l'application de commencer une nouvelle tâche.
Consultez la documentation de chaque modèle 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 depuis le lanceur d'applications, le quota est également réinitialisé. Ce mécanisme permet à une application un nouveau flux de tâches à partir de notifications. Cela s'applique même si une application est déjà lié et au premier plan.
Pour en savoir plus, consultez la section Afficher les notifications. sur l'affichage des notifications de votre application sur l'écran de la voiture. Consultez le Consultez la section Démarrer une application automobile avec un intent pour découvrir comment pour lancer 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 à l'aide du
API CarConnection
pour
pour récupérer les informations de connexion au moment de l'exécution.
Par exemple, dans le Session
de votre application pour voiture, initialisez CarConnection
et
s'abonner 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
Chaque voiture peut autoriser un nombre différent de
Item
instances à afficher pour
l’utilisateur à la fois. Utilisez les
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 obtenir les
limite de contenu. Par exemple, pour obtenir le nombre d'éléments pouvant être affichés
une grille, appeler
getContentLimit
par
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 offre aux utilisateurs une expérience de connexion, vous pouvez utiliser des modèles tels que
le SignInTemplate
et LongMessageTemplate
avec l'API Car App niveau 2 ou supérieur pour gérer la connexion à votre application sur le
l'unité principale de la voiture.
Pour créer un SignInTemplate
, définissez un SignInMethod
. La voiture
La bibliothèque d'applications est actuellement compatible avec les méthodes de connexion suivantes:
InputSignInMethod
pour la connexion par nom d'utilisateur/mot de passe.PinSignInMethod
pour la connexion par code, lorsque 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, par exemple Google Sign-In et One Tap.QRCodeSignInMethod
permettant à l'utilisateur de scanner un code QR pour se connecter leur 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 une 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 de compte simplifiée: les utilisateurs peuvent facilement gérer tous leurs comptes dans le menu "Comptes" des paramètres système, y compris la procédure de connexion et à vous déconnecter.
- "Invité" expériences: les voitures étant des appareils partagés, les OEM peuvent permettre l'expérience des clients dans le véhicule, lorsqu'il n'est pas possible d'ajouter des comptes.
Ajouter des variantes de chaîne de texte
La quantité de texte peut varier selon la taille d'écran de la voiture. Avec l'API Car App
niveau 2 ou supérieur, vous pouvez spécifier plusieurs variantes d'une chaîne de texte pour
pour s'adapter à l'écran. Pour savoir où les variantes textuelles sont acceptées, recherchez des modèles et
composants qui utilisent un CarText
.
Vous pouvez ajouter des variantes de chaîne de texte à une CarText
avec le paramètre
CarText.Builder.addVariant()
méthode:
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 le plus court. L'hôte choisit la chaîne de longueur appropriée en fonction de la la quantité d'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
Consultez la documentation pour
CarIconSpan.create
pour en savoir plus sur la création de ces objets Span. Voir
Spantastique
stylisation du texte avec les segments pour découvrir comment fonctionne l'application d'un style de texte avec les segments.
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 pour accéder aux propriétés et aux capteurs du véhicule.
Conditions requises
Pour utiliser les API avec Android Auto, commencez par ajouter une dépendance à
androidx.car.app:app-projected
au fichier build.gradle
de votre appareil Android
Module automatique. Pour Android Automotive OS, ajoutez une dépendance à
androidx.car.app:app-automotive
au fichier build.gradle
de votre appareil Android
Automotive OS.
De plus, dans votre fichier AndroidManifest.xml
, vous devez
déclarer les autorisations nécessaires pour
demander les données de la voiture
que vous souhaitez utiliser. Notez que ces autorisations doivent également être
accordée par l'utilisateur. Vous pouvez utiliser
le même code sur Android Auto et Android Automotive OS,
que de créer des flux dépendants de la plate-forme. Toutefois, 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
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
<ph type="x-smartling-placeholder"></ph> Ces données ne sont disponibles que sur certains véhicules Android Automotive OS vous exécutez 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
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 un message d'erreur s'affiche, vérifiez le
état de
la valeur que vous avez demandée afin de mieux comprendre pourquoi les données que vous avez demandées
ne peuvent pas être récupérées. Consultez le
documentation de référence
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
données de localisation. La disponibilité de ces valeurs peut dépendre
OEM. Le format des données de l'accéléromètre, du gyroscope et de la boussole est le suivant :
comme vous le feriez avec
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 le
Autorisation android.permission.ACCESS_FINE_LOCATION
.
Tests
Pour simuler les données de capteurs lors des tests sur Android Auto, reportez-vous au Capteurs et Capteur de configuration de Guide de l'unité principale pour ordinateur. Simuler les données de capteurs lors des tests sur Android Automotive OS, reportez-vous à la documentation sur l'émulation matérielle section "État" d'Android Guide de l'émulateur Automotive OS.
Cycles de vie des CarAppService, des sessions et des écrans
Les Session
et
Les classes Screen
mettent en œuvre
LifecycleOwner
. En tant que
l'utilisateur interagit avec l'application, vos objets Session
et Screen
. cycle de vie
des rappels sont invoqués, comme décrit dans les schémas suivants.
Cycles de vie d'un CarAppService et d'une session
Pour en savoir plus, consultez la documentation
Session.getLifecycle
.
Cycle de vie d'un écran
Pour en savoir plus, consultez la documentation
Screen.getLifecycle
.
Enregistrer depuis le micro de la voiture
À l'aide de la fonction
CarAppService
et les
API CarAudioRecord
vous pouvez autoriser votre application à accéder au micro de la voiture de l'utilisateur. Les utilisateurs doivent donner
l'autorisation à votre application d'accéder au micro de la voiture. Votre application peut enregistrer et
traiter les entrées utilisateur
dans votre application.
Autorisation d'enregistrement
Avant d'effectuer un enregistrement audio, vous devez demander l'autorisation d'enregistrer dans votre
AndroidManifest.xml
et demandez à l'utilisateur de 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 Demande autorisations pour découvrir comment demander un l'autorisation dans votre application pour voiture.
Enregistrer un fichier audio
Une fois que l'utilisateur vous a autorisé à enregistrer, vous pouvez enregistrer l'audio et le 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 récupérer du son sélectionner s'assurer que tout média en cours est arrêté. Si vous perdez la priorité audio, arrêter 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
Tests Android for Cars
Library fournit des ressources 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 le bon
Screen
et
Template
sont créés et
renvoyé.
Consultez le Exemples pour obtenir des exemples d'utilisation.
Signaler un problème lié à la bibliothèque d'applications Android for Cars
Si vous constatez un problème dans la bibliothèque, signalez-le à l'aide du Issue Tracker de Google : Veillez à fournir toutes les informations requises dans le modèle dédié.
Avant de signaler un nouveau numéro, vérifiez s'il figure dans le communiqué de la bibliothèque. notes ou signalées dans la liste des problèmes. Vous pouvez vous abonner et voter pour des problèmes d'ici le en cliquant sur l'étoile pour un problème dans l'outil de suivi. Pour en savoir plus, consultez S'abonner à un problème.