@nativescript-community/ui-image 4.6.6 → 5.0.0

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

@@ -0,0 +1,220 @@
+package com.nativescript.image;
+
+import android.content.Context;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.GlideBuilder;
+import com.bumptech.glide.Registry;
+import com.bumptech.glide.annotation.GlideModule;
+import com.bumptech.glide.load.Key;
+import com.bumptech.glide.load.Options;
+import com.bumptech.glide.load.engine.cache.MemorySizeCalculator;
+import com.bumptech.glide.load.engine.cache.DiskCache;
+import com.bumptech.glide.load.engine.cache.DiskLruCacheWrapper;
+import com.bumptech.glide.load.engine.cache.MemoryCache;
+import com.bumptech.glide.load.engine.cache.LruResourceCache;
+import com.bumptech.glide.load.engine.CapturingEngineKeyFactory;
+import com.bumptech.glide.load.model.GlideUrl;
+import com.bumptech.glide.module.AppGlideModule;
+import com.bumptech.glide.RequestBuilder;
+import com.bumptech.glide.signature.ObjectKey;
+import okhttp3.OkHttpClient;
+import java.io.InputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
+@GlideModule
+public class CustomGlideModule extends AppGlideModule {
+  private static final String TAG = "MyAppGlideModule";
+  private static final String INJECT_TAG = "EngineKeyFactoryInject";
+
+  @Override
+  public void applyOptions(@NonNull Context context, @NonNull GlideBuilder builder) {
+
+    // Use our custom memory cache wrapper
+    MemorySizeCalculator calculator = new MemorySizeCalculator.Builder(context)
+        .setMemoryCacheScreens(2)
+        .build();
+    LruResourceCache memoryCache = new LruResourceCache(calculator.getMemoryCacheSize());
+    EvictionManager.get().setMemoryCache(memoryCache);
+    builder.setMemoryCache(memoryCache);
+    // Set a disk cache factory that also registers the disk cache instance with
+    // EvictionManager.
+    builder.setDiskCache(new DiskCache.Factory() {
+      @Override
+      public DiskCache build() {
+        DiskCache dc = DiskLruCacheWrapper.create(context.getCacheDir(), 250 * 1024 * 1024);
+        EvictionManager.get().setDiskCache(dc);
+        return dc;
+      }
+    });
+  }
+
+  @Override
+  public void registerComponents(@NonNull Context context, @NonNull Glide glide, @NonNull Registry registry) {
+
+    // Create base OkHttp client
+    OkHttpClient client = new OkHttpClient.Builder().build();
+
+    // SINGLE LOADER: CustomUrlLoader handles both CustomGlideUrl and GlideUrl
+    // This replaces both the old CustomUrlLoader and UrlTrackingModelLoader
+    registry.replace(
+        GlideUrl.class,
+        InputStream.class,
+        new CustomUrlLoader.Factory(client));
+    // Listener: called when an EngineKey is created. Update the stored keys to
+    // include engineKey.
+    CapturingEngineKeyFactory.Listener listener = (engineKey, model) -> {
+      // Log.i("JS", "CapturingEngineKeyFactory.Listener 1" + engineKey + " " + model);
+      if (model == null)
+        return;
+      String id = String.valueOf(model);
+
+      // Read either persistent or in-memory stored keys
+      CacheKeyStore.StoredKeys s = EvictionManager.get().getKeyStore().get(id);
+      if (s == null) {
+        // if key store exists but no entry, create minimal
+        s = new CacheKeyStore.StoredKeys(
+            new com.bumptech.glide.signature.ObjectKey(id),
+            new com.bumptech.glide.signature.ObjectKey("signature-none"),
+            com.bumptech.glide.request.target.Target.SIZE_ORIGINAL,
+            com.bumptech.glide.request.target.Target.SIZE_ORIGINAL,
+            null,
+            null,
+            android.graphics.Bitmap.class,
+            new Options(),
+            null,
+            null);
+      }
+
+      // Build an updated StoredKeys that preserves everything and sets engineKey
+      CacheKeyStore.StoredKeys updated = new CacheKeyStore.StoredKeys(
+          s.sourceKey,
+          s.signature,
+          s.width,
+          s.height,
+          s.transformation, // may be null; preserved for in-process fallback
+          s.transformationKeyBytes, // raw bytes if recorded (preferred)
+          s.decodedResourceClass,
+          s.options,
+          s.optionsKeyBytes,
+          engineKey // set the captured engineKey
+      );
+
+      // Put updated entry into the in-memory store so later EvictionManager can
+      // remove memory entry.
+      EvictionManager.get().getKeyStore().put(id, updated);
+    };
+
+    // Create the capturing factory
+    // instantiate the capturing factory (public class in
+    // com.bumptech.glide.load.engine)
+    Object capturingFactory = new com.bumptech.glide.load.engine.CapturingEngineKeyFactory(listener);
+
+    // inject it into Glide's Engine reflectively, passing it as Object (no
+    // EngineKeyFactory compile-time ref)
+    try {
+      injectEngineKeyFactoryIntoGlide(glide, capturingFactory);
+      Log.i(TAG, "Injected capturing EngineKeyFactory into Glide engine");
+    } catch (Exception e) {
+      Log.w(TAG, "Failed to inject capturing EngineKeyFactory", e);
+    }
+
+  }
+
+  /**
+   * Reflectively find Glide.engine and replace its EngineKeyFactory-typed field
+   * with capturingFactory.
+   * This tries to be resilient across minor Glide 5.x binary differences.
+   */
+  private void injectEngineKeyFactoryIntoGlide(Object glideInstance, Object capturingFactory) throws Exception {
+    if (glideInstance == null) {
+      throw new IllegalArgumentException("glideInstance == null");
+    }
+    // 1) find Engine field on Glide
+    Field engineField = null;
+    for (Field f : glideInstance.getClass().getDeclaredFields()) {
+      if (f.getType().getName().contains("Engine")) {
+        engineField = f;
+        break;
+      }
+    }
+    if (engineField == null) {
+      throw new NoSuchFieldException("Could not find Engine field on Glide");
+    }
+    engineField.setAccessible(true);
+    Object engineInstance = engineField.get(glideInstance);
+    if (engineInstance == null) {
+      throw new IllegalStateException("Glide.engine is null");
+    }
+
+    // 2) find the keyFactory-like field on Engine
+    Field targetField = null;
+    Class<?> engineClass = engineInstance.getClass();
+    Class<?> cur = engineClass;
+    while (cur != null && targetField == null) {
+      for (Field f : cur.getDeclaredFields()) {
+        String typeName = f.getType().getName();
+        if (typeName.contains("EngineKeyFactory") || typeName.endsWith("EngineKeyFactory")
+            || f.getName().toLowerCase().contains("keyfactory")) {
+          targetField = f;
+          break;
+        }
+      }
+      cur = cur.getSuperclass();
+    }
+    if (targetField == null) {
+      throw new NoSuchFieldException(
+          "Could not find EngineKeyFactory-like field in Engine class: " + engineClass.getName());
+    }
+
+    targetField.setAccessible(true);
+
+    // Log current value
+    Object before = targetField.get(engineInstance);
+    int beforeHash = System.identityHashCode(before);
+    String beforeClass = (before == null) ? "null" : before.getClass().getName();
+
+    // If field is final, try to remove final modifier so setting works reliably
+    try {
+      Field modifiersField = Field.class.getDeclaredField("modifiers");
+      modifiersField.setAccessible(true);
+      int mods = targetField.getModifiers();
+      if (Modifier.isFinal(mods)) {
+        modifiersField.setInt(targetField, mods & ~Modifier.FINAL);
+      }
+    } catch (NoSuchFieldException nsf) {
+      // Android ART may not expose 'modifiers' the same way; ignore if not available
+      Log.i(INJECT_TAG, "Could not access Field.modifiers to clear final; continuing");
+    } catch (Throwable t) {
+      Log.w(INJECT_TAG, "Failed to clear final modifier (continuing attempt to set field)", t);
+    }
+
+    // 3) set the new factory instance
+    try {
+      targetField.set(engineInstance, capturingFactory);
+    } catch (IllegalAccessException | IllegalArgumentException iae) {
+      // Log and rethrow so caller can inspect
+      Log.w(INJECT_TAG, "targetField.set(...) failed", iae);
+      throw iae;
+    }
+
+    // 4) read back and log to verify
+    Object after = targetField.get(engineInstance);
+    int afterHash = System.identityHashCode(after);
+    String afterClass = (after == null) ? "null" : after.getClass().getName();
+
+    // quick verification: are they the same instance we tried to set?
+    boolean sameInstance = (after == capturingFactory);
+    if (!sameInstance) {
+      throw new IllegalStateException(
+          "Injection did not set the expected capturingFactory instance. afterClass=" + afterClass);
+    }
+  }
+
+  @Override
+  public boolean isManifestParsingEnabled() {
+    return false;
+  }
+}

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

@@ -0,0 +1,52 @@
+package com.nativescript.image;
+
+import com.bumptech.glide.load.model.GlideUrl;
+import com.bumptech.glide.load.model.LazyHeaders;
+import java.util.Map;
+
+/**
+ * Custom GlideUrl with progress and load source callbacks.
+ * Headers are automatically included in cache key by Glide's LazyHeaders.
+ */
+public class CustomGlideUrl extends GlideUrl {
+    private final ImageProgressCallback progressCallback;
+    private final ImageLoadSourceCallback loadSourceCallback;
+
+    public CustomGlideUrl(String url, 
+                         Map<String, String> headers, 
+                         ImageProgressCallback progressCallback,
+                         ImageLoadSourceCallback loadSourceCallback) {
+        // Use LazyHeaders.Builder - Glide automatically includes these in cache key!
+        super(url, buildLazyHeaders(headers));
+        this.progressCallback = progressCallback;
+        this.loadSourceCallback = loadSourceCallback;
+    }
+
+    private static LazyHeaders buildLazyHeaders(Map<String, String> headers) {
+        LazyHeaders.Builder builder = new LazyHeaders.Builder();
+        
+        if (headers != null) {
+            for (Map.Entry<String, String> entry : headers.entrySet()) {
+                builder.addHeader(entry.getKey(), entry.getValue());
+            }
+        }
+        
+        return builder.build();
+    }
+
+    public ImageProgressCallback getProgressCallback() {
+        return progressCallback;
+    }
+
+    public ImageLoadSourceCallback getLoadSourceCallback() {
+        return loadSourceCallback;
+    }
+
+    public boolean hasProgressListener() {
+        return progressCallback != null;
+    }
+
+    public boolean hasLoadSourceListener() {
+        return loadSourceCallback != null;
+    }
+}

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

@@ -0,0 +1,74 @@
+package com.nativescript.image;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.bumptech.glide.load.Options;
+import com.bumptech.glide.load.data.DataFetcher;
+import com.bumptech.glide.load.model.GlideUrl;
+import com.bumptech.glide.load.model.ModelLoader;
+import com.bumptech.glide.load.model.ModelLoaderFactory;
+import com.bumptech.glide.load.model.MultiModelLoaderFactory;
+import okhttp3.Call;
+import okhttp3.OkHttpClient;
+import java.io.InputStream;
+import android.util.Log;
+
+/**
+ * Unified ModelLoader that handles both CustomGlideUrl and standard GlideUrl.
+ * This eliminates the need for UrlTrackingModelLoader.
+ */
+public class CustomUrlLoader implements ModelLoader<GlideUrl, InputStream> {
+    private final Call.Factory client;
+
+    public CustomUrlLoader(Call.Factory client) {
+        this.client = client;
+    }
+
+    @Nullable
+    @Override
+    public LoadData<InputStream> buildLoadData(
+            @NonNull GlideUrl model,
+            int width,
+            int height,
+            @NonNull Options options) {
+
+        // Create the appropriate data fetcher
+        DataFetcher<InputStream> fetcher;
+
+        if (model instanceof CustomGlideUrl) {
+            // Use CustomDataFetcher for CustomGlideUrl (supports progress/load source)
+            fetcher = new CustomDataFetcher(client, (CustomGlideUrl) model);
+        } else {
+            // Use standard OkHttp fetcher for regular GlideUrl
+            fetcher = new com.bumptech.glide.integration.okhttp3.OkHttpStreamFetcher(
+                    client,
+                    model);
+        }
+
+        return new LoadData<>(model, fetcher);
+    }
+
+    @Override
+    public boolean handles(@NonNull GlideUrl model) {
+        // Handles both CustomGlideUrl and standard GlideUrl
+        return true;
+    }
+
+    public static class Factory implements ModelLoaderFactory<GlideUrl, InputStream> {
+        private final OkHttpClient client;
+
+        public Factory(OkHttpClient client) {
+            this.client = client;
+        }
+
+        @NonNull
+        @Override
+        public ModelLoader<GlideUrl, InputStream> build(MultiModelLoaderFactory multiFactory) {
+            return new CustomUrlLoader(client);
+        }
+
+        @Override
+        public void teardown() {
+        }
+    }
+}