react-native-fast-image 8.16.0 → 8.16.2

package/README.md

@@ -349,6 +349,8 @@ for (const result of results) {
 }
 ```
 
+Each source's `cache` applies, as for a view: with `web` the preload follows the HTTP cache, and with `cacheOnly` it doesn't download. A `cacheOnly` preload resolves `ok` only if the image is cached, and loads it from the disk cache into memory, so a view shows it at once.
+
 ### `FastImage.clearMemoryCache: () => Promise<void>`
 
 Clear all images from memory cache.

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

@@ -2,6 +2,7 @@ package com.dylanvann.fastimage;
 
 import android.content.Context;
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import com.bumptech.glide.Glide;
 import com.bumptech.glide.Registry;
@@ -42,6 +43,15 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
 
     private static final DispatchingProgressListener progressListener = new DispatchingProgressListener();
     private static final long WEB_CACHE_SIZE = 50 * 1024 * 1024;
+    // The HTTP cache of `cache: 'web'` images, once Glide has set up.
+    @Nullable
+    private static Cache webCache;
+
+    // Empties the HTTP cache of `cache: 'web'` images (clearDiskCache).
+    static void clearWebCache() throws IOException {
+        Cache cache = webCache;
+        if (cache != null) cache.evictAll();
+    }
 
     @Override
     public void registerComponents(
@@ -64,15 +74,14 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
         OkHttpUrlLoader.Factory factory = new OkHttpUrlLoader.Factory(client);
         registry.replace(GlideUrl.class, InputStream.class, factory);
 
-        // `cache: 'web'` skips Glide's caches and relies on HTTP caching, but
-        // React Native's shared client has no HTTP cache (unless the app gave
-        // it one), so those urls get a client with one (#280). Other urls are
-        // cached by Glide, so they don't use it (that would store them twice).
-        OkHttpClient webClient = client.cache() != null
-                ? client
-                : client.newBuilder()
-                        .cache(new Cache(new File(context.getCacheDir(), "fast-image-http-cache"), WEB_CACHE_SIZE))
-                        .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
+        // clearDiskCache can empty it without the app's other responses.
+        // Other urls are cached by Glide, so they don't use it (that would
+        // store them twice).
+        webCache = new Cache(new File(context.getCacheDir(), "fast-image-http-cache"), WEB_CACHE_SIZE);
+        OkHttpClient webClient = client.newBuilder().cache(webCache).build();
         registry.prepend(FastImageWebGlideUrl.class, InputStream.class, new WebUrlLoaderFactory(webClient));
     }
 

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

@@ -24,6 +24,7 @@ import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 
+import java.io.IOException;
 import java.util.ArrayDeque;
 
 class FastImageViewModule extends ReactContextBaseJavaModule {
@@ -190,6 +191,13 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
         }
 
         Glide.get(activity.getApplicationContext()).clearDiskCache();
+        // And the HTTP cache of `cache: 'web'` images, which Glide doesn't
+        // cache.
+        try {
+            FastImageOkHttpProgressGlideModule.clearWebCache();
+        } catch (IOException e) {
+            // Cleared as far as it could.
+        }
         promise.resolve(null);
     }
 }

package/ios/FastImage/FFFastImageSource.h

@@ -2,6 +2,8 @@
 #import <UIKit/UIKit.h>
 #import <SDWebImage/SDWebImageDownloaderRequestModifier.h>
 #import <SDWebImage/SDWebImageCacheKeyFilter.h>
+#import <SDWebImage/SDWebImageDefine.h>
+#import <SDWebImage/SDImageLoader.h>
 
 typedef NS_ENUM(NSInteger, FFFPriority) {
     FFFPriorityLow,
@@ -42,4 +44,17 @@ typedef NS_ENUM(NSInteger, FFFCacheControl) {
 // Caches the image under cacheKey, or nil without one.
 - (SDWebImageCacheKeyFilter *)cacheKeyFilter;
 
+// The load options for `cache`: web follows the HTTP cache, cacheOnly never
+// downloads. For views and preload alike.
+- (SDWebImageOptions)cacheOptions;
+
+// The loader for `cache: 'web'` images, whose HTTP cache is their own (see
+// webURLCache), or nil for SDWebImage's shared one.
+- (id<SDImageLoader>)imageLoader;
+
+// The HTTP cache of `cache: 'web'` images: their own rather than the app's
+// shared NSURLCache, so clearDiskCache can empty it without the app's other
+// responses. 50 MB, as on Android.
++ (NSURLCache *)webURLCache;
+
 @end

package/ios/FastImage/FFFastImageSource.m

@@ -1,4 +1,9 @@
 #import "FFFastImageSource.h"
+#import <SDWebImage/SDWebImageDownloader.h>
+#import <SDWebImage/SDWebImageDownloaderResponseModifier.h>
+#import <SDWebImage/SDWebImageDownloaderDecryptor.h>
+
+static NSUInteger const FFFWebCacheSize = 50 * 1024 * 1024;
 
 @implementation FFFastImageSource
 
@@ -29,6 +34,71 @@
     }];
 }
 
+- (SDWebImageOptions)cacheOptions
+{
+    switch (_cacheControl) {
+        case FFFCacheControlWeb:
+            return SDWebImageRefreshCached;
+        case FFFCacheControlCacheOnly:
+            return SDWebImageFromCacheOnly;
+        case FFFCacheControlImmutable:
+            return 0;
+    }
+    return 0;
+}
+
+- (id<SDImageLoader>)imageLoader
+{
+    if (_cacheControl != FFFCacheControlWeb) {
+        return nil;
+    }
+    static SDWebImageDownloader *downloader;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        // As SDWebImage's shared downloader is set up, with the HTTP cache.
+        SDWebImageDownloaderConfig *config = [SDWebImageDownloader.sharedDownloader.config copy];
+        NSURLSessionConfiguration *session = [(config.sessionConfiguration ?: NSURLSessionConfiguration.defaultSessionConfiguration) copy];
+        session.URLCache = [FFFastImageSource webURLCache];
+        config.sessionConfiguration = session;
+        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
+        // wouldn't apply anyway: each load's own (for its headers) replaces
+        // it. Headers set with setValue:forHTTPHeaderField: can't be read
+        // back, so web images don't get those.
+        downloader.responseModifier = [SDWebImageDownloaderResponseModifier responseModifierWithBlock:^NSURLResponse * _Nullable(NSURLResponse * _Nonnull response) {
+            id<SDWebImageDownloaderResponseModifier> shared = SDWebImageDownloader.sharedDownloader.responseModifier;
+            return shared ? [shared modifiedResponseWithResponse:response] : response;
+        }];
+        downloader.decryptor = [SDWebImageDownloaderDecryptor decryptorWithBlock:^NSData * _Nullable(NSData * _Nonnull data, NSURLResponse * _Nullable response) {
+            id<SDWebImageDownloaderDecryptor> shared = SDWebImageDownloader.sharedDownloader.decryptor;
+            return shared ? [shared decryptedDataWithData:data response:response] : data;
+        }];
+    });
+    return downloader;
+}
+
++ (NSURLCache *)webURLCache
+{
+    static NSURLCache *cache;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        NSString *name = @"fast-image-http-cache";
+        if (@available(iOS 13.0, tvOS 13.0, *)) {
+            NSURL *caches = [NSFileManager.defaultManager URLsForDirectory:NSCachesDirectory inDomains:NSUserDomainMask].firstObject;
+            cache = [[NSURLCache alloc] initWithMemoryCapacity:0
+                                                  diskCapacity:FFFWebCacheSize
+                                                  directoryURL:[caches URLByAppendingPathComponent:name]];
+        } else {
+            // In the app's caches directory.
+            cache = [[NSURLCache alloc] initWithMemoryCapacity:0
+                                                  diskCapacity:FFFWebCacheSize
+                                                      diskPath:name];
+        }
+    });
+    return cache;
+}
+
 - (SDWebImageDownloaderRequestModifier *)requestModifier
 {
     NSDictionary* headers = _headers;

package/ios/FastImage/FFFastImageView.m

@@ -500,17 +500,7 @@ NSString *FFFErrorMessage(NSError *error)
             break;
     }
 
-    switch (_source.cacheControl) {
-        case FFFCacheControlWeb:
-            options |= SDWebImageRefreshCached;
-            break;
-        case FFFCacheControlCacheOnly:
-            options |= SDWebImageFromCacheOnly;
-            break;
-        case FFFCacheControlImmutable:
-            break;
-    }
-    return options;
+    return options | [_source cacheOptions];
 }
 
 // Headers, and the size to decode at (see FFFDownsampledImage), which it
@@ -518,6 +508,7 @@ NSString *FFFErrorMessage(NSError *error)
 - (SDWebImageContext*) loadContext {
     SDWebImageMutableContext* context = [NSMutableDictionary dictionary];
     context[SDWebImageContextDownloadRequestModifier] = _source.requestModifier;
+    context[SDWebImageContextImageLoader] = _source.imageLoader;
     context[SDWebImageContextCacheKeyFilter] = _source.cacheKeyFilter;
     CGSize box = [self decodeBox];
     self.decodedBox = box;

package/ios/FastImage/FFFastImageViewManager.m

@@ -42,6 +42,7 @@ static SDWebImageMutableContext *FFFPreloadContext(FFFastImageSource *source)
 {
     SDWebImageMutableContext *context = [NSMutableDictionary dictionary];
     context[SDWebImageContextDownloadRequestModifier] = source.requestModifier;
+    context[SDWebImageContextImageLoader] = source.imageLoader;
     context[SDWebImageContextCacheKeyFilter] = source.cacheKeyFilter;
     return context;
 }
@@ -89,8 +90,9 @@ RCT_EXPORT_METHOD(preload:(nonnull NSArray<FFFastImageSource *> *)sources
             }
         };
         // With the prefetcher's options (low priority), but one source at a
-        // time (not SDWebImagePrefetcher), to get each source's result and to
-        // send its headers with its own request only.
+        // time (not SDWebImagePrefetcher), to get each source's result, to
+        // send its headers with its own request only, and to follow its
+        // `cache` (#406).
         SDWebImageOptions prefetcherOptions = [SDWebImagePrefetcher sharedImagePrefetcher].options;
 
         [sources enumerateObjectsUsingBlock:^(FFFastImageSource * _Nonnull source, NSUInteger idx, BOOL * _Nonnull stop) {
@@ -112,6 +114,7 @@ RCT_EXPORT_METHOD(preload:(nonnull NSArray<FFFastImageSource *> *)sources
                     options |= SDWebImageHighPriority;
                 }
             }
+            options |= [source cacheOptions];
             [FFFPendingPreloads addObject:[^{
                 // Once per slot: SDWebImage calls this once with finished set
                 // (a progressive load calls it more, without).
@@ -151,6 +154,8 @@ RCT_EXPORT_METHOD(clearMemoryCache:(RCTPromiseResolveBlock)resolve reject:(RCTPr
 
 RCT_EXPORT_METHOD(clearDiskCache:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
 {
+    // And the HTTP cache of `cache: 'web'` images.
+    [FFFastImageSource.webURLCache removeAllCachedResponses];
     [SDImageCache.sharedImageCache clearDiskOnCompletion:^(){
         resolve(NULL);
     }];

package/package.json

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