react-native-fast-image 8.17.0 → 8.17.2

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

@@ -7,6 +7,9 @@ import androidx.annotation.Nullable;
 import com.bumptech.glide.Glide;
 import com.bumptech.glide.Registry;
 import com.bumptech.glide.annotation.GlideModule;
+import com.bumptech.glide.load.ImageHeaderParser;
+import com.bumptech.glide.load.ImageHeaderParserUtils;
+import com.bumptech.glide.load.engine.bitmap_recycle.ArrayPool;
 import com.bumptech.glide.integration.okhttp3.OkHttpUrlLoader;
 import com.bumptech.glide.load.Options;
 import com.bumptech.glide.load.model.GlideUrl;
@@ -21,6 +24,7 @@ import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.HashMap;
+import java.util.Locale;
 import java.util.Map;
 import java.util.WeakHashMap;
 
@@ -62,7 +66,10 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
         OkHttpClient sharedClient = OkHttpClientProvider.getOkHttpClient();
         OkHttpClient.Builder builder = sharedClient
                 .newBuilder()
-                .addInterceptor(createInterceptor(progressListener));
+                .addInterceptor(createInterceptor(progressListener))
+                // A network interceptor, so it runs before the HTTP cache of
+                // `web` images stores the response (checking it reads it).
+                .addNetworkInterceptor(createNonImageInterceptor(registry, glide.getArrayPool()));
         // 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
@@ -71,8 +78,7 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
             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);
+        registry.replace(GlideUrl.class, InputStream.class, new UrlLoaderFactory(client));
 
         // `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,
@@ -85,6 +91,40 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
         registry.prepend(FastImageWebGlideUrl.class, InputStream.class, new WebUrlLoaderFactory(webClient));
     }
 
+    // Loads GlideUrls with the given client, except `web` ones
+    // (FastImageWebGlideUrls): Glide gives a model to the loaders of its
+    // superclasses too, and tries the next one when a load fails, so a `web`
+    // image that failed (e.g. a 404) was requested again with this client,
+    // without the HTTP cache, which also hid the failure.
+    private static class UrlLoaderFactory implements ModelLoaderFactory<GlideUrl, InputStream> {
+        private final OkHttpClient client;
+
+        UrlLoaderFactory(OkHttpClient client) {
+            this.client = client;
+        }
+
+        @NonNull
+        @Override
+        public ModelLoader<GlideUrl, InputStream> build(@NonNull MultiModelLoaderFactory multiFactory) {
+            final OkHttpUrlLoader loader = new OkHttpUrlLoader(client);
+            return new ModelLoader<GlideUrl, InputStream>() {
+                @Override
+                public LoadData<InputStream> buildLoadData(@NonNull GlideUrl model, int width, int height, @NonNull Options options) {
+                    return loader.buildLoadData(model, width, height, options);
+                }
+
+                @Override
+                public boolean handles(@NonNull GlideUrl model) {
+                    return !(model instanceof FastImageWebGlideUrl);
+                }
+            };
+        }
+
+        @Override
+        public void teardown() {
+        }
+    }
+
     // Loads FastImageWebGlideUrls with the given client.
     private static class WebUrlLoaderFactory implements ModelLoaderFactory<FastImageWebGlideUrl, InputStream> {
         private final OkHttpClient client;
@@ -115,6 +155,50 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
         }
     }
 
+    // Fails a successful response that's clearly not an image: its type isn't
+    // an image's (text, JSON, XML other than SVG) and its first bytes aren't a
+    // format Glide recognizes, e.g. a captive portal's or a proxy's HTML page
+    // sent with status 200. Glide keeps the bytes it downloads in its disk
+    // cache before decoding them (and doesn't remove them when that fails), as
+    // does the HTTP cache of `web` images, so every later load of the url
+    // would fail too. Neither caches a failed response. Images sent with the
+    // wrong type still load.
+    private static Interceptor createNonImageInterceptor(final Registry registry, final ArrayPool arrayPool) {
+        return new Interceptor() {
+            @NonNull
+            @Override
+            public Response intercept(@NonNull Chain chain) throws IOException {
+                Response response = chain.proceed(chain.request());
+                ResponseBody body = response.body();
+                MediaType type = body == null ? null : body.contentType();
+                if (!response.isSuccessful() || type == null || !isNotImageType(type)) {
+                    return response;
+                }
+                ImageHeaderParser.ImageType imageType;
+                try (InputStream stream = response.peekBody(64 * 1024).byteStream()) {
+                    imageType = ImageHeaderParserUtils.getType(
+                            registry.getImageHeaderParsers(), stream, arrayPool);
+                }
+                if (imageType != ImageHeaderParser.ImageType.UNKNOWN) {
+                    return response;
+                }
+                response.close();
+                throw new IOException("Not an image (Content-Type: " + type + ")");
+            }
+        };
+    }
+
+    private static boolean isNotImageType(MediaType type) {
+        String subtype = type.subtype();
+        if ("text".equalsIgnoreCase(type.type())) return true;
+        if (!"application".equalsIgnoreCase(type.type())) return false;
+        return subtype.equalsIgnoreCase("json")
+                || subtype.toLowerCase(Locale.ROOT).endsWith("+json")
+                || subtype.equalsIgnoreCase("xml")
+                || subtype.equalsIgnoreCase("xhtml+xml")
+                || subtype.equalsIgnoreCase("javascript");
+    }
+
     private static Interceptor createInterceptor(final ResponseProgressListener listener) {
         return new Interceptor() {
             @Override

package/ios/FastImage/FFFastImageSource.h

@@ -61,4 +61,10 @@ typedef NS_ENUM(NSInteger, FFFCacheControl) {
 // responses. 50 MB, as on Android.
 + (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.
+- (void)forgetResponseAfterError:(NSError *)error;
+
 @end

package/ios/FastImage/FFFastImageSource.m

@@ -2,6 +2,7 @@
 #import <SDWebImage/SDWebImageDownloader.h>
 #import <SDWebImage/SDWebImageDownloaderResponseModifier.h>
 #import <SDWebImage/SDWebImageDownloaderDecryptor.h>
+#import <SDWebImage/SDWebImageError.h>
 
 static NSUInteger const FFFWebCacheSize = 50 * 1024 * 1024;
 
@@ -79,6 +80,17 @@ static NSUInteger const FFFWebCacheSize = 50 * 1024 * 1024;
     return downloader;
 }
 
+- (void)forgetResponseAfterError:(NSError *)error
+{
+    if (_cacheControl != FFFCacheControlWeb || !_url) {
+        return;
+    }
+    if (![error.domain isEqualToString:SDWebImageErrorDomain] || error.code != SDWebImageErrorBadImageData) {
+        return;
+    }
+    [[FFFastImageSource webURLCache] removeCachedResponseForRequest:[NSURLRequest requestWithURL:_url]];
+}
+
 + (NSURLCache *)webURLCache
 {
     static NSURLCache *cache;

package/ios/FastImage/FFFastImageView.m

@@ -579,6 +579,9 @@ NSString *FFFErrorMessage(NSError *error)
                            setImageBlock: setImage
                                 progress: nil
                                completed: ^(UIImage* _Nullable image, NSData* _Nullable data, NSError* _Nullable error, SDImageCacheType cacheType, BOOL finished, NSURL* _Nullable imageURL) {
+            if (error) {
+                [source forgetResponseAfterError: error];
+            }
             if (error && weakSelf.loadCount == load) {
                 // Keeps the image it has, without trying again on every
                 // layout (e.g. while offline).
@@ -608,6 +611,9 @@ NSString *FFFErrorMessage(NSError *error)
                     SDImageCacheType cacheType,
                     BOOL finished,
                     NSURL* _Nullable imageURL) {
+                if (error) {
+                    [source forgetResponseAfterError: error];
+                }
                 // Replaced by another load (a new source, or the same one
                 // restarted for a new size), which sends the events. This
                 // one was cancelled, which SDWebImage reports as an error.

package/ios/FastImage/FFFastImageViewManager.m

@@ -107,7 +107,10 @@ RCT_EXPORT_METHOD(preload:(nonnull NSArray<FFFastImageSource *> *)sources
             }
             [results addObject:[NSNull null]];
             // A source's own priority replaces the prefetcher's, as on Android.
-            SDWebImageOptions options = prefetcherOptions;
+            // Failed urls are tried again, as views do (SDWebImage otherwise
+            // fails a url that failed before, e.g. with data that isn't an
+            // image, without a request until the app is relaunched, #394).
+            SDWebImageOptions options = prefetcherOptions | SDWebImageRetryFailed;
             if (source.hasPriority) {
                 options &= ~(SDWebImageLowPriority | SDWebImageHighPriority);
                 if (source.priority == FFFPriorityLow) {
@@ -137,6 +140,9 @@ RCT_EXPORT_METHOD(preload:(nonnull NSArray<FFFastImageSource *> *)sources
                         return;
                     }
                     done = YES;
+                    if (error) {
+                        [source forgetResponseAfterError:error];
+                    }
                     results[idx] = image
                         ? @{@"ok": @YES, @"width": @(image.size.width), @"height": @(image.size.height)}
                         : @{@"ok": @NO, @"error": FFFErrorMessage(error)};

package/package.json

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