Add isAlternateCacheKey to a new ExperimentalRequestListener interface.

PiperOrigin-RevId: 319301011

Author: sjudd

library/src/main/java/com/bumptech/glide/load/engine/DecodeJob.java

@@ -76,6 +76,7 @@ class DecodeJob<R>
   private volatile DataFetcherGenerator currentGenerator;
   private volatile boolean isCallbackNotified;
   private volatile boolean isCancelled;
+  private boolean isLoadingFromAlternateCacheKey;
 
   DecodeJob(DiskCacheProvider diskCacheProvider, Pools.Pool<DecodeJob<?>> pool) {
     this.diskCacheProvider = diskCacheProvider;
@@ -332,9 +333,10 @@ private void notifyFailed() {
     onLoadFailed();
   }
 
-  private void notifyComplete(Resource<R> resource, DataSource dataSource) {
+  private void notifyComplete(
+      Resource<R> resource, DataSource dataSource, boolean isLoadedFromAlternateCacheKey) {
     setNotifiedOrThrow();
-    callback.onResourceReady(resource, dataSource);
+    callback.onResourceReady(resource, dataSource, isLoadedFromAlternateCacheKey);
   }
 
   private void setNotifiedOrThrow() {
@@ -381,6 +383,8 @@ public void onDataFetcherReady(
     this.currentFetcher = fetcher;
     this.currentDataSource = dataSource;
     this.currentAttemptingKey = attemptedKey;
+    this.isLoadingFromAlternateCacheKey = sourceKey != decodeHelper.getCacheKeys().get(0);
+
     if (Thread.currentThread() != currentThread) {
       runReason = RunReason.DECODE_DATA;
       callback.reschedule(this);
@@ -429,13 +433,14 @@ private void decodeFromRetrievedData() {
       throwables.add(e);
     }
     if (resource != null) {
-      notifyEncodeAndRelease(resource, currentDataSource);
+      notifyEncodeAndRelease(resource, currentDataSource, isLoadingFromAlternateCacheKey);
     } else {
       runGenerators();
     }
   }
 
-  private void notifyEncodeAndRelease(Resource<R> resource, DataSource dataSource) {
+  private void notifyEncodeAndRelease(
+      Resource<R> resource, DataSource dataSource, boolean isLoadedFromAlternateCacheKey) {
     if (resource instanceof Initializable) {
       ((Initializable) resource).initialize();
     }
@@ -447,7 +452,7 @@ private void notifyEncodeAndRelease(Resource<R> resource, DataSource dataSource)
       result = lockedResource;
     }
 
-    notifyComplete(result, dataSource);
+    notifyComplete(result, dataSource, isLoadedFromAlternateCacheKey);
 
     stage = Stage.ENCODE;
     try {
@@ -710,7 +715,8 @@ void clear() {
 
   interface Callback<R> {
 
-    void onResourceReady(Resource<R> resource, DataSource dataSource);
+    void onResourceReady(
+        Resource<R> resource, DataSource dataSource, boolean isLoadedFromAlternateCacheKey);
 
     void onLoadFailed(GlideException e);
 

library/src/main/java/com/bumptech/glide/load/engine/Engine.java

@@ -217,7 +217,8 @@ public <R> LoadStatus load(
 
     // Avoid calling back while holding the engine lock, doing so makes it easier for callers to
     // deadlock.
-    cb.onResourceReady(memoryResource, DataSource.MEMORY_CACHE);
+    cb.onResourceReady(
+        memoryResource, DataSource.MEMORY_CACHE, /* isLoadedFromAlternateCacheKey= */ false);
     return null;
   }
 

library/src/main/java/com/bumptech/glide/load/engine/EngineJob.java

@@ -69,6 +69,7 @@ class EngineJob<R> implements DecodeJob.Callback<R>, Poolable {
 
   // Checked primarily on the main thread, but also on other threads in reschedule.
   private volatile boolean isCancelled;
+  private boolean isLoadedFromAlternateCacheKey;
 
   EngineJob(
       GlideExecutor diskCacheExecutor,
@@ -155,7 +156,7 @@ void callCallbackOnResourceReady(ResourceCallback cb) {
       // This is overly broad, some Glide code is actually called here, but it's much
       // simpler to encapsulate here than to do so at the actual call point in the
       // Request implementation.
-      cb.onResourceReady(engineResource, dataSource);
+      cb.onResourceReady(engineResource, dataSource, isLoadedFromAlternateCacheKey);
     } catch (Throwable t) {
       throw new CallbackException(t);
     }
@@ -304,6 +305,7 @@ private synchronized void release() {
     hasLoadFailed = false;
     isCancelled = false;
     hasResource = false;
+    isLoadedFromAlternateCacheKey = false;
     decodeJob.release(/*isRemovedFromQueue=*/ false);
     decodeJob = null;
     exception = null;
@@ -312,10 +314,12 @@ private synchronized void release() {
   }
 
   @Override
-  public void onResourceReady(Resource<R> resource, DataSource dataSource) {
+  public void onResourceReady(
+      Resource<R> resource, DataSource dataSource, boolean isLoadedFromAlternateCacheKey) {
     synchronized (this) {
       this.resource = resource;
       this.dataSource = dataSource;
+      this.isLoadedFromAlternateCacheKey = isLoadedFromAlternateCacheKey;
     }
     notifyCallbacksOfResult();
   }

library/src/main/java/com/bumptech/glide/request/ExperimentalRequestListener.java

@@ -0,0 +1,36 @@
+package com.bumptech.glide.request;
+
+import com.bumptech.glide.load.DataSource;
+import com.bumptech.glide.request.target.Target;
+
+/**
+ * An extension of {@link RequestListener} with additional parameters.
+ *
+ * <p>All equivalent methods are called at the relevant time by Glide. Implementations therefore
+ * should only implement one version of each method.
+ *
+ * @param <ResourceT> The type of resource that will be loaded for the request.
+ * @deprecated Not ready for public consumption, avoid using this class. It may be removed at any
+ *     time.
+ */
+@Deprecated
+public abstract class ExperimentalRequestListener<ResourceT> implements RequestListener<ResourceT> {
+
+  /**
+   * Identical to {@link #onResourceReady(Object, Object, Target, DataSource, boolean)} except that
+   * {@code isAlternateCacheKey} is provided.
+   *
+   * @param isAlternateCacheKey True if the data was obtained from the disk cache using an alternate
+   *     cache key provided by a {@link com.bumptech.glide.load.model.ModelLoader} via {@link
+   *     com.bumptech.glide.load.model.ModelLoader.LoadData#alternateKeys}. Valid only if {@code
+   *     dataSource} is {@link DataSource#DATA_DISK_CACHE} or {@link
+   *     DataSource#RESOURCE_DISK_CACHE}.
+   */
+  public abstract boolean onResourceReady(
+      ResourceT resource,
+      Object model,
+      Target<ResourceT> target,
+      DataSource dataSource,
+      boolean isFirstResource,
+      boolean isAlternateCacheKey);
+}

library/src/main/java/com/bumptech/glide/request/ResourceCallback.java

@@ -15,7 +15,8 @@ public interface ResourceCallback {
    *
    * @param resource The loaded resource.
    */
-  void onResourceReady(Resource<?> resource, DataSource dataSource);
+  void onResourceReady(
+      Resource<?> resource, DataSource dataSource, boolean isLoadedFromAlternateCacheKey);
 
   /**
    * Called when a resource fails to load successfully.

library/src/main/java/com/bumptech/glide/request/SingleRequest.java

@@ -237,7 +237,8 @@ public void begin() {
       // that the view size has changed will need to explicitly clear the View or Target before
       // starting the new load.
       if (status == Status.COMPLETE) {
-        onResourceReady(resource, DataSource.MEMORY_CACHE);
+        onResourceReady(
+            resource, DataSource.MEMORY_CACHE, /* isLoadedFromAlternateCacheKey= */ false);
         return;
       }
 
@@ -520,7 +521,8 @@ private void notifyLoadFailed() {
   /** A callback method that should never be invoked directly. */
   @SuppressWarnings("unchecked")
   @Override
-  public void onResourceReady(Resource<?> resource, DataSource dataSource) {
+  public void onResourceReady(
+      Resource<?> resource, DataSource dataSource, boolean isLoadedFromAlternateCacheKey) {
     stateVerifier.throwIfRecycled();
     Resource<?> toRelease = null;
     try {
@@ -572,7 +574,8 @@ public void onResourceReady(Resource<?> resource, DataSource dataSource) {
           return;
         }
 
-        onResourceReady((Resource<R>) resource, (R) received, dataSource);
+        onResourceReady(
+            (Resource<R>) resource, (R) received, dataSource, isLoadedFromAlternateCacheKey);
       }
     } finally {
       if (toRelease != null) {
@@ -582,14 +585,18 @@ public void onResourceReady(Resource<?> resource, DataSource dataSource) {
   }
 
   /**
-   * Internal {@link #onResourceReady(Resource, DataSource)} where arguments are known to be safe.
+   * Internal {@link #onResourceReady(Resource, DataSource, boolean)} where arguments are known to
+   * be safe.
    *
    * @param resource original {@link Resource}, never <code>null</code>
    * @param result object returned by {@link Resource#get()}, checked for type and never <code>null
    *     </code>
    */
+  // We're using experimental APIs...
+  @SuppressWarnings({"deprecation", "PMD.UnusedFormalParameter"})
   @GuardedBy("requestLock")
-  private void onResourceReady(Resource<R> resource, R result, DataSource dataSource) {
+  private void onResourceReady(
+      Resource<R> resource, R result, DataSource dataSource, boolean isAlternateCacheKey) {
     // We must call isFirstReadyResource before setting status.
     boolean isFirstResource = isFirstReadyResource();
     status = Status.COMPLETE;

library/test/src/test/java/com/bumptech/glide/RequestBuilderTest.java

@@ -128,7 +128,12 @@ public void runTest() {
   public void testMultipleRequestListeners() {
     getNullModelRequest().addListener(listener1).addListener(listener2).into(target);
     verify(requestManager).track(any(Target.class), requestCaptor.capture());
-    requestCaptor.getValue().onResourceReady(new SimpleResource<>(new Object()), DataSource.LOCAL);
+    requestCaptor
+        .getValue()
+        .onResourceReady(
+            new SimpleResource<>(new Object()),
+            DataSource.LOCAL,
+            /*isLoadedFromAlternateCacheKey=*/ false);
 
     verify(listener1)
         .onResourceReady(any(), any(), isA(Target.class), isA(DataSource.class), anyBoolean());
@@ -140,7 +145,12 @@ public void testMultipleRequestListeners() {
   public void testListenerApiOverridesListeners() {
     getNullModelRequest().addListener(listener1).listener(listener2).into(target);
     verify(requestManager).track(any(Target.class), requestCaptor.capture());
-    requestCaptor.getValue().onResourceReady(new SimpleResource<>(new Object()), DataSource.LOCAL);
+    requestCaptor
+        .getValue()
+        .onResourceReady(
+            new SimpleResource<>(new Object()),
+            DataSource.LOCAL,
+            /*isLoadedFromAlternateCacheKey=*/ false);
 
     // The #listener API removes any previous listeners, so the first listener should not be called.
     verify(listener1, never())