react-native-fast-image 8.27.4 → 8.28.1

package/README.md

@@ -276,7 +276,7 @@ Changing it restarts the animation.
 How the image is filtered when it's drawn smaller or larger than its size (like CSS's `image-rendering`):
 
 - `'auto'` **(Default)** - The platform's usual filtering.
-- `'smooth'` - iOS only. Keeps a large image drawn much smaller than its size (e.g. a big photo as a thumbnail, or fine lines and text) from looking jagged or noisy. **It uses more memory:** the image is also kept at smaller sizes for drawing, about a third more than the decoded image. On Android it's the same as `'auto'` (images are already decoded at about the view's size there).
+- `'smooth'` - iOS only. Keeps a large image drawn much smaller than its size (e.g. a big photo as a thumbnail, or fine lines and text) from looking jagged or noisy. Such an image is already decoded at about the view's size by default (see `downsample`), so this is for images shown at less than half their size with `downsample={false}`, or a little smaller than their size. **It uses more memory:** the image is also kept at smaller sizes for drawing, about a third more than the decoded image. On Android it's the same as `'auto'` (images are always decoded at about the view's size there).
 - `'pixelated'` - Sharp pixels, without smoothing, e.g. for pixel art drawn larger than its size. On Android, animated images are still smoothed.
 
 ---
@@ -312,9 +312,12 @@ Downloads, local files (`file://`, `content://`) and bundled images (`require()`
 
 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.
+- `true` **(Default)** - An image at least twice the size its view needs is decoded at about the view's size. If the view grows, the image is decoded again for its new size (from the disk cache).
+- `false` - Images are decoded at full size, e.g. for an image that's zoomed in on with a transform (a pinch-to-zoom viewer), which would otherwise show the smaller copy enlarged.
 
-Decoding a smaller copy can take a little longer, so use it where the memory matters. Needs SDWebImage 5.19.7 or later. Photo library images are always decoded this way. On Android images are already decoded at about the view's size.
+It doesn't change `onLoad`'s width and height (the image's own size) or the cached file. Needs SDWebImage 5.19.7 or later: before 5.19 images are decoded at full size, and 5.19.0 to 5.19.6 show photos stored sideways with an EXIF orientation (most phone photos) sideways. Photo library images are always decoded this way, and on Android images are always decoded at about the view's size.
+
+If you control the images, serve them at the size they're shown (resized on your server or by an image CDN), which also saves bandwidth.
 
 ---
 

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

@@ -131,6 +131,12 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
         view.setPaused(paused);
     }
 
+    // Set when the image has an onProgress (see onProgress).
+    @ReactProp(name = "trackProgress")
+    public void setTrackProgress(FastImageViewWithUrl view, boolean trackProgress) {
+        view.trackProgress = trackProgress;
+    }
+
     @ReactProp(name = "resizeMode")
     public void setResizeMode(FastImageViewWithUrl view, String resizeMode) {
         // repeat fills the view with the tiled image (see setImageDrawable).
@@ -163,11 +169,15 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
                 .build();
     }
 
+    // Sends the progress to the views loading the url that have an onProgress:
+    // the others would send an event to JS for every chunk, for nothing (and
+    // on the New Architecture each would log an unhandled event).
     @Override
     public void onProgress(String key, long bytesRead, long expectedLength) {
         List<FastImageViewWithUrl> viewsForKey = VIEWS_FOR_URLS.get(key);
         if (viewsForKey != null) {
             for (FastImageViewWithUrl view : viewsForKey) {
+                if (!view.trackProgress) continue;
                 WritableMap event = new WritableNativeMap();
                 event.putInt("loaded", (int) bytesRead);
                 event.putInt("total", (int) expectedLength);

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

@@ -183,6 +183,8 @@ class FastImageViewWithUrl extends AppCompatImageView {
 
     // Pauses GIFs on the frame they're showing (the view's own animation).
     private boolean mPaused = false;
+    // Whether to send progress events (the image has an onProgress).
+    boolean trackProgress = false;
 
     // The `transition` prop (from the next load): how long a loaded image
     // takes to fade in, in milliseconds (0 for no fade), whether it also fades

package/dist/index.cjs.js

@@ -183,6 +183,7 @@ function FastImageBase({ source, defaultSource, tintColor, onLoadStart, onProgre
 		defaultSource: resolvedDefaultSource,
 		onFastImageLoadStart: onLoadStart,
 		onFastImageProgress: withProgress(onProgress),
+		trackProgress: !!onProgress,
 		onFastImageLoad: onLoad,
 		onFastImageError: onError,
 		onFastImageLoadEnd: onLoadEnd && ((event) => onLoadEnd(loadResult(event.nativeEvent))),
@@ -272,7 +273,8 @@ const FastImageView = (0, react_native.requireNativeComponent)("FastImageView",
 	onFastImageProgress: true,
 	onFastImageLoad: true,
 	onFastImageError: true,
-	onFastImageLoadEnd: true
+	onFastImageLoadEnd: true,
+	trackProgress: true
 } });
 //#endregion
 exports.FastImageBackground = FastImageBackground;

package/dist/index.d.ts

@@ -161,9 +161,9 @@ export interface FastImageProps extends AccessibilityProps, ViewProps {
     transition?: boolean | number | Transition | null;
     /**
      * 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.
+     * takes much less memory. `true` (default). `false` decodes images at
+     * full size, e.g. for an image that's zoomed in on with a transform. See
+     * the README.
      */
     downsample?: boolean;
     /**

package/dist/index.js

@@ -156,6 +156,7 @@ function FastImageBase({ source, defaultSource, tintColor, onLoadStart, onProgre
 		defaultSource: resolvedDefaultSource,
 		onFastImageLoadStart: onLoadStart,
 		onFastImageProgress: withProgress(onProgress),
+		trackProgress: !!onProgress,
 		onFastImageLoad: onLoad,
 		onFastImageError: onError,
 		onFastImageLoadEnd: onLoadEnd && ((event) => onLoadEnd(loadResult(event.nativeEvent))),
@@ -245,7 +246,8 @@ const FastImageView = requireNativeComponent("FastImageView", FastImage, { nativ
 	onFastImageProgress: true,
 	onFastImageLoad: true,
 	onFastImageError: true,
-	onFastImageLoadEnd: true
+	onFastImageLoadEnd: true,
+	trackProgress: true
 } });
 //#endregion
 export { FastImageBackground, FastImage as default };

package/ios/FastImage/FFFastImageView.h

@@ -12,6 +12,8 @@
 
 @property (nonatomic, copy) RCTDirectEventBlock onFastImageLoadStart;
 @property (nonatomic, copy) RCTDirectEventBlock onFastImageProgress;
+// Whether to send progress events (the image has an onProgress).
+@property (nonatomic, assign) BOOL trackProgress;
 @property (nonatomic, copy) RCTDirectEventBlock onFastImageError;
 @property (nonatomic, copy) RCTDirectEventBlock onFastImageLoad;
 @property (nonatomic, copy) RCTDirectEventBlock onFastImageLoadEnd;

package/ios/FastImage/FFFastImageView.m

@@ -88,6 +88,9 @@ static UIImage* FFFBlurredImage(UIImage* image, CGFloat scale, CGFloat radius, B
     // rather than dimming like the system's controls.
     self.tintAdjustmentMode = UIViewTintAdjustmentModeNormal;
     _loopCount = -1;
+    // Images are decoded at about the size they're shown at unless
+    // downsample is false, as on Android.
+    _downsample = YES;
     return self;
 }
 
@@ -1033,7 +1036,7 @@ NSString *FFFErrorMessage(NSError *error)
     // there's a handler as the load starts. A handler added while loading is
     // used from the next load.
     SDImageLoaderProgressBlock progress = nil;
-    if (events && self.onFastImageProgress) {
+    if (events && self.trackProgress && 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.

package/ios/FastImage/FFFastImageViewManager.m

@@ -114,6 +114,7 @@ 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)

package/package.json

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