@nativescript-community/ui-image 5.0.12 → 5.0.13

package/platforms/android/java/com/nativescript/image/EvictionManager.java

@@ -5,12 +5,15 @@ import android.os.Looper;
 import androidx.annotation.GuardedBy;
 import androidx.annotation.MainThread;
 import androidx.annotation.Nullable;
+import com.bumptech.glide.Glide;
 import com.bumptech.glide.load.Key;
 import com.bumptech.glide.load.Options;
 import com.bumptech.glide.load.Transformation;
 import com.bumptech.glide.load.engine.cache.DiskCache;
 import com.bumptech.glide.load.engine.cache.MemoryCache;
 import com.bumptech.glide.load.engine.cache.LruResourceCache;
+import com.bumptech.glide.load.engine.cache.ModelSignatureDiskLruCacheWrapper;
+
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -35,18 +38,29 @@ import android.util.Log;
  * - Callbacks are always posted on the main thread.
  */
 public final class EvictionManager {
-  private static final String TAG = "EvictionManager";
+  private static final String TAG = "JS";
+  
   private static final EvictionManager INSTANCE = new EvictionManager();
 
+  // Cached reflection fields/methods for ActiveResources access
+  private static volatile java.lang.reflect.Field engineField;
+  private static volatile java.lang.reflect.Field activeResourcesField;
+  private static volatile java.lang.reflect.Field activeEngineResourcesField;
+
+  private static volatile boolean reflectionInitialized = false;
+  private static volatile boolean reflectionFailed = false;
+
   private final ExecutorService diskExecutor = Executors.newSingleThreadExecutor();
   private final Handler mainHandler = new Handler(Looper.getMainLooper());
 
   @GuardedBy("this")
-  private DiskCache diskCache;
+  private ModelSignatureDiskLruCacheWrapper diskCache;
   @GuardedBy("this")
-  private LruResourceCache memoryCache;
+  private ModelSignatureMemoryCache memoryCache;
+
+  private Glide glideInstance;
 
-  // in-memory store for captured info and engineKey object
+  // in-memory store for captured info
   private final CacheKeyStore inMemoryKeyStore = new CacheKeyStore();
 
   // optional persistent store (SharedPref). If null, fallback to in-memory only.
@@ -60,11 +74,15 @@ public final class EvictionManager {
     return INSTANCE;
   }
 
-  public synchronized void setDiskCache(DiskCache diskCache) {
+  public void setGlideInstance(Glide glideInstance) {
+    this.glideInstance = glideInstance;
+  }
+
+  public synchronized void setDiskCache(ModelSignatureDiskLruCacheWrapper diskCache) {
     this.diskCache = diskCache;
   }
 
-  public synchronized void setMemoryCache(LruResourceCache memoryCache) {
+  public synchronized void setMemoryCache(ModelSignatureMemoryCache memoryCache) {
     this.memoryCache = memoryCache;
   }
 
@@ -73,10 +91,12 @@ public final class EvictionManager {
   }
 
   /**
-   * Expose the in-memory store so callers/listeners can put engineKey objects
-   * there.
+   * Expose the in-memory store so callers/listeners can put key objects there.
    */
   public CacheKeyStore getKeyStore() {
+    if (persistentStore != null) {
+      return persistentStore;
+    }
     return inMemoryKeyStore;
   }
 
@@ -85,45 +105,23 @@ public final class EvictionManager {
    */
   public synchronized void saveKeys(final String id, final CacheKeyStore.StoredKeys newStored) {
     if (id == null || newStored == null) {
-      Log.w(TAG, "saveKeys called with null id or newStored");
       return;
     }
 
     try {
-      // 1) Load existing stored keys (check persistent store first, fallback to
-      // in-memory)
-      CacheKeyStore.StoredKeys existing = null;
-      if (persistentStore != null) {
+      // 1) Load existing stored keys
+      CacheKeyStore.StoredKeys existing = inMemoryKeyStore.get(id);
+      if (existing == null && persistentStore != null) {
         existing = persistentStore.get(id);
       }
-      if (existing == null) {
-        existing = inMemoryKeyStore.get(id);
-      }
 
-      // 2) If existing has an engineKey and newStored doesn't, merge the engineKey in
+      // 2) Just save the new keys directly
       CacheKeyStore.StoredKeys toPersist = newStored;
-      if (existing != null && existing.engineKey != null && toPersist.engineKey == null) {
-        // create a new StoredKeys that is identical to newStored but keeps
-        // existing.engineKey
-        toPersist = new CacheKeyStore.StoredKeys(
-            toPersist.sourceKey,
-            toPersist.signature,
-            toPersist.width,
-            toPersist.height,
-            toPersist.transformation,
-            toPersist.transformationKeyBytes,
-            toPersist.decodedResourceClass,
-            toPersist.options,
-            toPersist.optionsKeyBytes,
-            existing.engineKey // preserve captured engine key
-        );
-      }
-
-      // 3) Persist to persistent store if available, else to in-memory store
+    // Log.d(TAG, "EvictionManager saveKeys " + id + " " + toPersist);
+      // 3) Save to both stores
+      inMemoryKeyStore.put(id, toPersist);
       if (persistentStore != null) {
         persistentStore.put(id, toPersist);
-      } else {
-        inMemoryKeyStore.put(id, toPersist);
       }
     } catch (Throwable t) {
       Log.w(TAG, "saveKeys failed for id=" + id, t);
@@ -142,13 +140,9 @@ public final class EvictionManager {
 
   /** Disk presence callback for async check. */
   public interface DiskPresenceCallback {
-    void onResult(boolean sourcePresent, boolean transformedPresent);
+    void onResult(boolean present);
   }
 
-  // -----------------------
-  // New: clear APIs
-  // -----------------------
-
   /**
    * Clear the entire disk cache. Runs on a background thread. Callback invoked on
    * main thread.
@@ -157,7 +151,7 @@ public final class EvictionManager {
     diskExecutor.execute(() -> {
       boolean success = true;
       Exception ex = null;
-      DiskCache dc;
+      ModelSignatureDiskLruCacheWrapper dc;
       synchronized (EvictionManager.this) {
         dc = diskCache;
       }
@@ -169,6 +163,9 @@ public final class EvictionManager {
           ex = e;
         }
       }
+      if (persistentStore != null) {
+          persistentStore.clearAll();
+        }
       if (callback != null) {
         final boolean finalSuccess = success;
         final Exception finalEx = ex;
@@ -191,18 +188,20 @@ public final class EvictionManager {
     mainHandler.post(() -> {
       boolean success = true;
       Exception ex = null;
-      LruResourceCache mc;
+      ModelSignatureMemoryCache mc;
       synchronized (EvictionManager.this) {
         mc = memoryCache;
       }
       if (mc != null) {
         try {
           mc.clearMemory();
+          clearAllActiveResources();
         } catch (Exception e) {
           success = false;
           ex = e;
         }
       }
+      inMemoryKeyStore.clearAll();
       if (callback != null) {
         callback.onComplete(success, ex);
       }
@@ -225,7 +224,7 @@ public final class EvictionManager {
     diskExecutor.execute(() -> {
       boolean diskSuccess = true;
       Exception firstEx = null;
-      DiskCache dc;
+      ModelSignatureDiskLruCacheWrapper dc;
       synchronized (EvictionManager.this) {
         dc = diskCache;
       }
@@ -242,13 +241,14 @@ public final class EvictionManager {
       mainHandler.post(() -> {
         boolean memSuccess = true;
         Exception memEx = null;
-        LruResourceCache mc;
+        ModelSignatureMemoryCache mc;
         synchronized (EvictionManager.this) {
           mc = memoryCache;
         }
         if (mc != null) {
           try {
             mc.clearMemory();
+            clearAllActiveResources();
           } catch (Exception e) {
             memSuccess = false;
             if (finalFirstEx == null)
@@ -257,6 +257,10 @@ public final class EvictionManager {
         }
         boolean combined = finalDiskSuccess && memSuccess;
         Exception combinedEx = finalFirstEx != null ? finalFirstEx : memEx;
+        inMemoryKeyStore.clearAll();
+        if (persistentStore != null) {
+          persistentStore.clearAll();
+        }
         if (callback != null)
           callback.onComplete(combined, combinedEx);
       });
@@ -268,10 +272,6 @@ public final class EvictionManager {
     clearAll(null);
   }
 
-  // -----------------------
-  // Eviction-by-id APIs
-  // -----------------------
-
   /**
    * Evict both disk (source + transformed) and memory for id. Callback invoked on
    * main thread.
@@ -279,22 +279,70 @@ public final class EvictionManager {
   public void evictAllForId(final String id, @Nullable final EvictionCallback callback) {
     final CacheKeyStore.StoredKeys s = readStoredKeysPreferPersistent(id);
     if (s == null) {
-      // fallback conservative attempt (source only)
-      evictDiskForId(id, callback);
+      // fallback conservative attempt (disk only, then memory)
+      evictDiskForId(id, new EvictionCallback() {
+        @Override
+        public void onComplete(boolean diskSuccess, @Nullable Exception diskError) {
+          // After disk eviction, try memory eviction (will fail gracefully if no keys)
+          mainHandler.post(() -> {
+            evictMemoryForId(id, new EvictionCallback() {
+              @Override
+              public void onComplete(boolean memSuccess, @Nullable Exception memError) {
+                // Combine results: success only if both succeeded (or memory failed gracefully)
+                boolean combined = diskSuccess && memSuccess;
+                Exception combinedEx = diskError != null ? diskError : memError;
+                if (callback != null) {
+                  callback.onComplete(combined, combinedEx);
+                }
+              }
+            });
+          });
+        }
+      });
       return;
     }
-    final byte[] transformationBytes = getTransformationBytesFromStoredKeys(s);
-    final byte[] optionsBytes = s.optionsKeyBytes;
-    performEvictionTasks(
-        s.sourceKey,
-        s.signature,
-        s.width,
-        s.height,
-        transformationBytes,
-        s.decodedResourceClass,
-        optionsBytes,
-        s.engineKey,
-        callback);
+    
+    // Check if we have an enhanced disk cache
+    ModelSignatureDiskLruCacheWrapper dc;
+    synchronized (this) {
+      dc = diskCache;
+    }
+    
+    if (s.sourceKey != null && s.signature != null) {
+      // Use efficient model/signature-based eviction
+      // Log.i(TAG, "EvictionManager evictAllForId using efficient disk cache eviction for: " + id);
+      evictDiskByModelAndSignature(s.sourceKey, s.signature, new EvictionCallback() {
+        @Override
+        public void onComplete(boolean diskSuccess, @Nullable Exception diskError) {
+          // After disk eviction, evict from memory
+          mainHandler.post(() -> {
+            boolean memSuccess = true;
+            Exception memError = null;
+            
+            ModelSignatureMemoryCache mc;
+            synchronized (EvictionManager.this) {
+              mc = memoryCache;
+            }
+            
+            if (mc != null && s.sourceKey != null && s.signature != null) {
+              try {
+                mc.removeByModelAndSignature(s.sourceKey, s.signature);
+              } catch (Exception e) {
+                memSuccess = false;
+                memError = e;
+              }
+            }
+            
+            boolean combined = diskSuccess && memSuccess;
+            Exception combinedEx = diskError != null ? diskError : memError;
+            
+            if (callback != null) {
+              callback.onComplete(combined, combinedEx);
+            }
+          });
+        }
+      });
+    }
   }
 
   /** Backwards-compatible no-callback variant */
@@ -308,61 +356,24 @@ public final class EvictionManager {
   public void evictDiskForId(final String id, @Nullable final EvictionCallback callback) {
     final CacheKeyStore.StoredKeys s = readStoredKeysPreferPersistent(id);
     if (s == null) {
-      // fallback to deleting source by id-only ObjectKey
-      final Key fallbackSource = new com.bumptech.glide.signature.ObjectKey(id);
-      diskExecutor.execute(() -> {
-        boolean success = true;
-        Exception ex = null;
-        DiskCache dc;
-        synchronized (EvictionManager.this) {
-          dc = diskCache;
-        }
-        if (dc != null) {
-          try {
-            dc.delete(fallbackSource);
-          } catch (Exception e) {
-            success = false;
-            ex = e;
-          }
-        }
-        if (callback != null) {
-          final boolean finalSuccess = success;
-          final Exception finalEx = ex;
-          mainHandler.post(() -> callback.onComplete(finalSuccess, finalEx));
-        }
-      });
       return;
     }
 
     diskExecutor.execute(() -> {
       boolean success = true;
       Exception ex = null;
-      DiskCache dc;
+      ModelSignatureDiskLruCacheWrapper dc;
       synchronized (EvictionManager.this) {
         dc = diskCache;
       }
       if (dc != null) {
+        // Delete source data using DataCacheKey (sourceKey + signature)
         try {
-          dc.delete(s.sourceKey);
+          dc.removeByModelAndSignature(s.sourceKey, s.signature);
         } catch (Exception e) {
           success = false;
           ex = e;
         }
-        try {
-          Key resourceKey = new RecreatedResourceKey(
-              s.sourceKey,
-              s.signature,
-              s.width,
-              s.height,
-              getTransformationBytesFromStoredKeys(s),
-              s.decodedResourceClass,
-              s.optionsKeyBytes);
-          dc.delete(resourceKey);
-        } catch (Exception e) {
-          if (ex == null)
-            ex = e;
-          success = false;
-        }
       }
       if (callback != null) {
         final boolean finalSuccess = success;
@@ -377,86 +388,23 @@ public final class EvictionManager {
     evictDiskForId(id, null);
   }
 
-  /** Evict only source/raw bytes (disk). */
-  public void evictSourceForId(final String id, @Nullable final EvictionCallback callback) {
-    final CacheKeyStore.StoredKeys s = readStoredKeysPreferPersistent(id);
-    final Key sourceKey = (s != null && s.sourceKey != null) ? s.sourceKey
-        : new com.bumptech.glide.signature.ObjectKey(id);
-    diskExecutor.execute(() -> {
-      boolean success = true;
-      Exception ex = null;
-      DiskCache dc;
-      synchronized (EvictionManager.this) {
-        dc = diskCache;
-      }
-      if (dc != null) {
-        try {
-          dc.delete(sourceKey);
-        } catch (Exception e) {
-          success = false;
-          ex = e;
-        }
-      }
-      if (callback != null) {
-        final boolean finalSuccess = success;
-        final Exception finalEx = ex;
-        mainHandler.post(() -> callback.onComplete(finalSuccess, finalEx));
-      }
-    });
-  }
-
-  /** Evict only the transformed resource (disk). */
-  public void evictTransformedForId(final String id, @Nullable final EvictionCallback callback) {
-    final CacheKeyStore.StoredKeys s = readStoredKeysPreferPersistent(id);
-    if (s == null) {
-      if (callback != null)
-        mainHandler.post(() -> callback.onComplete(false, null));
-      return;
-    }
-    final byte[] transformationBytes = getTransformationBytesFromStoredKeys(s);
-    final byte[] optionsBytes = s.optionsKeyBytes;
-
-    diskExecutor.execute(() -> {
-      boolean success = true;
-      Exception ex = null;
-      DiskCache dc;
-      synchronized (EvictionManager.this) {
-        dc = diskCache;
-      }
-      if (dc != null) {
-        try {
-          Key resourceKey = new RecreatedResourceKey(s.sourceKey, s.signature, s.width, s.height, transformationBytes,
-              s.decodedResourceClass, optionsBytes);
-          dc.delete(resourceKey);
-        } catch (Exception e) {
-          success = false;
-          ex = e;
-        }
-      }
-      if (callback != null) {
-        final boolean finalSuccess = success;
-        final Exception finalEx = ex;
-        mainHandler.post(() -> callback.onComplete(finalSuccess, finalEx));
-      }
-    });
-  }
-
   /**
    * Evict only from memory (must be called on main thread). Callback invoked on
    * main thread.
    */
   @MainThread
   public void evictMemoryForId(final String id, @Nullable final EvictionCallback callback) {
-    final CacheKeyStore.StoredKeys s = (persistentStore != null) ? persistentStore.get(id) : inMemoryKeyStore.get(id);
-    final Key engineKey = (s != null) ? s.engineKey : null;
+    // Use the merged read to get engineKey from in-memory store (not persisted)
+    final CacheKeyStore.StoredKeys s = readStoredKeysPreferPersistent(id);
+    // final Key engineKey = (s != null) ? s.engineKey : null;
     boolean success = true;
     Exception ex = null;
-    if (engineKey == null) {
+    if (s == null) {
       if (callback != null)
         callback.onComplete(false, null);
       return;
     }
-    LruResourceCache mc;
+    ModelSignatureMemoryCache mc;
     synchronized (this) {
       mc = memoryCache;
     }
@@ -466,7 +414,8 @@ public final class EvictionManager {
       return;
     }
     try {
-      mc.remove(engineKey);
+      mc.removeByModelAndSignature(s.sourceKey, s.signature );
+      clearAllActiveResources();
     } catch (Exception e) {
       success = false;
       ex = e;
@@ -494,18 +443,17 @@ public final class EvictionManager {
    */
   @MainThread
   public boolean isInMemoryCache(final String id) {
-    final CacheKeyStore.StoredKeys s = (persistentStore != null) ? persistentStore.get(id) : inMemoryKeyStore.get(id);
-    if (s == null || s.engineKey == null)
+    final CacheKeyStore.StoredKeys s = readStoredKeysPreferPersistent(id);
+    if (s == null || s.sourceKey == null || s.signature == null)
       return false;
-    final Key engineKey = s.engineKey;
-    LruResourceCache mc;
+    ModelSignatureMemoryCache mc;
     synchronized (this) {
       mc = memoryCache;
     }
     if (mc == null)
       return false;
 
-    return mc.contains(engineKey);
+    return mc.containsByModelAndSignature(s.sourceKey, s.signature);
   }
 
   /**
@@ -518,36 +466,32 @@ public final class EvictionManager {
       boolean sourcePresent = false;
       boolean transformedPresent = false;
 
-      final CacheKeyStore.StoredKeys s = (persistentStore != null) ? persistentStore.get(id) : inMemoryKeyStore.get(id);
-
-      DiskCache dc;
+      final CacheKeyStore.StoredKeys s = readStoredKeysPreferPersistent(id);
+      ModelSignatureDiskLruCacheWrapper dc;
       synchronized (EvictionManager.this) {
         dc = diskCache;
       }
 
       if (dc == null) {
-        mainHandler.post(() -> callback.onResult(false, false));
+        mainHandler.post(() -> callback.onResult(false));
         return;
       }
 
       try {
-        if (s != null && s.sourceKey != null) {
-          sourcePresent = dc.get(s.sourceKey) != null;
-          byte[] transformationBytes = getTransformationBytesFromStoredKeys(s);
-          Key resourceKey = new RecreatedResourceKey(s.sourceKey, s.signature, s.width, s.height, transformationBytes,
-              s.decodedResourceClass, s.optionsKeyBytes);
-          transformedPresent = dc.get(resourceKey) != null;
+        if (hasValidStoredKeys(s)) {
+          // Log.d(TAG, "EvictionManager isInDiskCacheAsync " + id + " " + s.sourceKey+ " " + s.sourceKey.getClass().getName()+ " " + s.signature);
+          sourcePresent = dc.containsByModelAndSignature(s.sourceKey, s.signature);
         } else {
           // fallback: check ObjectKey(id) as source
           Key fallback = new com.bumptech.glide.signature.ObjectKey(id);
           sourcePresent = dc.get(fallback) != null;
+          // Log.d(TAG, "EvictionManager fallback check with ObjectKey: " + sourcePresent);
         }
-      } catch (Exception ignored) {
+      } catch (Exception e) {
+        Log.e(TAG, "EvictionManager isInDiskCacheAsync exception for " + id, e);
       }
-
-      final boolean finalSource = sourcePresent;
-      final boolean finalTransformed = transformedPresent;
-      mainHandler.post(() -> callback.onResult(finalSource, finalTransformed));
+      final Boolean result = sourcePresent;
+      mainHandler.post(() -> callback.onResult(result));
     });
   }
 
@@ -556,180 +500,234 @@ public final class EvictionManager {
    * only.
    * Returns array [sourcePresent, transformedPresent].
    */
-  public boolean[] isInDiskCacheBlocking(final String id) {
-    final CacheKeyStore.StoredKeys s = (persistentStore != null) ? persistentStore.get(id) : inMemoryKeyStore.get(id);
-    DiskCache dc;
+  public boolean isInDiskCacheBlocking(final String id) {
+    final CacheKeyStore.StoredKeys s = readStoredKeysPreferPersistent(id);
+    ModelSignatureDiskLruCacheWrapper dc;
     synchronized (EvictionManager.this) {
       dc = diskCache;
     }
     boolean sourcePresent = false;
     boolean transformedPresent = false;
     if (dc == null)
-      return new boolean[] { false, false };
+      return false;
     try {
-      if (s != null && s.sourceKey != null) {
-        sourcePresent = dc.get(s.sourceKey) != null;
-        Key resourceKey = new RecreatedResourceKey(s.sourceKey, s.signature, s.width, s.height,
-            getTransformationBytesFromStoredKeys(s), s.decodedResourceClass, s.optionsKeyBytes);
-        transformedPresent = dc.get(resourceKey) != null;
+      if (hasValidStoredKeys(s)) {
+          sourcePresent = dc.containsByModelAndSignature(s.sourceKey, s.signature);
       } else {
         Key fallback = new com.bumptech.glide.signature.ObjectKey(id);
         sourcePresent = dc.get(fallback) != null;
       }
     } catch (Exception ignored) {
     }
-    return new boolean[] { sourcePresent, transformedPresent };
+    return sourcePresent;
   }
 
+  @Nullable
+  public CacheKeyStore.StoredKeys readStoredKeysPreferPersistent(String id) {
+    CacheKeyStore.StoredKeys s = null;
+    
+    // First check in-memory
+    CacheKeyStore.StoredKeys inMem = inMemoryKeyStore.get(id);
+    CacheKeyStore.StoredKeys persistent = null;
+    
+    if (persistentStore != null) {
+      persistent = persistentStore.get(id);
+    }
+    
+    // Return whichever we have (prefer persistent)
+    return persistent != null ? persistent : inMem;
+  }
+
+  /**
+   * Helper to check if StoredKeys has all required components for disk cache operations.
+   * @param s the StoredKeys to check
+   * @return true if s has non-null sourceKey and signature
+   */
+  private static boolean hasValidStoredKeys(@Nullable CacheKeyStore.StoredKeys s) {
+    return s != null && s.sourceKey != null && s.signature != null;
+  }
+
+
+  // -----------------------
+  // Enhanced disk cache eviction methods using ModelSignatureDiskLruCacheWrapper
+  // -----------------------
+
   /**
-   * Helper used by the eviction methods to coordinate deletes + memory removal.
+   * Evict all disk cache entries (both source and transformed) matching model and signature
+   *
+   * @param model The model (e.g., URI)
+   * @param signature The signature Key
+   * @param callback Optional callback invoked on main thread
    */
-  private void performEvictionTasks(
-      final Key sourceKey,
-      final Key signature,
-      final int width,
-      final int height,
-      final byte[] transformationKeyBytes,
-      final Class<?> decodedResourceClass,
-      final byte[] optionsKeyBytes,
-      final Key engineKey,
+  public void evictDiskByModelAndSignature(
+      @Nullable final Object model,
+      @Nullable final Key signature,
       @Nullable final EvictionCallback callback) {
+    
+    if (model == null || signature == null) {
+      if (callback != null) {
+        mainHandler.post(() -> callback.onComplete(false, new IllegalArgumentException("model and signature must not be null")));
+      }
+      return;
+    }
 
-    int tasks = 0;
-    if (sourceKey != null)
-      tasks++;
-    if (signature != null && sourceKey != null)
-      tasks++;
-    if (tasks == 0) {
-      // only memory removal possible
-      if (engineKey != null) {
-        mainHandler.post(() -> {
-          MemoryCache mc;
-          synchronized (EvictionManager.this) {
-            mc = memoryCache;
-          }
-          if (mc != null) {
-            try {
-              mc.remove(engineKey);
-            } catch (Exception ignored) {
-            }
-          }
-          if (callback != null)
-            callback.onComplete(true, null);
-        });
-      } else {
-        if (callback != null)
-          mainHandler.post(() -> callback.onComplete(true, null));
+    diskExecutor.execute(() -> {
+      boolean success = false;
+      Exception ex = null;
+      int removed = 0;
+      
+      ModelSignatureDiskLruCacheWrapper dc;
+      synchronized (EvictionManager.this) {
+        dc = diskCache;
+      }
+      
+      removed = dc.removeByModelAndSignature(model, signature);
+      success = true;
+      
+      if (callback != null) {
+        final boolean finalSuccess = success;
+        final Exception finalEx = ex;
+        mainHandler.post(() -> callback.onComplete(finalSuccess, finalEx));
+      }
+    });
+  }
+
+  /**
+   * Remove all disk cache entries that do NOT match the given signature.
+   * Useful for cache invalidation when changing signature versions.
+   *
+   * @param currentSignature The current/valid signature to keep
+   * @param callback Optional callback invoked on main thread
+   */
+  public void evictDiskExceptSignature(
+      @Nullable final Key currentSignature,
+      @Nullable final EvictionCallback callback) {
+    
+    if (currentSignature == null) {
+      if (callback != null) {
+        mainHandler.post(() -> callback.onComplete(false, new IllegalArgumentException("currentSignature must not be null")));
       }
       return;
     }
 
-    final AtomicInteger remaining = new AtomicInteger(tasks);
-    final AtomicBoolean failed = new AtomicBoolean(false);
-    final AtomicReference<Exception> firstException = new AtomicReference<>(null);
+    diskExecutor.execute(() -> {
+      boolean success = false;
+      Exception ex = null;
+      int removed = 0;
+      
+      ModelSignatureDiskLruCacheWrapper dc;
+      synchronized (EvictionManager.this) {
+        dc = diskCache;
+      }
+      
+      removed = dc.removeAllExceptSignature(currentSignature);
+      success = true;
+      
+      if (callback != null) {
+        final boolean finalSuccess = success;
+        final Exception finalEx = ex;
+        mainHandler.post(() -> callback.onComplete(finalSuccess, finalEx));
+      }
+    });
+  }
 
-    // delete source bytes
-    if (sourceKey != null) {
-      diskExecutor.execute(() -> {
-        DiskCache dc;
-        synchronized (EvictionManager.this) {
-          dc = diskCache;
-        }
-        if (dc != null) {
-          try {
-            dc.delete(sourceKey);
-          } catch (Exception e) {
-            failed.set(true);
-            firstException.compareAndSet(null, e);
-          }
-        }
-        if (remaining.decrementAndGet() == 0) {
-          mainHandler.post(() -> {
-            if (engineKey != null) {
-              MemoryCache mc;
-              synchronized (EvictionManager.this) {
-                mc = memoryCache;
-              }
-              if (mc != null) {
-                try {
-                  mc.remove(engineKey);
-                } catch (Exception ignored) {
-                }
-              }
-            }
-            if (callback != null)
-              callback.onComplete(!failed.get(), firstException.get());
-          });
-        }
-      });
+  /**
+   * Get disk cache statistics.
+   *
+   * @return Array: [indexSize, diskCacheSize] or null if not supported
+   */
+  public long[] getDiskCacheStats() {
+    ModelSignatureDiskLruCacheWrapper dc;
+    synchronized (this) {
+      dc = diskCache;
     }
+    
+    return dc.getStats();
+  }
 
-    // delete transformed resource
-    if (signature != null && sourceKey != null) {
-      diskExecutor.execute(() -> {
-        DiskCache dc;
-        synchronized (EvictionManager.this) {
-          dc = diskCache;
-        }
-        if (dc != null) {
+  /**
+   * Initialize reflection fields/methods for ActiveResources access (once only)
+   */
+  private static void initActiveResourcesReflection() {
+    if (reflectionInitialized || reflectionFailed) {
+      return;
+    }
+    synchronized (EvictionManager.class) {
+      if (reflectionInitialized || reflectionFailed) {
+        return;
+      }
+      try {
+        // Get Glide.engine field
+        engineField = com.bumptech.glide.Glide.class.getDeclaredField("engine");
+        engineField.setAccessible(true);
+        
+        // Get Engine.activeResources field
+        Class<?> engineClass = Class.forName("com.bumptech.glide.load.engine.Engine");
+        activeResourcesField = engineClass.getDeclaredField("activeResources");
+        activeResourcesField.setAccessible(true);
+        
+        Class<?> activeResourcesClass = Class.forName("com.bumptech.glide.load.engine.ActiveResources");
+
+        // Get ActiveResources.activeEngineResources field (the actual map)
+        try {
+          activeEngineResourcesField = activeResourcesClass.getDeclaredField("activeEngineResources");
+          activeEngineResourcesField.setAccessible(true);
+        } catch (NoSuchFieldException e) {
+          // Try alternative field names in different Glide versions
           try {
-            Key resourceKey = new RecreatedResourceKey(sourceKey, signature, width, height, transformationKeyBytes,
-                decodedResourceClass, optionsKeyBytes);
-            dc.delete(resourceKey);
-          } catch (Exception e) {
-            failed.set(true);
-            firstException.compareAndSet(null, e);
+            activeEngineResourcesField = activeResourcesClass.getDeclaredField("activeResources");
+            activeEngineResourcesField.setAccessible(true);
+          } catch (NoSuchFieldException e2) {
+            Log.w(TAG, "Could not find activeEngineResources map field");
           }
         }
-        if (remaining.decrementAndGet() == 0) {
-          mainHandler.post(() -> {
-            if (engineKey != null) {
-              MemoryCache mc;
-              synchronized (EvictionManager.this) {
-                mc = memoryCache;
-              }
-              if (mc != null) {
-                try {
-                  mc.remove(engineKey);
-                } catch (Exception ignored) {
-                }
-              }
-            }
-            if (callback != null)
-              callback.onComplete(!failed.get(), firstException.get());
-          });
-        }
-      });
-    }
-  }
-
-  @Nullable
-  private CacheKeyStore.StoredKeys readStoredKeysPreferPersistent(String id) {
-    if (persistentStore != null) {
-      CacheKeyStore.StoredKeys s = persistentStore.get(id);
-      if (s != null) {
-        // keep mirrored in-memory copy for engineKey augmentation
-        inMemoryKeyStore.put(id, s);
-        return s;
+        
+        reflectionInitialized = true;
+        // Log.i(TAG, "ActiveResources reflection initialized successfully");
+      } catch (Throwable t) {
+        reflectionFailed = true;
+        Log.w(TAG, "Failed to initialize ActiveResources reflection (may not exist in this Glide version)", t);
       }
     }
-    return inMemoryKeyStore.get(id);
   }
 
-  @Nullable
-  private static byte[] getTransformationBytesFromStoredKeys(CacheKeyStore.StoredKeys s) {
-    if (s == null)
-      return null;
-    if (s.transformationKeyBytes != null)
-      return s.transformationKeyBytes;
-    if (s.transformation != null) {
-      try {
-        RecordingDigest rd = new RecordingDigest();
-        s.transformation.updateDiskCacheKey(rd);
-        return rd.digest();
-      } catch (Exception ignored) {
+  /**
+   * Clear all entries from Glide's ActiveResources cache.
+   * Must be called on main thread.
+   * 
+   * @return true if successfully cleared, false if reflection failed
+   */
+  @MainThread
+  public boolean clearAllActiveResources() {
+    try {
+      initActiveResourcesReflection();
+    
+      if (reflectionFailed) {
+        return false;
+      }
+      
+      Object engine = engineField.get(glideInstance);
+      
+      if (engine != null) {
+        Object activeResources = activeResourcesField.get(engine);
+        
+        if (activeResources != null && activeEngineResourcesField != null) {
+          // Get the map and clear it
+          Object mapObject = activeEngineResourcesField.get(activeResources);
+          
+          if (mapObject instanceof java.util.Map) {
+            java.util.Map<?, ?> map = (java.util.Map<?, ?>) mapObject;
+            int size = map.size();
+            map.clear();
+            // Log.i(TAG, "Cleared " + size + " entries from ActiveResources map");
+            return true;
+          }
+        }
       }
+    } catch (Throwable t) {
+      Log.w(TAG, "Failed to clear ActiveResources map", t);
     }
-    return null;
+    
+    return false;
   }
 }