Add ForwardingPlayer

The ForwardingPlayer implements the Player interface and forwards all
operations to another Player instance. Apps will be able to override
methods of ForwardinPlayer in order to modify and/or suppress specific
Player funcionalities.

This commit introduces the ForwardingPlayer which simply forwards all
Player operations to another Player instance. In follow-up changes,
the ForwardingPlayer will be extended so that it eventually reaches the
feature-set offered by ControlDispatcher.

PiperOrigin-RevId: 370653167

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

+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2;
+
+import android.os.Looper;
+import android.view.Surface;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.TextureView;
+import androidx.annotation.Nullable;
+import com.google.android.exoplayer2.audio.AudioAttributes;
+import com.google.android.exoplayer2.device.DeviceInfo;
+import com.google.android.exoplayer2.metadata.Metadata;
+import com.google.android.exoplayer2.source.TrackGroupArray;
+import com.google.android.exoplayer2.text.Cue;
+import com.google.android.exoplayer2.trackselection.TrackSelectionArray;
+import java.util.List;
+
+/**
+ * A {@link Player} that forwards operations to another {@link Player}. Applications can use this
+ * class to suppress or modify specific operations, by overriding the respective methods.
+ */
+public class ForwardingPlayer extends BasePlayer {
+  private final Player player;
+
+  /** Creates a new instance that forwards all operations to {@code player}. */
+  public ForwardingPlayer(Player player) {
+    this.player = player;
+  }
+
+  @Override
+  public Looper getApplicationLooper() {
+    return player.getApplicationLooper();
+  }
+
+  @Override
+  public void addListener(EventListener listener) {
+    player.addListener(listener);
+  }
+
+  @Override
+  public void addListener(Listener listener) {
+    player.addListener(listener);
+  }
+
+  @Override
+  public void removeListener(EventListener listener) {
+    player.removeListener(listener);
+  }
+
+  @Override
+  public void removeListener(Listener listener) {
+    player.removeListener(listener);
+  }
+
+  @Override
+  public void setMediaItems(List<MediaItem> mediaItems, boolean resetPosition) {
+    player.setMediaItems(mediaItems, resetPosition);
+  }
+
+  @Override
+  public void setMediaItems(
+      List<MediaItem> mediaItems, int startWindowIndex, long startPositionMs) {
+    player.setMediaItems(mediaItems, startWindowIndex, startPositionMs);
+  }
+
+  @Override
+  public void addMediaItems(int index, List<MediaItem> mediaItems) {
+    player.addMediaItems(index, mediaItems);
+  }
+
+  @Override
+  public void moveMediaItems(int fromIndex, int toIndex, int newIndex) {
+    player.moveMediaItems(fromIndex, toIndex, newIndex);
+  }
+
+  @Override
+  public void removeMediaItems(int fromIndex, int toIndex) {
+    player.removeMediaItems(fromIndex, toIndex);
+  }
+
+  @Override
+  public Commands getAvailableCommands() {
+    return player.getAvailableCommands();
+  }
+
+  @Override
+  public void prepare() {
+    player.prepare();
+  }
+
+  @Override
+  public int getPlaybackState() {
+    return player.getPlaybackState();
+  }
+
+  @Override
+  public int getPlaybackSuppressionReason() {
+    return player.getPlaybackSuppressionReason();
+  }
+
+  @Nullable
+  @Override
+  public ExoPlaybackException getPlayerError() {
+    return player.getPlayerError();
+  }
+
+  @Override
+  public void setPlayWhenReady(boolean playWhenReady) {
+    player.setPlayWhenReady(playWhenReady);
+  }
+
+  @Override
+  public boolean getPlayWhenReady() {
+    return player.getPlayWhenReady();
+  }
+
+  @Override
+  public void setRepeatMode(@RepeatMode int repeatMode) {
+    player.setRepeatMode(repeatMode);
+  }
+
+  @Override
+  public int getRepeatMode() {
+    return player.getRepeatMode();
+  }
+
+  @Override
+  public void setShuffleModeEnabled(boolean shuffleModeEnabled) {
+    player.setShuffleModeEnabled(shuffleModeEnabled);
+  }
+
+  @Override
+  public boolean getShuffleModeEnabled() {
+    return player.getShuffleModeEnabled();
+  }
+
+  @Override
+  public boolean isLoading() {
+    return player.isLoading();
+  }
+
+  @Override
+  public void seekTo(int windowIndex, long positionMs) {
+    player.seekTo(windowIndex, positionMs);
+  }
+
+  @Override
+  public void setPlaybackParameters(PlaybackParameters playbackParameters) {
+    player.setPlaybackParameters(playbackParameters);
+  }
+
+  @Override
+  public PlaybackParameters getPlaybackParameters() {
+    return player.getPlaybackParameters();
+  }
+
+  @Override
+  @SuppressWarnings("deprecation") // Forwarding to deprecated method.
+  public void stop(boolean reset) {
+    player.stop(reset);
+  }
+
+  @Override
+  public void release() {
+    player.release();
+  }
+
+  @Override
+  public TrackGroupArray getCurrentTrackGroups() {
+    return player.getCurrentTrackGroups();
+  }
+
+  @Override
+  public TrackSelectionArray getCurrentTrackSelections() {
+    return player.getCurrentTrackSelections();
+  }
+
+  @Override
+  public List<Metadata> getCurrentStaticMetadata() {
+    return player.getCurrentStaticMetadata();
+  }
+
+  @Override
+  public MediaMetadata getMediaMetadata() {
+    return player.getMediaMetadata();
+  }
+
+  @Override
+  public Timeline getCurrentTimeline() {
+    return player.getCurrentTimeline();
+  }
+
+  @Override
+  public int getCurrentPeriodIndex() {
+    return player.getCurrentPeriodIndex();
+  }
+
+  @Override
+  public int getCurrentWindowIndex() {
+    return player.getCurrentWindowIndex();
+  }
+
+  @Override
+  public long getDuration() {
+    return player.getDuration();
+  }
+
+  @Override
+  public long getCurrentPosition() {
+    return player.getCurrentPosition();
+  }
+
+  @Override
+  public long getBufferedPosition() {
+    return player.getBufferedPosition();
+  }
+
+  @Override
+  public long getTotalBufferedDuration() {
+    return player.getTotalBufferedDuration();
+  }
+
+  @Override
+  public boolean isPlayingAd() {
+    return player.isPlayingAd();
+  }
+
+  @Override
+  public int getCurrentAdGroupIndex() {
+    return player.getCurrentAdGroupIndex();
+  }
+
+  @Override
+  public int getCurrentAdIndexInAdGroup() {
+    return player.getCurrentAdIndexInAdGroup();
+  }
+
+  @Override
+  public long getContentPosition() {
+    return player.getContentPosition();
+  }
+
+  @Override
+  public long getContentBufferedPosition() {
+    return player.getContentBufferedPosition();
+  }
+
+  @Override
+  public AudioAttributes getAudioAttributes() {
+    return player.getAudioAttributes();
+  }
+
+  @Override
+  public void setVolume(float audioVolume) {
+    player.setVolume(audioVolume);
+  }
+
+  @Override
+  public float getVolume() {
+    return player.getVolume();
+  }
+
+  @Override
+  public void clearVideoSurface() {
+    player.clearVideoSurface();
+  }
+
+  @Override
+  public void clearVideoSurface(@Nullable Surface surface) {
+    player.clearVideoSurface(surface);
+  }
+
+  @Override
+  public void setVideoSurface(@Nullable Surface surface) {
+    player.setVideoSurface(surface);
+  }
+
+  @Override
+  public void setVideoSurfaceHolder(@Nullable SurfaceHolder surfaceHolder) {
+    player.setVideoSurfaceHolder(surfaceHolder);
+  }
+
+  @Override
+  public void clearVideoSurfaceHolder(@Nullable SurfaceHolder surfaceHolder) {
+    player.clearVideoSurfaceHolder(surfaceHolder);
+  }
+
+  @Override
+  public void setVideoSurfaceView(@Nullable SurfaceView surfaceView) {
+    player.setVideoSurfaceView(surfaceView);
+  }
+
+  @Override
+  public void clearVideoSurfaceView(@Nullable SurfaceView surfaceView) {
+    player.clearVideoSurfaceView(surfaceView);
+  }
+
+  @Override
+  public void setVideoTextureView(@Nullable TextureView textureView) {
+    player.setVideoTextureView(textureView);
+  }
+
+  @Override
+  public void clearVideoTextureView(@Nullable TextureView textureView) {
+    player.clearVideoTextureView(textureView);
+  }
+
+  @Override
+  public List<Cue> getCurrentCues() {
+    return player.getCurrentCues();
+  }
+
+  @Override
+  public DeviceInfo getDeviceInfo() {
+    return player.getDeviceInfo();
+  }
+
+  @Override
+  public int getDeviceVolume() {
+    return player.getDeviceVolume();
+  }
+
+  @Override
+  public boolean isDeviceMuted() {
+    return player.isDeviceMuted();
+  }
+
+  @Override
+  public void setDeviceVolume(int volume) {
+    player.setDeviceVolume(volume);
+  }
+
+  @Override
+  public void increaseDeviceVolume() {
+    player.increaseDeviceVolume();
+  }
+
+  @Override
+  public void decreaseDeviceVolume() {
+    player.decreaseDeviceVolume();
+  }
+
+  @Override
+  public void setDeviceMuted(boolean muted) {
+    player.setDeviceMuted(muted);
+  }
+}