Korzystanie z ustawień transportu

Ulepszaj dzięki funkcji tworzenia wiadomości
Dzięki Jetpack Compose na system operacyjny Android TV możesz tworzyć atrakcyjne interfejsy użytkownika przy użyciu minimalnej ilości pisania.

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:

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:

leanback transporter glue

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ą:

leanback transporter glue

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.

szorowanie

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. ,