Diese Seite wurde von der Cloud Translation API übersetzt.

Steuerelemente für die Übertragung verwenden

Das Leanback-UI-Toolkit verfügt über Steuerelemente für die Wiedergabe, die eine verbesserte User Experience aus. Bei Video-Apps unterstützen die Transportsteuerelemente das Scrubbing mit der Vorwärts- und Rückwärtssteuerung. Beim Scrubbing auf dem Display Thumbnails zur Orientierung im Video verwenden.

Die Bibliothek enthält abstrakte Klassen sowie vordefinierte, sofort einsatzbereite Implementierungen. mit denen Entwickler mehr Kontrolle haben. Vordefinierte Implementierungen können Sie schnell und ohne Programmieraufwand eine App mit vielen Funktionen erstellen. Wenn Sie weitere Anpassungen benötigen, können Sie alle vordefinierten Komponenten.

Steuerelemente und Player

Das Leanback-UI-Toolkit trennt die UI für Transportsteuerelemente von der dem Player, der das Video wiedergibt. Dies wird durch zwei Komponenten erreicht: ein Wiedergabe-Unterstützungsfragment zum Anzeigen der Transportsteuerelemente (und optional das Video) und einen Player-Adapter zum kapseln eines Mediaplayers.

Wiedergabefragment

Für die UI-Aktivität Ihrer App sollte eine PlaybackSupportFragment oder VideoSupportFragment. Beide enthalten die Steuerelemente für den Leanback-Transport:

Ein PlaybackSupportFragment animiert seine Transportsteuerelemente, um sie nach Bedarf ein- oder auszublenden.
Ein VideoSupportFragment erweitert PlaybackSupportFragment und hat einen SurfaceView zum Rendern von Videos.

Sie können die ObjectAdapter um die Benutzeroberfläche zu verbessern. Verwenden Sie beispielsweise setAdapter() um ein ähnliches Video Zeile.

Player-Adapter

PlayerAdapter ist eine abstrakte Klasse, die steuert den zugrunde liegenden Mediaplayer. Entwickler können wählen, vordefinierte MediaPlayerAdapter-Implementierung verwenden oder eine eigene Implementierung dieser Klasse.

Die Teile zusammenkleben

Du musst „Kontrollkleber“ verwenden zum Verbinden des Wiedergabefragments für den Player. Leichtathletik Bibliothek zwei Arten von Klebstoff bietet:

PlaybackBannerControlGlue zieht die Transportsteuerelementen im Wiedergabefragment im "alten Stil", in einem undurchsichtigen Hintergrund. (PlaybackBannerControlGlue) ersetzt PlaybackControlGlue, das eingestellt wurde.)
PlaybackTransportControlGlue verwendet „new style“ die Steuerelemente vor einem transparenten Hintergrund.

Leanback Transport Control Kleber

Wenn deine App Video-Scrubbing unterstützen soll, musst du PlaybackTransportControlGlue

Sie müssen auch einen „Glue Host“ angeben das bindet den Klebstoff an die Wiedergabe fragmentiert, zeichnet die Transportsteuerelemente in der Benutzeroberfläche auf und behält ihren Status bei Transportsteuerungsereignisse zurück an den Kleber. Der Host muss dem Wiedergabefragmenttyp entsprechen. Verwenden Sie PlaybackSupportFragmentGlueHost mit PlaybackFragment und VideoSupportFragmentGlueHost mit einem VideoFragment.

Hier ist eine Abbildung, die zeigt, wie die einzelnen Elemente einer zusammenpassen:

Leanback Transport Control Kleber

Der Code, der Ihre App zusammenfügt, sollte sich im PlaybackSupportFragment oder VideoSupportFragment, die die UI definieren.

Im Folgenden Beispiel: Die Anwendung erstellt eine Instanz von PlaybackTransportControlGlue, dem Namen playerGlue, und verknüpft sein VideoSupportFragment mit einem neu erstellten MediaPlayerAdapter. Seit Dies ist ein VideoSupportFragment. Der Einrichtungscode ruft setHost() auf, um einen VideoSupportFragmentGlueHost bis playerGlue. Der Code ist in der Klasse enthalten. zur Erweiterung von 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));
  }
}

Im Einrichtungscode ist auch ein PlayerAdapter.Callback definiert, um Ereignisse aus im Mediaplayer an.

UI-Kleber anpassen

Sie können anpassen PlaybackBannerControlGlue und PlaybackTransportControlGlue zum Ändern der PlaybackControlsRow

Titel und Beschreibung anpassen

Um den Titel und die Beschreibung oben im Wiedergabesteuerung, überschreiben 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;
}

Steuerelemente hinzufügen

Der Kontroll-Glue zeigt Steuerelemente für Aktionen in einem PlaybackControlsRow an.

Die Aktionen in PlaybackControlsRow sind zwei Gruppen zugewiesen: primäre Aktionen und sekundär. Aktionen. Die Steuerelemente für die primäre Gruppe werden über der Steuerleiste angezeigt. sekundäre Gruppe werden unter der Suchleiste angezeigt. Anfangs gibt es nur eine primäre Aktion für die Schaltfläche für Wiedergabe/Pause und keine sekundären Aktionen.

Sie können der primären und sekundären Gruppe Aktionen hinzufügen, indem Sie onCreatePrimaryActions() und 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);
}

Überschreiben onActionClicked() zum Verarbeiten der neuen Aktionen.

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

In Sonderfällen empfiehlt es sich, eine eigene PlaybackTransportRowPresenter um benutzerdefinierte Steuerelemente zu rendern und auf Suchaktionen mit der PlaybackSeekUi.

Video-Scrubbing

Ob deine App ein VideoSupportFragment verwendet und das Video-Scrubbing unterstützen möchtest.

scheuern

Ich muss eine Implementierung von PlaybackSeekDataProvider zur Verfügung stehen. Diese Komponente stellt die Video-Thumbnails bereit, die beim Scrollen verwendet werden. Sie müssen Ihren eigenen Anbieter implementieren, PlaybackSeekDataProvider Ein Beispiel finden Sie in der <ph type="x-smartling-placeholder"></ph> Leanback Showcase App. .

Zurück

Detailansicht erstellen

Weiter

Neue Nutzer in Ihre App einführen