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.
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.
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.
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.
Rysunek 3. SectionedItemTemplate zawierający Chips, Condensed Items, Interactive Header, Grid Items i Minimized Control Panel
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.
Przechodzenie do elementów sterujących odtwarzaniem
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();
}
}