Add optional offer-back "second-life" ring to WeakBitmapCountingMemoryCache

Reviewed By: Nehgupta-1203

Differential Revision: D107394433

fbshipit-source-id: 0da014f74e9bc8b799165ca2844784edad679ccc

Author: oprisnik

imagepipeline-base/src/main/java/com/facebook/imagepipeline/cache/MemoryCache.kt

@@ -40,6 +40,22 @@ interface MemoryCache<K, V> : MemoryTrimmable, HasDebugData {
    */
   fun cache(key: K, value: CloseableReference<V>): CloseableReference<V>?
 
+  /**
+   * Caches a value that is being released by its last UI holder — i.e. Vito's "offer-back" on
+   * detach (see [com.facebook.imagepipeline.core.ImagePipeline.returnImageToCache]).
+   *
+   * Defaults to [cache]. GC-managed caches that hold values only weakly may override this to give
+   * the released value a bounded strong-reference "second life", so it survives GC long enough to
+   * be re-served on scroll-back without raising steady-state peak memory.
+   *
+   * Wrapping/delegating caches MUST forward this to their delegate(s) rather than inheriting the
+   * default — otherwise the override on the wrapped cache is never reached.
+   *
+   * @return a new reference to be used, or null if the caching failed
+   */
+  fun cacheOnRelease(key: K, value: CloseableReference<V>): CloseableReference<V>? =
+      cache(key, value)
+
   /**
    * Gets the item with the given key, or null if there is no such item.
    *

imagepipeline/src/main/java/com/facebook/imagepipeline/cache/InstrumentedMemoryCache.java

@@ -52,6 +52,12 @@ public void probe(K key) {
     return mDelegate.cache(key, value);
   }
 
+  @Override
+  public @Nullable CloseableReference<V> cacheOnRelease(K key, CloseableReference<V> value) {
+    mTracker.onCachePut(key);
+    return mDelegate.cacheOnRelease(key, value);
+  }
+
   @Override
   public int removeAll(Predicate<K> predicate) {
     return mDelegate.removeAll(predicate);

imagepipeline/src/main/java/com/facebook/imagepipeline/cache/RoutingBitmapMemoryCache.kt

@@ -51,6 +51,18 @@ class RoutingBitmapMemoryCache(
     }
   }
 
+  override fun cacheOnRelease(
+      key: CacheKey,
+      value: CloseableReference<CloseableImage>,
+  ): CloseableReference<CloseableImage>? {
+    val image = value.get() ?: return null
+    return if (image is CloseableBitmap) {
+      bitmapCache.cacheOnRelease(key, value)
+    } else {
+      nonBitmapCache.cacheOnRelease(key, value)
+    }
+  }
+
   override fun get(key: CacheKey): CloseableReference<CloseableImage>? =
       bitmapCache[key] ?: nonBitmapCache[key]
 

imagepipeline/src/main/java/com/facebook/imagepipeline/core/ImagePipeline.kt

@@ -1071,7 +1071,7 @@ class ImagePipeline(
     val image = imageReference.get() ?: return
     if (image.isStateful) return
     if (!image.qualityInfo.isOfFullQuality) return
-    CloseableReference.closeSafely(bitmapMemoryCache.cache(cacheKey, imageReference))
+    CloseableReference.closeSafely(bitmapMemoryCache.cacheOnRelease(cacheKey, imageReference))
   }
 
   fun hasCachedImage(cacheKey: CacheKey?): Boolean {

vito/core-java-impl/src/main/java/com/facebook/fresco/vito/core/impl/FrescoController2Impl.kt

@@ -490,6 +490,22 @@ open class FrescoController2Impl(
   override fun onRelease(drawable: FrescoDrawable2Impl) {
     val imageRequest = drawable.imageRequest
     if (imageRequest != null) {
+      // Offer the image back to the memory cache before the drawable closes its reference, so
+      // weakly held entries (e.g. WeakBitmapCountingMemoryCache) can extend their second life and
+      // be re-served on scroll-back. Mirrors KFrescoController's offer-back hook.
+      val useOfferBackBitmap = config.useOfferBackOnRelease()
+      val useOfferBackNonBitmap = config.useOfferBackOnReleaseForNonBitmapImage()
+      if (useOfferBackBitmap || useOfferBackNonBitmap) {
+        val ref = drawable.imageReference
+        val image = ref?.get()
+        if (ref != null && CloseableReference.isValid(ref) && image != null) {
+          val shouldOfferBack =
+              if (image is CloseableBitmap) useOfferBackBitmap else useOfferBackNonBitmap
+          if (shouldOfferBack) {
+            imagePipeline.returnImageToCache(imageRequest, ref)
+          }
+        }
+      }
       // Notify listeners
       drawable.internalListener.onRelease(
           drawable.imageId,