react-native-fast-image 9.3.6 → 10.0.0

package/android/src/main/java/com/fastimage/FastImageCrop.java

@@ -0,0 +1,92 @@
+package com.fastimage;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+
+import androidx.annotation.NonNull;
+
+import com.bumptech.glide.load.engine.bitmap_recycle.BitmapPool;
+import com.bumptech.glide.load.resource.bitmap.BitmapTransformation;
+import com.bumptech.glide.load.resource.bitmap.TransformationUtils;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.security.MessageDigest;
+
+// objectFit cover with an objectPosition other than the center: Glide's
+// CenterCrop at that position. The image is scaled to cover the view's size
+// and the part the view shows is kept, so the bitmap is the view's size, as
+// with CenterCrop. On each axis the image's left or top edge is at
+// (view - image) * fraction + offset (CSS's object-position); an offset that
+// moves it past an edge leaves that part transparent.
+final class FastImageCrop extends BitmapTransformation {
+    private static final String ID = "com.fastimage.FastImageCrop";
+    private static final byte[] ID_BYTES = ID.getBytes(Charset.forName("UTF-8"));
+    private static final Paint PAINT = new Paint(Paint.DITHER_FLAG | Paint.FILTER_BITMAP_FLAG);
+
+    private final float x;
+    private final float xOffset;
+    private final float y;
+    private final float yOffset;
+
+    // Offsets in pixels.
+    FastImageCrop(float x, float xOffset, float y, float yOffset) {
+        this.x = x;
+        this.xOffset = xOffset;
+        this.y = y;
+        this.yOffset = yOffset;
+    }
+
+    @Override
+    protected Bitmap transform(@NonNull BitmapPool pool, @NonNull Bitmap toTransform, int outWidth, int outHeight) {
+        int width = toTransform.getWidth();
+        int height = toTransform.getHeight();
+        if (width <= 0 || height <= 0 || outWidth <= 0 || outHeight <= 0) return toTransform;
+        float scale = Math.max(outWidth / (float) width, outHeight / (float) height);
+        float shownWidth = width * scale;
+        float shownHeight = height * scale;
+        float left = Math.round((outWidth - shownWidth) * x + xOffset);
+        float top = Math.round((outHeight - shownHeight) * y + yOffset);
+        Bitmap.Config config = toTransform.getConfig() != null ? toTransform.getConfig() : Bitmap.Config.ARGB_8888;
+        // Past an edge, the view shows nothing there.
+        boolean uncovered = left > 0 || top > 0 || left + shownWidth < outWidth || top + shownHeight < outHeight;
+        if (uncovered && config == Bitmap.Config.RGB_565) config = Bitmap.Config.ARGB_8888;
+        Bitmap result = pool.get(outWidth, outHeight, config);
+        TransformationUtils.setAlpha(toTransform, result);
+        if (uncovered) {
+            result.setHasAlpha(true);
+            result.eraseColor(0);
+        }
+        Matrix matrix = new Matrix();
+        matrix.setScale(scale, scale);
+        matrix.postTranslate(left, top);
+        Canvas canvas = new Canvas(result);
+        canvas.drawBitmap(toTransform, matrix, PAINT);
+        canvas.setBitmap(null);
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof FastImageCrop)) return false;
+        FastImageCrop other = (FastImageCrop) o;
+        return other.x == x && other.xOffset == xOffset && other.y == y && other.yOffset == yOffset;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = ID.hashCode();
+        hash = hash * 31 + Float.floatToIntBits(x);
+        hash = hash * 31 + Float.floatToIntBits(xOffset);
+        hash = hash * 31 + Float.floatToIntBits(y);
+        return hash * 31 + Float.floatToIntBits(yOffset);
+    }
+
+    @Override
+    public void updateDiskCacheKey(@NonNull MessageDigest messageDigest) {
+        messageDigest.update(ID_BYTES);
+        messageDigest.update(ByteBuffer.allocate(16).putFloat(x).putFloat(xOffset).putFloat(y).putFloat(yOffset).array());
+    }
+}

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageEvent.java

@@ -1,11 +1,10 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.uimanager.events.Event;
 
 // An event for a FastImage view, sent with the EventDispatcher (see
-// FastImageEvents) instead of the RCTEventEmitter JS module, which the New
-// Architecture warns about on every event.
+// FastImageEvents).
 class FastImageEvent extends Event<FastImageEvent> {
     private final String name;
     private final WritableMap data;

package/android/src/main/java/com/fastimage/FastImageEvents.java

@@ -0,0 +1,74 @@
+package com.fastimage;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.events.EventDispatcher;
+
+// Sends FastImage view events through React Native's EventDispatcher.
+final class FastImageEvents {
+    // The handledEvents prop's bits (see src/specs/FastImageViewNativeComponent.ts).
+    static final int LOAD_START = 1;
+    static final int PROGRESS = 1 << 1;
+    static final int LOAD = 1 << 2;
+    static final int ERROR = 1 << 3;
+    static final int LOAD_END = 1 << 4;
+
+    private FastImageEvents() {
+    }
+
+    private static int bit(String name) {
+        switch (name) {
+            case FastImageViewManager.REACT_ON_LOAD_START_EVENT:
+                return LOAD_START;
+            case FastImageViewManager.REACT_ON_PROGRESS_EVENT:
+                return PROGRESS;
+            case FastImageRequestListener.REACT_ON_LOAD_EVENT:
+                return LOAD;
+            case FastImageRequestListener.REACT_ON_ERROR_EVENT:
+                return ERROR;
+            case FastImageRequestListener.REACT_ON_LOAD_END_EVENT:
+                return LOAD_END;
+            default:
+                return 0;
+        }
+    }
+
+    static void send(FastImageViewWithUrl view, String name) {
+        send(view, name, Arguments.createMap());
+    }
+
+    // onLoadEnd with the load's result: ok with the image's size, as onLoad
+    // sent it.
+    static void sendLoadEnd(FastImageViewWithUrl view, int width, int height) {
+        WritableMap event = Arguments.createMap();
+        event.putBoolean("ok", true);
+        event.putInt("width", width);
+        event.putInt("height", height);
+        send(view, FastImageRequestListener.REACT_ON_LOAD_END_EVENT, event);
+    }
+
+    // onLoadEnd with the load's result: not ok, with the error onError sent.
+    static void sendLoadEnd(FastImageViewWithUrl view, String error) {
+        WritableMap event = Arguments.createMap();
+        event.putBoolean("ok", false);
+        event.putString("error", error);
+        send(view, FastImageRequestListener.REACT_ON_LOAD_END_EVENT, event);
+    }
+
+    // Only the events JS has a handler for: most images have none.
+    static void send(FastImageViewWithUrl view, String name, WritableMap data) {
+        if (!view.handles(bit(name))) return;
+        ReactContext context = FastImageViewManager.getReactContext(view.getContext());
+        if (context == null) return;
+        // The view's event dispatcher (Fabric, bridgeless). Deprecated from React
+        // Native 0.85; its replacement, getEventDispatcher(context), isn't in 0.83.
+        @SuppressWarnings("deprecation")
+        EventDispatcher dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.getId());
+        if (dispatcher != null) {
+            dispatcher.dispatchEvent(new FastImageEvent(
+                    UIManagerHelper.getSurfaceId(view), view.getId(), name, data));
+        }
+    }
+}

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageGif.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import android.content.Context;
 import android.graphics.Bitmap;

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageGlide.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import android.content.Context;
 
@@ -16,7 +16,7 @@ final class FastImageGlide {
     // Set on FastImage's requests, so its decoders (animated WebP and AVIF,
     // APNG, SVG) only take its own images: another library's images (e.g.
     // expo-image's) keep that library's decoders.
-    static final Option<Boolean> REQUEST = Option.memory("com.dylanvann.fastimage.Request", false);
+    static final Option<Boolean> REQUEST = Option.memory("com.fastimage.Request", false);
 
     static boolean isRequest(@NonNull Options options) {
         return Boolean.TRUE.equals(options.get(REQUEST));
@@ -62,7 +62,7 @@ final class FastImageGlide {
             synchronized (FastImageGlide.class) {
                 if (registered != glide) {
                     new FastImageOkHttpProgressGlideModule()
-                            .registerComponents(context.getApplicationContext(), glide, registry);
+                            .register(context.getApplicationContext(), glide, registry, false);
                 }
             }
         }

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageGlideModule.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import android.content.Context;
 

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageKeyedGlideUrl.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageOkHttpProgressGlideModule.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import android.content.Context;
 import androidx.annotation.NonNull;
@@ -11,12 +11,14 @@ import com.bumptech.glide.load.ImageHeaderParser;
 import com.bumptech.glide.load.ImageHeaderParserUtils;
 import com.bumptech.glide.load.engine.bitmap_recycle.ArrayPool;
 import com.bumptech.glide.load.Options;
+import com.bumptech.glide.integration.okhttp3.OkHttpUrlLoader;
 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 com.bumptech.glide.module.LibraryGlideModule;
 import com.facebook.react.modules.network.CookieJarContainer;
+import com.facebook.react.modules.network.ForwardingCookieHandler;
 import com.facebook.react.modules.network.OkHttpClientProvider;
 
 import java.io.File;
@@ -26,6 +28,7 @@ import java.util.Locale;
 import java.util.concurrent.TimeUnit;
 
 import okhttp3.Cache;
+import okhttp3.Dispatcher;
 import okhttp3.HttpUrl;
 import okhttp3.Interceptor;
 import okhttp3.JavaNetCookieJar;
@@ -95,18 +98,23 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
             @NonNull Glide glide,
             @NonNull Registry registry
     ) {
+        register(context, glide, registry, true);
+    }
+
+    // `otherLoads`: as part of Glide's setup, where an app's own AppGlideModule
+    // runs after. Not when FastImageGlide.get registers FastImage's components
+    // itself, after the app's setup, which keeps what it registered for the
+    // app's other loads.
+    void register(Context context, Glide glide, Registry registry, boolean otherLoads) {
         OkHttpClient sharedClient = OkHttpClientProvider.getOkHttpClient();
-        OkHttpClient.Builder builder = sharedClient
-                .newBuilder()
-                // A network interceptor, so it runs before the HTTP cache of
-                // `web` images stores the response (checking it reads it).
-                .addNetworkInterceptor(createNonImageInterceptor(registry, glide.getArrayPool()));
+        OkHttpClient.Builder builder = sharedClient.newBuilder();
         // React Native's shared client comes with an empty cookie jar (React
         // Native only fills it in for its networking and Image clients), so
         // images were loaded without the app's cookies, unlike on iOS. Use the
-        // same cookie store. A cookie jar the app set up itself is kept.
+        // same cookie store (Android's CookieManager, through React Native's
+        // ForwardingCookieHandler). A cookie jar the app set up itself is kept.
         if (sharedClient.cookieJar() instanceof CookieJarContainer) {
-            builder.cookieJar(new JavaNetCookieJar(new FastImageCookieHandler()));
+            builder.cookieJar(new JavaNetCookieJar(new ForwardingCookieHandler()));
         }
         // React Native's shared client has no timeouts, so a download that
         // stopped (e.g. on a connection that died) never ended, and every
@@ -117,7 +125,26 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
         // longer than any.
         if (sharedClient.connectTimeoutMillis() == 0) builder.connectTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS);
         if (sharedClient.readTimeoutMillis() == 0) builder.readTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS);
-        OkHttpClient client = builder.build();
+        OkHttpClient appClient = builder.build();
+        // Images the app loads with Glide itself (a GlideUrl, from its own
+        // native code or another library) go through the same client, as
+        // expo-image does, instead of the default one Glide's OkHttp
+        // integration registers: the app's interceptors and cookies, these
+        // timeouts, and one connection pool. Not FastImage's check that a
+        // response is an image (below), which other loads, like a video's
+        // frame, can't pass. An app's own AppGlideModule runs after, and can
+        // register another.
+        // With a dispatcher of their own: FastImage's downloads count on
+        // having the client's requests per host to themselves
+        // (FastImageSharedDownloads), so the app's loads mustn't take them.
+        if (otherLoads) registry.replace(GlideUrl.class, InputStream.class,
+                new OkHttpUrlLoader.Factory(appClient.newBuilder().dispatcher(new Dispatcher()).build()));
+        OkHttpClient client = appClient
+                .newBuilder()
+                // A network interceptor, so it runs before the HTTP cache of
+                // `web` images stores the response (checking it reads it).
+                .addNetworkInterceptor(createNonImageInterceptor(registry, glide.getArrayPool()))
+                .build();
         // `cache: 'web'` skips Glide's caches and relies on HTTP caching, so
         // those urls get a client with an HTTP cache (#280): one of their own,
         // not the app's (if it gave React Native's shared client one), so

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageRequestListener.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import android.graphics.drawable.Drawable;
 
@@ -84,6 +84,11 @@ public class FastImageRequestListener implements RequestListener<Drawable> {
                 dataSource == DataSource.RESOURCE_DISK_CACHE);
         // Before the view shows it (the target does once this returns).
         view.onImageSize(size);
+        // Only onLoad and onLoadEnd need a local image's size read from it:
+        // without them, don't (scale-down and none lay it out from the decoded
+        // image meanwhile). (After get, which also forgets a size that mustn't
+        // be reused.)
+        if (!view.handles(FastImageEvents.LOAD | FastImageEvents.LOAD_END)) return false;
         if (size != null) {
             sendLoad(view, size);
             return false;

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageSharedDownloads.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import android.os.Process;
 

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageSource.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import android.content.Context;
 import android.content.res.Resources;

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageSourceSize.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import android.content.Context;
 import android.graphics.BitmapFactory;
@@ -110,13 +110,23 @@ final class FastImageSourceSize {
     // downsample strategy it implies wrapped by capture, and then blur if it
     // isn't null. Not downsampled (downsample false), the image isn't cropped
     // or fitted to the view's size either: the view scales it as it draws it.
-    static RequestOptions scaleTypeOptions(@Nullable ImageView.ScaleType scaleType, Capture capture, @Nullable FastImageBlur blur,
+    static RequestOptions scaleTypeOptions(
+            @Nullable ImageView.ScaleType scaleType,
+            Capture capture,
+            @Nullable FastImageCrop crop,
+            @Nullable FastImageBlur blur,
             boolean downsample) {
         RequestOptions options = new RequestOptions();
         BitmapTransformation transformation = null;
         if (scaleType != null && downsample) {
             switch (scaleType) {
                 case CENTER_CROP:
+                    if (crop != null) {
+                        // At objectPosition, rather than the center.
+                        options = options.optionalTransform(crop);
+                        transformation = crop;
+                        break;
+                    }
                     options = options.optionalCenterCrop();
                     transformation = new CenterCrop();
                     break;

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageSvg.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import android.graphics.Bitmap;
 
@@ -45,7 +45,7 @@ final class FastImageSvg {
     // the view. Part of the disk cache key, since the bitmap's size depends on
     // them. Unset (0) for the other fits, which draw it for the view's size.
     static final Option<Float> DENSITY = Option.disk(
-            "com.dylanvann.fastimage.FastImageSvg.Density", 0f,
+            "com.fastimage.FastImageSvg.Density", 0f,
             new Option.CacheKeyUpdater<Float>() {
                 @Override
                 public void update(@NonNull byte[] keyBytes, @NonNull Float value, @NonNull MessageDigest messageDigest) {
@@ -54,7 +54,7 @@ final class FastImageSvg {
                 }
             });
     static final Option<Boolean> FITS = Option.disk(
-            "com.dylanvann.fastimage.FastImageSvg.Fits", false,
+            "com.fastimage.FastImageSvg.Fits", false,
             new Option.CacheKeyUpdater<Boolean>() {
                 @Override
                 public void update(@NonNull byte[] keyBytes, @NonNull Boolean value, @NonNull MessageDigest messageDigest) {

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageSvgRenderer.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import android.graphics.Bitmap;
 import android.graphics.Canvas;

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageUrl.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import androidx.annotation.NonNull;
 

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageViewConverter.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import static com.bumptech.glide.request.RequestOptions.signatureOf;
 
@@ -43,16 +43,15 @@ class FastImageViewConverter {
                 put("high", Priority.HIGH);
             }};
 
-    private static final Map<String, ImageView.ScaleType> FAST_IMAGE_RESIZE_MODE_MAP =
+    // objectFit's scale types. scale-down and none are laid out by the view
+    // itself, at the image's own size in dp (see
+    // FastImageViewWithUrl.updateImageMatrix).
+    private static final Map<String, ImageView.ScaleType> FAST_IMAGE_OBJECT_FIT_MAP =
             new HashMap<String, ImageView.ScaleType>() {{
                 put("contain", ScaleType.FIT_CENTER);
                 put("cover", ScaleType.CENTER_CROP);
-                put("stretch", ScaleType.FIT_XY);
-                put("center", ScaleType.CENTER_INSIDE);
-                // objectFit="scale-down": as center, laid out in dp (see
-                // FastImageViewWithUrl.setResizeMode).
+                put("fill", ScaleType.FIT_XY);
                 put("scale-down", ScaleType.CENTER_INSIDE);
-                // objectFit="none": the image at its own size, centered.
                 put("none", ScaleType.CENTER);
             }};
 
@@ -163,7 +162,7 @@ class FastImageViewConverter {
     }
 
     static ScaleType getScaleType(String propValue) {
-        return getValue("resizeMode", "cover", FAST_IMAGE_RESIZE_MODE_MAP, propValue);
+        return getValue("objectFit", "cover", FAST_IMAGE_OBJECT_FIT_MAP, propValue);
     }
 
     private static <T> T getValue(String propName, String defaultPropValue, Map<String, T> map, String propValue) {