Navigations-App erstellen

Auf dieser Seite werden die verschiedenen Funktionen der Auto-App-Bibliothek beschrieben, mit denen Sie die Funktionen Ihrer App für die detaillierte Routenführung implementieren können.

Du kannst in deinem Manifest Navigationsunterstützung angeben

Deine Navigations-App muss im Intent-Filter der zugehörigen CarAppService die Kategorie von Auto-Apps androidx.car.app.category.NAVIGATION deklarieren:

<application>
    ...
   <service
       ...
        android:name=".MyNavigationCarAppService"
        android:exported="true">
      <intent-filter>
        <action android:name="androidx.car.app.CarAppService" />
        <category android:name="androidx.car.app.category.NAVIGATION"/>
      </intent-filter>
    </service>
    ...
</application>

Navigations-Intents unterstützen

Zur Unterstützung von Navigations-Intents für deine App, einschließlich solcher, die von Google Assistant über eine Sprachanfrage gesendet werden, muss deine App den CarContext.ACTION_NAVIGATE-Intent in ihren Session.onCreateScreen- und Session.onNewIntent-Elementen verarbeiten.

Weitere Informationen zum Format des Intents finden Sie in der Dokumentation zu CarContext.startCarApp.

Auf Navigationsvorlagen zugreifen

Navigations-Apps können auf die folgenden Vorlagen zugreifen. Diese zeigen im Hintergrund eine Oberfläche mit der Karte und während der aktiven Navigation detaillierte Routenführung.

• NavigationTemplate: Während der aktiven Navigation werden auch eine optionale Botschaft und Reiseschätzungen angezeigt.
• MapWithContentTemplate: Eine Vorlage, mit der eine App Kartenkacheln mit bestimmten Inhalten (z. B. einer Liste) rendern kann. Der Inhalt wird normalerweise als Overlay über den Kartenkacheln gerendert, wobei die sichtbaren und stabilen Bereiche der Karte an den Inhalt angepasst werden.

Weitere Informationen dazu, wie Sie die Benutzeroberfläche Ihrer Navigations-App mithilfe dieser Vorlagen gestalten, finden Sie unter Navigations-Apps.

Damit Sie auf die Navigationsvorlagen zugreifen können, muss Ihre App die Berechtigung androidx.car.app.NAVIGATION_TEMPLATES in der Datei AndroidManifest.xml deklarieren:

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

Zum Zeichnen von Karten ist eine zusätzliche Berechtigung erforderlich.

Zu MapWithContentTemplate migrieren

Ab API-Level 7 der Car App werden MapTemplate, PlaceListNavigationTemplate und RoutePreviewNavigationTemplate eingestellt. Verworfene Vorlagen werden weiterhin unterstützt, aber die Migration zu MapWithContentTemplate wird dringend empfohlen.

Die von diesen Vorlagen bereitgestellten Funktionen können mit MapWithContentTemplate implementiert werden. Die folgenden Snippets sind Beispiele:

// MapTemplate (deprecated)
val template = MapTemplate.Builder()
    .setPane(paneBuilder.build())
    .setActionStrip(actionStrip)
    .setHeader(header)
    .setMapController(mapController)
    .build()

// MapWithContentTemplate
val template = MapWithContentTemplate.Builder()
    .setContentTemplate(
        PaneTemplate.Builder(paneBuilder.build())
            .setHeader(header)
            .build())
    .setActionStrip(actionStrip)
    .setMapController(mapController)
    .build()

// MapTemplate (deprecated)
MapTemplate template = new MapTemplate.Builder()
    .setPane(paneBuilder.build())
    .setActionStrip(actionStrip)
    .setHeader(header)
    .setMapController(mapController)
    .build();

// MapWithContentTemplate
MapWithContentTemplate template = new MapWithContentTemplate.Builder()
    .setContentTemplate(new PaneTemplate.Builder(paneBuilder.build())
        .setHeader(header)
        build())
    .setActionStrip(actionStrip)
    .setMapController(mapController)
    .build();

// PlaceListNavigationTemplate (deprecated)
val template = PlaceListNavigationTemplate.Builder()
    .setItemList(itemListBuilder.build())
    .setHeader(header)
    .setActionStrip(actionStrip)
    .setMapActionStrip(mapActionStrip)
    .build()

// MapWithContentTemplate
val template = MapWithContentTemplate.Builder()
    .setContentTemplate(
        ListTemplate.Builder()
            .setSingleList(itemListBuilder.build())
            .setHeader(header)
            .build())
    .setActionStrip(actionStrip)
    .setMapController(
        MapController.Builder()
            .setMapActionStrip(mapActionStrip)
            .build())
    .build()

// PlaceListNavigationTemplate (deprecated)
PlaceListNavigationTemplate template = new PlaceListNavigationTemplate.Builder()
    .setItemList(itemListBuilder.build())
    .setHeader(header)
    .setActionStrip(actionStrip)
    .setMapActionStrip(mapActionStrip)
    .build();

// MapWithContentTemplate
MapWithContentTemplate template = new MapWithContentTemplate.Builder()
    .setContentTemplate(new ListTemplate.Builder()
        .setSingleList(itemListBuilder.build())
        .setHeader(header)
        .build())
    .setActionStrip(actionStrip)
    .setMapController(new MapController.Builder()
        .setMapActionStrip(mapActionStrip)
        .build())
    .build();

// RoutePreviewNavigationTemplate (deprecated)
val template = RoutePreviewNavigationTemplate.Builder()
    .setItemList(
        ItemList.Builder()
            .addItem(
                Row.Builder()
                    .setTitle(title)
                    .build())
            .build())
    .setHeader(header)
    .setNavigateAction(
        Action.Builder()
            .setTitle(actionTitle)
            .setOnClickListener { ... }
            .build())
    .setActionStrip(actionStrip)
    .setMapActionStrip(mapActionStrip)
    .build()

// MapWithContentTemplate
val template = MapWithContentTemplate.Builder()
    .setContentTemplate(
        ListTemplate.Builder()
            .setSingleList(
                ItemList.Builder()
                    .addItem(
                        Row.Builder()
                            .setTitle(title)
                            .addAction(
                                Action.Builder()
                                    .setTitle(actionTitle)
                                    .setOnClickListener { ... }
                                    .build())
                            .build())
                    .build())
            .setHeader(header)
            .build())
    .setActionStrip(actionStrip)
    .setMapController(
        MapController.Builder()
            .setMapActionStrip(mapActionStrip)
            .build())
    .build()

// RoutePreviewNavigationTemplate (deprecated)
RoutePreviewNavigationTemplate template = new RoutePreviewNavigationTemplate.Builder()
    .setItemList(new ItemList.Builder()
        .addItem(new Row.Builder()
            .setTitle(title))
            .build())
        .build())
    .setHeader(header)
    .setNavigateAction(new Action.Builder()
        .setTitle(actionTitle)
        .setOnClickListener(() -> { ... })
        .build())
    .setActionStrip(actionStrip)
    .setMapActionStrip(mapActionStrip)
    .build();

// MapWithContentTemplate
MapWithContentTemplate template = new MapWithContentTemplate.Builder()
    .setContentTemplate(new ListTemplate.Builder()
        .setSingleList(new ItemList.Builder()
            .addItem(new Row.Builder()
                  .setTitle(title))
                  .addAction(new Action.Builder()
                      .setTitle(actionTitle)
                      .setOnClickListener(() -> { ... })
                      .build())
                  .build())
            .build()))
        .setHeader(header)
        .build())
    .setActionStrip(actionStrip)
    .setMapController(new MapController.Builder()
        .setMapActionStrip(mapActionStrip)
        .build())
    .build();

Navigationsmetadaten kommunizieren

Navigations-Apps müssen zusätzliche Navigationsmetadaten mit dem Host kommunizieren. Der Host verwendet die Informationen, um dem Hauptgerät des Fahrzeugs Informationen zur Verfügung zu stellen und zu verhindern, dass Navigationsanwendungen über gemeinsam genutzte Ressourcen in Konflikt stehen.

Navigationsmetadaten werden über den Autodienst NavigationManager bereitgestellt, auf den über CarContext zugegriffen werden kann:

val navigationManager = carContext.getCarService(NavigationManager::class.java)

NavigationManager navigationManager = carContext.getCarService(NavigationManager.class);

Navigation starten, beenden und beenden

Damit der Host mehrere Navigations-Apps, Routingbenachrichtigungen und Fahrzeugclusterdaten verwalten kann, muss er den aktuellen Status der Navigation kennen. Wenn ein Nutzer die Navigation startet, rufen Sie NavigationManager.navigationStarted auf. Wenn die Navigation beendet wird, z. B. wenn der Nutzer sein Ziel erreicht oder die Navigation abbricht, rufen Sie NavigationManager.navigationEnded auf.

Rufen Sie NavigationManager.navigationEnded erst auf, wenn der Nutzer die Navigation beendet hat. Wenn Sie die Route beispielsweise mitten in einer Fahrt neu berechnen müssen, verwenden Sie stattdessen Trip.Builder.setLoading(true).

Gelegentlich benötigt der Host eine App, um die Navigation zu beenden, und ruft onStopNavigation in einem NavigationManagerCallback-Objekt auf, das von Ihrer App über NavigationManager.setNavigationManagerCallback bereitgestellt wird. Die App muss dann keine Informationen zur nächsten Abbiegung mehr über die Clusteranzeige, Navigationsbenachrichtigungen und die Sprachführung ausgeben.

Fahrtinformationen aktualisieren

Rufen Sie während der aktiven Navigation NavigationManager.updateTrip auf. Die in diesem Aufruf angegebenen Informationen können vom Cluster und den Heads-up-Displays des Fahrzeugs verwendet werden. Je nach Fahrzeug werden dem Nutzer nicht alle Informationen angezeigt. Die Desktop-Haupteinheit (Desktop Head Unit, DHU) zeigt beispielsweise das Step an, das dem Trip hinzugefügt wurde, nicht aber die Destination-Informationen.

Zur Clusteranzeige zeichnen

Für eine möglichst umfassende Nutzererfahrung bietet es sich an, nicht nur die grundlegenden Metadaten auf dem Cluster-Display des Fahrzeugs anzuzeigen. Ab Version 6 der Car App API-Ebene 6 können Navigations-Apps ihre eigenen Inhalte direkt auf dem Cluster-Display rendern (in unterstützten Fahrzeugen). Dabei gelten die folgenden Einschränkungen:

• Die Cluster Display API unterstützt keine Eingabesteuerelemente
• Die Cluster-Anzeige sollte nur Kartenkacheln enthalten. Auf diesen Kacheln kann optional eine aktive Routennavigation angezeigt werden.
• Die Cluster Display API unterstützt nur die Verwendung von NavigationTemplate
  • Im Gegensatz zu Hauptdarstellungen werden auf Cluster-Displays möglicherweise nicht alle NavigationTemplate-UI-Elemente wie detaillierte Routenführung, ETA-Karten und Aktionen angezeigt. Kartenkacheln sind die einzigen einheitlich angezeigten UI-Elemente.

Clustersupport deklarieren

Damit die Hostanwendung weiß, dass deine App das Rendern auf Clusterdisplays unterstützt, musst du dem <intent-filter> deines CarAppService ein androidx.car.app.category.FEATURE_CLUSTER-<category>-Element hinzufügen, wie im folgenden Snippet gezeigt:

<application>
    ...
   <service
       ...
        android:name=".MyNavigationCarAppService"
        android:exported="true">
      <intent-filter>
        <action android:name="androidx.car.app.CarAppService" />
        <category android:name="androidx.car.app.category.NAVIGATION"/>
        <category android:name="androidx.car.app.category.FEATURE_CLUSTER"/>
      </intent-filter>
    </service>
    ...
</application>

Lebenszyklus und Statusverwaltung

Ab API-Level 6 bleibt der Lebenszyklusablauf der Auto-App gleich, aber CarAppService::onCreateSession verwendet jetzt einen Parameter vom Typ SessionInfo, der zusätzliche Informationen zu der erstellten Session liefert (den Anzeigetyp und die unterstützten Vorlagen).

Anwendungen haben die Möglichkeit, entweder dieselbe Session-Klasse zur Verarbeitung der Cluster- und Hauptanzeige zu verwenden oder anzeigespezifische Sessions zu erstellen, um das Verhalten bei jeder Anzeige anzupassen (wie im folgenden Snippet gezeigt).

override fun onCreateSession(sessionInfo: SessionInfo): Session {
  return if (sessionInfo.displayType == SessionInfo.DISPLAY_TYPE_CLUSTER) {
    ClusterSession()
  } else {
    MainDisplaySession()
  }
}

@Override
@NonNull
public Session onCreateSession(@NonNull SessionInfo sessionInfo) {
  if (sessionInfo.getDisplayType() == SessionInfo.DISPLAY_TYPE_CLUSTER) {
    return new ClusterSession();
  } else {
    return new MainDisplaySession();
  }
}

Es gibt keine Garantie dafür, wann oder ob die Clusteranzeige bereitgestellt wird. Außerdem ist es möglich, dass der Cluster-Session der einzige Session ist (z. B. hat der Nutzer die Hauptanzeige zu einer anderen App gewechselt, während die App aktiv navigiert). Die "Standardvereinbarung" besagt, dass die Anwendung erst nach dem Aufruf von NavigationManager::navigationStarted die Kontrolle über die Clusteranzeige erhält. Es ist jedoch möglich, dass für die Anwendung die Clusteranzeige angezeigt wird, wenn keine aktive Navigation erfolgt, oder dass die Clusteranzeige nie angezeigt wird. Für solche Szenarien muss Ihre App den Inaktivitätsstatus der Kartenkacheln rendern.

Der Host erstellt einen separaten Binder und CarContext Instanzen pro Session. Das bedeutet, dass bei Verwendung von Methoden wie ScreenManager::push oder Screen::invalidate nur die Session betroffen sind, von denen sie aufgerufen werden. Anwendungen sollten ihre eigenen Kommunikationskanäle zwischen diesen Instanzen erstellen, wenn eine Sessionübergreifende Kommunikation erforderlich ist (z. B. durch Übertragungen, einen gemeinsamen Singleton oder etwas anderes).

Clusterunterstützung testen

Sie können Ihre Implementierung sowohl in Android Auto als auch in Android Automotive OS testen. Bei Android Auto muss die Desktop-Haupteinheit so konfiguriert werden, dass sie eine sekundäre Clusteranzeige emuliert. Unter Android Automotive OS emulieren die allgemeinen System-Images ab API-Level 30 eine Clusteranzeige.

Individuelle Reiseschätzung mit einem Text oder einem Symbol

Wenn Sie die Schätzung der Reisekosten mit Text, einem Symbol oder beidem anpassen möchten, verwenden Sie die Methoden setTripIcon oder setTripText der Klasse TravelEstimate.Builder. Der NavigationTemplate verwendet TravelEstimate, um optional Text und Symbole neben oder anstelle der geschätzten Ankunftszeit, der verbleibenden Zeit und der verbleibenden Entfernung festzulegen.

Im folgenden Snippet wird die Reiseschätzung anhand von setTripIcon und setTripText angepasst:

TravelEstimate.Builder(Distance.create(...), DateTimeWithZone.create(...))
      ...
      .setTripIcon(CarIcon.Builder(...).build())
      .setTripText(CarText.create(...))
      .build()

new TravelEstimate.Builder(Distance.create(...), DateTimeWithZone.create(...))
      ...
      .setTripIcon(CarIcon.Builder(...).build())
      .setTripText(CarText.create(...))
      .build();

Detaillierte Benachrichtigungen bereitstellen

Stellen Sie mithilfe einer häufig aktualisierten Navigationsbenachrichtigung eine detaillierte Routenführung bereit. Damit der Ersteller der Benachrichtigung auf dem Autodisplay als Navigationsbenachrichtigung behandelt wird, muss er Folgendes tun:

1. Markieren Sie die Benachrichtigung mit der Methode NotificationCompat.Builder.setOngoing als aktiv.
2. Legen Sie als Kategorie der Benachrichtigung Notification.CATEGORY_NAVIGATION fest.
3. Erweitern Sie die Benachrichtigung um einen CarAppExtender.

Eine Navigationsbenachrichtigung wird im Schienen-Widget unten auf dem Autobildschirm angezeigt. Wenn die Prioritätsstufe der Benachrichtigung auf IMPORTANCE_HIGH gesetzt ist, wird sie auch als Vorabbenachrichtigung (HUN) angezeigt. Wenn die Wichtigkeit nicht mit der Methode CarAppExtender.Builder.setImportance festgelegt wird, wird die Wichtigkeit des Benachrichtigungskanals verwendet.

Die App kann ein PendingIntent in der CarAppExtender festlegen, das an die App gesendet wird, wenn der Nutzer auf das HUN- oder das Rail-Widget tippt.

Wenn NotificationCompat.Builder.setOnlyAlertOnce mit dem Wert true aufgerufen wird, wird eine Benachrichtigung mit hoher Wichtigkeit nur einmal im HUN benachrichtigt.

Das folgende Snippet zeigt, wie eine Navigationsbenachrichtigung erstellt wird:

NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID)
    ...
    .setOnlyAlertOnce(true)
    .setOngoing(true)
    .setCategory(NotificationCompat.CATEGORY_NAVIGATION)
    .extend(
        CarAppExtender.Builder()
            .setContentTitle(carScreenTitle)
            ...
            .setContentIntent(
                PendingIntent.getBroadcast(
                    context,
                    ACTION_OPEN_APP.hashCode(),
                    Intent(ACTION_OPEN_APP).setComponent(
                        ComponentName(context, MyNotificationReceiver::class.java)),
                        0))
            .setImportance(NotificationManagerCompat.IMPORTANCE_HIGH)
            .build())
    .build()

new NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID)
    ...
    .setOnlyAlertOnce(true)
    .setOngoing(true)
    .setCategory(NotificationCompat.CATEGORY_NAVIGATION)
    .extend(
        new CarAppExtender.Builder()
            .setContentTitle(carScreenTitle)
            ...
            .setContentIntent(
                PendingIntent.getBroadcast(
                    context,
                    ACTION_OPEN_APP.hashCode(),
                    new Intent(ACTION_OPEN_APP).setComponent(
                        new ComponentName(context, MyNotificationReceiver.class)),
                        0))
            .setImportance(NotificationManagerCompat.IMPORTANCE_HIGH)
            .build())
    .build();

Aktualisieren Sie die TBT-Benachrichtigung regelmäßig für Entfernungsänderungen. Dadurch wird das Rail-Widget aktualisiert und die Benachrichtigung wird nur als HUN angezeigt. Sie können das HUN-Verhalten steuern, indem Sie die Wichtigkeit der Benachrichtigung mit CarAppExtender.Builder.setImportance festlegen. Wenn Sie die Wichtigkeit auf IMPORTANCE_HIGH setzen, wird eine HUN angezeigt. Wird ein anderer Wert festgelegt, wird nur das Widget für die Bahn aktualisiert.

„PlaceListNavigationTemplate“-Inhalt aktualisieren

Sie können zulassen, dass Fahrer Inhalte mit nur einmal tippen auf eine Schaltfläche aktualisieren, während sie sich Listen von Orten ansehen, die mit PlaceListNavigationTemplate erstellt wurden. Implementieren Sie zum Aktivieren der Listenaktualisierung die Methode onContentRefreshRequested der OnContentRefreshListener-Schnittstelle und legen Sie den Listener mit PlaceListNavigationTemplate.Builder.setOnContentRefreshListener für die Vorlage fest.

Das folgende Snippet zeigt, wie der Listener für die Vorlage festgelegt wird:

PlaceListNavigationTemplate.Builder()
    ...
    .setOnContentRefreshListener {
        // Execute any desired logic
        ...
        // Then call invalidate() so onGetTemplate() is called again
        invalidate()
    }
    .build()

new PlaceListNavigationTemplate.Builder()
        ...
        .setOnContentRefreshListener(() -> {
            // Execute any desired logic
            ...
            // Then call invalidate() so onGetTemplate() is called again
            invalidate();
        })
        .build();

Die Schaltfläche zum Aktualisieren wird nur dann im Header von PlaceListNavigationTemplate angezeigt, wenn der Listener einen Wert hat.

Wenn der Nutzer auf die Schaltfläche zum Aktualisieren klickt, wird die Methode onContentRefreshRequested deiner OnContentRefreshListener-Implementierung aufgerufen. Rufen Sie in onContentRefreshRequested die Methode Screen.invalidate auf. Der Host ruft dann die Methode Screen.onGetTemplate Ihrer App auf, um die Vorlage mit dem aktualisierten Inhalt abzurufen. Weitere Informationen zum Aktualisieren von Vorlagen finden Sie unter Inhalt einer Vorlage aktualisieren. Solange die nächste von onGetTemplate zurückgegebene Vorlage denselben Typ hat, wird dies als Aktualisierung gezählt und nicht auf das Vorlagenkontingent angerechnet.

Audioführung anbieten

Damit die Navigationsführung über die Autolautsprecher wiedergegeben werden kann, muss Ihre App den Audiofokus anfordern. Legen Sie im Rahmen Ihrer AudioFocusRequest die Nutzung als AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE fest. Legen Sie außerdem die Fokusverstärkung auf AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK fest.

Navigation simulieren

Damit du die Navigationsfunktion deiner App prüfen kannst, wenn du sie im Google Play Store einreichst, muss sie den NavigationManagerCallback.onAutoDriveEnabled-Callback implementieren. Wenn dieser Callback aufgerufen wird, muss die App die Navigation zum ausgewählten Ziel simulieren, wenn der Nutzer die Navigation startet. Ihre Anwendung kann diesen Modus beenden, wenn der Lebenszyklus des aktuellen Session den Status Lifecycle.Event.ON_DESTROY erreicht.

Sie können testen, ob Ihre Implementierung von onAutoDriveEnabled aufgerufen wird, indem Sie Folgendes über eine Befehlszeile ausführen:

adb shell dumpsys activity service CAR_APP_SERVICE_NAME AUTO_DRIVE

Dies wird im folgenden Beispiel gezeigt:

adb shell dumpsys activity service androidx.car.app.samples.navigation.car.NavigationCarAppService AUTO_DRIVE

Standard-Navigations-App für Autos

In Android Auto entspricht die Standardnavigations-App des Autos der letzten Navigations-App, die der Nutzer gestartet hat. Die Standard-App empfängt Navigations-Intents, wenn der Nutzer Navigationsbefehle über Assistant aufruft oder wenn eine andere App einen Intent zum Starten der Navigation sendet.

Kontextbezogene Navigationsbenachrichtigungen anzeigen

Alert zeigt dem Fahrer wichtige Informationen mit optionalen Aktionen an, ohne den Kontext des Navigationsbildschirms zu verlassen. Damit der Fahrer die beste Fahrerfahrung hat, arbeitet Alert innerhalb der NavigationTemplate, um die Navigationsroute nicht zu verdecken und die Ablenkung des Fahrers zu minimieren.

Alert ist nur innerhalb von NavigationTemplate verfügbar. Wenn du den Nutzer außerhalb von NavigationTemplate benachrichtigen möchtest, solltest du eine Vorabbenachrichtigung (HUN) verwenden, wie unter Benachrichtigungen anzeigen erläutert.

Verwenden Sie Alert beispielsweise für Folgendes:

• Informieren Sie den Fahrer über ein Update, das für die aktuelle Navigation relevant ist, z. B. eine Änderung der Verkehrslage.
• Bitten Sie den Fahrer, Ihnen ein Update zur aktuellen Navigation zu geben, z. B. ob ein Blitzer vorhanden ist.
• Schlagen Sie eine bevorstehende Aufgabe vor und fragen Sie, ob der Fahrer diese akzeptiert, z. B. ob er bereit ist, jemanden auf dem Weg abzuholen.

In seiner Grundform besteht eine Alert aus einem Titel und der Dauer für Alert. Die Dauer wird als Fortschrittsanzeige dargestellt. Optional können Sie eine Unterüberschrift, ein Symbol und bis zu zwei Action-Objekte hinzufügen.

Sobald ein Alert angezeigt wird, wird es nicht in eine andere Vorlage übernommen, wenn die Treiberinteraktion zum Verlassen von NavigationTemplate führt. Sie bleibt im ursprünglichen NavigationTemplate, bis das Zeitlimit für Alert überschritten wird, der Nutzer eine Aktion ausführt oder die App Alert schließt.

Benachrichtigung erstellen

Verwenden Sie Alert.Builder, um eine Alert-Instanz zu erstellen:

Alert.Builder(
        /*alertId*/ 1,
        /*title*/ CarText.create("Hello"),
        /*durationMillis*/ 5000
    )
    // The fields below are optional
    .addAction(firstAction)
    .addAction(secondAction)
    .setSubtitle(CarText.create(...))
    .setIcon(CarIcon.APP_ICON)
    .setCallback(...)
    .build()

new Alert.Builder(
        /*alertId*/ 1,
        /*title*/ CarText.create("Hello"),
        /*durationMillis*/ 5000
    )
    // The fields below are optional
    .addAction(firstAction)
    .addAction(secondAction)
    .setSubtitle(CarText.create(...))
    .setIcon(CarIcon.APP_ICON)
    .setCallback(...)
    .build();

Wenn du auf einen Abbruch oder eine Ablehnung von Alert warten möchtest, musst du eine Implementierung der Schnittstelle AlertCallback erstellen. Die AlertCallback-Aufrufpfade sind:

• Wenn das Zeitlimit für Alert überschritten wird, ruft der Host die Methode AlertCallback.onCancel mit dem Wert AlertCallback.REASON_TIMEOUT auf. Anschließend wird die Methode AlertCallback.onDismiss aufgerufen.

• Wenn der Fahrer auf eine der Aktionsschaltflächen klickt, ruft der Host Action.OnClickListener und dann AlertCallback.onDismiss auf.

• Wenn Alert nicht unterstützt wird, ruft der Host AlertCallback.onCancel mit dem Wert AlertCallback.REASON_NOT_SUPPORTED auf. Der Host ruft AlertCallback.onDismiss nicht auf, weil Alert nicht angezeigt wurde.

Benachrichtigungsdauer konfigurieren

Wähle für Alert eine Dauer aus, die den Anforderungen deiner App entspricht. Die empfohlene Dauer für eine Navigations-Alert beträgt 10 Sekunden. Weitere Informationen finden Sie unter Navigationswarnungen.

Benachrichtigung anzeigen

Rufen Sie zum Anzeigen eines Alert die AppManager.showAlert-Methode auf, die über die CarContext Ihrer App verfügbar ist.

// Show an alert
carContext.getCarService(AppManager.class).showAlert(alert)

• Der Aufruf von showAlert mit einem Alert, dessen alertId mit der ID der aktuell angezeigten Alert übereinstimmt, hat keine Auswirkung. Alert wird nicht aktualisiert. Um ein Alert zu aktualisieren, müssen Sie es mit einer neuen alertId neu erstellen.
• Wenn Sie showAlert mit einem Alert aufrufen, das einen anderen alertId als das aktuell angezeigte Alert hat, wird das aktuell angezeigte Alert geschlossen.

Benachrichtigung schließen

Ein Alert-Element wird aufgrund einer Zeitüberschreitung oder einer Treiberinteraktion automatisch geschlossen. Du kannst Alert aber auch manuell schließen, z. B. wenn die Informationen veraltet sind. Wenn Sie ein Alert schließen möchten, rufen Sie die Methode dismissAlert mit der alertId von Alert auf.

// Dismiss the same alert
carContext.getCarService(AppManager.class).dismissAlert(alert.getId())

Der Aufruf von dismissAlert mit einer alertId, die nicht mit der aktuell angezeigten Alert übereinstimmt, hat keine Auswirkung. Es wird keine Ausnahme ausgelöst.