react-native-fast-image 9.2.2 → 9.3.1

package/README.md

@@ -91,7 +91,7 @@ const YourImage = () => (
             headers: { Authorization: 'someAuthToken' },
             priority: 'normal',
         }}
-        resizeMode="contain"
+        objectFit="contain"
     />
 )
 ```
@@ -235,16 +235,36 @@ On Android, `defaultSource` doesn't show in debug builds: there the dev server s
 
 ---
 
+#### `objectFit`
+
+**Type:** `ObjectFit` · **Default:** `'cover'`
+
+How the image fits the view, as CSS's `object-fit` does.
+
+- `'cover'`: scales it uniformly (keeping its aspect ratio) so it covers the view (minus padding), cropping what doesn't fit.
+- `'contain'`: scales it uniformly (keeping its aspect ratio) so all of it fits in the view (minus padding).
+- `'fill'`: scales its width and height separately to fill the view, which can change its aspect ratio.
+- `'none'`: shows it at its own size, centered, cropped if it's larger than the view.
+- `'scale-down'`: shows it at its own size, centered, or scaled down uniformly to fit if it's larger than the view (the smaller of `'none'` and `'contain'`).
+
+An image's own size is its size in pixels, as points (dp on Android), as CSS counts an image's pixels: a 300 × 200 image is 300 × 200 points. A bundled image (`require()`) is its size in points.
+
+It can also be set in `style`; the prop wins. Either one overrides `resizeMode`.
+
+---
+
 #### `resizeMode`
 
 **Type:** `ResizeMode` · **Default:** `'cover'`
 
+**Deprecated:** Use `objectFit` instead.
+
 How the image fills the view.
 
-- `'contain'`: scales it uniformly (keeping its aspect ratio) so all of it fits in the view (minus padding).
-- `'cover'`: scales it uniformly (keeping its aspect ratio) so it covers the view (minus padding), cropping what doesn't fit.
-- `'stretch'`: scales its width and height separately to fill the view, which can change its aspect ratio.
-- `'center'`: centers it at its own size, scaled down uniformly to fit if it's larger than the view.
+- `'contain'`: as `objectFit="contain"`.
+- `'cover'`: as `objectFit="cover"`.
+- `'stretch'`: as `objectFit="fill"`.
+- `'center'`: as `objectFit="scale-down"`, except that on Android an image smaller than the view is shown at its size in pixels on the screen, so smaller than on iOS and the web.
 - `'repeat'`: repeats it to cover the view, from its top-left corner, at the image's own size in pixels (a bundled image at its size in points), scaled down to fit if it's larger than the view. An animated image repeats its first frame, and `defaultSource` repeats too.
 
 ---
@@ -686,6 +706,14 @@ A load's result, as `onLoadEnd` gets it: `ok` with the image's size, or not `ok`
 
 ---
 
+### `ObjectFit`
+
+**Type:** `'fill' | 'contain' | 'cover' | 'none' | 'scale-down'`
+
+How the image fits the view: see [`objectFit`](#objectfit).
+
+---
+
 ### `OnErrorEvent`
 
 `onError`'s event: `nativeEvent.error` says what went wrong, e.g. an HTTP status code or an image that can't be decoded.
@@ -826,9 +854,10 @@ FastImage works on the web with [react-native-web](https://necolas.github.io/rea
 
 Support is minimal:
 
-- Props that work: `source` (a `uri`, a `require()`d image, or several sizes), `defaultSource`, `resizeMode`, `tintColor`, `blurRadius`, `style`, children, `onLoadStart`, `onLoad`, `onError`, `onLoadEnd`, and View props such as `testID`, accessibility props, `onLayout` and `pointerEvents`.
+- Props that work: `source` (a `uri`, a `require()`d image, or several sizes), `defaultSource`, `objectFit`, `resizeMode`, `tintColor`, `blurRadius`, `style`, children, `onLoadStart`, `onLoad`, `onError`, `onLoadEnd`, and View props such as `testID`, accessibility props, `onLayout` and `pointerEvents`.
 - Ignored: `source.headers` (a browser can't send them for an image), `source.priority`, `source.cache`, `source.cacheKey`, `source.memoryCache`, `recyclingKey`, `loop`, `imageRendering`, `paused`, `transition`, `downsample`, `fallback` and `onProgress`.
-- Several sizes are shown with a lazily loaded `<img>` whose `srcset` lists them, with `sizes="auto, 100vw"`: the browser loads the one for the width the image is shown at, in device pixels (usually the smallest that's at least as wide). Browsers that don't support `sizes="auto"` use the viewport's width. `tintColor`, `defaultSource` and `resizeMode="repeat"` don't apply to them.
+- The image is an `<img>` element that fills the view inside its borders, with `objectFit` as its CSS `object-fit` (and `resizeMode`'s `stretch` as `fill`, `center` as `scale-down`). With `resizeMode="repeat"`, it's a repeated CSS background, with a transparent `<img>` over it. `tintColor` is an SVG filter and `blurRadius` a CSS `blur()`, and `defaultSource` is another `<img>`, under the image until it has loaded. A new `source` gets a new `<img>`, so the previous image doesn't stay while it loads (with several sizes, the browser shows it until the new one has loaded).
+- Several sizes are shown with a lazily loaded `<img>` whose `srcset` lists them, with `sizes="auto, 100vw"`: the browser loads the one for the width the image is shown at, in device pixels (usually the smallest that's at least as wide). Browsers that don't support `sizes="auto"` use the viewport's width. `resizeMode="repeat"` shows them as `cover`.
 - `FastImage.preload` loads the images into the browser's cache and resolves with a result per source. `clearMemoryCache`, `clearDiskCache` and `configureCache` resolve without doing anything (the browser manages its cache), and `getCachePath` and `writeToCache` resolve with `{ ok: false, error: 'Not supported on the web' }`.
 
 ## Troubleshooting

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

@@ -32,10 +32,17 @@ final class FastImageBlur extends BitmapTransformation {
     // In pixels on screen.
     private final float radius;
     private final ImageView.ScaleType scaleType;
+    // Pixels on screen per pixel of the image at its own size (scale-down and
+    // none show it at that size: see FastImageViewWithUrl.updateImageMatrix;
+    // 1 for resizeMode center).
+    private final float density;
 
-    FastImageBlur(float radius, ImageView.ScaleType scaleType) {
+    FastImageBlur(float radius, ImageView.ScaleType scaleType, float density) {
         this.radius = radius;
         this.scaleType = scaleType;
+        this.density = scaleType == ImageView.ScaleType.CENTER_INSIDE || scaleType == ImageView.ScaleType.CENTER
+                ? density
+                : 1;
     }
 
     @Override
@@ -80,7 +87,9 @@ final class FastImageBlur extends BitmapTransformation {
             case FIT_XY:
                 return (float) Math.sqrt(x * y);
             case CENTER_INSIDE:
-                return Math.min(Math.min(x, y), 1);
+                return Math.min(Math.min(x, y), density);
+            case CENTER:
+                return density;
             default:
                 return 1;
         }
@@ -197,17 +206,21 @@ final class FastImageBlur extends BitmapTransformation {
     public boolean equals(Object o) {
         return o instanceof FastImageBlur
                 && ((FastImageBlur) o).radius == radius
-                && ((FastImageBlur) o).scaleType == scaleType;
+                && ((FastImageBlur) o).scaleType == scaleType
+                && ((FastImageBlur) o).density == density;
     }
 
     @Override
     public int hashCode() {
-        return ID.hashCode() * 31 + Float.floatToIntBits(radius) * 31 + (scaleType == null ? 0 : scaleType.ordinal());
+        return (ID.hashCode() * 31 + Float.floatToIntBits(radius) * 31 + (scaleType == null ? 0 : scaleType.ordinal())) * 31
+                + Float.floatToIntBits(density);
     }
 
     @Override
     public void updateDiskCacheKey(@NonNull MessageDigest messageDigest) {
         messageDigest.update(ID_BYTES);
-        messageDigest.update((radius + "," + scaleType).getBytes(Charset.forName("UTF-8")));
+        String key = radius + "," + scaleType;
+        if (density != 1) key += "," + density;
+        messageDigest.update(key.getBytes(Charset.forName("UTF-8")));
     }
 }

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

@@ -82,6 +82,8 @@ public class FastImageRequestListener implements RequestListener<Drawable> {
         boolean local = !(model instanceof FastImageUrl);
         int[] size = FastImageSourceSize.get(resource, model, local,
                 dataSource == DataSource.RESOURCE_DISK_CACHE);
+        // Before the view shows it (the target does once this returns).
+        view.onImageSize(size);
         if (size != null) {
             sendLoad(view, size);
             return false;
@@ -92,7 +94,9 @@ public class FastImageRequestListener implements RequestListener<Drawable> {
         FastImageSourceSize.readLocal(view.getContext(), source, resource, model, new FastImageSourceSize.Callback() {
             @Override
             public void onSize(int[] size) {
-                if (target.getRequest() == request) sendLoad(view, size);
+                if (target.getRequest() != request) return;
+                view.onImageSize(size);
+                sendLoad(view, size);
             }
         });
         return false;

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

@@ -22,10 +22,13 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.PriorityQueue;
+import java.util.Set;
 import java.util.TreeMap;
+import java.util.TreeSet;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadFactory;
@@ -64,13 +67,18 @@ import okio.BufferedSource;
 // once every request has read what it needed.
 //
 // At most MAX_RUNNING downloads run at once, as SDWebImage's downloader limits
-// them; the others wait to send their request, most urgent first (Glide's
-// priority: views before preloads). A running download's response is read as
-// soon as it arrives (not on OkHttp's dispatcher, which React Native's
-// networking shares): a response left unread on an HTTP/2 connection would
-// hold back the others on it. A download that stalls fails like any other,
-// with the timeouts of the clients (FastImageOkHttpProgressGlideModule), which
-// only count once it has started.
+// them, and at most as many wait for their response from a host as the
+// client's dispatcher sends to a host at once (5 by default): OkHttp would
+// hold the others in the order they came, where a more urgent request can't
+// move them up. The others wait to send their request, most urgent first
+// (Glide's priority: views before preloads), and the most urgent one waiting
+// for a host's room keeps a running slot, so less urgent downloads to other
+// hosts can't take them all. A running download's response is read as soon
+// as it arrives, on its own thread (OkHttp counts a request to its host until
+// its callback returns): a response left unread on an HTTP/2 connection
+// would hold back the others on it. A download that stalls fails like any
+// other, with the timeouts of the clients (FastImageOkHttpProgressGlideModule),
+// which only count once it has started.
 final class FastImageSharedDownloads {
     // The longest response kept in memory, and the most bytes held in memory
     // for downloads at once: encoded images (not decoded bitmaps, which
@@ -98,9 +106,9 @@ final class FastImageSharedDownloads {
     // lock).
     private static final Map<String, Download> downloads = new HashMap<>();
     // Guarded by downloads: downloads waiting to start, most urgent first, then
-    // in the order they were asked for; how many are running; and the bytes
-    // held in memory.
-    private static final PriorityQueue<Download> queue = new PriorityQueue<>(11, new Comparator<Download>() {
+    // in the order they were asked for; how many are running, and how many
+    // wait for their response from each host; and the bytes held in memory.
+    private static final TreeSet<Download> queue = new TreeSet<>(new Comparator<Download>() {
         @Override
         public int compare(Download a, Download b) {
             int byPriority = a.priority.compareTo(b.priority);
@@ -109,6 +117,7 @@ final class FastImageSharedDownloads {
     });
     private static long orders = 0;
     private static int running = 0;
+    private static final Map<String, Integer> sentTo = new HashMap<>();
     private static long held = 0;
     // Stores not yet released (see busy()).
     private static final AtomicInteger open = new AtomicInteger();
@@ -165,9 +174,10 @@ final class FastImageSharedDownloads {
     static String busy() {
         synchronized (downloads) {
             int stores = open.get();
-            if (downloads.isEmpty() && queue.isEmpty() && running == 0 && held == 0 && stores == 0) return null;
+            if (downloads.isEmpty() && queue.isEmpty() && running == 0 && sentTo.isEmpty() && held == 0
+                    && stores == 0) return null;
             return downloads.size() + " downloads, " + queue.size() + " waiting, " + running + " running, "
-                    + held + " bytes in memory, " + stores + " stores open";
+                    + sentTo + " waiting for a response, " + held + " bytes in memory, " + stores + " stores open";
         }
     }
 
@@ -253,13 +263,25 @@ final class FastImageSharedDownloads {
         }
     }
 
-    // Starts the downloads waiting that can run now.
+    // Starts the downloads waiting that can run now, most urgent first: those
+    // whose host has room, leaving a slot for each host without (see above).
     private static void startQueued() {
         List<Download> starting = new ArrayList<>();
         List<Request> requests = new ArrayList<>();
         synchronized (downloads) {
-            while (running < MAX_RUNNING && !queue.isEmpty()) {
-                Download download = queue.poll();
+            Set<String> full = new HashSet<>();
+            Iterator<Download> waiting = queue.iterator();
+            while (running + full.size() < MAX_RUNNING && waiting.hasNext()) {
+                Download download = waiting.next();
+                String host = download.request.url().host();
+                Integer sent = sentTo.get(host);
+                if (sent != null && sent >= download.client.dispatcher().getMaxRequestsPerHost()) {
+                    full.add(host);
+                    continue;
+                }
+                waiting.remove();
+                sentTo.put(host, sent == null ? 1 : sent + 1);
+                download.host = host;
                 download.queued = false;
                 download.running = true;
                 running++;
@@ -539,6 +561,10 @@ final class FastImageSharedDownloads {
         private final long order;
         private boolean queued = false;
         private boolean running = false;
+        // Guarded by downloads. The host its request was sent to, until its
+        // response (or failure) arrives.
+        @Nullable
+        private String host;
         // Guarded by this. The call, once started, and whether the download
         // was cancelled (before it started, it doesn't).
         @Nullable
@@ -585,7 +611,9 @@ final class FastImageSharedDownloads {
                 return;
             }
             Download download;
-            boolean queuedOne = false;
+            // Queued one, or moved a waiting one to another url (whose host
+            // can have room).
+            boolean queueChanged = false;
             InputStream ready = null;
             synchronized (downloads) {
                 // Cancelled before it got here.
@@ -601,7 +629,7 @@ final class FastImageSharedDownloads {
                     downloads.put(fetcher.key, download);
                     download.queued = true;
                     queue.add(download);
-                    queuedOne = true;
+                    queueChanged = true;
                 } else if (download.queued) {
                     // A more urgent request moves it up (until it leaves).
                     if (fetcher.priority.compareTo(download.priority) < 0) download.reprioritize(fetcher.priority);
@@ -612,6 +640,7 @@ final class FastImageSharedDownloads {
                         download.url = fetcher.url;
                         download.client = fetcher.client;
                         download.request = request;
+                        queueChanged = true;
                     }
                 }
                 fetcher.download = download;
@@ -627,7 +656,7 @@ final class FastImageSharedDownloads {
                 }
             }
             if (ready != null) fetcher.deliver(ready, callback);
-            if (queuedOne) startQueued();
+            if (queueChanged) startQueued();
         }
 
         // Sends the request (off the main thread, and outside the locks:
@@ -656,10 +685,24 @@ final class FastImageSharedDownloads {
             if (started != null) started.cancel();
         }
 
+        // With downloads locked: its request has its response, failed, or
+        // wasn't sent, so another can be sent to its host.
+        private void responded() {
+            if (host == null) return;
+            int sent = sentTo.get(host) - 1;
+            if (sent == 0) {
+                sentTo.remove(host);
+            } else {
+                sentTo.put(host, sent);
+            }
+            host = null;
+        }
+
         // It no longer runs: the next download waiting can start.
         private void stopped() {
             synchronized (downloads) {
                 if (!running) return;
+                responded();
                 running = false;
                 FastImageSharedDownloads.running--;
             }
@@ -853,6 +896,7 @@ final class FastImageSharedDownloads {
             fromHttpCache = response.networkResponse() == null && response.cacheResponse() != null;
             final long length = body.contentLength();
             synchronized (downloads) {
+                responded();
                 // No progress without a length.
                 if (length <= 0) silent = true;
             }
@@ -862,6 +906,7 @@ final class FastImageSharedDownloads {
                     readInto(body, length);
                 }
             });
+            startQueued();
         }
 
         // Sends a progress step, unless the download has stopped: checked and

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

@@ -128,6 +128,8 @@ final class FastImageSourceSize {
     private static DownsampleStrategy strategy(@Nullable ImageView.ScaleType scaleType) {
         if (scaleType == null) return DownsampleStrategy.DEFAULT;
         switch (scaleType) {
+            case CENTER:
+                return FULL_SIZE;
             case CENTER_CROP:
                 return DownsampleStrategy.CENTER_OUTSIDE;
             case CENTER_INSIDE:
@@ -142,6 +144,26 @@ 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).
+    static final DownsampleStrategy FULL_SIZE = new FullSize();
+
+    private static final float MAX_PIXELS = 4096f * 4096f;
+
+    private static final class FullSize extends DownsampleStrategy {
+        @Override
+        public float getScaleFactor(int sourceWidth, int sourceHeight, int requestedWidth, int requestedHeight) {
+            float pixels = (float) sourceWidth * sourceHeight;
+            return pixels > MAX_PIXELS ? (float) Math.sqrt(MAX_PIXELS / pixels) : 1;
+        }
+
+        @Override
+        public SampleSizeRounding getSampleSizeRounding(int sourceWidth, int sourceHeight, int requestedWidth, int requestedHeight) {
+            return SampleSizeRounding.QUALITY;
+        }
+    }
+
     // The image's size, or null when it has to be read from a local image's
     // header first (see readLocal).
     @Nullable

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

@@ -6,6 +6,7 @@ import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
 import com.bumptech.glide.Registry;
+import com.bumptech.glide.load.Option;
 import com.bumptech.glide.load.Options;
 import com.bumptech.glide.load.ResourceDecoder;
 import com.bumptech.glide.load.engine.Resource;
@@ -17,6 +18,7 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
 import java.util.Locale;
 
 // SVG images (static), drawn with AndroidSVG, which FastImage includes
@@ -36,6 +38,31 @@ final class FastImageSvg {
     @Nullable
     private static Boolean available;
 
+    // objectFit scale-down and none show an image at its own size in dp
+    // (FastImageViewWithUrl.updateImageMatrix): an SVG is drawn at that size,
+    // the screen's pixels per dp (DENSITY) times its own, rather than at its
+    // size in pixels and then enlarged. With scale-down (FITS), no larger than
+    // the view. Part of the disk cache key, since the bitmap's size depends on
+    // them. Unset (0) for the other fits, which draw it for the view's size.
+    static final Option<Float> DENSITY = Option.disk(
+            "com.dylanvann.fastimage.FastImageSvg.Density", 0f,
+            new Option.CacheKeyUpdater<Float>() {
+                @Override
+                public void update(@NonNull byte[] keyBytes, @NonNull Float value, @NonNull MessageDigest messageDigest) {
+                    messageDigest.update(keyBytes);
+                    messageDigest.update(ByteBuffer.allocate(4).putFloat(value).array());
+                }
+            });
+    static final Option<Boolean> FITS = Option.disk(
+            "com.dylanvann.fastimage.FastImageSvg.Fits", false,
+            new Option.CacheKeyUpdater<Boolean>() {
+                @Override
+                public void update(@NonNull byte[] keyBytes, @NonNull Boolean value, @NonNull MessageDigest messageDigest) {
+                    messageDigest.update(keyBytes);
+                    messageDigest.update((byte) (value ? 1 : 0));
+                }
+            });
+
     private FastImageSvg() {
     }
 

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

@@ -70,6 +70,16 @@ final class FastImageSvgRenderer {
         float scale = 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);
+        if (density != null && density > 0) {
+            scale = density;
+            if (Boolean.TRUE.equals(options.get(FastImageSvg.FITS))) {
+                scale = Math.min(scale, Math.min(
+                        targetWidth / (float) sourceWidth, targetHeight / (float) sourceHeight));
+            }
+        }
         if (Float.isNaN(scale) || Float.isInfinite(scale) || scale <= 0) scale = 1f;
         float pixels = sourceWidth * scale * sourceHeight * scale;
         if (pixels > MAX_PIXELS) scale *= (float) Math.sqrt(MAX_PIXELS / pixels);

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

@@ -49,6 +49,11 @@ class FastImageViewConverter {
                 put("cover", ScaleType.CENTER_CROP);
                 put("stretch", ScaleType.FIT_XY);
                 put("center", ScaleType.CENTER_INSIDE);
+                // objectFit="scale-down": as center, laid out in dp (see
+                // FastImageViewWithUrl.setResizeMode).
+                put("scale-down", ScaleType.CENTER_INSIDE);
+                // objectFit="none": the image at its own size, centered.
+                put("none", ScaleType.CENTER);
             }};
 
     // Whether the source has a uri to load (not null, missing or blank).

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

@@ -184,7 +184,7 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> {
         boolean repeat = "repeat".equals(resizeMode);
         final FastImageViewWithUrl.ScaleType scaleType =
                 repeat ? FastImageViewWithUrl.ScaleType.FIT_XY : FastImageViewConverter.getScaleType(resizeMode);
-        view.setResizeMode(scaleType, repeat);
+        view.setResizeMode(scaleType, repeat, "center".equals(resizeMode));
     }
 
     @Override