@nativescript-community/ui-image 4.6.6 → 5.0.0

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

@@ -0,0 +1,735 @@
+package com.nativescript.image;
+
+import android.os.Handler;
+import android.os.Looper;
+import androidx.annotation.GuardedBy;
+import androidx.annotation.MainThread;
+import androidx.annotation.Nullable;
+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 java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+import android.util.Log;
+
+/**
+ * EvictionManager (updated)
+ *
+ * - adds clearDiskCache/clearMemory/clearAll with callback overloads
+ * - adds disk-only / memory-only evict methods
+ * - uses recorded transformation/options key bytes to recreate transformed
+ * cache keys
+ * - EvictionCallback now reports an optional Exception (first encountered) in
+ * addition to success flag
+ *
+ * Notes:
+ * - Disk operations run on a background executor.
+ * - Memory ops run on the main thread.
+ * - Callbacks are always posted on the main thread.
+ */
+public final class EvictionManager {
+  private static final String TAG = "EvictionManager";
+  private static final EvictionManager INSTANCE = new EvictionManager();
+
+  private final ExecutorService diskExecutor = Executors.newSingleThreadExecutor();
+  private final Handler mainHandler = new Handler(Looper.getMainLooper());
+
+  @GuardedBy("this")
+  private DiskCache diskCache;
+  @GuardedBy("this")
+  private LruResourceCache memoryCache;
+
+  // in-memory store for captured info and engineKey object
+  private final CacheKeyStore inMemoryKeyStore = new CacheKeyStore();
+
+  // optional persistent store (SharedPref). If null, fallback to in-memory only.
+  @Nullable
+  private SharedPrefCacheKeyStore persistentStore;
+
+  private EvictionManager() {
+  }
+
+  public static EvictionManager get() {
+    return INSTANCE;
+  }
+
+  public synchronized void setDiskCache(DiskCache diskCache) {
+    this.diskCache = diskCache;
+  }
+
+  public synchronized void setMemoryCache(LruResourceCache memoryCache) {
+    this.memoryCache = memoryCache;
+  }
+
+  public synchronized void setPersistentStore(@Nullable SharedPrefCacheKeyStore store) {
+    this.persistentStore = store;
+  }
+
+  /**
+   * Expose the in-memory store so callers/listeners can put engineKey objects
+   * there.
+   */
+  public CacheKeyStore getKeyStore() {
+    return inMemoryKeyStore;
+  }
+
+  /**
+   * Save keys (mirrors into persistent store if configured).
+   */
+  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) {
+        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
+      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
+      if (persistentStore != null) {
+        persistentStore.put(id, toPersist);
+      } else {
+        inMemoryKeyStore.put(id, toPersist);
+      }
+    } catch (Throwable t) {
+      Log.w(TAG, "saveKeys failed for id=" + id, t);
+    }
+  }
+
+  /**
+   * Eviction completion callback (always invoked on main thread).
+   *
+   * The second argument is the first Exception encountered during the operation
+   * (if any).
+   */
+  public interface EvictionCallback {
+    void onComplete(boolean success, @Nullable Exception error);
+  }
+
+  /** Disk presence callback for async check. */
+  public interface DiskPresenceCallback {
+    void onResult(boolean sourcePresent, boolean transformedPresent);
+  }
+
+  // -----------------------
+  // New: clear APIs
+  // -----------------------
+
+  /**
+   * Clear the entire disk cache. Runs on a background thread. Callback invoked on
+   * main thread.
+   */
+  public void clearDiskCache(@Nullable final EvictionCallback callback) {
+    diskExecutor.execute(() -> {
+      boolean success = true;
+      Exception ex = null;
+      DiskCache dc;
+      synchronized (EvictionManager.this) {
+        dc = diskCache;
+      }
+      if (dc != null) {
+        try {
+          dc.clear();
+        } catch (Exception e) {
+          success = false;
+          ex = e;
+        }
+      }
+      if (callback != null) {
+        final boolean finalSuccess = success;
+        final Exception finalEx = ex;
+        mainHandler.post(() -> callback.onComplete(finalSuccess, finalEx));
+      }
+    });
+  }
+
+  /** Clear disk cache without callback. */
+  public void clearDiskCache() {
+    clearDiskCache(null);
+  }
+
+  /**
+   * Clear the entire memory cache. This must be invoked on the main thread (we
+   * post to main to
+   * guarantee it). Callback invoked on main thread.
+   */
+  public void clearMemory(@Nullable final EvictionCallback callback) {
+    mainHandler.post(() -> {
+      boolean success = true;
+      Exception ex = null;
+      LruResourceCache mc;
+      synchronized (EvictionManager.this) {
+        mc = memoryCache;
+      }
+      if (mc != null) {
+        try {
+          mc.clearMemory();
+        } catch (Exception e) {
+          success = false;
+          ex = e;
+        }
+      }
+      if (callback != null) {
+        callback.onComplete(success, ex);
+      }
+    });
+  }
+
+  /** Clear memory cache without callback. */
+  public void clearMemory() {
+    clearMemory(null);
+  }
+
+  /**
+   * Clear both disk and memory caches. Disk clear runs first on background
+   * executor; when disk clear
+   * finishes we clear memory on the main thread. Callback invoked on main with
+   * combined success and
+   * the first exception encountered (if any).
+   */
+  public void clearAll(@Nullable final EvictionCallback callback) {
+    diskExecutor.execute(() -> {
+      boolean diskSuccess = true;
+      Exception firstEx = null;
+      DiskCache dc;
+      synchronized (EvictionManager.this) {
+        dc = diskCache;
+      }
+      if (dc != null) {
+        try {
+          dc.clear();
+        } catch (Exception e) {
+          diskSuccess = false;
+          firstEx = e;
+        }
+      }
+      final boolean finalDiskSuccess = diskSuccess;
+      final Exception finalFirstEx = firstEx;
+      mainHandler.post(() -> {
+        boolean memSuccess = true;
+        Exception memEx = null;
+        LruResourceCache mc;
+        synchronized (EvictionManager.this) {
+          mc = memoryCache;
+        }
+        if (mc != null) {
+          try {
+            mc.clearMemory();
+          } catch (Exception e) {
+            memSuccess = false;
+            if (finalFirstEx == null)
+              memEx = e;
+          }
+        }
+        boolean combined = finalDiskSuccess && memSuccess;
+        Exception combinedEx = finalFirstEx != null ? finalFirstEx : memEx;
+        if (callback != null)
+          callback.onComplete(combined, combinedEx);
+      });
+    });
+  }
+
+  /** Clear both disk and memory without callback. */
+  public void clearAll() {
+    clearAll(null);
+  }
+
+  // -----------------------
+  // Eviction-by-id APIs
+  // -----------------------
+
+  /**
+   * Evict both disk (source + transformed) and memory for id. Callback invoked on
+   * main thread.
+   */
+  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);
+      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);
+  }
+
+  /** Backwards-compatible no-callback variant */
+  public void evictAllForId(final String id) {
+    evictAllForId(id, null);
+  }
+
+  /**
+   * Evict from disk (source + transformed). Callback invoked on main thread.
+   */
+  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;
+      synchronized (EvictionManager.this) {
+        dc = diskCache;
+      }
+      if (dc != null) {
+        try {
+          dc.delete(s.sourceKey);
+        } 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;
+        final Exception finalEx = ex;
+        mainHandler.post(() -> callback.onComplete(finalSuccess, finalEx));
+      }
+    });
+  }
+
+  /** Evict disk-only, no callback. */
+  public void evictDiskForId(final String id) {
+    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;
+    boolean success = true;
+    Exception ex = null;
+    if (engineKey == null) {
+      if (callback != null)
+        callback.onComplete(false, null);
+      return;
+    }
+    LruResourceCache mc;
+    synchronized (this) {
+      mc = memoryCache;
+    }
+    if (mc == null) {
+      if (callback != null)
+        callback.onComplete(false, null);
+      return;
+    }
+    try {
+      mc.remove(engineKey);
+    } catch (Exception e) {
+      success = false;
+      ex = e;
+    }
+    if (callback != null)
+      callback.onComplete(success, ex);
+  }
+
+  /**
+   * Best-effort synchronous check whether the given id is currently present in
+   * the memory cache.
+   *
+   * - Returns true if present.
+   * - Returns false if not present or if we cannot determine (no suitable method
+   * on MemoryCache).
+   *
+   * Notes:
+   * - This uses a reflective 'contains(Key)' check if available on your
+   * MemoryCache implementation,
+   * else tries a reflective 'get(Key)' as a fallback. If neither exists we cannot
+   * reliably check
+   * without evicting; so we return false.
+   *
+   * - Call this on the main thread.
+   */
+  @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)
+      return false;
+    final Key engineKey = s.engineKey;
+    LruResourceCache mc;
+    synchronized (this) {
+      mc = memoryCache;
+    }
+    if (mc == null)
+      return false;
+
+    return mc.contains(engineKey);
+  }
+
+  /**
+   * Async disk presence check. Runs on background thread; callback invoked on
+   * main thread with two booleans:
+   * onResult(sourcePresent, transformedPresent)
+   */
+  public void isInDiskCacheAsync(final String id, final DiskPresenceCallback callback) {
+    diskExecutor.execute(() -> {
+      boolean sourcePresent = false;
+      boolean transformedPresent = false;
+
+      final CacheKeyStore.StoredKeys s = (persistentStore != null) ? persistentStore.get(id) : inMemoryKeyStore.get(id);
+
+      DiskCache dc;
+      synchronized (EvictionManager.this) {
+        dc = diskCache;
+      }
+
+      if (dc == null) {
+        mainHandler.post(() -> callback.onResult(false, 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;
+        } else {
+          // fallback: check ObjectKey(id) as source
+          Key fallback = new com.bumptech.glide.signature.ObjectKey(id);
+          sourcePresent = dc.get(fallback) != null;
+        }
+      } catch (Exception ignored) {
+      }
+
+      final boolean finalSource = sourcePresent;
+      final boolean finalTransformed = transformedPresent;
+      mainHandler.post(() -> callback.onResult(finalSource, finalTransformed));
+    });
+  }
+
+  /**
+   * Blocking disk presence check (dangerous on main thread). Call from background
+   * 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;
+    synchronized (EvictionManager.this) {
+      dc = diskCache;
+    }
+    boolean sourcePresent = false;
+    boolean transformedPresent = false;
+    if (dc == null)
+      return new boolean[] { false, 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;
+      } else {
+        Key fallback = new com.bumptech.glide.signature.ObjectKey(id);
+        sourcePresent = dc.get(fallback) != null;
+      }
+    } catch (Exception ignored) {
+    }
+    return new boolean[] { sourcePresent, transformedPresent };
+  }
+
+  /**
+   * Helper used by the eviction methods to coordinate deletes + memory removal.
+   */
+  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,
+      @Nullable final EvictionCallback callback) {
+
+    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));
+      }
+      return;
+    }
+
+    final AtomicInteger remaining = new AtomicInteger(tasks);
+    final AtomicBoolean failed = new AtomicBoolean(false);
+    final AtomicReference<Exception> firstException = new AtomicReference<>(null);
+
+    // 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());
+          });
+        }
+      });
+    }
+
+    // delete transformed resource
+    if (signature != null && sourceKey != null) {
+      diskExecutor.execute(() -> {
+        DiskCache dc;
+        synchronized (EvictionManager.this) {
+          dc = diskCache;
+        }
+        if (dc != null) {
+          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);
+          }
+        }
+        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;
+      }
+    }
+    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) {
+      }
+    }
+    return null;
+  }
+}