This mode should be used with caution, since holding limited resources may prevent other + * players of media components from acquiring them. It should only be enabled when both + * of the following conditions are true: + * + *
Note that foreground mode is not useful for switching between content without gaps + * between the playbacks. For this use case {@link #stop} does not need to be called, and simply + * calling {@link #prepare} for the new media will cause limited resources to be retained even if + * foreground mode is not enabled. + * + *
If foreground mode is enabled, it's the application's responsibility to disable it when the + * conditions described above no longer hold. + * + * @param foregroundMode Whether the player is allowed to keep limited resources even when in the + * idle state. + */ + void setForegroundMode(boolean foregroundMode); } diff --git a/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java b/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java index e1f942147d..130bf48921 100644 --- a/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java +++ b/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java @@ -71,6 +71,7 @@ import java.util.concurrent.CopyOnWriteArraySet; private int pendingOperationAcks; private boolean hasPendingPrepare; private boolean hasPendingSeek; + private boolean foregroundMode; private PlaybackParameters playbackParameters; private SeekParameters seekParameters; private @Nullable ExoPlaybackException playbackError; @@ -359,6 +360,14 @@ import java.util.concurrent.CopyOnWriteArraySet; return seekParameters; } + @Override + public void setForegroundMode(boolean foregroundMode) { + if (this.foregroundMode != foregroundMode) { + this.foregroundMode = foregroundMode; + internalPlayer.setForegroundMode(foregroundMode); + } + } + @Override public void stop(boolean reset) { if (reset) { diff --git a/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java b/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java index 0c6c3ca202..3034ead032 100644 --- a/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java +++ b/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java @@ -44,6 +44,7 @@ import com.google.android.exoplayer2.util.Util; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; +import java.util.concurrent.atomic.AtomicBoolean; /** Implements the internal behavior of {@link ExoPlayerImpl}. */ /* package */ final class ExoPlayerImplInternal @@ -76,9 +77,10 @@ import java.util.Collections; private static final int MSG_TRACK_SELECTION_INVALIDATED = 11; private static final int MSG_SET_REPEAT_MODE = 12; private static final int MSG_SET_SHUFFLE_ENABLED = 13; - private static final int MSG_SEND_MESSAGE = 14; - private static final int MSG_SEND_MESSAGE_TO_TARGET_THREAD = 15; - private static final int MSG_PLAYBACK_PARAMETERS_CHANGED_INTERNAL = 16; + private static final int MSG_SET_FOREGROUND_MODE = 14; + private static final int MSG_SEND_MESSAGE = 15; + private static final int MSG_SEND_MESSAGE_TO_TARGET_THREAD = 16; + private static final int MSG_PLAYBACK_PARAMETERS_CHANGED_INTERNAL = 17; private static final int PREPARING_SOURCE_INTERVAL_MS = 10; private static final int RENDERING_INTERVAL_MS = 10; @@ -115,6 +117,7 @@ import java.util.Collections; private boolean rebuffering; @Player.RepeatMode private int repeatMode; private boolean shuffleModeEnabled; + private boolean foregroundMode; private int pendingPrepareCount; private SeekPosition pendingInitialSeekPosition; @@ -218,6 +221,29 @@ import java.util.Collections; handler.obtainMessage(MSG_SEND_MESSAGE, message).sendToTarget(); } + public synchronized void setForegroundMode(boolean foregroundMode) { + if (foregroundMode) { + handler.obtainMessage(MSG_SET_FOREGROUND_MODE, /* foregroundMode */ 1, 0).sendToTarget(); + } else { + AtomicBoolean processedFlag = new AtomicBoolean(); + handler + .obtainMessage(MSG_SET_FOREGROUND_MODE, /* foregroundMode */ 0, 0, processedFlag) + .sendToTarget(); + boolean wasInterrupted = false; + while (!processedFlag.get() && !released) { + try { + wait(); + } catch (InterruptedException e) { + wasInterrupted = true; + } + } + if (wasInterrupted) { + // Restore the interrupted status. + Thread.currentThread().interrupt(); + } + } + } + public synchronized void release() { if (released) { return; @@ -311,8 +337,15 @@ import java.util.Collections; case MSG_SET_SEEK_PARAMETERS: setSeekParametersInternal((SeekParameters) msg.obj); break; + case MSG_SET_FOREGROUND_MODE: + setForegroundModeInternal( + /* foregroundMode= */ msg.arg1 != 0, /* processedFlag= */ (AtomicBoolean) msg.obj); + break; case MSG_STOP: - stopInternal(/* reset= */ msg.arg1 != 0, /* acknowledgeStop= */ true); + stopInternal( + /* forceResetRenderers= */ false, + /* resetPositionAndState= */ msg.arg1 != 0, + /* acknowledgeStop= */ true); break; case MSG_PERIOD_PREPARED: handlePeriodPrepared((MediaPeriod) msg.obj); @@ -345,17 +378,26 @@ import java.util.Collections; maybeNotifyPlaybackInfoChanged(); } catch (ExoPlaybackException e) { Log.e(TAG, "Playback error.", e); - stopInternal(/* reset= */ false, /* acknowledgeStop= */ false); + stopInternal( + /* forceResetRenderers= */ true, + /* resetPositionAndState= */ false, + /* acknowledgeStop= */ false); eventHandler.obtainMessage(MSG_ERROR, e).sendToTarget(); maybeNotifyPlaybackInfoChanged(); } catch (IOException e) { Log.e(TAG, "Source error.", e); - stopInternal(/* reset= */ false, /* acknowledgeStop= */ false); + stopInternal( + /* forceResetRenderers= */ false, + /* resetPositionAndState= */ false, + /* acknowledgeStop= */ false); eventHandler.obtainMessage(MSG_ERROR, ExoPlaybackException.createForSource(e)).sendToTarget(); maybeNotifyPlaybackInfoChanged(); } catch (RuntimeException e) { Log.e(TAG, "Internal runtime error.", e); - stopInternal(/* reset= */ false, /* acknowledgeStop= */ false); + stopInternal( + /* forceResetRenderers= */ true, + /* resetPositionAndState= */ false, + /* acknowledgeStop= */ false); eventHandler.obtainMessage(MSG_ERROR, ExoPlaybackException.createForUnexpected(e)) .sendToTarget(); maybeNotifyPlaybackInfoChanged(); @@ -394,7 +436,8 @@ import java.util.Collections; private void prepareInternal(MediaSource mediaSource, boolean resetPosition, boolean resetState) { pendingPrepareCount++; - resetInternal(/* releaseMediaSource= */ true, resetPosition, resetState); + resetInternal( + /* resetRenderers= */ false, /* releaseMediaSource= */ true, resetPosition, resetState); loadControl.onPrepared(); this.mediaSource = mediaSource; setState(Player.STATE_BUFFERING); @@ -631,7 +674,10 @@ import java.util.Collections; // End playback, as we didn't manage to find a valid seek position. setState(Player.STATE_ENDED); resetInternal( - /* releaseMediaSource= */ false, /* resetPosition= */ true, /* resetState= */ false); + /* resetRenderers= */ false, + /* releaseMediaSource= */ false, + /* resetPosition= */ true, + /* resetState= */ false); } else { // Execute the seek in the current media periods. long newPeriodPositionUs = periodPositionUs; @@ -738,9 +784,33 @@ import java.util.Collections; this.seekParameters = seekParameters; } - private void stopInternal(boolean reset, boolean acknowledgeStop) { + private void setForegroundModeInternal( + boolean foregroundMode, @Nullable AtomicBoolean processedFlag) { + if (this.foregroundMode != foregroundMode) { + this.foregroundMode = foregroundMode; + if (!foregroundMode) { + for (Renderer renderer : renderers) { + if (renderer.getState() == Renderer.STATE_DISABLED) { + renderer.reset(); + } + } + } + } + if (processedFlag != null) { + synchronized (this) { + processedFlag.set(true); + notifyAll(); + } + } + } + + private void stopInternal( + boolean forceResetRenderers, boolean resetPositionAndState, boolean acknowledgeStop) { resetInternal( - /* releaseMediaSource= */ true, /* resetPosition= */ reset, /* resetState= */ reset); + /* resetRenderers= */ forceResetRenderers || !foregroundMode, + /* releaseMediaSource= */ true, + /* resetPosition= */ resetPositionAndState, + /* resetState= */ resetPositionAndState); playbackInfoUpdate.incrementPendingOperationAcks( pendingPrepareCount + (acknowledgeStop ? 1 : 0)); pendingPrepareCount = 0; @@ -750,7 +820,10 @@ import java.util.Collections; private void releaseInternal() { resetInternal( - /* releaseMediaSource= */ true, /* resetPosition= */ true, /* resetState= */ true); + /* resetRenderers= */ true, + /* releaseMediaSource= */ true, + /* resetPosition= */ true, + /* resetState= */ true); loadControl.onReleased(); setState(Player.STATE_IDLE); internalPlaybackThread.quit(); @@ -772,7 +845,10 @@ import java.util.Collections; } private void resetInternal( - boolean releaseMediaSource, boolean resetPosition, boolean resetState) { + boolean resetRenderers, + boolean releaseMediaSource, + boolean resetPosition, + boolean resetState) { handler.removeMessages(MSG_DO_SOME_WORK); rebuffering = false; mediaClock.stop(); @@ -782,7 +858,17 @@ import java.util.Collections; disableRenderer(renderer); } catch (ExoPlaybackException | RuntimeException e) { // There's nothing we can do. - Log.e(TAG, "Stop failed.", e); + Log.e(TAG, "Disable failed.", e); + } + } + if (resetRenderers) { + for (Renderer renderer : renderers) { + try { + renderer.reset(); + } catch (RuntimeException e) { + // There's nothing we can do. + Log.e(TAG, "Reset failed.", e); + } } } enabledRenderers = new Renderer[0]; @@ -989,7 +1075,6 @@ import java.util.Collections; mediaClock.onRendererDisabled(renderer); ensureStopped(renderer); renderer.disable(); - renderer.reset(); } private void reselectTracksInternal() throws ExoPlaybackException { @@ -1294,7 +1379,10 @@ import java.util.Collections; setState(Player.STATE_ENDED); // Reset, but retain the source so that it can still be used should a seek occur. resetInternal( - /* releaseMediaSource= */ false, /* resetPosition= */ true, /* resetState= */ false); + /* resetRenderers= */ false, + /* releaseMediaSource= */ false, + /* resetPosition= */ true, + /* resetState= */ false); } /** @@ -1639,9 +1727,17 @@ import java.util.Collections; throws ExoPlaybackException { enabledRenderers = new Renderer[totalEnabledRendererCount]; int enabledRendererCount = 0; - MediaPeriodHolder playingPeriodHolder = queue.getPlayingPeriod(); + TrackSelectorResult trackSelectorResult = queue.getPlayingPeriod().getTrackSelectorResult(); + // Reset all disabled renderers before enabling any new ones. This makes sure resources released + // by the disabled renderers will be available to renderers that are being enabled. for (int i = 0; i < renderers.length; i++) { - if (playingPeriodHolder.getTrackSelectorResult().isRendererEnabled(i)) { + if (!trackSelectorResult.isRendererEnabled(i)) { + renderers[i].reset(); + } + } + // Enable the renderers. + for (int i = 0; i < renderers.length; i++) { + if (trackSelectorResult.isRendererEnabled(i)) { enableRenderer(i, rendererWasEnabledFlags[i], enabledRendererCount++); } } diff --git a/library/core/src/main/java/com/google/android/exoplayer2/SimpleExoPlayer.java b/library/core/src/main/java/com/google/android/exoplayer2/SimpleExoPlayer.java index 8517556887..4ca6b51ce2 100644 --- a/library/core/src/main/java/com/google/android/exoplayer2/SimpleExoPlayer.java +++ b/library/core/src/main/java/com/google/android/exoplayer2/SimpleExoPlayer.java @@ -958,6 +958,11 @@ public class SimpleExoPlayer extends BasePlayer return player.getSeekParameters(); } + @Override + public void setForegroundMode(boolean foregroundMode) { + player.setForegroundMode(foregroundMode); + } + @Override public void stop(boolean reset) { verifyApplicationThread(); diff --git a/testutils_robolectric/src/main/java/com/google/android/exoplayer2/testutil/StubExoPlayer.java b/testutils_robolectric/src/main/java/com/google/android/exoplayer2/testutil/StubExoPlayer.java index 156b573df8..1ac19591c0 100644 --- a/testutils_robolectric/src/main/java/com/google/android/exoplayer2/testutil/StubExoPlayer.java +++ b/testutils_robolectric/src/main/java/com/google/android/exoplayer2/testutil/StubExoPlayer.java @@ -267,4 +267,9 @@ public abstract class StubExoPlayer extends BasePlayer implements ExoPlayer { public long getContentBufferedPosition() { throw new UnsupportedOperationException(); } + + @Override + public void setForegroundMode(boolean foregroundMode) { + throw new UnsupportedOperationException(); + } }