@nativescript-community/ui-image 5.0.12 → 5.0.13

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

@@ -8,8 +8,10 @@ package com.nativescript.image;
 public class GlideConfiguration {
     private static GlideConfiguration instance;
     
+    private long diskCacheSize = 250 * 1024 * 1024; 
     private long memoryCacheSize = -1; // -1 means use default
     private float memoryCacheScreens = 2.0f;
+    private String diskCacheName = null;
     
     private GlideConfiguration() {
     }
@@ -21,6 +23,19 @@ public class GlideConfiguration {
         return instance;
     }
     
+    /**
+     * Set custom disk cache name.
+     * Must be called before Glide is initialized (before first image load).
+     * @param name String
+     */
+    public void setDiskCacheName(String diskCacheName) {
+        this.diskCacheName = diskCacheName;
+    }
+    
+    public String getDiskCacheName() {
+        return diskCacheName;
+    }
+    
     /**
      * Set custom memory cache size in bytes.
      * Must be called before Glide is initialized (before first image load).
@@ -34,6 +49,19 @@ public class GlideConfiguration {
         return memoryCacheSize;
     }
     
+    /**
+     * Set custom disk cache size in bytes.
+     * Must be called before Glide is initialized (before first image load).
+     * @param bytes Size in bytes
+     */
+    public void setDiskCacheSize(long bytes) {
+        this.diskCacheSize = bytes;
+    }
+    
+    public long getDiskCacheSize() {
+        return diskCacheSize;
+    }
+    
     /**
      * Set memory cache screens multiplier (default 2.0).
      * Only used if memoryCacheSize is -1.

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

@@ -0,0 +1,321 @@
+package com.bumptech.glide.load.engine.cache;
+
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.bumptech.glide.disklrucache.DiskLruCache;
+import com.bumptech.glide.disklrucache.DiskLruCache.Value;
+import com.bumptech.glide.load.Key;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * A disk cache wrapper that tracks cache keys for efficient querying and eviction based on
+ * model/signature pairs. Similar to ModelSignatureMemoryCache but for disk cache.
+ *
+ * Features:
+ * - Tracks all cached keys with their string representations
+ * - Supports querying existence by model and signature
+ * - Supports bulk eviction by model/signature or signature version
+ * - Thread-safe operations with minimal overhead
+ */
+public class ModelSignatureDiskLruCacheWrapper implements DiskCache {
+  private static final String TAG = "JS";
+
+  private static final int APP_VERSION = 1;
+  private static final int VALUE_COUNT = 1;
+  private static ModelSignatureDiskLruCacheWrapper wrapper;
+
+  private final SafeKeyGenerator safeKeyGenerator;
+  private final File directory;
+  private final long maxSize;
+  private final DiskCacheWriteLocker writeLocker = new DiskCacheWriteLocker();
+  private DiskLruCache diskLruCache;
+  
+  // Index of safeKey -> original key string for efficient lookup
+  // This allows us to query and evict based on model/signature without iterating the entire cache
+  private final Map<String, String> keyIndex = new ConcurrentHashMap<>();
+
+  /**
+   * Get a DiskCache in the given directory and size. If a disk cache has already been created with
+   * a different directory and/or size, it will be returned instead and the new arguments will be
+   * ignored.
+   *
+   * @param directory The directory for the disk cache
+   * @param maxSize The max size for the disk cache
+   * @return The new disk cache with the given arguments, or the current cache if one already exists
+   * @deprecated Use {@link #create(File, long)} to create a new cache with the specified arguments.
+   */
+  @SuppressWarnings("deprecation")
+  @Deprecated
+  public static synchronized DiskCache get(File directory, long maxSize) {
+    if (wrapper == null) {
+      wrapper = new ModelSignatureDiskLruCacheWrapper(directory, maxSize);
+    }
+    return wrapper;
+  }
+
+  /**
+   * Create a new DiskCache in the given directory with a specified max size.
+   *
+   * @param directory The directory for the disk cache
+   * @param maxSize The max size for the disk cache
+   * @return The new disk cache with the given arguments
+   */
+  @SuppressWarnings("deprecation")
+  public static ModelSignatureDiskLruCacheWrapper create(File directory, long maxSize) {
+    return new ModelSignatureDiskLruCacheWrapper(directory, maxSize);
+  }
+
+  /**
+   * @deprecated Do not extend this class.
+   */
+  @Deprecated
+  // Deprecated public API.
+  @SuppressWarnings({"WeakerAccess", "DeprecatedIsStillUsed"})
+  protected ModelSignatureDiskLruCacheWrapper(File directory, long maxSize) {
+    this.directory = directory;
+    this.maxSize = maxSize;
+    this.safeKeyGenerator = new SafeKeyGenerator();
+  }
+
+  private synchronized DiskLruCache getDiskCache() throws IOException {
+    if (diskLruCache == null) {
+      diskLruCache = DiskLruCache.open(directory, APP_VERSION, VALUE_COUNT, maxSize);
+    }
+    return diskLruCache;
+  }
+
+  @Override
+  public File get(Key key) {
+    String safeKey = safeKeyGenerator.getSafeKey(key);
+    File result = null;
+    try {
+      // It is possible that the there will be a put in between these two gets. If so that shouldn't
+      // be a problem because we will always put the same value at the same key so our input streams
+      // will still represent the same data.
+      final DiskLruCache.Value value = getDiskCache().get(safeKey);
+    // Log.v(TAG, "DiskCache Get: " + safeKey + " for Key: " + key + " found: " + value);
+      if (value != null) {
+        result = value.getFile(0);
+      }
+    } catch (IOException e) {
+      if (Log.isLoggable(TAG, Log.WARN)) {
+        Log.w(TAG, "Unable to get from disk cache", e);
+      }
+    }
+    return result;
+  }
+
+  @Override
+  public void put(Key key, Writer writer) {
+    // We want to make sure that puts block so that data is available when put completes. We may
+    // actually not write any data if we find that data is written by the time we acquire the lock.
+    String safeKey = safeKeyGenerator.getSafeKey(key);
+    writeLocker.acquire(safeKey);
+    try {
+      try {
+        // We assume we only need to put once, so if data was written while we were trying to get
+        // the lock, we can simply abort.
+        DiskLruCache diskCache = getDiskCache();
+        Value current = diskCache.get(safeKey);
+        if (current != null) {
+          return;
+        }
+
+        DiskLruCache.Editor editor = diskCache.edit(safeKey);
+        if (editor == null) {
+          throw new IllegalStateException("Had two simultaneous puts for: " + safeKey);
+        }
+        try {
+          File file = editor.getFile(0);
+          if (writer.write(file)) {
+            editor.commit();
+            // Track the key in our index after successful write
+            keyIndex.put(safeKey, key.toString());
+      // Log.w(TAG, "DiskCache Put: " + safeKey + " for Key: " + key + " size: " + keyIndex.size());
+          }
+        } finally {
+          editor.abortUnlessCommitted();
+        }
+      } catch (IOException e) {
+        if (Log.isLoggable(TAG, Log.WARN)) {
+          Log.w(TAG, "Unable to put to disk cache", e);
+        }
+      }
+    } finally {
+      writeLocker.release(safeKey);
+    }
+  }
+
+  @Override
+  public void delete(Key key) {
+    String safeKey = safeKeyGenerator.getSafeKey(key);
+    try {
+      getDiskCache().remove(safeKey);
+      // Remove from index
+      keyIndex.remove(safeKey);
+      // Log.w(TAG, "DiskCache deleted: " + safeKey + " size: " +  keyIndex.size());
+    } catch (IOException e) {
+      if (Log.isLoggable(TAG, Log.WARN)) {
+        Log.w(TAG, "Unable to delete from disk cache", e);
+      }
+    }
+  }
+
+  @Override
+  public synchronized void clear() {
+    try {
+      getDiskCache().delete();
+      // Clear the index
+      keyIndex.clear();
+    } catch (IOException e) {
+        Log.w(TAG, "Unable to clear disk cache or disk cache cleared externally", e);
+    } finally {
+      // Delete can close the cache but still throw. If we don't null out the disk cache here, every
+      // subsequent request will try to act on a closed disk cache and fail. By nulling out the disk
+      // cache we at least allow for attempts to open the cache in the future. See #2465.
+      resetDiskCache();
+    }
+  }
+
+  private synchronized void resetDiskCache() {
+    diskLruCache = null;
+  }
+
+  /**
+   * Check if an entry exists in the cache by model and signature.
+   * This is more efficient than trying to get the actual file.
+   *
+   * @param model The model (e.g., URI)
+   * @param signature The signature Key
+   * @return true if at least one matching entry exists
+   */
+  public boolean containsByModelAndSignature(@NonNull Object model, @NonNull Key signature) {
+    final String modelStr = model.toString();
+    final String signatureStr = signature.toString();
+
+    for (String keyStr : keyIndex.values()) {
+        if (matchesModelAndSignature(keyStr, modelStr, signatureStr)) {
+            return true;
+        }
+    }
+    return false;
+  }
+
+  /**
+   * Remove all entries matching the given model and signature.
+   * This removes both raw (source) and transformed (resource) cache entries.
+   *
+   * @param model The model to match
+   * @param signature The signature to match
+   * @return Number of entries removed
+   */
+  public int removeByModelAndSignature(@NonNull Object model, @NonNull Key signature) {
+    final String modelStr = model.toString();
+    final String signatureStr = signature.toString();
+    
+    // Log.w(TAG, "DiskCache removeByModelAndSignature: model=" + modelStr + " signature=" + signatureStr + " cacheCount=" + keyIndex.size());
+
+    List<String> safeKeysToRemove = new ArrayList<>();
+    
+    // Find all matching keys
+    for (Map.Entry<String, String> entry : keyIndex.entrySet()) {
+      String keyStr = entry.getValue();
+      if (matchesModelAndSignature(keyStr, modelStr, signatureStr)) {
+        safeKeysToRemove.add(entry.getKey());
+      }
+    }
+
+    // Remove them from disk cache
+    int removed = 0;
+    for (String safeKey : safeKeysToRemove) {
+      try {
+        getDiskCache().remove(safeKey);
+        keyIndex.remove(safeKey);
+        removed++;
+        // Log.v(TAG, "DiskCache removed: " + safeKey);
+      } catch (IOException e) {
+        Log.w(TAG, "Failed to remove disk cache entry: " + safeKey, e);
+      }
+    }
+
+    // Log.w(TAG, "DiskCache removed " + removed + " entries for model/signature");
+    return removed;
+  }
+
+  /**
+   * Remove all entries that do NOT match the given signature.
+   * Useful for cache invalidation when changing signature versions (e.g., v1 -> v2).
+   *
+   * @param currentSignature The current/valid signature to keep
+   * @return Number of entries removed
+   */
+  public int removeAllExceptSignature(@NonNull Key currentSignature) {
+    final String signatureStr = currentSignature.toString();
+    
+    List<String> safeKeysToRemove = new ArrayList<>();
+    
+    // Find all keys that don't match the current signature
+    for (Map.Entry<String, String> entry : keyIndex.entrySet()) {
+      String keyStr = entry.getValue();
+      if (!keyStr.contains(signatureStr) && !keyStr.contains("signature=" + signatureStr)) {
+        safeKeysToRemove.add(entry.getKey());
+      }
+    }
+
+    // Remove them
+    int removed = 0;
+    for (String safeKey : safeKeysToRemove) {
+      try {
+        getDiskCache().remove(safeKey);
+        keyIndex.remove(safeKey);
+        removed++;
+      } catch (IOException e) {
+        Log.w(TAG, "Failed to remove disk cache entry: " + safeKey, e);
+      }
+    }
+
+    // Log.i(TAG, "DiskCache removed " + removed + " entries with different signatures");
+    return removed;
+  }
+
+  /**
+   * Get statistics about the cache index.
+   *
+   * @return Array: [indexSize, diskCacheSize]
+   */
+  public long[] getStats() {
+    long indexSize = keyIndex.size();
+    long diskSize = 0;
+    try {
+      diskSize = getDiskCache().size();
+    } catch (IOException e) {
+      Log.w(TAG, "Failed to get disk cache size", e);
+    }
+    return new long[] { indexSize, diskSize };
+  }
+
+  /**
+   * Helper method to check if a key string matches a model and signature.
+   * Uses multiple matching strategies for robustness.
+   */
+  private boolean matchesModelAndSignature(String keyStr, String modelStr, String signatureStr) {
+    // Strategy 1: Exact pattern matching for known key formats (e.g., DataCacheKey, ResourceCacheKey)
+    if (keyStr.contains("model=" + modelStr) && keyStr.contains("signature=" + signatureStr)) {
+      return true;
+    }
+    
+    // Strategy 2: Substring matching (fallback for other key formats)
+    // Only match if both model and signature are present
+    if (keyStr.contains(modelStr) && keyStr.contains(signatureStr)) {
+      return true;
+    }
+    
+    return false;
+  }
+}

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

@@ -0,0 +1,155 @@
+package com.nativescript.image;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.bumptech.glide.load.Key;
+import com.bumptech.glide.load.engine.Resource;
+import com.bumptech.glide.load.engine.cache.LruResourceCache;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.Arrays;
+
+import android.util.Log;
+
+/**
+ * An LRU memory cache that keeps a small index of the string form of each Key so callers can
+ * evict all entries matching a model + signature pair.
+ */
+public final class ModelSignatureMemoryCache extends LruResourceCache {
+  private static final String TAG = "JS";
+ 
+  // Map of the Key -> cached key string (avoid calling toString() repeatedly and to have a quick
+  // snapshot of what's in cache). Entries are added on put and removed on remove / eviction.
+  private final Map<Key, String> keyStrings = new ConcurrentHashMap<>();
+
+  public ModelSignatureMemoryCache(long maxSizeBytes) {
+    super(maxSizeBytes);
+  }
+  @Override
+  public void trimMemory(int level) {
+   super.trimMemory(level);
+  }
+
+  @Nullable
+  @Override
+  public Resource<?> put(@NonNull Key key, @Nullable Resource<?> resource) {
+    // Save string representation for indexing before delegating.
+    keyStrings.put(key, key.toString());
+    // Log.w(TAG, "MemoryCache put " + key.toString() + " "  + keyStrings.size());
+    return super.put(key, resource);
+  }
+
+  @Nullable
+  @Override
+  public Resource<?> remove(@NonNull Key key) {
+    // Log.w(TAG, "MemoryCache remove " + key + " "  + keyStrings.size());
+    keyStrings.remove(key);
+    return super.remove(key);
+  }
+
+  @Override
+  protected void onItemEvicted(@NonNull Key key, @Nullable Resource<?> item) {
+    // Called by the LRU when an item is evicted; keep our index in sync.
+    keyStrings.remove(key);
+    super.onItemEvicted(key, item);
+  }
+
+  /**
+   * Remove all entries whose underlying Key looks like it was created for the given model and
+   * signature. Both checks are substring based against Key.toString().
+   *
+   * @param model The model (for example the URI or whatever you passed to .load(...)).
+   *              The code uses model.toString() to match keys.
+   * @param signature The request signature (a Key, e.g. new ObjectKey(...)) as used in the
+   *                  original request. Uses signature.toString() to match keys.
+   * @return number of removed entries
+   */
+  public int removeByModelAndSignature(@NonNull Object model, @NonNull Key signature) {
+    final String modelStr = model.toString();
+    final String modelCleanStr = (modelStr.startsWith("ObjectKey{object=") && modelStr.endsWith("}")) ? modelStr.substring(17, modelStr.length() - 1) : null;
+    final String signatureStr = signature.toString();
+
+    List<Key> toRemove = new ArrayList<>();
+    for (Map.Entry<Key, String> e : keyStrings.entrySet()) {
+      String s = e.getValue();
+// There are two checks: a direct "model=" / "signature=" pattern check (matches EngineKey.toString
+      // format currently used), and a fallback that simply checks both substrings exist. The first
+      // reduces false positives.
+      if (((s.contains("model=" + modelStr) || (modelCleanStr != null && s.contains("model=" + modelCleanStr)))&& s.contains("signature=" + signatureStr))) {
+        toRemove.add(e.getKey());
+      }
+    }
+    // Log.w(TAG, "ModelSignatureMemoryCache removeByModelAndSignature will remove " + toRemove.size() + " items from " + keyStrings.size() );
+
+    for (Key k : toRemove) {
+      remove(k);
+    }
+    return toRemove.size();
+  }
+
+  /**
+   * Convenience method if you only have a model string (e.g. a URI) and a signature string.
+   *
+   * This is less type-safe (signatures should be Key), but may be helpful in some cases.
+   */
+  public int removeByModelAndSignatureStrings(@NonNull String modelStr, @NonNull String signatureStr) {
+    List<Key> toRemove = new ArrayList<>();
+    final String modelCleanStr = (modelStr.startsWith("ObjectKey{object=") && modelStr.endsWith("}")) ? modelStr.substring(17, modelStr.length() - 1) : null;
+    for (Map.Entry<Key, String> e : keyStrings.entrySet()) {
+      String s = e.getValue();
+      if (((s.contains("model=" + modelStr) || (modelCleanStr != null && s.contains("model=" + modelCleanStr)))&& s.contains("signature=" + signatureStr))) {
+        toRemove.add(e.getKey());
+      }
+    }
+    for (Key k : toRemove) {
+      remove(k);
+    }
+    return toRemove.size();
+  }
+
+  /**
+   * Test whether there is at least one entry in the memory cache that matches the given
+   * model and signature.
+   *
+   * Matching is performed by checking the cached Key.toString() for substrings derived from the
+   * provided model and signature (same heuristic used by removeByModelAndSignature).
+   *
+   * @param model The model object used in the original request (e.g. the URI or model instance).
+   * @param signature The signature Key used in the original request.
+   * @return true if at least one matching entry exists in memory cache.
+   */
+  public boolean containsByModelAndSignature(@NonNull Object model, @NonNull Key signature) {
+    final String modelStr = model.toString();
+    final String modelCleanStr = (modelStr.startsWith("ObjectKey{object=") && modelStr.endsWith("}")) ? modelStr.substring(17, modelStr.length() - 1) : null;
+    final String signatureStr = signature.toString();
+    // Log.i(TAG, "ModelSignatureMemoryCache containsByModelAndSignature " + modelStr + " " +  signatureStr + " " +  keyStrings.size());
+
+    for (String s : keyStrings.values()) {
+      if (((s.contains("model=" + modelStr) || (modelCleanStr != null && s.contains("model=" + modelCleanStr)))&& s.contains("signature=" + signatureStr))) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Convenience version that accepts precomputed strings for model and signature.
+   *
+   * @param modelString model.toString() or similar representation.
+   * @param signatureString signature.toString() or similar representation.
+   * @return true if at least one matching entry exists in memory cache.
+   */
+  public boolean containsByModelAndSignatureStrings(@NonNull String modelStr, @NonNull String signatureStr) {
+    final String modelCleanStr = (modelStr.startsWith("ObjectKey{object=") && modelStr.endsWith("}")) ? modelStr.substring(17, modelStr.length() - 1) : null;
+    for (String s : keyStrings.values()) {
+      if (((s.contains("model=" + modelStr) || (modelCleanStr != null && s.contains("model=" + modelCleanStr)))&& s.contains("signature=" + signatureStr))) {
+        return true;
+      }
+    }
+    return false;
+  }
+}