Revert of 9c8c0a59

PiperOrigin-RevId: 426994820

libraries/cast/src/main/java/androidx/media3/cast/CastPlayer.java

@@ -137,7 +137,7 @@ public final class CastPlayer extends BasePlayer {
   private final SeekResultCallback seekResultCallback;
 
   // Listeners and notification.
-  private final ListenerSet<Listener> listeners;
+  private final ListenerSet<Player.EventListener> listeners;
   @Nullable private SessionAvailabilityListener sessionAvailabilityListener;
 
   // Internal state.
@@ -280,11 +280,41 @@ public final class CastPlayer extends BasePlayer {
 
   @Override
   public void addListener(Listener listener) {
+    EventListener eventListener = listener;
+    addListener(eventListener);
+  }
+
+  /**
+   * Registers a listener to receive events from the player.
+   *
+   * <p>The listener's methods will be called on the thread associated with {@link
+   * #getApplicationLooper()}.
+   *
+   * @param listener The listener to register.
+   * @deprecated Use {@link #addListener(Listener)} and {@link #removeListener(Listener)} instead.
+   */
+  @Deprecated
+  @SuppressWarnings("deprecation")
+  public void addListener(EventListener listener) {
     listeners.add(listener);
   }
 
   @Override
   public void removeListener(Listener listener) {
+    EventListener eventListener = listener;
+    removeListener(eventListener);
+  }
+
+  /**
+   * Unregister a listener registered through {@link #addListener(EventListener)}. The listener will
+   * no longer receive events from the player.
+   *
+   * @param listener The listener to unregister.
+   * @deprecated Use {@link #addListener(Listener)} and {@link #removeListener(Listener)} instead.
+   */
+  @Deprecated
+  @SuppressWarnings("deprecation")
+  public void removeListener(EventListener listener) {
     listeners.remove(listener);
   }
 
@@ -443,7 +473,7 @@ public final class CastPlayer extends BasePlayer {
       }
       updateAvailableCommandsAndNotifyIfChanged();
     } else if (pendingSeekCount == 0) {
-      listeners.queueEvent(/* eventFlag= */ C.INDEX_UNSET, Listener::onSeekProcessed);
+      listeners.queueEvent(/* eventFlag= */ C.INDEX_UNSET, EventListener::onSeekProcessed);
     }
     listeners.flushEvents();
   }
@@ -1447,7 +1477,7 @@ public final class CastPlayer extends BasePlayer {
         currentWindowIndex = pendingSeekWindowIndex;
         pendingSeekWindowIndex = C.INDEX_UNSET;
         pendingSeekPositionMs = C.TIME_UNSET;
-        listeners.sendEvent(/* eventFlag= */ C.INDEX_UNSET, Listener::onSeekProcessed);
+        listeners.sendEvent(/* eventFlag= */ C.INDEX_UNSET, EventListener::onSeekProcessed);
       }
     }
   }

libraries/common/src/main/java/androidx/media3/common/ForwardingPlayer.java

@@ -819,159 +819,191 @@ public class ForwardingPlayer implements Player {
     return player;
   }
 
-  private static final class ForwardingListener implements Listener {
+  @SuppressWarnings("deprecation") // Use of deprecated type for backwards compatibility.
+  private static class ForwardingEventListener implements EventListener {
 
     private final ForwardingPlayer forwardingPlayer;
-    private final Listener listener;
+    private final EventListener eventListener;
 
-    public ForwardingListener(ForwardingPlayer forwardingPlayer, Listener listener) {
+    private ForwardingEventListener(
+        ForwardingPlayer forwardingPlayer, EventListener eventListener) {
       this.forwardingPlayer = forwardingPlayer;
-      this.listener = listener;
-    }
-
-    @Override
-    public void onEvents(Player player, Events events) {
-      // Replace player with forwarding player.
-      listener.onEvents(forwardingPlayer, events);
+      this.eventListener = eventListener;
     }
 
     @Override
     public void onTimelineChanged(Timeline timeline, @TimelineChangeReason int reason) {
-      listener.onTimelineChanged(timeline, reason);
+      eventListener.onTimelineChanged(timeline, reason);
     }
 
     @Override
     public void onMediaItemTransition(
         @Nullable MediaItem mediaItem, @MediaItemTransitionReason int reason) {
-      listener.onMediaItemTransition(mediaItem, reason);
+      eventListener.onMediaItemTransition(mediaItem, reason);
     }
 
     @Override
-    @SuppressWarnings("deprecation")
     public void onTracksChanged(TrackGroupArray trackGroups, TrackSelectionArray trackSelections) {
-      listener.onTracksChanged(trackGroups, trackSelections);
+      eventListener.onTracksChanged(trackGroups, trackSelections);
     }
 
     @Override
     public void onTracksInfoChanged(TracksInfo tracksInfo) {
-      listener.onTracksInfoChanged(tracksInfo);
+      eventListener.onTracksInfoChanged(tracksInfo);
     }
 
     @Override
     public void onMediaMetadataChanged(MediaMetadata mediaMetadata) {
-      listener.onMediaMetadataChanged(mediaMetadata);
+      eventListener.onMediaMetadataChanged(mediaMetadata);
     }
 
     @Override
     public void onPlaylistMetadataChanged(MediaMetadata mediaMetadata) {
-      listener.onPlaylistMetadataChanged(mediaMetadata);
+      eventListener.onPlaylistMetadataChanged(mediaMetadata);
     }
 
     @Override
     public void onIsLoadingChanged(boolean isLoading) {
-      listener.onIsLoadingChanged(isLoading);
+      eventListener.onIsLoadingChanged(isLoading);
     }
 
     @Override
-    @SuppressWarnings("deprecation")
     public void onLoadingChanged(boolean isLoading) {
-      listener.onIsLoadingChanged(isLoading);
+      eventListener.onIsLoadingChanged(isLoading);
     }
 
     @Override
     public void onAvailableCommandsChanged(Commands availableCommands) {
-      listener.onAvailableCommandsChanged(availableCommands);
+      eventListener.onAvailableCommandsChanged(availableCommands);
     }
 
     @Override
     public void onTrackSelectionParametersChanged(TrackSelectionParameters parameters) {
-      listener.onTrackSelectionParametersChanged(parameters);
+      eventListener.onTrackSelectionParametersChanged(parameters);
     }
 
     @Override
-    @SuppressWarnings("deprecation")
     public void onPlayerStateChanged(boolean playWhenReady, @State int playbackState) {
-      listener.onPlayerStateChanged(playWhenReady, playbackState);
+      eventListener.onPlayerStateChanged(playWhenReady, playbackState);
     }
 
     @Override
     public void onPlaybackStateChanged(@State int playbackState) {
-      listener.onPlaybackStateChanged(playbackState);
+      eventListener.onPlaybackStateChanged(playbackState);
     }
 
     @Override
     public void onPlayWhenReadyChanged(
         boolean playWhenReady, @PlayWhenReadyChangeReason int reason) {
-      listener.onPlayWhenReadyChanged(playWhenReady, reason);
+      eventListener.onPlayWhenReadyChanged(playWhenReady, reason);
     }
 
     @Override
     public void onPlaybackSuppressionReasonChanged(
         @PlayWhenReadyChangeReason int playbackSuppressionReason) {
-      listener.onPlaybackSuppressionReasonChanged(playbackSuppressionReason);
+      eventListener.onPlaybackSuppressionReasonChanged(playbackSuppressionReason);
     }
 
     @Override
     public void onIsPlayingChanged(boolean isPlaying) {
-      listener.onIsPlayingChanged(isPlaying);
+      eventListener.onIsPlayingChanged(isPlaying);
     }
 
     @Override
     public void onRepeatModeChanged(@RepeatMode int repeatMode) {
-      listener.onRepeatModeChanged(repeatMode);
+      eventListener.onRepeatModeChanged(repeatMode);
     }
 
     @Override
     public void onShuffleModeEnabledChanged(boolean shuffleModeEnabled) {
-      listener.onShuffleModeEnabledChanged(shuffleModeEnabled);
+      eventListener.onShuffleModeEnabledChanged(shuffleModeEnabled);
     }
 
     @Override
     public void onPlayerError(PlaybackException error) {
-      listener.onPlayerError(error);
+      eventListener.onPlayerError(error);
     }
 
     @Override
     public void onPlayerErrorChanged(@Nullable PlaybackException error) {
-      listener.onPlayerErrorChanged(error);
+      eventListener.onPlayerErrorChanged(error);
     }
 
     @Override
-    @SuppressWarnings("deprecation")
     public void onPositionDiscontinuity(@DiscontinuityReason int reason) {
-      listener.onPositionDiscontinuity(reason);
+      eventListener.onPositionDiscontinuity(reason);
     }
 
     @Override
     public void onPositionDiscontinuity(
         PositionInfo oldPosition, PositionInfo newPosition, @DiscontinuityReason int reason) {
-      listener.onPositionDiscontinuity(oldPosition, newPosition, reason);
+      eventListener.onPositionDiscontinuity(oldPosition, newPosition, reason);
     }
 
     @Override
     public void onPlaybackParametersChanged(PlaybackParameters playbackParameters) {
-      listener.onPlaybackParametersChanged(playbackParameters);
+      eventListener.onPlaybackParametersChanged(playbackParameters);
     }
 
     @Override
     public void onSeekBackIncrementChanged(long seekBackIncrementMs) {
-      listener.onSeekBackIncrementChanged(seekBackIncrementMs);
+      eventListener.onSeekBackIncrementChanged(seekBackIncrementMs);
     }
 
     @Override
     public void onSeekForwardIncrementChanged(long seekForwardIncrementMs) {
-      listener.onSeekForwardIncrementChanged(seekForwardIncrementMs);
+      eventListener.onSeekForwardIncrementChanged(seekForwardIncrementMs);
     }
 
     @Override
     public void onMaxSeekToPreviousPositionChanged(long maxSeekToPreviousPositionMs) {
-      listener.onMaxSeekToPreviousPositionChanged(maxSeekToPreviousPositionMs);
+      eventListener.onMaxSeekToPreviousPositionChanged(maxSeekToPreviousPositionMs);
     }
 
     @Override
-    @SuppressWarnings("deprecation")
     public void onSeekProcessed() {
-      listener.onSeekProcessed();
+      eventListener.onSeekProcessed();
+    }
+
+    @Override
+    public void onEvents(Player player, Events events) {
+      // Replace player with forwarding player.
+      eventListener.onEvents(forwardingPlayer, events);
+    }
+
+    @Override
+    public boolean equals(@Nullable Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (!(o instanceof ForwardingEventListener)) {
+        return false;
+      }
+
+      ForwardingEventListener that = (ForwardingEventListener) o;
+
+      if (!forwardingPlayer.equals(that.forwardingPlayer)) {
+        return false;
+      }
+      return eventListener.equals(that.eventListener);
+    }
+
+    @Override
+    public int hashCode() {
+      int result = forwardingPlayer.hashCode();
+      result = 31 * result + eventListener.hashCode();
+      return result;
+    }
+  }
+
+  private static final class ForwardingListener extends ForwardingEventListener
+      implements Listener {
+
+    private final Listener listener;
+
+    public ForwardingListener(ForwardingPlayer forwardingPlayer, Listener listener) {
+      super(forwardingPlayer, listener);
+      this.listener = listener;
     }
 
     @Override
@@ -1028,27 +1060,5 @@ public class ForwardingPlayer implements Player {
     public void onDeviceVolumeChanged(int volume, boolean muted) {
       listener.onDeviceVolumeChanged(volume, muted);
     }
-
-    @Override
-    public boolean equals(@Nullable Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (!(o instanceof ForwardingListener)) {
-        return false;
-      }
-      ForwardingListener that = (ForwardingListener) o;
-      if (!forwardingPlayer.equals(that.forwardingPlayer)) {
-        return false;
-      }
-      return listener.equals(that.listener);
-    }
-
-    @Override
-    public int hashCode() {
-      int result = forwardingPlayer.hashCode();
-      result = 31 * result + listener.hashCode();
-      return result;
-    }
   }
 }

libraries/common/src/test/java/androidx/media3/common/ForwardingPlayerTest.java

@@ -116,6 +116,21 @@ public class ForwardingPlayerTest {
   }
 
   @Test
+  @SuppressWarnings("deprecation") // Testing backwards compatibility with deprecated type.
+  public void forwardingEventListener_overridesAllEventListenerMethods() throws Exception {
+    // Check with reflection that ForwardingListener overrides all Listener methods.
+    Class<?> forwardingListenerClass = getInnerClass("ForwardingEventListener");
+    List<Method> methods = getPublicMethods(Player.EventListener.class);
+    for (int i = 0; i < methods.size(); i++) {
+      Method method = methods.get(i);
+      assertThat(
+              forwardingListenerClass.getDeclaredMethod(
+                  method.getName(), method.getParameterTypes()))
+          .isNotNull();
+    }
+  }
+
+  @Test
   public void forwardingListener_overridesAllListenerMethods() throws Exception {
     // Check with reflection that ForwardingListener overrides all Listener methods.
     Class<?> forwardingListenerClass = getInnerClass("ForwardingListener");

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/ExoPlayer.java

@@ -1082,6 +1082,32 @@ public interface ExoPlayer extends Player {
   DeviceComponent getDeviceComponent();
 
   /**
+   * Registers a listener to receive events from the player.
+   *
+   * <p>The listener's methods will be called on the thread associated with {@link
+   * #getApplicationLooper()}.
+   *
+   * @param listener The listener to register.
+   * @deprecated Use {@link #addListener(Listener)} and {@link #removeListener(Listener)} instead.
+   */
+  @UnstableApi
+  @Deprecated
+  @SuppressWarnings("deprecation")
+  void addListener(EventListener listener);
+
+  /**
+   * Unregister a listener registered through {@link #addListener(EventListener)}. The listener will
+   * no longer receive events from the player.
+   *
+   * @param listener The listener to unregister.
+   * @deprecated Use {@link #addListener(Listener)} and {@link #removeListener(Listener)} instead.
+   */
+  @UnstableApi
+  @Deprecated
+  @SuppressWarnings("deprecation")
+  void removeListener(EventListener listener);
+
+  /**
    * Adds a listener to receive audio offload events.
    *
    * @param listener The listener to register.

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/SimpleExoPlayer.java

@@ -33,6 +33,7 @@ import androidx.media3.common.Format;
 import androidx.media3.common.MediaItem;
 import androidx.media3.common.MediaMetadata;
 import androidx.media3.common.PlaybackParameters;
+import androidx.media3.common.Player;
 import androidx.media3.common.PriorityTaskManager;
 import androidx.media3.common.Timeline;
 import androidx.media3.common.TrackGroupArray;
@@ -618,11 +619,23 @@ public class SimpleExoPlayer extends BasePlayer
     player.addListener(listener);
   }
 
+  @Deprecated
+  @Override
+  public void addListener(Player.EventListener listener) {
+    player.addEventListener(listener);
+  }
+
   @Override
   public void removeListener(Listener listener) {
     player.removeListener(listener);
   }
 
+  @Deprecated
+  @Override
+  public void removeListener(Player.EventListener listener) {
+    player.removeEventListener(listener);
+  }
+
   @Override
   public @State int getPlaybackState() {
     return player.getPlaybackState();

libraries/test_utils/src/main/java/androidx/media3/test/utils/StubExoPlayer.java

@@ -20,6 +20,7 @@ import androidx.annotation.Nullable;
 import androidx.media3.common.AudioAttributes;
 import androidx.media3.common.AuxEffectInfo;
 import androidx.media3.common.Format;
+import androidx.media3.common.Player;
 import androidx.media3.common.PriorityTaskManager;
 import androidx.media3.common.util.Clock;
 import androidx.media3.common.util.UnstableApi;
@@ -80,6 +81,16 @@ public class StubExoPlayer extends StubPlayer implements ExoPlayer {
   }
 
   @Override
+  public void addListener(Player.EventListener listener) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public void removeListener(Player.EventListener listener) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
   public void addAudioOffloadListener(AudioOffloadListener listener) {
     throw new UnsupportedOperationException();
   }