Dodaj obsługę systemu operacyjnego Android Automotive do aplikacji do multimediów

System operacyjny Android Automotive umożliwia użytkownikom instalowanie aplikacji w samochodzie. Aby dotrzeć do użytkowników tej platformy, musisz rozpowszechniać aplikację zoptymalizowaną pod kątem kierowcy, zgodną z systemem operacyjnym Android Automotive. Możesz ponownie wykorzystać prawie cały kod i zasoby w aplikacji Android Auto, ale musisz utworzyć oddzielną kompilację, która spełnia wymagania podane na tej stronie.

Omówienie programowania

Dodanie obsługi systemu operacyjnego Android Automotive wymaga tylko kilku kroków, które opisujemy w sekcjach poniżej:

1. Włącz funkcje motoryzacyjne w Android Studio
2. Tworzenie modułu motoryzacyjnego
3. Zaktualizuj zależności Gradle.
4. Opcjonalnie wdrażaj ustawienia i aktywności związane z logowaniem.
5. Opcjonalnie odczytaj wskazówki dotyczące hosta multimediów.

Uwagi dotyczące projektu

System operacyjny Android Automotive zajmuje się układem treści multimedialnych, które otrzymuje z usługi przeglądarki multimediów Twojej aplikacji. Oznacza to, że gdy użytkownik uruchomi odtwarzanie multimediów, aplikacja nie będzie rysować interfejsu ani rozpoczynać żadnych działań.

Jeśli wdrażasz ustawienia lub aktywności związane z logowaniem, muszą one być zoptymalizowane pod kątem pojazdów. Podczas projektowania tych obszarów aplikacji postępuj zgodnie z wytycznymi dotyczącymi projektowania aplikacji na system operacyjny Android Automotive.

Konfigurowanie projektu

Aby włączyć obsługę systemu operacyjnego Android Automotive, musisz skonfigurować kilka części projektu aplikacji.

Włączanie funkcji motoryzacyjnych w Android Studio

Używaj Androida Studio w wersji 4.0 lub nowszej, aby mieć pewność, że wszystkie funkcje Automotive OS są włączone.

Tworzenie modułu motoryzacyjnego

Niektóre komponenty systemu operacyjnego Android Automotive, takie jak plik manifestu, mają wymagania specyficzne dla platformy. Utwórz moduł, który będzie przechowywać kod tych komponentów oddzielnie od innego kodu w projekcie, np. kodu używanego w aplikacji na telefon.

Aby dodać moduł motoryzacyjny do projektu, wykonaj te czynności:

1. W Android Studio kliknij Plik > Nowy > Nowy moduł.
2. Kliknij kolejno Moduł motoryzacyjny i Dalej.
3. Wpisz nazwę aplikacji lub biblioteki. Jest to nazwa, którą użytkownicy widzą w przypadku Twojej aplikacji w systemie operacyjnym Android Automotive.
4. Wpisz nazwę modułu.
5. Dostosuj nazwę pakietu do swojej aplikacji.

6. W sekcji Minimalny pakiet SDK wybierz API 28: Android 9.0 (Pie), a potem kliknij Dalej.

   Wszystkie samochody obsługujące system operacyjny Android Automotive działają na Androidzie 9 (poziom API 28) lub nowszym, więc wybranie tej wartości spowoduje kierowanie na wszystkie kompatybilne samochody.

7. Wybierz Brak aktywności, a następnie kliknij Zakończ.

Po utworzeniu modułu w Android Studio otwórz plik AndroidManifest.xml w nowym module samochodowym:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.media">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme" />

    <uses-feature
        android:name="android.hardware.type.automotive"
        android:required="true" />

</manifest>

Element <application> zawiera standardowe informacje o aplikacji oraz element <uses-feature>, który deklaruje obsługę systemu operacyjnego Android Automotive. Pamiętaj, że w pliku manifestu nie zadeklarowano żadnych działań.

Jeśli wdrażasz ustawienia lub działania związane z logowaniem, dodaj je tutaj. Te działania są wywoływane przez system za pomocą jawnych intencji i są jedynymi działaniami, które deklarujesz w pliku manifestu aplikacji na system operacyjny Android Automotive.

Po dodaniu ustawień lub aktywności związanych z logowaniem uzupełnij plik manifestu, ustawiając atrybut android:appCategory elementu <application> na "audio".

<application
  ...
  android:appCategory="audio" />

Deklarowanie wymagań dotyczących funkcji

Wszystkie aplikacje utworzone na system operacyjny Android Automotive muszą spełniać określone wymagania, aby można było je rozpowszechniać w Google Play. Więcej informacji znajdziesz w artykule Spełnianie wymagań dotyczących funkcji Google Play.

Deklarowanie obsługi multimediów w systemie operacyjnym Android Automotive

Aby zadeklarować, że aplikacja obsługuje system operacyjny Android Automotive, użyj tego wpisu w pliku manifestu:

<application>
    ...
    <meta-data android:name="com.android.automotive"
        android:resource="@xml/automotive_app_desc"/>
    ...
</application>

Ten wpis w pliku manifestu odnosi się do pliku XML, który deklaruje funkcje motoryzacyjne obsługiwane przez aplikację.

Aby wskazać, że masz aplikację do multimediów, dodaj plik XML o nazwie automotive_app_desc.xml do katalogu res/xml/ w projekcie. W tym pliku umieść te treści:

<automotiveApp>
    <uses name="media"/>
</automotiveApp>

Filtry intencji

System operacyjny Android Automotive używa jawnych intencji do wywoływania działań w aplikacji do multimediów. Nie umieszczaj w pliku manifestu żadnych działań, które mają filtry intencji CATEGORY_LAUNCHER lub ACTION_MAIN.

Działania takie jak w poniższym przykładzie są zwykle kierowane na telefon lub inne urządzenie mobilne. Zadeklaruj te działania w module, który tworzy aplikację na telefon, a nie w module, który tworzy aplikację na Androida Automotive OS.

<activity android:name=".MyActivity">
    <intent-filter>
        <!-- You can't use either of these intents for Android Automotive OS -->
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
        <!--
        In their place, you can include other intent filters for any activities
        that your app needs for Android Automotive OS, such as settings or
        sign-in activities.
        -->
    </intent-filter>
</activity>

Aktualizowanie zależności Gradle

Zalecamy, aby usługa przeglądarki multimediów była przechowywana w osobnym module, który jest udostępniany między aplikacją na telefon a modułem samochodowym. Jeśli używasz tego podejścia, musisz zaktualizować moduł samochodowy, aby uwzględniał moduł udostępniony, jak pokazano w tym fragmencie kodu:

my-auto-module/build.gradle

buildscript {
    ...
    dependencies {
        ...
        implementation project(':shared_module_name')
    }
}

buildscript {
    ...
    dependencies {
        ...
        implementation(project(":shared_module_name"))
    }
}

Wdrażanie ustawień i aktywności związanych z logowaniem

Oprócz usługi przeglądarki multimediów możesz też udostępniać zoptymalizowane pod kątem pojazdu ustawienia i aktywności logowania w aplikacji na Androida Automotive OS. Te aktywności umożliwiają udostępnianie funkcji aplikacji, które nie są uwzględnione w interfejsach Android Media API.

Te działania wdrażaj tylko wtedy, gdy aplikacja na system operacyjny Android Automotive musi umożliwiać użytkownikom logowanie się lub określanie ustawień aplikacji. Te aktywności nie są używane przez Androida Auto.

Przepływy pracy związane z aktywnością

Ten diagram pokazuje, jak użytkownik wchodzi w interakcje z ustawieniami i aktywnością związaną z logowaniem w systemie operacyjnym Android Automotive:

Rysunek 1. procesy związane z ustawieniami i aktywnością logowania;

Ograniczanie rozpraszania uwagi w ustawieniach i podczas logowania

Aby mieć pewność, że ustawienia i aktywności związane z logowaniem są dostępne tylko wtedy, gdy pojazd użytkownika jest zaparkowany, sprawdź, czy element <activity> nie zawiera elementu <meta-data>. Jeśli podczas sprawdzania wykryjemy taki element, Twoja aplikacja zostanie odrzucona.

<!-- NOT ALLOWED -->
<meta-data
  android:name="distractionOptimized"
  android:value="true"/>

Dodawanie aktywności związanej z ustawieniami

Możesz dodać aktywność z ustawieniami zoptymalizowanymi pod kątem pojazdów, aby użytkownicy mogli konfigurować ustawienia aplikacji w samochodzie. Aktywność w ustawieniach może też umożliwiać inne działania, takie jak logowanie się na konto użytkownika lub wylogowywanie się z niego oraz przełączanie kont użytkowników. Pamiętaj, że ta aktywność jest wywoływana tylko przez aplikację działającą w systemie operacyjnym Android Automotive. Aplikacje na telefon połączone z Androidem Auto nie korzystają z tej funkcji.

Deklarowanie aktywności związanej z ustawieniami

Musisz zadeklarować aktywność związaną z ustawieniami w pliku manifestu aplikacji, jak pokazano w tym fragmencie kodu:

<application>
    ...
    <activity android:name=".AppSettingsActivity"
              android:exported="true"
              android:theme="@style/SettingsActivity"
              android:label="@string/app_settings_activity_title">
        <intent-filter>
            <action android:name="android.intent.action.APPLICATION_PREFERENCES"/>
        </intent-filter>
    </activity>
    ...
</application>

Wdrażanie aktywności związanej z ustawieniami

Gdy użytkownik uruchomi Twoją aplikację, system operacyjny Android Automotive wykryje zadeklarowaną przez Ciebie aktywność związaną z ustawieniami i wyświetli element interfejsu, np. ikonę. Użytkownik może kliknąć lub wybrać ten element na wyświetlaczu samochodu, aby przejść do aktywności. System operacyjny Android Automotive wysyła intencję ACTION_APPLICATION_PREFERENCES, która nakazuje aplikacji rozpoczęcie działania ustawień.

W pozostałej części tej sekcji dowiesz się, jak dostosować kod z przykładowej aplikacji Universal Android Music Player (UAMP), aby zaimplementować w swojej aplikacji aktywność związaną z ustawieniami.

Na początek pobierz przykładowy kod:

# Clone the UAMP repository
git clone https://github.com/android/uamp.git

# Fetch the appropriate pull request to your local repository
git fetch origin pull/323/head:NEW_LOCAL_BRANCH_NAME

# Switch to the new branch
git checkout NEW_LOCAL_BRANCH_NAME

Aby wdrożyć aktywność, wykonaj te czynności:

1. Skopiuj folder automotive/automotive-lib do modułu samochodowego.
2. Zdefiniuj drzewo preferencji, jak w automotive/src/main/res/xml/preferences.xml.

3. Wdróż PreferenceFragmentCompat, które wyświetla aktywność związaną z ustawieniami. Więcej informacji znajdziesz w plikach SettingsFragment.kt i SettingsActivity.kt w UAMP oraz w przewodniku po ustawieniach Androida.

Podczas wdrażania aktywności związanej z ustawieniami pamiętaj o tych sprawdzonych metodach korzystania z niektórych komponentów w bibliotece Preferencje:

• W aktywności ustawień nie może być więcej niż 2 poziomy zagnieżdżenia poniżej widoku głównego.
• Nie używaj znaku DropDownPreference. Zamiast tego użyj ListPreference.
• Komponenty organizacyjne:
  • PreferenceScreen
    • Musi to być najwyższy poziom drzewa ustawień.
  • PreferenceCategory
    • Służy do grupowania obiektów Preference.
    • Dodaj title.
• We wszystkich tych komponentach umieść znaki key i title. Możesz też dodać summary, icon lub oba te elementy:
  • Preference
    • Dostosuj logikę w wywołaniu zwrotnym onPreferenceTreeClick() implementacji PreferenceFragmentCompat.
  • CheckBoxPreference
    • W przypadku tekstu warunkowego może zawierać summaryOn lub summaryOff zamiast summary.
  • SwitchPreference
    • W przypadku tekstu warunkowego może zawierać summaryOn lub summaryOff zamiast summary.
    • Może mieć wartość switchTextOn lub switchTextOff.
  • SeekBarPreference
    • Uwzględnij min, max i defaultValue.
  • EditTextPreference
    • Uwzględnij dialogTitle, positiveButtonText i negativeButtonText.
    • Może zawierać jedną lub obie wartości dialogMessage i dialogLayoutResource.
  • com.example.android.uamp.automotive.lib.ListPreference
    • Pochodzi głównie z ListPreference.
    • Służy do wyświetlania listy obiektów Preference z możliwością wyboru jednego z nich.
    • Musi zawierać tablicę wartości entries i odpowiadających im wartości entryValues.
  • com.example.android.uamp.automotive.lib.MultiSelectListPreference
    • Pochodzi głównie z MultiSelectListPreference
    • Służy do wyświetlania listy wyboru zawierającej obiekty Preference.
    • Musi zawierać tablicę wartości entries i odpowiadających im wartości entryValues.

Dodawanie aktywności związanej z logowaniem

Jeśli aplikacja wymaga zalogowania się użytkownika przed rozpoczęciem korzystania z niej, możesz dodać aktywność logowania zoptymalizowaną pod kątem pojazdów, która obsługuje logowanie się i wylogowywanie z aplikacji. Możesz też dodać procesy logowania i wylogowywania do aktywności ustawień, ale jeśli aplikacja nie może być używana, dopóki użytkownik się nie zaloguje, użyj dedykowanej aktywności logowania. Pamiętaj, że ta aktywność jest wywoływana tylko przez aplikację działającą w systemie operacyjnym Android Automotive. Aplikacje na telefon połączone z Androidem Auto nie korzystają z tej funkcji.

Wymagaj zalogowania się przy uruchamianiu aplikacji

Aby wymagać od użytkownika zalogowania się przed rozpoczęciem korzystania z aplikacji, usługa przeglądarki multimediów musi wykonać te czynności:

1. W metodzie onLoadChildren() usługi wyślij wynik null za pomocą metody sendResult().
2. Ustaw PlaybackStateCompat sesji multimedialnej na STATE_ERROR za pomocą metody setState(). Informuje to system operacyjny Android Automotive, że do czasu rozwiązania problemu nie można wykonywać żadnych innych operacji.
3. Ustaw kod błędu sesji multimedialnej PlaybackStateCompat na ERROR_CODE_AUTHENTICATION_EXPIRED. Informuje to system operacyjny Android Automotive, że użytkownik musi się uwierzytelnić.
4. Ustaw komunikat o błędzie sesji multimedialnej za pomocą metody setErrorMessage().PlaybackStateCompat Ten komunikat o błędzie jest widoczny dla użytkownika, więc przetłumacz go na język ustawiony na urządzeniu użytkownika.

5. Ustaw dodatkowe informacje sesji multimedialnej za pomocą metody setExtras().PlaybackStateCompat Dodaj te 2 lub 3 klucze:

   • PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_LABEL: ciąg znaków wyświetlany na przycisku, który rozpoczyna proces logowania. Ten ciąg znaków jest widoczny dla użytkownika, więc przetłumacz go na jego bieżące ustawienia regionalne.
   • PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_INTENT:PendingIntent, który po kliknięciu przycisku wskazanego przez PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_LABEL kieruje użytkownika do aktywności związanej z logowaniem.
   • PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_USING_CAR_APP_LIBRARY_INTENT: PendingIntent, który kieruje użytkownika do aktywności logowania w bibliotece aplikacji samochodowych. Host biblioteki aplikacji samochodowych jest zoptymalizowany pod kątem prowadzenia pojazdu, więc intencja automatycznie pomija ekran rozwiązywania błędów i od razu wyświetla ekran logowania. Jeśli ustawisz ten dodatkowy parametr, ustaw też dwa poprzednie, aby zapewnić zgodność wsteczną ze starszymi pojazdami.

Ten fragment kodu pokazuje, jak aplikacja może wymagać od użytkownika zalogowania się przed rozpoczęciem korzystania z niej:

import androidx.media.utils.MediaConstants

val signInIntent = Intent(this, SignInActivity::class.java)
val signInActivityPendingIntent = PendingIntent.getActivity(this, 0,
    signInIntent, 0)
val extras = Bundle().apply {
    putString(
        MediaConstants.PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_LABEL,
        "Sign in"
    )
    putParcelable(
        MediaConstants.PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_INTENT,
        signInActivityPendingIntent
    )
}

val playbackState = PlaybackStateCompat.Builder()
        .setState(PlaybackStateCompat.STATE_ERROR, 0, 0f)
        .setErrorMessage(
            PlaybackStateCompat.ERROR_CODE_AUTHENTICATION_EXPIRED,
            "Authentication required"
        )
        .setExtras(extras)
        .build()
mediaSession.setPlaybackState(playbackState)

import androidx.media.utils.MediaConstants;

Intent signInIntent = new Intent(this, SignInActivity.class);
PendingIntent signInActivityPendingIntent = PendingIntent.getActivity(this, 0,
    signInIntent, 0);
Bundle extras = new Bundle();
extras.putString(
    MediaConstants.PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_LABEL,
    "Sign in");
extras.putParcelable(
    MediaConstants.PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_INTENT,
    signInActivityPendingIntent);

PlaybackStateCompat playbackState = new PlaybackStateCompat.Builder()
    .setState(PlaybackStateCompat.STATE_ERROR, 0, 0f)
    .setErrorMessage(
            PlaybackStateCompat.ERROR_CODE_AUTHENTICATION_EXPIRED,
            "Authentication required"
    )
    .setExtras(extras)
    .build();
mediaSession.setPlaybackState(playbackState);

Po pomyślnym uwierzytelnieniu użytkownika ustaw wartość PlaybackStateCompat z powrotem na stan inny niż STATE_ERROR, a następnie przywróć użytkownikowi dostęp do systemu operacyjnego Android Automotive, wywołując metodę finish() aktywności.

Wdrażanie aktywności związanej z logowaniem

Google oferuje różne narzędzia do weryfikacji tożsamości, których możesz używać, aby ułatwić użytkownikom logowanie się w aplikacji w samochodzie. Niektóre narzędzia, takie jak Uwierzytelnianie Firebase, udostępniają pełne zestawy narzędzi, które mogą pomóc w tworzeniu spersonalizowanych funkcji uwierzytelniania. Inne narzędzia wykorzystują istniejące dane logowania użytkownika lub inne technologie, aby ułatwić Ci tworzenie wygodnych sposobów logowania.

Poniższe narzędzia mogą ułatwić logowanie użytkownikom, którzy logowali się już wcześniej na innym urządzeniu:

• Logowanie i rejestracja jednym dotknięciem: jeśli masz już wdrożoną funkcję logowania jednym dotknięciem na innych urządzeniach, np. w aplikacji na telefon, wdróż ją w aplikacji na Androida Automotive OS, aby obsługiwać obecnych użytkowników logowania jednym dotknięciem.
• Logowanie przez Google: jeśli masz już wdrożone logowanie przez Google na innych urządzeniach, np. w aplikacji na telefon, wdróż logowanie przez Google w aplikacji na system operacyjny Android Automotive, aby obsługiwać obecnych użytkowników logowania przez Google.
• Autouzupełnianie z Google: jeśli użytkownicy włączyli autouzupełnianie z Google na innych urządzeniach z Androidem, ich dane logowania są zapisywane w Menedżerze haseł Google. Gdy użytkownicy zalogują się w aplikacji na system operacyjny Android Automotive, funkcja Autouzupełnianie z Google zasugeruje odpowiednie zapisane dane logowania. Korzystanie z Autouzupełniania z Google nie wymaga żadnych prac związanych z opracowywaniem aplikacji. Deweloperzy aplikacji mogą jednak optymalizować swoje aplikacje, aby uzyskać lepsze wyniki jakości. Autouzupełnianie z Google jest obsługiwane na wszystkich urządzeniach z Androidem 8.0 (poziom interfejsu API 26) lub nowszym, w tym na systemie operacyjnym Android Automotive.

Użyj konta AccountManager

Aplikacje na system operacyjny Android Automotive, które wymagają uwierzytelniania, muszą używać AccountManager z tych powodów:

• Lepsza obsługa i łatwiejsze zarządzanie kontami: użytkownicy mogą zarządzać wszystkimi kontami w menu kont w ustawieniach systemu, w tym logować się i wylogowywać.
• Tryb „gościa”: samochody są urządzeniami współdzielonymi, co oznacza, że producenci OEM mogą włączyć w pojeździe tryb „gościa”, w którym nie można dodawać kont. To ograniczenie jest osiągane za pomocą DISALLOW_MODIFY_ACCOUNTS w przypadku AccountManager.

Uprawnienia

Jeśli musisz poprosić użytkownika o uprawnienia, użyj tego samego procesu co w przypadku działania uwierzytelniania lub działania ustawień na diagramie przepływów działań w poprzedniej sekcji.

Wdrażanie wylogowywania

Niezależnie od tego, jak zaimplementujesz logowanie, gdy użytkownik się wyloguje, musisz wywołać funkcję MediaBrowserServiceCompat#notifyChildrenChanged(rootId), aby unieważnić drzewo przeglądania. Dzięki temu aplikacja hostująca multimedia usunie wszelkie informacje związane z użytkownikiem (np. ostatnie zapytanie).

Uruchamianie aplikacji hosta multimediów

Możesz tworzyć intencje otwierania aplikacji hosta multimediów w swojej aplikacji lub treści w niej. Na przykład:

• Aplikacja może wysyłać powiadomienie z intencją oczekującą, która umożliwia użytkownikowi otwarcie aplikacji w celu odtworzenia nowych treści.
• Aplikacja może obsługiwać precyzyjne linki i otwierać aplikację hosta w najodpowiedniejszym widoku.

Określanie możliwości hosta multimediów

Wersje aplikacji hosta multimediów obsługują różne funkcje. Usługi wskazują obsługę różnych funkcji, dodając filtry intencji dla tych działań intencji:

• android.car.intent.action.MEDIA_TEMPLATE
• androidx.car.app.mediaextensions.action.MEDIA_TEMPLATE_V2

Wszystkie aplikacje hostujące multimedia obsługują intencje MEDIA_TEMPLATE. Aby sprawdzić, czy host multimediów obsługuje intencje MEDIA_TEMPLATE_V2, możesz użyć queryIntentActivities() w ten sposób:

val isMediaTemplateV2Supported = packageManager.queryIntentActivities(
  Intent(MediaIntentExtras.ACTION_MEDIA_TEMPLATE_V2),
  //  MATCH_DEFAULT_ONLY  since the host should be started with implicit intents
  //  MATCH_SYSTEM_ONLY  excludes any apps that aren't preinstalled
  PackageManager.MATCH_DEFAULT_ONLY or PackageManager.MATCH_SYSTEM_ONLY
).size > 0

Tworzenie i używanie intencji

W zależności od tego, które działania związane z intencją są obsługiwane przez hosta multimediów i jaki jest Twój konkretny przypadek użycia, podczas tworzenia intencji używanej do uruchamiania aplikacji hosta multimediów możesz podać te dodatkowe informacje:

Na przykład w przypadku hosta, który obsługuje MEDIA_TEMPLATE_V2, poniższy kod otworzy aplikację hosta multimediów, połączy ją z MyMediaBrowserService, wyszuka „Jazz” i odtwarza pierwszy element z wyników wyszukiwania. Na wszystkich innych hostach otworzy tylko aplikację hosta multimediów i wyszuka „Jazz”, pozostawiając użytkownikowi wybór elementu do odtworzenia z wyników.

val startMediaHostIntent = Intent(ACTION_MEDIA_TEMPLATE)
  .putExtra(MediaIntentExtras.EXTRA_KEY_MEDIA_COMPONENT, MyMediaBrowserService::class.java)
  .putExtra(MediaIntentExtras.EXTRA_KEY_SEARCH_QUERY, "Jazz")
  .putExtra(MediaIntentExtras.EXTRA_KEY_SEARCH_ACTION, MediaIntentExtras.EXTRA_VALUE_PLAY_FIRST_ITEM_FROM_SEARCH)

context.startActivity(startMediaHostIntent)

Obsługa precyzyjnych linków

Aby zwiększyć komfort korzystania z aplikacji multimedialnej na urządzeniach z systemem operacyjnym Android Automotive, możesz dodać do niej obsługę precyzyjnych linków. Dzięki temu użytkownicy będą mogli otwierać aplikację bezpośrednio z przeglądarki lub po otrzymaniu adresu URL udostępnionego z telefonu za pomocą szybkiego udostępniania.

Dodawanie filtrów intencji precyzyjnych linków

Aby poinformować system operacyjny, że Twoja aplikacja może obsługiwać precyzyjne linki, musi ona mieć działania z odpowiednimi filtrami intencji. Wskazówki dotyczące formatu filtrów intencji używanych w przypadku precyzyjnych linków znajdziesz w artykule Dodawanie filtrów intencji dla linków przychodzących.

Aby zapewnić użytkownikom jak najlepsze wrażenia, obsługuj wszystkie precyzyjne linki, które obsługuje Twoja aplikacja mobilna, jeśli można je w rozsądny sposób obsługiwać w aplikacji samochodowej. Jeśli Twoja aplikacja ma ustawienia lub działania związane z logowaniem, filtry intencji do obsługi precyzyjnych linków do ustawień i logowania powinny być zadeklarowane w odpowiednich elementach manifestu <activity>. W przypadku odtwarzania multimediów i przeglądania precyzyjnych linków możesz użyć aktywności trampoliny, jak opisano w dalszej części tej sekcji.

Obsługa intencji precyzyjnych linków

Więcej informacji o tym, jak odczytywać intencje przychodzące i na nie reagować, znajdziesz w artykule Odczytywanie danych z intencji przychodzących.

Obsługa precyzyjnych linków do odtwarzania multimediów i przeglądania

Interfejs przeglądania i odtwarzania jest rysowany przez aplikację hosta, więc aktywność używana do obsługi precyzyjnych linków do odtwarzania i przeglądania nie powinna mieć własnego interfejsu.

Powinna być używana głównie do tworzenia i używania intencji uruchamiania aplikacji hosta multimediów. W razie potrzeby może też obsługiwać dodatkowe zmiany stanu aplikacji, takie jak dodawanie elementów multimedialnych do kolejki. Poniższy fragment kodu pokazuje przykładową implementację aktywności na trampolinie:

fun DeepLinkTrampolineActivity : ComponentActivity() {

  override fun onCreate() {
    handleIntent(intent)
  }

  override fun onNewIntent(intent: Intent) {
    handleIntent(intent)
  }

  private fun handleIntent(intent: Intent) {
    // Handle any side effects, such as adding a song to the queue
    ...
    // Build the intent used to start the media host app
    val startMediaHostIntent = ...
    startActivity(intent)
    // Finish the activity immediately so it isn't shown on screen
    finish()
  }
}

Odczytywanie wskazówek dotyczących hosta multimediów

W zależności od aplikacji systemowej (w tym jej wersji), która łączy się z usługą przeglądarki multimediów, aplikacja może otrzymywać te dodatkowe informacje:

• MediaBrowserServiceCompat#onGetRoot:

  • KEY_ROOT_HINT_MEDIA_HOST_VERSION
  • KEY_ROOT_HINT_MEDIA_SESSION_API
  • BROWSER_ROOT_HINTS_KEY_MEDIA_ART_SIZE_PIXELS
  • BROWSER_ROOT_HINTS_KEY_CUSTOM_BROWSER_ACTION_LIMIT
  • BROWSER_ROOT_HINTS_KEY_ROOT_CHILDREN_LIMIT
  • KEY_ROOT_HINT_MAX_QUEUE_ITEMS_WHILE_RESTRICTED

• W językach MediaBrowserServiceCompat#onLoadChildren i MediaBrowserServiceCompat#onSearch:

  • KEY_HINT_VIEW_MAX_ITEMS_WHILE_RESTRICTED
  • KEY_HINT_VIEW_MAX_LIST_ITEMS_COUNT_PER_ROW
  • KEY_HINT_VIEW_MAX_CATEGORY_LIST_ITEMS_COUNT_PER_ROW
  • KEY_HINT_VIEW_MAX_GRID_ITEMS_COUNT_PER_ROW
  • KEY_HINT_VIEW_MAX_CATEGORY_GRID_ITEMS_COUNT_PER_ROW

Obsługa błędów

Błędy w aplikacjach do multimediów w systemie operacyjnym Android Automotive są zgłaszane za pomocą PlaybackStateCompat sesji multimediów. W przypadku wszystkich błędów ustaw odpowiedni kod błędu i komunikat o błędzie w PlaybackStateCompat. Spowoduje to wyświetlenie w interfejsie ikony Toast.

Jeśli wystąpi błąd, ale odtwarzanie może być kontynuowane, zgłoś błąd niekrytyczny. Na przykład użytkownik może odtwarzać muzykę w aplikacji przed zalogowaniem się, ale musi się zalogować, aby móc pominąć utwór. Gdy używasz błędu niekrytycznego, system może zaproponować użytkownikowi zalogowanie się bez przerywania odtwarzania bieżącego elementu multimedialnego.

Gdy zgłosisz błąd niekrytyczny, zachowaj pozostałą część PlaybackStateCompat w niezmienionej postaci, z wyjątkiem kodu błędu i komunikatu o błędzie. Dzięki temu odtwarzanie bieżącego elementu multimedialnego może być kontynuowane, podczas gdy użytkownik decyduje, czy chce się zalogować.

Jeśli odtwarzanie nie jest możliwe, np. gdy nie ma połączenia z internetem i nie ma treści offline, ustaw stan PlaybackStateCompat na STATE_ERROR.

Przy kolejnych aktualizacjach PlaybackStateCompat usuwaj kody błędów i komunikaty o błędach, aby uniknąć wyświetlania wielu ostrzeżeń dotyczących tego samego błędu.

Jeśli w dowolnym momencie nie możesz wczytać drzewa przeglądania, np. jeśli wymagane jest uwierzytelnianie, a użytkownik nie jest zalogowany, wyślij puste drzewo przeglądania. Aby to zasygnalizować, zwróć wartość null z funkcji onLoadChildren() w przypadku węzła głównego multimediów. W takim przypadku system wyświetli błąd na pełnym ekranie z komunikatem o błędzie ustawionym w PlaybackStateCompat.

Błędy wymagające podjęcia działań

Jeśli błąd wymaga podjęcia działania, w elemencie PlaybackStateCompat ustaw dodatkowo te 2 wartości dodatkowe:

• PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_LABEL: etykieta przycisku, który należy kliknąć, aby rozwiązać problem. Ten ciąg znaków jest widoczny dla użytkownika, więc przetłumacz go na język ustawiony na urządzeniu.
• PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_INTENT:PendingIntent, który przycisk uruchamia, aby rozwiązać problem, np. uruchamiając aktywność logowania.

Błędy wymagające podjęcia działania są oznaczone symbolem Dialog i mogą być rozwiązywane przez użytkowników tylko wtedy, gdy samochód jest zatrzymany.

Testowanie przypadków błędów

Sprawdź, czy aplikacja prawidłowo obsługuje błędy we wszystkich scenariuszach, w tym:

• Różne wersje produktu: np. bezpłatna i premium lub dla zalogowanych i niezalogowanych użytkowników.
• Różne stany jazdy: np. parkowanie i jazda.
• Różne stany połączenia: np. online i offline.

Inne uwagi

Podczas tworzenia aplikacji na Androida Automotive OS pamiętaj o tych kwestiach:

Treść offline

W razie potrzeby wdróż obsługę odtwarzania offline. Samochody z Androidem Automotive OS powinny mieć własne połączenie do transmisji danych, co oznacza, że pakiet danych jest wliczony w cenę pojazdu lub opłacany przez użytkownika. Oczekuje się jednak, że samochody będą miały bardziej zmienne połączenie niż urządzenia mobilne.

Oto kilka kwestii, o których warto pamiętać, gdy rozważasz strategię pomocy offline:

• Najlepszy czas na pobieranie treści to okres, w którym aplikacja jest używana.
• Nie zakładaj, że sieć Wi-Fi jest dostępna. Samochód może nigdy nie znaleźć się w zasięgu Wi-Fi lub producent OEM może wyłączyć Wi-Fi na rzecz sieci komórkowej.
• Możesz buforować treści, z których użytkownicy będą korzystać, ale zalecamy, aby użytkownik mógł zmienić to zachowanie w ustawieniach.
• Pojemność dysku w samochodach jest różna, dlatego udostępnij użytkownikom możliwość usuwania treści offline, np. za pomocą opcji w aktywności ustawień.

Obsługa WebView

Komponenty WebView są obsługiwane w systemie operacyjnym Android Automotive, ale są dozwolone tylko w przypadku ustawień i aktywności związanych z logowaniem. Aktywności korzystające z widoku WebView muszą mieć poza nim element „zamknij” lub „wstecz”.

Oto kilka przykładów dopuszczalnych przypadków użycia widoków WebView:

• wyświetlanie w aktywności ustawień linków do polityki prywatności, warunków korzystania z usługi lub innych dokumentów prawnych;
• Proces internetowy w Twojej aktywności związanej z logowaniem.

Jeśli korzystasz z WebView, możesz włączyć JavaScript.

Zabezpieczanie WebView

Podejmij wszelkie możliwe środki ostrożności, aby mieć pewność, że komponent WebView nie jest punktem wejścia do internetu. Poniższy fragment kodu pokazuje, jak zablokować WebView na adresie URL używanym w wywołaniu loadUrl() i zapobiec przekierowaniom. Zdecydowanie zalecamy wdrażanie takich zabezpieczeń, gdy jest to możliwe, np. podczas wyświetlania linków związanych z kwestiami prawnymi.

override fun shouldOverrideUrlLoading(webView: WebView,
                             webResourceRequest: WebResourceRequest): Boolean {
  val originalUri: Uri = Uri.parse(webView.originalUrl)
  // Check for allowed URLs
  if (originalUri.equals(Uri.parse(BLANK_URL))
      || originalUri.equals(webResourceRequest.url)) {
    return false
  }
  if (webResourceRequest.isRedirect) {
    logger.w("Redirect detected, not following")
    return true
  }
  setupWizardWebViewClientListener.onUriBlocked(webResourceRequest.url)
  logger.w(
    String.format(
      "Navigation prevented to %s original is %s", webResourceRequest.url, originalUri))
  return true
}

@Override
public boolean shouldOverrideUrlLoading(WebView webView, WebResourceRequest webResourceRequest) {
  Uri originalUri = Uri.parse(webView.getOriginalUrl());
  // Check for allowed URLs
  if (originalUri.equals(Uri.parse(BLANK_URL))
      || originalUri.equals(webResourceRequest.getUrl())) {
    return false;
  }
  if (webResourceRequest.isRedirect()) {
    logger.w("Redirect detected, not following");
    return true;
  }
  setupWizardWebViewClientListener.onUriBlocked(webResourceRequest.getUrl());
  logger.w(
      String.format(
          "Navigation prevented to %s original is %s", webResourceRequest.getUrl(), originalUri));
  return true;
}

Nazwy pakietów

Ponieważ dystrybuujesz osobny pakiet aplikacji na Androida (APK) na Androida Automotive OS, możesz ponownie wykorzystać nazwę pakietu z aplikacji mobilnej lub utworzyć nową nazwę pakietu. Jeśli używasz innej nazwy pakietu, Twoja aplikacja będzie miała 2 osobne wpisy w Sklepie Play. Jeśli ponownie użyjesz obecnej nazwy pakietu, Twoja aplikacja będzie miała jedną stronę w obu platformach.

Jest to przede wszystkim decyzja biznesowa. Jeśli na przykład masz jeden zespół pracujący nad aplikacją mobilną i osobny zespół pracujący nad aplikacją na Androida Automotive OS, warto używać oddzielnych nazw pakietów i umożliwić każdemu zespołowi zarządzanie własną wizytówką w Sklepie Play. Nie ma dużej różnicy w nakładzie pracy technicznej wymaganej do zastosowania obu tych podejść.

W tej tabeli zestawiono inne najważniejsze różnice między zachowaniem obecnej nazwy pakietu a użyciem nowej nazwy pakietu:

Najczęstsze pytania

W sekcjach poniżej znajdziesz odpowiedzi na niektóre z najczęstszych pytań dotyczących systemu operacyjnego Android Automotive.

Sprzęt

Czy moja aplikacja może uzyskać dostęp do mikrofonu?

W przypadku aplikacji kierowanych na Androida 10 (API na poziomie 29) lub nowszego zapoznaj się z dokumentacją na temat udostępniania danych wejściowych audio. Nie jest to możliwe w przypadku interfejsu API na poziomie niższym niż 29.

Do których interfejsów API samochodu możemy uzyskać dostęp i jak to zrobić?

Możesz korzystać tylko z interfejsów API udostępnianych przez producenta OEM. Trwają prace nad opracowaniem procesów, które ujednolicą sposób uzyskiwania dostępu do tych interfejsów API.

Aplikacje mogą uzyskiwać dostęp do interfejsów API samochodu za pomocą SetProperty() i GetProperty() w CarPropertyManager. Listę wszystkich dostępnych właściwości znajdziesz w kodzie źródłowym lub dokumentacji. Jeśli właściwość jest oznaczona adnotacją @SystemApi, jest ona ograniczona do wstępnie załadowanych aplikacji systemowych.

Jakie typy kodeków audio są obsługiwane?

Szczegółowe informacje o kodekach audio znajdziesz w dokumencie CDD Androida.

Czy Widevine DRM jest obsługiwany?

Tak. Obsługiwany jest system DRM Widevine.

Programowanie i testowanie

Czy istnieją jakieś ograniczenia lub zalecenia dotyczące korzystania z zewnętrznych pakietów SDK i bibliotek?

Nie mamy konkretnych wytycznych dotyczących korzystania z pakietów SDK i bibliotek innych firm. Jeśli zdecydujesz się używać pakietów SDK i bibliotek innych firm, nadal będziesz odpowiadać za spełnianie wszystkich wymagań dotyczących jakości aplikacji na samochody.

Czy mogę używać usługi na pierwszym planie?

Jedynym dozwolonym przypadkiem użycia usługi działającej na pierwszym planie jest pobieranie treści do użytku offline. Jeśli masz inny przypadek użycia usługi (działającej) na pierwszym planie, w którym chcesz uzyskać pomoc, skontaktuj się z nami za pomocą grupy dyskusyjnej systemu operacyjnego Android Automotive.

Publikowanie aplikacji na system operacyjny Android Automotive

Jak opublikować aplikację na system operacyjny Android Automotive za pomocą Konsoli Google Play?

Szczegółowe informacje o publikowaniu aplikacji na system operacyjny Android Automotive za pomocą Konsoli Google Play znajdziesz w artykule Dystrybucja aplikacji na samochody.

Dodatkowe materiały

Więcej informacji o systemie operacyjnym Android Automotive znajdziesz w tych materiałach:

Przykłady

• Uniwersalny odtwarzacz muzyki na Androida

Przewodniki

• Projektowanie pod kątem samochodów
• Korzystanie z aplikacji testowej opcji sterowania multimediami
• Powiadomienia w systemie operacyjnym Android Automotive
• Jakość aplikacji na Androida dla samochodów

Blogi

• Aktualizacje systemu operacyjnego Android Automotive dla deweloperów
• Tworzenie aplikacji na system operacyjny Android Automotive

Filmy

• How to Build Media Apps for Cars (Android Dev Summit '19)
• Jak tworzyć aplikacje na Androida do samochodów (Google I/O'19)

Zgłaszanie problemów z multimediami w systemie operacyjnym Android Automotive

Jeśli podczas tworzenia aplikacji do multimediów na Androida Automotive OS napotkasz problem, możesz go zgłosić za pomocą Google Issue Tracker. Pamiętaj, aby podać wszystkie wymagane informacje w szablonie problemu.

Tworzenie nowego problemu

Zanim zgłosisz nowy problem, sprawdź, czy nie został on już zgłoszony na liście problemów. Aby zasubskrybować problem i na niego zagłosować, kliknij gwiazdkę przy problemie w narzędziu do śledzenia. Więcej informacji znajdziesz w sekcji Subskrybowanie problemu.