react-native-fast-image 9.3.7 → 10.1.0

package/ios/FastImage/FFFDownsampledImage.m

@@ -54,41 +54,7 @@ static CGSize FFFPixelSize(NSData* data) {
 
 @implementation FFFDownsampledImage
 
-+ (BOOL) isSupported {
-    static BOOL supported = NO;
-    static dispatch_once_t once;
-    dispatch_once(&once, ^{
-        // No animated image coder takes JPEG, so before SDWebImage 5.19
-        // SDAnimatedImage returned nil for one, and SDWebImage decoded it with
-        // its thumbnail options as they are (stretched to the box).
-        CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
-        CGContextRef context = CGBitmapContextCreate(NULL, 1, 1, 8, 4, colorSpace, kCGImageAlphaNoneSkipLast);
-        CGColorSpaceRelease(colorSpace);
-        CGImageRef pixel = context ? CGBitmapContextCreateImage(context) : NULL;
-        if (context) {
-            CGContextRelease(context);
-        }
-        if (!pixel) {
-            return;
-        }
-        NSMutableData* jpeg = [NSMutableData data];
-        CGImageDestinationRef destination = CGImageDestinationCreateWithData((__bridge CFMutableDataRef) jpeg, CFSTR("public.jpeg"), 1, NULL);
-        if (destination) {
-            CGImageDestinationAddImage(destination, pixel, NULL);
-            CGImageDestinationFinalize(destination);
-            CFRelease(destination);
-        }
-        CGImageRelease(pixel);
-        supported = jpeg.length > 0 && [[SDAnimatedImage alloc] initWithData: jpeg scale: 1 options: nil] != nil;
-    });
-    return supported;
-}
-
 + (void) addFullSizeToContext: (SDWebImageMutableContext*)context {
-    if (![self isSupported]) {
-        context[SDWebImageContextAnimatedImageClass] = [SDAnimatedImage class];
-        return;
-    }
     context[SDWebImageContextAnimatedImageClass] = [FFFDownsampledImage class];
     context[SDWebImageContextImageDecodeOptions] = @{FFFDecodeSourceSize: [FFFSourceSize new]};
 }

package/ios/FastImage/FFFastImageModule.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+#import <RNFastImageSpec/RNFastImageSpec.h>
+
+// FastImage's functions (preload, getCachePath, writeToCache and the caches'
+// settings): the FastImageModule TurboModule (src/specs).
+@interface FFFastImageModule : NSObject <NativeFastImageModuleSpec>
+
+@end

package/ios/FastImage/{FFFastImageViewManager.m → FFFastImageModule.mm}

@@ -1,8 +1,10 @@
-#import "FFFastImageViewManager.h"
+#import "FFFastImageModule.h"
+#import "RCTConvert+FFFastImage.h"
 #import "FFFastImageView.h"
 #import "FFFDownsampledImage.h"
 
 #import <SDWebImage/SDImageCache.h>
+#import <SDWebImage/SDImageCoderHelper.h>
 #import <SDWebImage/SDWebImageManager.h>
 #import <SDWebImage/SDWebImageError.h>
 #import <SDWebImage/SDWebImagePrefetcher.h>
@@ -41,8 +43,7 @@ static NSNumber *FFFCacheLimit(NSString *name)
 }
 
 // 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).
+// SDWebImage's default. maxDiskAge counts from when an image was last used.
 static void FFFSetCacheLimit(SDImageCacheConfig *config, NSString *name, NSNumber *value)
 {
     double limit = MAX(value.doubleValue, 0);
@@ -54,6 +55,8 @@ static void FFFSetCacheLimit(SDImageCacheConfig *config, NSString *name, NSNumbe
         // SDWebImage never expires images with a negative age (with 0 it
         // would remove them all).
         config.maxDiskAge = limit > 0 ? limit : -1;
+        // SDWebImage's default; set in case the app changed it, as FastImage
+        // documents maxDiskAge as counted from an image's last use.
         config.diskCacheExpireType = SDImageCacheConfigExpireTypeAccessDate;
     } else {
         config.maxDiskAge = 60 * 60 * 24 * 7;
@@ -76,50 +79,51 @@ static unsigned long long FFFFolderSize(NSString *path)
     return size;
 }
 
-@implementation FFFastImageViewManager
+// Runs once per launch, before FastImage first uses SDWebImage's cache: from
+// FFFastImageModule's +initialize (on the JS thread: React Native creates the
+// app's module providers, this class among them, at the first native module JS
+// asks for) or FFFastImageView's (main thread), whichever comes first;
+// dispatch_once makes the other wait until the limits are set. Image loads
+// don't read the limits: SDWebImage reads the disk ones when it trims the disk
+// cache (on its I/O queue, when the app goes to the background or closes), and
+// the memory one is its NSCache's cost limit (NSCache is thread-safe).
+void FFFApplyCacheLimits(void)
+{
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        SDImageCacheConfig *config = SDImageCache.sharedImageCache.config;
+        for (NSString *name in FFFCacheLimitNames()) {
+            NSNumber *value = FFFCacheLimit(name);
+            if (value) {
+                FFFSetCacheLimit(config, name, value);
+            }
+        }
+    });
+}
 
-RCT_EXPORT_MODULE(FastImageView)
+@implementation FFFastImageModule
 
-// 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.
+// React Native finds the module through codegenConfig's ios.modulesProvider
+// (in the app's RCTAppDependencyProvider), as it finds the view through
+// componentProvider, so it isn't registered with RCT_EXPORT_MODULE.
++ (NSString *)moduleName
+{
+    return @"FastImageModule";
+}
+
+// The app's cache limits, before a preload (views apply them too).
 + (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);
-        }
+    if (self == [FFFastImageModule class]) {
+        FFFApplyCacheLimits();
     }
 }
 
-- (FFFastImageView*)view {
-  return [[FFFastImageView alloc] init];
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeFastImageModuleSpecJSI>(params);
 }
 
-RCT_EXPORT_VIEW_PROPERTY(source, FFFastImageSource)
-RCT_EXPORT_VIEW_PROPERTY(sources, FFFastImageSourceArray)
-RCT_EXPORT_VIEW_PROPERTY(defaultSource, UIImage)
-RCT_EXPORT_VIEW_PROPERTY(resizeMode, FFFResizeMode)
-RCT_EXPORT_VIEW_PROPERTY(recyclingKey, NSString)
-RCT_EXPORT_VIEW_PROPERTY(loopCount, NSInteger)
-RCT_EXPORT_VIEW_PROPERTY(imageRendering, NSString)
-RCT_EXPORT_VIEW_PROPERTY(paused, BOOL)
-RCT_EXPORT_VIEW_PROPERTY(transitionDuration, double)
-RCT_EXPORT_VIEW_PROPERTY(transitionBetweenImages, BOOL)
-RCT_EXPORT_VIEW_PROPERTY(transitionSkipOnCacheHit, NSString)
-RCT_EXPORT_VIEW_PROPERTY(downsample, BOOL)
-RCT_EXPORT_VIEW_PROPERTY(blurRadius, CGFloat)
-RCT_EXPORT_VIEW_PROPERTY(trackProgress, BOOL)
-RCT_EXPORT_VIEW_PROPERTY(onFastImageLoadStart, RCTDirectEventBlock)
-RCT_EXPORT_VIEW_PROPERTY(onFastImageProgress, RCTDirectEventBlock)
-RCT_EXPORT_VIEW_PROPERTY(onFastImageError, RCTDirectEventBlock)
-RCT_EXPORT_VIEW_PROPERTY(onFastImageLoad, RCTDirectEventBlock)
-RCT_EXPORT_VIEW_PROPERTY(onFastImageLoadEnd, RCTDirectEventBlock)
-RCT_REMAP_VIEW_PROPERTY(tintColor, imageColor, UIColor)
 
 // Preloads waiting to start, in the order they were added, and the number
 // loading, across all preload calls. Like SDWebImagePrefetcher, at most
@@ -251,6 +255,10 @@ static NSDictionary *FFFFailure(NSString *error)
     return @{@"ok": @NO, @"error": error};
 }
 
+// preload's, getCachePath's and writeToCache's error for a source with
+// diskCache false.
+static NSString *const FFFNotOnDisk = @"The source has diskCache: false, so it isn't kept on disk";
+
 static NSDictionary *FFFFile(NSString *path)
 {
     return @{@"ok": @YES, @"path": path};
@@ -260,11 +268,12 @@ static NSDictionary *FFFFile(NSString *path)
 // { ok, width, height } or { ok: false, error }. Never rejects. A source with
 // memoryCache false is only stored on disk, without decoding it (its size
 // comes from the header).
-RCT_EXPORT_METHOD(preload:(nonnull NSArray<FFFastImageSource *> *)sources
-                  resolve:(RCTPromiseResolveBlock)resolve
-                  reject:(__unused RCTPromiseRejectBlock)reject)
+- (void)preload:(NSArray *)sourcesJSON
+        resolve:(RCTPromiseResolveBlock)resolve
+         reject:(__unused RCTPromiseRejectBlock)reject
 {
-    // This runs on the UIManager queue; the queue state is only touched on
+    NSArray<FFFastImageSource *> *sources = [RCTConvert FFFastImageSourceArray:sourcesJSON];
+    // This runs on the module's queue; the queue state is only touched on
     // the main queue.
     dispatch_async(dispatch_get_main_queue(), ^{
         NSMutableArray *results = [NSMutableArray arrayWithCapacity:sources.count];
@@ -285,6 +294,13 @@ RCT_EXPORT_METHOD(preload:(nonnull NSArray<FFFastImageSource *> *)sources
                 finishOne();
                 return;
             }
+            if (!source.diskCache) {
+                // Views decode an image for their own size, so one only
+                // preloaded into memory would be downloaded again.
+                [results addObject:FFFFailure(FFFNotOnDisk)];
+                finishOne();
+                return;
+            }
             [results addObject:[NSNull null]];
             SDWebImageOptions options = FFFPreloadOptions(source);
             SDWebImageMutableContext *context = FFFPreloadContext(source);
@@ -293,7 +309,7 @@ RCT_EXPORT_METHOD(preload:(nonnull NSArray<FFFastImageSource *> *)sources
             if (!source.memoryCache) {
                 // Not decoded (only its header is read, for the size), and not
                 // kept in memory, also when it comes from the disk cache.
-                options |= SDWebImageAvoidDecodeImage;
+                context[SDWebImageContextImageForceDecodePolicy] = @(SDImageForceDecodePolicyNever);
                 context[SDWebImageContextStoreCacheType] = @(SDImageCacheTypeDisk);
             }
             FFFQueueLoad(source, options, [context copy], ^(UIImage *image, NSError *error) {
@@ -317,10 +333,15 @@ RCT_EXPORT_METHOD(preload:(nonnull NSArray<FFFastImageSource *> *)sources
 // preloads' queue): { ok, path } or { ok: false, error }. Never rejects. With
 // `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)
+- (void)getCachePath:(NSDictionary *)sourceJSON
+             resolve:(RCTPromiseResolveBlock)resolve
+              reject:(__unused RCTPromiseRejectBlock)reject
 {
+    FFFastImageSource *source = [RCTConvert FFFastImageSource:sourceJSON];
+    if (source && !source.diskCache) {
+        resolve(FFFFailure(FFFNotOnDisk));
+        return;
+    }
     if (!source.url) {
         NSString *key = FFFDiskCacheKey(source);
         if (!key) {
@@ -351,8 +372,9 @@ RCT_EXPORT_METHOD(getCachePath:(FFFastImageSource *)source
         // 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 completes once
         // the file is written.
-        SDWebImageOptions options = FFFPreloadOptions(source) | SDWebImageAvoidDecodeImage | SDWebImageWaitStoreCache;
+        SDWebImageOptions options = FFFPreloadOptions(source) | SDWebImageWaitStoreCache;
         SDWebImageMutableContext *context = FFFPreloadContext(source);
+        context[SDWebImageContextImageForceDecodePolicy] = @(SDImageForceDecodePolicyNever);
         context[SDWebImageContextQueryCacheType] = @(SDImageCacheTypeDisk);
         context[SDWebImageContextStoreCacheType] = @(SDImageCacheTypeDisk);
         FFFQueueLoad(source, options, [context copy], ^(UIImage *image, NSError *error) {
@@ -374,11 +396,16 @@ RCT_EXPORT_METHOD(getCachePath:(FFFastImageSource *)source
 // 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)
+- (void)writeToCache:(NSDictionary *)sourceJSON
+                file:(NSString *)file
+             resolve:(RCTPromiseResolveBlock)resolve
+              reject:(__unused RCTPromiseRejectBlock)reject
 {
+    FFFastImageSource *source = [RCTConvert FFFastImageSource:sourceJSON];
+    if (source && !source.diskCache) {
+        resolve(FFFFailure(FFFNotOnDisk));
+        return;
+    }
     if (source.cacheControl == FFFCacheControlWeb) {
         resolve(FFFFailure(@"Can't store cache: 'web' images (they're kept in an HTTP cache)"));
         return;
@@ -421,24 +448,27 @@ RCT_EXPORT_METHOD(writeToCache:(FFFastImageSource *)source
 }
 
 // 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
+// launches too: a number (0 for no limit), or its name in `reset` (null in
+// JS) 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)
+- (void)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;
+    // The limits set to null in JS arrive as a list of names (a TurboModule
+    // leaves null values out of the dictionary).
+    NSArray *reset = [limits[@"reset"] isKindOfClass:NSArray.class] ? limits[@"reset"] : @[];
     for (NSString *name in FFFCacheLimitNames()) {
         id value = limits[name];
-        if (value == (id)kCFNull) {
+        if ([reset containsObject:name]) {
             [defaults removeObjectForKey:FFFSavedCacheLimitKey(name)];
         } else if ([value isKindOfClass:NSNumber.class]) {
             [defaults setObject:value forKey:FFFSavedCacheLimitKey(name)];
@@ -466,13 +496,13 @@ RCT_EXPORT_METHOD(configureCache:(NSDictionary *)limits
     }
 }
 
-RCT_EXPORT_METHOD(clearMemoryCache:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+- (void)clearMemoryCache:(RCTPromiseResolveBlock)resolve reject:(__unused RCTPromiseRejectBlock)reject
 {
     [SDImageCache.sharedImageCache clearMemory];
     resolve(@{@"ok": @YES});
 }
 
-RCT_EXPORT_METHOD(clearDiskCache:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+- (void)clearDiskCache:(RCTPromiseResolveBlock)resolve reject:(__unused RCTPromiseRejectBlock)reject
 {
     // And the HTTP cache of `cache: 'web'` images.
     [FFFastImageSource.webURLCache removeAllCachedResponses];

package/ios/FastImage/FFFastImageSource.h

@@ -39,6 +39,10 @@ typedef NS_ENUM(NSInteger, FFFCacheControl) {
 // default YES). Without it, it's only kept on disk: views don't leave it in
 // memory, and preload doesn't decode it.
 @property (nonatomic) BOOL memoryCache;
+// Whether the image is kept in the disk cache (`diskCache`, default YES).
+// Without it, it isn't read from or written to the disk cache, nor for `web`
+// images the HTTP cache.
+@property (nonatomic) BOOL diskCache;
 
 - (instancetype)initWithURL:(NSURL *)url
                    priority:(FFFPriority)priority

package/ios/FastImage/FFFastImageSource.m

@@ -346,6 +346,7 @@ static BOOL FFFLooksLikeSVG(NSData *data)
         _headers = headers;
         _cacheControl = cacheControl;
         _memoryCache = YES;
+        _diskCache = YES;
     }
     return self;
 }
@@ -366,7 +367,10 @@ static BOOL FFFLooksLikeSVG(NSData *data)
 {
     switch (_cacheControl) {
         case FFFCacheControlWeb:
-            return SDWebImageRefreshCached;
+            // Without the disk cache, nor the HTTP cache: without this option
+            // SDWebImage's requests neither read it nor store their responses
+            // there.
+            return _diskCache ? SDWebImageRefreshCached : 0;
         case FFFCacheControlCacheOnly:
             return SDWebImageFromCacheOnly;
         case FFFCacheControlImmutable:

package/ios/FastImage/FFFastImageView.h

@@ -4,15 +4,19 @@
 #import <SDWebImage/SDWebImageDownloader.h>
 
 #import <React/RCTComponent.h>
-#import <React/RCTResizeMode.h>
 
 #import "FFFastImageSource.h"
 
-// resizeMode: React Native's, and `none` (objectFit="none": the image at its
-// own size, centered, not scaled), which React Native's own resize modes only
-// have from 0.77, with another meaning (top-left).
-typedef RCTResizeMode FFFResizeMode;
-static const FFFResizeMode FFFResizeModeNone = (FFFResizeMode) -2;
+// objectFit, as CSS's object-fit.
+typedef NS_ENUM(NSInteger, FFFObjectFit) {
+    FFFObjectFitCover,
+    FFFObjectFitContain,
+    FFFObjectFitFill,
+    // The image at its own size, or scaled down to fit if it's larger.
+    FFFObjectFitScaleDown,
+    // The image at its own size, whatever its size (cropped by the view).
+    FFFObjectFitNone,
+};
 
 @interface FFFastImageView : SDAnimatedImageView
 
@@ -23,7 +27,7 @@ static const FFFResizeMode FFFResizeModeNone = (FFFResizeMode) -2;
 @property (nonatomic, copy) RCTDirectEventBlock onFastImageError;
 @property (nonatomic, copy) RCTDirectEventBlock onFastImageLoad;
 @property (nonatomic, copy) RCTDirectEventBlock onFastImageLoadEnd;
-@property (nonatomic, assign) FFFResizeMode resizeMode;
+@property (nonatomic, assign) FFFObjectFit objectFit;
 @property (nonatomic, strong) FFFastImageSource *source;
 // Several sources (2 or more) of the same image at different sizes: the view
 // loads the one whose size is closest to its own.
@@ -51,10 +55,35 @@ static const FFFResizeMode FFFResizeModeNone = (FFFResizeMode) -2;
 @property (nonatomic, assign) BOOL downsample;
 // Blurs the loaded image by this radius, in points (0 is no blur).
 @property (nonatomic, assign) CGFloat blurRadius;
+// objectPosition, as CSS computes it: on each axis the image's left or top
+// edge is at (view - image) * fraction + offset, in points.
+@property (nonatomic, assign) CGFloat objectPositionX;
+@property (nonatomic, assign) CGFloat objectPositionXOffset;
+@property (nonatomic, assign) CGFloat objectPositionY;
+@property (nonatomic, assign) CGFloat objectPositionYOffset;
+
+// After an update's props are set: loads the image if they changed it (once
+// the view has a size, when it needs one).
+- (void) didSetProps;
+
+// Keeps the view's mask (React Native's, for its rounded corners) on the box
+// the view was laid out at, while objectPosition moves the view: after React
+// Native sets or removes it.
+- (void) updateMask;
+
+// Stops for good, before the view is discarded: cancels the load and sends no
+// more events, also for a load that already finished and is on its way to the
+// main queue.
+- (void) stop;
 
 @end
 
 // An error's description, with the HTTP status code when there is one.
 FOUNDATION_EXTERN NSString *FFFErrorMessage(NSError *error);
 
+// Applies the app's cache limits (saved by configureCache, or in its
+// Info.plist) to SDWebImage's cache, once, before FastImage loads an image
+// (in FFFastImageModule.mm).
+FOUNDATION_EXTERN void FFFApplyCacheLimits(void);
+