react-native-fast-image 8.6.40 → 8.6.42

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

@@ -0,0 +1,84 @@
+package com.dylanvann.fastimage;
+
+import android.content.Context;
+import android.os.Build;
+import android.text.TextUtils;
+import android.webkit.CookieManager;
+import android.webkit.CookieSyncManager;
+
+import androidx.annotation.Nullable;
+
+import java.net.CookieHandler;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+// Reads and stores cookies in Android's cookie store (the WebView's
+// CookieManager), which React Native's networking (fetch) and its Image
+// component use. Image requests then send the cookies the app's other requests
+// got, as on iOS. Does what React Native's ForwardingCookieHandler does,
+// without the ReactContext that one needs (up to at least 0.77). Used through
+// OkHttp's JavaNetCookieJar, which parses the cookies.
+final class FastImageCookieHandler extends CookieHandler {
+    private final Context context;
+    @Nullable
+    private CookieManager cookieManager;
+
+    FastImageCookieHandler(Context context) {
+        this.context = context.getApplicationContext();
+    }
+
+    @Override
+    public Map<String, List<String>> get(URI uri, Map<String, List<String>> requestHeaders) {
+        CookieManager cookieManager = cookieManager();
+        if (cookieManager == null) return Collections.emptyMap();
+        String cookies = cookieManager.getCookie(uri.toString());
+        if (TextUtils.isEmpty(cookies)) return Collections.emptyMap();
+        return Collections.singletonMap("Cookie", Collections.singletonList(cookies));
+    }
+
+    @Override
+    public void put(URI uri, Map<String, List<String>> responseHeaders) {
+        CookieManager cookieManager = cookieManager();
+        if (cookieManager == null) return;
+        String url = uri.toString();
+        boolean added = false;
+        for (Map.Entry<String, List<String>> header : responseHeaders.entrySet()) {
+            String name = header.getKey();
+            if (!"Set-Cookie".equalsIgnoreCase(name) && !"Set-Cookie2".equalsIgnoreCase(name)) continue;
+            for (String cookie : header.getValue()) {
+                cookieManager.setCookie(url, cookie);
+                added = true;
+            }
+        }
+        if (added) flush(cookieManager);
+    }
+
+    @SuppressWarnings("deprecation")
+    private static void flush(CookieManager cookieManager) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            cookieManager.flush();
+        } else {
+            CookieSyncManager.getInstance().sync();
+        }
+    }
+
+    // null while the WebView isn't available (not installed, or being
+    // updated): requests go without cookies then, instead of failing.
+    @Nullable
+    @SuppressWarnings("deprecation")
+    private synchronized CookieManager cookieManager() {
+        if (cookieManager == null) {
+            try {
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+                    CookieSyncManager.createInstance(context);
+                }
+                cookieManager = CookieManager.getInstance();
+            } catch (Exception e) {
+                return null;
+            }
+        }
+        return cookieManager;
+    }
+}

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

@@ -13,6 +13,7 @@ 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.OkHttpClientProvider;
 
 import java.io.File;
@@ -24,6 +25,7 @@ import java.util.WeakHashMap;
 
 import okhttp3.Cache;
 import okhttp3.Interceptor;
+import okhttp3.JavaNetCookieJar;
 import okhttp3.MediaType;
 import okhttp3.OkHttpClient;
 import okhttp3.Request;
@@ -47,11 +49,18 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
             @NonNull Glide glide,
             @NonNull Registry registry
     ) {
-        OkHttpClient client = OkHttpClientProvider
-                .getOkHttpClient()
+        OkHttpClient sharedClient = OkHttpClientProvider.getOkHttpClient();
+        OkHttpClient.Builder builder = sharedClient
                 .newBuilder()
-                .addInterceptor(createInterceptor(progressListener))
-                .build();
+                .addInterceptor(createInterceptor(progressListener));
+        // 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.
+        if (sharedClient.cookieJar() instanceof CookieJarContainer) {
+            builder.cookieJar(new JavaNetCookieJar(new FastImageCookieHandler(context)));
+        }
+        OkHttpClient client = builder.build();
         OkHttpUrlLoader.Factory factory = new OkHttpUrlLoader.Factory(client);
         registry.replace(GlideUrl.class, InputStream.class, factory);
 

package/ios/FastImage/FFFastImageView.m

@@ -1,6 +1,7 @@
 #import "FFFastImageView.h"
 #import <SDWebImage/UIImage+MultiFormat.h>
 #import <SDWebImage/UIView+WebCache.h>
+#import <React/RCTUtils.h>
 
 @interface FFFastImageView ()
 
@@ -14,11 +15,31 @@
 // The image before tinting, kept while a tint is applied so the tint can be
 // changed or removed. nil when there's no tint (super.image is untinted).
 @property(nonatomic, strong) UIImage* untintedImage;
+// Whether the current load was already restarted after the app came back
+// from the background (see downloadImage:).
+@property(nonatomic, assign) BOOL retriedAfterBackground;
+// Waits for the app to be active again, to restart a load.
+@property(nonatomic, strong) id activeObserver;
 
 @end
 
+// When the app last went to the background (CACurrentMediaTime), or 0.
+static CFTimeInterval FFFEnteredBackgroundAt = 0;
+
 @implementation FFFastImageView
 
++ (void) initialize {
+    if (self != [FFFastImageView class]) {
+        return;
+    }
+    [[NSNotificationCenter defaultCenter] addObserverForName: UIApplicationDidEnterBackgroundNotification
+                                                      object: nil
+                                                       queue: [NSOperationQueue mainQueue]
+                                                  usingBlock: ^(NSNotification* notification) {
+        FFFEnteredBackgroundAt = CACurrentMediaTime();
+    }];
+}
+
 - (id) init {
     self = [super init];
     self.resizeMode = RCTResizeModeCover;
@@ -232,6 +253,8 @@
         }
         self.hasCompleted = NO;
         self.hasErrored = NO;
+        self.retriedAfterBackground = NO;
+        [self stopWaitingForActive];
 
         [self downloadImage: _source options: options context: context];
     } else if (_defaultSource) {
@@ -267,6 +290,7 @@
             });
         };
     }
+    CFTimeInterval startedAt = CACurrentMediaTime();
     [self sd_setImageWithURL: _source.url
             placeholderImage: _defaultSource
                      options: options
@@ -276,6 +300,18 @@
                     NSError* _Nullable error,
                     SDImageCacheType cacheType,
                     NSURL* _Nullable imageURL) {
+                // 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
+                // back (NSURLErrorTimedOut), or loses its connection. Load it
+                // again once the app is active, as Android does (#758).
+                if (error && [error.domain isEqualToString: NSURLErrorDomain] &&
+                    FFFEnteredBackgroundAt > startedAt && !weakSelf.retriedAfterBackground &&
+                    weakSelf.source == source) {
+                    weakSelf.retriedAfterBackground = YES;
+                    [weakSelf downloadWhenActive: source options: options context: context];
+                    return;
+                }
                 if (error) {
                     weakSelf.hasErrored = YES;
                     if (weakSelf.onFastImageError) {
@@ -294,7 +330,37 @@
             }];
 }
 
+// Downloads the source now if the app is active, or once it is (unless
+// another load started meanwhile).
+- (void) downloadWhenActive: (FFFastImageSource*)source options: (SDWebImageOptions)options context: (SDWebImageContext*)context {
+    // nil in app extensions, which don't get these notifications.
+    UIApplication* application = RCTSharedApplication();
+    if (!application || application.applicationState == UIApplicationStateActive) {
+        [self downloadImage: source options: options context: context];
+        return;
+    }
+    [self stopWaitingForActive];
+    __weak typeof(self) weakSelf = self;
+    self.activeObserver = [[NSNotificationCenter defaultCenter] addObserverForName: UIApplicationDidBecomeActiveNotification
+                                                                            object: nil
+                                                                             queue: [NSOperationQueue mainQueue]
+                                                                        usingBlock: ^(NSNotification* notification) {
+        [weakSelf stopWaitingForActive];
+        if (weakSelf.source == source) {
+            [weakSelf downloadImage: source options: options context: context];
+        }
+    }];
+}
+
+- (void) stopWaitingForActive {
+    if (self.activeObserver) {
+        [[NSNotificationCenter defaultCenter] removeObserver: self.activeObserver];
+        self.activeObserver = nil;
+    }
+}
+
 - (void) dealloc {
+    [self stopWaitingForActive];
     [self sd_cancelCurrentImageLoad];
 }
 

package/package.json

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