react-native-fast-image 8.17.2 → 8.18.0

package/README.md

@@ -371,6 +371,34 @@ Clear all images from memory cache.
 
 Clear all images from disk cache.
 
+### `FastImage.getCachePath: (source: Source) => Promise<CachePathResult>`
+
+The path of the source's downloaded file in the disk cache, e.g. to share, save or upload an image without downloading it again. If the file isn't there, it's downloaded first, without decoding the image or keeping it in memory. Resolves with `{ ok: true, path }`, or `{ ok: false, error }` if it can't be downloaded. Never rejects.
+
+```js
+const result = await FastImage.getCachePath({ uri: photo.url })
+if (result.ok) {
+    await shareFile(`file://${result.path}`) // e.g. with react-native-share
+}
+```
+
+With `cache: 'cacheOnly'` it doesn't download: use it to check whether an image is cached.
+
+```js
+const { ok } = await FastImage.getCachePath({
+    uri: photo.url,
+    cache: FastImage.cacheControl.cacheOnly,
+})
+```
+
+- The source's `headers`, `cacheKey` and `priority` apply, as for a view. Downloads wait in the same queue as `preload`'s, so they don't hold up the images on screen.
+- The file belongs to the cache, which can remove it at any time: copy it to keep it.
+- Its name may not have an image extension (on Android it ends in `.0` or `.1`): copy it with one for APIs that need it.
+- A `file://` source is its own path. Other local images (`require()` in a release build, `content://`) have no file to give.
+- With `cache: 'web'`, Android only keeps the file if the server allows caching it (in an HTTP cache), and returns `ok: false` otherwise. If the server compressed the image with `Content-Encoding` (rare for images), that file is compressed.
+
+There's no way to remove a single image from the cache. To load an image again after it changed on the server, change its [`cacheKey`](#sourcecachekey-string).
+
 ## Troubleshooting
 
 If you have any problems using this library try the steps in [troubleshooting](docs/troubleshooting.md) and see if they fix it.

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

@@ -29,6 +29,7 @@ import java.util.Map;
 import java.util.WeakHashMap;
 
 import okhttp3.Cache;
+import okhttp3.HttpUrl;
 import okhttp3.Interceptor;
 import okhttp3.JavaNetCookieJar;
 import okhttp3.MediaType;
@@ -50,6 +51,9 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
     // The HTTP cache of `cache: 'web'` images, once Glide has set up.
     @Nullable
     private static Cache webCache;
+    // The client that loads them, with that cache.
+    @Nullable
+    private static OkHttpClient webClient;
 
     // Empties the HTTP cache of `cache: 'web'` images (clearDiskCache).
     static void clearWebCache() throws IOException {
@@ -57,6 +61,43 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
         if (cache != null) cache.evictAll();
     }
 
+    // Downloads a `web` image (with its headers) through the client with the
+    // HTTP cache, which stores it if the server allows it (getCachePath).
+    // Blocking. Glide must be set up.
+    static void downloadToWebCache(GlideUrl url) throws IOException {
+        OkHttpClient client = webClient;
+        if (client == null) throw new IOException("Glide isn't set up");
+        Request.Builder request = new Request.Builder().url(url.toStringUrl());
+        for (Map.Entry<String, String> header : url.getHeaders().entrySet()) {
+            request.addHeader(header.getKey(), header.getValue());
+        }
+        try (Response response = client.newCall(request.build()).execute()) {
+            if (!response.isSuccessful()) {
+                // As Glide's HttpException reports it.
+                throw new IOException(response.message() + ", status code: " + response.code());
+            }
+            ResponseBody body = response.body();
+            if (body == null) return;
+            // Read to the end, so the cache stores it.
+            BufferedSource source = body.source();
+            Buffer buffer = new Buffer();
+            while (source.read(buffer, 8192) != -1) buffer.clear();
+        }
+    }
+
+    // The file with the body of url's response in the HTTP cache of
+    // `cache: 'web'` images (getCachePath), or null. OkHttp has no API for it:
+    // its cache stores each response as `<Cache.key(url)>.0` (headers) and
+    // `.1` (body, as the server sent it) once it's complete.
+    @Nullable
+    static File webCacheFile(String url) {
+        Cache cache = webCache;
+        HttpUrl httpUrl = HttpUrl.parse(url);
+        if (cache == null || httpUrl == null) return null;
+        File file = new File(cache.directory(), Cache.key(httpUrl) + ".1");
+        return file.isFile() ? file : null;
+    }
+
     @Override
     public void registerComponents(
             @NonNull Context context,
@@ -87,7 +128,7 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
         // 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();
+        webClient = client.newBuilder().cache(webCache).build();
         registry.prepend(FastImageWebGlideUrl.class, InputStream.class, new WebUrlLoaderFactory(webClient));
     }
 

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

@@ -138,7 +138,7 @@ class FastImageViewConverter {
         return options;
     }
 
-    private static FastImageCacheControl getCacheControl(ReadableMap source) {
+    static FastImageCacheControl getCacheControl(ReadableMap source) {
         return getValueFromSource("cache", "immutable", FAST_IMAGE_CACHE_CONTROL_MAP, source);
     }
 

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

@@ -256,6 +256,165 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
         return result;
     }
 
+    // Where getCachePath looks in the caches and downloads `web` images
+    // (blocking calls, off the UI and modules threads).
+    private static final Executor cachePathExecutor = Executors.newSingleThreadExecutor();
+
+    private static WritableMap pathResult(File file) {
+        WritableMap result = Arguments.createMap();
+        result.putBoolean("ok", true);
+        result.putString("path", file.getAbsolutePath());
+        return result;
+    }
+
+    // The source's downloaded file in the disk cache, downloading it first if
+    // it isn't there (without decoding it or keeping it in memory, and in the
+    // preloads' queue): { ok, path } or { ok: false, error }. Never rejects.
+    // With `cacheOnly` it doesn't download. A local file is its own path.
+    @ReactMethod
+    public void getCachePath(final ReadableMap source, final Promise promise) {
+        final ReactApplicationContext context = getReactApplicationContext();
+        if (!FastImageViewConverter.hasUri(source)) {
+            promise.resolve(failure("Invalid source: no uri"));
+            return;
+        }
+        final FastImageSource imageSource = FastImageViewConverter.getImageSource(context, source);
+        if (imageSource.getUri().toString().isEmpty()) {
+            promise.resolve(failure("Invalid source: can't resolve " + source.getString("uri")));
+            return;
+        }
+        if ("file".equalsIgnoreCase(imageSource.getUri().getScheme())) {
+            File file = new File(imageSource.getUri().getPath());
+            promise.resolve(file.isFile() ? pathResult(file) : failure("No file at this uri"));
+            return;
+        }
+        if (!imageSource.isRemote()) {
+            // content://, a resource or a data uri: there's no file to give.
+            promise.resolve(failure("Not a remote image"));
+            return;
+        }
+        final boolean cacheOnly = FastImageViewConverter.getCacheControl(source) == FastImageCacheControl.CACHE_ONLY;
+        final RequestOptions options = FastImageViewConverter.getOptions(context, imageSource, source);
+        final RequestOptions preloadOptions = source.hasKey("priority") && !source.isNull("priority")
+                ? options
+                : options.priority(Priority.LOW);
+        final String url = imageSource.getUri().toString();
+        cachePathExecutor.execute(new Runnable() {
+            @Override
+            public void run() {
+                // On disk already: in Glide's cache (not for `web` images,
+                // which it doesn't cache), or in the HTTP cache of `web`
+                // images (set up by Glide, which is started first).
+                File file = null;
+                Glide.get(context);
+                if (!imageSource.isWebCache()) {
+                    try {
+                        file = Glide.with(context)
+                                .asFile()
+                                .load(imageSource.getSourceForLoad())
+                                .apply(options)
+                                .onlyRetrieveFromCache(true)
+                                .submit()
+                                .get();
+                    } catch (Exception e) {
+                        // Not in Glide's cache.
+                    }
+                }
+                if (file == null) file = FastImageOkHttpProgressGlideModule.webCacheFile(url);
+                if (file != null) {
+                    promise.resolve(pathResult(file));
+                    return;
+                }
+                if (cacheOnly) {
+                    promise.resolve(failure("Not in the disk cache"));
+                    return;
+                }
+                UiThreadUtil.runOnUiThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        pendingPreloads.add(imageSource.isWebCache()
+                                ? downloadToWebCache(imageSource, url, promise)
+                                : downloadToDiskCache(context, imageSource, preloadOptions, promise));
+                        startPendingPreloads();
+                    }
+                });
+            }
+        });
+    }
+
+    // Frees a preload slot (on the UI thread) and resolves.
+    private static void finishDownload(final Promise promise, final WritableMap result) {
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                preloadsInFlight--;
+                startPendingPreloads();
+                promise.resolve(result);
+            }
+        });
+    }
+
+    // Downloads the image into Glide's disk cache (as a disk-only preload).
+    private static Runnable downloadToDiskCache(
+            final Context context,
+            final FastImageSource imageSource,
+            final RequestOptions options,
+            final Promise promise) {
+        return new Runnable() {
+            @Override
+            public void run() {
+                Glide
+                        .with(context)
+                        .asFile()
+                        .load(imageSource.getSourceForLoad())
+                        .apply(options)
+                        .listener(new RequestListener<File>() {
+                            @Override
+                            public boolean onLoadFailed(@Nullable GlideException e, Object model, Target<File> target, boolean isFirstResource) {
+                                finishDownload(promise, failure(FastImageRequestListener.errorMessage(e)));
+                                return false;
+                            }
+
+                            @Override
+                            public boolean onResourceReady(File file, Object model, Target<File> target, DataSource dataSource, boolean isFirstResource) {
+                                finishDownload(promise, pathResult(file));
+                                return false;
+                            }
+                        })
+                        .preload();
+            }
+        };
+    }
+
+    // Downloads a `web` image into its HTTP cache, which keeps it only if the
+    // server allows caching it.
+    private static Runnable downloadToWebCache(
+            final FastImageSource imageSource,
+            final String url,
+            final Promise promise) {
+        return new Runnable() {
+            @Override
+            public void run() {
+                cachePathExecutor.execute(new Runnable() {
+                    @Override
+                    public void run() {
+                        WritableMap result;
+                        try {
+                            FastImageOkHttpProgressGlideModule.downloadToWebCache(imageSource.getGlideUrl());
+                            File file = FastImageOkHttpProgressGlideModule.webCacheFile(url);
+                            result = file != null
+                                    ? pathResult(file)
+                                    : failure("Not stored in the disk cache (the server doesn't allow caching it)");
+                        } catch (IOException e) {
+                            result = failure(e.getMessage() != null ? e.getMessage() : e.toString());
+                        }
+                        finishDownload(promise, result);
+                    }
+                });
+            }
+        };
+    }
+
     @ReactMethod
     public void clearMemoryCache(final Promise promise) {
         final Activity activity = getCurrentActivity();

package/dist/index.cjs.js

@@ -195,6 +195,7 @@ FastImage.preload = (sources) => Promise.resolve(react_native.NativeModules.Fast
 }));
 FastImage.clearMemoryCache = () => react_native.NativeModules.FastImageView.clearMemoryCache();
 FastImage.clearDiskCache = () => react_native.NativeModules.FastImageView.clearDiskCache();
+FastImage.getCachePath = (source) => Promise.resolve(react_native.NativeModules.FastImageView.getCachePath(source || {}));
 const styles = react_native.StyleSheet.create({
 	fallbackImage: {
 		position: "absolute",

package/dist/index.cjs.js.flow

@@ -53,6 +53,10 @@ export type LoadResult =
     | {| ok: true, width: number, height: number |}
     | {| ok: false, error: string |}
 
+export type CachePathResult =
+    | {| ok: true, path: string |}
+    | {| ok: false, error: string |}
+
 export type PreloadSuccess = {|
     uri: string,
     ok: true,
@@ -118,4 +122,5 @@ declare export default class FastImage extends React$Component<FastImageProps> {
     static preload: PreloadFn;
     static clearMemoryCache: () => Promise<void>;
     static clearDiskCache: () => Promise<void>;
+    static getCachePath: (source: FastImageSource) => Promise<CachePathResult>;
 }

package/dist/index.d.ts

@@ -62,6 +62,13 @@ export type LoadResult = {
     ok: false;
     error: string;
 };
+export type CachePathResult = {
+    ok: true;
+    path: string;
+} | {
+    ok: false;
+    error: string;
+};
 export interface OnProgressEvent {
     nativeEvent: {
         loaded: number;
@@ -179,6 +186,12 @@ export interface FastImageStaticProperties {
     preload: (sources: Source[]) => Promise<PreloadResult[]>;
     clearMemoryCache: () => Promise<void>;
     clearDiskCache: () => Promise<void>;
+    /**
+     * The path of the source's downloaded file in the disk cache, downloading
+     * it first if it isn't there (without decoding it). With
+     * `cache: 'cacheOnly'` it doesn't download. Never rejects.
+     */
+    getCachePath: (source: Source) => Promise<CachePathResult>;
 }
 declare const FastImage: React.ComponentType<FastImageProps> & FastImageStaticProperties;
 export interface FastImageBackgroundProps extends Omit<FastImageProps, 'style' | 'children'> {

package/dist/index.js

@@ -168,6 +168,7 @@ FastImage.preload = (sources) => Promise.resolve(NativeModules.FastImageView.pre
 }));
 FastImage.clearMemoryCache = () => NativeModules.FastImageView.clearMemoryCache();
 FastImage.clearDiskCache = () => NativeModules.FastImageView.clearDiskCache();
+FastImage.getCachePath = (source) => Promise.resolve(NativeModules.FastImageView.getCachePath(source || {}));
 const styles = StyleSheet.create({
 	fallbackImage: {
 		position: "absolute",

package/dist/index.js.flow

@@ -53,6 +53,10 @@ export type LoadResult =
     | {| ok: true, width: number, height: number |}
     | {| ok: false, error: string |}
 
+export type CachePathResult =
+    | {| ok: true, path: string |}
+    | {| ok: false, error: string |}
+
 export type PreloadSuccess = {|
     uri: string,
     ok: true,
@@ -118,4 +122,5 @@ declare export default class FastImage extends React$Component<FastImageProps> {
     static preload: PreloadFn;
     static clearMemoryCache: () => Promise<void>;
     static clearDiskCache: () => Promise<void>;
+    static getCachePath: (source: FastImageSource) => Promise<CachePathResult>;
 }

package/ios/FastImage/FFFastImageViewManager.m

@@ -47,6 +47,27 @@ static SDWebImageMutableContext *FFFPreloadContext(FFFastImageSource *source)
     return context;
 }
 
+// A preload's options: the prefetcher's (low priority), with the source's own
+// priority instead if it has one (as on Android), and its `cache` (#406). One
+// source at a time, not SDWebImagePrefetcher, to get each source's result and
+// to send its headers with its own request only. 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).
+static SDWebImageOptions FFFPreloadOptions(FFFastImageSource *source)
+{
+    SDWebImageOptions options = [SDWebImagePrefetcher sharedImagePrefetcher].options | SDWebImageRetryFailed;
+    if (source.hasPriority) {
+        options &= ~(SDWebImageLowPriority | SDWebImageHighPriority);
+        if (source.priority == FFFPriorityLow) {
+            options |= SDWebImageLowPriority;
+        } else if (source.priority == FFFPriorityHigh) {
+            options |= SDWebImageHighPriority;
+        }
+    }
+    return options | [source cacheOptions];
+}
+
 static NSUInteger FFFPreloadLimit(void)
 {
     NSUInteger limit = [SDWebImagePrefetcher sharedImagePrefetcher].maxConcurrentPrefetchCount;
@@ -91,11 +112,6 @@ RCT_EXPORT_METHOD(preload:(nonnull NSArray<FFFastImageSource *> *)sources
                 resolve(results);
             }
         };
-        // With the prefetcher's options (low priority), but one source at a
-        // 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) {
             if (!source.url) {
@@ -106,20 +122,7 @@ RCT_EXPORT_METHOD(preload:(nonnull NSArray<FFFastImageSource *> *)sources
                 return;
             }
             [results addObject:[NSNull null]];
-            // A source's own priority replaces the prefetcher's, as on Android.
-            // 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) {
-                    options |= SDWebImageLowPriority;
-                } else if (source.priority == FFFPriorityHigh) {
-                    options |= SDWebImageHighPriority;
-                }
-            }
-            options |= [source cacheOptions];
+            SDWebImageOptions options = FFFPreloadOptions(source);
             SDWebImageMutableContext *context = FFFPreloadContext(source);
             if (!source.memoryCache) {
                 // Not decoded (only its header is read, for the size), and not
@@ -161,6 +164,82 @@ RCT_EXPORT_METHOD(preload:(nonnull NSArray<FFFastImageSource *> *)sources
     });
 }
 
+// The source's downloaded file in the disk cache, downloading it first if it
+// isn't there (without decoding it or keeping it in memory, and in the
+// preloads' queue): { ok, path } or { ok: false, error }. Never rejects. With
+// `cacheOnly` it doesn't download. A local file is its own path.
+RCT_EXPORT_METHOD(getCachePath:(FFFastImageSource *)source
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(__unused RCTPromiseRejectBlock)reject)
+{
+    if (!source.url) {
+        resolve(@{@"ok": @NO, @"error": @"Invalid source: no uri"});
+        return;
+    }
+    if (source.url.isFileURL) {
+        BOOL exists = [NSFileManager.defaultManager fileExistsAtPath:source.url.path];
+        resolve(exists
+            ? @{@"ok": @YES, @"path": source.url.path}
+            : @{@"ok": @NO, @"error": @"No file at this uri"});
+        return;
+    }
+    SDWebImageMutableContext *context = FFFPreloadContext(source);
+    // The key SDWebImage stores it under (the cacheKey, or the converted url).
+    NSString *key = [SDWebImageManager.sharedManager cacheKeyForURL:source.url context:context];
+    SDImageCache *cache = SDImageCache.sharedImageCache;
+    void (^resolveFromDisk)(NSString *) = ^(NSString *error) {
+        [cache diskImageExistsWithKey:key completion:^(BOOL exists) {
+            resolve(exists
+                ? @{@"ok": @YES, @"path": [cache cachePathForKey:key]}
+                : @{@"ok": @NO, @"error": error});
+        }];
+    };
+    [cache diskImageExistsWithKey:key completion:^(BOOL exists) {
+        // On the main queue, where the preloads' queue is used.
+        if (exists) {
+            resolve(@{@"ok": @YES, @"path": [cache cachePathForKey:key]});
+            return;
+        }
+        if (source.cacheControl == FFFCacheControlCacheOnly) {
+            resolve(@{@"ok": @NO, @"error": @"Not in the disk cache"});
+            return;
+        }
+        if (!FFFPendingPreloads) {
+            FFFPendingPreloads = [NSMutableArray array];
+        }
+        // As a disk-only preload: not decoded, and not looked up in or kept in
+        // memory (an image in memory may not be on disk). It resolves once the
+        // file is written.
+        SDWebImageOptions options = FFFPreloadOptions(source) | SDWebImageAvoidDecodeImage | SDWebImageWaitStoreCache;
+        context[SDWebImageContextQueryCacheType] = @(SDImageCacheTypeDisk);
+        context[SDWebImageContextStoreCacheType] = @(SDImageCacheTypeDisk);
+        [FFFPendingPreloads addObject:[^{
+            __block BOOL done = NO;
+            [[SDWebImageManager sharedManager] loadImageWithURL:source.url
+                                                        options:options
+                                                        context:[context copy]
+                                                       progress:nil
+                                                      completed:^(UIImage *image, NSData *data, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {
+                if (!finished || done) {
+                    return;
+                }
+                done = YES;
+                FFFPreloadsInFlight--;
+                FFFStartPendingPreloads();
+                if (error) {
+                    [source forgetResponseAfterError:error];
+                }
+                if (!image) {
+                    resolve(@{@"ok": @NO, @"error": FFFErrorMessage(error)});
+                    return;
+                }
+                resolveFromDisk(@"Not stored in the disk cache");
+            }];
+        } copy]];
+        FFFStartPendingPreloads();
+    }];
+}
+
 RCT_EXPORT_METHOD(clearMemoryCache:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
 {
     [SDImageCache.sharedImageCache clearMemory];

package/package.json

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