[PreCacheHelper] Start downloader after loaders for preparing released

This is only applied to progressive media only.

#cherrypick

PiperOrigin-RevId: 778856425
(cherry picked from commit b8066f9)

Author: tianyif

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/offline/DownloadHelper.java

@@ -75,8 +75,10 @@
 import androidx.media3.exoplayer.upstream.Allocator;
 import androidx.media3.exoplayer.upstream.BandwidthMeter;
 import androidx.media3.exoplayer.upstream.DefaultAllocator;
+import androidx.media3.exoplayer.util.ReleasableExecutor;
 import androidx.media3.extractor.ExtractorsFactory;
 import androidx.media3.extractor.SeekMap;
+import com.google.common.base.Supplier;
 import com.google.common.collect.ImmutableList;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import java.io.IOException;
@@ -118,11 +120,13 @@ public static final class Factory {
     @Nullable private RenderersFactory renderersFactory;
     private TrackSelectionParameters trackSelectionParameters;
     @Nullable private DrmSessionManager drmSessionManager;
+    @Nullable private Supplier<ReleasableExecutor> loadExecutorSupplier;
     private boolean debugLoggingEnabled;
 
     /** Creates a {@link Factory}. */
     public Factory() {
       this.trackSelectionParameters = DEFAULT_TRACK_SELECTOR_PARAMETERS;
+      loadExecutorSupplier = null;
     }
 
     /**
@@ -181,6 +185,21 @@ public Factory setDrmSessionManager(@Nullable DrmSessionManager drmSessionManage
       return this;
     }
 
+    /**
+     * Sets a supplier for an {@link ReleasableExecutor} that is used for loading the media.
+     *
+     * <p>This is only used for progressive streams.
+     *
+     * @param loadExecutor A {@link Supplier} that provides an externally managed {@link
+     *     ReleasableExecutor} for loading.
+     * @return This factory, for convenience.
+     */
+    @CanIgnoreReturnValue
+    public Factory setLoadExecutor(Supplier<ReleasableExecutor> loadExecutor) {
+      this.loadExecutorSupplier = loadExecutor;
+      return this;
+    }
+
     /**
      * Sets whether to log debug information. The default is {@code false}.
      *
@@ -209,7 +228,10 @@ public DownloadHelper create(MediaItem mediaItem) {
           isProgressive && dataSourceFactory == null
               ? null
               : createMediaSourceInternal(
-                  mediaItem, castNonNull(dataSourceFactory), drmSessionManager),
+                  mediaItem,
+                  castNonNull(dataSourceFactory),
+                  drmSessionManager,
+                  loadExecutorSupplier),
           trackSelectionParameters,
           renderersFactory != null
               ? new DefaultRendererCapabilitiesList.Factory(renderersFactory)
@@ -461,7 +483,10 @@ public static MediaSource createMediaSource(
       DataSource.Factory dataSourceFactory,
       @Nullable DrmSessionManager drmSessionManager) {
     return createMediaSourceInternal(
-        downloadRequest.toMediaItem(), dataSourceFactory, drmSessionManager);
+        downloadRequest.toMediaItem(),
+        dataSourceFactory,
+        drmSessionManager,
+        /* loadExecutorSupplier= */ null);
   }
 
   private static final String TAG = "DownloadHelper";
@@ -1185,11 +1210,19 @@ private TrackSelectorResult runTrackSelection(int periodIndex) throws ExoPlaybac
   private static MediaSource createMediaSourceInternal(
       MediaItem mediaItem,
       DataSource.Factory dataSourceFactory,
-      @Nullable DrmSessionManager drmSessionManager) {
-    MediaSource.Factory mediaSourceFactory =
-        isProgressive(checkNotNull(mediaItem.localConfiguration))
-            ? new ProgressiveMediaSource.Factory(dataSourceFactory)
-            : new DefaultMediaSourceFactory(dataSourceFactory, ExtractorsFactory.EMPTY);
+      @Nullable DrmSessionManager drmSessionManager,
+      @Nullable Supplier<ReleasableExecutor> loadExecutorSupplier) {
+    MediaSource.Factory mediaSourceFactory;
+    if (isProgressive(checkNotNull(mediaItem.localConfiguration))) {
+      mediaSourceFactory = new ProgressiveMediaSource.Factory(dataSourceFactory);
+      if (loadExecutorSupplier != null) {
+        ((ProgressiveMediaSource.Factory) mediaSourceFactory)
+            .setDownloadExecutor(loadExecutorSupplier);
+      }
+    } else {
+      mediaSourceFactory =
+          new DefaultMediaSourceFactory(dataSourceFactory, ExtractorsFactory.EMPTY);
+    }
     if (drmSessionManager != null) {
       mediaSourceFactory.setDrmSessionManagerProvider(unusedMediaItem -> drmSessionManager);
     }

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ProgressiveMediaSource.java

@@ -259,8 +259,21 @@ public Factory setDrmSessionManagerProvider(
     @CanIgnoreReturnValue
     public <T extends Executor> Factory setDownloadExecutor(
         Supplier<T> downloadExecutor, Consumer<T> downloadExecutorReleaser) {
-      this.downloadExecutorSupplier =
-          () -> ReleasableExecutor.from(downloadExecutor.get(), downloadExecutorReleaser);
+      setDownloadExecutor(
+          () -> ReleasableExecutor.from(downloadExecutor.get(), downloadExecutorReleaser));
+      return this;
+    }
+
+    /**
+     * Sets a supplier for an {@link ReleasableExecutor} that is used for loading the media.
+     *
+     * @param downloadExecutor A {@link Supplier} that provides an externally managed {@link
+     *     ReleasableExecutor} for downloading and extraction.
+     * @return This factory, for convenience.
+     */
+    @CanIgnoreReturnValue
+    public MediaSource.Factory setDownloadExecutor(Supplier<ReleasableExecutor> downloadExecutor) {
+      this.downloadExecutorSupplier = downloadExecutor;
       return this;
     }
 

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/preload/PreCacheHelper.java

@@ -43,11 +43,14 @@
 import androidx.media3.exoplayer.offline.Downloader;
 import androidx.media3.exoplayer.offline.DownloaderFactory;
 import androidx.media3.exoplayer.source.MediaSource;
+import androidx.media3.exoplayer.util.ReleasableExecutor;
 import com.google.common.base.Supplier;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import java.io.IOException;
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
 
 /** A helper for pre-caching a single media. */
 @UnstableApi
@@ -260,7 +263,7 @@ public PreCacheHelper create(MediaItem mediaItem) {
           new DefaultDownloaderFactory(cacheDataSourceFactory, downloadExecutor);
       return new PreCacheHelper(
           mediaItem,
-          /* mediaSourceFactory= */ null,
+          /* testMediaSourceFactory= */ null,
           downloadHelperFactory,
           downloaderFactory,
           preCacheLooper,
@@ -271,7 +274,9 @@ public PreCacheHelper create(MediaItem mediaItem) {
   @VisibleForTesting /* package */ static final int DEFAULT_MIN_RETRY_COUNT = 5;
 
   private final MediaItem mediaItem;
-  private final Supplier<DownloadHelper> downloadHelperSupplier;
+
+  @Nullable private final MediaSource.Factory testMediaSourceFactory;
+  private final DownloadHelper.Factory downloadHelperFactory;
   private final DownloaderFactory downloaderFactory;
   @Nullable private final Listener listener;
   private final Handler preCacheHandler;
@@ -280,17 +285,14 @@ public PreCacheHelper create(MediaItem mediaItem) {
 
   /* package */ PreCacheHelper(
       MediaItem mediaItem,
-      @Nullable MediaSource.Factory mediaSourceFactory,
+      @Nullable MediaSource.Factory testMediaSourceFactory,
       DownloadHelper.Factory downloadHelperFactory,
       DownloaderFactory downloaderFactory,
       Looper preCacheLooper,
       @Nullable Listener listener) {
     this.mediaItem = mediaItem;
-    this.downloadHelperSupplier =
-        () ->
-            mediaSourceFactory != null
-                ? downloadHelperFactory.create(mediaSourceFactory.createMediaSource(mediaItem))
-                : downloadHelperFactory.create(mediaItem);
+    this.testMediaSourceFactory = testMediaSourceFactory;
+    this.downloadHelperFactory = downloadHelperFactory;
     this.downloaderFactory = downloaderFactory;
     this.listener = listener;
     this.preCacheHandler = Util.createHandler(preCacheLooper, /* callback= */ null);
@@ -352,14 +354,84 @@ public void release(boolean removeCachedContent) {
         });
   }
 
+  private static final class ReleasableSingleThreadExecutor implements ReleasableExecutor {
+
+    private final ExecutorService executor;
+    private final Runnable releaseRunnable;
+
+    private ReleasableSingleThreadExecutor(Runnable releaseRunnable) {
+      this.executor = Util.newSingleThreadExecutor("PreCacheHelper:Loader");
+      this.releaseRunnable = releaseRunnable;
+    }
+
+    @Override
+    public void release() {
+      execute(releaseRunnable);
+      executor.shutdown();
+    }
+
+    @Override
+    public void execute(Runnable command) {
+      executor.execute(command);
+    }
+  }
+
+  private static final class ReleasableExecutorSupplier implements Supplier<ReleasableExecutor> {
+    private final Handler preCacheHandler;
+    private @MonotonicNonNull DownloadCallback downloadCallback;
+
+    @GuardedBy("this")
+    private int executorCount;
+
+    private ReleasableExecutorSupplier(Handler preCacheHandler) {
+      this.preCacheHandler = preCacheHandler;
+    }
+
+    public void setDownloadCallback(DownloadCallback downloadCallback) {
+      this.downloadCallback = downloadCallback;
+    }
+
+    @Override
+    public ReleasableSingleThreadExecutor get() {
+      synchronized (ReleasableExecutorSupplier.this) {
+        executorCount++;
+      }
+      return new ReleasableSingleThreadExecutor(this::onExecutorReleased);
+    }
+
+    private void onExecutorReleased() {
+      synchronized (ReleasableExecutorSupplier.this) {
+        checkState(executorCount > 0);
+        executorCount--;
+        if (wereExecutorsReleased()) {
+          preCacheHandler.post(
+              () -> {
+                checkState(wereExecutorsReleased());
+                if (downloadCallback != null) {
+                  downloadCallback.maybeSubmitPendingDownloadRequest();
+                }
+              });
+        }
+      }
+    }
+
+    public boolean wereExecutorsReleased() {
+      synchronized (ReleasableExecutorSupplier.this) {
+        return executorCount == 0;
+      }
+    }
+  }
+
   private final class DownloadCallback implements DownloadHelper.Callback {
 
     private final Object lock;
     private final long startPositionMs;
     private final long durationMs;
+    @Nullable private final ReleasableExecutorSupplier releasableExecutorSupplier;
     private final DownloadHelper downloadHelper;
 
     private boolean isPreparationOngoing;
+    @Nullable private DownloadRequest pendingDownloadRequest;
     @Nullable private Downloader downloader;
     @Nullable private Task downloaderTask;
 
@@ -371,7 +443,16 @@ public DownloadCallback(long startPositionMs, long durationMs) {
       this.lock = new Object();
       this.startPositionMs = startPositionMs;
       this.durationMs = durationMs;
-      this.downloadHelper = downloadHelperSupplier.get();
+      if (testMediaSourceFactory != null) {
+        this.releasableExecutorSupplier = null;
+        this.downloadHelper =
+            downloadHelperFactory.create(testMediaSourceFactory.createMediaSource(mediaItem));
+      } else {
+        this.releasableExecutorSupplier = new ReleasableExecutorSupplier(preCacheHandler);
+        downloadHelperFactory.setLoadExecutor(releasableExecutorSupplier);
+        this.downloadHelper = downloadHelperFactory.create(mediaItem);
+        this.releasableExecutorSupplier.setDownloadCallback(this);
+      }
       this.isPreparationOngoing = true;
       this.downloadHelper.prepare(this);
     }
@@ -386,14 +467,11 @@ public void onPrepared(DownloadHelper helper, boolean tracksInfoAvailable) {
       downloadHelper.release();
       MediaItem updatedMediaItem = downloadRequest.toMediaItem(mediaItem.buildUpon());
       notifyListeners(listener -> listener.onPrepared(mediaItem, updatedMediaItem));
-      downloader = downloaderFactory.createDownloader(downloadRequest);
-      downloaderTask =
-          new Task(
-              downloader,
-              /* isRemove= */ false,
-              DEFAULT_MIN_RETRY_COUNT,
-              /* downloadCallback= */ this);
-      downloaderTask.start();
+      pendingDownloadRequest = downloadRequest;
+      if (releasableExecutorSupplier == null
+          || releasableExecutorSupplier.wereExecutorsReleased()) {
+        maybeSubmitPendingDownloadRequest();
+      }
     }
 
     @Override
@@ -405,6 +483,21 @@ public void onPrepareError(DownloadHelper helper, IOException e) {
       notifyListeners(listener -> listener.onPrepareError(mediaItem, e));
     }
 
+    public void maybeSubmitPendingDownloadRequest() {
+      checkState(Looper.myLooper() == preCacheHandler.getLooper());
+      if (pendingDownloadRequest != null) {
+        downloader = downloaderFactory.createDownloader(pendingDownloadRequest);
+        downloaderTask =
+            new Task(
+                downloader,
+                /* isRemove= */ false,
+                DEFAULT_MIN_RETRY_COUNT,
+                /* downloadCallback= */ this);
+        downloaderTask.start();
+        pendingDownloadRequest = null;
+      }
+    }
+
     public void onDownloadStopped(Task task) {
       preCacheHandler.post(
           () -> {
@@ -440,6 +533,7 @@ public void cancel(boolean removeCachedContent) {
       synchronized (lock) {
         isCanceled = true;
       }
+      pendingDownloadRequest = null;
       downloadHelper.release();
       if (downloaderTask != null && downloaderTask.isRemove) {
         return;

libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/preload/PreCacheHelperTest.java

@@ -74,7 +74,6 @@
 import java.util.concurrent.atomic.AtomicReference;
 import org.junit.After;
 import org.junit.Before;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
@@ -113,7 +112,6 @@ public void tearDown() {
   }
 
   @Test
-  @Ignore("TODO: Fix the flakiness of this test and re-enable it")
   public void preCache_succeeds() throws Exception {
     PreCacheHelper preCacheHelper =
         new PreCacheHelper.Factory(
@@ -931,7 +929,7 @@ public void releaseWithRemovingCachedContent_whileDownloadOngoing_downloaderCanc
     PreCacheHelper preCacheHelper =
         new PreCacheHelper(
             mediaItem,
-            /* mediaSourceFactory= */ null,
+            /* testMediaSourceFactory= */ null,
             downloadHelperFactory,
             fakeDownloaderFactory,
             preCacheLooper,
@@ -965,7 +963,7 @@ public void releaseWithRemovingCachedContent_whileRemoveOngoing_doNotCancelDownl
     PreCacheHelper preCacheHelper =
         new PreCacheHelper(
             mediaItem,
-            /* mediaSourceFactory= */ null,
+            /* testMediaSourceFactory= */ null,
             downloadHelperFactory,
             fakeDownloaderFactory,
             preCacheLooper,