Aplikacje multimedialne korzystające z szablonów biblioteki aplikacji do samochodu mogą dostosowywać sposób przeglądania i odtwarzania multimediów, zapewniając jednocześnie optymalizację pod kątem ekranów samochodowych i minimalizując rozpraszanie uwagi podczas jazdy.
W tym przewodniku założyliśmy, że masz już aplikację do odtwarzania multimediów, która odtwarza dźwięk na telefonie, i że jest ona zgodna z architekturą aplikacji multimedialnych na Androida. Biblioteka aplikacji do samochodu umożliwia zastąpienie interfejsu w aplikacji szablonami zamiast tych, które zostały utworzone przy użyciu struktury danych Tworzenie aplikacji multimedialnych do samochodów.MediaBrowser Nadal musisz podać MediaSession
dla elementów sterujących odtwarzaniem oraz MediaBrowserService lub MediaLibraryService,
które są używane do rekomendacji i innych inteligentnych funkcji.
Konfigurowanie manifestu aplikacji
Oprócz czynności opisanych w artykule Korzystanie z biblioteki aplikacji Androida do samochodu aplikacje do multimediów oparte na szablonach muszą spełniać te wymagania:
Deklarowanie obsługi kategorii w pliku manifestu
Aplikacja musi zadeklarować androidx.car.app.category.MEDIA
kategorię aplikacji samochodowej w filtrze intencjiCarAppService.
<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 MediaPlaybackTemplate są obsługiwane tylko w interfejsie CAL API 8 i nowszym. Upewnij się, że minimalny Car App API level jest ustawiony na 8.
<application ...>
...
<meta-data
android:name="androidx.car.app.minCarApiLevel"
android:value="8"/>
...
</application>
Podaj ikonę atrybucji
W przypadku aplikacji do multimediów utworzonych przy użyciu biblioteki Car App Library dodaj ikonę atrybucji.
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ę szablonu do automotive_app_desc.xml w plikach xml
zasobów. 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ę multimedialną z obsługą biblioteki aplikacji samochodowych możesz rozpowszechniać w systemie operacyjnym Android Automotive na 2 sposoby: jako jeden plik APK lub jako 2 osobne pliki APK. Jeśli rozpowszechniasz jeden plik APK, będzie on obsługiwać pojazdy z włączonym systemem operacyjnym Android Automotive z hostem biblioteki aplikacji do samochodu i w razie potrzeby przełączać się na aplikację MediaBrowserService lub MediaLibraryService, nawet w przypadku starszych wersji Androida (Android 10–13). Jeśli zdecydujesz się rozpowszechniać 2 osobne pakiety APK, możesz aktualizować nowe dodatki do wersji biblioteki aplikacji na samochody, nie martwiąc się o wpływ na wersję MediaBrowserService lub MediaLibraryService aplikacji.
Dystrybucja pojedynczego pakietu APK
Podczas rozpowszechniania pojedynczego pliku APK dla biblioteki aplikacji samochodowych oraz wersji aplikacji MediaBrowserService lub MediaLibraryService konieczne jest ustawienie wartości 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ź aplikację CarAppActivity, którą można uruchomić (lub aktywność trampolinową). W pliku manifestu musisz ustawić aktywność na android:enabled="false". Następnie dodaj do deklaracji MediaBrowserService tag metadanych wskazujący komponent CarAppActivity jako zamiennik. Oto 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 MediaBrowserServicelub MediaLibraryService powinien mieć włączony wyższy kod wersji i wartość minSdk kierowaną na Androida 14 (34).
Dystrybucja za pomocą 2 plików APK
Aby rozpowszechniać 2 osobne pliki APK, z których jeden korzysta z biblioteki aplikacji na samochody, a drugi z MediaBrowserService lub MediaLibraryService, wykonaj te czynności, aby mieć pewność, że prawidłowo kierujesz reklamy na odpowiednie funkcje pojazdu.
Podczas tworzenia osobnego pliku APK dla wersji aplikacji korzystającej z biblioteki aplikacji na samochody musisz ustawić wartość android.software.car.templates_host.media na android:required=true. Dzięki temu aplikacja będzie rozpowszechniana tylko w wersjach systemu operacyjnego Android Automotive certyfikowanych pod kątem obsługi 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 w przypadku aktywności biblioteki aplikacji do samochodu, którą można uruchomić.
Play Distribution
Plik APK, który korzysta z biblioteki aplikacji do samochodu, powinien być rozpowszechniany na dedykowanej ścieżce Automotive OS.
Obsługa komend głosowych
Włącz obsługę głosową w aplikacji, aby użytkownicy mogli wykonywać typowe działania bez użycia rąk.
Szczegółowe instrukcje wdrażania znajdziesz w artykule obsługa działań głosowych w przypadku multimediów. W przypadku aplikacji do multimediów opartej na szablonie, jeśli otrzymasz polecenie głosowe, nie musisz aktualizować MediaBrowserService ani MediaLibraryService z wynikami wyszukiwania. Zamiast tego rozważ dodanie działania w szablonie odtwarzania multimediów, aby umożliwić użytkownikowi znajdowanie większej liczby treści na podstawie odtwarzania lub zapytania. Obsługa poleceń głosowych jest wymagana, aby spełnić wytyczne dotyczące VC-1 jakości.
Tworzenie szablonu odtwarzania
MediaPlaybackTemplate wyświetla informacje o odtwarzaniu multimediów w aplikacji do multimediów z biblioteki aplikacji samochodowych. Ten szablon umożliwia ustawienie nagłówka z tytułem i dostosowywanymi działaniami, a informacje o multimediach i elementy sterujące odtwarzaniem są wypełniane przez hosta na podstawie stanu MediaSession aplikacji.
Ilustracja 1.
MediaPlaybackTemplate z działaniem w nagłówku, które otwiera kolejkę
u góry.
Ten przykład kodu 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. W przeciwnym razie, gdy do hosta zostanie wysłany element MediaPlaybackTemplate, 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ędne do udostępniania informacji o odtwarzaniu multimediów i elementów sterujących w Androidzie Auto. Jest to również ważne, aby host mógł tworzyć powiadomienia dotyczące konkretnych mediów.
W przypadku aplikacji korzystających z biblioteki Media3, które używają PlatformToken zamiast standardowego MediaSessionCompat.Token, musisz w MediaLibrarySession.Callback zaimplementować niestandardowy SessionCommand, który zwraca podstawowy token platformy sesji: session.platformToken. W CarAppService wyślij do sesji to polecenie niestandardowe. Po otrzymaniu tokena platformy przekonwertuj go za pomocą funkcji MediaSessionCompat.Token.fromToken(platformToken) i przekaż ten token zgodności do biblioteki aplikacji do samochodu w funkcji .registerMediaPlaybackToken().
Porządkowanie multimediów za pomocą szablonów
Do porządkowania multimediów, takich jak utwory lub albumy, zalecamy używanie elementu SectionedItemTemplate, który umożliwia łączenie elementów GridSection i RowSection w celu tworzenia układów zawierających listy obrazów i elementów tekstowych.
Ilustracja 2. A
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 elementu SectionedItemTemplate w ramach elementu 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
Car App Library API w wersji 1.9 wprowadza dostosowane komponenty, które zapewniają unikalne możliwości przeglądania, takie jak elementy, paski postępu, skrócone elementy, interaktywny i rozwinięty nagłówek, sekcje wyróżnione i banery.
Ilustracja 3. A
SectionedItemTemplate zawierający Chips, Condensed Items, Interactive Header, Grid Items i Minimized Control Panel
Ilustracja 4. Dwa ekrany przeglądania multimediów z ikonami Expanded Header, Spotlight Sections i Progress Bars
Więcej informacji o projektowaniu interfejsu użytkownika aplikacji multimedialnej za pomocą tych szablonów znajdziesz w sekcji Aplikacje multimedialne.
Przechodzenie do elementów sterujących odtwarzaniem
Podczas przeglądania multimediów użytkownik musi mieć możliwość szybkiego przejścia 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 działania, który przeniesie Cię na ekran odtwarzania multimediów. Użyj standardowego działania Action.MEDIA_PLAYBACK biblioteki aplikacji samochodowych. Aplikacja do multimediów wyświetli tę czynność jako zminimalizowany panel sterowania, który jest wymagany do spełnienia wymagania 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 osiągnąć za pomocą działania w nagłówku.
Obsługa intencji odtwarzania multimediów w systemie
Jest to wymagane, aby kierować użytkownika do MediaPlaybackTemplate, gdy aplikacja jest uruchamiana z poziomu systemowego odtwarzacza multimediów, np. karty multimediów. Wymagamy, aby aplikacje multimedialne obsługiwały to Intent Action, aby zapewnić użytkownikom bezproblemowe działanie.
Dodaj działanie androidx.car.app.media.action.SHOW_MEDIA_PLAYBACK do filtra intencji komponentu biblioteki aplikacji na samochody (CarAppActivity lub trampoliny Activity).
Upewnij się, że Twoja aktywność używa launchMode singleTask lub singleTop, aby wywołać 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 metodę onNewIntent(), aby przeanalizować przychodzący zamiar.
Jeśli działanie przychodzącego zamiaru pasuje do SHOW_MEDIA_PLAYBACK, przenieś użytkownika na ekran Odtwarzane.
@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 korzystasz z aktywności na trampolinie, sprawdź działanie intencji w onCreate(). Przekaż tę czynność 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();
}
}