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

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

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

Dodanie obsługi systemu operacyjnego Android Automotive wymaga wykonania kilku czynności opisanych w następnych sekcjach:

1. Włącz funkcje samochodowe w Android Studio.
2. Utwórz moduł dotyczący motoryzacji.
3. Zaktualizuj zależności Gradle.
4. Opcjonalnie wdróż ustawienia i aktywności logowania.
5. Opcjonalnie przeczytaj wskazówki dotyczące hosta multimediów.

Uwagi dotyczące projektu

System operacyjny Android Automotive zajmuje się układaniem treści multimedialnych, które otrzymuje od usługi przeglądarki multimediów w aplikacji. Oznacza to, że aplikacja nie wyświetla interfejsu użytkownika ani nie uruchamia żadnych działań, gdy użytkownik odtwarza multimedia.

Jeśli wdrażasz ustawienia lub czynności logowania, czynności te muszą być zoptymalizowane pod kątem pojazdu. Podczas projektowania tych obszarów aplikacji zapoznaj się z wytycznymi dotyczącymi projektowania na potrzeby systemu operacyjnego Android Automotive.

Konfigurowanie projektu

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

Włączanie funkcji samochodowych w Android Studio

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

Tworzenie modułu samochodowego

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

Aby dodać moduł samochodowy do projektu:

1. W Android Studio kliknij Plik > Nowy > Nowy moduł.
2. Kliknij kolejno Moduł motoryzacyjny i Dalej.
3. Wpisz nazwę aplikacji lub biblioteki. To nazwa, którą użytkownicy widzą w aplikacji w systemie operacyjnym Android Automotive.
4. Wpisz nazwę modułu.
5. Dostosuj nazwę pakietu tak, aby pasowała do Twojej 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 interfejsu API 28) lub nowszym, więc wybór tej wartości spowoduje kierowanie reklam do wszystkich kompatybilnych samochodów.

7. Wybierz Brak aktywności i kliknij Zakończ.

Po utworzeniu modułu w Android Studio otwórz 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 ma żadnych deklarowanych aktywności.

Jeśli wdrożono ustawienia lub aktywności logowania, dodaj je tutaj. Te aktywności są wywoływane przez system za pomocą jawnych intencji i są jedynymi aktywnościami deklarowanymi w pliku manifestu aplikacji na system operacyjny Android Automotive.

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

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

Zadeklaruj wymagania dotyczące funkcji

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

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 samochodowe obsługiwane przez aplikację.

Aby wskazać, że masz aplikację multimedialną, 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 dodawaj do pliku manifestu żadnych działań z filtrami intencji CATEGORY_LAUNCHER lub ACTION_MAIN.

Aktywności takie jak w tym przykładzie zwykle dotyczą telefonu lub innego urządzenia mobilnego. Deklaruj te czynności w module, który tworzy aplikację na telefon, a nie w module, który tworzy aplikację na system operacyjny Android Automotive.

<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 multimedialnej była przechowywana w oddzielnym module, który jest wspólny dla aplikacji na telefon i modułu samochodowego. Jeśli używasz tego podejścia, musisz zaktualizować moduł dotyczący pojazdów, aby uwzględnić w nim moduł współdzielony, 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 działań logowania

Oprócz usługi przeglądarki multimediów możesz też udostępniać optymalizowane pod kątem pojazdu ustawienia i aktywności logowania w aplikacji na system operacyjny Android Automotive. Te aktywności umożliwiają udostępnianie funkcji aplikacji, których nie ma w interfejsach API multimediów Androida.

Wykonuj te czynności tylko wtedy, gdy aplikacja na system operacyjny Android Automotive musi umożliwiać użytkownikom logowanie się lub ustawianie ustawień aplikacji. Te czynności nie są obsługiwane przez Androida Auto.

Przepływy pracy dotyczące aktywności

Ten diagram pokazuje, jak użytkownik wchodzi w interakcje z ustawieniami i aktywnościami logowania w systemie operacyjnym Android Automotive:

Rysunek 1. procesy związane z ustawieniami i logowaniem.

unikać rozpraszania uwagi podczas konfigurowania ustawień i logowania się.

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

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

Dodawanie aktywności związanej z ustawieniami

Możesz dodać aktywność ustawień zoptymalizowaną pod kątem pojazdów, aby użytkownicy mogli konfigurować ustawienia aplikacji w samochodzie. Aktywność związana z ustawieniami może też obejmować inne przepływy pracy, takie jak logowanie się na konto użytkownika lub wylogowywanie się z niego albo 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 telefonie połączone z Androidem Auto nie korzystają z tego interfejsu.

Deklarowanie aktywności ustawień

Aktywność ustawień musisz zadeklarować 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>

Implementacja aktywności związanej z ustawieniami

Gdy użytkownik uruchomi aplikację, system operacyjny Android Automotive wykryje zadeklarowaną przez Ciebie aktywność ustawień i wyświetli element interfejsu, np. ikonę. Użytkownik może kliknąć lub wybrać tę opcję na wyświetlaczu samochodu, aby przejść do aktywności. System operacyjny Android Automotive wysyła działanie ACTION_APPLICATION_PREFERENCES, które informuje aplikację o konieczności uruchomienia aktywności ustawień.

W pozostałej części tej sekcji pokażemy, jak zastosować kod z przykładowej aplikacji Universal Android Music Player (UAMP) do implementacji aktywności ustawień w swojej aplikacji.

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. Wprowadź PreferenceFragmentCompat, aby wyświetlić aktywność związaną z ustawieniami. Aby dowiedzieć się więcej, zapoznaj się z plikami SettingsFragment.kt i SettingsActivity.kt w UAMP oraz z przewodnikiem po ustawieniach Androida.

Podczas wdrażania aktywności ustawień zastosuj te sprawdzone metody dotyczące korzystania z niektórych komponentów w bibliotece preferencji:

• W ramach aktywności dotyczącej ustawień nie należy tworzyć więcej niż 2 poziomów głębokości poniżej widoku głównego.
• Nie używaj znaku DropDownPreference. Zamiast tego użyj kolumny ListPreference.
• Elementy organizacyjne:
  • PreferenceScreen
    • Musi to być najwyższy poziom drzewa preferencji.
  • PreferenceCategory
    • Służy do grupowania obiektów Preference.
    • Uwzględnij title.
• Uwzględnij elementy key i title we wszystkich tych komponentach. Możesz też dodać element summary lub icon albo oba te elementy:
  • Preference
    • Dostosuj logikę w wywołaniu zwrotnym onPreferenceTreeClick() w ramach implementacji PreferenceFragmentCompat.
  • CheckBoxPreference
    • Zamiast summary może zawierać summaryOn lub summaryOff w przypadku tekstu warunkowego.
  • SwitchPreference
    • Zamiast summary może zawierać summaryOn lub summaryOff w przypadku tekstu warunkowego.
    • Może mieć wartość switchTextOn lub switchTextOff.
  • SeekBarPreference
    • Uwzględnij właściwości min, max i defaultValue.
  • EditTextPreference
    • Uwzględnij dialogTitle, positiveButtonText i negativeButtonText.
    • Może zawierać dialogMessage lub dialogLayoutResource.
  • com.example.android.uamp.automotive.lib.ListPreference
    • Pochodzi głównie z ListPreference.
    • Służy do wyświetlania listy obiektów Preference z jednym wyborem.
    • Musi zawierać tablicę entries i odpowiadające jej entryValues.
  • com.example.android.uamp.automotive.lib.MultiSelectListPreference
    • pochodzi głównie z MultiSelectListPreference
    • Służy do wyświetlania listy obiektów Preference z kilkoma opcjami do wyboru.
    • Musi zawierać tablicę entries i odpowiadające jej entryValues.

Dodawanie aktywności logowania

Jeśli aplikacja wymaga zalogowania się użytkownika, aby mógł z niej korzystać, możesz dodać optymalną dla pojazdu aktywność logowania, która obsługuje logowanie się i wylogowywanie z aplikacji. Możesz też dodać przepływy logowania i wylogowywania do aktywności ustawień, ale użyj dedykowanej aktywności logowania, jeśli aplikacji nie można używać, dopóki użytkownik się nie zaloguje. Pamiętaj, że ta aktywność jest wywoływana tylko przez aplikację działającą w systemie Android Automotive. Aplikacje na telefonie połączone z Androidem Auto nie korzystają z tej funkcji.

Wymagaj zalogowania się przy uruchamianiu aplikacji

Aby wymagać od użytkownika zalogowania się przed użyciem aplikacji, przeglądarka multimediów musi:

1. W metodzie onLoadChildren() usługi wyślij wynik null za pomocą metody sendResult().
2. Ustaw wartość parametru PlaybackStateCompat na STATE_ERROR za pomocą metody setState(). Informuje to system Android Automotive, że dopóki błąd nie zostanie naprawiony, nie można wykonać żadnych innych operacji.
3. Ustaw kod błędu PlaybackStateCompat sesji multimediów na ERROR_CODE_AUTHENTICATION_EXPIRED. Informuje system operacyjny Android Automotive, że użytkownik musi się uwierzytelnić.
4. Ustaw komunikat o błędzie PlaybackStateCompatsesji multimediów za pomocą metody setErrorMessage(). Ten komunikat o błędzie jest widoczny dla użytkownika, dlatego należy go zlokalizować zgodnie z jego ustawieniami regionalnymi.

5. Ustaw dodatkowe opcje PlaybackStateCompatsesji multimediów za pomocą metody setExtras(). Dodaj te 2 klucze:

   • PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_LABEL: ciąg znaków wyświetlany na przycisku, który uruchamia proces logowania. Ten ciąg tekstowy jest widoczny dla użytkownika, dlatego należy go zlokalizować zgodnie z jego bieżącymi ustawieniami języka.
   • PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_INTENT: PendingIntentprzekierowuje użytkownika do Twojej aktywności logowania, gdy użytkownik kliknie przycisk, do którego odwołuje się element PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_LABEL.

Ten fragment kodu pokazuje, jak aplikacja może wymagać od użytkownika zalogowania się przed jej użyciem:

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 uwierzytelnieniu użytkownika ustaw PlaybackStateCompatz powrotem na stan inny niż STATE_ERROR, a następnie przekieruj użytkownika z powrotem 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óre możesz wykorzystać, aby ułatwić użytkownikom logowanie się w aplikacji w samochodzie. Niektóre narzędzia, takie jak Uwierzytelnianie Firebase, zapewniają pełny zestaw narzędzi, który ułatwia tworzenie niestandardowych metod uwierzytelniania. Inne narzędzia korzystają z dotychczasowych danych logowania użytkownika lub innych technologii, aby ułatwić użytkownikom płynne logowanie.

Te narzędzia ułatwiają logowanie się użytkownikom, którzy wcześniej logowali się 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, wdrożenie jej w aplikacji na system Android Automotive, aby obsługiwać obecnych użytkowników logowania jednym dotknięciem.
• Logowanie w Google: jeśli na innych urządzeniach, np. w aplikacji na telefon, masz już zaimplementowane logowanie w Google, zaimplementuj logowanie w Google w aplikacji na system operacyjny Android Automotive, aby umożliwić korzystanie z tej funkcji użytkownikom.
• Autouzupełnianie z Google: jeśli użytkownicy korzystają z autouzupełniania z Google na innych urządzeniach z Androidem, ich dane logowania są zapisywane w Menedżerze haseł Google. Gdy użytkownicy logują się w aplikacji na system operacyjny Android Automotive, autouzupełnianie z Google sugeruje odpowiednie zapisane dane logowania. Korzystanie z autouzupełniania z Google wymaga zaangażowania w procesie tworzenia aplikacji. Deweloperzy aplikacji mogą jednak optymalizować je pod kątem lepszej jakości wyników. 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.

Korzystanie z usługi AccountManager

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

• Lepsze wrażenia użytkowników i łatwe zarządzanie kontami: użytkownicy mogą łatwo zarządzać wszystkimi swoimi kontami w menu kont w ustawieniach systemu, w tym logować się i wylogowywać.
• „Tryb gościa”: samochody to urządzenia wspólne, co oznacza, że producenci OEM mogą włączyć w nich „tryb gościa”, w którym nie można dodawać kont. To ograniczenie jest osiągane za pomocą atrybutu DISALLOW_MODIFY_ACCOUNTS w przypadku atrybutu AccountManager.

Uprawnienia

Jeśli chcesz poprosić użytkownika o przyznanie uprawnień, użyj tego samego procesu co w przypadku działania uwierzytelniania lub działania ustawień w diagramie przepływu działań pokazanym w poprzedniej sekcji.

Uruchamianie aplikacji hosta multimediów

Możesz utworzyć intencje, aby otworzyć aplikację hostu multimediów w Twojej aplikacji lub w treściach w niej. Na przykład:

• Aplikacja może wyświetlić powiadomienie z oczekującym zamiarem, który umożliwia użytkownikowi otwarcie aplikacji w celu odsłuchania nowego materiału.
• Aplikacja może obsługiwać precyzyjne linki i otwierać aplikację hostującą na najbardziej odpowiednim widoku.

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

Różne wersje aplikacji hostującej multimedia obsługują różne funkcje. Hosty wskazują obsługę różnych funkcji, podając filtry intencji dla tych działań:

• 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 intencyjne obsługuje gospodarz multimediów, oraz od konkretnego przypadku użycia, podczas tworzenia intencjonalnego działania, którego używasz do uruchamiania aplikacji gospodarza multimediów, możesz podać te dodatkowe informacje.

Na przykład w przypadku hosta obsługującego akcje MEDIA_TEMPLATE_V2 poniższy kod otwiera aplikację hosta multimediów, powoduje jej połączenie z MyMediaBrowserService, wyszukuje „Jazz”, a potem odtwarza pierwszy element z wyników wyszukiwania. W przypadku wszystkich innych hostów otworzy tylko aplikację hosta multimediów i wykona wyszukiwanie „Jazz”, a użytkownik będzie mógł wybrać element do odtworzenia spośród 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 ulepszyć działanie aplikacji multimedialnej na urządzeniach z systemem 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ą Quick Share.

Dodawanie filtrów intencji precyzyjnych linków

Aby poinformować system operacyjny, że aplikacja obsługuje precyzyjne linki, musi zawierać aktywności z odpowiednimi filtrami intencji. Wskazówki dotyczące formatu filtrów intencji używanych do precyzyjnych linków znajdziesz w sekcji Dodawanie filtrów intencji do 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 zawiera czynności związane z ustawieniami lub logowaniem, filtry intencji do obsługi precyzyjnych linków do ustawień i logowania należy zadeklarować w odpowiednich elementach <activity> pliku manifestu. Do 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 związanych z precyzyjnymi linkami

W artykule Czytanie danych z przychodzących intencji znajdziesz wskazówki dotyczące odczytywania intencji i reagowania na nią.

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

Interfejs użytkownika służący do przeglądania i odtwarzania jest wyświetlany przez aplikację goszczącą, dlatego aktywność służąca do obsługi precyzyjnych linków do odtwarzania i przeglądania nie powinna mieć własnego interfejsu.

Zamiast tego należy go używać głównie do tworzenia i używania intencji w celu uruchomienia aplikacji hostującej multimedia. W razie potrzeby może on też obsługiwać wszelkie dodatkowe zmiany stanu aplikacji, takie jak dodawanie elementów multimedialnych do kolejki. Ten fragment kodu pokazuje przykładową implementację aktywności trampoliny:

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

Czytanie wskazówek dotyczących hostowania multimediów

W zależności od aplikacji systemowej (w tym jej wersji) łączącej się z Twoją 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 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 multimedialnych w systemie operacyjnym Android Automotive są przekazywane za pomocą PlaybackStateCompatsesji multimediów. W przypadku wszystkich błędów ustaw odpowiedni kod błędu i komunikat o błędzie w elementach PlaybackStateCompat. W rezultacie w interfejsie pojawi się Toast.

Jeśli wystąpi błąd, ale odtwarzanie może być kontynuowane, wygeneruj niekrytyczny błąd. 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 zasugerować użytkownikowi zalogowanie się bez przerywania odtwarzania bieżącego elementu multimedialnego.

Jeśli wygenerujesz błąd niekrytyczny, zachowaj pozostałą część pliku PlaybackStateCompat w postaci oryginalnej (z wyjątkiem kodu błędu i komunikatu o błędzie). Dzięki temu odtwarzanie bieżącego elementu multimedialnego będzie kontynuowane, gdy użytkownik zdecyduje się zalogować.

Gdy odtwarzanie nie jest możliwe, na przykład gdy nie ma połączenia z internetem lub treści offline, ustaw stan PlaybackStateCompat na STATE_ERROR.

Podczas kolejnych aktualizacji PlaybackStateCompat usuwaj wszystkie 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 jakimś momencie nie możesz załadować drzewa przeglądania (na przykład, gdy wymagasz uwierzytelniania, a użytkownik nie jest zalogowany), prześlij puste drzewo przeglądania. Aby to zasygnalizować, zwracaj wartość null z parametru onLoadChildren() dla węzła źródeł multimediów. W takim przypadku system wyświetla pełny ekran błędu z komunikatem o błędzie ustawionym w PlaybackStateCompat.

Błędy, które można naprawić

Jeśli błąd można naprawić, dodatkowo w polu PlaybackStateCompat ustaw te 2 opcje dodatkowe:

• PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_LABEL: etykieta przycisku, który należy kliknąć, aby rozwiązać błąd. Ten ciąg znaków jest widoczny dla użytkownika, dlatego należy go zlokalizować zgodnie z jego bieżącymi ustawieniami regionalnymi.
• PLAYBACK_STATE_EXTRAS_KEY_ERROR_RESOLUTION_ACTION_INTENT: PendingIntent, który przycisk uruchamia w celu rozwiązania błędu, na przykład uruchomienie czynności logowania.

Błędy wymagające działania wyświetlają się jako 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 poziomy produktu: na przykład wersja bezpłatna i premium lub zalogowana i niezalogowana.
• Różne stany jazdy: na przykład parkowanie i jazda.
• Różne stany połączenia: na przykład online lub offline.

Inne rzeczy, które warto wziąć pod uwagę

Podczas tworzenia aplikacji na Androida Automotive weź pod uwagę te kwestie:

Treści offline

W razie potrzeby wdrożyć obsługę odtwarzania offline. Samochody z systemem operacyjnym Android Automotive powinny mieć własne połączenie z internetem, co oznacza, że pakiet danych jest uwzględniony w kosztach pojazdu lub płatny przez użytkownika. Samochody powinny jednak mieć bardziej zmienne połączenie niż urządzenia mobilne.

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

• Najlepszym momentem na pobranie treści jest czas korzystania z aplikacji.
• Nie zakładaj, że sieć Wi-Fi jest dostępna. Samochód może nigdy nie znaleźć się w zasięgu sieci Wi-Fi, a producent OEM może wyłączyć Wi-Fi na rzecz sieci komórkowej.
• Chociaż można inteligentnie przechowywać w pamięci podręcznej treści, których oczekują użytkownicy, zalecamy umożliwienie użytkownikowi zmiany tego zachowania za pomocą aktywności w ustawieniach.
• Pamięć na dysku w samochodach jest różna, dlatego daj użytkownikom możliwość usuwania treści offline, np. za pomocą opcji w aktywności ustawień.

Obsługa WebView

Interfejsy WebView są obsługiwane w systemie operacyjnym Android Automotive, ale są dozwolone tylko w przypadku ustawień i działań związanych z logowaniem. Aktywności, które korzystają z WebView, muszą mieć opcję „zamknij” lub „wstecz” poza WebView.

Oto kilka przykładów akceptowanych zastosowań WebView:

• wyświetlanie polityki prywatności, warunków korzystania z usługi lub innych linków związanych z prawem w ramach aktywności ustawień.
• Proces logowania się w witrynie.

Podczas korzystania z WebView możesz włączyć JavaScript.

Zabezpieczanie WebView

Podejmij wszelkie możliwe środki ostrożności, aby komponent WebView nie był punktem wejścia do internetu. Poniżej znajdziesz fragment kodu, który pokazuje, jak zablokować WebView na adres URL użyty w wywołaniu loadUrl() i zapobiec przekierowaniom. Zalecamy stosowanie takich zabezpieczeń, gdy jest to możliwe, np. podczas wyświetlania linków związanych z prawodnictwem.

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 Android Application Package Kit (APK) dla systemu operacyjnego Android Automotive, możesz ponownie użyć nazwy pakietu z aplikacji mobilnej lub utworzyć nową nazwę pakietu. Jeśli używasz innej nazwy pakietu, Twoja aplikacja ma 2 osobne strony w Google Play. Jeśli użyjesz obecnej nazwy pakietu, Twoja aplikacja będzie mieć jedną stronę na obu platformach.

Jest to przede wszystkim decyzja biznesowa. Jeśli na przykład jeden zespół pracuje nad aplikacją mobilną, a inny nad aplikacją na system Android Automotive, warto użyć oddzielnych nazw pakietów i zezwolić każdemu zespołowi na zarządzanie własną stroną w Sklepie Play. Nie ma dużej różnicy w nakładzie pracy technicznej wymaganej do zastosowania obu tych metod.

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

Najczęstsze pytania

W następnych sekcjach znajdziesz odpowiedzi na niektóre z najczęstszych pytań dotyczących systemu Android Automotive.

Sprzęt

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

W przypadku aplikacji kierowanych na Androida 10 (poziom API 29) lub nowszego zapoznaj się z dokumentacją dotyczącą udostępniania danych wejściowych audio. Nie jest to możliwe przed poziomem interfejsu API 29.

Do których interfejsów API samochodów możemy uzyskać dostęp i w jaki sposób?

Możesz korzystać tylko z interfejsów API udostępnionych przez producenta OEM. Opracowujemy procesy, aby ujednolicić sposób uzyskiwania dostępu do tych interfejsów API.

Aplikacje mogą uzyskiwać dostęp do interfejsów API samochodów za pomocą SetProperty() i GetProperty() w CarPropertyManager. Aby zobaczyć listę wszystkich dostępnych usług, zapoznaj się z kodem źródłowym lub dokumentacją referencyjną. Jeśli właściwość jest oznaczona symbolem @SystemApi, jest ograniczona do wstępnie załadowanych aplikacji systemowych.

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

Zapoznaj się ze szczegółami dotyczącymi kodeka audio w dokumentacji CDD na Androida.

Czy obsługiwany jest DRM Widevine?

Tak. Obsługiwany jest DRM Widevine.

Programowanie i testowanie

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

Nie mamy żadnych konkretnych wytycznych dotyczących używania zewnętrznych pakietów SDK i bibliotek. Jeśli zdecydujesz się używać pakietów SDK i bibliotek innych firm, nadal będziesz odpowiadać za zgodność z wymaganiami dotyczącymi jakości aplikacji samochodowych.

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

Jedynym dozwolonym przypadkiem użycia usługi na pierwszym planie jest pobieranie treści do użytku offline. Jeśli masz inny przypadek użycia usługi na pierwszym planie, którego chcesz się dowiedzieć, 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 Rozpowszechnianie aplikacji na samochody.

Dodatkowe materiały

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

Próbki

• Uniwersalny odtwarzacz muzyki na Androida

Przewodniki

• Projektowanie pod kątem jazdy
• Korzystanie z aplikacji testowej sterownika multimediów
• Powiadomienia w systemie operacyjnym Android Automotive
• Jakość aplikacji samochodowych na Androida

Blogi

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

Filmy

• Jak tworzyć aplikacje multimedialne do samochodów (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 napotkasz problem, możesz go zgłosić za pomocą Google Issue Tracker. Pamiętaj, aby podać wszystkie wymagane informacje w szablonie problemu.

Tworzenie nowego zgłoszenia

Zanim zgłosisz nowy problem, sprawdź, czy nie został już zgłoszony na liście problemów. Możesz subskrybować problemy i głosować na nie, klikając gwiazdkę obok problemu w śledzącym. Więcej informacji znajdziesz w artykule Subskrybowanie problemu.