Allow limiting the size of LruBitmapPool/MemoryCache when in background

When an app is moved to background, onTrimMemory() will be called, and LruBitmapPool/MemoryCache will be trimmed. However, the app could keep running and will new bitmaps will be retired to MemoryCache and LruBitmapPool. This change limits the sizes of LruBitmapPool/MemoryCache to zero when the app is in background, and restore the sizes to normal when it's moved out of background.

We introduce an experimental API `setMemoryCategoryInBackground(MemoryCategory)` for this purpose, as well as a new `MemoryCategory.ZERO` for no pooling/caching. App can use this API to set the MemoryCategory to limit the pool/cache size when the app is in background.

PiperOrigin-RevId: 856285259

Author: falhassen

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

@@ -1,10 +1,12 @@
 package com.bumptech.glide;
 
 import android.app.Activity;
+import android.app.Application;
 import android.content.ComponentCallbacks2;
 import android.content.Context;
 import android.content.res.Configuration;
 import android.graphics.Bitmap;
+import android.os.Bundle;
 import android.os.MessageQueue.IdleHandler;
 import android.util.Log;
 import android.view.View;
@@ -33,6 +35,7 @@
 import com.bumptech.glide.request.RequestOptions;
 import com.bumptech.glide.request.target.ImageViewTargetFactory;
 import com.bumptech.glide.request.target.Target;
+import com.bumptech.glide.util.GlideSuppliers;
 import com.bumptech.glide.util.GlideSuppliers.GlideSupplier;
 import com.bumptech.glide.util.Preconditions;
 import com.bumptech.glide.util.Util;
@@ -81,6 +84,13 @@ public class Glide implements ComponentCallbacks2 {
   @Nullable
   private BitmapPreFiller bitmapPreFiller;
 
+  private boolean inBackground = false;
+  private MemoryCategory memoryCategoryInBackground = null;
+  private MemoryCategory memoryCategoryInForeground = MemoryCategory.NORMAL;
+
+  private final GlideSupplier<SetMemoryCategoryOnLifecycleCallbacks> setMemoryCategoryCallbacks =
+      GlideSuppliers.memorize(SetMemoryCategoryOnLifecycleCallbacks::new);
+
   /**
    * Returns a directory with a default name in the private cache directory of the application to
    * use to store retrieved media and thumbnails.
@@ -206,6 +216,7 @@ public static void tearDown() {
     synchronized (Glide.class) {
       if (glide != null) {
         glide.getContext().getApplicationContext().unregisterComponentCallbacks(glide);
+        glide.unregisterActivityLifecycleCallbacks();
         glide.engine.shutdown();
       }
       glide = null;
@@ -265,6 +276,7 @@ private static void initializeGlide(
     }
     Glide glide = builder.build(applicationContext, manifestModules, annotationGeneratedModule);
     applicationContext.registerComponentCallbacks(glide);
+    glide.registerActivityLifecycleCallbacks();
     Glide.glide = glide;
   }
 
@@ -332,6 +344,12 @@ private static void throwIncorrectGlideModule(Exception e) {
     this.connectivityMonitorFactory = connectivityMonitorFactory;
     this.defaultRequestOptionsFactory = defaultRequestOptionsFactory;
 
+    GlideBuilder.MemoryCategoryInBackground memoryCategoryInBackground =
+        experiments.get(GlideBuilder.MemoryCategoryInBackground.class);
+    if (memoryCategoryInBackground != null) {
+      this.memoryCategoryInBackground = memoryCategoryInBackground.value();
+    }
+
     // This has a circular relationship with Glide and GlideContext in that it depends on both,
     // but it's created by Glide's constructor. In practice this shouldn't matter because the
     // supplier holding the registry should never be initialized before this constructor finishes.
@@ -678,6 +696,11 @@ void unregisterRequestManager(RequestManager requestManager) {
   @Override
   public void onTrimMemory(int level) {
     trimMemory(level);
+    // when level is TRIM_MEMORY_UI_HIDDEN or higher, it indicates that the app is
+    // in the background, limit the memory usage by memoryCategoryInBackground.
+    if (level >= TRIM_MEMORY_UI_HIDDEN) {
+      setMemoryCategoryWhenInBackground();
+    }
   }
 
   @Override
@@ -697,4 +720,85 @@ public interface RequestOptionsFactory {
     @NonNull
     RequestOptions build();
   }
+
+  private void registerActivityLifecycleCallbacks() {
+    if (memoryCategoryInBackground != null) {
+      Context context = getContext().getApplicationContext();
+      if (!(context instanceof Application) && Log.isLoggable(TAG, Log.WARN)) {
+        Log.w(
+            TAG,
+            "Glide requires an Application Context. You passed: "
+                + context
+                + ". This will disable setting memory category in background.");
+        return;
+      }
+      ((Application) context).registerActivityLifecycleCallbacks(setMemoryCategoryCallbacks.get());
+    }
+  }
+
+  private void unregisterActivityLifecycleCallbacks() {
+    if (memoryCategoryInBackground != null) {
+      Context context = getContext().getApplicationContext();
+      if (context instanceof Application) {
+        ((Application) context)
+            .unregisterActivityLifecycleCallbacks(setMemoryCategoryCallbacks.get());
+      }
+    }
+  }
+
+  private void setMemoryCategoryWhenInBackground() {
+    if (memoryCategoryInBackground == null || inBackground) {
+      return;
+    }
+    inBackground = true;
+    memoryCategoryInForeground = setMemoryCategory(memoryCategoryInBackground);
+  }
+
+  private void setMemoryCategoryWhenInForeground() {
+    if (memoryCategoryInBackground == null || !inBackground) {
+      return;
+    }
+    inBackground = false;
+    setMemoryCategory(memoryCategoryInForeground);
+  }
+
+  private final class SetMemoryCategoryOnLifecycleCallbacks
+      implements Application.ActivityLifecycleCallbacks {
+    @Override
+    public void onActivityStarted(Activity activity) {
+      // Do nothing.
+    }
+
+    @Override
+    public void onActivityResumed(Activity activity) {
+      // Any activity resumed indicates that the app is no longer in the background,
+      // and we should restore the memory usage to normal.
+      setMemoryCategoryWhenInForeground();
+    }
+
+    @Override
+    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
+      // Do nothing.
+    }
+
+    @Override
+    public void onActivityDestroyed(Activity activity) {
+      // Do nothing.
+    }
+
+    @Override
+    public void onActivityStopped(Activity activity) {
+      // Do nothing.
+    }
+
+    @Override
+    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
+      // Do nothing.
+    }
+
+    @Override
+    public void onActivityPaused(Activity activity) {
+      // Do nothing.
+    }
+  }
 }

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

@@ -512,6 +512,17 @@ public GlideBuilder setUseMediaStoreOpenFileApisIfPossible(boolean isEnabled) {
     return this;
   }
 
+  /**
+   * Set to {@code true} to make Glide use {@link MemoryCategory} to set the memory category when
+   * the app is in the background.
+   *
+   * <p>This is an experimental API that may be removed in the future.
+   */
+  public GlideBuilder setMemoryCategoryInBackground(MemoryCategory memoryCategory) {
+    glideExperimentsBuilder.add(new MemoryCategoryInBackground(memoryCategory));
+    return this;
+  }
+
   /**
    * @deprecated This method does nothing. It will be hard coded and removed in a future release
    *     without further warning.
@@ -653,4 +664,17 @@ public static final class OverrideGlideThreadPriority implements Experiment {}
 
   /** See {@link #setUseMediaStoreOpenFileApisIfPossible(boolean)}. */
   public static final class UseMediaStoreOpenFileApisIfPossible implements Experiment {}
+
+  /** See {@link #setMemoryCategoryInBackground(MemoryCategory)} */
+  public static final class MemoryCategoryInBackground implements Experiment {
+    private final MemoryCategory memoryCategory;
+
+    MemoryCategoryInBackground(MemoryCategory memoryCategory) {
+      this.memoryCategory = memoryCategory;
+    }
+
+    public MemoryCategory value() {
+      return memoryCategory;
+    }
+  }
 }

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

@@ -2,6 +2,8 @@
 
 /** An enum for dynamically modifying the amount of memory Glide is able to use. */
 public enum MemoryCategory {
+  /** Tells Glide's memory cache and bitmap pool to use no memory. */
+  ZERO(0f),
   /**
    * Tells Glide's memory cache and bitmap pool to use at most half of their initial maximum size.
    */