react-native-fast-image 9.0.3 → 9.2.0

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

@@ -1,278 +1,364 @@
 package com.dylanvann.fastimage;
 
+import android.os.Process;
+
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
 import com.bumptech.glide.Priority;
 import com.bumptech.glide.load.DataSource;
-import com.bumptech.glide.load.Option;
-import com.bumptech.glide.load.Options;
+import com.bumptech.glide.load.HttpException;
 import com.bumptech.glide.load.data.DataFetcher;
 import com.bumptech.glide.load.model.GlideUrl;
 import com.bumptech.glide.load.model.ModelLoader;
 
+import java.io.EOFException;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.RandomAccessFile;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.TreeMap;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-// Lets a view load an image that a preload is downloading from the preload's
-// file, instead of downloading it again. Glide only shares a download between
-// requests for the same size (and a preload loads the original size), so a
-// view mounted while its image was being preloaded downloaded it a second
-// time. A preload's download registers here once it has started (not while
-// it's queued); a view's download of the same url then waits for the
-// preload's file and reads it, and downloads as usual if the preload fails.
-// The wait holds no thread: the view's fetch returns, and goes on when the
-// preload has finished, as an OkHttp download does. A finished download stays
-// for a while: a view's request that looked in the disk cache before the
-// preload stored the file, and gets to downloading after, reads it too.
-final class FastImageSharedDownloads {
-    // Set on a preload's request (see FastImageViewModule.loadFile).
-    static final Option<Boolean> PRELOAD = Option.memory("com.dylanvann.fastimage.Preload", false);
+import java.util.concurrent.atomic.AtomicInteger;
+
+import okhttp3.Call;
+import okhttp3.Callback;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import okhttp3.ResponseBody;
+import okio.BufferedSource;
 
-    // The longest a view waits for a preload's download, before downloading
-    // the image itself.
-    private static final long WAIT_MS = 30_000;
-    // How long a finished download's file is used.
+// One download of an image at a time, shared by every request for it, as
+// SDWebImage's downloader shares one per url (and Fresco one per encoded
+// image). Glide only shares a load between requests for the same size and
+// options, so views showing an image at different sizes, or one mounted while
+// a preload downloads it, downloaded it again. Downloads are keyed by key(),
+// which progress is sent by too (FastImageViewManager.onDownloadProgress).
+//
+// A download reads its response on a thread of its own, and keeps the bytes:
+// in memory if the response is small (a known length up to MEMORY_MAX, while
+// MEMORY_BUDGET has room), otherwise in a temporary file (Glide streams a
+// download to its disk cache, and decodes at the view's size, so a large image
+// never needs its bytes in the heap; the file keeps it that way; if the file
+// can't be made or written, e.g. on a full disk, they're kept in memory up to
+// FALLBACK_MAX). The requests
+// for it wait without holding a thread, and once it has ended, each gets a
+// stream over all of the bytes, as SDWebImage and Fresco decode a download
+// once it has arrived. Glide's threads (4) never wait for the network, so a
+// request that comes while many images download still gets to the queue below
+// at once, and other images aren't held up behind slow downloads. The download
+// is cancelled once every request for it has gone, and its bytes are dropped
+// 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.
+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
+    // Glide's memory cache holds), each only until every request has read it.
+    // Others are kept in a temporary file.
+    private static final long MEMORY_MAX = 1024 * 1024;
+    private static final long MEMORY_BUDGET = Runtime.getRuntime().maxMemory() / 16;
+    // The longest response kept in memory, still within MEMORY_BUDGET, when
+    // its temporary file can't be made or written (e.g. the device's storage
+    // is full): Glide's own fetcher decoded a download from its network
+    // stream, which it buffers up to 5 MB, when it couldn't write its disk
+    // cache.
+    private static final int FALLBACK_MAX = 5 * 1024 * 1024;
+    // The most downloads running at once (see above).
+    private static final int MAX_RUNNING = 16;
+    // How long a preload's finished file is used (see finished()).
     private static final long KEEP_MS = 60_000;
+    // Progress is sent when a download has read another 0.5% (and at its
+    // start and end).
+    private static final long PROGRESS_STEPS = 200;
 
-    // Goes on with waiting views (opening the file, or starting their own
-    // download), off the main thread, where preloads finish.
-    private static final ScheduledExecutorService executor =
-            Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
+    // The download new requests for a key join: in progress, or ended and
+    // still being read. Guards the downloads' sharing, queue and progress
+    // (taken before a download's own lock, and FastImageViewManager's progress
+    // 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>() {
+        @Override
+        public int compare(Download a, Download b) {
+            int byPriority = a.priority.compareTo(b.priority);
+            return byPriority != 0 ? byPriority : Long.compare(a.order, b.order);
+        }
+    });
+    private static long orders = 0;
+    private static int running = 0;
+    private static long held = 0;
+    // Stores not yet released (see busy()).
+    private static final AtomicInteger open = new AtomicInteger();
+
+    // Where temporary files go (FastImageOkHttpProgressGlideModule sets it).
+    @Nullable
+    private static volatile File directory;
+
+    // Reads the running downloads' responses, one thread each, at the priority
+    // of Glide's own threads (below the UI's), where downloads were read before.
+    private static final ThreadPoolExecutor reading = new ThreadPoolExecutor(
+            MAX_RUNNING, MAX_RUNNING, 30, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(),
+            new ThreadFactory() {
                 @Override
-                public Thread newThread(@NonNull Runnable runnable) {
-                    Thread thread = new Thread(runnable, "FastImageSharedDownloads");
+                public Thread newThread(@NonNull final Runnable runnable) {
+                    Thread thread = new Thread(new Runnable() {
+                        @Override
+                        public void run() {
+                            Process.setThreadPriority(
+                                    Process.THREAD_PRIORITY_BACKGROUND + Process.THREAD_PRIORITY_MORE_FAVORABLE);
+                            runnable.run();
+                        }
+                    }, "FastImageDownload");
                     thread.setDaemon(true);
                     return thread;
                 }
             });
 
-    // A view's fetch waiting for a download. It goes on once: with the file,
-    // or without it (the preload failed, or took too long).
-    private static final class Waiter {
-        private final Fetcher fetcher;
-        private final Priority priority;
-        private final DataFetcher.DataCallback<? super InputStream> callback;
-        private final AtomicBoolean went = new AtomicBoolean();
-
-        Waiter(Fetcher fetcher, Priority priority, DataFetcher.DataCallback<? super InputStream> callback) {
-            this.fetcher = fetcher;
-            this.priority = priority;
-            this.callback = callback;
-        }
+    static {
+        reading.allowCoreThreadTimeOut(true);
+    }
 
-        void go(@Nullable File file) {
-            if (went.compareAndSet(false, true)) fetcher.resume(file, priority, callback);
-        }
+    private static final class Finished {
+        final File file;
+        final long at;
 
-        // Cancelled: never goes on.
-        void drop() {
-            went.set(true);
+        Finished(File file, long at) {
+            this.file = file;
+            this.at = at;
         }
     }
 
-    private static final class Download {
-        // Guarded by this.
-        private boolean done;
-        private final List<Waiter> waiters = new ArrayList<>();
-        @Nullable
-        volatile File file;
-        volatile long finishedAt;
+    // Preloads' files in Glide's disk cache, by key, for a while after they
+    // finished.
+    private static final ConcurrentHashMap<String, Finished> finished = new ConcurrentHashMap<>();
 
-        synchronized boolean isDone() {
-            return done;
-        }
+    private FastImageSharedDownloads() {
+    }
 
-        boolean isStale(long now) {
-            return isDone() && now - finishedAt > KEEP_MS;
+    // For tests: what downloads still hold, or null once none is left (none
+    // waiting or running), their memory has been given back, and every store
+    // released.
+    @Nullable
+    static String busy() {
+        synchronized (downloads) {
+            int stores = open.get();
+            if (downloads.isEmpty() && queue.isEmpty() && running == 0 && held == 0 && stores == 0) return null;
+            return downloads.size() + " downloads, " + queue.size() + " waiting, " + running + " running, "
+                    + held + " bytes in memory, " + stores + " stores open";
         }
+    }
 
-        void await(final Waiter waiter) {
-            synchronized (this) {
-                if (!done) {
-                    waiters.add(waiter);
-                    executor.schedule(new Runnable() {
-                        @Override
-                        public void run() {
-                            remove(waiter);
-                            waiter.go(null);
-                        }
-                    }, WAIT_MS, TimeUnit.MILLISECONDS);
-                    return;
-                }
+    // Also removes files left in it (one is unlinked once open, but the app
+    // can end in between).
+    static void setDirectory(final File cacheDirectory) {
+        directory = cacheDirectory;
+        reading.execute(new Runnable() {
+            @Override
+            public void run() {
+                File[] left = cacheDirectory.listFiles();
+                if (left == null) return;
+                //noinspection ResultOfMethodCallIgnored
+                for (File file : left) file.delete();
             }
-            goOn(waiter, file);
-        }
+        });
+    }
+
+    // The key downloads are shared, and their progress sent, by. A url with
+    // the source's cacheKey: the key (Glide caches it, and shares its loads,
+    // by the key too). Another url: the url and its headers (Glide's loads
+    // compare both). `web` images apart: they load with their own client, and
+    // its HTTP cache.
+    static String key(GlideUrl url) {
+        if (url instanceof FastImageKeyedGlideUrl) return "key " + url.getCacheKey();
+        String key = url.getCacheKey() + " " + new TreeMap<>(url.getHeaders());
+        return (url instanceof FastImageWebGlideUrl ? "web " : "url ") + key;
+    }
 
-        synchronized void remove(Waiter waiter) {
-            waiters.remove(waiter);
+    // A preload's download ended (FastImageViewModule.loadFile), with its file
+    // in Glide's disk cache, or null if it failed. A request that looked in
+    // the disk cache before the preload stored the file, and gets to
+    // downloading after, reads the file.
+    static void finished(String key, @Nullable File file) {
+        long now = System.currentTimeMillis();
+        for (Map.Entry<String, Finished> entry : finished.entrySet()) {
+            if (now - entry.getValue().at > KEEP_MS) finished.remove(entry.getKey(), entry.getValue());
         }
+        if (file != null) finished.put(key, new Finished(file, now));
+    }
 
-        // Returns false if it had finished already.
-        boolean finish(@Nullable File file, long now) {
-            List<Waiter> waiting;
-            synchronized (this) {
-                if (done) return false;
-                done = true;
-                this.file = file;
-                finishedAt = now;
-                waiting = new ArrayList<>(waiters);
-                waiters.clear();
-            }
-            for (Waiter waiter : waiting) goOn(waiter, file);
-            return true;
+    @Nullable
+    private static File finishedFile(String key) {
+        Finished file = finished.get(key);
+        if (file == null) return null;
+        if (System.currentTimeMillis() - file.at > KEEP_MS) {
+            finished.remove(key, file);
+            return null;
         }
+        return file.file;
+    }
 
-        private static void goOn(final Waiter waiter, @Nullable final File file) {
-            executor.execute(new Runnable() {
-                @Override
-                public void run() {
-                    waiter.go(file);
-                }
-            });
+    // A remote image's load data (FastImageOkHttpProgressGlideModule): its
+    // download with the client, shared with the other requests for its key.
+    static ModelLoader.LoadData<InputStream> loadData(GlideUrl url, OkHttpClient client) {
+        return new ModelLoader.LoadData<>(url, new Fetcher(url, client));
+    }
+
+    // As Glide's OkHttp fetcher requests it. A url or header OkHttp can't
+    // send is an IOException, so its load fails (OkHttp throws an
+    // IllegalArgumentException, which would crash the thread it's on).
+    static Request request(GlideUrl url) throws IOException {
+        try {
+            Request.Builder builder = new Request.Builder().url(url.toStringUrl());
+            for (Map.Entry<String, String> header : url.getHeaders().entrySet()) {
+                builder.addHeader(header.getKey(), header.getValue());
+            }
+            return builder.build();
+        } catch (IllegalArgumentException e) {
+            throw new IOException("Invalid request: " + e.getMessage(), e);
         }
     }
 
-    // Preloads' downloads in progress, or finished with their file, by the
-    // url's cache key.
-    private static final ConcurrentHashMap<String, Download> downloads = new ConcurrentHashMap<>();
+    private static boolean sameRequest(GlideUrl a, GlideUrl b) {
+        return a.toStringUrl().equals(b.toStringUrl()) && a.getHeaders().equals(b.getHeaders());
+    }
 
-    private FastImageSharedDownloads() {
+    private static void closeQuietly(InputStream stream) {
+        try {
+            stream.close();
+        } catch (IOException e) {
+            // Closed as far as it could.
+        }
     }
 
-    // A preload's download of the image with this cache key has ended: with
-    // its file in Glide's disk cache, or null if it failed or was cancelled.
-    // Views waiting for it go on.
-    static void finished(String key, @Nullable File file) {
-        long now = System.currentTimeMillis();
-        for (Map.Entry<String, Download> entry : downloads.entrySet()) {
-            if (entry.getValue().isStale(now)) downloads.remove(entry.getKey(), entry.getValue());
+    // Starts the downloads waiting that can run now.
+    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();
+                download.queued = false;
+                download.running = true;
+                running++;
+                starting.add(download);
+                requests.add(download.request);
+                download.tried.add(download.url);
+            }
         }
-        Download download = downloads.get(key);
-        if (download == null) return;
-        if (download.finish(file, now) && file == null) downloads.remove(key, download);
+        for (int i = 0; i < starting.size(); i++) starting.get(i).start(requests.get(i));
     }
 
-    // The url loader's load data, with a fetcher that shares preloads'
-    // downloads.
-    static ModelLoader.LoadData<InputStream> share(
-            ModelLoader.LoadData<InputStream> data, GlideUrl model, Options options) {
-        boolean preload = Boolean.TRUE.equals(options.get(PRELOAD));
-        return new ModelLoader.LoadData<>(
-                data.sourceKey,
-                data.alternateKeys,
-                new Fetcher(data.fetcher, model.getCacheKey(), preload));
+    // A download's progress steps (see PROGRESS_STEPS).
+    private static final class Progress {
+        private long lastStep = -1;
+
+        // Whether `loaded` is another step. Without a Content-Length the total
+        // is unknown (-1), and a fraction can't be worked out from it.
+        boolean step(long loaded, long total) {
+            if (total <= 0) return false;
+            long step = Math.min(loaded, total) * PROGRESS_STEPS / total;
+            if (step == lastStep) return false;
+            lastStep = step;
+            return true;
+        }
     }
 
+    // A request's fetch: joins its key's download.
     private static final class Fetcher implements DataFetcher<InputStream> {
-        private final DataFetcher<InputStream> fetcher;
-        private final String key;
-        private final boolean preload;
-        private volatile boolean cancelled;
-        // While it waits for a preload's download.
-        @Nullable
-        private volatile Download download;
+        final GlideUrl url;
+        final OkHttpClient client;
+        // Set when it loads (Glide also makes fetchers it doesn't use, e.g.
+        // for an image in its disk cache).
+        String key;
+        Priority priority;
+        volatile boolean cancelled;
+        // The download it waits for, or reads (guarded by downloads).
         @Nullable
-        private volatile Waiter waiter;
-        // The preload's file, when the image came from it.
+        Download download;
+        // What it gave Glide.
         @Nullable
         private volatile InputStream stream;
+        private volatile boolean fromFile;
 
-        Fetcher(DataFetcher<InputStream> fetcher, String key, boolean preload) {
-            this.fetcher = fetcher;
-            this.key = key;
-            this.preload = preload;
+        Fetcher(GlideUrl url, OkHttpClient client) {
+            this.url = url;
+            this.client = client;
         }
 
         @Override
-        public void loadData(@NonNull Priority priority, @NonNull final DataCallback<? super InputStream> callback) {
-            if (preload) {
-                // A second preload of the url (with other options) keeps the
-                // first's entry while it's downloading; one after it finished
-                // downloads again (the file left the disk cache).
-                Download current = downloads.get(key);
-                if (current == null || current.isDone()) downloads.put(key, new Download());
-                fetcher.loadData(priority, new DataCallback<InputStream>() {
-                    @Override
-                    public void onDataReady(@Nullable InputStream data) {
-                        callback.onDataReady(data);
-                    }
-
-                    @Override
-                    public void onLoadFailed(@NonNull Exception e) {
-                        finished(key, null);
-                        callback.onLoadFailed(e);
-                    }
-                });
-                return;
-            }
-            Download current = downloads.get(key);
-            if (current == null || current.isStale(System.currentTimeMillis())) {
-                fetcher.loadData(priority, callback);
-                return;
-            }
-            Waiter waiting = new Waiter(this, priority, callback);
-            download = current;
-            waiter = waiting;
-            current.await(waiting);
-        }
-
-        // Goes on after waiting: reads the preload's file, or downloads the
-        // image if there's none.
-        void resume(@Nullable File file, Priority priority, DataCallback<? super InputStream> callback) {
-            download = null;
-            waiter = null;
-            if (cancelled) return;
+        public void loadData(@NonNull Priority priority, @NonNull DataCallback<? super InputStream> callback) {
+            this.key = key(url);
+            this.priority = priority;
+            // `web` images follow their HTTP cache, not a preload's file.
+            File file = url instanceof FastImageWebGlideUrl ? null : finishedFile(key);
             if (file != null) {
                 try {
-                    stream = new FileInputStream(file);
-                    callback.onDataReady(stream);
+                    InputStream opened = new FileInputStream(file);
+                    fromFile = true;
+                    stream = opened;
+                    callback.onDataReady(opened);
                     return;
                 } catch (IOException e) {
                     // Gone from the disk cache meanwhile: download it.
                 }
             }
-            fetcher.loadData(priority, callback);
+            Download.join(this, callback);
         }
 
+        // From the download, outside its locks, off the main thread.
+        void deliver(InputStream data, DataCallback<? super InputStream> callback) {
+            stream = data;
+            // Cancelled meanwhile: Glide won't read or close it.
+            if (cancelled) {
+                closeQuietly(data);
+                return;
+            }
+            callback.onDataReady(data);
+        }
+
+        // On one of Glide's threads.
         @Override
         public void cleanup() {
             InputStream opened = stream;
-            if (opened != null) {
-                try {
-                    opened.close();
-                } catch (IOException e) {
-                    // Closed as far as it could.
-                }
-                stream = null;
-            }
-            fetcher.cleanup();
+            if (opened != null) closeQuietly(opened);
         }
 
+        // On the main thread. The request leaves its download, which is
+        // cancelled once no request is left, and its stream on the bytes (if
+        // it has one) is closed.
         @Override
         public void cancel() {
             cancelled = true;
-            Download waitingFor = download;
-            Waiter waiting = waiter;
-            if (waitingFor != null && waiting != null) {
-                waitingFor.remove(waiting);
-                waiting.drop();
+            Download joined;
+            synchronized (downloads) {
+                joined = download;
             }
-            // The preload's download stops: views waiting for it download
-            // the image themselves.
-            if (preload) finished(key, null);
-            fetcher.cancel();
+            if (joined != null) joined.leave(this);
+            InputStream opened = stream;
+            if (opened instanceof SharedStream) closeQuietly(opened);
         }
 
         @NonNull
@@ -281,12 +367,678 @@ final class FastImageSharedDownloads {
             return InputStream.class;
         }
 
-        // From the preload's file: as from Glide's disk cache, which it is in,
-        // so Glide doesn't store it there again.
+        // A preload's file is from Glide's disk cache. A download is remote
+        // for every request reading it: Glide stores it in its disk cache once
+        // (a request that finds it there already reads it from there), and
+        // fades the image in as for any download.
         @NonNull
         @Override
         public DataSource getDataSource() {
-            return stream != null ? DataSource.DATA_DISK_CACHE : fetcher.getDataSource();
+            return fromFile ? DataSource.DATA_DISK_CACHE : DataSource.REMOTE;
+        }
+    }
+
+    // A request waiting for a download to end.
+    private static final class Waiter {
+        final Fetcher fetcher;
+        final DataFetcher.DataCallback<? super InputStream> callback;
+        // Its url's request (with its headers).
+        final Request request;
+
+        Waiter(Fetcher fetcher, DataFetcher.DataCallback<? super InputStream> callback, Request request) {
+            this.fetcher = fetcher;
+            this.callback = callback;
+            this.request = request;
+        }
+    }
+
+    // Where a download keeps its response's bytes: written in order on its
+    // reading thread, then read by the requests, on theirs.
+    private interface Store {
+        void write(long at, byte[] buffer, int count) throws IOException;
+
+        // Reads up to `count` of the bytes, from `at`.
+        int read(long at, byte[] buffer, int offset, int count) throws IOException;
+
+        void release();
+    }
+
+    private static final class MemoryStore implements Store {
+        private final byte[] bytes;
+
+        MemoryStore(int length) {
+            bytes = new byte[length];
+        }
+
+        @Override
+        public void write(long at, byte[] buffer, int count) {
+            System.arraycopy(buffer, 0, bytes, (int) at, count);
+        }
+
+        @Override
+        public int read(long at, byte[] buffer, int offset, int count) {
+            System.arraycopy(bytes, (int) at, buffer, offset, count);
+            return count;
+        }
+
+        @Override
+        public void release() {
+        }
+    }
+
+    // A temporary file, removed from its folder once open: its space is freed
+    // once it's closed, or the app ends, so nothing is left behind. Read and
+    // written with a RandomAccessFile, which (unlike a FileChannel) isn't
+    // closed for every thread when one reading it is interrupted.
+    private static final class FileStore implements Store {
+        private final RandomAccessFile file;
+
+        FileStore() throws IOException {
+            File folder = directory;
+            if (folder == null) throw new IOException("No folder for downloads");
+            if (!folder.isDirectory() && !folder.mkdirs() && !folder.isDirectory()) {
+                throw new IOException("Can't make " + folder);
+            }
+            File created = File.createTempFile("download", null, folder);
+            try {
+                file = new RandomAccessFile(created, "rw");
+            } finally {
+                //noinspection ResultOfMethodCallIgnored
+                created.delete();
+            }
+        }
+
+        @Override
+        public synchronized void write(long at, byte[] buffer, int count) throws IOException {
+            file.seek(at);
+            file.write(buffer, 0, count);
+        }
+
+        @Override
+        public synchronized int read(long at, byte[] buffer, int offset, int count) throws IOException {
+            file.seek(at);
+            int read = file.read(buffer, offset, count);
+            if (read == -1) throw new EOFException("The download's file ended early");
+            return read;
+        }
+
+        // Not waiting for a read in progress (it fails): only the request
+        // whose stream was closed (it was cancelled) can still be reading.
+        @Override
+        public void release() {
+            try {
+                file.close();
+            } catch (IOException e) {
+                // Closed as far as it could.
+            }
+        }
+    }
+
+    // The bytes in memory, for a response whose temporary file can't be used
+    // (see FALLBACK_MAX), growing as they arrive, with the memory reserved
+    // first.
+    private static final class GrowingStore implements Store {
+        private final Download download;
+        // Why the file couldn't be used.
+        private final IOException cause;
+        private byte[] bytes;
+
+        GrowingStore(Download download, byte[] bytes, IOException cause) {
+            this.download = download;
+            this.bytes = bytes;
+            this.cause = cause;
+        }
+
+        @Override
+        public void write(long at, byte[] buffer, int count) throws IOException {
+            long end = at + count;
+            if (end > bytes.length) {
+                if (end > FALLBACK_MAX) {
+                    throw new IOException("The download is too large to keep in memory, and its temporary file couldn't be written", cause);
+                }
+                int length = (int) Math.min(FALLBACK_MAX, Math.max(end, 2L * bytes.length));
+                download.reserve(length - bytes.length, cause);
+                bytes = Arrays.copyOf(bytes, length);
+            }
+            System.arraycopy(buffer, 0, bytes, (int) at, count);
+        }
+
+        @Override
+        public int read(long at, byte[] buffer, int offset, int count) {
+            System.arraycopy(bytes, (int) at, buffer, offset, count);
+            return count;
+        }
+
+        @Override
+        public void release() {
+        }
+    }
+
+    private static final class Download implements Callback {
+        private final String key;
+        // Guarded by downloads. The request it downloads (its url and
+        // headers): until it starts, the latest url a request for its key
+        // asked for (see join()).
+        private GlideUrl url;
+        private OkHttpClient client;
+        private Request request;
+        // Guarded by downloads. The urls requested for its key so far: its own
+        // once it starts, and those of the downloads it's a retry of (see
+        // fail()).
+        private final List<GlideUrl> tried = new ArrayList<>();
+        // Guarded by downloads. In the queue (most urgent first, then in
+        // order), or running.
+        private Priority priority;
+        private final long order;
+        private boolean queued = false;
+        private boolean running = false;
+        // Guarded by this. The call, once started, and whether the download
+        // was cancelled (before it started, it doesn't).
+        @Nullable
+        private Call call;
+        private boolean cancelled = false;
+        // Guarded by this. Requests waiting for it to end, and once it has,
+        // the streams open on its bytes.
+        private final List<Waiter> waiting = new ArrayList<>();
+        private int readers = 0;
+        // Guarded by this. Where the bytes are (null before the response is
+        // read, and once dropped), and how many there are.
+        @Nullable
+        private Store store;
+        private long size = 0;
+        // All of the response has been read, or the download failed.
+        private boolean ended = false;
+        // Guarded by downloads. The memory the bytes hold, and whether it sends
+        // no more progress: it ended, or was cancelled (it can still read
+        // bytes it had received).
+        private long reserved = 0;
+        private boolean silent = false;
+
+        // With downloads locked.
+        private Download(String key, GlideUrl url, OkHttpClient client, Request request, Priority priority) {
+            this.key = key;
+            this.url = url;
+            this.client = client;
+            this.request = request;
+            this.priority = priority;
+            this.order = orders++;
+        }
+
+        // Joins the fetcher's key's download, or queues one of its url.
+        static void join(Fetcher fetcher, DataFetcher.DataCallback<? super InputStream> callback) {
+            // Its own request, which it sends if it starts the download.
+            Request request;
+            try {
+                request = request(fetcher.url);
+            } catch (IOException e) {
+                callback.onLoadFailed(e);
+                return;
+            }
+            Download download;
+            boolean queuedOne = false;
+            InputStream ready = null;
+            synchronized (downloads) {
+                // Cancelled before it got here.
+                if (fetcher.cancelled) return;
+                download = downloads.get(fetcher.key);
+                // A `web` image follows its HTTP cache: it only joins a
+                // download in progress, not the bytes of one that has ended.
+                if (download != null && fetcher.url instanceof FastImageWebGlideUrl && download.hasEnded()) {
+                    download = null;
+                }
+                if (download == null) {
+                    download = new Download(fetcher.key, fetcher.url, fetcher.client, request, fetcher.priority);
+                    downloads.put(fetcher.key, download);
+                    download.queued = true;
+                    queue.add(download);
+                    queuedOne = 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);
+                    // Not started yet: another url for its key (a cacheKey's)
+                    // is the latest one, e.g. a signed url with a fresh token,
+                    // so it's the one requested (they're the same image).
+                    if (!sameRequest(download.url, fetcher.url)) {
+                        download.url = fetcher.url;
+                        download.client = fetcher.client;
+                        download.request = request;
+                    }
+                }
+                fetcher.download = download;
+                synchronized (download) {
+                    // An ended download in the map has its bytes (a failed one
+                    // leaves the map).
+                    if (download.ended) {
+                        download.readers++;
+                        ready = download.stream();
+                    } else {
+                        download.waiting.add(new Waiter(fetcher, callback, request));
+                    }
+                }
+            }
+            if (ready != null) fetcher.deliver(ready, callback);
+            if (queuedOne) startQueued();
+        }
+
+        // Sends the request (off the main thread, and outside the locks:
+        // creating the call runs the app's OkHttp EventListener).
+        private void start(Request request) {
+            Call created = client.newCall(request);
+            boolean go;
+            synchronized (this) {
+                go = !cancelled;
+                if (go) call = created;
+            }
+            if (go) {
+                created.enqueue(this);
+            } else {
+                stopped();
+            }
+        }
+
+        // Cancels the call, or keeps it from starting. Outside the locks.
+        private void cancel() {
+            Call started;
+            synchronized (this) {
+                cancelled = true;
+                started = call;
+            }
+            if (started != null) started.cancel();
+        }
+
+        // It no longer runs: the next download waiting can start.
+        private void stopped() {
+            synchronized (downloads) {
+                if (!running) return;
+                running = false;
+                FastImageSharedDownloads.running--;
+            }
+            startQueued();
+        }
+
+        private synchronized boolean hasEnded() {
+            return ended;
+        }
+
+        // With downloads locked.
+        private boolean wasTried(GlideUrl other) {
+            for (GlideUrl requested : tried) {
+                if (sameRequest(requested, other)) return true;
+            }
+            return false;
+        }
+
+        // With downloads locked, while it's queued.
+        private void reprioritize(Priority urgency) {
+            queue.remove(this);
+            priority = urgency;
+            queue.add(this);
+        }
+
+        // With this locked, once it has ended: a stream over all of its bytes.
+        private SharedStream stream() {
+            return new SharedStream(this, store, size);
+        }
+
+        // With downloads locked: new requests start another download.
+        private void unmap() {
+            if (downloads.get(key) == this) downloads.remove(key);
+        }
+
+        // With downloads and this locked: drops the bytes, and gives their
+        // memory back. Returns the store, to release outside the locks (closing
+        // a file can wait for the disk; this can be the main thread).
+        @Nullable
+        private Store drop() {
+            held -= reserved;
+            reserved = 0;
+            Store dropped = store;
+            store = null;
+            return dropped;
+        }
+
+        private static void release(@Nullable Store store) {
+            if (store == null) return;
+            store.release();
+            open.decrementAndGet();
+        }
+
+        // With this locked: the requests waiting for it to end.
+        private List<Waiter> takeWaiting() {
+            List<Waiter> taken = new ArrayList<>(waiting);
+            waiting.clear();
+            return taken;
+        }
+
+        // A request was cancelled (on the main thread). With no one left, the
+        // download is too (or, waiting to start, leaves the queue); waiting to
+        // start, it's as urgent as the most urgent request left, and of the
+        // latest url left (the url of a request that left isn't asked for).
+        void leave(Fetcher fetcher) {
+            boolean cancel = false;
+            Priority urgency = null;
+            Waiter latest = null;
+            synchronized (downloads) {
+                synchronized (this) {
+                    for (int i = waiting.size() - 1; i >= 0; i--) {
+                        if (waiting.get(i).fetcher == fetcher) waiting.remove(i);
+                    }
+                    if (!ended && waiting.isEmpty()) {
+                        unmap();
+                        silent = true;
+                        cancel = true;
+                    }
+                    for (Waiter waiter : waiting) {
+                        Priority asked = waiter.fetcher.priority;
+                        if (urgency == null || asked.compareTo(urgency) < 0) urgency = asked;
+                        latest = waiter;
+                    }
+                }
+                if (cancel && queued) {
+                    queue.remove(this);
+                    queued = false;
+                } else if (queued && urgency != null) {
+                    if (urgency != priority) reprioritize(urgency);
+                    if (!sameRequest(url, latest.fetcher.url)) {
+                        url = latest.fetcher.url;
+                        client = latest.fetcher.client;
+                        request = latest.request;
+                    }
+                }
+            }
+            if (cancel) cancel();
+        }
+
+        // A stream on the bytes was closed: once every one has, the bytes go.
+        void readerClosed() {
+            Store dropped = null;
+            synchronized (downloads) {
+                synchronized (this) {
+                    readers--;
+                    if (readers > 0) return;
+                    unmap();
+                    dropped = drop();
+                }
+            }
+            release(dropped);
+        }
+
+        @Override
+        public void onFailure(@NonNull Call call, @NonNull IOException e) {
+            fail(e);
+        }
+
+        // The download failed: the requests waiting for it fail with the
+        // error, but those that asked for another url (a cacheKey's, e.g. a
+        // signed url with a fresh token) wait for a retry, of the latest of
+        // those urls (they're the same image), if it hasn't been tried for the
+        // key yet: this url can fail for reasons of its own, like an expired
+        // token. So a newer url that joins a retry gets a retry of its own,
+        // and an older one doesn't. As on iOS, where each url downloads on its
+        // own, an image gets onError when its own url fails.
+        private void fail(IOException e) {
+            List<Waiter> failed;
+            Store dropped;
+            Download again = null;
+            synchronized (downloads) {
+                synchronized (this) {
+                    unmap();
+                    silent = true;
+                    ended = true;
+                    failed = takeWaiting();
+                    dropped = drop();
+                }
+                Waiter latest = null;
+                Priority urgency = null;
+                for (Waiter waiter : failed) {
+                    if (waiter.fetcher.cancelled || sameRequest(waiter.fetcher.url, url)) continue;
+                    latest = waiter;
+                    Priority asked = waiter.fetcher.priority;
+                    if (urgency == null || asked.compareTo(urgency) < 0) urgency = asked;
+                }
+                if (latest != null && !wasTried(latest.fetcher.url)) {
+                    again = new Download(key, latest.fetcher.url, latest.fetcher.client, latest.request, urgency);
+                    again.tried.addAll(tried);
+                    List<Waiter> failing = new ArrayList<>();
+                    synchronized (again) {
+                        for (Waiter waiter : failed) {
+                            if (waiter.fetcher.cancelled) continue;
+                            if (sameRequest(waiter.fetcher.url, url)) {
+                                failing.add(waiter);
+                            } else {
+                                waiter.fetcher.download = again;
+                                again.waiting.add(waiter);
+                            }
+                        }
+                    }
+                    failed = failing;
+                    // Not yet in the map, so no one else has it. The requests
+                    // for the other urls can have left meanwhile (a cancel
+                    // marks its request before it takes the lock): no retry.
+                    if (again.waiting.isEmpty()) {
+                        again = null;
+                    } else {
+                        downloads.put(key, again);
+                        again.queued = true;
+                        queue.add(again);
+                    }
+                }
+            }
+            release(dropped);
+            stopped();
+            if (again != null) startQueued();
+            for (Waiter waiter : failed) waiter.callback.onLoadFailed(e);
+        }
+
+        @Override
+        public void onResponse(@NonNull Call call, @NonNull Response response) {
+            final ResponseBody body = response.body();
+            if (!response.isSuccessful() || body == null) {
+                if (body != null) body.close();
+                fail(new HttpException(response.message(), response.code()));
+                return;
+            }
+            final long length = body.contentLength();
+            synchronized (downloads) {
+                // No progress without a length.
+                if (length <= 0) silent = true;
+            }
+            reading.execute(new Runnable() {
+                @Override
+                public void run() {
+                    readInto(body, length);
+                }
+            });
+        }
+
+        // Sends a progress step, unless the download has stopped: checked and
+        // sent with downloads locked, which a cancel takes to stop it, so a new
+        // load of the key never gets a cancelled download's steps. Without an
+        // image with onProgress, nothing is locked.
+        private void report(Progress progress, long loaded, long total) {
+            if (!progress.step(loaded, total) || !FastImageViewManager.wantsProgress()) return;
+            synchronized (downloads) {
+                if (!silent) FastImageViewManager.onDownloadProgress(key, Math.min(loaded, total), total);
+            }
+        }
+
+        // Memory for a response of known length up to MEMORY_MAX, if the
+        // budget has room for it (and there's the memory), otherwise a file.
+        private Store newStore(long length) throws IOException {
+            if (length >= 0 && length <= MEMORY_MAX) {
+                boolean fits;
+                synchronized (downloads) {
+                    fits = held + length <= MEMORY_BUDGET;
+                    if (fits) {
+                        held += length;
+                        reserved = length;
+                    }
+                }
+                if (fits) {
+                    try {
+                        MemoryStore created = new MemoryStore((int) length);
+                        open.incrementAndGet();
+                        return created;
+                    } catch (OutOfMemoryError e) {
+                        synchronized (downloads) {
+                            held -= reserved;
+                            reserved = 0;
+                        }
+                    }
+                }
+            }
+            try {
+                FileStore created = new FileStore();
+                open.incrementAndGet();
+                return created;
+            } catch (IOException e) {
+                return inMemory(null, 0, length, e);
+            }
+        }
+
+        // Memory for `more` of its bytes, from MEMORY_BUDGET (see
+        // GrowingStore), given back when they're dropped; without room, the
+        // download fails with why its file couldn't be used.
+        private void reserve(long more, IOException cause) throws IOException {
+            synchronized (downloads) {
+                if (held + more > MEMORY_BUDGET) {
+                    throw new IOException("No memory left for downloads, and the temporary file couldn't be written", cause);
+                }
+                held += more;
+                reserved += more;
+            }
+        }
+
+        // Its temporary file couldn't be made, or written (`failed`): the
+        // bytes go to memory instead (see FALLBACK_MAX), with the `read` of
+        // them already in `file`.
+        private Store inMemory(@Nullable Store file, long read, long length, IOException failed) throws IOException {
+            if (length > FALLBACK_MAX) throw failed;
+            int capacity = (int) (length >= 0 ? length : Math.max(read, 64 * 1024));
+            reserve(capacity, failed);
+            byte[] bytes = new byte[capacity];
+            if (file != null) {
+                for (long at = 0; at < read; ) at += file.read(at, bytes, (int) at, (int) (read - at));
+            }
+            GrowingStore memory = new GrowingStore(this, bytes, failed);
+            open.incrementAndGet();
+            synchronized (this) {
+                store = memory;
+            }
+            release(file);
+            return memory;
+        }
+
+        // Reads the response into its store, on a thread of `reading`, then
+        // gives the requests waiting a stream each.
+        private void readInto(ResponseBody body, long length) {
+            Progress progress = new Progress();
+            long read = 0;
+            try (BufferedSource source = body.source()) {
+                Store kept = newStore(length);
+                synchronized (this) {
+                    store = kept;
+                }
+                byte[] buffer = new byte[8192];
+                while (length < 0 || read < length) {
+                    int count = source.read(buffer, 0, (int) (length < 0 ? buffer.length : Math.min(buffer.length, length - read)));
+                    if (count == -1) {
+                        if (length < 0) break;
+                        throw new EOFException("The response ended early");
+                    }
+                    try {
+                        kept.write(read, buffer, count);
+                    } catch (IOException e) {
+                        // The temporary file can't be written (e.g. a full
+                        // disk): the bytes go to memory.
+                        if (!(kept instanceof FileStore)) throw e;
+                        kept = inMemory(kept, read, length, e);
+                        kept.write(read, buffer, count);
+                    }
+                    read += count;
+                    report(progress, read, length);
+                }
+            } catch (IOException e) {
+                fail(e);
+                return;
+            } catch (RuntimeException | OutOfMemoryError e) {
+                // E.g. no memory for OkHttp's buffers: the requests fail, and
+                // the next ones start another download.
+                fail(new IOException(e));
+                return;
+            }
+            List<Waiter> waiters;
+            List<SharedStream> streams = new ArrayList<>();
+            Store dropped = null;
+            synchronized (downloads) {
+                synchronized (this) {
+                    size = read;
+                    ended = true;
+                    silent = true;
+                    waiters = takeWaiting();
+                    readers += waiters.size();
+                    for (int i = 0; i < waiters.size(); i++) streams.add(stream());
+                    // Every request left as it ended.
+                    if (readers == 0) {
+                        unmap();
+                        dropped = drop();
+                    }
+                }
+            }
+            release(dropped);
+            stopped();
+            for (int i = 0; i < waiters.size(); i++) {
+                waiters.get(i).fetcher.deliver(streams.get(i), waiters.get(i).callback);
+            }
+        }
+    }
+
+    // A request's stream on a download's bytes, all of them there. Closing it
+    // holds no connection, so it can be done on the main thread.
+    private static final class SharedStream extends InputStream {
+        private final Download download;
+        @Nullable
+        private final Store store;
+        private final long size;
+        private final byte[] one = new byte[1];
+        // Only used by the thread reading it.
+        private long position = 0;
+        private volatile boolean closed = false;
+
+        SharedStream(Download download, @Nullable Store store, long size) {
+            this.download = download;
+            this.store = store;
+            this.size = size;
+        }
+
+        @Override
+        public int read() throws IOException {
+            int count = read(one, 0, 1);
+            return count == -1 ? -1 : one[0] & 0xff;
+        }
+
+        @Override
+        public int read(@NonNull byte[] buffer, int offset, int length) throws IOException {
+            if (length == 0) return 0;
+            if (closed) throw new IOException("Canceled");
+            if (position >= size || store == null) return -1;
+            int read = store.read(position, buffer, offset, (int) Math.min(length, size - position));
+            position += read;
+            return read;
+        }
+
+        @Override
+        public int available() {
+            return closed ? 0 : (int) Math.min(Integer.MAX_VALUE, size - position);
+        }
+
+        @Override
+        public void close() {
+            synchronized (this) {
+                if (closed) return;
+                closed = true;
+            }
+            download.readerClosed();
         }
     }
 }