Add new functionality to Glide for posting Glide onResourceReady callback to the front of the main thread queue after job completion

PiperOrigin-RevId: 767679744

Author: falhassen

library/src/main/java/com/bumptech/glide/RequestBuilder.java

@@ -818,6 +818,19 @@ public <Y extends Target<TranscodeType>> Y into(@NonNull Y target) {
     return into(target, /* targetListener= */ null, Executors.mainThreadExecutor());
   }
 
+  /**
+   * Set the target the resource will be loaded into; the callback will be set at the front of the
+   * queue.
+   *
+   * @param target The target to load the resource into.
+   * @return The given target.
+   * @see RequestManager#clear(Target)
+   */
+  @NonNull
+  public <Y extends Target<TranscodeType>> Y experimentalIntoFront(@NonNull Y target) {
+    return into(target, /* targetListener= */ null, Executors.mainThreadExecutorFront());
+  }
+
   @NonNull
   <Y extends Target<TranscodeType>> Y into(
       @NonNull Y target,
@@ -922,6 +935,57 @@ public ViewTarget<ImageView, TranscodeType> into(@NonNull ImageView view) {
         Executors.mainThreadExecutor());
   }
 
+  /**
+   * Sets the {@link ImageView} the resource will be loaded into, cancels any existing loads into
+   * the view, and frees any resources Glide may have previously loaded into the view so they may be
+   * reused; the callback will be set at the front of the queue.
+   *
+   * @see RequestManager#clear(Target)
+   * @param view The view to cancel previous loads for and load the new resource into.
+   * @return The {@link com.bumptech.glide.request.target.Target} used to wrap the given {@link
+   *     ImageView}.
+   */
+  @NonNull
+  public ViewTarget<ImageView, TranscodeType> experimentalIntoFront(@NonNull ImageView view) {
+    Util.assertMainThread();
+    Preconditions.checkNotNull(view);
+
+    BaseRequestOptions<?> requestOptions = this;
+    if (!requestOptions.isTransformationSet()
+        && requestOptions.isTransformationAllowed()
+        && view.getScaleType() != null) {
+      // Clone in this method so that if we use this RequestBuilder to load into a View and then
+      // into a different target, we don't retain the transformation applied based on the previous
+      // View's scale type.
+      switch (view.getScaleType()) {
+        case CENTER_CROP:
+          requestOptions = requestOptions.clone().optionalCenterCrop();
+          break;
+        case CENTER_INSIDE:
+          requestOptions = requestOptions.clone().optionalCenterInside();
+          break;
+        case FIT_CENTER:
+        case FIT_START:
+        case FIT_END:
+          requestOptions = requestOptions.clone().optionalFitCenter();
+          break;
+        case FIT_XY:
+          requestOptions = requestOptions.clone().optionalCenterInside();
+          break;
+        case CENTER:
+        case MATRIX:
+        default:
+          // Do nothing.
+      }
+    }
+
+    return into(
+        glideContext.buildImageViewTarget(view, transcodeClass),
+        /* targetListener= */ null,
+        requestOptions,
+        Executors.mainThreadExecutorFront());
+  }
+
   /**
    * Returns a future that can be used to do a blocking get on a background thread.
    *
@@ -1001,6 +1065,36 @@ public Target<TranscodeType> preload(int width, int height) {
     return into(target);
   }
 
+  /**
+   * Preloads the resource into the cache using the given width and height; the callback will be set
+   * at the front of the queue.
+   *
+   * <p>Pre-loading is useful for making sure that resources you are going to to want in the near
+   * future are available quickly.
+   *
+   * <p>Note - Any thumbnail request that does not complete before the primary request will be
+   * cancelled and may not be preloaded successfully. Cancellation of outstanding thumbnails after
+   * the primary request succeeds is a common behavior of all Glide requests. We do not try to
+   * prevent that behavior here. If you absolutely need all thumbnails to be preloaded individually,
+   * make separate preload() requests for each thumbnail (you can still combine them into one call
+   * when loading the image(s) into the UI in a subsequent request).
+   *
+   * @param width The desired width in pixels, or {@link Target#SIZE_ORIGINAL}. This will be
+   *     overridden by {@link com.bumptech.glide.request.RequestOptions#override(int, int)} if
+   *     previously called.
+   * @param height The desired height in pixels, or {@link Target#SIZE_ORIGINAL}. This will be
+   *     overridden by {@link com.bumptech.glide.request.RequestOptions#override(int, int)}} if
+   *     previously called).
+   * @return A {@link Target} that can be used to cancel the load via {@link
+   *     RequestManager#clear(Target)}.
+   * @see com.bumptech.glide.ListPreloader
+   */
+  @NonNull
+  public Target<TranscodeType> experimentalPreloadFront(int width, int height) {
+    final PreloadTarget<TranscodeType> target = PreloadTarget.obtain(requestManager, width, height);
+    return experimentalIntoFront(target);
+  }
+
   /**
    * Preloads the resource into the cache using {@link Target#SIZE_ORIGINAL} as the target width and
    * height. Equivalent to calling {@link #preload(int, int)} with {@link Target#SIZE_ORIGINAL} as

library/src/main/java/com/bumptech/glide/util/Executors.java

@@ -19,6 +19,13 @@ public void execute(@NonNull Runnable command) {
           Util.postOnUiThread(command);
         }
       };
+  private static final Executor MAIN_THREAD_EXECUTOR_FRONT =
+      new Executor() {
+        @Override
+        public void execute(@NonNull Runnable command) {
+          Util.postAtFrontOfQueueOnUiThread(command);
+        }
+      };
   private static final Executor DIRECT_EXECUTOR =
       new Executor() {
         @Override
@@ -32,6 +39,11 @@ public static Executor mainThreadExecutor() {
     return MAIN_THREAD_EXECUTOR;
   }
 
+  /** Posts executions to the main thread at the front of the queue. */
+  public static Executor mainThreadExecutorFront() {
+    return MAIN_THREAD_EXECUTOR_FRONT;
+  }
+
   /** Immediately calls {@link Runnable#run()} on the current thread. */
   public static Executor directExecutor() {
     return DIRECT_EXECUTOR;

library/src/main/java/com/bumptech/glide/util/Util.java

@@ -151,6 +151,14 @@ public static void postOnUiThread(Runnable runnable) {
     getUiThreadHandler().post(runnable);
   }
 
+  /**
+   * Posts the given {@code runnable} to the front of the queue on the UI thread using a shared
+   * {@link Handler}.
+   */
+  public static void postAtFrontOfQueueOnUiThread(Runnable runnable) {
+    getUiThreadHandler().postAtFrontOfQueue(runnable);
+  }
+
   /** Removes the given {@code runnable} from the UI threads queue if it is still queued. */
   public static void removeCallbacksOnUiThread(Runnable runnable) {
     getUiThreadHandler().removeCallbacks(runnable);

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

@@ -77,13 +77,25 @@ public void testDoesNotThrowWithNullModelWhenRequestIsBuilt() {
     getNullModelRequest().into(target);
   }
 
+  @Test
+  public void testDoesNotThrowWithNullModelWhenRequestIsBuiltFront() {
+    getNullModelRequest().experimentalIntoFront(target);
+  }
+
   @Test
   public void testAddsNewRequestToRequestTracker() {
     getNullModelRequest().into(target);
 
     verify(requestManager).track(eq(target), isA(Request.class));
   }
 
+  @Test
+  public void testAddsNewRequestToRequestTrackerFront() {
+    getNullModelRequest().experimentalIntoFront(target);
+
+    verify(requestManager).track(eq(target), isA(Request.class));
+  }
+
   @Test
   public void testRemovesPreviousRequestFromRequestTracker() {
     Request previous = mock(Request.class);
@@ -94,17 +106,38 @@ public void testRemovesPreviousRequestFromRequestTracker() {
     verify(requestManager).clear(eq(target));
   }
 
+  @Test
+  public void testRemovesPreviousRequestFromRequestTrackerFront() {
+    Request previous = mock(Request.class);
+    when(target.getRequest()).thenReturn(previous);
+
+    getNullModelRequest().experimentalIntoFront(target);
+
+    verify(requestManager).clear(eq(target));
+  }
+
   @Test(expected = NullPointerException.class)
   public void testThrowsIfGivenNullTarget() {
     //noinspection ConstantConditions testing if @NonNull is enforced
     getNullModelRequest().into((Target<Object>) null);
   }
 
+  @Test(expected = NullPointerException.class)
+  public void testThrowsIfGivenNullTargetFront() {
+    //noinspection ConstantConditions testing if @NonNull is enforced
+    getNullModelRequest().experimentalIntoFront((Target<Object>) null);
+  }
+
   @Test(expected = NullPointerException.class)
   public void testThrowsIfGivenNullView() {
     getNullModelRequest().into((ImageView) null);
   }
 
+  @Test(expected = NullPointerException.class)
+  public void testThrowsIfGivenNullViewFront() {
+    getNullModelRequest().experimentalIntoFront((ImageView) null);
+  }
+
   @Test(expected = RuntimeException.class)
   public void testThrowsIfIntoViewCalledOnBackgroundThread() throws InterruptedException {
     final ImageView imageView = new ImageView(ApplicationProvider.getApplicationContext());
@@ -117,6 +150,18 @@ public void runTest() {
         });
   }
 
+  @Test(expected = RuntimeException.class)
+  public void testThrowsIfIntoViewCalledOnBackgroundThreadFront() throws InterruptedException {
+    final ImageView imageView = new ImageView(ApplicationProvider.getApplicationContext());
+    testInBackground(
+        new BackgroundTester() {
+          @Override
+          public void runTest() {
+            getNullModelRequest().experimentalIntoFront(imageView);
+          }
+        });
+  }
+
   @Test
   public void doesNotThrowIfIntoTargetCalledOnBackgroundThread() throws InterruptedException {
     final Target<Object> target = mock(Target.class);
@@ -129,6 +174,18 @@ public void runTest() {
         });
   }
 
+  @Test
+  public void doesNotThrowIfIntoTargetCalledOnBackgroundThreadFront() throws InterruptedException {
+    final Target<Object> target = mock(Target.class);
+    testInBackground(
+        new BackgroundTester() {
+          @Override
+          public void runTest() {
+            getNullModelRequest().experimentalIntoFront(target);
+          }
+        });
+  }
+
   @Test
   public void testMultipleRequestListeners() {
     getNullModelRequest().addListener(listener1).addListener(listener2).into(target);
@@ -146,6 +203,26 @@ public void testMultipleRequestListeners() {
         .onResourceReady(any(), any(), isA(Target.class), isA(DataSource.class), anyBoolean());
   }
 
+  @Test
+  public void testMultipleRequestListenersFront() {
+    getNullModelRequest()
+        .addListener(listener1)
+        .addListener(listener2)
+        .experimentalIntoFront(target);
+    verify(requestManager).track(any(Target.class), requestCaptor.capture());
+    requestCaptor
+        .getValue()
+        .onResourceReady(
+            new SimpleResource<>(new Object()),
+            DataSource.LOCAL,
+            /* isLoadedFromAlternateCacheKey= */ false);
+
+    verify(listener1)
+        .onResourceReady(any(), any(), isA(Target.class), isA(DataSource.class), anyBoolean());
+    verify(listener2)
+        .onResourceReady(any(), any(), isA(Target.class), isA(DataSource.class), anyBoolean());
+  }
+
   @Test
   public void testListenerApiOverridesListeners() {
     getNullModelRequest().addListener(listener1).listener(listener2).into(target);
@@ -164,6 +241,24 @@ public void testListenerApiOverridesListeners() {
         .onResourceReady(any(), any(), isA(Target.class), isA(DataSource.class), anyBoolean());
   }
 
+  @Test
+  public void testListenerApiOverridesListenersFront() {
+    getNullModelRequest().addListener(listener1).listener(listener2).experimentalIntoFront(target);
+    verify(requestManager).track(any(Target.class), requestCaptor.capture());
+    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())
+        .onResourceReady(any(), any(), isA(Target.class), isA(DataSource.class), anyBoolean());
+    verify(listener2)
+        .onResourceReady(any(), any(), isA(Target.class), isA(DataSource.class), anyBoolean());
+  }
+
   @Test
   public void testEquals() {
     Object firstModel = new Object();