Tworzenie aplikacji multimedialnej na podstawie szablonu

Aplikacje do multimediów oparte na szablonach są w wersji beta
Obecnie każdy może publikować oparte na szablonach aplikacje do multimediów na ścieżkach testów wewnętrznych i ścieżkach testu zamkniętego w Sklepie Google Play. Publikowanie na ścieżkach otwartych i produkcyjnych będzie możliwe w późniejszym terminie.

Aplikacje do multimediów korzystające z szablonów biblioteki aplikacji do samochodu mogą dostosowywać przeglądanie i odtwarzanie multimediów, zapewniając jednocześnie optymalizację pod kątem ekranów samochodowych i minimalizując rozpraszanie uwagi podczas jazdy.

W tym przewodniku zakładamy, że masz już aplikację do multimediów, która odtwarza dźwięk na telefonie, i że jest ona zgodna z architekturą aplikacji do multimediów na Androida. Biblioteka aplikacji do samochodu umożliwia zastąpienie wrażeń użytkownika aplikacji szablonami zamiast tych utworzonych za pomocą struktury danych Tworzenie aplikacji do multimediów do samochodu MediaBrowser. Nadal musisz podać MediaSession na potrzeby elementów sterujących odtwarzaniem oraz MediaBrowserService lub MediaLibraryService, które są używane do rekomendacji i innych inteligentnych funkcji.

Funkcje parkowania i jazdy są teraz dostępne w wersji beta
Aplikacje do multimediów oparte na szablonach mogą teraz dodawać funkcje park-to-drive w systemie operacyjnym Android Automotive. Dzięki temu aplikacja może dodawać adaptacyjne działania natywne podczas postoju i płynnie przechodzić do odtwarzania multimediów na podstawie szablonu, gdy samochód jest w ruchu.

Konfigurowanie pliku manifestu aplikacji

Oprócz czynności opisanych w artykule Korzystanie z biblioteki aplikacji Android do samochodu w przypadku aplikacji do multimediów opartych na szablonach wymagane są te elementy:

Deklarowanie obsługi kategorii w pliku manifestu

Aplikacja musi deklarować androidx.car.app.category.MEDIA kategorię aplikacji samochodowej w filtrze intencji elementu CarAppService.

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

Aby uzyskać dostęp do MediaPlaybackTemplate, aplikacja musi też zadeklarować uprawnienie androidx.car.app.MEDIA_TEMPLATES w pliku manifestu:

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

Ustawianie minimalnego poziomu interfejsu API aplikacji do samochodu

Aplikacje do multimediów korzystające z szablonu MediaPlaybackTemplate są obsługiwane tylko w interfejsie CAL API 8 lub nowszym. Upewnij się, że minimalny poziom Car App API level jest ustawiony na 8.

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

Podawanie ikony atrybucji

Pamiętaj, aby dodać ikonę atrybucji w przypadku aplikacji do multimediów utworzonych przy użyciu biblioteki aplikacji do samochodu.

Deklarowanie obsługi Androida Auto

Upewnij się, że w pliku manifestu aplikacji znajdują się te elementy:

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

Następnie dodaj deklarację template do automotive_app_desc.xml w zasobach XML. Powinien on wyglądać tak:

<automotiveApp xmlns:android="http://schemas.android.com/apk/res/android">
 <uses name="media"/>
 <uses name="template"/>
</automotiveApp>

Deklarowanie obsługi systemu operacyjnego Android Automotive

Aplikację do multimediów z biblioteką aplikacji samochodowych możesz rozpowszechniać na system operacyjny Android Automotive na 2 sposoby: jako pojedynczy plik APK lub jako 2 osobne pliki APK. Jeśli rozpowszechniasz jeden plik APK, będzie on obsługiwać pojazdy z systemem operacyjnym Android Automotive z hostem biblioteki aplikacji samochodowych, a w przeciwnym razie będzie korzystać z aplikacji MediaBrowserService lub MediaLibraryService, nawet w przypadku starszych wersji Androida (Android 10–13). Jeśli zdecydujesz się na dystrybucję 2 oddzielnych pakietów APK, możesz aktualizować nowe dodatki do wersji Biblioteki aplikacji samochodowych bez obaw, że wpłynie to na wersję aplikacji na MediaBrowserService lub MediaLibraryService.

Rozpowszechnianie jednego pakietu APK

Jeśli rozpowszechniasz pojedynczy plik APK dla Biblioteki aplikacji samochodowych i wersji aplikacji na MediaBrowserService lub MediaLibraryService, musisz ustawić android.software.car.templates_host.media na android:required="false".

<uses-feature android:name="android.software.car.templates_host.media" android:required="false"/>

Następnie postępuj zgodnie z wytycznymi dotyczącymi biblioteki aplikacji samochodowych na AAOS i wprowadź aktywność uruchamianą CarAppActivity (lub aktywność trampoliny). W pliku manifestu musisz ustawić aktywność na android:enabled="false". Następnie dodaj tag metadanych do deklaracji MediaBrowserService, wskazując komponent CarAppActivity jako zamiennik. Zobacz ten przykładowy plik manifestu:

<service android:name=".media.MyMediaService"
    android:exported="true"
    android:label="@string/app_name">
    <intent-filter>
        <action android:name="androidx.media3.session.MediaLibraryService"/>
    </intent-filter>

    <!-- Link to Car App Library Activity -->
    <meta-data
        android:name="androidx.car.app.media.CalMediaActivityComponent"
        android:value="com.example.mediaapp.LaunchableTrampoline"/>
</service>

<activity
    android:name=".LaunchableTrampoline"
    android:exported="true"
    android:theme="@android:style/Theme.DeviceDefault.NoActionBar"
    android:launchMode="singleTask"
    android:label="@string/app_name_cal"
    android:enabled="false"> <!-- Set to false -->

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

    <intent-filter>
        <action android:name="android.intent.action.MAIN"/>
        <action android:name="androidx.car.app.media.action.SHOW_MEDIA_PLAYBACK"/>
        <category android:name="android.intent.category.LAUNCHER"/>
    </intent-filter>
</activity>

Dystrybucja w Google Play

Plik APK z biblioteką aplikacji do samochodu i MediaBrowserService lub MediaLibraryService powinien być włączony z wyższym kodem wersji i minSdk kierowanym na Androida 14 (34).

Dystrybucja z użyciem 2 pakietów APK

Aby rozpowszechniać 2 osobne pliki APK, z których jeden korzysta z biblioteki aplikacji samochodowych, a drugi z MediaBrowserService lub MediaLibraryService, wykonaj te czynności, aby mieć pewność, że odpowiednie funkcje pojazdu są prawidłowo kierowane.

Podczas tworzenia osobnego pliku APK dla wersji aplikacji z biblioteką aplikacji samochodowych musisz ustawić android.software.car.templates_host.media na android:required=true. Dzięki temu aplikacja będzie rozpowszechniana tylko w kompilacjach systemu operacyjnego Android Automotive, które są certyfikowane i obsługują hosta biblioteki aplikacji samochodowych.

<uses-feature android:name="android.software.car.templates_host.media" android:required="true"/>

Oprócz użycia android.software.car.templates_host.media i ustawienia go na android:required=true wykonaj te czynności, aby włączyć system operacyjny Android Automotive dla aktywności Biblioteki aplikacji do samochodu, którą można uruchomić.

Dystrybucja w Google Play

Plik APK, który korzysta z biblioteki aplikacji na samochód, powinien być rozpowszechniany na ścieżce przeznaczonej dla systemu operacyjnego Automotive OS.

obsługiwać komendy głosowe,

Włącz obsługę głosową w aplikacji, aby umożliwić użytkownikom wykonywanie typowych działań bez użycia rąk. Więcej informacji o implementacji znajdziesz w artykule o obsłudze komend głosowych w przypadku multimediów. W przypadku aplikacji do multimediów opartej na szablonie, gdy otrzymasz polecenie głosowe, nie musisz aktualizować MediaBrowserService ani MediaLibraryService o wyniki wyszukiwania. Zamiast tego rozważ dodanie działania w szablonie odtwarzania multimediów, aby umożliwić użytkownikowi znalezienie większej ilości treści na podstawie tego odtworzenia lub zapytania. Obsługa poleceń głosowych jest wymagana, aby spełnić wskazówki dotyczące jakości VC-1.

Tworzenie szablonu odtwarzania

MediaPlaybackTemplate wyświetla informacje o odtwarzaniu multimediów w aplikacji do multimediów w bibliotece aplikacji samochodowych. Ten szablon umożliwia ustawienie nagłówka z tytułem i działaniami, które można dostosować, podczas gdy informacje o multimediach i elementy sterujące odtwarzaniem są wypełniane przez hosta na podstawie stanu MediaSession aplikacji.

Odtwarzacz muzyki wyświetla utwór „Sounds of Spring” wykonawcy Summer Fielding z kwadratowym zdjęciem kobiety grającej na gitarze.

Rysunek 1. MediaPlaybackTemplate z działaniem nagłówka, które otwiera kolejkę u góry.

Ten przykładowy kod pokazuje, jak utworzyć przykładowy szablon odtwarzania, który ustawia działanie nagłówka umożliwiające użytkownikowi przejście do ekranu z kolejką utworów.

val playbackTemplate = MediaPlaybackTemplate.Builder()
      .setHeader(
        Header.Builder()
          .setStartHeaderAction(Action.BACK)
          .addEndHeaderAction(
                Action.Builder()
                  .setTitle(model.context.getString(R.string.queue_button_title))
                  .setIcon(
                    CarIcon.Builder(
                        IconCompat.createWithResource(
                          model.context,
                          R.drawable.gs_queue_music_vd_theme_24,
                        ))
                      .build())
                  .setOnClickListener(showQueueScreen())
                  .build())
          .setTitle(model.context.getString(R.string.media_playback_view_title))
          .build())
      .build()

Gdy używasz MediaPlaybackTemplate, zarejestruj token MediaSession za pomocą MediaPlaybackManager w CarAppService. Jeśli tego nie zrobisz, podczas wysyłania MediaPlaybackTemplate do hosta pojawi się błąd.

import androidx.car.app.media.MediaPlaybackManager
…

override fun onCreateSession(sessionInfo: SessionInfo): Session {
    return object : Session() {
        …

        init {
          lifecycle.addObserver(
            LifecycleEventObserver { _, event ->
              if (event == ON_CREATE) {
                val token = ... // MediaSessionCompat.Token
                (carContext.getCarService(CarContext.MEDIA_PLAYBACK_SERVICE) as MediaPlaybackManager)
                  .registerMediaPlaybackToken(token)
              }
              ...
            }
          )
        }
    }
}

.registerMediaPlaybackToken jest niezbędna do wyświetlania informacji o odtwarzaniu multimediów i elementów sterujących w Androidzie Auto. Jest to też ważne, aby host mógł tworzyć powiadomienia dotyczące multimediów.

W przypadku aplikacji korzystających z biblioteki Media3, które używają PlatformToken zamiast standardowego MediaSessionCompat.Token, musisz zaimplementować niestandardowy SessionCommand w MediaLibrarySession.Callback, który zwraca podstawowy token platformy sesji: session.platformToken. W CarAppService wyślij to polecenie niestandardowe do sesji. Gdy otrzymasz token platformy, przekonwertuj go za pomocą MediaSessionCompat.Token.fromToken(platformToken) i przekaż ten token zgodności do biblioteki aplikacji do samochodu w .registerMediaPlaybackToken().

Porządkowanie multimediów za pomocą szablonów

Aby uporządkować multimedia do przeglądania, takie jak utwory lub albumy, zalecamy użycie SectionedItemTemplate, który umożliwia jednoczesne korzystanie z GridSection i RowSection do tworzenia układów łączących listy obrazów i elementów tekstowych.

Interfejs aplikacji muzycznej wyświetla ostatnio odtwarzane utwory i albumy, w tym 2 pionowe rzędy i 3 poziome okładki albumów.

Rysunek 2. SectionedItemTemplate zawierający RowSection, po którym następuje GridSection

Używanie szablonu SectionedItemTemplate w szablonie TabTemplate

Wygodnym sposobem kategoryzowania multimediów w aplikacji jest użycie SectionedItemTemplate w TabTemplate.

val template =
      SectionedItemTemplate.Builder()...build();
val tabTemplate =
      TabTemplate.Builder(tabCallback)
          .setTabContents(TabContents.Builder(template).build)
          .setHeaderAction(Action.APP_ICON)
          …
          .build();

Komponenty i funkcje biblioteki aplikacji samochodowych w wersji 1.9

Interfejs Car App Library API w wersji 1.9 wprowadza dostosowane komponenty, które zapewniają unikalne możliwości przeglądania, takie jak elementy typu chip, paski postępu, elementy skondensowane, interaktywny i rozwinięty nagłówek, sekcje wyróżnione i banery.

Interfejs aplikacji muzycznej wyświetla ostatnio odtwarzane utwory i albumy, w tym 2 pionowe rzędy i 3 poziome okładki albumów.

Rysunek 3. SectionedItemTemplate zawierający Chips, Condensed Items, Interactive Header, Grid Items i Minimized Control Panel

Interfejs aplikacji muzycznej wyświetla ostatnio odtwarzane utwory i albumy, w tym 2 pionowe rzędy i 3 poziome okładki albumów.

Ilustracja 4. 2 ekrany przeglądania multimediów z Expanded Header, Spotlight Sections i Progress Bars

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

Podczas przeglądania multimediów ważne jest, aby użytkownik mógł szybko przejść do MediaPlaybackTemplate przy minimalnym rozproszeniu uwagi.Aby spełnić wymagania dotyczące jakości MFT-1, aplikacja musi umożliwiać dostęp do MediaPlaybackTemplate ze wszystkich ekranów przeglądania multimediów.

Jeśli używasz SectionedItemTemplate, możesz to zrobić, dodając przycisk polecenia, który przekieruje Cię do ekranu odtwarzania multimediów. Użyj standardowego działania Action.MEDIA_PLAYBACK biblioteki aplikacji do samochodu. Aplikacja do multimediów wyświetli to działanie jako Zminimalizowany panel sterowania, co jest wymagane do spełnienia wymogu jakości MFT-1, jeśli używasz interfejsu Car App Library API w wersji 1.9 lub nowszej. W przypadku innych szablonów można to zrobić za pomocą działania w nagłówku.

Obsługa intencji odtwarzania multimediów systemowych

Gdy aplikacja jest uruchamiana z systemowej powierzchni odtwarzania multimediów, np. karty multimediów, użytkownik musi zostać przekierowany do MediaPlaybackTemplate. Wymagamy, aby aplikacje multimedialne obsługiwały to zdarzenie Intent Action, aby zapewnić użytkownikom płynne działanie.

Dodaj działanie androidx.car.app.media.action.SHOW_MEDIA_PLAYBACK do filtra intencji komponentu biblioteki aplikacji samochodowych (CarAppActivity lub trampoline Activity).

Upewnij się, że aktywność używa launchMode o wartości singleTask lub singleTop, aby wywoływana była metoda onNewIntent().

<activity
    android:name=".LaunchableTrampoline"
    android:exported="true"
    android:theme="@android:style/Theme.DeviceDefault.NoActionBar"
    android:launchMode="singleTask"
    android:label="@string/app_name_cal"
    android:enabled="false">

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

    <intent-filter>
        <action android:name="android.intent.action.MAIN"/>
        <action android:name="androidx.car.app.media.action.SHOW_MEDIA_PLAYBACK"/>
        <category android:name="android.intent.category.LAUNCHER"/>
    </intent-filter>
</activity>

W klasie Session zastąp onNewIntent(), aby przeanalizować przychodzącą intencję. Jeśli działanie przychodzącej intencji pasuje do SHOW_MEDIA_PLAYBACK, przekieruj użytkownika do ekranu Co jest grane.

@Override
public void onNewIntent(@NonNull Intent intent) {
    super.onNewIntent(intent);
    if (SHOW_MEDIA_PLAYBACK.equals(intent.getAction())) {
        ScreenManager screenManager = getCarContext().getCarService(ScreenManager.class);
        // Avoid redundant navigation if already on the playing screen
        if (screenManager.getTop() instanceof MyMediaPlayScreen) {
            return;
        }
        screenManager.push(MyMediaPlayScreen.createScreenFromPlaying(
                getCarContext(), mMediaSessionController));
    }
}

Jeśli używasz aktywności trampolinowej, sprawdź działanie intencji w onCreate(). Przekaż to działanie do intencji tworzenia CarAppActivity przed wywołaniem finish().

public class LaunchableTrampoline extends AppCompatActivity {
    private static final String SHOW_MEDIA_PLAYBACK = "androidx.car.app.media.action.SHOW_MEDIA_PLAYBACK";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Intent receivedIntent = getIntent();
        String action;

        if (SHOW_MEDIA_PLAYBACK.equals(receivedIntent.getAction())) {
            action = SHOW_MEDIA_PLAYBACK;
        } else {
            action = Intent.ACTION_MAIN;
        }

        Intent intent = new Intent(action);
        intent.setClassName(getPackageName(), "androidx.car.app.activity.CarAppActivity");
        startActivity(intent);
        finish();
    }
}