react-native-fast-image 8.29.0 → 8.30.0

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

@@ -0,0 +1,141 @@
+package com.dylanvann.fastimage;
+
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.bumptech.glide.load.engine.Resource;
+import com.github.penfeizhou.animation.apng.APNGDrawable;
+import com.github.penfeizhou.animation.apng.decode.APNGDecoder;
+import com.github.penfeizhou.animation.loader.ByteBufferLoader;
+import com.github.penfeizhou.animation.loader.Loader;
+
+import java.nio.ByteBuffer;
+
+// APNGs with APNG4Android (FastImageApng, which only uses this when it's
+// there). Glide keeps the image's data in its memory cache, and each view
+// gets a drawable of its own over it, so views don't share playback: making
+// one only reads the image's header, and it decodes its frames (at a sample
+// size from the size it's drawn at) on APNG4Android's threads as it plays.
+final class FastImageApngRenderer {
+    private FastImageApngRenderer() {
+    }
+
+    // Throws NoClassDefFoundError without APNG4Android.
+    static boolean available() {
+        return APNGDrawable.class.getName() != null;
+    }
+
+    private static Loader loader(ByteBuffer data) {
+        return new ByteBufferLoader() {
+            @Override
+            public ByteBuffer getByteBuffer() {
+                ByteBuffer buffer = data.duplicate();
+                buffer.position(0);
+                return buffer;
+            }
+        };
+    }
+
+    // Null if APNG4Android can't read it (Glide then decodes it as a PNG).
+    @Nullable
+    static Resource<Drawable> decode(@NonNull ByteBuffer data, int plays) {
+        // Reads the header, waiting for APNG4Android's thread.
+        Rect bounds = new APNGDecoder(loader(data), null).getBounds();
+        if (bounds.isEmpty()) return null;
+        return new ApngResource(data, plays, bounds);
+    }
+
+    private static final class ApngResource implements Resource<Drawable> {
+        private final ByteBuffer data;
+        private final int plays;
+        private final Rect bounds;
+
+        ApngResource(ByteBuffer data, int plays, Rect bounds) {
+            this.data = data;
+            this.plays = plays;
+            this.bounds = bounds;
+        }
+
+        @NonNull
+        @Override
+        public Class<Drawable> getResourceClass() {
+            return Drawable.class;
+        }
+
+        @NonNull
+        @Override
+        public Drawable get() {
+            return new ApngDrawable(loader(data), plays);
+        }
+
+        // The data, and a frame at full size (each view's drawable has its
+        // own, at the size it's drawn at).
+        @Override
+        public int getSize() {
+            return data.limit() + bounds.width() * bounds.height() * 4;
+        }
+
+        @Override
+        public void recycle() {
+        }
+    }
+
+    private static final class ApngDrawable extends APNGDrawable implements FastImageAnimatable {
+        // How many times the file says it plays (0: forever).
+        private final int plays;
+        private volatile boolean paused = false;
+
+        ApngDrawable(Loader loader, int plays) {
+            super(loader);
+            this.plays = plays;
+        }
+
+        @Override
+        public void setLoopCount(int loopCount, boolean restart) {
+            // Plays (0: forever), as APNG4Android counts them.
+            setLoopLimit(loopCount == -1 ? plays : loopCount);
+            if (restart) {
+                reset();
+                start();
+            }
+        }
+
+        @Override
+        public void setPaused(boolean paused) {
+            this.paused = paused;
+            // It starts and stops itself as it's shown and hidden, but not
+            // while paused.
+            setAutoPlay(!paused);
+            if (paused) {
+                pause();
+            } else {
+                resume();
+            }
+        }
+
+        // From its first frame. The target starts it right after
+        // setVisible(true) has (auto play): APNG4Android's start() stops and
+        // starts a running decoder, and a stop made while the decoder is
+        // still starting can win over that start, leaving it stopped on its
+        // first frame. A running one is reset to its first frame instead.
+        @Override
+        public void start() {
+            if (isRunning()) {
+                getFrameSeqDecoder().reset();
+                return;
+            }
+            super.start();
+        }
+
+        // On its decoder thread, once starting has drawn the first frame:
+        // starting clears a pause made before it got there, so pause again.
+        @Override
+        public void onStart() {
+            super.onStart();
+            if (paused) getFrameSeqDecoder().pause();
+        }
+    }
+}

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

@@ -121,6 +121,8 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
         OkHttpClient client = builder.build();
         registry.replace(GlideUrl.class, InputStream.class, new UrlLoaderFactory(client));
         FastImageSvg.register(registry, glide.getBitmapPool());
+        FastImageAnimated.register(context, glide, registry);
+        FastImageApng.register(registry);
 
         // `cache: 'web'` skips Glide's caches and relies on HTTP caching, so
         // those urls get a client with an HTTP cache (#280): one of their own,
@@ -156,7 +158,10 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
             return new ModelLoader<GlideUrl, InputStream>() {
                 @Override
                 public LoadData<InputStream> buildLoadData(@NonNull GlideUrl model, int width, int height, @NonNull Options options) {
-                    return loader.buildLoadData(model, width, height, options);
+                    LoadData<InputStream> data = loader.buildLoadData(model, width, height, options);
+                    // A view loading an image that's being preloaded waits
+                    // for the preload's download.
+                    return data == null ? null : FastImageSharedDownloads.share(data, model, options);
                 }
 
                 @Override

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

@@ -0,0 +1,292 @@
+package com.dylanvann.fastimage;
+
+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.data.DataFetcher;
+import com.bumptech.glide.load.model.GlideUrl;
+import com.bumptech.glide.load.model.ModelLoader;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ThreadFactory;
+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);
+
+    // 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.
+    private static final long KEEP_MS = 60_000;
+
+    // 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() {
+                @Override
+                public Thread newThread(@NonNull Runnable runnable) {
+                    Thread thread = new Thread(runnable, "FastImageSharedDownloads");
+                    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;
+        }
+
+        void go(@Nullable File file) {
+            if (went.compareAndSet(false, true)) fetcher.resume(file, priority, callback);
+        }
+
+        // Cancelled: never goes on.
+        void drop() {
+            went.set(true);
+        }
+    }
+
+    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;
+
+        synchronized boolean isDone() {
+            return done;
+        }
+
+        boolean isStale(long now) {
+            return isDone() && now - finishedAt > KEEP_MS;
+        }
+
+        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;
+                }
+            }
+            goOn(waiter, file);
+        }
+
+        synchronized void remove(Waiter waiter) {
+            waiters.remove(waiter);
+        }
+
+        // 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;
+        }
+
+        private static void goOn(final Waiter waiter, @Nullable final File file) {
+            executor.execute(new Runnable() {
+                @Override
+                public void run() {
+                    waiter.go(file);
+                }
+            });
+        }
+    }
+
+    // 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 FastImageSharedDownloads() {
+    }
+
+    // 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());
+        }
+        Download download = downloads.get(key);
+        if (download == null) return;
+        if (download.finish(file, now) && file == null) downloads.remove(key, download);
+    }
+
+    // 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));
+    }
+
+    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;
+        @Nullable
+        private volatile Waiter waiter;
+        // The preload's file, when the image came from it.
+        @Nullable
+        private volatile InputStream stream;
+
+        Fetcher(DataFetcher<InputStream> fetcher, String key, boolean preload) {
+            this.fetcher = fetcher;
+            this.key = key;
+            this.preload = preload;
+        }
+
+        @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;
+            if (file != null) {
+                try {
+                    stream = new FileInputStream(file);
+                    callback.onDataReady(stream);
+                    return;
+                } catch (IOException e) {
+                    // Gone from the disk cache meanwhile: download it.
+                }
+            }
+            fetcher.loadData(priority, callback);
+        }
+
+        @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();
+        }
+
+        @Override
+        public void cancel() {
+            cancelled = true;
+            Download waitingFor = download;
+            Waiter waiting = waiter;
+            if (waitingFor != null && waiting != null) {
+                waitingFor.remove(waiting);
+                waiting.drop();
+            }
+            // The preload's download stops: views waiting for it download
+            // the image themselves.
+            if (preload) finished(key, null);
+            fetcher.cancel();
+        }
+
+        @NonNull
+        @Override
+        public Class<InputStream> getDataClass() {
+            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.
+        @NonNull
+        @Override
+        public DataSource getDataSource() {
+            return stream != null ? DataSource.DATA_DISK_CACHE : fetcher.getDataSource();
+        }
+    }
+}

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

@@ -169,7 +169,7 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
                         pendingPreloads.add(new Runnable() {
                             @Override
                             public void run() {
-                                loadFile(context, imageSource.getSourceForLoad(), preloadOptions, new FileCallback() {
+                                loadFile(context, imageSource.getSourceForLoad(), preloadOptions, true, new FileCallback() {
                                     @Override
                                     public void run(@Nullable final File file, @Nullable String error) {
                                         if (file == null) {
@@ -196,7 +196,8 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
                         });
                         continue;
                     }
-                    pendingPreloads.add(new Runnable() {
+                    // Decodes it into the memory cache.
+                    final Runnable decode = new Runnable() {
                         @Override
                         public void run() {
                             Glide
@@ -222,6 +223,22 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
                                     })
                                     .preload();
                         }
+                    };
+                    // A remote image is downloaded to the disk cache first,
+                    // so views that load it meanwhile can wait for the file
+                    // (FastImageSharedDownloads), then decoded from there.
+                    final boolean download = !imageSource.isWebCache() && imageSource.isRemote();
+                    pendingPreloads.add(!download ? decode : new Runnable() {
+                        @Override
+                        public void run() {
+                            loadFile(context, imageSource.getSourceForLoad(), preloadOptions, true, new FileCallback() {
+                                @Override
+                                public void run(@Nullable File file, @Nullable String error) {
+                                    if (file == null) done.run(failure(error));
+                                    else decode.run();
+                                }
+                            });
+                        }
                     });
                 }
                 if (count == 0) {
@@ -250,21 +267,26 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
 
     // Downloads the image into Glide's disk cache without decoding it (if it
     // isn't there), then calls back with its file or the error, on the UI
-    // thread.
-    private static void loadFile(Context context, Object model, RequestOptions options, final FileCallback callback) {
+    // thread. For a preload (`shared`), views that load the image meanwhile
+    // wait for the download and read its file (FastImageSharedDownloads).
+    private static void loadFile(Context context, Object model, RequestOptions options, boolean shared, final FileCallback callback) {
+        final String key = shared && model instanceof GlideUrl ? ((GlideUrl) model).getCacheKey() : null;
         Glide.with(context)
                 .asFile()
                 .load(model)
                 .apply(options)
+                .set(FastImageSharedDownloads.PRELOAD, shared)
                 .listener(new RequestListener<File>() {
                     @Override
                     public boolean onLoadFailed(@Nullable GlideException e, Object model, Target<File> target, boolean isFirstResource) {
+                        if (key != null) FastImageSharedDownloads.finished(key, null);
                         callback.run(null, FastImageRequestListener.errorMessage(e));
                         return false;
                     }
 
                     @Override
                     public boolean onResourceReady(File file, Object model, Target<File> target, DataSource dataSource, boolean isFirstResource) {
+                        if (key != null) FastImageSharedDownloads.finished(key, file);
                         callback.run(file, null);
                         return false;
                     }
@@ -400,7 +422,7 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
         return new Runnable() {
             @Override
             public void run() {
-                loadFile(context, imageSource.getSourceForLoad(), options, new FileCallback() {
+                loadFile(context, imageSource.getSourceForLoad(), options, false, new FileCallback() {
                     @Override
                     public void run(@Nullable File file, @Nullable String error) {
                         finishDownload(promise, file != null ? pathResult(file) : failure(error));