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 UI oddziela interfejs elementów sterujących odtwarzaniem od odtwarzacza, który odtwarza 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 adaptera odtwarzacza na jego obudowa.
Fragment odtwarzania
Aktywność w interfejsie aplikacji powinna wykorzystywać
PlaybackSupportFragment
lub
VideoSupportFragment
Oba zawierają te elementy sterowania:
- W razie potrzeby
PlaybackSupportFragment
animuje elementy sterujące transportu, aby je ukryć lub wyświetlić. VideoSupportFragment
rozszerzaPlaybackSupportFragment
i maSurfaceView
do renderowania filmu.
Możesz dostosować fragment 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
Aby połączyć fragment odtwarzania z odtwarzaczem, musisz użyć „elementu sterującego”. Leanback biblioteka udostępnia dwa rodzaje kleju:
PlaybackBannerControlGlue
rysuje elementy sterowania w fragmentach 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, aby Twoja aplikacja obsługiwała przewijanie filmu, musisz użyć funkcji 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 być zgodny z typem fragmentu odtwarzania. Użyj
PlaybackSupportFragmentGlueHost
z
PlaybackFragment
,
VideoSupportFragmentGlueHost
z
VideoFragment
Ilustracja pokazująca, jak elementy skonfigurowanego sterowania przesyłaniem leanback łączą się ze sobą:
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
.
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))
}
}
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 elementów interfejsu
Możesz dostosować PlaybackBannerControlGlue
i PlaybackTransportControlGlue
, aby zmienić PlaybackControlsRow
.
Dostosowywanie tytułu i opisu
Aby dostosować tytuł i opis u góry elementów sterujących odtwarzaniem, zastąpij:onCreateRowPresenter()
override fun onCreateRowPresenter(): PlaybackRowPresenter {
return super.onCreateRowPresenter().apply {
(this as? PlaybackTransportRowPresenter)
?.setDescriptionPresenter(MyCustomDescriptionPresenter())
}
}
@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 sekcji PlaybackControlsRow
są przypisane do 2 grup: działań głównych i działań dodatkowych. Elementy sterujące grupy głównej są widoczne nad paskiem przewijania oraz
grupa dodatkowa pojawi się pod paskiem przewijania. Początkowo jest tylko jedno działanie podstawowe (przycisk odtwarzania/pauzowania) i brak działań dodatkowych.
Do grup głównych i dodatkowych możesz dodawać działania, zastępując wartości w elementach onCreatePrimaryActions()
i onCreateSecondaryActions()
.
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)
}
}
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);
}
Aby obsłużyć nowe działania, musisz zastąpić onActionClicked()
.
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.
}
@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 warto zaimplementować własne PlaybackTransportRowPresenter
, aby renderować niestandardowe elementy sterujące i reagować na działania przesuwania za pomocą PlaybackSeekUi
.
Przewijanie filmu
Jeśli Twoja aplikacja korzysta z elementu VideoSupportFragment
i chcesz umożliwić przewijanie filmów.
Musisz podać implementację usługi PlaybackSeekDataProvider
.
Ten komponent udostępnia miniatury filmów używane podczas przewijania.
Musisz wdrożyć własnego dostawcę przez rozszerzenie
PlaybackSeekDataProvider
Przykład znajdziesz w aplikacji Showcase w formacie Leanback.