react-native-fast-image 8.18.1 → 8.19.0

package/ios/FastImage/FFFastImageViewManager.m

@@ -5,11 +5,97 @@
 #import <SDWebImage/SDWebImageManager.h>
 #import <SDWebImage/SDWebImageError.h>
 #import <SDWebImage/SDWebImagePrefetcher.h>
+#import <SDWebImage/NSData+ImageContentType.h>
+
+// configureCache's limits, by their names in JS. Each is set in the app's
+// Info.plist (FastImageMaxDiskSize, ...) or changed at runtime, which is saved
+// (FastImage.maxDiskSize, ...) and wins until it's reset with null.
+static NSArray<NSString *> *FFFCacheLimitNames(void)
+{
+    return @[@"maxDiskSize", @"maxDiskAge", @"maxMemorySize"];
+}
+
+static NSString *FFFSavedCacheLimitKey(NSString *name)
+{
+    return [@"FastImage." stringByAppendingString:name];
+}
+
+// A limit's value: the one saved by configureCache, or the app's Info.plist's,
+// or nil for SDWebImage's default.
+static NSNumber *FFFCacheLimit(NSString *name)
+{
+    id saved = [NSUserDefaults.standardUserDefaults objectForKey:FFFSavedCacheLimitKey(name)];
+    if ([saved isKindOfClass:NSNumber.class]) {
+        return saved;
+    }
+    NSString *infoKey = [NSString stringWithFormat:@"FastImage%@%@",
+                         [name substringToIndex:1].uppercaseString, [name substringFromIndex:1]];
+    id info = [NSBundle.mainBundle objectForInfoDictionaryKey:infoKey];
+    if ([info isKindOfClass:NSNumber.class]) {
+        return info;
+    }
+    if ([info isKindOfClass:NSString.class]) {
+        return @([info doubleValue]);
+    }
+    return nil;
+}
+
+// Sets a limit in SDWebImage's cache config: 0 for no limit, nil for
+// SDWebImage's default. maxDiskAge counts from when an image was last used
+// (SDWebImage's default from 5.21; before, from when it was stored).
+static void FFFSetCacheLimit(SDImageCacheConfig *config, NSString *name, NSNumber *value)
+{
+    double limit = MAX(value.doubleValue, 0);
+    if ([name isEqualToString:@"maxDiskSize"]) {
+        config.maxDiskSize = limit;
+    } else if ([name isEqualToString:@"maxMemorySize"]) {
+        config.maxMemoryCost = limit;
+    } else if (value) {
+        // SDWebImage never expires images with a negative age (with 0 it
+        // would remove them all).
+        config.maxDiskAge = limit > 0 ? limit : -1;
+        config.diskCacheExpireType = SDImageCacheConfigExpireTypeAccessDate;
+    } else {
+        config.maxDiskAge = 60 * 60 * 24 * 7;
+    }
+}
+
+// The bytes of the files in a folder.
+static unsigned long long FFFFolderSize(NSString *path)
+{
+    unsigned long long size = 0;
+    NSDirectoryEnumerator<NSURL *> *files = [NSFileManager.defaultManager enumeratorAtURL:[NSURL fileURLWithPath:path isDirectory:YES]
+                                                                includingPropertiesForKeys:@[NSURLFileSizeKey]
+                                                                                   options:0
+                                                                              errorHandler:nil];
+    for (NSURL *file in files) {
+        NSNumber *fileSize;
+        [file getResourceValue:&fileSize forKey:NSURLFileSizeKey error:nil];
+        size += fileSize.unsignedLongLongValue;
+    }
+    return size;
+}
 
 @implementation FFFastImageViewManager
 
 RCT_EXPORT_MODULE(FastImageView)
 
+// The app's cache limits (saved or in its Info.plist), before FastImage loads
+// any image: this class is used first, to create the views and for preload.
++ (void)initialize
+{
+    if (self != [FFFastImageViewManager class]) {
+        return;
+    }
+    SDImageCacheConfig *config = SDImageCache.sharedImageCache.config;
+    for (NSString *name in FFFCacheLimitNames()) {
+        NSNumber *value = FFFCacheLimit(name);
+        if (value) {
+            FFFSetCacheLimit(config, name, value);
+        }
+    }
+}
+
 - (FFFastImageView*)view {
   return [[FFFastImageView alloc] init];
 }
@@ -68,6 +154,20 @@ static SDWebImageOptions FFFPreloadOptions(FFFastImageSource *source)
     return options | [source cacheOptions];
 }
 
+// The key a source's image is in SDWebImage's cache under: its cacheKey
+// (without needing a uri), or its url as a view converts it. `web` images
+// ignore cacheKey. nil without either.
+static NSString *FFFDiskCacheKey(FFFastImageSource *source)
+{
+    if (source.cacheKey.length > 0 && source.cacheControl != FFFCacheControlWeb) {
+        return source.cacheKey;
+    }
+    if (!source.url) {
+        return nil;
+    }
+    return [SDWebImageManager.sharedManager cacheKeyForURL:source.url context:FFFPreloadContext(source)];
+}
+
 static NSUInteger FFFPreloadLimit(void)
 {
     NSUInteger limit = [SDWebImagePrefetcher sharedImagePrefetcher].maxConcurrentPrefetchCount;
@@ -89,6 +189,64 @@ static void FFFStartPendingPreloads(void)
     }
 }
 
+// Loads the source in the preloads' queue, then calls completed once with its
+// image or error. Only on the main queue (SDWebImageManager calls its
+// completion blocks there); call FFFStartPendingPreloads after adding loads.
+static void FFFQueueLoad(FFFastImageSource *source,
+                         SDWebImageOptions options,
+                         SDWebImageContext *context,
+                         void (^completed)(UIImage *image, NSError *error))
+{
+    if (!FFFPendingPreloads) {
+        FFFPendingPreloads = [NSMutableArray array];
+    }
+    [FFFPendingPreloads addObject:[^{
+        // Once per slot: SDWebImage calls this once with finished set (a
+        // progressive load calls it more, without).
+        __block BOOL done = NO;
+        [[SDWebImageManager sharedManager] loadImageWithURL:source.url
+                                                    options:options
+                                                    context:context
+                                                   progress:nil
+                                                  completed:^(UIImage *image, NSData *data, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {
+            if (!finished || done) {
+                return;
+            }
+            done = YES;
+            if (error) {
+                [source forgetResponseAfterError:error];
+            }
+            FFFPreloadsInFlight--;
+            completed(image, error);
+            FFFStartPendingPreloads();
+        }];
+    } copy]];
+}
+
+// Calls found with the path of the file cached under key, or missing if it
+// isn't on disk. On the main queue.
+static void FFFFindCachedFile(NSString *key, void (^found)(NSString *path), dispatch_block_t missing)
+{
+    SDImageCache *cache = SDImageCache.sharedImageCache;
+    [cache diskImageExistsWithKey:key completion:^(BOOL exists) {
+        if (exists) {
+            found([cache cachePathForKey:key]);
+        } else {
+            missing();
+        }
+    }];
+}
+
+static NSDictionary *FFFFailure(NSString *error)
+{
+    return @{@"ok": @NO, @"error": error};
+}
+
+static NSDictionary *FFFFile(NSString *path)
+{
+    return @{@"ok": @YES, @"path": path};
+}
+
 // Resolves with a result per source, in order, once all have loaded or failed:
 // { ok, width, height } or { ok: false, error }. Never rejects. A source with
 // memoryCache false is only stored on disk, without decoding it (its size
@@ -100,9 +258,6 @@ RCT_EXPORT_METHOD(preload:(nonnull NSArray<FFFastImageSource *> *)sources
     // This runs on the UIManager queue; the queue state is only touched on
     // the main queue.
     dispatch_async(dispatch_get_main_queue(), ^{
-        if (!FFFPendingPreloads) {
-            FFFPendingPreloads = [NSMutableArray array];
-        }
         NSMutableArray *results = [NSMutableArray arrayWithCapacity:sources.count];
         // Sources of this call still to finish. It starts at the number of
         // sources, so the promise can't resolve before they've all been added.
@@ -117,7 +272,7 @@ RCT_EXPORT_METHOD(preload:(nonnull NSArray<FFFastImageSource *> *)sources
             if (!source.url) {
                 // An empty, missing or null uri (JS sends null sources as {}).
                 // It fails without taking a slot.
-                [results addObject:@{@"ok": @NO, @"error": @"Invalid source: no uri"}];
+                [results addObject:FFFFailure(@"Invalid source: no uri")];
                 finishOne();
                 return;
             }
@@ -130,30 +285,12 @@ RCT_EXPORT_METHOD(preload:(nonnull NSArray<FFFastImageSource *> *)sources
                 options |= SDWebImageAvoidDecodeImage;
                 context[SDWebImageContextStoreCacheType] = @(SDImageCacheTypeDisk);
             }
-            [FFFPendingPreloads addObject:[^{
-                // Once per slot: SDWebImage calls this once with finished set
-                // (a progressive load calls it more, without).
-                __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;
-                    if (error) {
-                        [source forgetResponseAfterError:error];
-                    }
-                    results[idx] = image
-                        ? @{@"ok": @YES, @"width": @(image.size.width), @"height": @(image.size.height)}
-                        : @{@"ok": @NO, @"error": FFFErrorMessage(error)};
-                    FFFPreloadsInFlight--;
-                    finishOne();
-                    FFFStartPendingPreloads();
-                }];
-            } copy]];
+            FFFQueueLoad(source, options, [context copy], ^(UIImage *image, NSError *error) {
+                results[idx] = image
+                    ? @{@"ok": @YES, @"width": @(image.size.width), @"height": @(image.size.height)}
+                    : FFFFailure(FFFErrorMessage(error));
+                finishOne();
+            });
         }];
 
         if (sources.count == 0) {
@@ -167,77 +304,155 @@ 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.
+// `cacheOnly`, or a cacheKey without a uri, 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"});
+        NSString *key = FFFDiskCacheKey(source);
+        if (!key) {
+            resolve(FFFFailure(@"Invalid source: no uri or cacheKey"));
+            return;
+        }
+        FFFFindCachedFile(key, ^(NSString *path) {
+            resolve(FFFFile(path));
+        }, ^{
+            resolve(FFFFailure(@"Not in the disk cache"));
+        });
         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"});
+        resolve(exists ? FFFFile(source.url.path) : FFFFailure(@"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});
-        }];
+    NSString *key = FFFDiskCacheKey(source);
+    void (^resolveFile)(NSString *) = ^(NSString *path) {
+        resolve(FFFFile(path));
     };
-    [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;
-        }
+    FFFFindCachedFile(key, resolveFile, ^{
         if (source.cacheControl == FFFCacheControlCacheOnly) {
-            resolve(@{@"ok": @NO, @"error": @"Not in the disk cache"});
+            resolve(FFFFailure(@"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.
+        // memory (an image in memory may not be on disk). It completes once
+        // the file is written.
         SDWebImageOptions options = FFFPreloadOptions(source) | SDWebImageAvoidDecodeImage | SDWebImageWaitStoreCache;
+        SDWebImageMutableContext *context = FFFPreloadContext(source);
         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]];
+        FFFQueueLoad(source, options, [context copy], ^(UIImage *image, NSError *error) {
+            if (!image) {
+                resolve(FFFFailure(FFFErrorMessage(error)));
+                return;
+            }
+            FFFFindCachedFile(key, resolveFile, ^{
+                resolve(FFFFailure(@"Not stored in the disk cache"));
+            });
+        });
         FFFStartPendingPreloads();
-    }];
+    });
+}
+
+// Stores a local image file as the source's image in the disk cache, so views
+// and preloads of the source load it without downloading it, and resolves
+// with its cached file: { ok, path } or { ok: false, error }. Never rejects.
+// It doesn't replace an image that's already cached (Glide can't on Android;
+// a new image should get a new cacheKey), and doesn't store `web` sources
+// (Android keeps them only in an HTTP cache).
+RCT_EXPORT_METHOD(writeToCache:(FFFastImageSource *)source
+                  file:(NSString *)file
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(__unused RCTPromiseRejectBlock)reject)
+{
+    if (source.cacheControl == FFFCacheControlWeb) {
+        resolve(FFFFailure(@"Can't store cache: 'web' images (they're kept in an HTTP cache)"));
+        return;
+    }
+    // A cacheKey is enough (the image doesn't need a url yet); otherwise a
+    // remote url.
+    NSString *scheme = source.url.scheme.lowercaseString;
+    if (source.cacheKey.length == 0 && ![scheme isEqualToString:@"http"] && ![scheme isEqualToString:@"https"]) {
+        resolve(FFFFailure(@"Invalid source: no remote uri or cacheKey"));
+        return;
+    }
+    // A file:// url or a path.
+    NSURL *fileURL = [RCTConvert NSURL:file];
+    if (!fileURL.isFileURL) {
+        resolve(FFFFailure(@"Not a local file"));
+        return;
+    }
+    NSString *key = FFFDiskCacheKey(source);
+    FFFFindCachedFile(key, ^(NSString *path) {
+        resolve(FFFFailure(@"Already in the disk cache"));
+    }, ^{
+        dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+            NSData *data = [NSData dataWithContentsOfURL:fileURL];
+            if (!data) {
+                resolve(FFFFailure(@"Can't read the file"));
+                return;
+            }
+            if ([NSData sd_imageFormatForImageData:data] == SDImageFormatUndefined) {
+                resolve(FFFFailure(@"Not an image"));
+                return;
+            }
+            SDImageCache *cache = SDImageCache.sharedImageCache;
+            [cache storeImageDataToDisk:data forKey:key];
+            // An image a view showed under this key before, which isn't on
+            // disk anymore.
+            [cache removeImageFromMemoryForKey:key];
+            resolve(FFFFile([cache cachePathForKey:key]));
+        });
+    });
+}
+
+// Changes cache limits at runtime and saves them, so they're used on the next
+// launches too: a number (0 for no limit), or null to go back to the app's
+// Info.plist or SDWebImage's default. A lower disk limit applies at once (what's
+// over it is removed; the disk cache is trimmed to half of maxDiskSize when
+// it's over), instead of when the app next goes to the background. Resolves
+// with the limits in effect (0 for no limit), and diskSize: the bytes the disk
+// cache uses now.
+RCT_EXPORT_METHOD(configureCache:(NSDictionary *)limits
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(__unused RCTPromiseRejectBlock)reject)
+{
+    SDImageCache *cache = SDImageCache.sharedImageCache;
+    SDImageCacheConfig *config = cache.config;
+    NSUserDefaults *defaults = NSUserDefaults.standardUserDefaults;
+    NSUInteger maxDiskSize = config.maxDiskSize;
+    NSTimeInterval maxDiskAge = config.maxDiskAge;
+    for (NSString *name in FFFCacheLimitNames()) {
+        id value = limits[name];
+        if (value == (id)kCFNull) {
+            [defaults removeObjectForKey:FFFSavedCacheLimitKey(name)];
+        } else if ([value isKindOfClass:NSNumber.class]) {
+            [defaults setObject:value forKey:FFFSavedCacheLimitKey(name)];
+        } else {
+            // Not given: unchanged.
+            continue;
+        }
+        FFFSetCacheLimit(config, name, FFFCacheLimit(name));
+    }
+    void (^finish)(void) = ^{
+        // Not on the disk cache's queue, which image loads use.
+        dispatch_async(dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
+            resolve(@{
+                @"maxDiskSize": @(config.maxDiskSize),
+                @"maxDiskAge": @(MAX(config.maxDiskAge, 0)),
+                @"maxMemorySize": @(config.maxMemoryCost),
+                @"diskSize": @(FFFFolderSize(cache.diskCachePath)),
+            });
+        });
+    };
+    if (config.maxDiskSize != maxDiskSize || config.maxDiskAge != maxDiskAge) {
+        [cache deleteOldFilesWithCompletionBlock:finish];
+    } else {
+        finish();
+    }
 }
 
 RCT_EXPORT_METHOD(clearMemoryCache:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-fast-image",
-    "version": "8.18.1",
+    "version": "8.19.0",
     "description": "🚩 FastImage, performant React Native image component.",
     "keywords": [
         "cache",
@@ -29,6 +29,7 @@
         "ios/FastImage",
         "ios/FastImage.xcodeproj/project.pbxproj",
         "ios/FastImage.xcodeproj/xcshareddata",
+        "app.plugin.js",
         "dist",
         "RNFastImage.podspec"
     ],