react-native-fast-image 8.11.0 → 8.13.0

package/README.md

@@ -196,6 +196,22 @@ How the image is filtered when it's drawn smaller or larger than its size (like
 
 ---
 
+### `paused?: boolean`
+
+Pauses an animated image (GIF, and animated WebP on iOS) on the frame it's showing; `false` plays it again from there. Each image animates on its own, so pausing one doesn't pause others showing the same file.
+
+---
+
+### `downsample?: boolean`
+
+iOS only. Decodes a large image at about the size it's shown at, instead of at full size, so it takes much less memory.
+
+Use it when you show images much larger than their views and can't get them at the right size, e.g. user uploads or other people's URLs in a list. If you control the images, serve them at the size they're shown instead (resized on your server or by an image CDN), which also saves bandwidth.
+
+Decoding a smaller copy can take a little longer, so use it where the memory matters. Needs SDWebImage 5.19.7 or later. On Android images are already decoded at about the view's size.
+
+---
+
 ### `onLoadStart?: () => void`
 
 Called when the image starts to load.

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

@@ -18,6 +18,7 @@ import com.bumptech.glide.load.resource.bitmap.BitmapResource;
 import com.bumptech.glide.load.resource.gif.GifBitmapProvider;
 import com.bumptech.glide.load.resource.gif.GifDrawable;
 
+import java.lang.reflect.Field;
 import java.nio.ByteBuffer;
 
 // Gives a view its own animation of a GIF. Glide gives every view that shows
@@ -64,6 +65,42 @@ final class FastImageGif {
         return copy;
     }
 
+    // GifDrawable.start() also starts counting plays again, so a paused GIF
+    // would play its whole loop count again when resumed; iOS continues it.
+    // The count isn't public: keep it across start() by reflection. A GIF
+    // that already finished its plays starts over, as on iOS. Without the
+    // fields (another Glide version), it counts again, as start() does.
+    @Nullable
+    private static final Field LOOP_COUNT = field("loopCount");
+    @Nullable
+    private static final Field MAX_LOOP_COUNT = field("maxLoopCount");
+
+    static void resume(GifDrawable gif) {
+        if (LOOP_COUNT == null || MAX_LOOP_COUNT == null) {
+            gif.start();
+            return;
+        }
+        try {
+            int played = LOOP_COUNT.getInt(gif);
+            int max = MAX_LOOP_COUNT.getInt(gif);
+            gif.start();
+            if (max == GifDrawable.LOOP_FOREVER || played < max) LOOP_COUNT.setInt(gif, played);
+        } catch (IllegalAccessException e) {
+            gif.start();
+        }
+    }
+
+    @Nullable
+    private static Field field(String name) {
+        try {
+            Field field = GifDrawable.class.getDeclaredField(name);
+            field.setAccessible(true);
+            return field.getType() == int.class ? field : null;
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
     // ByteBufferGifDecoder's.
     private static int sampleSize(GifHeader header, int width, int height) {
         int exact = Math.min(header.getHeight() / height, header.getWidth() / width);

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

@@ -99,6 +99,11 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
         view.setImageRendering(imageRendering);
     }
 
+    @ReactProp(name = "paused")
+    public void setPaused(FastImageViewWithUrl view, boolean paused) {
+        view.setPaused(paused);
+    }
+
     @ReactProp(name = "resizeMode")
     public void setResizeMode(FastImageViewWithUrl view, String resizeMode) {
         final FastImageViewWithUrl.ScaleType scaleType = FastImageViewConverter.getScaleType(resizeMode);

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

@@ -79,8 +79,26 @@ class FastImageViewWithUrl extends AppCompatImageView {
         // another view plays it.
         if (mOwnGif != null && getDrawable() == mOwnGif) {
             applyLoopCount(mOwnGif);
-            mOwnGif.stop();
-            mOwnGif.startFromFirstFrame();
+            if (!mPaused) {
+                mOwnGif.stop();
+                mOwnGif.startFromFirstFrame();
+            }
+        }
+    }
+
+    // Pauses GIFs on the frame they're showing (the view's own animation).
+    private boolean mPaused = false;
+
+    public void setPaused(boolean paused) {
+        if (paused == mPaused) return;
+        mPaused = paused;
+        if (mOwnGif != null && getDrawable() == mOwnGif) {
+            if (paused) {
+                mOwnGif.stop();
+            } else {
+                // Continues the loop count, as on iOS.
+                FastImageGif.resume(mOwnGif);
+            }
         }
     }
 
@@ -112,12 +130,27 @@ class FastImageViewWithUrl extends AppCompatImageView {
                     applyLoopCount(own);
                     super.onResourceReady(own, transition);
                     mOwnGif = own;
+                    // The target starts it; paused, it waits on its first frame.
+                    if (mPaused) own.stop();
                     return;
                 }
             }
             super.onResourceReady(resource, transition);
         }
 
+        // The target starts animations again when the Activity does: not a
+        // paused one, and the view's own GIF continues its loop count (start()
+        // would count again).
+        @Override
+        public void onStart() {
+            if (mPaused) return;
+            if (mOwnGif != null && getDrawable() == mOwnGif) {
+                FastImageGif.resume(mOwnGif);
+            } else {
+                super.onStart();
+            }
+        }
+
         @Override
         protected void setResource(@Nullable Drawable resource) {
             super.setResource(resource);

package/dist/index.cjs.js.flow

@@ -91,6 +91,8 @@ export type FastImageProps = $ReadOnly<{|
     recyclingKey?: ?string,
     loop?: ?(boolean | number),
     imageRendering?: ?('auto' | 'smooth' | 'pixelated'),
+    paused?: ?boolean,
+    downsample?: ?boolean,
     testID?: ?string,
 |}>
 

package/dist/index.d.ts

@@ -88,6 +88,19 @@ export interface FastImageProps extends AccessibilityProps, ViewProps {
      * pixels, e.g. for pixel art).
      */
     imageRendering?: 'auto' | 'smooth' | 'pixelated';
+    /**
+     * Pauses an animated image (GIF, and animated WebP on iOS) on the frame
+     * it's showing; `false` plays it again from there. Each image animates on
+     * its own, so pausing one doesn't pause others showing the same file.
+     */
+    paused?: boolean;
+    /**
+     * iOS only. Decodes a large image at about the size it's shown at, so it
+     * takes much less memory. For images much larger than their views that
+     * you can't get at the right size (if you can, resize them on your server
+     * or with an image CDN instead). See the README.
+     */
+    downsample?: boolean;
     onLoadStart?(): void;
     onProgress?(event: OnProgressEvent): void;
     onLoad?(event: OnLoadEvent): void;

package/dist/index.js.flow

@@ -91,6 +91,8 @@ export type FastImageProps = $ReadOnly<{|
     recyclingKey?: ?string,
     loop?: ?(boolean | number),
     imageRendering?: ?('auto' | 'smooth' | 'pixelated'),
+    paused?: ?boolean,
+    downsample?: ?boolean,
     testID?: ?string,
 |}>
 

package/ios/FastImage/FFFDownsampledImage.h

@@ -0,0 +1,28 @@
+#import <SDWebImage/SDAnimatedImage.h>
+#import <SDWebImage/SDWebImageDefine.h>
+
+// An image decoded at about the size it's shown at (the `downsample`
+// prop), instead of at full size. The view asks for it with SDWebImage's
+// thumbnail context: the box to fill (the view's size in pixels), and
+// preserveAspectRatio NO when the image has to cover the box (resizeMode
+// cover or stretch) rather than fit in it (contain or center). SDWebImage's
+// own thumbnail decoding can only fit, so this class works out the size from
+// the image's header before it decodes, as React Native's Image does.
+@interface FFFDownsampledImage : SDAnimatedImage
+
+// The url to load a source's url with, when it's downsampled.
++ (NSURL*) loadURLForURL: (NSURL*)url;
+
+// Sets a load's context to decode the image for a box (in pixels) to cover
+// or fit in.
++ (void) addToContext: (SDWebImageMutableContext*)context forURL: (NSURL*)url box: (CGSize)box cover: (BOOL)cover;
+
+// The size of the full image (in points, like UIImage's size) that an image
+// loaded this way was decoded from, for onLoad, or zero for other images.
++ (CGSize) sourceSizeOfImage: (UIImage*)image;
+
+// Whether this version of SDWebImage can decode through this class: it
+// decodes static images through the animated image class since 5.19.
++ (BOOL) isSupported;
+
+@end

package/ios/FastImage/FFFDownsampledImage.m

@@ -0,0 +1,169 @@
+#import "FFFDownsampledImage.h"
+#import <ImageIO/ImageIO.h>
+#import <SDWebImage/SDImageCoder.h>
+#import <SDWebImage/SDImageCacheDefine.h>
+#import <SDWebImage/SDWebImageCacheKeyFilter.h>
+#import <SDWebImage/UIImage+Metadata.h>
+
+// The decode option that carries the full image's size to the view.
+static SDImageCoderOption const FFFDecodeSourceSize = @"FFFDecodeSourceSize";
+// Added to the url's fragment, which isn't sent to the server.
+static NSString* const FFFDownsampledFragment = @"fastimage-downsampled";
+
+// The image's size in pixels as it's shown (EXIF orientations 5 to 8 turn it
+// sideways), from its header, or zero if ImageIO can't read it.
+static CGSize FFFPixelSize(NSData* data) {
+    CGImageSourceRef source = CGImageSourceCreateWithData((__bridge CFDataRef) data, NULL);
+    if (!source) {
+        return CGSizeZero;
+    }
+    NSDictionary* properties = (__bridge_transfer NSDictionary*) CGImageSourceCopyPropertiesAtIndex(source, 0, NULL);
+    CFRelease(source);
+    CGFloat width = [properties[(__bridge NSString*) kCGImagePropertyPixelWidth] doubleValue];
+    CGFloat height = [properties[(__bridge NSString*) kCGImagePropertyPixelHeight] doubleValue];
+    NSUInteger orientation = [properties[(__bridge NSString*) kCGImagePropertyOrientation] unsignedIntegerValue];
+    if (orientation >= kCGImagePropertyOrientationLeftMirrored) {
+        return CGSizeMake(height, width);
+    }
+    return CGSizeMake(width, height);
+}
+
+// Where the decode puts the full image's size, passed in the load's decode
+// options. SDWebImage attaches those options to the image it ends up with
+// (sd_decodeOptions), also when its force decoding replaces the decoded image
+// with another one, which drops anything kept on the image itself.
+@interface FFFSourceSize : NSObject
+@property (atomic, assign) CGSize size;
+@end
+
+@implementation FFFSourceSize
+
+// Any two are equal: it's where the result goes, not part of the request, so
+// the same request from several views is still decoded once (SDWebImage's
+// downloader groups them by their decode options).
+- (BOOL) isEqual: (id)object {
+    return [object isKindOfClass: [FFFSourceSize class]];
+}
+
+- (NSUInteger) hash {
+    return 0;
+}
+
+@end
+
+@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;
+}
+
++ (NSURL*) loadURLForURL: (NSURL*)url {
+    // SDWebImage's downloader shares a download between loads of the same
+    // url, and decodes each load's image with the first load's image class.
+    // After a load that isn't downsampled (e.g. a preload), this class
+    // wouldn't be used, and the box would be decoded as SDWebImage does (to
+    // fill it, stretched). With its own url, a downsampled load only shares
+    // downloads with other downsampled ones.
+    NSURLComponents* components = [NSURLComponents componentsWithURL: url resolvingAgainstBaseURL: NO];
+    if (!components) {
+        return url;
+    }
+    components.fragment = components.fragment.length > 0
+        ? [components.fragment stringByAppendingFormat: @"-%@", FFFDownsampledFragment]
+        : FFFDownsampledFragment;
+    return components.URL ?: url;
+}
+
++ (void) addToContext: (SDWebImageMutableContext*)context forURL: (NSURL*)url box: (CGSize)box cover: (BOOL)cover {
+    context[SDWebImageContextAnimatedImageClass] = [FFFDownsampledImage class];
+    // Cached under the url itself (see loadURLForURL:), so the disk cache
+    // keeps one download for every size and for loads that aren't downsampled.
+    NSString* key = url.absoluteString;
+    context[SDWebImageContextCacheKeyFilter] = [SDWebImageCacheKeyFilter cacheKeyFilterWithBlock: ^NSString* (NSURL* _Nonnull loadURL) {
+        return key;
+    }];
+    // The memory cache key is the url with these (SDWebImage's thumbnail
+    // key), so views of other sizes don't get this image.
+    context[SDWebImageContextImageThumbnailPixelSize] = [NSValue valueWithCGSize: box];
+    context[SDWebImageContextImagePreserveAspectRatio] = @(!cover);
+    context[SDWebImageContextImageDecodeOptions] = @{FFFDecodeSourceSize: [FFFSourceSize new]};
+    // Only in memory: the disk cache has the downloaded file.
+    context[SDWebImageContextStoreCacheType] = @(SDImageCacheTypeMemory);
+    context[SDWebImageContextQueryCacheType] = @(SDImageCacheTypeMemory);
+}
+
++ (CGSize) sourceSizeOfImage: (UIImage*)image {
+    id sourceSize = image.sd_decodeOptions[FFFDecodeSourceSize];
+    return [sourceSize isKindOfClass: [FFFSourceSize class]] ? ((FFFSourceSize*) sourceSize).size : CGSizeZero;
+}
+
+- (instancetype) initWithData: (NSData*)data scale: (CGFloat)scale options: (SDImageCoderOptions*)options {
+    NSValue* boxValue = options[SDImageCoderDecodeThumbnailPixelSize];
+    CGSize box = boxValue ? boxValue.CGSizeValue : CGSizeZero;
+    NSNumber* preserveAspectRatio = options[SDImageCoderDecodePreserveAspectRatio];
+    BOOL cover = preserveAspectRatio != nil && !preserveAspectRatio.boolValue;
+    CGSize pixelSize = FFFPixelSize(data);
+
+    // Decode at full size unless the image is at least twice as large as it
+    // needs to be (or its size can't be read). Decoding smaller is done in
+    // software, while newer iPhones decode JPEG and HEIC at full size in
+    // hardware: on an iPhone 15 Pro Max a 12 MP JPEG took about 20 ms at full
+    // size, and 120-130 ms with a peak of 100-125 MB decoded to 60-90% of its
+    // size (1-6 MB and 27-40 ms for a thumbnail).
+    NSMutableDictionary* decodeOptions = options ? [options mutableCopy] : [NSMutableDictionary dictionary];
+    [decodeOptions removeObjectForKey: SDImageCoderDecodeThumbnailPixelSize];
+    decodeOptions[SDImageCoderDecodePreserveAspectRatio] = @YES;
+    if (box.width > 0 && box.height > 0 && pixelSize.width > 0 && pixelSize.height > 0) {
+        CGFloat widthRatio = box.width / pixelSize.width;
+        CGFloat heightRatio = box.height / pixelSize.height;
+        CGFloat ratio = cover ? MAX(widthRatio, heightRatio) : MIN(widthRatio, heightRatio);
+        if (ratio <= 0.5) {
+            // ImageIO takes the longest side (kCGImageSourceThumbnailMaxPixelSize).
+            // SDWebImage works it out from the box with the image's stored
+            // width and height, before EXIF orientation, so a square box is
+            // the one that gives this side for any orientation.
+            CGFloat longest = ceil(MAX(pixelSize.width, pixelSize.height) * ratio);
+            decodeOptions[SDImageCoderDecodeThumbnailPixelSize] = [NSValue valueWithCGSize: CGSizeMake(longest, longest)];
+        }
+    }
+
+    self = [super initWithData: data scale: scale options: decodeOptions];
+    if (self) {
+        CGFloat imageScale = MAX(scale, 1);
+        FFFSourceSize* sourceSize = options[FFFDecodeSourceSize];
+        if ([sourceSize isKindOfClass: [FFFSourceSize class]]) {
+            sourceSize.size = pixelSize.width > 0 && pixelSize.height > 0
+                ? CGSizeMake(pixelSize.width / imageScale, pixelSize.height / imageScale)
+                : self.size;
+        }
+    }
+    return self;
+}
+
+@end

package/ios/FastImage/FFFastImageView.h

@@ -28,6 +28,10 @@
 // How the image is filtered when drawn at another size: auto, smooth or
 // pixelated.
 @property (nonatomic, copy) NSString *imageRendering;
+// Pauses animated images on the frame they're showing.
+@property (nonatomic, assign) BOOL paused;
+// Decodes images at about the view's size instead of at full size.
+@property (nonatomic, assign) BOOL downsample;
 
 @end
 

package/ios/FastImage/FFFastImageView.m

@@ -3,6 +3,7 @@
 #import <SDWebImage/UIView+WebCache.h>
 #import <React/RCTUtils.h>
 #import <SDWebImage/SDWebImageError.h>
+#import "FFFDownsampledImage.h"
 
 @interface FFFastImageView ()
 
@@ -25,6 +26,14 @@
 // Whether the view shows an image that loaded (not defaultSource or nothing).
 // A new source then keeps it until the new image has loaded (see reloadImage).
 @property(nonatomic, assign) BOOL showsLoadedImage;
+// downsample: a load waits for the view's size (see didSetProps).
+@property(nonatomic, assign) BOOL waitsForSize;
+// The size (in pixels) the image showing or loading was decoded for, and
+// whether it covers it; zero for a full-size image.
+@property(nonatomic, assign) CGSize decodedBox;
+@property(nonatomic, assign) BOOL decodedCover;
+// Counts loads, so a quiet reload's completion can tell if it's still current.
+@property(nonatomic, assign) NSUInteger loadCount;
 
 @end
 
@@ -85,9 +94,28 @@ static CFTimeInterval FFFEnteredBackgroundAt = 0;
     } else if (self.player && [self.image conformsToProtocol: @protocol(SDAnimatedImage)]) {
         self.player.totalLoopCount = [(id<SDAnimatedImage>) self.image animatedImageLoopCount];
     }
-    // Apply it to the image that's showing, and play it again.
+    // Apply it to the image that's showing, and play it again (unless it's
+    // paused: then it waits on the first frame).
     if (self.player) {
         [self.player seekToFrameAtIndex: 0 loopCount: 0];
+        if (!_paused) {
+            [self startAnimating];
+        }
+    }
+}
+
+- (void) setPaused: (BOOL)paused {
+    if (_paused == paused) {
+        return;
+    }
+    _paused = paused;
+    // SDAnimatedImageView starts an animated image when it's shown, and again
+    // when the view comes back on screen, unless autoPlayAnimatedImage is off.
+    // Stopping keeps the frame it's on (resetFrameIndexWhenStopped is off).
+    self.autoPlayAnimatedImage = !paused;
+    if (paused) {
+        [self stopAnimating];
+    } else {
         [self startAnimating];
     }
 }
@@ -121,6 +149,13 @@ static CFTimeInterval FFFEnteredBackgroundAt = 0;
 - (void) layoutSubviews {
     [super layoutSubviews];
     [self updateContentMode];
+    if (self.waitsForSize) {
+        if ([self hasSize]) {
+            [self reloadImage];
+        }
+    } else {
+        [self reloadIfResized];
+    }
 }
 
 - (void) setOnFastImageLoadEnd: (RCTDirectEventBlock)onFastImageLoadEnd {
@@ -235,9 +270,14 @@ NSString *FFFErrorMessage(NSError *error)
 }
 
 - (void) sendOnLoad: (UIImage*)image {
+    // The full image's size, also when it was decoded smaller.
+    CGSize size = [FFFDownsampledImage sourceSizeOfImage: image];
+    if (CGSizeEqualToSize(size, CGSizeZero)) {
+        size = image.size;
+    }
     self.onLoadEvent = @{
-            @"width": [NSNumber numberWithDouble: image.size.width],
-            @"height": [NSNumber numberWithDouble: image.size.height]
+            @"width": [NSNumber numberWithDouble: size.width],
+            @"height": [NSNumber numberWithDouble: size.height]
     };
     if (self.onFastImageLoad) {
         self.onFastImageLoad(self.onLoadEvent);
@@ -275,12 +315,95 @@ NSString *FFFErrorMessage(NSError *error)
 
 - (void) didSetProps: (NSArray<NSString*>*)changedProps {
     if (_needsReload) {
+        // With downsample on, the image is decoded for the view's size, so
+        // a view that hasn't been laid out yet loads once it has. Props and
+        // layout are applied in the same update, so that's before the next
+        // frame (in layoutSubviews). A view that still has no size then
+        // (e.g. one sized from onLoad) loads at full size.
+        if ([self downsamples] && ![self hasSize]) {
+            if (!self.waitsForSize) {
+                self.waitsForSize = YES;
+                __weak typeof(self) weakSelf = self;
+                dispatch_async(dispatch_get_main_queue(), ^{
+                    if (weakSelf.waitsForSize) {
+                        [weakSelf reloadImage];
+                    }
+                });
+            }
+            return;
+        }
         [self reloadImage];
+    } else {
+        [self reloadIfResized];
+    }
+}
+
+// Whether images are decoded at about the view's size (downsample).
+// Not for `repeat`, which tiles the image at its own size, or SDWebImage
+// before 5.19.
+- (BOOL) downsamples {
+    return _downsample && _resizeMode != RCTResizeModeRepeat && [FFFDownsampledImage isSupported];
+}
+
+// Whether the view has been laid out with an area. One that's 0 wide or tall
+// (e.g. sized from onLoad) has no size to decode the image for.
+- (BOOL) hasSize {
+    return self.bounds.size.width > 0 && self.bounds.size.height > 0;
+}
+
+// The size in pixels to decode the image for, or zero for full size.
+- (CGSize) decodeBox {
+    if (![self downsamples] || ![self hasSize]) {
+        return CGSizeZero;
+    }
+    CGFloat scale = self.window.screen.scale ?: [UIScreen mainScreen].scale;
+    CGSize size = self.bounds.size;
+    return CGSizeMake(ceil(size.width * scale), ceil(size.height * scale));
+}
+
+// Whether the image has to cover the box, rather than fit in it.
+- (BOOL) decodeCovers {
+    return _resizeMode == RCTResizeModeCover || _resizeMode == RCTResizeModeStretch;
+}
+
+// The view grew (by more than a fifth, as React Native's Image reloads), or
+// now needs a covering or full-size image: loads the image again for its
+// size, keeping the current one until then. It comes from the disk cache
+// (the downloaded file is kept there whatever size it's decoded at).
+- (void) reloadIfResized {
+    if (!_source || _needsReload || self.hasErrored || CGSizeEqualToSize(self.decodedBox, CGSizeZero)) {
+        return;
+    }
+    // Already at full size (it's no larger than the view it was decoded for).
+    UIImage* image = self.untintedImage ?: super.image;
+    if (self.hasCompleted && CGSizeEqualToSize(image.size, [FFFDownsampledImage sourceSizeOfImage: image])) {
+        return;
     }
+    CGSize box = [self decodeBox];
+    BOOL cover = [self decodeCovers];
+    if ([self downsamples]) {
+        if (![self hasSize]) {
+            return;
+        }
+        BOOL grew = box.width > self.decodedBox.width * 1.2 || box.height > self.decodedBox.height * 1.2;
+        if (!grew && (self.decodedCover || !cover)) {
+            return;
+        }
+    }
+    SDWebImageOptions options = [self loadOptions];
+    if (self.showsLoadedImage) {
+        options |= SDWebImageDelayPlaceholder;
+    }
+    // Without events once it has loaded: it's the same image. If it's still
+    // loading, it restarts for the new size, and sends its events as usual.
+    BOOL events = !self.hasCompleted;
+    [self downloadImage: _source options: options context: [self loadContext] events: events];
 }
 
 - (void) reloadImage {
     _needsReload = NO;
+    self.waitsForSize = NO;
+    self.decodedBox = CGSizeZero;
 
     if (_source) {
         // Load base64 images.
@@ -321,33 +444,7 @@ NSString *FFFErrorMessage(NSError *error)
             return;
         }
 
-        // Set headers.
-        SDWebImageContext* context = @{SDWebImageContextDownloadRequestModifier: _source.requestModifier};
-
-        // Set priority.
-        SDWebImageOptions options = SDWebImageRetryFailed | SDWebImageHandleCookies;
-        switch (_source.priority) {
-            case FFFPriorityLow:
-                options |= SDWebImageLowPriority;
-                break;
-            case FFFPriorityNormal:
-                // Priority is normal by default.
-                break;
-            case FFFPriorityHigh:
-                options |= SDWebImageHighPriority;
-                break;
-        }
-
-        switch (_source.cacheControl) {
-            case FFFCacheControlWeb:
-                options |= SDWebImageRefreshCached;
-                break;
-            case FFFCacheControlCacheOnly:
-                options |= SDWebImageFromCacheOnly;
-                break;
-            case FFFCacheControlImmutable:
-                break;
-        }
+        SDWebImageOptions options = [self loadOptions];
 
         // Keep showing the loaded image until the new one has loaded, instead
         // of clearing it to defaultSource (or nothing) while it loads, which
@@ -368,20 +465,66 @@ NSString *FFFErrorMessage(NSError *error)
         self.retriedAfterBackground = NO;
         [self stopWaitingForActive];
 
-        [self downloadImage: _source options: options context: context];
+        [self downloadImage: _source options: options context: [self loadContext] events: YES];
     } else if (_defaultSource) {
         [self setImage: _defaultSource];
         self.showsLoadedImage = NO;
     }
 }
 
-- (void) downloadImage: (FFFastImageSource*)source options: (SDWebImageOptions)options context: (SDWebImageContext*)context {
+- (SDWebImageOptions) loadOptions {
+    SDWebImageOptions options = SDWebImageRetryFailed | SDWebImageHandleCookies;
+    switch (_source.priority) {
+        case FFFPriorityLow:
+            options |= SDWebImageLowPriority;
+            break;
+        case FFFPriorityNormal:
+            // Priority is normal by default.
+            break;
+        case FFFPriorityHigh:
+            options |= SDWebImageHighPriority;
+            break;
+    }
+
+    switch (_source.cacheControl) {
+        case FFFCacheControlWeb:
+            options |= SDWebImageRefreshCached;
+            break;
+        case FFFCacheControlCacheOnly:
+            options |= SDWebImageFromCacheOnly;
+            break;
+        case FFFCacheControlImmutable:
+            break;
+    }
+    return options;
+}
+
+// Headers, and the size to decode at (see FFFDownsampledImage), which it
+// records as decodedBox.
+- (SDWebImageContext*) loadContext {
+    SDWebImageMutableContext* context = [NSMutableDictionary dictionary];
+    context[SDWebImageContextDownloadRequestModifier] = _source.requestModifier;
+    CGSize box = [self decodeBox];
+    self.decodedBox = box;
+    self.decodedCover = [self decodeCovers];
+    if (CGSizeEqualToSize(box, CGSizeZero)) {
+        context[SDWebImageContextAnimatedImageClass] = [SDAnimatedImage class];
+        return context;
+    }
+    [FFFDownsampledImage addToContext: context forURL: _source.url box: box cover: self.decodedCover];
+    return context;
+}
+
+// events: NO for a quiet reload at a new size (see reloadIfResized), which
+// sends no events and keeps the current image if it fails.
+- (void) downloadImage: (FFFastImageSource*)source options: (SDWebImageOptions)options context: (SDWebImageContext*)context events: (BOOL)events {
     __weak typeof(self) weakSelf = self; // Always use a weak reference to self in blocks
+    NSUInteger load = ++self.loadCount;
     // Most images have no onProgress, so only ask SDWebImage for progress when
     // there's a handler as the load starts. A handler added while loading is
     // used from the next load.
     SDImageLoaderProgressBlock progress = nil;
-    if (self.onFastImageProgress) {
+    if (events && 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.
@@ -404,15 +547,49 @@ NSString *FFFErrorMessage(NSError *error)
         };
     }
     CFTimeInterval startedAt = CACurrentMediaTime();
-    [self sd_setImageWithURL: _source.url
-            placeholderImage: _defaultSource
-                     options: options
-                     context: context
-                    progress: progress
-                   completed: ^(UIImage* _Nullable image,
+    NSURL* url = context[SDWebImageContextImageThumbnailPixelSize] ? [FFFDownsampledImage loadURLForURL: source.url] : source.url;
+    if (!events) {
+        // Only this load's image: SDWebImage would clear the view (to the
+        // placeholder) if it fails, and a cancelled load can still complete.
+        SDSetImageBlock setImage = ^(UIImage* _Nullable image, NSData* _Nullable data, SDImageCacheType cacheType, NSURL* _Nullable imageURL) {
+            if (image && weakSelf.loadCount == load) {
+                weakSelf.image = image;
+            }
+        };
+        [self sd_internalSetImageWithURL: url
+                        placeholderImage: nil
+                                 options: options
+                                 context: context
+                           setImageBlock: setImage
+                                progress: nil
+                               completed: ^(UIImage* _Nullable image, NSData* _Nullable data, NSError* _Nullable error, SDImageCacheType cacheType, BOOL finished, NSURL* _Nullable imageURL) {
+            if (error && weakSelf.loadCount == load) {
+                // Keeps the image it has, without trying again on every
+                // layout (e.g. while offline).
+                weakSelf.decodedBox = CGSizeZero;
+            }
+        }];
+        return;
+    }
+    // Like SDAnimatedImageView's sd_setImageWithURL, which sets the image
+    // class to SDAnimatedImage (loadContext sets it).
+    [self sd_internalSetImageWithURL: url
+                    placeholderImage: _defaultSource
+                             options: options
+                             context: context
+                       setImageBlock: nil
+                            progress: progress
+                           completed: ^(UIImage* _Nullable image,
+                    NSData* _Nullable data,
                     NSError* _Nullable error,
                     SDImageCacheType cacheType,
+                    BOOL finished,
                     NSURL* _Nullable imageURL) {
+                // Restarted for a new size (reloadIfResized): the new load
+                // sends the events.
+                if (weakSelf.loadCount != load && weakSelf.source == source) {
+                    return;
+                }
                 // The download was running when the app went to the
                 // background, and failed: iOS suspends it there, and its
                 // timeout keeps counting, so it times out as the app comes
@@ -449,7 +626,7 @@ NSString *FFFErrorMessage(NSError *error)
     // nil in app extensions, which don't get these notifications.
     UIApplication* application = RCTSharedApplication();
     if (!application || application.applicationState == UIApplicationStateActive) {
-        [self downloadImage: source options: options context: context];
+        [self downloadImage: source options: options context: context events: YES];
         return;
     }
     [self stopWaitingForActive];
@@ -460,7 +637,7 @@ NSString *FFFErrorMessage(NSError *error)
                                                                         usingBlock: ^(NSNotification* notification) {
         [weakSelf stopWaitingForActive];
         if (weakSelf.source == source) {
-            [weakSelf downloadImage: source options: options context: context];
+            [weakSelf downloadImage: source options: options context: context events: YES];
         }
     }];
 }

package/ios/FastImage/FFFastImageViewManager.m

@@ -20,6 +20,8 @@ RCT_EXPORT_VIEW_PROPERTY(resizeMode, RCTResizeMode)
 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(downsample, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(onFastImageLoadStart, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(onFastImageProgress, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(onFastImageError, RCTDirectEventBlock)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-fast-image",
-    "version": "8.11.0",
+    "version": "8.13.0",
     "description": "🚩 FastImage, performant React Native image component.",
     "keywords": [
         "cache",
@@ -51,6 +51,7 @@
         "@types/react": "^17.0.14",
         "@types/react-native": "^0.69.5",
         "@types/react-test-renderer": "^17.0.1",
+        "conventional-changelog-angular": "8.3.1",
         "maestro-runner": "1.1.27",
         "odiff-bin": "^4.5.0",
         "oxfmt": "0.70.0",