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;
@@ -123,6 +123,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);
   }
@@ -134,21 +139,71 @@ public class ForwardingPlayer extends BasePlayer {
   }
 
   @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();
     if (filteredCommands == null || !commands.equals(unfilteredCommands)) {
@@ -173,6 +228,11 @@ public class ForwardingPlayer extends BasePlayer {
     return player.getPlaybackSuppressionReason();
   }
 
+  @Override
+  public boolean isPlaying() {
+    return player.isPlaying();
+  }
+
   @Nullable
   @Override
   public ExoPlaybackException getPlayerError() {
@@ -180,6 +240,16 @@ public class ForwardingPlayer extends BasePlayer {
   }
 
   @Override
+  public void play() {
+    player.play();
+  }
+
+  @Override
+  public void pause() {
+    player.pause();
+  }
+
+  @Override
   public void setPlayWhenReady(boolean playWhenReady) {
     player.setPlayWhenReady(playWhenReady);
   }
@@ -215,21 +285,66 @@ public class ForwardingPlayer extends BasePlayer {
   }
 
   @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) {
     player.stop(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();
@@ -276,6 +397,32 @@ public class ForwardingPlayer extends BasePlayer {
   }
 
   @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();
   }
@@ -291,11 +438,36 @@ public class ForwardingPlayer extends BasePlayer {
   }
 
   @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();
   }
@@ -311,6 +483,11 @@ public class ForwardingPlayer extends BasePlayer {
   }
 
   @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

@@ -255,12 +255,26 @@ public class ForwardingPlayerTest {
   }
 
   @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();