@nativescript-community/ui-image 4.6.6 → 5.0.0

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

@@ -0,0 +1,109 @@
+package com.nativescript.image;
+
+import android.util.Log;
+import com.bumptech.glide.load.Options;
+import com.bumptech.glide.request.RequestOptions;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+/**
+ * Utility to extract com.bumptech.glide.load.Options from a RequestOptions
+ * instance via reflection.
+ *
+ * Behavior:
+ * - Try public RequestOptions.getOptions() if present (cached).
+ * - Otherwise try to find a private 'options' field on RequestOptions or its
+ * superclasses (cached).
+ * - If neither is found, return new Options() and log a single warning
+ * (subsequent calls won't re-log lookup failures).
+ *
+ * Notes:
+ * - Reflection is fragile across Glide versions and with R8/ProGuard. This
+ * class logs failures and falls back safely.
+ */
+public final class ExtractRequestOptions {
+  private static final String TAG = "ExtractRequestOptions";
+
+  // Cached reflective handles and lookup state
+  private static volatile Method cachedGetOptionsMethod;
+  private static volatile Field cachedOptionsField;
+  private static volatile boolean triedMethodLookup = false;
+  private static volatile boolean triedFieldLookup = false;
+
+  private ExtractRequestOptions() {
+  }
+
+  /**
+   * Extracts the internal Options from a RequestOptions instance.
+   * This method is fast after the first call because it caches reflective
+   * handles.
+   */
+  public static Options getFrom(RequestOptions requestOptions) {
+    if (requestOptions == null) {
+      return new Options();
+    }
+
+    // 2) Try cached field lookup if method didn't yield a result
+    Field f = cachedOptionsField;
+    if (f == null && !triedFieldLookup) {
+      synchronized (ExtractRequestOptions.class) {
+        if (!triedFieldLookup) {
+          triedFieldLookup = true;
+          Class<?> cls = requestOptions.getClass();
+          while (cls != null && cls != Object.class) {
+            try {
+              Field optionsField = cls.getDeclaredField("options");
+              if (optionsField != null) {
+                optionsField.setAccessible(true);
+                cachedOptionsField = optionsField;
+                f = optionsField;
+                break;
+              }
+            } catch (NoSuchFieldException nsf) {
+              // try superclass
+              cls = cls.getSuperclass();
+            } catch (Throwable t) {
+              Log.w(TAG, "Failed to access 'options' field via reflection", t);
+              break;
+            }
+          }
+          if (f == null) {
+            Log.w(TAG, "Could not find 'options' field on RequestOptions (will fall back to new Options()).");
+          }
+        } else {
+          f = cachedOptionsField;
+        }
+      }
+    }
+
+    if (f != null) {
+      try {
+        Object value = f.get(requestOptions);
+        if (value instanceof Options) {
+          return (Options) value;
+        } else {
+          Log.w(TAG, "Found 'options' field but it's not an Options instance: "
+              + (value == null ? "null" : value.getClass().getName()));
+        }
+      } catch (Throwable t) {
+        Log.w(TAG, "Reading cached 'options' field failed; falling back to new Options()", t);
+      }
+    }
+    // 3) Final fallback: return new Options() and warn (only logged during the
+    // first failed lookups)
+    return new Options();
+  }
+
+  /**
+   * Optional: clear cached reflective handles. Useful for tests or if you load
+   * different Glide versions at runtime.
+   */
+  public static void clearCache() {
+    synchronized (ExtractRequestOptions.class) {
+      cachedGetOptionsMethod = null;
+      cachedOptionsField = null;
+      triedMethodLookup = false;
+      triedFieldLookup = false;
+    }
+  }
+}

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

@@ -0,0 +1,5 @@
+package com.nativescript.image;
+
+public interface ImageLoadSourceCallback {
+    void onLoadStarted(String url, String source); // "network"
+}

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

@@ -0,0 +1,5 @@
+package com.nativescript.image;
+
+public interface ImageProgressCallback {
+    void onProgress(String url, long bytesRead, long totalBytes);
+}

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

@@ -0,0 +1,28 @@
+package com.nativescript.image;
+
+import java.io.IOException;
+import okhttp3.Interceptor;
+import okhttp3.Response;
+
+public class LoadSourceInterceptor implements Interceptor {
+    private final String url;
+    private final ImageLoadSourceCallback callback;
+    private boolean notified = false;
+
+    public LoadSourceInterceptor(String url, ImageLoadSourceCallback callback) {
+        this.url = url;
+        this.callback = callback;
+    }
+
+    @Override
+    public Response intercept(Chain chain) throws IOException {
+        // Notify that network load is starting BEFORE making the request
+        if (!notified && callback != null) {
+            callback.onLoadStarted(url, "network");
+            notified = true;
+        }
+
+        // Proceed with the request
+        return chain.proceed(chain.request());
+    }
+}

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

@@ -0,0 +1,200 @@
+package com.nativescript.image;
+
+import android.graphics.Canvas;
+import android.graphics.Matrix;
+import android.graphics.Outline;
+import android.graphics.Rect;
+import android.graphics.drawable.Animatable;
+import android.graphics.drawable.Drawable;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/**
+ * Drawable wrapper that applies a Matrix before drawing the wrapped drawable
+ * and
+ * properly forwards drawable callbacks so animated drawables work.
+ *
+ * Behavior:
+ * - The wrapped drawable is kept in drawable-local coords: bounds
+ * (0,0,intrinsicW,intrinsicH).
+ * - setMatrix(matrix) expects a matrix mapping drawable-local coords -> view
+ * coords.
+ * - We implement Drawable.Callback methods
+ * (invalidateDrawable/scheduleDrawable/unscheduleDrawable)
+ * so the wrapped drawable can drive invalidation/scheduling through this
+ * wrapper.
+ *
+ * Notes:
+ * - Drawable.setCallback(...) is final on some Android versions and cannot be
+ * overridden.
+ * We therefore ensure the wrapped drawable's callback points at this wrapper by
+ * calling
+ * mWrapped.setCallback(this) in the constructor and expose
+ * refreshWrappedCallback()
+ * so hosts can re-assert the relationship if needed (e.g. after ImageView
+ * changes state).
+ */
+public class MatrixDrawable extends Drawable implements Drawable.Callback, Animatable {
+
+    private final Drawable mWrapped;
+    private final Matrix mMatrix = new Matrix();
+    private final Rect mViewBounds = new Rect();
+
+    public MatrixDrawable(@NonNull Drawable wrapped) {
+        mWrapped = wrapped;
+        int iw = Math.max(1, wrapped.getIntrinsicWidth());
+        int ih = Math.max(1, wrapped.getIntrinsicHeight());
+        // Keep wrapped drawable in drawable-local coordinates:
+        mWrapped.setBounds(0, 0, iw, ih);
+        // Ensure wrapped drawable callbacks are delivered to this wrapper
+        mWrapped.setCallback(this);
+    }
+
+    /**
+     * Re-assert that the wrapped drawable's callback is this wrapper.
+     * Call this if you suspect the wrapped drawable's callback may have been
+     * changed.
+     */
+    public void refreshWrappedCallback() {
+        mWrapped.setCallback(this);
+    }
+
+    /**
+     * Set the transformation matrix that maps the wrapped drawable coordinates
+     * into this drawable's view coordinates. Pass null to reset to identity.
+     */
+    public void setMatrix(@Nullable Matrix matrix) {
+        mMatrix.reset();
+        if (matrix != null) {
+            mMatrix.set(matrix);
+        }
+        invalidateSelf();
+    }
+
+    @Override
+    public void draw(@NonNull Canvas canvas) {
+        int save = canvas.save();
+        // Apply the matrix that maps drawable-local coords -> view coords.
+        canvas.concat(mMatrix);
+        // Draw the wrapped drawable which is in drawable-local coords.
+        mWrapped.draw(canvas);
+        canvas.restoreToCount(save);
+    }
+
+    @Override
+    public void setAlpha(int alpha) {
+        mWrapped.setAlpha(alpha);
+    }
+
+    @Override
+    public void setColorFilter(@Nullable android.graphics.ColorFilter colorFilter) {
+        mWrapped.setColorFilter(colorFilter);
+    }
+
+    @Override
+    public int getOpacity() {
+        return mWrapped.getOpacity();
+    }
+
+    @Override
+    public void setBounds(int left, int top, int right, int bottom) {
+        // Bounds here represent the view bounds. Keep them for invalidation and
+        // measurement,
+        // but the wrapped drawable remains in drawable-local coords.
+        super.setBounds(left, top, right, bottom);
+        mViewBounds.set(left, top, right, bottom);
+
+        // ensure wrapped drawable remains in drawable-local coords
+        int iw = mWrapped.getIntrinsicWidth();
+        int ih = mWrapped.getIntrinsicHeight();
+        if (iw <= 0)
+            iw = 1;
+        if (ih <= 0)
+            ih = 1;
+        mWrapped.setBounds(0, 0, iw, ih);
+    }
+
+    @Override
+    protected void onBoundsChange(Rect bounds) {
+        super.onBoundsChange(bounds);
+        mViewBounds.set(bounds);
+    }
+
+    @Override
+    public int getIntrinsicWidth() {
+        return mWrapped.getIntrinsicWidth();
+    }
+
+    @Override
+    public int getIntrinsicHeight() {
+        return mWrapped.getIntrinsicHeight();
+    }
+
+    @Override
+    public void getOutline(@NonNull Outline outline) {
+        // Optional: forward to wrapped drawable's outline if desired. Default behavior
+        // left empty.
+        // If you want the wrapper to provide the wrapped outline, uncomment the next
+        // line:
+        // mWrapped.getOutline(outline);
+        super.getOutline(outline);
+    }
+
+    // Drawable.Callback implementations: forward wrapped callbacks to the wrapper
+    // host
+
+    @Override
+    public void invalidateDrawable(@NonNull Drawable who) {
+        // When wrapped drawable requests invalidation, propagate invalidation of this
+        // wrapper.
+        invalidateSelf();
+    }
+
+    @Override
+    public void scheduleDrawable(@NonNull Drawable who, @NonNull Runnable what, long when) {
+        // Forward scheduling to this drawable's callback (typically the View)
+        final Drawable.Callback cb = getCallback();
+        if (cb != null) {
+            cb.scheduleDrawable(this, what, when);
+        }
+    }
+
+    @Override
+    public void unscheduleDrawable(@NonNull Drawable who, @NonNull Runnable what) {
+        final Drawable.Callback cb = getCallback();
+        if (cb != null) {
+            cb.unscheduleDrawable(this, what);
+        }
+    }
+
+    // Animatable forwarding so callers can treat MatrixDrawable as animatable when
+    // wrapped drawable is
+    @Override
+    public void start() {
+        if (mWrapped instanceof Animatable) {
+            ((Animatable) mWrapped).start();
+        }
+    }
+
+    @Override
+    public void stop() {
+        if (mWrapped instanceof Animatable) {
+            ((Animatable) mWrapped).stop();
+        }
+    }
+
+    @Override
+    public boolean isRunning() {
+        return (mWrapped instanceof Animatable) && ((Animatable) mWrapped).isRunning();
+    }
+
+    @Override
+    public boolean setVisible(boolean visible, boolean restart) {
+        boolean changed = super.setVisible(visible, restart);
+        // forward visibility to wrapped drawable so animations can start/stop
+        // appropriately
+        mWrapped.setVisible(visible, restart);
+        return changed;
+    }
+}

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

@@ -0,0 +1,154 @@
+package com.nativescript.image;
+
+import android.graphics.drawable.Animatable;
+import android.graphics.drawable.Drawable;
+import android.widget.ImageView;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.bumptech.glide.request.target.ViewTarget;
+import com.bumptech.glide.request.transition.Transition;
+
+/**
+ * Glide target that doesn't clear/replace the ImageView if the placeholder is
+ * null.
+ * This avoids a transient "blank" state when a Glide request starts without a
+ * placeholder.
+ */
+public class MatrixDrawableImageViewTarget extends ViewTarget<ImageView, Drawable>
+        implements Transition.ViewAdapter {
+
+    @Nullable
+    private Animatable animatable;
+
+  public MatrixDrawableImageViewTarget(ImageView view) {
+    super(view);
+  }
+
+  /**
+   * @deprecated Use {@link #waitForLayout()} instead.
+   */
+  @SuppressWarnings({"deprecation"})
+  @Deprecated
+  public MatrixDrawableImageViewTarget(ImageView view, boolean waitForLayout) {
+    super(view, waitForLayout);
+  }
+
+    /**
+     * Returns the current {@link android.graphics.drawable.Drawable} being
+     * displayed in the view
+     * using {@link android.widget.ImageView#getDrawable()}.
+     */
+    @Override
+    @Nullable
+    public Drawable getCurrentDrawable() {
+        return view.getDrawable();
+    }
+
+    /**
+     * Sets the given {@link android.graphics.drawable.Drawable} on the view using
+     * {@link
+     * android.widget.ImageView#setImageDrawable(android.graphics.drawable.Drawable)}.
+     *
+     * @param drawable {@inheritDoc}
+     */
+    @Override
+    public void setDrawable(Drawable drawable) {
+        view.setImageDrawable(drawable);
+    }
+
+    /**
+     * Sets the given {@link android.graphics.drawable.Drawable} on the view using
+     * {@link
+     * android.widget.ImageView#setImageDrawable(android.graphics.drawable.Drawable)}.
+     *
+     * @param placeholder {@inheritDoc}
+     */
+    @Override
+    public void onLoadStarted(@Nullable Drawable placeholder) {
+        super.onLoadStarted(placeholder);
+
+        // setResourceInternal(null);
+        if (placeholder != null) {
+            setDrawable(placeholder);
+        }
+    }
+
+    /**
+     * Sets the given {@link android.graphics.drawable.Drawable} on the view using
+     * {@link
+     * android.widget.ImageView#setImageDrawable(android.graphics.drawable.Drawable)}.
+     *
+     * @param errorDrawable {@inheritDoc}
+     */
+    @Override
+    public void onLoadFailed(@Nullable Drawable errorDrawable) {
+        super.onLoadFailed(errorDrawable);
+        setResourceInternal(null);
+        if (errorDrawable != null) {
+            setDrawable(errorDrawable);
+        }
+    }
+
+    /**
+     * Sets the given {@link android.graphics.drawable.Drawable} on the view using
+     * {@link
+     * android.widget.ImageView#setImageDrawable(android.graphics.drawable.Drawable)}.
+     *
+     * @param placeholder {@inheritDoc}
+     */
+    @Override
+    public void onLoadCleared(@Nullable Drawable placeholder) {
+        super.onLoadCleared(placeholder);
+        if (animatable != null) {
+            animatable.stop();
+        }
+        // setResourceInternal(null);
+        if (placeholder != null) {
+            setDrawable(placeholder);
+        }
+    }
+
+    @Override
+    public void onResourceReady(@NonNull Drawable resource, @Nullable Transition<? super Drawable> transition) {
+        if (transition == null || !transition.transition(resource, this)) {
+            setResourceInternal(resource);
+        } else {
+            maybeUpdateAnimatable(resource);
+        }
+    }
+
+    @Override
+    public void onStart() {
+        if (animatable != null) {
+            animatable.start();
+        }
+    }
+
+    @Override
+    public void onStop() {
+        if (animatable != null) {
+            animatable.stop();
+        }
+    }
+
+    private void setResourceInternal(@Nullable Drawable resource) {
+        // Order matters here. Set the resource first to make sure that the Drawable has
+        // a valid and
+        // non-null Callback before starting it.
+        setResource(resource);
+        maybeUpdateAnimatable(resource);
+    }
+
+    private void maybeUpdateAnimatable(@Nullable Drawable resource) {
+        if (resource instanceof Animatable) {
+            animatable = (Animatable) resource;
+            animatable.start();
+        } else {
+            animatable = null;
+        }
+    }
+
+    protected void setResource(@Nullable Drawable resource) {
+        view.setImageDrawable(resource);
+    }
+}