@nativescript-community/ui-image 4.6.6 → 5.0.0

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

@@ -0,0 +1,25 @@
+package com.nativescript.image;
+
+import java.io.IOException;
+import okhttp3.Interceptor;
+import okhttp3.Response;
+
+public class ProgressInterceptor implements Interceptor {
+    private final String url;
+    private final ImageProgressCallback callback;
+
+    public ProgressInterceptor(String url, ImageProgressCallback callback) {
+        this.url = url;
+        this.callback = callback;
+    }
+
+    @Override
+    public Response intercept(Chain chain) throws IOException {
+        Response originalResponse = chain.proceed(chain.request());
+
+        // Wrap response body with progress tracking
+        return originalResponse.newBuilder()
+                .body(new ProgressResponseBody(originalResponse.body(), url, callback))
+                .build();
+    }
+}

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

@@ -0,0 +1,70 @@
+package com.nativescript.image;
+
+import java.io.IOException;
+import okhttp3.MediaType;
+import okhttp3.ResponseBody;
+import okio.Buffer;
+import okio.BufferedSource;
+import okio.ForwardingSource;
+import okio.Okio;
+import okio.Source;
+
+public class ProgressResponseBody extends ResponseBody {
+    private final ResponseBody responseBody;
+    private final String url;
+    private final ImageProgressCallback callback;
+    private BufferedSource bufferedSource;
+
+    public ProgressResponseBody(ResponseBody responseBody, String url, ImageProgressCallback callback) {
+        this.responseBody = responseBody;
+        this.url = url;
+        this.callback = callback;
+    }
+
+    @Override
+    public MediaType contentType() {
+        return responseBody.contentType();
+    }
+
+    @Override
+    public long contentLength() {
+        return responseBody.contentLength();
+    }
+
+    @Override
+    public BufferedSource source() {
+        if (bufferedSource == null) {
+            bufferedSource = Okio.buffer(source(responseBody.source()));
+        }
+        return bufferedSource;
+    }
+
+    private Source source(Source source) {
+        return new ForwardingSource(source) {
+            long totalBytesRead = 0L;
+            long lastNotified = 0L;
+            static final long NOTIFY_INTERVAL = 8192L; // 8KB
+
+            @Override
+            public long read(Buffer sink, long byteCount) throws IOException {
+                long bytesRead = super.read(sink, byteCount);
+
+                if (bytesRead != -1) {
+                    totalBytesRead += bytesRead;
+
+                    // Notify if we've read enough bytes or at completion
+                    if (totalBytesRead - lastNotified >= NOTIFY_INTERVAL ||
+                            totalBytesRead >= contentLength()) {
+
+                        if (callback != null) {
+                            callback.onProgress(url, totalBytesRead, contentLength());
+                        }
+                        lastNotified = totalBytesRead;
+                    }
+                }
+
+                return bytesRead;
+            }
+        };
+    }
+}

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

@@ -0,0 +1,48 @@
+package com.nativescript.image;
+
+import java.io.ByteArrayOutputStream;
+import java.security.MessageDigest;
+
+/**
+ * Small MessageDigest that records raw bytes passed to update(...).
+ * We don't compute a digest here: we simply capture the bytes that callers
+ * write by calling
+ * update(byte[]) so we can later replay them into another MessageDigest.
+ *
+ * Usage:
+ * RecordingDigest r = new RecordingDigest();
+ * transformation.updateDiskCacheKey(r);
+ * byte[] bytes = r.digest(); // returns the concatenated bytes that
+ * transformation wrote
+ */
+public final class RecordingDigest extends MessageDigest {
+  private final ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+  public RecordingDigest() {
+    // algorithm name is arbitrary here; we do not rely on MessageDigest's actual
+    // hashing.
+    super("NONE");
+  }
+
+  @Override
+  protected void engineUpdate(byte input) {
+    out.write(input);
+  }
+
+  @Override
+  protected void engineUpdate(byte[] input, int offset, int len) {
+    out.write(input, offset, len);
+  }
+
+  @Override
+  protected byte[] engineDigest() {
+    byte[] result = out.toByteArray();
+    out.reset();
+    return result;
+  }
+
+  @Override
+  protected void engineReset() {
+    out.reset();
+  }
+}

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

@@ -0,0 +1,95 @@
+package com.nativescript.image;
+
+import androidx.annotation.NonNull;
+import com.bumptech.glide.load.Key;
+import java.nio.ByteBuffer;
+import java.security.MessageDigest;
+import java.util.Objects;
+
+/**
+ * Recreates ResourceCacheKey updateDiskCacheKey ordering but accepts
+ * precomputed transformation
+ * and options key bytes. This avoids the need to reconstruct
+ * Transformation/Options objects.
+ *
+ * Ordering mirrors Glide's ResourceCacheKey:
+ * signature.updateDiskCacheKey(md)
+ * sourceKey.updateDiskCacheKey(md)
+ * md.update(dimensions)
+ * md.update(transformationKeyBytes) -- if present
+ * md.update(optionsKeyBytes) -- if present
+ * md.update(decodedResourceClass.getName().getBytes(...))
+ */
+public final class RecreatedResourceKey implements Key {
+  private final Key sourceKey;
+  private final Key signature;
+  private final int width;
+  private final int height;
+  private final byte[] transformationKeyBytes; // may be null
+  private final Class<?> decodedResourceClass;
+  private final byte[] optionsKeyBytes; // may be null
+
+  public RecreatedResourceKey(
+      Key sourceKey,
+      Key signature,
+      int width,
+      int height,
+      byte[] transformationKeyBytes,
+      Class<?> decodedResourceClass,
+      byte[] optionsKeyBytes) {
+    this.sourceKey = Objects.requireNonNull(sourceKey);
+    this.signature = Objects.requireNonNull(signature);
+    this.width = width;
+    this.height = height;
+    this.transformationKeyBytes = transformationKeyBytes;
+    this.decodedResourceClass = Objects.requireNonNull(decodedResourceClass);
+    this.optionsKeyBytes = optionsKeyBytes;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o)
+      return true;
+    if (!(o instanceof RecreatedResourceKey))
+      return false;
+    RecreatedResourceKey that = (RecreatedResourceKey) o;
+    return width == that.width
+        && height == that.height
+        && sourceKey.equals(that.sourceKey)
+        && signature.equals(that.signature)
+        && java.util.Arrays.equals(transformationKeyBytes, that.transformationKeyBytes)
+        && decodedResourceClass.equals(that.decodedResourceClass)
+        && java.util.Arrays.equals(optionsKeyBytes, that.optionsKeyBytes);
+  }
+
+  @Override
+  public int hashCode() {
+    int result = sourceKey.hashCode();
+    result = 31 * result + signature.hashCode();
+    result = 31 * result + width;
+    result = 31 * result + height;
+    result = 31 * result + java.util.Arrays.hashCode(transformationKeyBytes);
+    result = 31 * result + decodedResourceClass.hashCode();
+    result = 31 * result + java.util.Arrays.hashCode(optionsKeyBytes);
+    return result;
+  }
+
+  @Override
+  public void updateDiskCacheKey(@NonNull MessageDigest messageDigest) {
+    byte[] dimensions = ByteBuffer.allocate(8).putInt(width).putInt(height).array();
+
+    signature.updateDiskCacheKey(messageDigest);
+    sourceKey.updateDiskCacheKey(messageDigest);
+    messageDigest.update(dimensions);
+
+    if (transformationKeyBytes != null) {
+      messageDigest.update(transformationKeyBytes);
+    }
+
+    if (optionsKeyBytes != null) {
+      messageDigest.update(optionsKeyBytes);
+    }
+
+    messageDigest.update(decodedResourceClass.getName().getBytes(CHARSET));
+  }
+}

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

@@ -0,0 +1,145 @@
+package com.nativescript.image;
+
+import android.graphics.drawable.Drawable;
+import android.util.Log;
+
+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.request.RequestListener;
+import com.bumptech.glide.request.RequestOptions;
+import com.bumptech.glide.request.target.Target;
+import com.bumptech.glide.load.engine.GlideException;
+
+/**
+ * RequestListener that records the disk & transformation key bytes used for a
+ * request
+ * and persists them via EvictionManager so later evictions / presence checks
+ * can recreate
+ * the exact disk keys without needing to recreate Transformation objects.
+ *
+ * Usage:
+ * - Preferred: pass a RequestOptions instance; this listener will extract the
+ * internal Options
+ * via ExtractRequestOptions (cached reflection) so your existing RequestOptions
+ * usage continues to work.
+ * - Alternative: pass an Options instance directly if you already have it.
+ *
+ * The listener returns false from callbacks so it does not short-circuit other
+ * listeners or Glide's handling.
+ */
+public final class SaveKeysRequestListener implements RequestListener<Drawable> {
+  private static final String TAG = "SaveKeysRequestListener";
+
+  private final String id; // canonical id you use to later evict (typically the URL string or normalized
+                           // model id)
+  private final Object model; // the same model object you pass to Glide.load(...)
+  private final Key sourceKey;
+  private final Key signature;
+  private final int width;
+  private final int height;
+  @Nullable
+  private final Transformation<?> transformation;
+  private final Options options;
+  private final Class<?> decodedResourceClass;
+
+  /**
+   * Construct directly with an Options instance.
+   */
+  public SaveKeysRequestListener(
+      String id,
+      Object model,
+      Key sourceKey,
+      Key signature,
+      int width,
+      int height,
+      @Nullable Transformation<?> transformation,
+      RequestOptions options,
+      Class<?> decodedResourceClass) {
+    this.id = id;
+    this.model = model;
+    this.sourceKey = sourceKey;
+    this.signature = signature;
+    this.width = width;
+    this.height = height;
+    this.transformation = transformation;
+    this.options = (options == null) ? new Options() : ExtractRequestOptions.getFrom(options);
+    this.decodedResourceClass = (decodedResourceClass == null) ? Drawable.class : decodedResourceClass;
+  }
+
+  @Override
+  public boolean onLoadFailed(GlideException e, Object model, Target<Drawable> target, boolean isFirstResource) {
+    // We don't persist anything on failure (could be added). Do not consume the
+    // event.
+    return false;
+  }
+
+  @Override
+  public boolean onResourceReady(Drawable resource, Object model, Target<Drawable> target,
+      com.bumptech.glide.load.DataSource dataSource, boolean isFirstResource) {
+    try {
+      byte[] transformationBytes = null;
+      byte[] optionsBytes = null;
+
+      // Record transformation key bytes if we have a transformation instance
+      if (transformation != null) {
+        try {
+          RecordingDigest rd = new RecordingDigest();
+          transformation.updateDiskCacheKey(rd);
+          transformationBytes = rd.digest();
+        } catch (Throwable t) {
+          Log.w(TAG, "Failed to record transformation key bytes for id=" + id, t);
+        }
+      }
+
+      // Record options key bytes (Options.updateDiskCacheKey)
+      try {
+        RecordingDigest rd2 = new RecordingDigest();
+        options.updateDiskCacheKey(rd2);
+        optionsBytes = rd2.digest();
+      } catch (Throwable t) {
+        Log.w(TAG, "Failed to record options key bytes for id=" + id, t);
+      }
+
+      // Attempt to preserve existing engineKey if present
+      com.bumptech.glide.load.Key engineKeyToKeep = null;
+
+      try {
+        CacheKeyStore.StoredKeys existing = null;
+        if (EvictionManager.get() != null) {
+          // use the public API to fetch current stored keys for this id (may be
+          // persistent or in-memory)
+          existing = EvictionManager.get().getKeyStore().get(id);
+        }
+        if (existing != null && existing.engineKey != null) {
+          engineKeyToKeep = existing.engineKey;
+        }
+      } catch (Throwable t) {
+        Log.w(TAG, "Failed to read existing stored keys to preserve engineKey for id=" + id, t);
+      }
+
+      // Build StoredKeys and persist via EvictionManager
+      CacheKeyStore.StoredKeys stored = new CacheKeyStore.StoredKeys(
+          sourceKey,
+          signature,
+          width,
+          height,
+          transformation, // may be null; kept for in-process fallback
+          transformationBytes, // recorded transformation bytes (preferred)
+          decodedResourceClass,
+          options,
+          optionsBytes,
+          engineKeyToKeep // preserve any engineKey we found
+      );
+
+      EvictionManager.get().saveKeys(id, stored);
+    } catch (Throwable t) {
+      Log.w(TAG, "Unexpected error in SaveKeysRequestListener.onResourceReady for id=" + id, t);
+    }
+    // Do not consume the event; allow other listeners and Glide to continue normal
+    // handling.
+    return false;
+  }
+}

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

@@ -0,0 +1,129 @@
+package com.nativescript.image;
+
+import android.graphics.Matrix;
+import android.graphics.RectF;
+import android.graphics.drawable.Drawable;
+import android.widget.ImageView;
+
+/**
+ * Utilities to compute an image -> view matrix that respects an
+ * ImageView.ScaleType
+ * while also applying an image rotation (degrees).
+ *
+ * Notes:
+ * - Rotation is applied around the drawable's center before fitting/scaling.
+ * - The output matrix maps drawable coordinates to view coordinates.
+ *
+ * Usage:
+ * Matrix m = new Matrix();
+ * ScaleUtils.getImageMatrix(drawable, viewWidth, viewHeight, rotationDegrees,
+ * scaleType, m);
+ */
+public final class ScaleUtils {
+
+    private ScaleUtils() {
+    }
+
+    /**
+     * Compute a matrix that maps the drawable (drawable-local coords:
+     * 0..intrinsicW/H)
+     * into view coordinates, applying rotation (degrees) about the drawable center
+     * first,
+     * then the scaleType fit.
+     *
+     * rotationDegrees is a float to allow smooth animated rotation.
+     */
+    public static void getImageMatrix(
+            Drawable d,
+            int viewWidth,
+            int viewHeight,
+            float rotationDegrees,
+            ImageView.ScaleType scaleType,
+            Matrix outMatrix) {
+        if (d == null) {
+            outMatrix.reset();
+            return;
+        }
+        float dW = d.getIntrinsicWidth();
+        float dH = d.getIntrinsicHeight();
+        if (dW <= 0 || dH <= 0 || viewWidth == 0 || viewHeight == 0) {
+            outMatrix.reset();
+            return;
+        }
+
+        RectF src = new RectF(0, 0, dW, dH);
+        Matrix m = new Matrix();
+
+        // 1) rotate around drawable center (drawable-local coords)
+        if ((rotationDegrees % 360f) != 0f) {
+            m.postRotate(rotationDegrees, dW / 2f, dH / 2f);
+        }
+
+        // 2) compute rotated drawable bounds in drawable-local coords
+        RectF rotated = new RectF();
+        m.mapRect(rotated, src);
+
+        float rW = rotated.width();
+        float rH = rotated.height();
+
+        float scaleX = (float) viewWidth / rW;
+        float scaleY = (float) viewHeight / rH;
+
+        switch (scaleType) {
+            case CENTER:
+                // no scaling, center only; rotation already applied
+                break;
+            case CENTER_CROP: {
+                float scale = Math.max(scaleX, scaleY);
+                m.postScale(scale, scale, dW / 2f, dH / 2f);
+                break;
+            }
+            case CENTER_INSIDE: {
+                float scale = Math.min(1f, Math.min(scaleX, scaleY));
+                m.postScale(scale, scale, dW / 2f, dH / 2f);
+                break;
+            }
+            case FIT_CENTER:
+            case FIT_START:
+            case FIT_END:
+            case FIT_XY: {
+                if (scaleType == ImageView.ScaleType.FIT_XY) {
+                    m.postScale(scaleX, scaleY, dW / 2f, dH / 2f);
+                } else {
+                    float scale = Math.min(scaleX, scaleY);
+                    m.postScale(scale, scale, dW / 2f, dH / 2f);
+                }
+                break;
+            }
+            case MATRIX:
+            default:
+                // Let the caller manage the matrix in MATRIX mode; here treat like FIT_CENTER.
+                float scale = Math.min(scaleX, scaleY);
+                m.postScale(scale, scale, dW / 2f, dH / 2f);
+                break;
+        }
+
+        // 3) translate to position according to scaleType
+        RectF mapped = new RectF();
+        m.mapRect(mapped, src);
+
+        float dx = 0f;
+        float dy = 0f;
+
+        if (scaleType == ImageView.ScaleType.FIT_START) {
+            dx = 0f - mapped.left;
+            dy = 0f - mapped.top;
+        } else if (scaleType == ImageView.ScaleType.FIT_END) {
+            dx = viewWidth - mapped.right;
+            dy = viewHeight - mapped.bottom;
+        } else {
+            // center
+            dx = viewWidth * 0.5f - mapped.centerX();
+            dy = viewHeight * 0.5f - mapped.centerY();
+        }
+
+        m.postTranslate(dx, dy);
+
+        outMatrix.set(m);
+    }
+}

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

@@ -0,0 +1,92 @@
+package com.nativescript.image;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.util.Base64;
+import org.json.JSONException;
+import org.json.JSONObject;
+import com.bumptech.glide.load.Key;
+import com.bumptech.glide.signature.ObjectKey;
+import com.bumptech.glide.load.Options;
+import com.bumptech.glide.load.Transformation;
+
+/**
+ * SharedPreferences-backed minimal persistent store.
+ * Stores:
+ * - source (string)
+ * - signature (string)
+ * - width, height
+ * - decodedResourceClass (string)
+ * - transformationKeyBytes (base64)
+ * - optionsKeyBytes (base64)
+ *
+ * For transformations: we store recorded bytes (from RecordingDigest) rather
+ * than trying to
+ * re-create the Transformation object.
+ */
+public class SharedPrefCacheKeyStore {
+  private static final String PREFS = "glide_cache_keys_v2";
+  private final SharedPreferences prefs;
+
+  public SharedPrefCacheKeyStore(Context context) {
+    this.prefs = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE);
+  }
+
+  public void put(String id, CacheKeyStore.StoredKeys keys) {
+    try {
+      JSONObject j = new JSONObject();
+      j.put("source", keys.sourceKey == null ? JSONObject.NULL : keys.sourceKey.toString());
+      j.put("signature", keys.signature == null ? JSONObject.NULL : keys.signature.toString());
+      j.put("width", keys.width);
+      j.put("height", keys.height);
+      j.put("decodedResourceClass",
+          keys.decodedResourceClass == null ? JSONObject.NULL : keys.decodedResourceClass.getName());
+      j.put("transformationBytes", keys.transformationKeyBytes == null ? JSONObject.NULL
+          : Base64.encodeToString(keys.transformationKeyBytes, Base64.NO_WRAP));
+      j.put("optionsBytes",
+          keys.optionsKeyBytes == null ? JSONObject.NULL : Base64.encodeToString(keys.optionsKeyBytes, Base64.NO_WRAP));
+      prefs.edit().putString(id, j.toString()).apply();
+    } catch (JSONException e) {
+      // log if you want
+    }
+  }
+
+  public CacheKeyStore.StoredKeys get(String id) {
+    String s = prefs.getString(id, null);
+    if (s == null)
+      return null;
+    try {
+      JSONObject j = new JSONObject(s);
+      String source = j.optString("source", null);
+      String signature = j.optString("signature", null);
+      int width = j.optInt("width", com.bumptech.glide.request.target.Target.SIZE_ORIGINAL);
+      int height = j.optInt("height", com.bumptech.glide.request.target.Target.SIZE_ORIGINAL);
+      String decodedName = j.optString("decodedResourceClass", android.graphics.Bitmap.class.getName());
+      String transformationBase64 = j.optString("transformationBytes", null);
+      String optionsBase64 = j.optString("optionsBytes", null);
+
+      Key sourceKey = source != null && !"null".equals(source) ? new ObjectKey(source) : new ObjectKey(id);
+      Key signatureKey = signature != null && !"null".equals(signature) ? new ObjectKey(signature)
+          : new ObjectKey("signature-none");
+      Class<?> decodedClass = Class.forName(decodedName);
+      byte[] transformationBytes = (transformationBase64 == null || "null".equals(transformationBase64)) ? null
+          : Base64.decode(transformationBase64, Base64.NO_WRAP);
+      byte[] optionsBytes = (optionsBase64 == null || "null".equals(optionsBase64)) ? null
+          : Base64.decode(optionsBase64, Base64.NO_WRAP);
+
+      // We cannot re-create a reliable Options instance from optionsBytes. We store
+      // optionsBytes and will replay them
+      // into the ResourceCacheKey digest when deleting. For in-memory Options pass an
+      // empty instance or the caller's instance.
+      Options options = new Options();
+      return new CacheKeyStore.StoredKeys(sourceKey, signatureKey, width, height, /* transformation */ null,
+          transformationBytes, decodedClass, options, optionsBytes, /* engineKey */ null);
+    } catch (Exception e) {
+      return null;
+    }
+  }
+
+  public void remove(String id) {
+    prefs.edit().remove(id).apply();
+  }
+}

package/platforms/android/native-api-usage.json

@@ -1,42 +1,44 @@
 {
     "uses": [
-        "com.facebook.drawee.drawable:ScalingUtils",
-        "com.facebook.drawee.drawable:ScalingUtils.ScaleType",
-        "com.facebook.drawee.generic:RoundingParams",
-        "com.facebook.drawee.drawable:ProgressBarDrawable",
-        "com.facebook.drawee.view:DraweeView",
-        "com.facebook.drawee.interfaces:DraweeHierarchy",
-        "com.facebook.drawee.interfaces:SettableDraweeHierarchy",
-        "com.facebook.drawee.interfaces:SimpleDraweeControllerBuilder",
-        "com.facebook.drawee.interfaces:DraweeController",
-        "com.facebook.drawee.generic:GenericDraweeHierarchyBuilder",
-        "com.facebook.drawee.generic:GenericDraweeHierarchy",
-        "com.facebook.imagepipeline.request:ImageRequestBuilder",
-        "com.facebook.imagepipeline.request:ImageRequest",
-        "com.facebook.imagepipeline.core:ImagePipelineConfig",
-        "com.facebook.imagepipeline.core:ImagePipelineConfig.Builder",
-        "com.facebook.imagepipeline.core:ImagePipeline",
-        "com.facebook.imagepipeline.common:RotationOptions",
-        "com.facebook.imagepipeline.common:ResizeOptions",
-        "com.facebook.drawee.backends.pipeline:Fresco",
-        "com.facebook.drawee.backends.pipeline:PipelineDraweeControllerBuilder",
-        "com.facebook.drawee.backends.pipeline:PipelineDraweeController",
-        "com.facebook.drawee.controller:AbstractDraweeControllerBuilder",
-        "com.facebook.drawee.controller:AbstractDraweeController",
-        "com.facebook.drawee.backends.pipeline.info:ImagePerfDataListener",
-        "com.facebook.drawee.backends.pipeline.info:ImagePerfData",
-        "com.facebook.drawee.controller:ControllerListener",
-        "com.nativescript.image:ScalingUtils*",
-        "com.nativescript.image:DraweeView",
-        "com.nativescript.image:OkHttpNetworkFetcher",
-        "com.nativescript.image:ScalingBlurPostprocessor",
-        "com.facebook.imagepipeline.producers:NetworkFetcher",
-        "com.facebook.imagepipeline.backends.okhttp3:OkHttpImagePipelineConfigFactory",
-        "okhttp3:OkHttpClient",
-        "android.graphics.drawable:Animatable",
-        "com.facebook.imagepipeline.image:ImageInfo",
-        "com.facebook.common.util:UriUtil",
         "android.net:Uri",
-        "android.net:Uri.Builder"
+        "com.nativescript.image:SharedPrefCacheKeyStore",
+        "com.nativescript.image:CacheKeyStore",
+        "com.nativescript.image:EvictionManager",
+        "com.nativescript.image:EvictionManager.DiskPresenceCallback",
+        "com.nativescript.image:EvictionManager.EvictionCallback",
+        "com.nativescript.image:ImageProgressCallback",
+        "com.nativescript.image:ImageLoadSourceCallback",
+        "com.nativescript.image:CustomGlideUrl",
+        "com.nativescript.image:ConditionalCrossFadeFactory",
+        "com.nativescript.image:SaveKeysRequestListener",
+        "com.nativescript.image:CompositeRequestListener",
+        "com.nativescript.image:MatrixDrawableImageViewTarget",
+        "com.nativescript.image:MatrixImageView",
+        "com.bumptech.glide:Glide",
+        "com.bumptech.glide.signature:ObjectKey",
+        "com.bumptech.glide.request:RequestOptions",
+        "com.bumptech.glide.request:RequestBuilder",
+        "com.bumptech.glide.request:RequestListener",
+        "com.bumptech.glide.request.target:Target",
+        "com.bumptech.glide.request.target:ViewTarget",
+        "com.bumptech.glide:RequestManager",
+        "com.bumptech.glide.load:MultiTransformation",
+        "com.bumptech.glide.load:Transformation",
+        "com.bumptech.glide.load:DataSource",
+        "com.bumptech.glide.load:Key",
+        "com.bumptech.glide.load.resource.drawable:DrawableTransitionOptions",
+        "com.bumptech.glide.load.engine:DiskCacheStrategy",
+        "com.bumptech.glide.request.transition:Transition",
+        "com.bumptech.glide.request.transition:DrawableCrossFadeFactory",
+        "android.graphics.drawable:Drawable",
+        "android.graphics.drawable:BitmapDrawable",
+        "android.widget:ImageView:ScaleType",
+        "android.widget:ImageView",
+        "androidx.appcompat.widget:AppCompatImageView",
+        "android.graphics.PorterDuff:Mode",
+        "jp.wasabeef.glide.transformations:BlurTransformation",
+        "jp.wasabeef.glide.transformations:CropCircleTransformation",
+        "jp.wasabeef.glide.transformations:RoundedCornersTransformation",
+        "jp.wasabeef.glide.transformations:ColorFilterTransformation"
     ]
 }