react-native-fast-image 8.18.1 → 8.19.0

package/android/src/main/java/com/dylanvann/fastimage/FastImageViewModule.java

@@ -4,6 +4,7 @@ import android.app.Activity;
 import android.content.Context;
 import android.graphics.BitmapFactory;
 import android.graphics.drawable.Drawable;
+import android.net.Uri;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -13,7 +14,9 @@ import com.bumptech.glide.Priority;
 import com.bumptech.glide.load.DataSource;
 import com.bumptech.glide.load.ImageHeaderParser;
 import com.bumptech.glide.load.ImageHeaderParserUtils;
+import com.bumptech.glide.load.engine.DiskCacheStrategy;
 import com.bumptech.glide.load.engine.GlideException;
+import com.bumptech.glide.load.model.GlideUrl;
 import com.bumptech.glide.request.RequestListener;
 import com.bumptech.glide.request.RequestOptions;
 import com.bumptech.glide.request.target.Target;
@@ -149,13 +152,7 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
                         finishOne.run();
                         continue;
                     }
-                    RequestOptions options = FastImageViewConverter.getOptions(context, imageSource, source);
-                    // Low priority unless the source sets one, as on iOS (the
-                    // prefetcher's options), so the images the app shows load
-                    // first.
-                    final RequestOptions preloadOptions = source.hasKey("priority") && !source.isNull("priority")
-                            ? options
-                            : options.priority(Priority.LOW);
+                    final RequestOptions preloadOptions = preloadOptions(context, imageSource, source);
                     // A source's result, which frees its slot.
                     final ResultCallback done = new ResultCallback() {
                         @Override
@@ -172,38 +169,29 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
                         pendingPreloads.add(new Runnable() {
                             @Override
                             public void run() {
-                                Glide
-                                        .with(context)
-                                        .asFile()
-                                        .load(imageSource.getSourceForLoad())
-                                        .apply(preloadOptions)
-                                        .listener(new RequestListener<File>() {
-                                            @Override
-                                            public boolean onLoadFailed(@Nullable GlideException e, Object model, Target<File> target, boolean isFirstResource) {
-                                                done.run(failure(FastImageRequestListener.errorMessage(e)));
-                                                return false;
-                                            }
-
+                                loadFile(context, imageSource.getSourceForLoad(), preloadOptions, new FileCallback() {
+                                    @Override
+                                    public void run(@Nullable final File file, @Nullable String error) {
+                                        if (file == null) {
+                                            done.run(failure(error));
+                                            return;
+                                        }
+                                        sizeExecutor.execute(new Runnable() {
                                             @Override
-                                            public boolean onResourceReady(final File file, Object model, Target<File> target, DataSource dataSource, boolean isFirstResource) {
-                                                sizeExecutor.execute(new Runnable() {
+                                            public void run() {
+                                                final int[] size = imageSize(context, file);
+                                                UiThreadUtil.runOnUiThread(new Runnable() {
                                                     @Override
                                                     public void run() {
-                                                        final int[] size = imageSize(context, file);
-                                                        UiThreadUtil.runOnUiThread(new Runnable() {
-                                                            @Override
-                                                            public void run() {
-                                                                done.run(size != null
-                                                                        ? success(size[0], size[1])
-                                                                        : failure("Failed to read the image's size"));
-                                                            }
-                                                        });
+                                                        done.run(size != null
+                                                                ? success(size[0], size[1])
+                                                                : failure("Failed to read the image's size"));
                                                     }
                                                 });
-                                                return false;
                                             }
-                                        })
-                                        .preload();
+                                        });
+                                    }
+                                });
                             }
                         });
                         continue;
@@ -249,6 +237,57 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
         void run(WritableMap result);
     }
 
+    // A preload's options: low priority unless the source sets one, as on
+    // iOS (the prefetcher's options), so the images the app shows load first.
+    private static RequestOptions preloadOptions(Context context, FastImageSource imageSource, ReadableMap source) {
+        RequestOptions options = FastImageViewConverter.getOptions(context, imageSource, source);
+        return source.hasKey("priority") && !source.isNull("priority") ? options : options.priority(Priority.LOW);
+    }
+
+    private interface FileCallback {
+        void run(@Nullable File file, @Nullable String error);
+    }
+
+    // Downloads the image into Glide's disk cache without decoding it (if it
+    // isn't there), then calls back with its file or the error, on the UI
+    // thread.
+    private static void loadFile(Context context, Object model, RequestOptions options, final FileCallback callback) {
+        Glide.with(context)
+                .asFile()
+                .load(model)
+                .apply(options)
+                .listener(new RequestListener<File>() {
+                    @Override
+                    public boolean onLoadFailed(@Nullable GlideException e, Object model, Target<File> target, boolean isFirstResource) {
+                        callback.run(null, FastImageRequestListener.errorMessage(e));
+                        return false;
+                    }
+
+                    @Override
+                    public boolean onResourceReady(File file, Object model, Target<File> target, DataSource dataSource, boolean isFirstResource) {
+                        callback.run(file, null);
+                        return false;
+                    }
+                })
+                .preload();
+    }
+
+    // The file of the image in Glide's disk cache, or null. Blocking.
+    @Nullable
+    private static File cachedFile(Context context, Object model, RequestOptions options) {
+        try {
+            return Glide.with(context)
+                    .asFile()
+                    .load(model)
+                    .apply(options)
+                    .onlyRetrieveFromCache(true)
+                    .submit()
+                    .get();
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
     private static WritableMap failure(String error) {
         WritableMap result = Arguments.createMap();
         result.putBoolean("ok", false);
@@ -270,12 +309,27 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
     // The source's downloaded file in the disk cache, downloading it first if
     // it isn't there (without decoding it or keeping it in memory, and in the
     // preloads' queue): { ok, path } or { ok: false, error }. Never rejects.
-    // With `cacheOnly` it doesn't download. A local file is its own path.
+    // With `cacheOnly`, or a cacheKey without a uri, it doesn't download. A
+    // local file is its own path.
     @ReactMethod
     public void getCachePath(final ReadableMap source, final Promise promise) {
         final ReactApplicationContext context = getReactApplicationContext();
         if (!FastImageViewConverter.hasUri(source)) {
-            promise.resolve(failure("Invalid source: no uri"));
+            // `web` images ignore cacheKey.
+            final String cacheKey = FastImageViewConverter.getCacheControl(source) == FastImageCacheControl.WEB
+                    ? null
+                    : FastImageViewConverter.getCacheKey(source);
+            if (cacheKey == null) {
+                promise.resolve(failure("Invalid source: no uri or cacheKey"));
+                return;
+            }
+            cachePathExecutor.execute(new Runnable() {
+                @Override
+                public void run() {
+                    File file = cachedFile(context, FastImageKeyedGlideUrl.forKey(cacheKey), new RequestOptions());
+                    promise.resolve(file != null ? pathResult(file) : failure("Not in the disk cache"));
+                }
+            });
             return;
         }
         final FastImageSource imageSource = FastImageViewConverter.getImageSource(context, source);
@@ -294,33 +348,16 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
             return;
         }
         final boolean cacheOnly = FastImageViewConverter.getCacheControl(source) == FastImageCacheControl.CACHE_ONLY;
-        final RequestOptions options = FastImageViewConverter.getOptions(context, imageSource, source);
-        final RequestOptions preloadOptions = source.hasKey("priority") && !source.isNull("priority")
-                ? options
-                : options.priority(Priority.LOW);
-        final String url = imageSource.getUri().toString();
+        final RequestOptions options = preloadOptions(context, imageSource, source);
         cachePathExecutor.execute(new Runnable() {
             @Override
             public void run() {
                 // On disk already: in Glide's cache (not for `web` images,
                 // which it doesn't cache), or in the HTTP cache of `web`
                 // images (set up by Glide, which is started first).
-                File file = null;
                 Glide.get(context);
-                if (!imageSource.isWebCache()) {
-                    try {
-                        file = Glide.with(context)
-                                .asFile()
-                                .load(imageSource.getSourceForLoad())
-                                .apply(options)
-                                .onlyRetrieveFromCache(true)
-                                .submit()
-                                .get();
-                    } catch (Exception e) {
-                        // Not in Glide's cache.
-                    }
-                }
-                if (file == null) file = FastImageOkHttpProgressGlideModule.webCacheFile(url);
+                File file = imageSource.isWebCache() ? null : cachedFile(context, imageSource.getSourceForLoad(), options);
+                if (file == null) file = FastImageOkHttpProgressGlideModule.webCacheFile(imageSource.getUri().toString());
                 if (file != null) {
                     promise.resolve(pathResult(file));
                     return;
@@ -333,8 +370,8 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
                     @Override
                     public void run() {
                         pendingPreloads.add(imageSource.isWebCache()
-                                ? downloadToWebCache(imageSource, url, promise)
-                                : downloadToDiskCache(context, imageSource, preloadOptions, promise));
+                                ? downloadToWebCache(imageSource, promise)
+                                : downloadToDiskCache(context, imageSource, options, promise));
                         startPendingPreloads();
                     }
                 });
@@ -363,35 +400,19 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
         return new Runnable() {
             @Override
             public void run() {
-                Glide
-                        .with(context)
-                        .asFile()
-                        .load(imageSource.getSourceForLoad())
-                        .apply(options)
-                        .listener(new RequestListener<File>() {
-                            @Override
-                            public boolean onLoadFailed(@Nullable GlideException e, Object model, Target<File> target, boolean isFirstResource) {
-                                finishDownload(promise, failure(FastImageRequestListener.errorMessage(e)));
-                                return false;
-                            }
-
-                            @Override
-                            public boolean onResourceReady(File file, Object model, Target<File> target, DataSource dataSource, boolean isFirstResource) {
-                                finishDownload(promise, pathResult(file));
-                                return false;
-                            }
-                        })
-                        .preload();
+                loadFile(context, imageSource.getSourceForLoad(), options, new FileCallback() {
+                    @Override
+                    public void run(@Nullable File file, @Nullable String error) {
+                        finishDownload(promise, file != null ? pathResult(file) : failure(error));
+                    }
+                });
             }
         };
     }
 
     // Downloads a `web` image into its HTTP cache, which keeps it only if the
     // server allows caching it.
-    private static Runnable downloadToWebCache(
-            final FastImageSource imageSource,
-            final String url,
-            final Promise promise) {
+    private static Runnable downloadToWebCache(final FastImageSource imageSource, final Promise promise) {
         return new Runnable() {
             @Override
             public void run() {
@@ -401,7 +422,7 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
                         WritableMap result;
                         try {
                             FastImageOkHttpProgressGlideModule.downloadToWebCache(imageSource.getGlideUrl());
-                            File file = FastImageOkHttpProgressGlideModule.webCacheFile(url);
+                            File file = FastImageOkHttpProgressGlideModule.webCacheFile(imageSource.getUri().toString());
                             result = file != null
                                     ? pathResult(file)
                                     : failure("Not stored in the disk cache (the server doesn't allow caching it)");
@@ -415,6 +436,111 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
         };
     }
 
+    // Stores a local image file (file:// or content://) as the source's image
+    // in Glide's disk cache, so views and preloads of the source load it
+    // without downloading it, and resolves with its cached file: { ok, path }
+    // or { ok: false, error }. Never rejects. It doesn't replace an image
+    // that's already cached (Glide can't: a new image should get a new
+    // cacheKey), and doesn't store `web` sources (kept only in an HTTP cache,
+    // which can't be added to).
+    @ReactMethod
+    public void writeToCache(final ReadableMap source, final String file, final Promise promise) {
+        final ReactApplicationContext context = getReactApplicationContext();
+        if (FastImageViewConverter.getCacheControl(source) == FastImageCacheControl.WEB) {
+            promise.resolve(failure("Can't store cache: 'web' images (they're kept in an HTTP cache)"));
+            return;
+        }
+        final FastImageSource imageSource = FastImageViewConverter.hasUri(source)
+                ? FastImageViewConverter.getImageSource(context, source)
+                : null;
+        // A cacheKey is enough (the image doesn't need a url yet); otherwise a
+        // remote url.
+        final String cacheKey = FastImageViewConverter.getCacheKey(source);
+        if (cacheKey == null && (imageSource == null || !imageSource.isRemote())) {
+            promise.resolve(failure("Invalid source: no remote uri or cacheKey"));
+            return;
+        }
+        // What the image is cached under, and how the source looks it up.
+        final GlideUrl key = imageSource != null && imageSource.isRemote()
+                ? imageSource.getGlideUrl()
+                : FastImageKeyedGlideUrl.forKey(cacheKey);
+        final Object lookUp = imageSource != null && imageSource.isRemote() ? imageSource.getSourceForLoad() : key;
+        // A file:// or content:// uri, or a path.
+        Uri parsed = Uri.parse(file);
+        final Uri fileUri = parsed.getScheme() == null ? Uri.fromFile(new File(file)) : parsed;
+        if (!"file".equalsIgnoreCase(fileUri.getScheme()) && !"content".equalsIgnoreCase(fileUri.getScheme())) {
+            promise.resolve(failure("Not a local file"));
+            return;
+        }
+        cachePathExecutor.execute(new Runnable() {
+            @Override
+            public void run() {
+                if (cachedFile(context, lookUp, new RequestOptions()) != null) {
+                    promise.resolve(failure("Already in the disk cache"));
+                    return;
+                }
+                BitmapFactory.Options bounds = new BitmapFactory.Options();
+                bounds.inJustDecodeBounds = true;
+                try (InputStream stream = context.getContentResolver().openInputStream(fileUri)) {
+                    if (stream == null) throw new IOException();
+                    BitmapFactory.decodeStream(stream, null, bounds);
+                } catch (IOException | SecurityException e) {
+                    promise.resolve(failure("Can't read the file"));
+                    return;
+                }
+                // The platform's decoders (so HEIF too, where Android has
+                // them), as a view's would decode it.
+                if (bounds.outWidth <= 0 || bounds.outHeight <= 0) {
+                    promise.resolve(failure("Not an image"));
+                    return;
+                }
+                try {
+                    File cached = Glide.with(context)
+                            .asFile()
+                            .load(new FastImageCacheWrite(key, fileUri))
+                            .diskCacheStrategy(DiskCacheStrategy.DATA)
+                            .skipMemoryCache(true)
+                            .submit()
+                            .get();
+                    promise.resolve(pathResult(cached));
+                } catch (Exception e) {
+                    promise.resolve(failure("Couldn't store it: " + e));
+                }
+            }
+        });
+    }
+
+    // Saves maxDiskSize (bytes, 0 for no limit; null goes back to the app's
+    // manifest or Glide's default), which FastImageGlideModule applies when
+    // Glide starts: now if it hasn't started yet (this starts it), or on the
+    // next launch. Resolves with the limit in effect and the
+    // bytes the disk cache uses now: { maxDiskSize, diskSize }, or {} if the
+    // app starts Glide with its own AppGlideModule (its size and folder are
+    // the app's). maxDiskAge and maxMemorySize are iOS only (Glide has no
+    // age limit, and sizes its memory cache from the screen).
+    @ReactMethod
+    public void configureCache(final ReadableMap limits, final Promise promise) {
+        final ReactApplicationContext context = getReactApplicationContext();
+        if (limits.hasKey("maxDiskSize")) {
+            FastImageCacheLimits.saveMaxDiskSize(context, limits.isNull("maxDiskSize")
+                    ? null
+                    : (Long) (long) Math.max(limits.getDouble("maxDiskSize"), 0));
+        }
+        cachePathExecutor.execute(new Runnable() {
+            @Override
+            public void run() {
+                Glide.get(context);
+                WritableMap result = Arguments.createMap();
+                long maxDiskSize = FastImageCacheLimits.startedMaxDiskSize;
+                if (maxDiskSize >= 0) {
+                    result.putDouble("maxDiskSize", maxDiskSize);
+                    result.putDouble("diskSize", FastImageCacheLimits.diskSize(context));
+                }
+                promise.resolve(result);
+            }
+        });
+    }
+
     @ReactMethod
     public void clearMemoryCache(final Promise promise) {
         final Activity activity = getCurrentActivity();

package/android/src/main/java/com/dylanvann/fastimage/FastImageViewPackage.java

@@ -14,12 +14,14 @@ public class FastImageViewPackage implements ReactPackage {
     @NonNull
     @Override
     public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        FastImageCacheLimits.loadInBackground(reactContext);
         return Collections.<NativeModule>singletonList(new FastImageViewModule(reactContext));
     }
 
     @NonNull
     @Override
     public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        FastImageCacheLimits.loadInBackground(reactContext);
         return Collections.<ViewManager>singletonList(new FastImageViewManager());
     }
 }

package/app.plugin.js

@@ -0,0 +1,62 @@
+// Expo config plugin: sets FastImage's cache limits in the native projects, so
+// they're in effect from the first image. In app.json:
+//
+//     "plugins": [["react-native-fast-image", { "maxDiskSize": 209715200 }]]
+//
+// maxDiskSize (bytes), maxDiskAge (seconds, iOS) and maxMemorySize (bytes,
+// iOS); 0 means no limit. See the README's configureCache section.
+
+const INFO_PLIST_KEYS = {
+    maxDiskSize: 'FastImageMaxDiskSize',
+    maxDiskAge: 'FastImageMaxDiskAge',
+    maxMemorySize: 'FastImageMaxMemorySize',
+}
+const ANDROID_MAX_DISK_SIZE = 'fastimage.MAX_DISK_SIZE'
+
+// Sets the limits given in the iOS Info.plist.
+function setInfoPlist(infoPlist, options = {}) {
+    for (const [name, key] of Object.entries(INFO_PLIST_KEYS)) {
+        if (typeof options[name] === 'number') infoPlist[key] = options[name]
+    }
+    return infoPlist
+}
+
+// Sets maxDiskSize in the Android manifest's application meta-data (Android
+// only has that limit).
+function setAndroidManifest(manifest, options = {}) {
+    if (typeof options.maxDiskSize !== 'number') return manifest
+    const application = manifest.manifest.application[0]
+    const metaData = (application['meta-data'] || []).filter(
+        (item) => item.$['android:name'] !== ANDROID_MAX_DISK_SIZE,
+    )
+    metaData.push({
+        $: {
+            'android:name': ANDROID_MAX_DISK_SIZE,
+            'android:value': String(options.maxDiskSize),
+        },
+    })
+    application['meta-data'] = metaData
+    return manifest
+}
+
+function withFastImage(config, options) {
+    // From the Expo project, which has it (older SDKs only as the package).
+    let plugins
+    try {
+        plugins = require('expo/config-plugins')
+    } catch {
+        plugins = require('@expo/config-plugins')
+    }
+    config = plugins.withInfoPlist(config, (mod) => {
+        mod.modResults = setInfoPlist(mod.modResults, options)
+        return mod
+    })
+    return plugins.withAndroidManifest(config, (mod) => {
+        mod.modResults = setAndroidManifest(mod.modResults, options)
+        return mod
+    })
+}
+
+module.exports = withFastImage
+module.exports.setInfoPlist = setInfoPlist
+module.exports.setAndroidManifest = setAndroidManifest

package/dist/index.cjs.js

@@ -195,6 +195,8 @@ FastImage.preload = (sources) => Promise.resolve(react_native.NativeModules.Fast
 }));
 FastImage.clearMemoryCache = () => react_native.NativeModules.FastImageView.clearMemoryCache();
 FastImage.clearDiskCache = () => react_native.NativeModules.FastImageView.clearDiskCache();
+FastImage.configureCache = (limits = {}) => Promise.resolve(react_native.NativeModules.FastImageView.configureCache(limits));
+FastImage.writeToCache = (source, file) => Promise.resolve(react_native.NativeModules.FastImageView.writeToCache(source || {}, file));
 FastImage.getCachePath = (source) => Promise.resolve(react_native.NativeModules.FastImageView.getCachePath(source || {}));
 const styles = react_native.StyleSheet.create({
 	fallbackImage: {

package/dist/index.cjs.js.flow

@@ -53,6 +53,19 @@ export type LoadResult =
     | {| ok: true, width: number, height: number |}
     | {| ok: false, error: string |}
 
+export type CacheLimits = {|
+    maxDiskSize?: ?number,
+    maxDiskAge?: ?number,
+    maxMemorySize?: ?number,
+|}
+
+export type CacheState = {|
+    maxDiskSize?: number,
+    maxDiskAge?: number,
+    maxMemorySize?: number,
+    diskSize?: number,
+|}
+
 export type CachePathResult =
     | {| ok: true, path: string |}
     | {| ok: false, error: string |}
@@ -123,4 +136,9 @@ declare export default class FastImage extends React$Component<FastImageProps> {
     static clearMemoryCache: () => Promise<void>;
     static clearDiskCache: () => Promise<void>;
     static getCachePath: (source: FastImageSource) => Promise<CachePathResult>;
+    static configureCache: (limits?: CacheLimits) => Promise<CacheState>;
+    static writeToCache: (
+        source: FastImageSource,
+        file: string,
+    ) => Promise<CachePathResult>;
 }

package/dist/index.d.ts

@@ -62,6 +62,17 @@ export type LoadResult = {
     ok: false;
     error: string;
 };
+export interface CacheLimits {
+    maxDiskSize?: number | null;
+    maxDiskAge?: number | null;
+    maxMemorySize?: number | null;
+}
+export interface CacheState {
+    maxDiskSize?: number;
+    maxDiskAge?: number;
+    maxMemorySize?: number;
+    diskSize?: number;
+}
 export type CachePathResult = {
     ok: true;
     path: string;
@@ -189,9 +200,28 @@ export interface FastImageStaticProperties {
     /**
      * The path of the source's downloaded file in the disk cache, downloading
      * it first if it isn't there (without decoding it). With
-     * `cache: 'cacheOnly'` it doesn't download. Never rejects.
+     * `cache: 'cacheOnly'`, or a `cacheKey` without a `uri`, it doesn't
+     * download. Never rejects.
      */
     getCachePath: (source: Source) => Promise<CachePathResult>;
+    /**
+     * Stores a local image file (a `file://` uri or a path, or on Android a
+     * `content://` uri) as the source's image in the disk cache, so views and
+     * preloads of the source show it without downloading it. A source with a
+     * `cacheKey` doesn't need a `uri`. Resolves with its cached file. Doesn't
+     * replace an image that's already cached, and isn't for `cache: 'web'`
+     * sources. Never rejects.
+     */
+    writeToCache: (source: Source, file: string) => Promise<CachePathResult>;
+    /**
+     * Changes the cache's limits at runtime (only those given; 0 for no
+     * limit, null to go back to the app's native config) and saves them, then
+     * resolves with the limits in effect and the disk cache's size. Without
+     * limits, only resolves. iOS applies changes at once. Android only has
+     * `maxDiskSize`, applied when Glide starts: at once if no image has
+     * loaded yet, otherwise from the next launch.
+     */
+    configureCache: (limits?: CacheLimits) => Promise<CacheState>;
 }
 declare const FastImage: React.ComponentType<FastImageProps> & FastImageStaticProperties;
 export interface FastImageBackgroundProps extends Omit<FastImageProps, 'style' | 'children'> {

package/dist/index.js

@@ -168,6 +168,8 @@ FastImage.preload = (sources) => Promise.resolve(NativeModules.FastImageView.pre
 }));
 FastImage.clearMemoryCache = () => NativeModules.FastImageView.clearMemoryCache();
 FastImage.clearDiskCache = () => NativeModules.FastImageView.clearDiskCache();
+FastImage.configureCache = (limits = {}) => Promise.resolve(NativeModules.FastImageView.configureCache(limits));
+FastImage.writeToCache = (source, file) => Promise.resolve(NativeModules.FastImageView.writeToCache(source || {}, file));
 FastImage.getCachePath = (source) => Promise.resolve(NativeModules.FastImageView.getCachePath(source || {}));
 const styles = StyleSheet.create({
 	fallbackImage: {

package/dist/index.js.flow

@@ -53,6 +53,19 @@ export type LoadResult =
     | {| ok: true, width: number, height: number |}
     | {| ok: false, error: string |}
 
+export type CacheLimits = {|
+    maxDiskSize?: ?number,
+    maxDiskAge?: ?number,
+    maxMemorySize?: ?number,
+|}
+
+export type CacheState = {|
+    maxDiskSize?: number,
+    maxDiskAge?: number,
+    maxMemorySize?: number,
+    diskSize?: number,
+|}
+
 export type CachePathResult =
     | {| ok: true, path: string |}
     | {| ok: false, error: string |}
@@ -123,4 +136,9 @@ declare export default class FastImage extends React$Component<FastImageProps> {
     static clearMemoryCache: () => Promise<void>;
     static clearDiskCache: () => Promise<void>;
     static getCachePath: (source: FastImageSource) => Promise<CachePathResult>;
+    static configureCache: (limits?: CacheLimits) => Promise<CacheState>;
+    static writeToCache: (
+        source: FastImageSource,
+        file: string,
+    ) => Promise<CachePathResult>;
 }

package/ios/FastImage/FFFastImageSource.h

@@ -62,9 +62,12 @@ typedef NS_ENUM(NSInteger, FFFCacheControl) {
 + (NSURLCache *)webURLCache;
 
 // After a load of this source failed: for a `cache: 'web'` image whose data
-// isn't an image (e.g. a captive portal's HTML page), removes the response
-// from the HTTP cache, which stored it as it downloaded. Otherwise the next
-// loads would get it from there until it expires, and fail again.
+// isn't an image, removes the response from the HTTP cache, which stored it as
+// it downloaded. Otherwise the next loads would get it from there until it
+// expires, and fail again. The web loader already doesn't store responses
+// that aren't images (e.g. a captive portal's HTML page); this is for data
+// that looks like an image but can't be decoded, or an app's own operation
+// class.
 - (void)forgetResponseAfterError:(NSError *)error;
 
 @end

package/ios/FastImage/FFFastImageSource.m

@@ -3,9 +3,35 @@
 #import <SDWebImage/SDWebImageDownloaderResponseModifier.h>
 #import <SDWebImage/SDWebImageDownloaderDecryptor.h>
 #import <SDWebImage/SDWebImageError.h>
+#import <SDWebImage/SDWebImageDownloaderOperation.h>
+#import <SDWebImage/NSData+ImageContentType.h>
 
 static NSUInteger const FFFWebCacheSize = 50 * 1024 * 1024;
 
+// Downloads `cache: 'web'` images. The HTTP cache only stores a response whose
+// body is an image: a page sent instead (e.g. a captive portal's, with status
+// 200) would be served from there until it expired, and each load would fail.
+// Removing it after a load failed (forgetResponseAfterError:) could still be
+// in progress when the next load started.
+@interface FFFWebDownloaderOperation : SDWebImageDownloaderOperation
+@end
+
+@implementation FFFWebDownloaderOperation
+
+- (void)URLSession:(NSURLSession *)session
+          dataTask:(NSURLSessionDataTask *)dataTask
+ willCacheResponse:(NSCachedURLResponse *)proposedResponse
+ completionHandler:(void (^)(NSCachedURLResponse *cachedResponse))completionHandler
+{
+    if ([NSData sd_imageFormatForImageData:proposedResponse.data] == SDImageFormatUndefined) {
+        completionHandler(nil);
+        return;
+    }
+    [super URLSession:session dataTask:dataTask willCacheResponse:proposedResponse completionHandler:completionHandler];
+}
+
+@end
+
 @implementation FFFastImageSource
 
 - (instancetype)initWithURL:(NSURL *)url
@@ -62,6 +88,10 @@ static NSUInteger const FFFWebCacheSize = 50 * 1024 * 1024;
         NSURLSessionConfiguration *session = [(config.sessionConfiguration ?: NSURLSessionConfiguration.defaultSessionConfiguration) copy];
         session.URLCache = [FFFastImageSource webURLCache];
         config.sessionConfiguration = session;
+        // Unless the app set its own operation class.
+        if (!config.operationClass || config.operationClass == [SDWebImageDownloaderOperation class]) {
+            config.operationClass = [FFFWebDownloaderOperation class];
+        }
         downloader = [[SDWebImageDownloader alloc] initWithConfig:config];
         // The shared downloader's response modifier and decryptor, when it
         // has them (as they are at each download). Its request modifier