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.

Tworzenie wiadomości do telewizora →

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 rozszerza PlaybackSupportFragment i ma SurfaceView 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ępuje PlaybackControlGlue, 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.