Zestaw narzędzi interfejsu Leanback zawiera elementy sterujące odtwarzaniem użytkowników. W przypadku aplikacji wideo elementy sterujące transportem obsługują przewijanie wideo. za pomocą elementów sterujących do przodu i do tyłu. Podczas przewijania wyświetlacza widać miniatury ułatwiające poruszanie się po filmie.
Biblioteka zawiera klasy abstrakcyjne, a także gotowe, gotowe do użycia implementacje. które dają deweloperom bardziej szczegółową kontrolę. Korzystanie z gotowego interfejsu możesz szybko stworzyć aplikację z wieloma funkcjami bez konieczności kodowania. Jeśli potrzebujesz większych możliwości dostosowywania, możesz rozszerzyć
Elementy sterujące i odtwarzacz
Zestaw narzędzi interfejsu Leanback oddziela interfejs transportowy interfejsu użytkownika od odtwarzacz, w którym można odtworzyć film. Składa się to z 2 elementów: fragment obsługi odtwarzania do wyświetlania elementów sterujących transportem (oraz opcjonalnie wideo) i adapter odtwarzacza do jego umieszczenia.
Fragment odtwarzania
Aktywność w interfejsie aplikacji powinna wykorzystywać
PlaybackSupportFragment
lub
VideoSupportFragment
Oba zawierają elementy sterujące przenoszeniem Leanback:
- W razie potrzeby
PlaybackSupportFragment
animuje elementy sterujące transportu, aby je ukryć lub wyświetlić. - Rozszerzenie
VideoSupportFragment
rozszerza się oPlaybackSupportFragment
i zawiera elementSurfaceView
umożliwiający renderowanie filmu.
Możesz dostosować tag
ObjectAdapter
aby ulepszyć interfejs. Na przykład użyj wartości
setAdapter()
dodaj „podobne filmy wideo”, .
PlayerAdapter
PlayerAdapter
to klasa abstrakcyjna, która
pozwala sterować odtwarzaczem. Deweloperzy mogą wybrać
gotową implementację MediaPlayerAdapter
lub wpisz
z własną implementacją tej klasy.
Sklejanie elementów
Musisz użyć „kontrolnego kleju” do połączenia fragmentu odtwarzanego do odtwarzacza. Leanback biblioteka udostępnia dwa rodzaje kleju:
PlaybackBannerControlGlue
remisuje elementy sterujące do przenoszenia we fragmencie odtwarzania w „starym stylu”, umieszczając je na nieprzezroczystym tle. (PlaybackBannerControlGlue
zastępujePlaybackControlGlue
, która została wycofana).PlaybackTransportControlGlue
używa „nowego stylu” z przezroczystym tłem.
Jeśli chcesz, by aplikacja obsługiwała przewijanie wideo, musisz użyć
PlaybackTransportControlGlue
Musisz też określić „hosta glue” które
wiąże klej z odtwarzaniem,
rysuje elementy sterujące transportem w interfejsie użytkownika i zachowuje ich stan,
przekazuje zdarzenia sterujące transportem z powrotem do kleju. Host musi pasować do typu fragmentu przy odtwarzaniu. Używaj
PlaybackSupportFragmentGlueHost
z
PlaybackFragment
,
VideoSupportFragmentGlueHost
z
VideoFragment
Oto ilustracja, która przedstawia elementy sterujące funkcją Leanback do siebie pasują:
Kod, który łączy aplikację, powinien znajdować się w sekcji
PlaybackSupportFragment
lub VideoSupportFragment
, który określa interfejs użytkownika.
W następujących
jeśli na przykład aplikacja tworzy wystąpienie elementu PlaybackTransportControlGlue
,
nadając mu nazwę playerGlue
,
i łączy jego VideoSupportFragment
z nowo utworzonym MediaPlayerAdapter
. Od
to jest VideoSupportFragment
. Kod konfiguracji wywołuje setHost()
, aby dołączyć
VideoSupportFragmentGlueHost
do playerGlue
. Kod jest umieszczony w obrębie zajęć
który rozciąga się VideoSupportFragment
.
Kotlin
class MyVideoFragment : VideoSupportFragment() { fun onCreate(savedInstanceState: Bundle) { super.onCreate(savedInstanceState) val playerGlue = PlaybackTransportControlGlue(getActivity(), MediaPlayerAdapter(getActivity())) playerGlue.setHost(VideoSupportFragmentGlueHost(this)) playerGlue.addPlayerCallback(object : PlaybackGlue.PlayerCallback() { override fun onPreparedStateChanged(glue: PlaybackGlue) { if (glue.isPrepared()) { playerGlue.seekProvider = MySeekProvider() playerGlue.play() } } }) playerGlue.setSubtitle("Leanback artist") playerGlue.setTitle("Leanback team at work") val uriPath = "android.resource://com.example.android.leanback/raw/video" playerGlue.getPlayerAdapter().setDataSource(Uri.parse(uriPath)) } }
Java
public class MyVideoFragment extends VideoSupportFragment { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); final PlaybackTransportControlGlue<MediaPlayerAdapter> playerGlue = new PlaybackTransportControlGlue(getActivity(), new MediaPlayerAdapter(getActivity())); playerGlue.setHost(new VideoSupportFragmentGlueHost(this)); playerGlue.addPlayerCallback(new PlaybackGlue.PlayerCallback() { @Override public void onPreparedStateChanged(PlaybackGlue glue) { if (glue.isPrepared()) { playerGlue.setSeekProvider(new MySeekProvider()); playerGlue.play(); } } }); playerGlue.setSubtitle("Leanback artist"); playerGlue.setTitle("Leanback team at work"); String uriPath = "android.resource://com.example.android.leanback/raw/video"; playerGlue.getPlayerAdapter().setDataSource(Uri.parse(uriPath)); } }
Zwróć uwagę, że kod konfiguracji określa też PlayerAdapter.Callback
do obsługi zdarzeń z
w odtwarzaczu.
Dostosowywanie kleju do interfejsu
Możesz dostosować
PlaybackBannerControlGlue
i PlaybackTransportControlGlue
aby zmienić
PlaybackControlsRow
Dostosowywanie tytułu i opisu
Aby dostosować tytuł i opis na górze sekcji
elementy sterujące odtwarzaniem, zastępowanie
onCreateRowPresenter()
:
Kotlin
override fun onCreateRowPresenter(): PlaybackRowPresenter { return super.onCreateRowPresenter().apply { (this as? PlaybackTransportRowPresenter) ?.setDescriptionPresenter(MyCustomDescriptionPresenter()) } }
Java
@Override protected PlaybackRowPresenter onCreateRowPresenter() { PlaybackTransportRowPresenter presenter = (PlaybackTransportRowPresenter) super.onCreateRowPresenter(); presenter.setDescriptionPresenter(new MyCustomDescriptionPresenter()); return presenter; }
Dodawanie elementów sterujących
Element sterujący typu glue wyświetla elementy sterujące działaniami w elemencie PlaybackControlsRow
.
Działania w kolumnie PlaybackControlsRow
są przypisane do 2 grup: działań głównych i dodatkowych.
czynności. Elementy sterujące grupy głównej są widoczne nad paskiem przewijania oraz
grupa dodatkowa pojawi się pod paskiem przewijania. Początkowo istnieje tylko jedno działanie główne.
dla przycisku odtwarzania/wstrzymania, bez żadnych działań dodatkowych.
Możesz dodać działania do grupy podstawowej i dodatkowej przez zastąpienie
onCreatePrimaryActions()
i
onCreateSecondaryActions()
Kotlin
private lateinit var repeatAction: PlaybackControlsRow.RepeatAction private lateinit var pipAction: PlaybackControlsRow.PictureInPictureAction private lateinit var thumbsUpAction: PlaybackControlsRow.ThumbsUpAction private lateinit var thumbsDownAction: PlaybackControlsRow.ThumbsDownAction private lateinit var skipPreviousAction: PlaybackControlsRow.SkipPreviousAction private lateinit var skipNextAction: PlaybackControlsRow.SkipNextAction private lateinit var fastForwardAction: PlaybackControlsRow.FastForwardAction private lateinit var rewindAction: PlaybackControlsRow.RewindAction override fun onCreatePrimaryActions(primaryActionsAdapter: ArrayObjectAdapter) { // Order matters, super.onCreatePrimaryActions() will create the play / pause action. // Will display as follows: // play/pause, previous, rewind, fast forward, next // > /|| |< << >> >| super.onCreatePrimaryActions(primaryActionsAdapter) primaryActionsAdapter.apply { add(skipPreviousAction) add(rewindAction) add(fastForwardAction) add(skipNextAction) } } override fun onCreateSecondaryActions(adapter: ArrayObjectAdapter?) { super.onCreateSecondaryActions(adapter) adapter?.apply { add(thumbsDownAction) add(thumbsUpAction) } }
Java
private PlaybackControlsRow.RepeatAction repeatAction; private PlaybackControlsRow.PictureInPictureAction pipAction; private PlaybackControlsRow.ThumbsUpAction thumbsUpAction; private PlaybackControlsRow.ThumbsDownAction thumbsDownAction; private PlaybackControlsRow.SkipPreviousAction skipPreviousAction; private PlaybackControlsRow.SkipNextAction skipNextAction; private PlaybackControlsRow.FastForwardAction fastForwardAction; private PlaybackControlsRow.RewindAction rewindAction; @Override protected void onCreatePrimaryActions(ArrayObjectAdapter primaryActionsAdapter) { // Order matters, super.onCreatePrimaryActions() will create the play / pause action. // Will display as follows: // play/pause, previous, rewind, fast forward, next // > /|| |< << >> >| super.onCreatePrimaryActions(primaryActionsAdapter); primaryActionsAdapter.add(skipPreviousAction); primaryActionsAdapter.add(rewindAction); primaryActionsAdapter.add(fastForwardAction); primaryActionsAdapter.add(skipNextAction); } @Override protected void onCreateSecondaryActions(ArrayObjectAdapter adapter) { super.onCreateSecondaryActions(adapter); adapter.add(thumbsDownAction); adapter.add(thumbsUpAction); }
Musisz zastąpić
onActionClicked()
, aby obsługiwać nowe działania.
Kotlin
override fun onActionClicked(action: Action) { when(action) { rewindAction -> { // Handle Rewind } fastForwardAction -> { // Handle FastForward } thumbsDownAction -> { // Handle ThumbsDown } thumbsUpAction -> { // Handle ThumbsUp } else -> // The superclass handles play/pause and delegates next/previous actions to abstract methods, // so those two methods should be overridden rather than handling the actions here. super.onActionClicked(action) } } override fun next() { // Skip to next item in playlist. } override fun previous() { // Skip to previous item in playlist. }
Java
@Override public void onActionClicked(Action action) { if (action == rewindAction) { // Handle Rewind } else if (action == fastForwardAction ) { // Handle FastForward } else if (action == thumbsDownAction) { // Handle ThumbsDown } else if (action == thumbsUpAction) { // Handle ThumbsUp } else { // The superclass handles play/pause and delegates next/previous actions to abstract methods, // so those two methods should be overridden rather than handling the actions here. super.onActionClicked(action); } } @Override public void next() { // Skip to next item in playlist. } @Override public void previous() { // Skip to previous item in playlist. }
W szczególnych przypadkach możesz samodzielnie zaimplementować
PlaybackTransportRowPresenter
do renderowania niestandardowych elementów sterujących i reagowania na działania przewijania za pomocą
PlaybackSeekUi
Czyszczenie filmów
Jeśli Twoja aplikacja używa interfejsu VideoSupportFragment
i chcesz obsługiwać przewijanie wideo.
Ty
musisz zapewnić implementację tagu PlaybackSeekDataProvider
.
Ten komponent udostępnia miniatury filmów używane podczas przewijania.
Musisz wdrożyć własnego dostawcę przez rozszerzenie
PlaybackSeekDataProvider
Zapoznaj się z przykładem w
aplikacji Leanback Showcase.
,