react-native-fast-image 9.3.5 → 9.3.7

package/README.md

@@ -311,7 +311,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'`: 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. 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).
+- `'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'`.
 - `'pixelated'`: sharp pixels, without smoothing, e.g. for pixel art drawn larger than its size. On Android, animated images are still smoothed.
 
 ---
@@ -342,14 +342,14 @@ Downloads, local files (`file://`, `content://`) and bundled images (`require()`
 
 #### `downsample`
 
-**Type:** `boolean` · **Default:** `true` · iOS only
+**Type:** `boolean` · **Default:** `true`
 
 Decodes a large image at about the size it's shown at, instead of at full size, so it takes much less memory.
 
-- `true`: 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.
+- `true`: an image at least twice the size its view needs is decoded at about the view's size (on Android, any image larger than its view). 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. **It uses more memory:** a 12-megapixel photo takes about 48 MB decoded, however small it's shown. On Android, an image over 16 megapixels (4096 × 4096) is decoded at the largest size under that, which Android can still draw.
 
-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 (but Android 16 and later decode animated WebP at full size, and scale it as they draw it).
+It doesn't change `onLoad`'s width and height (the image's own size) or the cached file. On iOS it 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 at about the view's size. Android 16 and later decode animated WebP at full size either way, and scale it as they draw it.
 
 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/FastImageGif.java

@@ -34,8 +34,10 @@ final class FastImageGif {
     private FastImageGif() {}
 
     // Null if the GIF can't be decoded again (then the view shows Glide's).
+    // Full size (downsample false): at the GIF's own size, or sampled down to
+    // at most FastImageSourceSize.MAX_PIXELS pixels.
     @Nullable
-    static GifDrawable copy(Context context, GifDrawable gif, int width, int height) {
+    static GifDrawable copy(Context context, GifDrawable gif, int width, int height, boolean fullSize) {
         if (width <= 0 || height <= 0) return null;
         ByteBuffer data = gif.getBuffer();
         GifHeader header = new GifHeaderParser().setData(data).parseHeader();
@@ -44,7 +46,7 @@ final class FastImageGif {
         BitmapPool bitmapPool = glide.getBitmapPool();
         GifDecoder decoder = new StandardGifDecoder(
                 new GifBitmapProvider(bitmapPool, glide.getArrayPool()),
-                header, gif.getBuffer(), sampleSize(header, width, height));
+                header, gif.getBuffer(), fullSize ? fullSizeSampleSize(header) : sampleSize(header, width, height));
         decoder.setDefaultBitmapConfig(Bitmap.Config.ARGB_8888);
         decoder.advance();
         Bitmap firstFrame = decoder.getNextFrame();
@@ -101,6 +103,15 @@ final class FastImageGif {
         }
     }
 
+    private static int fullSizeSampleSize(GifHeader header) {
+        int sampleSize = 1;
+        while ((float) (header.getWidth() / sampleSize) * (header.getHeight() / sampleSize)
+                > FastImageSourceSize.MAX_PIXELS) {
+            sampleSize *= 2;
+        }
+        return sampleSize;
+    }
+
     // 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/FastImageSourceSize.java

@@ -49,50 +49,72 @@ final class FastImageSourceSize {
     // options, so the size is recorded by image rather than by request.
     static final class Capture extends DownsampleStrategy {
         private final DownsampleStrategy strategy;
+        // What an SVG is drawn at (see FastImageSvgRenderer): the strategy for
+        // the view's scale type, also when images are decoded at full size
+        // (downsample false). An SVG has no size of its own to decode at, and
+        // drawn at the view's size it's already sharp.
+        private final DownsampleStrategy vectorStrategy;
         private final String key;
         private boolean recorded;
 
         Capture(DownsampleStrategy strategy, String key) {
+            this(strategy, strategy, key);
+        }
+
+        Capture(DownsampleStrategy strategy, DownsampleStrategy vectorStrategy, String key) {
             this.strategy = strategy;
+            this.vectorStrategy = vectorStrategy;
             this.key = key;
         }
 
-        @Override
-        public float getScaleFactor(int sourceWidth, int sourceHeight, int requestedWidth, int requestedHeight) {
+        private void record(int sourceWidth, int sourceHeight) {
             // Called again with the sampled size; the first call has the image's.
             if (!recorded) {
                 recorded = true;
                 SIZES.put(key, new int[]{sourceWidth, sourceHeight});
             }
+        }
+
+        @Override
+        public float getScaleFactor(int sourceWidth, int sourceHeight, int requestedWidth, int requestedHeight) {
+            record(sourceWidth, sourceHeight);
             return strategy.getScaleFactor(sourceWidth, sourceHeight, requestedWidth, requestedHeight);
         }
 
+        float getVectorScaleFactor(int sourceWidth, int sourceHeight, int requestedWidth, int requestedHeight) {
+            record(sourceWidth, sourceHeight);
+            return vectorStrategy.getScaleFactor(sourceWidth, sourceHeight, requestedWidth, requestedHeight);
+        }
+
         @Override
         public SampleSizeRounding getSampleSizeRounding(int sourceWidth, int sourceHeight, int requestedWidth, int requestedHeight) {
             return strategy.getSampleSizeRounding(sourceWidth, sourceHeight, requestedWidth, requestedHeight);
         }
 
         // Glide's memory cache keys include the strategy, so match the wrapped
-        // one to keep sharing cached images between views.
+        // ones to keep sharing cached images between views.
         @Override
         public boolean equals(Object o) {
-            return o instanceof Capture && ((Capture) o).strategy.equals(strategy);
+            return o instanceof Capture && ((Capture) o).strategy.equals(strategy)
+                    && ((Capture) o).vectorStrategy.equals(vectorStrategy);
         }
 
         @Override
         public int hashCode() {
-            return strategy.hashCode();
+            return 31 * strategy.hashCode() + vectorStrategy.hashCode();
         }
     }
 
     // What RequestBuilder.into(ImageView) applies for the view's scale type
     // (it leaves a transformation that's already set alone), with the
     // downsample strategy it implies wrapped by capture, and then blur if it
-    // isn't null.
-    static RequestOptions scaleTypeOptions(@Nullable ImageView.ScaleType scaleType, Capture capture, @Nullable FastImageBlur blur) {
+    // isn't null. Not downsampled (downsample false), the image isn't cropped
+    // or fitted to the view's size either: the view scales it as it draws it.
+    static RequestOptions scaleTypeOptions(@Nullable ImageView.ScaleType scaleType, Capture capture, @Nullable FastImageBlur blur,
+            boolean downsample) {
         RequestOptions options = new RequestOptions();
         BitmapTransformation transformation = null;
-        if (scaleType != null) {
+        if (scaleType != null && downsample) {
             switch (scaleType) {
                 case CENTER_CROP:
                     options = options.optionalCenterCrop();
@@ -121,8 +143,9 @@ final class FastImageSourceSize {
         return options.downsample(capture);
     }
 
-    static Capture capture(@Nullable ImageView.ScaleType scaleType, Object model) {
-        return new Capture(strategy(scaleType), String.valueOf(model));
+    static Capture capture(@Nullable ImageView.ScaleType scaleType, Object model, boolean downsample) {
+        DownsampleStrategy strategy = strategy(scaleType);
+        return new Capture(downsample ? strategy : FULL_SIZE, strategy, String.valueOf(model));
     }
 
     private static DownsampleStrategy strategy(@Nullable ImageView.ScaleType scaleType) {
@@ -145,11 +168,12 @@ final class FastImageSourceSize {
     }
 
     // At the image's own size (objectFit none shows it at that size, whatever
-    // the view's), or scaled down to at most MAX_PIXELS pixels, which a
-    // bitmap can be drawn at (Android won't draw one over 100 MB).
+    // the view's, and downsample false decodes every image this way), or
+    // scaled down to at most MAX_PIXELS pixels, which a bitmap can be drawn at
+    // (Android won't draw one over 100 MB).
     static final DownsampleStrategy FULL_SIZE = new FullSize();
 
-    private static final float MAX_PIXELS = 4096f * 4096f;
+    static final float MAX_PIXELS = 4096f * 4096f;
 
     private static final class FullSize extends DownsampleStrategy {
         @Override

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

@@ -63,13 +63,17 @@ final class FastImageSvgRenderer {
         int sourceHeight = Math.max(1, Math.round(ownHeight));
 
         // The strategy also records the SVG's own size for onLoad
-        // (FastImageSourceSize.Capture).
+        // (FastImageSourceSize.Capture), and has the one for the view when
+        // images are decoded at full size (downsample false).
         DownsampleStrategy strategy = options.get(DownsampleStrategy.OPTION);
         int targetWidth = width > 0 ? width : sourceWidth;
         int targetHeight = height > 0 ? height : sourceHeight;
-        float scale = strategy != null
-                ? strategy.getScaleFactor(sourceWidth, sourceHeight, targetWidth, targetHeight)
-                : 1f;
+        float scale = strategy instanceof FastImageSourceSize.Capture
+                ? ((FastImageSourceSize.Capture) strategy).getVectorScaleFactor(
+                        sourceWidth, sourceHeight, targetWidth, targetHeight)
+                : strategy != null
+                        ? strategy.getScaleFactor(sourceWidth, sourceHeight, targetWidth, targetHeight)
+                        : 1f;
         // objectFit scale-down and none: at its own size in dp (see
         // FastImageSvg.DENSITY), and for scale-down no larger than the view.
         Float density = options.get(FastImageSvg.DENSITY);

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

@@ -147,6 +147,11 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> {
         view.setImageRendering(imageRendering);
     }
 
+    @ReactProp(name = "downsample", defaultBoolean = true)
+    public void setDownsample(FastImageViewWithUrl view, boolean downsample) {
+        view.setDownsample(downsample);
+    }
+
     @ReactProp(name = "blurRadius")
     public void setBlurRadius(FastImageViewWithUrl view, float blurRadius) {
         view.setBlurRadius(PixelUtil.toPixelFromDIP(blurRadius));

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

@@ -659,7 +659,7 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
             }
             if (resource instanceof GifDrawable) {
                 GifDrawable own = FastImageGif.copy(
-                        getContext(), (GifDrawable) resource, mLoadingWidth, mLoadingHeight);
+                        getContext(), (GifDrawable) resource, mLoadingWidth, mLoadingHeight, !mDownsample);
                 if (own != null) {
                     applyLoopCount(own);
                     super.onResourceReady(own, transition);
@@ -780,13 +780,15 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
     private ScaleType mLayoutScaleType = ScaleType.FIT_CENTER;
 
     // Glide crops or fits the bitmap for the scale type when it loads, so a
-    // new resizeMode needs a reload to take effect (#762).
+    // new resizeMode needs a reload to take effect (#762): the image that's
+    // showing, loaded again quietly (see reblur), as for a new blurRadius,
+    // without the load events, as on iOS.
     public void setResizeMode(ScaleType scaleType, boolean repeat, boolean inPixels) {
         if (scaleType == mResizeScaleType && repeat == mRepeat && inPixels == mInPixels) return;
         mResizeScaleType = scaleType;
         mInPixels = inPixels;
         mRepeat = repeat;
-        mNeedsReload = true;
+        mFitChanged = true;
         // A loaded image on screen was cropped or fitted for the old scale
         // type: it keeps its layout until the image for the new one is ready
         // (onImageLoaded), or the load fails. Laid out for the new one, a
@@ -918,9 +920,9 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
 
     // imageRendering="pixelated": no resampling by Glide, and drawn without
     // filtering (sharp pixels). "smooth" is iOS only; here it's the same as
-    // "auto": Glide already decodes a large image at about the view's size, and
-    // averaging it properly would need a full-size decode. Part of the
-    // request, so a change reloads.
+    // "auto": Glide decodes a large image at about the view's size (unless
+    // downsample is false), and averaging it properly would need mipmaps or
+    // a full-size decode. Part of the request, so a change reloads.
     private boolean mPixelated = false;
 
     public void setImageRendering(@Nullable String imageRendering) {
@@ -930,10 +932,24 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
         mNeedsReload = true;
     }
 
+    // downsample false: images are decoded at their own size (capped, see
+    // FastImageSourceSize.FULL_SIZE), not cropped or fitted to the view's
+    // size, so a view zoomed in on with a transform shows the image's detail.
+    // Part of the request, so a change reloads.
+    private boolean mDownsample = true;
+
+    public void setDownsample(boolean downsample) {
+        if (downsample == mDownsample) return;
+        mDownsample = downsample;
+        mNeedsReload = true;
+    }
+
     // blurRadius, in pixels (0 is no blur). Part of the request (see
     // reblur for a change).
     private float mBlurRadius = 0;
     private boolean mBlurChanged = false;
+    // resizeMode or objectFit changed (setResizeMode).
+    private boolean mFitChanged = false;
 
     public void setBlurRadius(float blurRadius) {
         if (blurRadius == mBlurRadius) return;
@@ -968,8 +984,8 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
                     .dontTransform();
             if (blur != null) options = options.optionalTransform(blur);
         } else {
-            options = FastImageSourceSize.scaleTypeOptions(
-                    mResizeScaleType, FastImageSourceSize.capture(mResizeScaleType, model), blur);
+            options = FastImageSourceSize.scaleTypeOptions(mResizeScaleType,
+                    FastImageSourceSize.capture(mResizeScaleType, model, mDownsample), blur, mDownsample);
             boolean ownSize = mResizeScaleType == ScaleType.CENTER_INSIDE || mResizeScaleType == ScaleType.CENTER;
             // scale-down and none show it at its own size in dp: an SVG is
             // drawn at that size, so it's sharp (not with a blur, which hides
@@ -1111,10 +1127,11 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
         into(shown, builder, meanwhile, true);
     }
 
-    // blurRadius changed, and nothing else that needs a reload: the image
-    // that's showing, blurred again, with no events, as reloadForSize does: it's
-    // decoded again from the cache and blurred on Glide's threads, and the view
-    // keeps the current image until then. If that fails, it shows the image
+    // blurRadius or resizeMode changed, and nothing else that needs a reload:
+    // the image that's showing, blurred or fitted again, with no events, as
+    // reloadForSize does: it's decoded again from the cache and blurred or
+    // fitted on Glide's threads, and the view keeps the current image (and its
+    // layout, see onImageLoaded) until then. If that fails, it shows the image
     // from Glide's caches; cache: 'web' skips them, so the view shows
     // defaultSource (or nothing) then. Also while it's loading again that way
     // (e.g. the blur changes every frame): that load is replaced. A load that
@@ -1228,8 +1245,9 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
             @Nullable RequestManager requestManager) {
         if (mDropped) return;
         mManager = manager;
-        if (mBlurChanged && !mNeedsReload) {
+        if ((mBlurChanged || mFitChanged) && !mNeedsReload) {
             mBlurChanged = false;
+            mFitChanged = false;
             reblur();
         }
         if (!mNeedsReload)
@@ -1260,6 +1278,7 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
         // defaultSource, resizeMode), not for every prop update.
         mNeedsReload = false;
         mBlurChanged = false;
+        mFitChanged = false;
         boolean switching = mSwitchesSource;
         mSwitchesSource = false;
         boolean restarting = mRestarting;

package/dist/index.d.ts

@@ -376,8 +376,7 @@ export interface FastImageProps extends AccessibilityProps, ViewProps {
      *   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).
+     *   image. On Android it's the same as `'auto'`.
      * - `'pixelated'`: sharp pixels, without smoothing, e.g. for pixel art
      *   drawn larger than its size. On Android, animated images are still
      *   smoothed.
@@ -416,25 +415,29 @@ export interface FastImageProps extends AccessibilityProps, ViewProps {
      * full size, so it takes much less memory.
      *
      * - `true`: 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).
+     *   at about the view's size (on Android, any image larger than its
+     *   view). 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.
+     *   otherwise show the smaller copy enlarged. **It uses more memory:** a
+     *   12-megapixel photo takes about 48 MB decoded, however small it's
+     *   shown. On Android, an image over 16 megapixels (4096 × 4096) is
+     *   decoded at the largest size under that, which Android can still
+     *   draw.
      *
      * 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 (but Android 16 and later
-     * decode animated WebP at full size, and scale it as they draw it).
+     * the cached file. On iOS it 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 at about the view's size.
+     * Android 16 and later decode animated WebP at full size either way, and
+     * scale it as they draw it.
      *
      * 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.
      *
-     * @platform ios
      * @default true
      */
     downsample?: boolean;

package/package.json

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