react-native-fast-image 8.6.37 → 8.6.39

package/README.md

@@ -139,7 +139,7 @@ Indicates the load order priority of an image. Images with `FastImage.priority.h
 ### `source.cache?: enum`
 
 - `FastImage.cacheControl.immutable` - **(Default)** - Only updates if url changes.
-- `FastImage.cacheControl.web` - Use headers and follow normal caching procedures.
+- `FastImage.cacheControl.web` - Use headers and follow normal caching procedures. On Android these responses are kept in a 50 MB HTTP cache (or the app's own, if its OkHttp client has one).
 - `FastImage.cacheControl.cacheOnly` - Only show images from cache, do not make any network requests.
 
 ---

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

@@ -7,16 +7,22 @@ import com.bumptech.glide.Glide;
 import com.bumptech.glide.Registry;
 import com.bumptech.glide.annotation.GlideModule;
 import com.bumptech.glide.integration.okhttp3.OkHttpUrlLoader;
+import com.bumptech.glide.load.Options;
 import com.bumptech.glide.load.model.GlideUrl;
+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.OkHttpClientProvider;
 
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.WeakHashMap;
 
+import okhttp3.Cache;
 import okhttp3.Interceptor;
 import okhttp3.MediaType;
 import okhttp3.OkHttpClient;
@@ -33,6 +39,7 @@ import okio.Source;
 public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
 
     private static final DispatchingProgressListener progressListener = new DispatchingProgressListener();
+    private static final long WEB_CACHE_SIZE = 50 * 1024 * 1024;
 
     @Override
     public void registerComponents(
@@ -47,6 +54,47 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
                 .build();
         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();
+        registry.prepend(FastImageWebGlideUrl.class, InputStream.class, new WebUrlLoaderFactory(webClient));
+    }
+
+    // Loads FastImageWebGlideUrls with the given client.
+    private static class WebUrlLoaderFactory implements ModelLoaderFactory<FastImageWebGlideUrl, InputStream> {
+        private final OkHttpClient client;
+
+        WebUrlLoaderFactory(OkHttpClient client) {
+            this.client = client;
+        }
+
+        @NonNull
+        @Override
+        public ModelLoader<FastImageWebGlideUrl, InputStream> build(@NonNull MultiModelLoaderFactory multiFactory) {
+            final OkHttpUrlLoader loader = new OkHttpUrlLoader(client);
+            return new ModelLoader<FastImageWebGlideUrl, InputStream>() {
+                @Override
+                public LoadData<InputStream> buildLoadData(@NonNull FastImageWebGlideUrl model, int width, int height, @NonNull Options options) {
+                    return loader.buildLoadData(model, width, height, options);
+                }
+
+                @Override
+                public boolean handles(@NonNull FastImageWebGlideUrl model) {
+                    return true;
+                }
+            };
+        }
+
+        @Override
+        public void teardown() {
+        }
     }
 
     private static Interceptor createInterceptor(final ResponseProgressListener listener) {
@@ -92,7 +140,10 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
         @Override
         public void update(final String key, final long bytesRead, final long contentLength) {
             final FastImageProgressListener listener = LISTENERS.get(key);
-            if (listener == null) {
+            // Without a Content-Length the total is unknown (-1), and a
+            // percentage can't be worked out from it, so don't send those. (It
+            // also looked like the last update, which stopped all updates.)
+            if (listener == null || contentLength <= 0) {
                 return;
             }
             if (contentLength <= bytesRead) {

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

@@ -117,7 +117,16 @@ public class FastImageSource extends ImageSource {
         return mHeaders;
     }
 
+    // Set for `cache: 'web'`.
+    private boolean mWebCache = false;
+
+    void setWebCache(boolean webCache) {
+        mWebCache = webCache;
+    }
+
     public GlideUrl getGlideUrl() {
-        return new GlideUrl(getUri().toString(), getHeaders());
+        return mWebCache
+                ? new FastImageWebGlideUrl(getUri().toString(), getHeaders())
+                : new GlideUrl(getUri().toString(), getHeaders());
     }
 }

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

@@ -60,9 +60,10 @@ class FastImageViewConverter {
     // Resolve the source uri to a file path that android understands.
     static @Nullable
     FastImageSource getImageSource(Context context, @Nullable ReadableMap source) {
-        return source == null
-                ? null
-                : new FastImageSource(context, source.getString("uri"), getHeaders(source));
+        if (source == null) return null;
+        FastImageSource imageSource = new FastImageSource(context, source.getString("uri"), getHeaders(source));
+        imageSource.setWebCache(getCacheControl(source) == FastImageCacheControl.WEB);
+        return imageSource;
     }
 
     static Headers getHeaders(ReadableMap source) {

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

@@ -0,0 +1,13 @@
+package com.dylanvann.fastimage;
+
+import com.bumptech.glide.load.model.GlideUrl;
+import com.bumptech.glide.load.model.Headers;
+
+// A url loaded with `cache: 'web'`. Glide doesn't cache these, so they load
+// through an OkHttp client with an HTTP cache (see
+// FastImageOkHttpProgressGlideModule) to follow the server's caching headers.
+class FastImageWebGlideUrl extends GlideUrl {
+    FastImageWebGlideUrl(String url, Headers headers) {
+        super(url, headers);
+    }
+}

package/ios/FastImage/FFFastImageView.m

@@ -247,6 +247,11 @@
     SDImageLoaderProgressBlock progress = nil;
     if (self.onFastImageProgress) {
         progress = ^(NSInteger receivedSize, NSInteger expectedSize, NSURL* _Nullable targetURL) {
+            // Without a Content-Length the total is unknown (-1 or 0), and a
+            // percentage can't be worked out from it, so don't send those.
+            if (expectedSize <= 0) {
+                return;
+            }
             // SDWebImage calls this on its download queue, while React Native
             // sets onFastImageProgress (and deallocates the view) on the main
             // queue. Read and call it there, so it can't change or be released

package/package.json

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