react-native-fast-image 10.8.0 → 10.8.2

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

@@ -1,5 +1,8 @@
 package com.fastimage;
 
+import android.os.Handler;
+import android.os.Looper;
+
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.WritableMap;
@@ -15,6 +18,8 @@ final class FastImageEvents {
     static final int ERROR = 1 << 3;
     static final int LOAD_END = 1 << 4;
 
+    private static final Handler MAIN = new Handler(Looper.getMainLooper());
+
     private FastImageEvents() {
     }
 
@@ -57,8 +62,21 @@ final class FastImageEvents {
         send(view, FastImageRequestListener.REACT_ON_LOAD_END_EVENT, event);
     }
 
-    // Only the events JS has a handler for: most images have none.
+    // Only the events JS has a handler for: most images have none. Posted to
+    // the main thread rather than dispatched here: this is called from Glide's
+    // onResourceReady and onLoadFailed, and EventDispatcher calls its listeners
+    // inline. Reanimated's listener flushes pending mount items, which can
+    // drop this view, and the drop clears the request inside its own
+    // callback, which Glide doesn't allow (it throws). One Handler keeps the
+    // events in order.
     static void send(FastImageViewWithUrl view, String name, WritableMap data) {
+        if (!view.handles(bit(name))) return;
+        MAIN.post(() -> dispatch(view, name, data));
+    }
+
+    // Dispatches the event now: for callers on the main thread outside Glide's
+    // callbacks (e.g. progress, which is posted already).
+    static void dispatch(FastImageViewWithUrl view, String name, WritableMap data) {
         if (!view.handles(bit(name))) return;
         ReactContext context = FastImageViewManager.getReactContext(view.getContext());
         if (context == null) return;

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

@@ -555,7 +555,7 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl>
             // Downloads only report a known length (see FastImageSharedDownloads).
             event.putDouble("progress", Math.min(1.0, Math.max(0.0, (double) loaded / total)));
             try {
-                FastImageEvents.send(view, REACT_ON_PROGRESS_EVENT, event);
+                FastImageEvents.dispatch(view, REACT_ON_PROGRESS_EVENT, event);
             } catch (RuntimeException e) {
                 // E.g. the view's React instance is gone: progress isn't worth
                 // crashing the app for.

package/ios/FastImage/FFFastImageModule.mm

@@ -505,7 +505,7 @@ static NSDictionary *FFFFile(NSString *path)
 - (void)clearDiskCache:(RCTPromiseResolveBlock)resolve reject:(__unused RCTPromiseRejectBlock)reject
 {
     // And the HTTP cache of `cache: 'web'` images.
-    [FFFastImageSource.webURLCache removeAllCachedResponses];
+    [FFFastImageSource clearWebURLCache];
     [SDImageCache.sharedImageCache clearDiskOnCompletion:^(){
         resolve(@{@"ok": @YES});
     }];

package/ios/FastImage/FFFastImageSource.h

@@ -84,6 +84,14 @@ typedef NS_ENUM(NSInteger, FFFCacheControl) {
 // responses. 50 MB, as on Android.
 + (NSURLCache *)webURLCache;
 
+// Empties webURLCache (for clearDiskCache). Its removal takes effect a few
+// milliseconds after removeAllCachedResponses returns, and NSURLCache doesn't
+// say when: until then a `cache: 'web'` load could still get a response from
+// before the clear. So each response the web loader stores records the clear
+// it came after, and for 5 s after a clear, a load ignores a cached response
+// stored before it.
++ (void)clearWebURLCache;
+
 // After a load of this source failed: for a `cache: 'web'` image whose data
 // 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

package/ios/FastImage/FFFastImageSource.m

@@ -215,6 +215,31 @@ static NSString *FFFBundleAssetName(NSURL *url)
 @interface FFFWebDownloaderOperation : SDWebImageDownloaderOperation
 @end
 
+// The key, in a stored response's userInfo, of the clear it came after (see
+// clearWebURLCache).
+static NSString *const FFFCacheTokenKey = @"FFFastImageCacheToken";
+
+// A new value at each clearWebURLCache (and one for the launch until then).
+// Not the time: a change of the device's clock would move it.
+static NSString *FFFWebURLCacheToken;
+
+// When clearWebURLCache last ran, in seconds since the device started, or 0.
+static NSTimeInterval FFFWebURLCacheClearedAt;
+
+// How long after a clear loads check the response they'd get: the removal
+// takes about 10 ms, longer on a busy device. Each check is a cache lookup.
+static const NSTimeInterval FFFWebURLCacheClearCheck = 5;
+
+static NSString *FFFCurrentWebURLCacheToken(void)
+{
+    @synchronized ([FFFastImageSource class]) {
+        if (!FFFWebURLCacheToken) {
+            FFFWebURLCacheToken = NSUUID.UUID.UUIDString;
+        }
+        return FFFWebURLCacheToken;
+    }
+}
+
 @implementation FFFWebDownloaderOperation
 
 // Whether data is an SVG document: its first element (after an XML
@@ -279,7 +304,14 @@ static BOOL FFFLooksLikeSVG(NSData *data)
         completionHandler(nil);
         return;
     }
-    [super URLSession:session dataTask:dataTask willCacheResponse:proposedResponse completionHandler:completionHandler];
+    // The clear it came after (see clearWebURLCache).
+    NSMutableDictionary *userInfo = [proposedResponse.userInfo mutableCopy] ?: [NSMutableDictionary dictionary];
+    userInfo[FFFCacheTokenKey] = FFFCurrentWebURLCacheToken();
+    NSCachedURLResponse *response = [[NSCachedURLResponse alloc] initWithResponse:proposedResponse.response
+                                                                             data:proposedResponse.data
+                                                                         userInfo:userInfo
+                                                                    storagePolicy:proposedResponse.storagePolicy];
+    [super URLSession:session dataTask:dataTask willCacheResponse:response completionHandler:completionHandler];
 }
 
 @end
@@ -481,15 +513,46 @@ static BOOL FFFLooksLikeSVG(NSData *data)
     return cache;
 }
 
++ (void)clearWebURLCache
+{
+    @synchronized (self) {
+        FFFWebURLCacheToken = NSUUID.UUID.UUIDString;
+        FFFWebURLCacheClearedAt = NSProcessInfo.processInfo.systemUptime;
+    }
+    [self.webURLCache removeAllCachedResponses];
+}
+
+// Whether the HTTP cache's response to the request was stored before the last
+// clearWebURLCache (or has no token: stored by an app's own operation class),
+// in the few seconds after it.
++ (BOOL)isCachedBeforeClear:(NSURLRequest *)request
+{
+    NSString *token;
+    NSTimeInterval clearedAt;
+    @synchronized (self) {
+        token = FFFWebURLCacheToken;
+        clearedAt = FFFWebURLCacheClearedAt;
+    }
+    if (clearedAt == 0 || NSProcessInfo.processInfo.systemUptime - clearedAt > FFFWebURLCacheClearCheck) {
+        return NO;
+    }
+    NSCachedURLResponse *cached = [self.webURLCache cachedResponseForRequest:request];
+    return cached && ![cached.userInfo[FFFCacheTokenKey] isEqual:token];
+}
+
 - (SDWebImageDownloaderRequestModifier *)requestModifier
 {
     NSDictionary* headers = _headers;
+    BOOL web = _cacheControl == FFFCacheControlWeb;
     return [SDWebImageDownloaderRequestModifier requestModifierWithBlock: ^NSURLRequest* _Nullable (NSURLRequest* _Nonnull request) {
         NSMutableURLRequest* mutableRequest = [request mutableCopy];
         for (NSString* header in headers) {
             NSString* value = headers[header];
             [mutableRequest setValue: value forHTTPHeaderField: header];
         }
+        if (web && [FFFastImageSource isCachedBeforeClear:mutableRequest]) {
+            mutableRequest.cachePolicy = NSURLRequestReloadIgnoringLocalCacheData;
+        }
         return [mutableRequest copy];
     }];
 }

package/package.json

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