Android for Cars App-Bibliothek verwenden

Die Android for Cars-App-Bibliothek können Sie Ihre Navigationselemente, POIs und das Internet der Dinge (Internet of Things, IoT) Apps für das Auto. Dazu gibt es eine Reihe von Vorlagen, mit denen die Ablenkung der Autofahrer reduziert werden kann. und auf Details wie die verschiedenen Faktoren für Autodisplays geachtet. und Eingabemodalitäten.

Dieser Leitfaden bietet einen Überblick über die wichtigsten Funktionen und Konzepte der Bibliothek sowie zeigt Ihnen, wie Sie eine einfache App einrichten.

Codelab

Grundlagen der Auto-App-Bibliothek

arrow_forward

Hinweis

1. Lesen Sie den Artikel Design für Fahrten mit dem Auto der Auto-App-Bibliothek <ph type="x-smartling-placeholder">
   </ph>
   • Navigations-Apps und andere Apps zum Autofahren Kategorieübersichten
   • Apps mit Vorlagen erstellen – Übersicht
   • Bausteine zu Vorlagen und Vorlagenkomponenten
   • Beispielabläufe gängige UX-Muster aufzuzeigen
   • Anforderungen an Vorlagen-Apps
2. Sehen Sie sich die wichtigen Begriffe und Konzepte im Folgenden an. .
3. Mach dich mit dem Android Auto-System vertraut Benutzeroberfläche und Android Automotive OS Design.
4. Lesen Sie die Versionshinweise.
5. Sehen Sie sich die Beispiele an.

Wichtige Begriffe und Konzepte

Modelle und Vorlagen

Die Benutzeroberfläche wird durch ein Diagramm mit Modellobjekten dargestellt. unterschiedlich angeordnet sind, wie es die Vorlage zulässt, zu der sie gehören. an. Vorlagen sind Teil der Modelle und können Grafiken. Modelle enthalten die Informationen, die dem Nutzer in der von Text und Bildern sowie Attribute zur Konfiguration von Aspekten des visuelle Darstellung solcher Informationen, z. B. Textfarben oder Bilder Größen. Der Host konvertiert die Modelle in Ansichten, die auf die Ablenkungsstandards für Autofahrer und achtet auf Details wie die Vielfalt von Autodisplay-Faktoren und Eingabemodalitäten.

Host

Der Host ist die Back-End-Komponente, die die angebotenen Funktionen implementiert die APIs der Bibliothek anpassen, damit Ihre App im Auto ausgeführt werden kann. Die Die Aufgaben des Hosts reichen von der Entdeckung Ihrer App bis hin zur Verwaltung bis zum Umwandeln Ihrer Modelle in Ansichten und Benachrichtigen Ihrer App der Nutzerinteraktionen. Auf Mobilgeräten wird dieser Host von Android implementiert. Automatisch. Unter Android Automotive OS wird dieser Host als System-App installiert.

Vorlageneinschränkungen

Für die verschiedenen Vorlagen gelten inhaltliche Einschränkungen. Für Beispiel: Bei Listenvorlagen ist die Anzahl der Elemente begrenzt, die dem Nutzer präsentiert werden. Für Vorlagen gelten außerdem Einschränkungen miteinander verbunden sein, um den Ablauf einer Aufgabe zu bilden. Die App kann beispielsweise nur Push-Benachrichtigungen bis zu fünf Vorlagen hinzufügen. Weitere Informationen finden Sie unter Weitere Informationen zu Vorlageneinschränkungen

Screen

Screen ist eine Klasse, die vom Bibliothek, die von Apps implementiert wird, um die Benutzeroberfläche zu verwalten, die der Nutzer. Screen hat einen Lebenszyklus und stellt den Mechanismus bereit, über den die App Vorlage senden, die angezeigt wird, wenn der Bildschirm sichtbar ist. Screen Instanzen können auch per Push übertragen werden und in einen Screen-Stack geknackt, sicherstellen, dass sie die Einschränkungen des Vorlagenflusses.

CarAppService

CarAppService ist ein Service-Klasse, die in Ihrer App müssen implementiert und exportiert werden, damit sie vom Host erkannt und verwaltet werden können. Die CarAppService deiner App ist ist für die Validierung der vertrauenswürdigen Hostverbindung mithilfe von createHostValidator und geben anschließend Session an für jede Verbindung mithilfe von onCreateSession

Session

Session ist eine abstrakte Klasse, die muss Ihre App mithilfe von CarAppService.onCreateSession. Sie dient als Einstiegspunkt für die Anzeige von Informationen auf dem Autodisplay. Es hat einen Lebenszyklus, der den den aktuellen Status Ihrer App auf dem Autodisplay zu sehen, z. B. wann Ihre App sichtbar oder ausgeblendet.

Wenn ein Session gestartet wird, z. B. wenn die App zum ersten Mal gestartet wird, fordert der Host die erste Screen zum Anzeigen mithilfe der onCreateScreen .

Car App-Bibliothek installieren

Jetpack-Bibliothek ansehen Release-Seite für wie du die Bibliothek zu deiner App hinzufügst.

Manifestdateien Ihrer App konfigurieren

Bevor du die Auto-App erstellen kannst, musst du die Einstellungen deiner App konfigurieren Manifestdateien wie nachfolgend beschrieben.

CarAppService deklarieren

Der Host stellt über Ihr CarAppService-Implementierung Ich Deklariere diesen Dienst in deinem Manifest, damit der Host erkennen und eine Verbindung herstellen kann zu Ihrer App hinzufügen.

Außerdem müssen Sie die Kategorie Ihrer App im <category>-Elements Ihrer App Intent-Filter. Liste der unterstützten App-Kategorien für die zulässigen Werte für dieses Element.

Das folgende Code-Snippet zeigt, wie ein Auto-App-Dienst für einen Punkt Interessen-App in Ihrem Manifest verwenden:

<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>

Unterstützte App-Kategorien

Geben Sie die Kategorie Ihrer App an, indem Sie mindestens eine der folgenden Kategorien hinzufügen im Intent-Filter, wenn Sie CarAppService wie beschrieben deklarieren im vorherigen Abschnitt:

• androidx.car.app.category.NAVIGATION: eine App, die eine detaillierte Routenführung bietet Wegbeschreibungen. Weitere Informationen finden Sie unter Navigations-Apps für Autos entwickeln. finden Sie weitere Informationen zu dieser Kategorie.
• androidx.car.app.category.POI: eine App mit relevanten Funktionen um POIs wie Parkplätze, Ladestationen und Tankstellen. Zur Kasse POI-Apps für Autos erstellen für weitere Dokumentation zu dieser Kategorie.
• androidx.car.app.category.IOT: Eine App, mit der Nutzer relevante Aktionen auf verbundenen Geräten aus dem Auto heraus. Zur Kasse Apps für das Internet der Dinge für Autos entwickeln weitere Dokumentation zu dieser Kategorie.

Siehe Qualitätsrichtlinien für Android-Apps für Autos für detaillierte Beschreibungen der einzelnen Kategorien und Kriterien für die jeweiligen Apps.

Name und Symbol der App angeben

Sie müssen einen App-Namen und ein Symbol angeben, die der Host zur Darstellung Ihrer App auf der System-UI.

Sie können den Namen und das Symbol der App, die zur Darstellung Ihrer App verwendet werden, mithilfe von label und icon Attribute Ihrer CarAppService:

...
<service
   android:name=".MyCarAppService"
   android:exported="true"
   android:label="@string/my_app_name"
   android:icon="@drawable/my_app_icon">
   ...
</service>
...

Wenn das Label oder Symbol nicht im Element <service>, der Host auf die Werte zurück, die für den <application>-Element.

Benutzerdefiniertes Design festlegen

Wenn du ein benutzerdefiniertes Design für deine Auto-App festlegen möchtest, füge ein <meta-data>-Element in Ihrem Manifestdatei so an:

<meta-data
    android:name="androidx.car.app.theme"
    android:resource="@style/MyCarAppTheme />

Deklarieren Sie dann Ihre Stilressource, Legen Sie die folgenden Attribute für Ihr benutzerdefiniertes Auto-App-Design fest:

<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>

Car App API-Level

Die Car App Library definiert ihre eigenen API-Ebenen, damit Sie wissen, welche Bibliotheksfunktionen vom Vorlagenhost des Fahrzeugs unterstützt werden. Um das höchste von einem Host unterstützte Car App-API-Level abzurufen, verwende die getCarAppApiLevel() .

Gib das von deiner App unterstützte Mindest-API-Level für die Car App in deinem AndroidManifest.xml-Datei:

<manifest ...>
    <application ...>
        <meta-data
            android:name="androidx.car.app.minCarApiLevel"
            android:value="1"/>
    </application>
</manifest>

Weitere Informationen finden Sie in der Dokumentation zum RequiresCarApi -Anmerkung für Details zur Aufrechterhaltung der Abwärtskompatibilität und das für die Nutzung einer Funktion erforderliche Mindest-API-Level haben. Für eine Definition welcher API ist für die Verwendung einer bestimmten Funktion der Auto-App-Bibliothek erforderlich. Referenzdokumentation für CarAppApiLevels

CarAppService und Sitzung erstellen

Deine App muss die CarAppService-Klasse und implementieren sein onCreateSession , die ein Session zurückgibt. Instanz, die der aktuellen Verbindung zum Host entspricht:

class HelloWorldService : CarAppService() {
    ...
    override fun onCreateSession(): Session {
        return HelloWorldSession()
    }
    ...
}

public final class HelloWorldService extends CarAppService {
    ...
    @Override
    @NonNull
    public Session onCreateSession() {
        return new HelloWorldSession();
    }
    ...
}

Die Instanz Session ist verantwortlich für Rückgabe der Instanz Screen zur Verwendung des wenn die App zum ersten Mal gestartet wird:

class HelloWorldSession : Session() {
    ...
    override fun onCreateScreen(intent: Intent): Screen {
        return HelloWorldScreen(carContext)
    }
    ...
}

public final class HelloWorldSession extends Session {
    ...
    @Override
    @NonNull
    public Screen onCreateScreen(@NonNull Intent intent) {
        return new HelloWorldScreen(getCarContext());
    }
    ...
}

Für Szenarien, in denen die Auto-App mit einem Bildschirm starten muss, der nicht Start- oder Landingpage der App, z. B. bei der Verwendung von Deeplinks, können Sie einen Back-Stack von Bildschirmen mithilfe ScreenManager.push vor der Rückkehr von onCreateScreen Mit Pre-Seeding können Nutzende vom ersten auf dem Ihre App angezeigt wird.

Startbildschirm erstellen

Sie erstellen die Bildschirme, die von Ihrer App angezeigt werden, indem Sie Klassen definieren, die die Screen-Klasse und Implementierung der onGetTemplate , die die Methode Template-Instanz, die darstellt Status der Benutzeroberfläche, die auf dem Autodisplay angezeigt werden soll.

Das folgende Snippet zeigt, wie ein Screen mit einem Vorlage PaneTemplate für eine einfache „Hallo Welt!“- String:

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()
    }
}

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();
    }
}

CarContext-Klasse

Die Klasse CarContext ist eine ContextWrapper-Unterklasse zugänglich für Session und Screen Instanzen. Sie bietet Zugriff Autodienste wie die ScreenManager zum Verwalten des Screen Stack die AppManager für allgemeine App-bezogene Funktionalität, wie der Zugriff auf das Objekt Surface zum Zeichnen von Karten; und die NavigationManager wird von Apps für die detaillierte Routenführung verwendet, um die Navigation zu kommunizieren. Metadaten und andere navigationsbezogen Events mit den Organisator.

Weitere Informationen finden Sie unter Auf die Navigation zugreifen. Vorlagen für ein umfassende Liste der für Navigations-Apps verfügbaren Bibliotheksfunktionen

CarContext bietet auch weitere Funktionen wie das Laden von Drawable-Ressourcen mithilfe der über das Autodisplay, das Starten einer App im Auto mit Intents, und signalisieren, ob die Karte in Ihrer App im dunklen Design angezeigt werden soll.

Bildschirmnavigation implementieren

Apps zeigen oft eine Reihe verschiedener Bildschirme an, die jeweils verschiedene Vorlagen, durch die Nutzende navigieren können, wenn sie mit die auf dem Bildschirm angezeigte Benutzeroberfläche.

Die Klasse ScreenManager bietet Einen Screen Stack, mit dem Sie Bildschirme verschieben können, die automatisch geöffnet werden können Der Nutzer wählt auf dem Autodisplay eine Schaltfläche „Zurück“ aus oder verwendet die Hardware in der Rückseite. in einigen Autos verfügbar.

Das folgende Snippet zeigt, wie Sie einer Nachrichtenvorlage eine Aktion „Zurück“ hinzufügen: sowie eine Aktion, die einen neuen Bildschirm öffnet, wenn sie vom Benutzer ausgewählt wird:

val template = MessageTemplate.Builder("Hello world!")
    .setHeaderAction(Action.BACK)
    .addAction(
        Action.Builder()
            .setTitle("Next screen")
            .setOnClickListener { screenManager.push(NextScreen(carContext)) }
            .build())
    .build()

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();

Das Objekt Action.BACK ist ein Standard-Action, die automatisch ruft ScreenManager.pop auf. Dieses Verhalten kann mit der Methode OnBackPressedDispatcher Instanz verfügbar im CarContext.

Um sicherzustellen, dass die App während der Fahrt sicher genutzt werden kann, kann der Screen Stack maximal mit fünf Bildschirmen. Siehe Vorlageneinschränkungen .

Inhalt einer Vorlage aktualisieren

Deine App kann den Inhalt eines Screen wird durch Aufrufen der Methode Screen.invalidate-Methode. Der Host ruft anschließend die Funktion Screen.onGetTemplate , um die Vorlage mit dem neuen Inhalt abzurufen.

Wenn Sie ein Screen aktualisieren, ist es wichtig, den spezifischen Inhalt der Vorlage zu verstehen, der aktualisiert werden kann. sodass der Host die neue Vorlage nicht auf das Vorlagenkontingent angerechnet. Weitere Informationen finden Sie im Abschnitt Vorlageneinschränkungen.

Wir empfehlen Ihnen, Ihre Bildschirme so zu strukturieren, dass Sie Zuordnung zwischen Screen und dem Typ Vorlage, die über die onGetTemplate-Implementierung zurückgegeben wird.

Karten zeichnen

Navigations- und POI-Apps, die die folgenden Vorlagen verwenden, können Karten zeichnen, indem Sie auf ein Surface zugreifen:

Berechtigung für die Oberfläche deklarieren

Neben der Berechtigung, die für die von Ihrer App verwendete Vorlage erforderlich ist, für deine App die Berechtigung „androidx.car.app.ACCESS_SURFACE“ in den AndroidManifest.xml, um Zugriff auf die Oberfläche zu erhalten:

<manifest ...>
  ...
  <uses-permission android:name="androidx.car.app.ACCESS_SURFACE" />
  ...
</manifest>

Zugriff auf die Oberfläche

Für den Zugriff auf die vom Host bereitgestellten Surface müssen Sie eine SurfaceCallback und geben Sie diese Implementierung im AppManager Autoservice. Der aktuelle Surface wird an Ihr SurfaceCallback im Parameter SurfaceContainer des onSurfaceAvailable()- und onSurfaceDestroyed()-Callbacks.

carContext.getCarService(AppManager::class.java).setSurfaceCallback(surfaceCallback)

carContext.getCarService(AppManager.class).setSurfaceCallback(surfaceCallback);

Den sichtbaren Bereich der Oberfläche verstehen

Der Host kann Benutzeroberflächenelemente für die Vorlagen auf der Karte. Der Host gibt den Bereich der Oberfläche an, der garantiert nicht verdeckt und für den Nutzer vollständig sichtbar sind. SurfaceCallback.onVisibleAreaChanged . Um die Anzahl der Änderungen zu minimieren, ruft der Host außerdem die SurfaceCallback.onStableAreaChanged mit dem kleinsten Rechteck, das basierend auf der Methode aktuelle Vorlage.

Wenn eine Navigations-App beispielsweise die NavigationTemplate mit einer Aktionsleiste oben lässt sie sich ausblenden. wenn der Nutzer länger nicht mit dem Bildschirm interagiert hat, Platz für die Karte. In diesem Fall gibt es einen Callback von onStableAreaChanged und onVisibleAreaChanged mit demselben Rechteck. Ist die Aktionsleiste ausgeblendet, wird nur onVisibleAreaChanged mit dem größeren Gebiet aufgerufen. Wenn der Nutzer mit dem Bildschirm interagiert, dann wird ebenfalls nur onVisibleAreaChanged mit mit dem ersten Rechteck.

Dunkles Design unterstützen

Apps müssen ihre Karte auf die Surface-Instanz mit der entsprechenden dunklen wenn der Host bestimmte Bedingungen erfüllt, wie in Qualität von Android-Apps für Autos.

Um zu entscheiden, ob eine dunkle Karte gezeichnet werden soll, können Sie die CarContext.isDarkMode . Immer wenn sich der Status des dunklen Designs ändert, erhalten Sie einen Anruf an Session.onCarConfigurationChanged

Nutzern die Interaktion mit Ihrer Karte ermöglichen

Wenn Sie die folgenden Vorlagen verwenden, können Sie Unterstützung für die Interaktion der Nutzer hinzufügen mit den von Ihnen gezeichneten Karten erstellen, z. B. indem Sie ihnen Zoomen und Schwenken.

Interaktivitäts-Callbacks implementieren

SurfaceCallback-Oberfläche verfügt über mehrere Callback-Methoden, die Sie implementieren können, um die erstellten Karten interaktiv zu gestalten. mit den Vorlagen im vorherigen Abschnitt:

Kartenaktionsleiste hinzufügen

Diese Vorlagen können eine Leiste mit Kartenaktionen für kartenbezogene Aktionen enthalten, z. B. wie Sie heran- und herauszoomen, zentrieren, einen Kompass anzeigen und auswählen, die angezeigt werden sollen. Die Kartenaktionsleiste kann bis zu vier Schaltflächen enthalten, die nur mit Symbolen versehen sind. die ohne Auswirkungen auf die Aufgabentiefe aktualisiert werden kann. Bei Inaktivität wird es ausgeblendet. und erscheint im aktiven Status wieder.

Um Interaktions-Callbacks für Karten zu erhalten, müssen Sie muss die Schaltfläche Action.PAN in der Aktionsleiste der Karte hinzugefügt werden. Wenn Nutzende die Schaltfläche zum Schwenken drückt, wechselt der Host in den Schwenkmodus, wie im Folgenden beschrieben. .

Wenn in deiner App das Feld Action.PAN weggelassen wird auf der Kartenaktionsleiste hat, erhält sie keine Nutzereingabe SurfaceCallback-Methoden und der Host beendet alle zuvor aktivierten Methoden Schwenkmodus.

Auf einem Touchscreen wird die Schaltfläche zum Schwenken nicht angezeigt.

Schwenkmodus

Im Schwenkmodus übersetzt der Vorlagenhost die Nutzereingabe aus einer berührungslosen Eingabe wie Drehregler und Touchpads, in die entsprechenden SurfaceCallback-Methoden. Auf Nutzeraktion reagieren, um den Schwenkmodus zu starten oder zu beenden mit dem setPanModeListener in NavigationTemplate.Builder. Der Organisator kann andere UI ausblenden. Komponenten in der Vorlage bearbeiten, während der Nutzer sich im Schwenkmodus befindet.

Mit den Nutzenden interagieren

Ihre App kann mithilfe von Mustern, die denen in einer mobilen App ähneln, mit dem Nutzer interagieren.

Nutzereingaben verarbeiten

Ihre App kann auf Nutzereingaben reagieren, indem sie die entsprechenden Listener an die die sie unterstützen. Das folgende Snippet zeigt, wie ein Action-Modell, das ein OnClickListener, die einen Aufruf an eine Methode zurück, die durch den Code Ihrer App definiert ist:

val action = Action.Builder()
    .setTitle("Navigate")
    .setOnClickListener(::onClickNavigate)
    .build()

Action action = new Action.Builder()
    .setTitle("Navigate")
    .setOnClickListener(this::onClickNavigate)
    .build();

Mit der Methode onClickNavigate kann dann Standardnavigation Auto-App mit der Methode CarContext.startCarApp :

private fun onClickNavigate() {
    val intent = Intent(CarContext.ACTION_NAVIGATE, Uri.parse("geo:0,0?q=" + address))
    carContext.startCarApp(intent)
}

private void onClickNavigate() {
    Intent intent = new Intent(CarContext.ACTION_NAVIGATE, Uri.parse("geo:0,0?q=" + address));
    getCarContext().startCarApp(intent);
}

Weitere Informationen zum Starten von Apps, einschließlich des Formats der Intent ACTION_NAVIGATE, siehe Auto-App mit einem Intent starten .

Einige Aktionen, z. B. solche, die den Nutzer zum Fortfahren anweisen müssen Interaktionen auf ihren Mobilgeräten sind, sind nur zulässig, wenn das Auto geparkt ist. Sie können die ParkedOnlyOnClickListener um diese Aktionen umzusetzen. Wenn das Auto nicht geparkt ist, zeigt der Organisator eine Ein Hinweis für den Nutzer, dass die Aktion in diesem Fall nicht zulässig ist. Wenn das Auto geparkt ist, wird der Code normal ausgeführt. Das folgende Snippet zeigt, ParkedOnlyOnClickListener verwenden zum Öffnen eines Einstellungsbildschirms auf dem Mobilgerät:

val row = Row.Builder()
    .setTitle("Open Settings")
    .setOnClickListener(ParkedOnlyOnClickListener.create(::openSettingsOnPhone))
    .build()

Row row = new Row.Builder()
    .setTitle("Open Settings")
    .setOnClickListener(ParkedOnlyOnClickListener.create(this::openSettingsOnPhone))
    .build();

Benachrichtigungen anzeigen

An das Mobilgerät gesendete Benachrichtigungen werden nur dann auf dem Autodisplay angezeigt, wenn werden sie um eine CarAppExtender Einige Benachrichtigungsattribute wie Inhaltstitel, Text, Symbol und Aktionen kann im CarAppExtender festgelegt werden und überschreibt dabei die Attribute der Benachrichtigung wenn sie auf dem Autodisplay erscheinen.

Das folgende Snippet zeigt, wie Sie eine Benachrichtigung an das Autodisplay senden, zeigt einen anderen Titel als den auf dem Mobilgerät angezeigten an:

val notification = NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID)
    .setContentTitle(titleOnThePhone)
    .extend(
        CarAppExtender.Builder()
            .setContentTitle(titleOnTheCar)
            ...
            .build())
    .build()

Notification notification = new NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID)
    .setContentTitle(titleOnThePhone)
    .extend(
        new CarAppExtender.Builder()
            .setContentTitle(titleOnTheCar)
            ...
            .build())
    .build();

Benachrichtigungen können sich auf die folgenden Bereiche der Benutzeroberfläche auswirken:

• Dem Nutzer kann eine Warnmeldung (HUN) angezeigt werden.
• Ein Eintrag im Benachrichtigungscenter kann hinzugefügt werden, optional mit einem Badge. in der Leiste sichtbar.
• Bei Navigations-Apps kann die Benachrichtigung im Eisenbahn-Widget als beschrieben in Detaillierte Benachrichtigungen.

Sie können die Benachrichtigungen Ihrer App so konfigurieren, dass sie sich auf Elemente der Benutzeroberfläche mithilfe der Priorität der Benachrichtigung, in der CarAppExtender Dokumentation.

Wenn NotificationCompat.Builder.setOnlyAlertOnce mit dem Wert true aufgerufen wird, wird eine Benachrichtigung mit hoher Priorität Nur einmal JAGEN.

Weitere Informationen zur Gestaltung der Benachrichtigungen deiner Auto-App findest du in der Leitfaden zu Google Design for Driving Benachrichtigungen:

Toasts anzeigen

Ihre App kann einen Toast anzeigen mit CarToast wie in diesem Snippet gezeigt:

CarToast.makeText(carContext, "Hello!", CarToast.LENGTH_SHORT).show()

CarToast.makeText(getCarContext(), "Hello!", CarToast.LENGTH_SHORT).show();

Berechtigungen anfordern

Wenn Ihre App Zugriff auf eingeschränkte Daten oder Aktionen benötigt, z. B. Standort: die Standardregeln von Android Berechtigungen angewendet werden. Eine Berechtigung können Sie mit dem CarContext.requestPermissions() .

Die Vorteile der Verwendung von CarContext.requestPermissions(), im Gegensatz zur Verwendung von Android-Standard-APIs dass Sie keine eigene Activity starten müssen, erstellen Sie das Berechtigungsdialogfeld. Außerdem können Sie denselben Code für beide Android Auto und Android Automotive OS erstellen, anstatt plattformabhängigen Abläufen.

Dialogfeld für Berechtigungen in Android Auto gestalten

In Android Auto wird das Berechtigungsdialogfeld für den Nutzer auf dem Smartphone angezeigt. Standardmäßig wird kein Hintergrund hinter dem Dialogfeld angezeigt. So legen Sie ein benutzerdefiniertes Hintergrund, legen Sie ein Auto-App-Design in Ihrem AndroidManifest.xml und lege das Attribut carPermissionActivityLayout fest. für dein Auto-App-Design.

<meta-data
    android:name="androidx.car.app.theme"
    android:resource="@style/MyCarAppTheme />

Legen Sie dann das Attribut carPermissionActivityLayout für das Design Ihrer Auto-App fest:

<resources>
  <style name="MyCarAppTheme">
    <item name="carPermissionActivityLayout">@layout/my_custom_background</item>
  </style>
</resources>

Auto-App mit Intent starten

Sie können die Methode CarContext.startCarApp , um eine der folgenden Aktionen auszuführen:

• Öffne die Telefon App, um einen Anruf zu tätigen.
• Mit dem Navigationssymbol Standardnavigation Auto-App.
• Starten Sie Ihre eigene App mit einem Intent.

Das folgende Beispiel zeigt, wie Sie eine Benachrichtigung mit einer Aktion erstellen, die öffnet Ihre App mit einem Bildschirm, auf dem die Details einer Parkplatzreservierung angezeigt werden. Sie erweitern die Benachrichtigungsinstanz um einen Inhalts-Intent, der einen PendingIntent, die einen expliziten der Aktion Ihrer App entsprechen:

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())

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());

Ihre App muss außerdem eine BroadcastReceiver ist wird aufgerufen, um den Intent zu verarbeiten, wenn der Nutzer die Aktion im Benachrichtigungsoberfläche und ruft CarContext.startCarApp mit einem Intent, der den Daten-URI enthält:

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)))
        }
    }
}

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)));
        }
    }
}

Die Funktion Session.onNewIntent verarbeitet diesen Intent in Ihrer App, indem der Bildschirm für die Parkplatzreservierung im Stapel, falls er nicht bereits ganz oben steht:

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))
        }
    }
}

@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()));
        }
    }
}

Weitere Informationen finden Sie im Abschnitt Benachrichtigungen anzeigen. Informationen zum Umgang mit Benachrichtigungen in der Auto-App.

Vorlageneinschränkungen

Der Host beschränkt die Anzahl der Vorlagen, die für eine bestimmte Aufgabe angezeigt werden, auf ein Maximum von fünf, wobei die letzte Vorlage einen der folgenden Typen haben muss:

• NavigationTemplate
• PaneTemplate
• MessageTemplate

Dieses Limit gilt für die Anzahl der Vorlagen, nicht für Screen Instanzen im Stack. Für Beispiel: Wenn eine App in Bildschirm A zwei Vorlagen sendet und dann B, jetzt kann er drei weitere Vorlagen senden. Wenn jeder Bildschirm strukturiert ist, Vorlage senden, kann die App fünf Bildschirminstanzen an die ScreenManager Stapel.

Bei diesen Einschränkungen gibt es Sonderfälle: Vorlagen werden aktualisiert, Vorgänge zurücksetzen.

Vorlage wird aktualisiert

Bestimmte Inhaltsaktualisierungen werden nicht auf die Vorlagenbeschränkung angerechnet. Im Allgemeinen Eine App überträgt eine neue Vorlage desselben Typs und enthält mit dem Hauptinhalt der vorherigen Vorlage, wird die neue Vorlage auf das Kontingent angerechnet. Wenn Sie beispielsweise den Umschaltstatus einer Zeile in einer ListTemplate wird nicht gezählt auf das Kontingent angerechnet. Weitere Informationen finden Sie in der Dokumentation zu den einzelnen Vorlagen welche inhaltlichen Änderungen als Auffrischung infrage kommen.

Back-Operationen

Um untergeordnete Abläufe innerhalb einer Aufgabe zu aktivieren, erkennt der Host, wenn eine App Screen aus dem ScreenManager-Stack und Updates das verbleibende Kontingent basierend auf der Anzahl der Vorlagen, rückwärts durch.

Wenn die App in Bildschirm A beispielsweise zwei Vorlagen sendet, zwei weitere Vorlagen sendet, hat die App noch ein Kontingent übrig. Wenn kehrt die App wieder zu Bildschirm A zurück, setzt der Host das Kontingent auf drei zurück, in der App um zwei Vorlagen zurückgegangen.

Wenn eine App wieder auf dem Bildschirm erscheint, muss sie eine Vorlage senden, des gleichen Typs wie die zuletzt von diesem Bildschirm gesendete Nachricht. Weitere Vorlagentyp verursacht einen Fehler. Solange der Typ jedoch weiterhin der während eines Backvorgangs identisch sind, kann eine App den Inhalt der ohne das Kontingent zu beeinträchtigen.

Vorgänge zurücksetzen

Bestimmte Vorlagen haben eine spezielle Semantik, die das Ende einer Aufgabe kennzeichnet. Für Beispiel: Der Parameter NavigationTemplate ist eine Ansicht, die voraussichtlich auf dem Bildschirm bleibt und mit neuen detaillierte Anleitungen für die Nutzung durch die Nutzenden. Wenn eines dieser Ziele erreicht wird, Vorlagen, setzt der Host das Vorlagenkontingent zurück und behandelt sie ist dies der erste Schritt einer neuen Aufgabe. Dadurch kann die App eine neue Aufgabe starten. In der Dokumentation der einzelnen Vorlagen erfahren Sie, welche Vorlagen das Zurücksetzen auslösen. auf dem Host.

Wenn der Host einen Intent zum Starten der App über eine Benachrichtigungsaktion oder wird auch das Kontingent zurückgesetzt. Mit diesem Mechanismus kann eine App einen neuen Aufgabenfluss aus Benachrichtigungen starten. Dies gilt auch dann, wenn eine App die bereits gebunden sind und sich im Vordergrund befinden.

Weitere Informationen finden Sie im Abschnitt Benachrichtigungen anzeigen. zur Anzeige von App-Benachrichtigungen auf dem Autodisplay. Weitere Informationen finden Sie in der Im Abschnitt Auto-App mit Intent starten findest du Informationen dazu, um deine App über eine Benachrichtigungsaktion zu starten.

Verbindungs-API

Sie können feststellen, ob Ihre App für Android Auto oder Android ausgeführt wird Automotive OS mithilfe der CarConnection API für um Verbindungsinformationen zur Laufzeit abzurufen.

Initialisieren Sie beispielsweise in der Session Ihrer Auto-App eine CarConnection und Abonniere LiveData Updates:

CarConnection(carContext).type.observe(this, ::onConnectionStateUpdated)

new CarConnection(getCarContext()).getType().observe(this, this::onConnectionStateUpdated);

Im Beobachter können Sie dann auf Änderungen im Verbindungsstatus reagieren:

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()
}

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();
}

Einschränkungs-API

Je nach Fahrzeug ist die Anzahl der Item Instanzen für die Anzeige für die Nutzenden nacheinander. Verwenden Sie die Methode ConstraintManager um das Inhaltslimit während der Laufzeit zu überprüfen und die entsprechende Anzahl von Elementen festzulegen in Ihren Vorlagen.

Fordern Sie zuerst ein ConstraintManager von CarContext an:

val manager = carContext.getCarService(ConstraintManager::class.java)

ConstraintManager manager = getCarContext().getCarService(ConstraintManager.class);

Anschließend können Sie das abgerufene ConstraintManager-Objekt für die entsprechende Abfrage Inhaltsbeschränkung Um beispielsweise die Anzahl der Artikel zu ermitteln, ein Raster, einen getContentLimit mit CONTENT_LIMIT_TYPE_GRID:

val gridItemLimit = manager.getContentLimit(ConstraintManager.CONTENT_LIMIT_TYPE_GRID)

int gridItemLimit = manager.getContentLimit(ConstraintManager.CONTENT_LIMIT_TYPE_GRID);

Anmeldevorgang hinzufügen

Wenn Nutzer in Ihrer App angemeldet sind, können Sie Vorlagen wie diese verwenden: SignInTemplate und LongMessageTemplate mit Car App API-Level 2 und höher, um die Anmeldung in Ihrer App auf der des Infotainmentsystems des Autos.

Definieren Sie einen SignInMethod, um eine SignInTemplate zu erstellen. Das Auto Die App-Bibliothek unterstützt derzeit die folgenden Anmeldemethoden:

• InputSignInMethod für die Anmeldung mit Nutzername/Passwort.
• PinSignInMethod für die PIN-Anmeldung, bei der der Nutzer sein Konto über sein Smartphone verknüpft mit einer PIN, die auf dem Infotainmentsystem angezeigt wird.
• ProviderSignInMethod für die Anmeldung über einen Anbieter, z. B. Google Log-in und One Tap.
• QRCodeSignInMethod für die Anmeldung mit einem QR-Code, bei der der Nutzer einen QR-Code scannt, um die Anmeldung abzuschließen ihr Smartphone. Diese Option ist für Car-API-Level 4 und höher verfügbar.

Um beispielsweise eine Vorlage zu implementieren, die das Passwort des Nutzers erfasst, beginnen Sie mit InputCallback wird erstellt zur Verarbeitung und Validierung von Nutzereingaben:

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.
    }
}

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.
    }
};

Für InputSignInMethod Builder ist ein InputCallback erforderlich.

val passwordInput = InputSignInMethod.Builder(callback)
    .setHint("Password")
    .setInputType(InputSignInMethod.INPUT_TYPE_PASSWORD)
    ...
    .build()

InputSignInMethod passwordInput = new InputSignInMethod.Builder(callback)
    .setHint("Password")
    .setInputType(InputSignInMethod.INPUT_TYPE_PASSWORD)
    ...
    .build();

Verwenden Sie schließlich Ihren neuen InputSignInMethod, um einen SignInTemplate zu erstellen.

SignInTemplate.Builder(passwordInput)
    .setTitle("Sign in with username and password")
    .setInstructions("Enter your password")
    .setHeaderAction(Action.BACK)
    ...
    .build()

new SignInTemplate.Builder(passwordInput)
    .setTitle("Sign in with username and password")
    .setInstructions("Enter your password")
    .setHeaderAction(Action.BACK)
    ...
    .build();

Account Manager verwenden

Für Android Automotive OS-Apps mit Authentifizierung muss Folgendes verwendet werden: AccountManager aus den folgenden Gründen:

• Bessere Benutzeroberfläche und einfachere Kontoverwaltung: Nutzer können alles ganz einfach verwalten. über das Menü „Konten“ in den Systemeinstellungen, einschließlich der Anmeldung und sich abmelden.
• „Gast“ Da Autos gemeinsam genutzte Geräte sind, können OEMs Gästeerlebnisse im Fahrzeug, bei denen keine Konten hinzugefügt werden können.

Textstringvarianten hinzufügen

Je nach Größe des Autodisplays können unterschiedliche Textmengen angezeigt werden. Mit Car App API ab 2 können Sie mehrere Varianten einer Textzeichenfolge angeben, an die Bildschirmgröße anpassen. Um zu sehen, wo Textvarianten akzeptiert werden, suchen Sie nach Vorlagen und Komponenten, die ein CarText verwenden.

Sie können einer CarText Textstringvarianten mit dem Parameter CarText.Builder.addVariant() :

val itemTitle = CarText.Builder("This is a very long string")
    .addVariant("Shorter string")
    ...
    .build()

CarText itemTitle = new CarText.Builder("This is a very long string")
    .addVariant("Shorter string")
    ...
    .build();

Sie können dieses CarText dann verwenden, z. B. als Primärtext eines GridItem

GridItem.Builder()
    .addTitle(itemTitle)
    ...
    .build()

new GridItem.Builder()
    .addTitle(itemTitle)
    ...
    build();

Fügen Sie die Zeichenfolgen von der höchsten bis zur niedrigsten Priorität hinzu, z. B. vom längsten bis zum am kürzesten ist. Der Host wählt die Zeichenfolge mit der passenden Länge aus, je nachdem, wie viel Platz auf dem Autodisplay verfügbar ist.

Inline-CarIcons für Zeilen hinzufügen

Symbole können direkt im Text eingefügt werden, um die App ansprechender zu gestalten. CarIconSpan Weitere Informationen finden Sie in der Dokumentation zu CarIconSpan.create finden Sie weitere Informationen zum Erstellen dieser Spans. Weitere Informationen finden Sie unter Spantastisch Textstil mit Spans finden Sie einen Überblick über die Funktionsweise des Textstils mit Spans.

  
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()
  
  

  
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();
  
  

APIs für Autohardware

Ab Level 3 der Car App API enthält die Car App Library APIs, auf Fahrzeugeigenschaften und Sensoren zugreifen.

Voraussetzungen

Wenn du die APIs mit Android Auto verwenden möchtest, füge zuerst eine Abhängigkeit von androidx.car.app:app-projected in die build.gradle-Datei für Ihr Android-Gerät Auto-Modul. Fügen Sie für Android Automotive OS eine Abhängigkeit von androidx.car.app:app-automotive in die build.gradle-Datei für Ihr Android-Gerät Automotive OS-Modul

Außerdem müssen Sie in der Datei AndroidManifest.xml Folgendes tun: die relevanten Berechtigungen zu deklarieren, fordert die gewünschten Autodaten an. Diese Berechtigungen müssen auch vom Nutzer gewährt. Sie können die denselben Code für Android Auto und Android Automotive OS verwenden, als plattformabhängige Abläufe erstellen. Die erforderlichen Berechtigungen unterscheiden.

Autoinfo

In dieser Tabelle werden die Eigenschaften des CarInfo APIs und die Berechtigungen, die Sie anfordern müssen, um sie verwenden zu können:

Instanziieren Sie beispielsweise zum Abrufen des verbleibenden Bereichs einen CarInfo-Objekt, dann Erstellen und registrieren Sie eine OnCarDataAvailableListener:

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)

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);

Gehen Sie nicht davon aus, dass die Daten des Fahrzeugs jederzeit verfügbar sind. Wenn Sie eine Fehlermeldung erhalten, prüfen Sie die status von Wert, den Sie angefordert haben, um besser zu verstehen, warum die von Ihnen angeforderten Daten kann nicht abgerufen werden. Weitere Informationen finden Sie im Referenzdokumentation für die vollständige CarInfo-Klassendefinition.

Autosensoren

Klasse CarSensors auf den Beschleunigungsmesser, das Gyroskop, den Kompass und Standortdaten. Die Verfügbarkeit dieser Werte kann vom OEM. Das Format der Daten von Beschleunigungsmesser, Gyroskop und Kompass ist genauso wie im SensorManager API. Beispiel: um die Richtung des Fahrzeugs zu prüfen:

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)

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);

Um auf Standortdaten aus dem Auto zuzugreifen, musst du auch die Berechtigung „android.permission.ACCESS_FINE_LOCATION“.

Testen

Informationen zum Simulieren von Sensordaten für Tests mit Android Auto finden Sie in der Sensoren und Sensor Konfiguration der Anleitung für Haupteinheit für Computer. Um Sensordaten beim Testen unter Android zu simulieren Automotive OS, siehe die Emulate-Hardware der Android-App über den Status Leitfaden für den Automotive OS-Emulator

Die Lebenszyklen von CarAppService, Session und Screen

Die Session und Screen-Klassen implementieren die LifecycleOwner-Oberfläche. Als der Nutzer mit der App interagiert, die Objekte Session und Screen Lebenszyklus -Callbacks aufgerufen werden, wie in den folgenden Diagrammen beschrieben.

Die Lebenszyklen eines CarAppService und einer Sitzung

</ph>

Ausführliche Informationen finden Sie in der Dokumentation zum Session.getLifecycle .

Der Lebenszyklus eines Bildschirms

</ph>

Ausführliche Informationen finden Sie in der Dokumentation zum Screen.getLifecycle-Methode.

Über das Mikrofon des Autos aufnehmen

Mit der CarAppService und die CarAudioRecord API, kannst du deiner App Zugriff auf das Mikrofon des Autos gewähren. Die Nutzenden müssen App-Berechtigung zum Zugriff auf das Mikrofon des Autos. Ihre App kann Daten aufzeichnen und die Eingabe des Nutzers in Ihrer App zu verarbeiten.

Berechtigung zum Aufzeichnen

Bevor Sie Audioinhalte aufzeichnen, müssen Sie zuerst die Berechtigung zum Aufzeichnen in Ihrem AndroidManifest.xml und bittet den Nutzer, sie zu gewähren.

<manifest ...>
   ...
   <uses-permission android:name="android.permission.RECORD_AUDIO" />
   ...
</manifest>

Sie müssen die Berechtigung zum Aufzeichnen während der Laufzeit anfordern. Weitere Informationen finden Sie im Abschnitt Anfrage im Abschnitt zu Berechtigungen. in deiner Auto-App.

Audio aufnehmen

Nachdem der Nutzer die Berechtigung zum Aufnehmen erteilt hat, können Sie das Audio aufzeichnen und für die Aufzeichnung.

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()
 

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();
 

Audiofokus

Bei Aufnahmen über das Mikrofon des Autos zuerst Audio erfassen Fokus auf dass laufende Medien gestoppt werden. Wenn Sie den Audiofokus verlieren, Aufzeichnung beenden.

Hier ist ein Beispiel für die Erfassung des Audiofokus:

 
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

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
 

Testbibliothek

Android for Cars-Tests Bibliothek bietet zusätzliche Klassen, mit denen Sie das Verhalten Ihrer App in einer Testumgebung validieren können. Beispiel: Der Parameter SessionController können Sie eine Verbindung zum Host simulieren und prüfen, Screen und Template erstellt und zurückgegeben.

Weitere Informationen finden Sie im Beispiele für Anwendungsbeispiele.

Problem mit der Android for Cars-App-Bibliothek melden

Wenn du ein Problem mit der Bibliothek entdeckst, melde es über das Problemverfolgung von Google Geben Sie alle erforderlichen Informationen in der Problemvorlage an.

Neues Problem erstellen

Bevor Sie eine neue Ausgabe einreichen, prüfen Sie bitte, ob sie in der Version der Bibliothek aufgeführt ist. Probleme gemeldet oder gemeldet werden. Sie können Themen abonnieren und abstimmen, indem Sie indem Sie auf den Stern für ein Problem im Tracker klicken. Weitere Informationen finden Sie unter Eine Ausgabe abonnieren: