react-native-fast-image 9.3.7 → 10.1.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,12 +16,22 @@ 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));
     }
 
+    // Set for a source with diskCache false: its download goes through a
+    // client without an HTTP cache (FastImageOkHttpProgressGlideModule), so
+    // neither the `web` images' HTTP cache nor one the app gave its client
+    // keeps it.
+    static final Option<Boolean> NO_STORE = Option.memory("com.fastimage.NoStore", false);
+
+    static boolean isNoStore(@NonNull Options options) {
+        return Boolean.TRUE.equals(options.get(NO_STORE));
+    }
+
     // The Glide instance FastImage's components (FastImageOkHttpProgressGlideModule)
     // were registered with.
     private static volatile Glide registered;
@@ -62,7 +72,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
@@ -127,7 +154,10 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
         webCache = new Cache(new File(context.getCacheDir(), "fast-image-http-cache"), WEB_CACHE_SIZE);
         webClient = client.newBuilder().cache(webCache).build();
         FastImageSharedDownloads.setDirectory(new File(context.getCacheDir(), "fast-image-downloads"));
-        registry.prepend(FastImageUrl.class, InputStream.class, new UrlLoaderFactory(client, webClient));
+        // diskCache false: no HTTP cache at all, also when the app's client has
+        // one.
+        OkHttpClient noStoreClient = client.newBuilder().cache(null).build();
+        registry.prepend(FastImageUrl.class, InputStream.class, new UrlLoaderFactory(client, webClient, noStoreClient));
         FastImageSvg.register(registry, glide.getBitmapPool());
         FastImageAnimated.register(context, glide, registry);
         FastImageApng.register(registry);
@@ -141,16 +171,19 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
     // Loads FastImage's remote images (FastImageUrls), with one download of an
     // image at a time, shared by its requests (FastImageSharedDownloads):
     // `web` ones (FastImageWebGlideUrls) with the client with the HTTP cache,
-    // others with the other client. FastImageUrl isn't a GlideUrl, so Glide
+    // others with the other client, and those with diskCache false
+    // (FastImageGlide.NO_STORE) with a client without any. FastImageUrl isn't a GlideUrl, so Glide
     // doesn't also give these to other GlideUrl loaders, which it would try
     // after a failed load (e.g. a 404, requested again).
     private static class UrlLoaderFactory implements ModelLoaderFactory<FastImageUrl, InputStream> {
         private final OkHttpClient client;
         private final OkHttpClient webClient;
+        private final OkHttpClient noStoreClient;
 
-        UrlLoaderFactory(OkHttpClient client, OkHttpClient webClient) {
+        UrlLoaderFactory(OkHttpClient client, OkHttpClient webClient, OkHttpClient noStoreClient) {
             this.client = client;
             this.webClient = webClient;
+            this.noStoreClient = noStoreClient;
         }
 
         @NonNull
@@ -159,8 +192,10 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
             return new ModelLoader<FastImageUrl, InputStream>() {
                 @Override
                 public LoadData<InputStream> buildLoadData(@NonNull FastImageUrl model, int width, int height, @NonNull Options options) {
-                    return FastImageSharedDownloads.loadData(
-                            model.url, model.url instanceof FastImageWebGlideUrl ? webClient : client);
+                    OkHttpClient urlClient = FastImageGlide.isNoStore(options) ? noStoreClient
+                            : model.url instanceof FastImageWebGlideUrl ? webClient
+                            : client;
+                    return FastImageSharedDownloads.loadData(model.url, urlClient);
                 }
 
                 @Override

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;
@@ -156,6 +156,17 @@ public class FastImageSource extends ImageSource {
         return mMemoryCache;
     }
 
+    // `diskCache`: whether the image is kept in the disk cache.
+    private boolean mDiskCache = true;
+
+    void setDiskCache(boolean diskCache) {
+        mDiskCache = diskCache;
+    }
+
+    boolean isDiskCache() {
+        return mDiskCache;
+    }
+
     // An http(s) url.
     boolean isRemote() {
         String scheme = mUri == null ? null : mUri.getScheme();

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);
             }};
 
@@ -63,6 +62,13 @@ class FastImageViewConverter {
         return uri != null && !uri.trim().isEmpty();
     }
 
+    // `diskCache`: whether the image is kept in the disk cache (true unless
+    // the source sets false).
+    static boolean isDiskCache(@Nullable ReadableMap source) {
+        return source == null || !source.hasKey("diskCache") || source.getType("diskCache") != ReadableType.Boolean
+                || source.getBoolean("diskCache");
+    }
+
     // Resolve the source uri to a file path that android understands.
     static @Nullable
     FastImageSource getImageSource(Context context, @Nullable ReadableMap source) {
@@ -72,6 +78,7 @@ class FastImageViewConverter {
         if (source.hasKey("memoryCache") && source.getType("memoryCache") == ReadableType.Boolean) {
             imageSource.setMemoryCache(source.getBoolean("memoryCache"));
         }
+        imageSource.setDiskCache(isDiskCache(source));
         if (source.hasKey("cacheKey") && source.getType("cacheKey") == ReadableType.String) {
             imageSource.setCacheKey(source.getString("cacheKey"));
         }
@@ -121,6 +128,13 @@ class FastImageViewConverter {
                 break;
         }
 
+        // diskCache false: neither written to Glide's disk cache nor read from
+        // it, nor to an HTTP cache (NO_STORE).
+        final boolean noStore = imageSource != null && !imageSource.isDiskCache();
+        if (noStore) {
+            diskCacheStrategy = DiskCacheStrategy.NONE;
+        }
+
         RequestOptions options = new RequestOptions()
                 .diskCacheStrategy(diskCacheStrategy)
                 .onlyRetrieveFromCache(onlyFromCache)
@@ -128,7 +142,8 @@ class FastImageViewConverter {
                 .skipMemoryCache(skipMemoryCache || (imageSource != null && !imageSource.isMemoryCache()))
                 .priority(priority)
                 .placeholder(TRANSPARENT_DRAWABLE)
-                .set(FastImageGlide.REQUEST, true);
+                .set(FastImageGlide.REQUEST, true)
+                .set(FastImageGlide.NO_STORE, noStore);
 
         // imageSource is null when only a defaultSource is shown.
         if (imageSource != null && imageSource.isResource()) {
@@ -163,7 +178,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) {