ForwardingPlayer implements Player

Make ForwardingPlayer implement Player and not extend BasePlayer so that
ForwardingPlayer forwards each Player method directly to the wrapped
Player instance.

PiperOrigin-RevId: 374161084

library/common/src/main/java/com/google/android/exoplayer2/ForwardingPlayer.java

@@ -43,7 +43,7 @@ import java.util.List;
  * player advertises available commands, either with {@link Player#isCommandAvailable(int)} or with
  * {@link Listener#onAvailableCommandsChanged}, the disabled commands will be filtered out.
  */
-public class ForwardingPlayer extends BasePlayer {
+public class ForwardingPlayer implements Player {
   private final Player player;
   private final Clock clock;
   @Nullable private ForwardingListener forwardingListener;
@@ -122,6 +122,11 @@ public class ForwardingPlayer extends BasePlayer {
     }
   }
 
+  @Override
+  public void setMediaItems(List<MediaItem> mediaItems) {
+    player.setMediaItems(mediaItems);
+  }
+
   @Override
   public void setMediaItems(List<MediaItem> mediaItems, boolean resetPosition) {
     player.setMediaItems(mediaItems, resetPosition);
@@ -133,21 +138,71 @@ public class ForwardingPlayer extends BasePlayer {
     player.setMediaItems(mediaItems, startWindowIndex, startPositionMs);
   }
 
+  @Override
+  public void setMediaItem(MediaItem mediaItem) {
+    player.setMediaItem(mediaItem);
+  }
+
+  @Override
+  public void setMediaItem(MediaItem mediaItem, long startPositionMs) {
+    player.setMediaItem(mediaItem, startPositionMs);
+  }
+
+  @Override
+  public void setMediaItem(MediaItem mediaItem, boolean resetPosition) {
+    player.setMediaItem(mediaItem, resetPosition);
+  }
+
+  @Override
+  public void addMediaItem(MediaItem mediaItem) {
+    player.addMediaItem(mediaItem);
+  }
+
+  @Override
+  public void addMediaItem(int index, MediaItem mediaItem) {
+    player.addMediaItem(index, mediaItem);
+  }
+
+  @Override
+  public void addMediaItems(List<MediaItem> mediaItems) {
+    player.addMediaItems(mediaItems);
+  }
+
   @Override
   public void addMediaItems(int index, List<MediaItem> mediaItems) {
     player.addMediaItems(index, mediaItems);
   }
 
+  @Override
+  public void moveMediaItem(int currentIndex, int newIndex) {
+    player.moveMediaItem(currentIndex, newIndex);
+  }
+
   @Override
   public void moveMediaItems(int fromIndex, int toIndex, int newIndex) {
     player.moveMediaItems(fromIndex, toIndex, newIndex);
   }
 
+  @Override
+  public void removeMediaItem(int index) {
+    player.removeMediaItem(index);
+  }
+
   @Override
   public void removeMediaItems(int fromIndex, int toIndex) {
     player.removeMediaItems(fromIndex, toIndex);
   }
 
+  @Override
+  public void clearMediaItems() {
+    player.clearMediaItems();
+  }
+
+  @Override
+  public boolean isCommandAvailable(@Command int command) {
+    return !disabledCommands.contains(command) && player.isCommandAvailable(command);
+  }
+
   @Override
   public Commands getAvailableCommands() {
     Commands commands = player.getAvailableCommands();
@@ -173,12 +228,27 @@ public class ForwardingPlayer extends BasePlayer {
     return player.getPlaybackSuppressionReason();
   }
 
+  @Override
+  public boolean isPlaying() {
+    return player.isPlaying();
+  }
+
   @Nullable
   @Override
   public ExoPlaybackException getPlayerError() {
     return player.getPlayerError();
   }
 
+  @Override
+  public void play() {
+    player.play();
+  }
+
+  @Override
+  public void pause() {
+    player.pause();
+  }
+
   @Override
   public void setPlayWhenReady(boolean playWhenReady) {
     player.setPlayWhenReady(playWhenReady);
@@ -214,21 +284,66 @@ public class ForwardingPlayer extends BasePlayer {
     return player.isLoading();
   }
 
+  @Override
+  public void seekToDefaultPosition() {
+    player.seekToDefaultPosition();
+  }
+
+  @Override
+  public void seekToDefaultPosition(int windowIndex) {
+    player.seekToDefaultPosition(windowIndex);
+  }
+
+  @Override
+  public void seekTo(long positionMs) {
+    player.seekTo(positionMs);
+  }
+
   @Override
   public void seekTo(int windowIndex, long positionMs) {
     player.seekTo(windowIndex, positionMs);
   }
 
+  @Override
+  public boolean hasPrevious() {
+    return player.hasPrevious();
+  }
+
+  @Override
+  public void previous() {
+    player.previous();
+  }
+
+  @Override
+  public boolean hasNext() {
+    return player.hasNext();
+  }
+
+  @Override
+  public void next() {
+    player.next();
+  }
+
   @Override
   public void setPlaybackParameters(PlaybackParameters playbackParameters) {
     player.setPlaybackParameters(playbackParameters);
   }
 
+  @Override
+  public void setPlaybackSpeed(float speed) {
+    player.setPlaybackSpeed(speed);
+  }
+
   @Override
   public PlaybackParameters getPlaybackParameters() {
     return player.getPlaybackParameters();
   }
 
+  @Override
+  public void stop() {
+    player.stop();
+  }
+
   @Override
   @SuppressWarnings("deprecation") // Forwarding to deprecated method.
   public void stop(boolean reset) {
@@ -260,6 +375,12 @@ public class ForwardingPlayer extends BasePlayer {
     return player.getMediaMetadata();
   }
 
+  @Nullable
+  @Override
+  public Object getCurrentManifest() {
+    return player.getCurrentManifest();
+  }
+
   @Override
   public Timeline getCurrentTimeline() {
     return player.getCurrentTimeline();
@@ -275,6 +396,32 @@ public class ForwardingPlayer extends BasePlayer {
     return player.getCurrentWindowIndex();
   }
 
+  @Override
+  public int getNextWindowIndex() {
+    return player.getNextWindowIndex();
+  }
+
+  @Override
+  public int getPreviousWindowIndex() {
+    return player.getPreviousWindowIndex();
+  }
+
+  @Nullable
+  @Override
+  public MediaItem getCurrentMediaItem() {
+    return player.getCurrentMediaItem();
+  }
+
+  @Override
+  public int getMediaItemCount() {
+    return player.getMediaItemCount();
+  }
+
+  @Override
+  public MediaItem getMediaItemAt(int index) {
+    return player.getMediaItemAt(index);
+  }
+
   @Override
   public long getDuration() {
     return player.getDuration();
@@ -290,11 +437,36 @@ public class ForwardingPlayer extends BasePlayer {
     return player.getBufferedPosition();
   }
 
+  @Override
+  public int getBufferedPercentage() {
+    return player.getBufferedPercentage();
+  }
+
   @Override
   public long getTotalBufferedDuration() {
     return player.getTotalBufferedDuration();
   }
 
+  @Override
+  public boolean isCurrentWindowDynamic() {
+    return player.isCurrentWindowDynamic();
+  }
+
+  @Override
+  public boolean isCurrentWindowLive() {
+    return player.isCurrentWindowLive();
+  }
+
+  @Override
+  public long getCurrentLiveOffset() {
+    return player.getCurrentLiveOffset();
+  }
+
+  @Override
+  public boolean isCurrentWindowSeekable() {
+    return player.isCurrentWindowSeekable();
+  }
+
   @Override
   public boolean isPlayingAd() {
     return player.isPlayingAd();
@@ -310,6 +482,11 @@ public class ForwardingPlayer extends BasePlayer {
     return player.getCurrentAdIndexInAdGroup();
   }
 
+  @Override
+  public long getContentDuration() {
+    return player.getContentDuration();
+  }
+
   @Override
   public long getContentPosition() {
     return player.getContentPosition();

library/common/src/test/java/com/google/android/exoplayer2/ForwardingPlayerTest.java

@@ -254,13 +254,27 @@ public class ForwardingPlayerTest {
     inOrder.verifyNoMoreInteractions();
   }
 
+  @Test
+  public void forwardingPlayer_overridesAllPlayerMethods() throws Exception {
+    // Check with reflection that ForwardingPlayer overrides all Player methods.
+    List<Method> playerMethods = getPublicMethods(Player.class);
+    for (int i = 0; i < playerMethods.size(); i++) {
+      Method method = playerMethods.get(i);
+      assertThat(
+              ForwardingPlayer.class.getDeclaredMethod(
+                  method.getName(), method.getParameterTypes()))
+          .isNotNull();
+    }
+  }
+
   @Test
   public void forwardingListener_overridesAllListenerMethods() throws Exception {
     // Check with reflection that ForwardingListener in ForwardingPlayer overrides all Listener
     // methods.
     Class<?> forwardingListenerClass = getNestedClass("ForwardingListener");
     List<Method> publicListenerMethods = getPublicMethods(Player.Listener.class);
-    for (Method method : publicListenerMethods) {
+    for (int i = 0; i < publicListenerMethods.size(); i++) {
+      Method method = publicListenerMethods.get(i);
       assertThat(
               forwardingListenerClass.getDeclaredMethod(
                   method.getName(), method.getParameterTypes()))
@@ -274,7 +288,8 @@ public class ForwardingPlayerTest {
     // EventListener methods.
     Class<?> listenerWrapperClass = getNestedClass("EventListenerWrapper");
     List<Method> publicListenerMethods = getPublicMethods(Player.EventListener.class);
-    for (Method method : publicListenerMethods) {
+    for (int i = 0; i < publicListenerMethods.size(); i++) {
+      Method method = publicListenerMethods.get(i);
       assertThat(
               listenerWrapperClass.getDeclaredMethod(method.getName(), method.getParameterTypes()))
           .isNotNull();