react-native-fast-image 10.0.0 → 10.1.1

package/README.md

@@ -201,6 +201,16 @@ Whether the decoded image is kept in the memory cache. With `false` it's only ke
 
 ---
 
+##### `source.diskCache`
+
+**Type:** `boolean` · **Default:** `true`
+
+Whether the image is kept on disk. With `false` it isn't kept in the disk cache or an HTTP cache, or read from them. Use it for images the app shouldn't keep once they've been shown (e.g. disappearing messages, or where a security policy doesn't allow caching sensitive images), images that change every time they load, or large images shown once, which would push other images out of the disk cache. The image is downloaded again whenever it isn't in memory, e.g. for a view of another size (or on Android, a change of `blurRadius` or `objectFit`), so with `memoryCache: false` too it's downloaded each time it's shown. With `cache: 'web'` it isn't kept in memory either, so it's downloaded every time it loads. With `cache: 'cacheOnly'` it's only looked for in memory. On Android, a large download is held in a temporary file while it loads, as every download is, deleted as soon as it's opened.
+
+`FastImage.preload`, `getCachePath` and `writeToCache` resolve not `ok` for it: there's no file, and a view decodes the image for its own size, so it may download a preloaded one again. A source for the same url (or `cacheKey`) without `diskCache: false` still stores the image.
+
+---
+
 ##### `source.width`
 
 **Type:** `number`
@@ -873,7 +883,7 @@ FastImage works on the web with [react-native-web](https://necolas.github.io/rea
 Support is minimal:
 
 - Props that work: `source` (a `uri`, a `require()`d image, or several sizes), `defaultSource`, `objectFit`, `objectPosition`, `tintColor`, `blurRadius`, `style`, `onLoadStart`, `onLoad`, `onError`, `onLoadEnd`, and View props such as `testID`, accessibility props, `onLayout` and `pointerEvents`.
-- Ignored: `source.headers` (a browser can't send them for an image), `source.priority`, `source.cache`, `source.cacheKey`, `source.memoryCache`, `recyclingKey`, `loop`, `imageRendering`, `paused`, `transition`, `downsample` and `onProgress`.
+- Ignored: `source.headers` (a browser can't send them for an image), `source.priority`, `source.cache`, `source.cacheKey`, `source.memoryCache`, `source.diskCache`, `recyclingKey`, `loop`, `imageRendering`, `paused`, `transition`, `downsample` and `onProgress`.
 - The image is an `<img>` element that fills the view inside its borders, with `objectFit` and `objectPosition` as its CSS `object-fit` and `object-position`. `tintColor` is an SVG filter and `blurRadius` a CSS `blur()`, and `defaultSource` is another `<img>`, under the image until it has loaded. A new `source` gets a new `<img>`, so the previous image doesn't stay while it loads (with several sizes, the browser shows it until the new one has loaded).
 - Several sizes are shown with a lazily loaded `<img>` whose `srcset` lists them, with `sizes="auto, 100vw"`: the browser loads the one for the width the image is shown at, in device pixels (usually the smallest that's at least as wide). Browsers that don't support `sizes="auto"` use the viewport's width.
 - `FastImage.preload` loads the images into the browser's cache and resolves with a result per source. `clearMemoryCache`, `clearDiskCache` and `configureCache` resolve without doing anything (the browser manages its cache), and `getCachePath` and `writeToCache` resolve with `{ ok: false, error: 'Not supported on the web' }`.

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

@@ -22,6 +22,16 @@ final class FastImageGlide {
         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;

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

@@ -154,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);
@@ -168,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
@@ -186,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/fastimage/FastImageSource.java

@@ -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/fastimage/FastImageViewConverter.java

@@ -62,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) {
@@ -71,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"));
         }
@@ -120,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)
@@ -127,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()) {

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

@@ -136,6 +136,13 @@ class FastImageViewModule extends NativeFastImageModuleSpec {
                         finishOne.run();
                         continue;
                     }
+                    // Views decode an image for their own size, so one only
+                    // preloaded into memory would be downloaded again.
+                    if (!FastImageViewConverter.isDiskCache(source)) {
+                        results[i] = failure(NOT_ON_DISK);
+                        finishOne.run();
+                        continue;
+                    }
                     final FastImageSource imageSource = FastImageViewConverter.getImageSource(context, source);
                     // A uri that can't be resolved (e.g. a relative path) resolves
                     // to an empty one.
@@ -314,6 +321,10 @@ class FastImageViewModule extends NativeFastImageModuleSpec {
         }
     }
 
+    // preload's, getCachePath's and writeToCache's error for a source with
+    // diskCache false.
+    private static final String NOT_ON_DISK = "The source has diskCache: false, so it isn't kept on disk";
+
     private static WritableMap failure(String error) {
         WritableMap result = Arguments.createMap();
         result.putBoolean("ok", false);
@@ -342,6 +353,10 @@ class FastImageViewModule extends NativeFastImageModuleSpec {
     @Override
     public void getCachePath(final ReadableMap source, final Promise promise) {
         final ReactApplicationContext context = getReactApplicationContext();
+        if (!FastImageViewConverter.isDiskCache(source)) {
+            promise.resolve(failure(NOT_ON_DISK));
+            return;
+        }
         if (!FastImageViewConverter.hasUri(source)) {
             // `web` images ignore cacheKey.
             final String cacheKey = FastImageViewConverter.getCacheControl(source) == FastImageCacheControl.WEB
@@ -474,6 +489,10 @@ class FastImageViewModule extends NativeFastImageModuleSpec {
     @Override
     public void writeToCache(final ReadableMap source, final String file, final Promise promise) {
         final ReactApplicationContext context = getReactApplicationContext();
+        if (!FastImageViewConverter.isDiskCache(source)) {
+            promise.resolve(failure(NOT_ON_DISK));
+            return;
+        }
         if (FastImageViewConverter.getCacheControl(source) == FastImageCacheControl.WEB) {
             promise.resolve(failure("Can't store cache: 'web' images (they're kept in an HTTP cache)"));
             return;

package/dist/index.cjs.js.flow

@@ -117,6 +117,7 @@ export type FastImageSource = {
     cache?: CacheControls,
     cacheKey?: string,
     memoryCache?: boolean,
+    diskCache?: boolean,
     width?: number,
     height?: number,
     scale?: number,

package/dist/index.cjs.web.js.flow

@@ -117,6 +117,7 @@ export type FastImageSource = {
     cache?: CacheControls,
     cacheKey?: string,
     memoryCache?: boolean,
+    diskCache?: boolean,
     width?: number,
     height?: number,
     scale?: number,

package/dist/index.d.ts

@@ -86,6 +86,31 @@ export type Source = {
      * @default true
      */
     memoryCache?: boolean;
+    /**
+     * Whether the image is kept on disk. With `false` it isn't kept in the
+     * disk cache or an HTTP cache, or read from them. Use it for images the
+     * app shouldn't
+     * keep once they've been shown (e.g. disappearing messages, or where a
+     * security policy doesn't allow caching sensitive images), images that
+     * change every time they load, or large images shown once, which would
+     * push other images out of the disk cache.
+     * The image is downloaded again whenever it isn't in memory, e.g. for a
+     * view of another size (or on Android, a change of `blurRadius` or
+     * `objectFit`), so with `memoryCache: false` too it's downloaded each
+     * time it's shown. With `cache: 'web'` it isn't kept in memory either,
+     * so it's downloaded every time it loads. With `cache: 'cacheOnly'` it's
+     * only looked for in memory. On Android, a large download is held in a
+     * temporary file while it loads, as every download is, deleted as soon
+     * as it's opened.
+     *
+     * `FastImage.preload`, `getCachePath` and `writeToCache` resolve not `ok`
+     * for it: there's no file, and a view decodes the image for its own
+     * size, so it may download a preloaded one again. A source for the same
+     * url (or `cacheKey`) without `diskCache: false` still stores the image.
+     *
+     * @default true
+     */
+    diskCache?: boolean;
     /**
      * With several sources (`source` as an array), the image's width at this
      * uri, in pixels (times `scale`, if given).

package/dist/index.js.flow

@@ -117,6 +117,7 @@ export type FastImageSource = {
     cache?: CacheControls,
     cacheKey?: string,
     memoryCache?: boolean,
+    diskCache?: boolean,
     width?: number,
     height?: number,
     scale?: number,

package/dist/index.web.js.flow

@@ -117,6 +117,7 @@ export type FastImageSource = {
     cache?: CacheControls,
     cacheKey?: string,
     memoryCache?: boolean,
+    diskCache?: boolean,
     width?: number,
     height?: number,
     scale?: number,

package/ios/FastImage/FFFastImageModule.mm

@@ -255,6 +255,10 @@ static NSDictionary *FFFFailure(NSString *error)
     return @{@"ok": @NO, @"error": error};
 }
 
+// preload's, getCachePath's and writeToCache's error for a source with
+// diskCache false.
+static NSString *const FFFNotOnDisk = @"The source has diskCache: false, so it isn't kept on disk";
+
 static NSDictionary *FFFFile(NSString *path)
 {
     return @{@"ok": @YES, @"path": path};
@@ -290,6 +294,13 @@ static NSDictionary *FFFFile(NSString *path)
                 finishOne();
                 return;
             }
+            if (!source.diskCache) {
+                // Views decode an image for their own size, so one only
+                // preloaded into memory would be downloaded again.
+                [results addObject:FFFFailure(FFFNotOnDisk)];
+                finishOne();
+                return;
+            }
             [results addObject:[NSNull null]];
             SDWebImageOptions options = FFFPreloadOptions(source);
             SDWebImageMutableContext *context = FFFPreloadContext(source);
@@ -327,6 +338,10 @@ static NSDictionary *FFFFile(NSString *path)
               reject:(__unused RCTPromiseRejectBlock)reject
 {
     FFFastImageSource *source = [RCTConvert FFFastImageSource:sourceJSON];
+    if (source && !source.diskCache) {
+        resolve(FFFFailure(FFFNotOnDisk));
+        return;
+    }
     if (!source.url) {
         NSString *key = FFFDiskCacheKey(source);
         if (!key) {
@@ -387,6 +402,10 @@ static NSDictionary *FFFFile(NSString *path)
               reject:(__unused RCTPromiseRejectBlock)reject
 {
     FFFastImageSource *source = [RCTConvert FFFastImageSource:sourceJSON];
+    if (source && !source.diskCache) {
+        resolve(FFFFailure(FFFNotOnDisk));
+        return;
+    }
     if (source.cacheControl == FFFCacheControlWeb) {
         resolve(FFFFailure(@"Can't store cache: 'web' images (they're kept in an HTTP cache)"));
         return;

package/ios/FastImage/FFFastImageSource.h

@@ -39,6 +39,10 @@ typedef NS_ENUM(NSInteger, FFFCacheControl) {
 // default YES). Without it, it's only kept on disk: views don't leave it in
 // memory, and preload doesn't decode it.
 @property (nonatomic) BOOL memoryCache;
+// Whether the image is kept in the disk cache (`diskCache`, default YES).
+// Without it, it isn't read from or written to the disk cache, nor for `web`
+// images the HTTP cache.
+@property (nonatomic) BOOL diskCache;
 
 - (instancetype)initWithURL:(NSURL *)url
                    priority:(FFFPriority)priority

package/ios/FastImage/FFFastImageSource.m

@@ -346,6 +346,7 @@ static BOOL FFFLooksLikeSVG(NSData *data)
         _headers = headers;
         _cacheControl = cacheControl;
         _memoryCache = YES;
+        _diskCache = YES;
     }
     return self;
 }
@@ -366,7 +367,10 @@ static BOOL FFFLooksLikeSVG(NSData *data)
 {
     switch (_cacheControl) {
         case FFFCacheControlWeb:
-            return SDWebImageRefreshCached;
+            // Without the disk cache, nor the HTTP cache: without this option
+            // SDWebImage's requests neither read it nor store their responses
+            // there.
+            return _diskCache ? SDWebImageRefreshCached : 0;
         case FFFCacheControlCacheOnly:
             return SDWebImageFromCacheOnly;
         case FFFCacheControlImmutable:

package/ios/FastImage/FFFastImageView.m

@@ -1031,10 +1031,7 @@ NSString *FFFErrorMessage(NSError *error)
     context[SDWebImageContextCacheKeyFilter] = source.cacheKeyFilter;
     if (CGSizeEqualToSize(box, CGSizeZero)) {
         [FFFDownsampledImage addFullSizeToContext: context];
-        if (!source.memoryCache) {
-            // Only on disk, also when it comes from there.
-            context[SDWebImageContextStoreCacheType] = @(SDImageCacheTypeDisk);
-        }
+        [self applyCacheOptions: context source: source fullSize: YES];
         [FFFDownsampledImage forgetSmallerFullSizeImageForURL: source.url context: context];
         return context;
     }
@@ -1046,12 +1043,35 @@ NSString *FFFErrorMessage(NSError *error)
         context[SDWebImageContextOriginalStoreCacheType] = @(SDImageCacheTypeNone);
         context[SDWebImageContextOriginalQueryCacheType] = @(SDImageCacheTypeNone);
     }
+    [self applyCacheOptions: context source: source fullSize: NO];
+    return context;
+}
+
+// The source's memoryCache and diskCache: which caches the image is looked up
+// in and kept in. fullSize: the image is decoded at its own size, rather than
+// smaller (addToContext keeps those in memory only, as the disk cache has the
+// downloaded file).
+- (void) applyCacheOptions: (SDWebImageMutableContext*)context source: (FFFastImageSource*)source fullSize: (BOOL)fullSize {
+    if (!source.diskCache) {
+        // Neither the downloaded file (the original, for a smaller decode)
+        // nor the decoded image is read from or written to the disk cache. A
+        // `web` one isn't kept in memory either, as on Android: it's
+        // downloaded every time it loads.
+        SDImageCacheType memory = source.memoryCache && source.cacheControl != FFFCacheControlWeb
+            ? SDImageCacheTypeMemory
+            : SDImageCacheTypeNone;
+        context[SDWebImageContextStoreCacheType] = @(memory);
+        context[SDWebImageContextQueryCacheType] = @(memory);
+        context[SDWebImageContextOriginalStoreCacheType] = @(SDImageCacheTypeNone);
+        context[SDWebImageContextOriginalQueryCacheType] = @(SDImageCacheTypeNone);
+        return;
+    }
     if (!source.memoryCache) {
-        // The smaller copy is only kept in memory, so it isn't kept (the
-        // downloaded file is still on disk).
-        context[SDWebImageContextStoreCacheType] = @(SDImageCacheTypeNone);
+        // Only on disk, also when it comes from there. A smaller copy is
+        // only kept in memory, so it isn't kept (the downloaded file is still
+        // on disk).
+        context[SDWebImageContextStoreCacheType] = @(fullSize ? SDImageCacheTypeDisk : SDImageCacheTypeNone);
     }
-    return context;
 }
 
 // events: NO for a quiet reload at a new size (see reloadIfResized), which
@@ -1154,6 +1174,13 @@ NSString *FFFErrorMessage(NSError *error)
                 if (weakSelf.loadCount != load) {
                     return;
                 }
+                // cacheOnly: SDWebImage completes the load of an image that
+                // isn't cached with neither an image nor an error.
+                if (!error && !image) {
+                    error = [NSError errorWithDomain: @"FastImage"
+                                                code: 0
+                                            userInfo: @{NSLocalizedDescriptionKey: @"Not in the cache"}];
+                }
                 // The download was running when the app went to the
                 // background, and failed: iOS suspends it there, and its
                 // timeout keeps counting, so it times out as the app comes

package/ios/FastImage/RCTConvert+FFFastImage.m

@@ -59,6 +59,8 @@ RCT_ENUM_CONVERTER(FFFCacheControl, (@{
     imageSource.cacheKey = cacheKey.length > 0 ? cacheKey : nil;
     id memoryCache = json[@"memoryCache"];
     imageSource.memoryCache = memoryCache && memoryCache != (id)kCFNull ? [self BOOL:memoryCache] : YES;
+    id diskCache = json[@"diskCache"];
+    imageSource.diskCache = diskCache && diskCache != (id)kCFNull ? [self BOOL:diskCache] : YES;
     CGFloat scale = json[@"scale"] && json[@"scale"] != (id)kCFNull ? [self CGFloat:json[@"scale"]] : 1;
     imageSource.pixelCount = [self CGFloat:json[@"width"]] * [self CGFloat:json[@"height"]] * scale * scale;
     

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-fast-image",
-    "version": "10.0.0",
+    "version": "10.1.1",
     "description": "FastImage, performant React Native image component.",
     "keywords": [
         "cache",

package/src/index.js.flow

@@ -117,6 +117,7 @@ export type FastImageSource = {
     cache?: CacheControls,
     cacheKey?: string,
     memoryCache?: boolean,
+    diskCache?: boolean,
     width?: number,
     height?: number,
     scale?: number,

package/src/index.tsx

@@ -104,6 +104,31 @@ export type Source = {
      * @default true
      */
     memoryCache?: boolean
+    /**
+     * Whether the image is kept on disk. With `false` it isn't kept in the
+     * disk cache or an HTTP cache, or read from them. Use it for images the
+     * app shouldn't
+     * keep once they've been shown (e.g. disappearing messages, or where a
+     * security policy doesn't allow caching sensitive images), images that
+     * change every time they load, or large images shown once, which would
+     * push other images out of the disk cache.
+     * The image is downloaded again whenever it isn't in memory, e.g. for a
+     * view of another size (or on Android, a change of `blurRadius` or
+     * `objectFit`), so with `memoryCache: false` too it's downloaded each
+     * time it's shown. With `cache: 'web'` it isn't kept in memory either,
+     * so it's downloaded every time it loads. With `cache: 'cacheOnly'` it's
+     * only looked for in memory. On Android, a large download is held in a
+     * temporary file while it loads, as every download is, deleted as soon
+     * as it's opened.
+     *
+     * `FastImage.preload`, `getCachePath` and `writeToCache` resolve not `ok`
+     * for it: there's no file, and a view decodes the image for its own
+     * size, so it may download a preloaded one again. A source for the same
+     * url (or `cacheKey`) without `diskCache: false` still stores the image.
+     *
+     * @default true
+     */
+    diskCache?: boolean
     /**
      * With several sources (`source` as an array), the image's width at this
      * uri, in pixels (times `scale`, if given).