Utwórz aplikację nawigacyjną

Na tej stronie znajdziesz szczegółowe informacje o różnych funkcjach Biblioteki aplikacji samochodowych, których możesz używać do implementowania funkcji nawigacji z naprowadzaniem.

Zadeklaruj obsługę nawigacji w pliku manifestu

Aplikacja do nawigacji musi zadeklarować androidx.car.app.category.NAVIGATION kategorię aplikacji samochodowej w filtrze intencji CarAppService:

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

Obsługa intencji nawigacji

Aby obsługiwać intencje nawigacyjne w aplikacji, w tym te pochodzące z Asystenta Google za pomocą zapytania głosowego, aplikacja musi obsługiwać intencję CarContext.ACTION_NAVIGATE w Session.onCreateScreeni Session.onNewIntent.

Szczegółowe informacje o formatach intencji znajdziesz w dokumentacji dotyczącej CarContext.startCarApp.

Otwieranie szablonów nawigacji

Aplikacje do nawigacji mogą korzystać z tych szablonów, które wyświetlają mapę w tle oraz podczas aktywnej nawigacji – wskazówki zakręt po zakręcie.

• NavigationTemplate: wyświetla również opcjonalny komunikat informacyjny i szacunki czasu podróży podczas aktywnej nawigacji.
• MapWithContentTemplate: szablon, który umożliwia aplikacji renderowanie kafelków mapy z różnymi rodzajami treści (np. listą). Treści są zwykle renderowane jako nakładka na płytkach mapy, a widoczne obszary mapy i stabilne obszary dostosowują się do treści.

Więcej informacji o projektowaniu interfejsu aplikacji nawigacyjnej za pomocą tych szablonów znajdziesz w artykule Aplikacje nawigacyjne.

Aby uzyskać dostęp do szablonów nawigacji, aplikacja musi zadeklarować uprawnienie androidx.car.app.NAVIGATION_TEMPLATES w pliku AndroidManifest.xml:

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

Aby rysować mapy, wymagane jest dodatkowe uprawnienie.

Migracja do szablonu MapWithContent

Od poziomu interfejsu API 7 dla aplikacji na Car App wartości MapTemplate, PlaceListNavigationTemplate i RoutePreviewNavigationTemplate są wycofane. Nadal będziemy obsługiwać wycofane szablony, ale zdecydowanie zalecamy przejście na MapWithContentTemplate.

Funkcje, które zapewniają te szablony, można zaimplementować za pomocą MapWithContentTemplate. Przykłady takich fragmentów kodu:

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

Przekazywanie metadanych nawigacji

Aplikacje do nawigacji muszą przekazywać dodatkowe metadane nawigacji do hosta. Host używa tych informacji, aby przesyłać informacje do konsoli pojazdu i zapobiegać konfliktom między aplikacjami nawigacyjnymi w przypadku współdzielonych zasobów.

Metadane nawigacji są dostarczane za pomocą usługi NavigationManagercar dostępnej z poziomu CarContext:

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

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

Rozpoczynanie, kończenie i zatrzymywanie nawigacji

Aby host mógł zarządzać wieloma aplikacjami do nawigacji, powiadomieniami o nawigacji i danymi klastra pojazdów, musi znać bieżący stan nawigacji. Gdy użytkownik rozpoczyna nawigację, wywołaj funkcję NavigationManager.navigationStarted. Podobnie, gdy nawigacja się kończy (np. gdy użytkownik dotrze do celu lub anuluje nawigację), wywołaj NavigationManager.navigationEnded.

Wywołuj NavigationManager.navigationEndedtylko wtedy, gdy użytkownik zakończy nawigację. Jeśli na przykład musisz ponownie obliczyć trasę w połowie podróży, użyj polecenia Trip.Builder.setLoading(true).

Czasami gospodarz musi zatrzymać nawigację i wywołania onStopNavigation w obiekcie NavigationManagerCallback udostępnianym przez Twoją aplikację za pomocą interfejsu NavigationManager.setNavigationManagerCallback. Aplikacja musi wtedy przestać wyświetlać informacje o następnym skręcie na wyświetlaczu klastra, powiadomienia nawigacyjne i głosowe wskazówki.

Aktualizowanie informacji o podróży

Podczas aktywnej nawigacji wybierz NavigationManager.updateTrip. Informacje przekazane w ramach tego wywołania mogą być używane przez zestaw wskaźników i wyświetlacze HUD pojazdu. W zależności od konkretnego pojazdu nie wszystkie informacje są wyświetlane użytkownikowi. Na przykład w przypadku jednostki głównej na komputerze (DHU) wyświetlana jest wartość Step dodana do Trip, ale nie są wyświetlane informacje Destination.

Rysowanie na wyświetlaczu grupowym

Aby zapewnić użytkownikom jak najlepsze wrażenia, warto wyświetlać na ekranie konsoli więcej niż podstawowe metadane. Począwszy od interfejsu Car App API w wersji 6 aplikacje nawigacyjne mają możliwość renderowania własnych treści bezpośrednio na wyświetlaczu zespołu (w obsługiwanych pojazdach) z tymi ograniczeniami:

• Interfejs API wyświetlania klastra nie obsługuje elementów sterujących
• Wskazówki dotyczące jakości aplikacji samochodowych NF-9: Wyświetlanie grupowe powinno zawierać tylko kafelki mapy. Na tych kartach opcjonalnie można wyświetlić aktywną trasę nawigacji.
• Interfejs API wyświetlania klastra obsługuje tylko użycie parametru NavigationTemplate.
  • W odróżnieniu od wyświetlaczy głównych wyświetlacze klastrów mogą nie wyświetlać konsekwentnie wszystkich elementów NavigationTemplate interfejsu, takich jak wskazówki dojazdu, karty ETA i czynności. Kafelki mapy to jedyny element interfejsu użytkownika, który jest wyświetlany w sposób spójny.

Zadeklaruj obsługę klastra

Aby poinformować aplikację hosta, że Twoja aplikacja obsługuje renderowanie na wyświetlaczach klastra, musisz dodać element androidx.car.app.category.FEATURE_CLUSTER <category> do elementu <intent-filter> aplikacji CarAppService, jak pokazano w tym fragmencie kodu:

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

Zarządzanie stanem i cyklem życia

Począwszy od poziomu 6 interfejsu API przepływ danych aplikacji samochodowej pozostaje taki sam, ale teraz CarAppService::onCreateSession przyjmuje parametr typu SessionInfo, który zawiera dodatkowe informacje o tworzonym Session (a mianowicie typ wyświetlania i zestaw obsługiwanych szablonów).

Aplikacje mogą używać tej samej klasy Session do obsługi klastra i głównego wyświetlacza lub tworzyć Sessions dla poszczególnych wyświetlaczy, aby dostosować ich działanie (jak pokazano w tym fragmencie kodu).

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

Nie ma gwarancji, kiedy i czy wyświetlanie klastra jest dostępne. Możliwe też, że klaster Session jest jedynym Session (na przykład użytkownik przełączył wyświetlanie główne na inną aplikację, gdy Twoja aplikacja aktywnie się przewija). „Standardowa” umowa zakłada, że aplikacja uzyskuje kontrolę nad wyświetlaniem klastra dopiero po wywołaniu funkcji NavigationManager::navigationStarted. Może się jednak zdarzyć, że wyświetlanie klastra jest dostępne w aplikacji, gdy nie ma aktywnej nawigacji, lub że aplikacja nigdy nie ma dostępu do wyświetlania klastra. Twoja aplikacja musi obsługiwać te scenariusze, renderując stan spoczynku kafelków mapy.

Host tworzy oddzielne instancje bindera i CarContext na potrzeby każdego Session. Oznacza to, że podczas korzystania z metod takich jak ScreenManager::push lub Screen::invalidate wpływa to tylko na Session, z którego są wywoływane. Jeśli aplikacje potrzebują komunikacji między instancjami, powinny tworzyć własne kanały komunikacji (np. za pomocą transmisji, udostępnionego elementu singleton lub innego rozwiązania).Session

Pomoc dotycząca klastra testowego

Implementację możesz przetestować zarówno w Androidzie Auto, jak i w systemie operacyjnym Android Automotive. W przypadku Androida Auto jest to realizowane przez skonfigurowanie konsoli głównej na komputerze, aby emulować wyświetlacz klastra dodatkowego. W przypadku systemu operacyjnego Android Automotive schematy systemowe dla poziomu interfejsu API 30 i wyższych emulują wyświetlacz klastra.

Dostosowywanie szacowanego czasu podróży za pomocą tekstu lub ikony

Aby dostosować szacowany czas podróży, używając tekstu lub ikony albo obu tych elementów, użyj metod klasy TravelEstimate.BuildersetTripIcon lub setTripText. Element NavigationTemplate używa TravelEstimate do opcjonalnego ustawiania tekstu i ikon obok lub zamiast szacunkowego czasu przybycia, pozostałego czasu i pozostałości dystansu.

W tym fragmencie kodu do dostosowania szacowania czasu podróży użyto parametrów setTripIcon i setTripText:

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

wyświetlać powiadomienia o nawigacji zakręt po zakrętem;

Udostępnianie wskazówek dojazdu zakręt po zakręcie za pomocą często aktualizowanego powiadomienia nawigacyjnego. Aby powiadomienie było traktowane jako powiadomienie nawigacyjne na ekranie samochodu, twórca powiadomienia musi:

1. Oznacz powiadomienie jako trwające, używając metody NotificationCompat.Builder.setOngoing.
2. Ustaw kategorię powiadomienia na Notification.CATEGORY_NAVIGATION.
3. Rozwiń powiadomienie, klikając CarAppExtender.

Powiadomienie o nawigacji wyświetla się w widżecie szyny u dołu ekranu samochodu. Jeśli poziom ważności powiadomienia jest ustawiony naIMPORTANCE_HIGH, wyświetla się ono również jako powiadomienie ostrzeżenie (HUN). Jeśli znaczenie nie zostało określone za pomocą metody CarAppExtender.Builder.setImportance, zostanie użyte znaczenie kanału powiadomień.

Aplikacja może ustawić w CarAppExtender wartość PendingIntent, która jest wysyłana do aplikacji, gdy użytkownik kliknie HUN lub widżet na pasku.

Jeśli funkcja NotificationCompat.Builder.setOnlyAlertOnce jest wywoływana z wartością true, powiadomienie o wysokiej ważności jest wysyłane tylko raz w usługach HUN.

Ten fragment kodu pokazuje, jak utworzyć powiadomienie nawigacyjne:

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

Regularnie aktualizuj powiadomienie TBT w przypadku zmian odległości, które aktualizuje widżet kolejowy, i wyświetlaj tylko powiadomienie jako HUN. Możesz kontrolować działanie funkcji HUN, ustawiając ważność powiadomienia za pomocą parametru CarAppExtender.Builder.setImportance. Ustawienie wagi na poziomie IMPORTANCE_HIGH powoduje wyświetlenie HUN. Ustawienie go na dowolną inną wartość spowoduje zaktualizowanie tylko widżetu szyny.

Odświeżanie treści szablonu PlaceListNavigationTemplate

Podczas przeglądania list miejsc utworzonych za pomocą PlaceListNavigationTemplate możesz umożliwić kierowcom odświeżanie treści jednym kliknięciem. Aby umożliwić odświeżanie listy, zaimplementuj metodę interfejsu OnContentRefreshListener onContentRefreshRequested i użyj metody PlaceListNavigationTemplate.Builder.setOnContentRefreshListener, aby ustawić listenera w szablonie.

Ten fragment kodu pokazuje, jak ustawić odbiornik w szablonie:

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

Przycisk odświeżania jest widoczny w nagłówku elementu PlaceListNavigationTemplate tylko wtedy, gdy listener ma wartość.

Gdy użytkownik kliknie przycisk odświeżania, wywoływana jest metoda onContentRefreshRequested implementacji OnContentRefreshListener. W klasie onContentRefreshRequested wywołaj metodę Screen.invalidate. Następnie gospodarz wywołuje metodę Screen.onGetTemplate aplikacji, aby pobrać szablon z odświeżonymi treściami. Więcej informacji o odświeżaniu szablonów znajdziesz w artykule Odświeżanie zawartości szablonu. Dopóki kolejny szablon zwracany przez funkcję onGetTemplate jest tego samego typu, jest traktowany jako odświeżenie i nie wlicza się do limitu szablonów.

Wskazówki audio

Aby odtwarzać wskazówki nawigacji przez głośniki samochodu, aplikacja musi poprosić o udzielenie dostępu do dźwięku. W ramach AudioFocusRequest ustaw użycie jako AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE. Ustaw też wzmocnienie ostrości na AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK.

Symulowanie nawigacji

Aby można było zweryfikować funkcję nawigacji w aplikacji podczas przesyłania jej do Sklepu Google Play, aplikacja musi implementować funkcję wywołania zwrotnego NavigationManagerCallback.onAutoDriveEnabled. Gdy wywołasz tę funkcję z poziomu funkcji zwracającej wywołanie zwrotne, aplikacja musi symulować nawigację do wybranego miejsca docelowego, gdy użytkownik rozpocznie nawigację. Aplikacja może wyjść z tego trybu, gdy cykl życia bieżącego procesu Session osiągnie stan Lifecycle.Event.ON_DESTROY.

Aby sprawdzić, czy Twoja implementacja funkcji onAutoDriveEnabled jest wywoływana, wykonaj w wierszu poleceń następujące polecenie:

adb shell dumpsys activity service CAR_APP_SERVICE_NAME AUTO_DRIVE

Przykład:

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

Domyślna aplikacja do nawigacji w samochodzie

W Android Auto domyślna aplikacja nawigacyjna odpowiada ostatniej aplikacji nawigacyjnej uruchomionej przez użytkownika. Aplikacja domyślna otrzymuje intencje nawigacyjne, gdy użytkownik wywołuje polecenia nawigacji za pomocą Asystenta lub gdy inna aplikacja wysyła intencję rozpoczęcia nawigacji.

wyświetlać alerty nawigacyjne w kontekście;

Alert wyświetla ważne informacje dla kierowcy z opcjonalnymi działaniami, bez konieczności opuszczania kontekstu ekranu nawigacji. Aby zapewnić kierowcy jak najlepsze wrażenia, Alert działa w ramach NavigationTemplate, aby nie blokować trasy nawigacji i zminimalizować rozproszenie uwagi kierowcy.

Funkcja Alert jest dostępna tylko w ramach NavigationTemplate. Aby powiadomić użytkownika poza NavigationTemplate, rozważ użycie powiadomienia o zbliżającym się wydarzeniu (HUN), zgodnie z opisem w artykule Wyświetlanie powiadomień.

Na przykład Alert możesz użyć, aby:

• Poinformuj kierowcę o zmianie w bieżącej nawigacji, np. o zmianie warunków na drodze.
• Poproś kierowcę o aktualizację informacji dotyczących bieżącej nawigacji, na przykład o to, czy są fotoradary.
• Proponować nadchodzące zadanie i pytać, czy kierowca je zaakceptuje, np. czy jest gotowy odebrać kogoś po drodze.

W swojej podstawowej formie Alert składa się z tytułu i czasu trwania Alert. Czas trwania jest reprezentowany przez pasek postępu. Opcjonalnie możesz dodać napisy, ikonę i maksymalnie 2 elementy Action.

Gdy wyświetli się Alert, nie jest on przenoszony do innego szablonu, jeśli interakcja z użytkownikiem powoduje opuszczenie NavigationTemplate. Pozostają one w pierwotnym NavigationTemplate do czasu, gdy Alert wygaśnie, użytkownik podejmie działanie lub aplikacja zamknie Alert.

Tworzenie alertu

Aby utworzyć instancję Alert:Alert.Builder

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

Jeśli chcesz słuchać Alertanulowania lub odrzucenia, utwórz implementację interfejsu AlertCallback. Ścieżki wywołania AlertCallback to:

• Jeśli Alert przekroczy limit czasu, host wywołuje metodę AlertCallback.onCancel z wartością AlertCallback.REASON_TIMEOUT. Następnie wywołuje metodę AlertCallback.onDismiss.

• Jeśli kierowca kliknie jeden z przycisków działania, host wywoła funkcję Action.OnClickListener, a następnie funkcję AlertCallback.onDismiss.

• Jeśli Alert nie jest obsługiwana, host wywołuje funkcję AlertCallback.onCancel z wartością AlertCallback.REASON_NOT_SUPPORTED. Host nie dzwoni doAlertCallback.onDismiss, ponieważ Alert nie został wyświetlony.

Konfigurowanie czasu trwania alertu

Wybierz czas trwania Alert, który odpowiada potrzebom aplikacji. Zalecana długość nawigacjiAlert to 10 sekund. Więcej informacji znajdziesz w artykule Ostrzeżenia nawigacyjne.

Pokaż alert

Aby wyświetlić Alert, wywołaj metodę AppManager.showAlert, która jest dostępna w aplikacji CarContext.

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

• Wywołanie funkcji showAlert z parametrem Alert, który ma identyfikator alertId, taki sam jak identyfikator wyświetlanego obecnie elementu Alert, nie powoduje żadnego działania. Wartość Alert się nie zmienia. Aby zaktualizować Alert, musisz utworzyć go ponownie za pomocą nowego alertId.
• Wywołanie showAlert z Alert, które ma inną alertId niż Alert wyświetlaną obecnie, powoduje usunięcie Alert wyświetlanego obecnie.

Zamknij alert

Chociaż Alert jest automatycznie usuwane z powodu limitu czasu lub interakcji kierowcy, możesz też ręcznie usunąć Alert, na przykład gdy informacje są nieaktualne. Aby zamknąć Alert, wywołaj metodę dismissAlert z parametrem alertId Alert.

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

Wywołanie funkcji dismissAlert z wartością alertId, która nie odpowiada aktualnie wyświetlanej wartości Alert, nie powoduje żadnych działań. Nie powoduje wyjątku.