react-native-fast-image 8.29.0 → 8.30.0

package/README.md

@@ -115,22 +115,9 @@ Remote url to load the image from. e.g. `'https://example.com/image.jpg'`.
 
 #### Photo library images (iOS)
 
-A photo library url (`ph://<localIdentifier>`, as camera roll libraries give) loads when the app has SDWebImagePhotosPlugin. Add it to the app's `ios/Podfile` and run `pod install`:
+A photo library url (`ph://<localIdentifier>`, as camera roll libraries give) loads with SDWebImagePhotosPlugin, which FastImage includes on iOS.
 
-```ruby
-pod 'SDWebImagePhotosPlugin'
-```
-
-With Expo, add it with [expo-build-properties](https://docs.expo.dev/versions/latest/sdk/build-properties/):
-
-```json
-[
-    "expo-build-properties",
-    { "ios": { "extraPods": [{ "name": "SDWebImagePhotosPlugin" }] } }
-]
-```
-
-The app needs access to the photo library, which it has if it got the url from there. A photo library image is decoded at about the view's size, since photos are large and usually shown small; `onLoad` still reports the photo's own size. `FastImage.preload` of a `ph://` source loads the full-size photo (there's no view to size it for), which doesn't make a view's smaller copy load faster, so preloading photo library images usually isn't worth it. Without the plugin, a `ph://` source fails with `onError`, saying so. `assets-library://` urls aren't supported. On Android, photo pickers give `content://` urls, which load as they are.
+The app needs access to the photo library, which it has if it got the url from there. A photo library image is decoded at about the view's size, since photos are large and usually shown small; `onLoad` still reports the photo's own size. `FastImage.preload` of a `ph://` source loads the full-size photo (there's no view to size it for), which doesn't make a view's smaller copy load faster, so preloading photo library images usually isn't worth it. `assets-library://` urls aren't supported. On Android, photo pickers give `content://` urls, which load as they are.
 
 #### SVG images
 
@@ -154,6 +141,12 @@ An SVG is drawn at the size it's shown at, so it's sharp at any size, and then w
 
 ---
 
+#### Animated PNG (Android)
+
+APNG (animated PNG) images animate on Android with [APNG4Android](https://github.com/penfeizhou/APNG4Android), which FastImage includes when the app's `minSdkVersion` is 21 or later (React Native 0.64 and later by default). With an older `minSdkVersion` they show their first frame.
+
+APNGs work like other animated images: `loop`, `paused` (which continues from the frame it paused on), and a still first frame with `blurRadius` or `resizeMode="repeat"`. Each frame is decoded as it plays, at about the size it's shown at, off the main thread.
+
 ### `source.headers?: object`
 
 Headers to load the image with. e.g. `{ Authorization: 'someAuthToken' }`.
@@ -260,7 +253,7 @@ For views that get reused for other content, such as rows in FlashList or recycl
 
 ### `loop?: boolean | number`
 
-How many times an animated image (GIF, animated WebP) plays:
+How many times an animated image (GIF, animated WebP, APNG, and animated AVIF on Android) plays:
 
 - Not set **(Default)** - As many times as the file says (like a browser).
 - `true` - Loop forever.
@@ -283,7 +276,7 @@ How the image is filtered when it's drawn smaller or larger than its size (like
 
 ### `paused?: boolean`
 
-Pauses an animated image (GIF, and animated WebP on iOS) on the frame it's showing; `false` plays it again from there. Each image animates on its own, so pausing one doesn't pause others showing the same file.
+Pauses an animated image (GIF, animated WebP, APNG, and animated AVIF on Android) on the frame it's showing; `false` plays it again from there (on Android, an animated WebP or AVIF plays again from its first frame: Android can't resume one). Each image animates on its own, so pausing one doesn't pause others showing the same file.
 
 ---
 
@@ -315,7 +308,7 @@ iOS only. Decodes a large image at about the size it's shown at, instead of at f
 - `true` **(Default)** - An image at least twice the size its view needs is decoded at about the view's size. If the view grows, the image is decoded again for its new size (from the disk cache).
 - `false` - Images are decoded at full size, e.g. for an image that's zoomed in on with a transform (a pinch-to-zoom viewer), which would otherwise show the smaller copy enlarged.
 
-It doesn't change `onLoad`'s width and height (the image's own size) or the cached file. Needs SDWebImage 5.19.7 or later: before 5.19 images are decoded at full size, and 5.19.0 to 5.19.6 show photos stored sideways with an EXIF orientation (most phone photos) sideways. Photo library images are always decoded this way, and on Android images are always decoded at about the view's size.
+It doesn't change `onLoad`'s width and height (the image's own size) or the cached file. Needs SDWebImage 5.19.7 or later: before 5.19 images are decoded at full size, and 5.19.0 to 5.19.6 show photos stored sideways with an EXIF orientation (most phone photos) sideways. Photo library images are always decoded this way, and on Android images are always decoded at about the view's size (but Android 16 and later decode animated WebP at full size, and scale it as they draw it).
 
 If you control the images, serve them at the size they're shown (resized on your server or by an image CDN), which also saves bandwidth.
 
@@ -328,7 +321,7 @@ Blurs the image by this radius, in points (the same radius looks about the same
 It's for still images, or a radius that changes now and then (e.g. blurring a photo behind a sheet). Each change blurs the image again on the CPU, so don't animate it.
 
 - Only the loaded image is blurred, not `defaultSource`.
-- An animated image (GIF, animated WebP) shows its first frame, blurred, and doesn't animate.
+- An animated image (GIF, animated WebP, APNG or AVIF) shows its first frame, blurred, and doesn't animate.
 - With `tintColor`, the blurred image is tinted.
 - The image is blurred at about the size it's shown at, off the main thread. The cached file stays the original image, so `getCachePath` and other views of it aren't affected.
 - Changing it blurs the image that's showing again, without sending the load events again.

package/RNFastImage.podspec

@@ -21,4 +21,7 @@ Pod::Spec.new do |s|
   # manifest Apple requires.
   s.dependency 'SDWebImage', '>= 5.11.1', '< 6.0'
   s.dependency 'SDWebImageWebPCoder', '>= 0.8.4', '< 1.0'
+  # Photo library images (ph://). iOS only: it needs tvOS 10, and FastImage
+  # finds it at runtime, so a tvOS app can still add it.
+  s.ios.dependency 'SDWebImagePhotosPlugin', '>= 1.2.0', '< 2.0'
 end

package/android/build.gradle

@@ -19,6 +19,17 @@ buildscript {
 
 apply plugin: 'com.android.library'
 
+// When changing the default, revisit the Glide rules in consumer-rules.pro.
+// 4.15+ animates animated WebP (Android 9+) and AVIF (Android 12+).
+def glideVersion = safeExtGet('glideVersion', '4.16.0')
+// Whether it's 4.15 or later, which FastImageAnimated (src/glide-4.15) builds
+// on; an older one gets a stand-in (src/glide-older). A version that isn't
+// numbered (e.g. "4.+") is taken to be recent.
+def glideVersionParts = glideVersion.toString() =~ /^(\d+)\.(\d+)/
+def glideHasAnimatedDecoder = !glideVersionParts.find() ||
+        glideVersionParts.group(1).toInteger() > 4 ||
+        (glideVersionParts.group(1).toInteger() == 4 && glideVersionParts.group(2).toInteger() >= 15)
+
 // Newer versions of the Android Gradle plugin (7.3+) take the namespace from
 // build.gradle and warn about the package attribute in AndroidManifest.xml;
 // older versions need that attribute.
@@ -44,9 +55,12 @@ android {
                 manifest.srcFile "src/main/AndroidManifestNew.xml"
             }
             java {
+                srcDir glideHasAnimatedDecoder ? "src/glide-4.15/java" : "src/glide-older/java"
                 if (safeExtGet('excludeAppGlideModule', false)) {
                     srcDir "src"
                     exclude "**/FastImageGlideModule.java"
+                    // Only the one chosen above.
+                    exclude "glide-*/**"
                 }
             }
         }
@@ -70,9 +84,6 @@ repositories {
     mavenCentral()
 }
 
-// When changing the default, revisit the Glide rules in consumer-rules.pro.
-def glideVersion = safeExtGet('glideVersion', '4.12.0')
-
 dependencies {
     //noinspection GradleDynamicVersion
     implementation 'com.facebook.react:react-native:+'  // From node_modules
@@ -84,4 +95,13 @@ dependencies {
     // SVG images, when the app has AndroidSVG (either package): not shipped,
     // so there's never a second copy of it (see FastImageSvg).
     compileOnly 'com.caverock:androidsvg-aar:1.4'
+    // Animated PNGs, with APNG4Android (see FastImageApng), which needs
+    // minSdkVersion 21: shipped when the app's is 21 or later. With an older
+    // one, FastImage only compiles against it, and APNGs show their first
+    // frame.
+    if (safeExtGet('minSdkVersion', 16).toString().toInteger() >= 21) {
+        implementation 'com.github.penfeizhou.android.animation:apng:3.0.5'
+    } else {
+        compileOnly 'com.github.penfeizhou.android.animation:apng:3.0.5'
+    }
 }

package/android/consumer-rules.pro

@@ -9,11 +9,11 @@
 
 # The Glide rules below cover what Glide's own rules (its library's
 # proguard-rules.txt) didn't at the version FastImage uses by default
-# (glideVersion in build.gradle, 4.12.0) and older ones apps may pick. When
-# updating Glide, revisit which are still needed: whether Glide's rules now
-# keep modules' constructors, and whether its integrations still register
-# old-style modules in their manifests (the OkHttp integration's
-# OkHttpGlideModule still did in 5.0.9).
+# (glideVersion in build.gradle) and older ones apps may pick. When updating
+# Glide, revisit which are still needed: whether Glide's rules now keep
+# modules' constructors (4.16.0's still keep only the AppGlideModule's), and
+# whether its integrations still register old-style modules in their
+# manifests (the OkHttp integration's OkHttpGlideModule still did in 5.0.9).
 
 # Glide's modules and their constructors: FastImage's, the one Glide
 # generates from them, and old-style modules Glide finds in the app's manifest
@@ -46,3 +46,7 @@
 # (FastImageSvgRenderer), and doesn't ship. Without it, R8 would stop at the
 # missing classes.
 -dontwarn com.caverock.androidsvg.**
+
+# APNG4Android, which FastImage uses for animated PNGs (FastImageApngRenderer),
+# and doesn't ship to apps with a minSdkVersion below 21 (build.gradle).
+-dontwarn com.github.penfeizhou.animation.**

package/android/src/glide-4.15/java/com/dylanvann/fastimage/FastImageAnimated.java

@@ -0,0 +1,244 @@
+package com.dylanvann.fastimage;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.drawable.AnimatedImageDrawable;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.Registry;
+import com.bumptech.glide.load.ImageHeaderParser;
+import com.bumptech.glide.load.Options;
+import com.bumptech.glide.load.ResourceDecoder;
+import com.bumptech.glide.load.engine.Resource;
+import com.bumptech.glide.load.engine.bitmap_recycle.ArrayPool;
+import com.bumptech.glide.load.resource.bitmap.BitmapDrawableDecoder;
+import com.bumptech.glide.load.resource.bitmap.ByteBufferBitmapDecoder;
+import com.bumptech.glide.load.resource.bitmap.Downsampler;
+import com.bumptech.glide.load.resource.bitmap.StreamBitmapDecoder;
+import com.bumptech.glide.load.resource.drawable.AnimatedImageDecoder;
+import com.bumptech.glide.load.resource.gif.GifOptions;
+import com.bumptech.glide.util.ByteBufferUtil;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.util.List;
+import java.util.Map;
+import java.util.WeakHashMap;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+
+// Animated WebP and AVIF images, as views' own animations. Glide (4.15+)
+// decodes them to an AnimatedImageDrawable and keeps it in its memory cache,
+// giving the same drawable to every view that shows the image, so the views
+// would share its playback: one view's paused or loop would apply to all of
+// them. A view shows the drawable Glide gives it when no other view is showing
+// it (shownElsewhere), and otherwise one of its own (copy), decoded again from
+// the image's data (which the drawable keeps anyway, to decode its frames
+// from), off the main thread.
+//
+// Not animated (dontAnimate: blurRadius, resizeMode repeat), they're decoded
+// as their first frame, a bitmap, as GIFs are, and as Glide did before 4.15.
+// Glide's own decoder for them doesn't check that option.
+//
+// Built only with Glide 4.15 or later, which has the decoder this wraps; with
+// an older Glide, src/glide-older's stand-in does nothing (build.gradle).
+final class FastImageAnimated {
+    private FastImageAnimated() {}
+
+    interface CopyCallback {
+        // On the main thread: the copy, or null if it couldn't be decoded.
+        void onCopy(@Nullable Drawable copy);
+    }
+
+    // What each drawable Glide decoded was decoded from, to decode copies
+    // (kept as long as the drawable is).
+    private static final Map<Drawable, Source> SOURCES = new WeakHashMap<>();
+    // Decodes copies, one at a time.
+    private static final Executor COPIES = Executors.newSingleThreadExecutor(runnable -> {
+        Thread thread = new Thread(runnable, "FastImageAnimated");
+        thread.setDaemon(true);
+        return thread;
+    });
+    private static final Handler MAIN = new Handler(Looper.getMainLooper());
+    // The repeat count each drawable decoded here had: the file's, which a
+    // view goes back to when loop isn't set (a view may have changed it with
+    // loop, this one or one that showed the drawable before).
+    private static final Map<Drawable, Integer> REPEAT_COUNTS = new WeakHashMap<>();
+
+    private static final class Source {
+        final ResourceDecoder<ByteBuffer, Drawable> decoder;
+        final ByteBuffer data;
+        final int width;
+        final int height;
+        final Options options;
+
+        Source(ResourceDecoder<ByteBuffer, Drawable> decoder, ByteBuffer data, int width, int height, Options options) {
+            this.decoder = decoder;
+            this.data = data;
+            this.width = width;
+            this.height = height;
+            this.options = options;
+        }
+    }
+
+    // Ahead of Glide's own decoder for them, which this uses.
+    static void register(@NonNull Context context, @NonNull Glide glide, @NonNull Registry registry) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) return;
+        List<ImageHeaderParser> parsers = registry.getImageHeaderParsers();
+        ArrayPool arrayPool = glide.getArrayPool();
+        Resources resources = context.getResources();
+        Downsampler downsampler = new Downsampler(
+                parsers, resources.getDisplayMetrics(), glide.getBitmapPool(), arrayPool);
+        ByteBufferDecoder byteBufferDecoder = new ByteBufferDecoder(
+                AnimatedImageDecoder.byteBufferDecoder(parsers, arrayPool),
+                new BitmapDrawableDecoder<>(resources, new ByteBufferBitmapDecoder(downsampler)));
+        registry.prepend(ByteBuffer.class, Drawable.class, byteBufferDecoder);
+        registry.prepend(InputStream.class, Drawable.class, new StreamDecoder(
+                AnimatedImageDecoder.streamDecoder(parsers, arrayPool),
+                new BitmapDrawableDecoder<>(resources, new StreamBitmapDecoder(downsampler, arrayPool)),
+                byteBufferDecoder));
+    }
+
+    // Whether the drawable is one decoded here that a view other than this
+    // one is showing (its callback is that view, or a drawable that view
+    // shows). A view that stops showing it clears its callback, so the next
+    // view can show it instead of a copy.
+    static boolean shownElsewhere(@NonNull Drawable drawable, @NonNull Drawable.Callback view) {
+        synchronized (SOURCES) {
+            if (!SOURCES.containsKey(drawable)) return false;
+        }
+        Drawable.Callback callback = drawable.getCallback();
+        return callback != null && callback != view;
+    }
+
+    // The file's repeat count for a drawable decoded here, or null.
+    @Nullable
+    static Integer repeatCount(@NonNull Drawable drawable) {
+        synchronized (REPEAT_COUNTS) {
+            return REPEAT_COUNTS.get(drawable);
+        }
+    }
+
+    @RequiresApi(Build.VERSION_CODES.P)
+    @Nullable
+    private static Resource<Drawable> remember(@Nullable Resource<Drawable> decoded) {
+        if (decoded == null) return null;
+        Drawable drawable = decoded.get();
+        if (drawable instanceof AnimatedImageDrawable) {
+            synchronized (REPEAT_COUNTS) {
+                REPEAT_COUNTS.put(drawable, ((AnimatedImageDrawable) drawable).getRepeatCount());
+            }
+        }
+        return decoded;
+    }
+
+    // Decodes a drawable of its own for an image decoded here, off the main
+    // thread (its first frame: the drawable decodes the rest as it plays).
+    // The callback gets null if it isn't one, or it couldn't be decoded.
+    static void copy(@NonNull Drawable drawable, @NonNull CopyCallback callback) {
+        Source source;
+        synchronized (SOURCES) {
+            source = SOURCES.get(drawable);
+        }
+        if (source == null) {
+            callback.onCopy(null);
+            return;
+        }
+        COPIES.execute(() -> {
+            Drawable copy = null;
+            try {
+                Resource<Drawable> resource = remember(source.decoder.decode(
+                        source.data.duplicate(), source.width, source.height, source.options));
+                if (resource != null) copy = resource.get();
+            } catch (IOException | RuntimeException ignored) {
+                // It decoded the first time; if it doesn't now, there's no copy.
+            }
+            Drawable result = copy;
+            MAIN.post(() -> callback.onCopy(result));
+        });
+    }
+
+    private static boolean animates(Options options) {
+        return !Boolean.TRUE.equals(options.get(GifOptions.DISABLE_ANIMATION));
+    }
+
+    // The first frame, as a still image.
+    @SuppressWarnings("unchecked")
+    @Nullable
+    private static <T> Resource<Drawable> still(
+            ResourceDecoder<T, BitmapDrawable> decoder, T source, int width, int height, Options options)
+            throws IOException {
+        return (Resource<Drawable>) (Resource<?>) decoder.decode(source, width, height, options);
+    }
+
+    @RequiresApi(Build.VERSION_CODES.P)
+    private static final class ByteBufferDecoder implements ResourceDecoder<ByteBuffer, Drawable> {
+        private final ResourceDecoder<ByteBuffer, Drawable> glide;
+        private final ResourceDecoder<ByteBuffer, BitmapDrawable> stillDecoder;
+
+        ByteBufferDecoder(ResourceDecoder<ByteBuffer, Drawable> glide,
+                ResourceDecoder<ByteBuffer, BitmapDrawable> stillDecoder) {
+            this.glide = glide;
+            this.stillDecoder = stillDecoder;
+        }
+
+        @Override
+        public boolean handles(@NonNull ByteBuffer source, @NonNull Options options) throws IOException {
+            return glide.handles(source, options);
+        }
+
+        @Nullable
+        @Override
+        public Resource<Drawable> decode(@NonNull ByteBuffer source, int width, int height, @NonNull Options options)
+                throws IOException {
+            if (!animates(options)) return still(stillDecoder, source, width, height, options);
+            // Its own position, for decoding it again.
+            ByteBuffer data = source.duplicate();
+            Resource<Drawable> decoded = remember(glide.decode(source, width, height, options));
+            if (decoded != null) {
+                synchronized (SOURCES) {
+                    SOURCES.put(decoded.get(), new Source(glide, data, width, height, options));
+                }
+            }
+            return decoded;
+        }
+    }
+
+    @RequiresApi(Build.VERSION_CODES.P)
+    private static final class StreamDecoder implements ResourceDecoder<InputStream, Drawable> {
+        private final ResourceDecoder<InputStream, Drawable> glide;
+        private final ResourceDecoder<InputStream, BitmapDrawable> stillDecoder;
+        private final ByteBufferDecoder byteBufferDecoder;
+
+        StreamDecoder(ResourceDecoder<InputStream, Drawable> glide,
+                ResourceDecoder<InputStream, BitmapDrawable> stillDecoder, ByteBufferDecoder byteBufferDecoder) {
+            this.glide = glide;
+            this.stillDecoder = stillDecoder;
+            this.byteBufferDecoder = byteBufferDecoder;
+        }
+
+        @Override
+        public boolean handles(@NonNull InputStream source, @NonNull Options options) throws IOException {
+            return glide.handles(source, options);
+        }
+
+        // Read whole, as Glide's own does.
+        @Nullable
+        @Override
+        public Resource<Drawable> decode(@NonNull InputStream source, int width, int height, @NonNull Options options)
+                throws IOException {
+            if (!animates(options)) return still(stillDecoder, source, width, height, options);
+            return byteBufferDecoder.decode(ByteBufferUtil.fromStream(source), width, height, options);
+        }
+    }
+}

package/android/src/glide-older/java/com/dylanvann/fastimage/FastImageAnimated.java

@@ -0,0 +1,36 @@
+package com.dylanvann.fastimage;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.Registry;
+
+// Built instead of src/glide-4.15's FastImageAnimated with a Glide before
+// 4.15 (build.gradle), which has no decoder for animated WebP or AVIF: they
+// show their first frame, so there's nothing to register, remember or copy.
+final class FastImageAnimated {
+    private FastImageAnimated() {}
+
+    interface CopyCallback {
+        void onCopy(@Nullable Drawable copy);
+    }
+
+    static void register(@NonNull Context context, @NonNull Glide glide, @NonNull Registry registry) {}
+
+    @Nullable
+    static Integer repeatCount(@NonNull Drawable drawable) {
+        return null;
+    }
+
+    static boolean shownElsewhere(@NonNull Drawable drawable, @NonNull Drawable.Callback view) {
+        return false;
+    }
+
+    static void copy(@NonNull Drawable drawable, @NonNull CopyCallback callback) {
+        callback.onCopy(null);
+    }
+}

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

@@ -0,0 +1,13 @@
+package com.dylanvann.fastimage;
+
+// An animated image that applies FastImage's loop and paused itself (an APNG,
+// FastImageApngRenderer). The view's target starts it when it's shown.
+interface FastImageAnimatable {
+    // loopCount as FastImageViewWithUrl has it: -1, as many times as the file
+    // says; 0, forever; n, n times. restart: play it again from its first
+    // frame.
+    void setLoopCount(int loopCount, boolean restart);
+
+    // Stays on the frame it's showing; false continues from there.
+    void setPaused(boolean paused);
+}

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

@@ -0,0 +1,141 @@
+package com.dylanvann.fastimage;
+
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.bumptech.glide.Registry;
+import com.bumptech.glide.load.Options;
+import com.bumptech.glide.load.ResourceDecoder;
+import com.bumptech.glide.load.engine.Resource;
+import com.bumptech.glide.load.resource.gif.GifOptions;
+import com.bumptech.glide.util.ByteBufferUtil;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+
+// Animated PNGs (APNG), animated with APNG4Android
+// (com.github.penfeizhou.android.animation:apng), which FastImage ships when
+// the app's minSdkVersion is 21 or later, as APNG4Android needs (build.gradle).
+// Without it, an APNG shows its first frame, as Android shows it. Android and
+// Glide don't animate APNG themselves.
+//
+// The decoders come before Glide's own, and only take PNGs with an animation
+// control chunk (acTL), when the request animates (not with dontAnimate:
+// blurRadius, resizeMode repeat, which get the first frame from Glide's
+// decoder). This class doesn't use APNG4Android itself
+// (FastImageApngRenderer does), so it loads without it.
+final class FastImageApng {
+    // As much of the start of the file as is read to find acTL, which comes
+    // before the image data.
+    private static final int HEAD_LENGTH = 4096;
+    private static final byte[] SIGNATURE = {(byte) 0x89, 'P', 'N', 'G', '\r', '\n', 0x1a, '\n'};
+    @Nullable
+    private static Boolean available;
+
+    private FastImageApng() {
+    }
+
+    static synchronized boolean available() {
+        if (available == null) {
+            try {
+                // Android 5+, as APNG4Android needs.
+                available = Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && FastImageApngRenderer.available();
+            } catch (Throwable e) {
+                available = false;
+            }
+        }
+        return available;
+    }
+
+    static void register(@NonNull Registry registry) {
+        if (!available()) return;
+        registry.prepend(InputStream.class, Drawable.class, new StreamDecoder())
+                .prepend(ByteBuffer.class, Drawable.class, new BufferDecoder());
+    }
+
+    // How many times the APNG says it plays (0: forever), or -1 if the data
+    // doesn't start like an APNG: a PNG with an acTL chunk before its image
+    // data.
+    static int plays(@NonNull byte[] head, int length) {
+        if (length < SIGNATURE.length) return -1;
+        for (int i = 0; i < SIGNATURE.length; i++) {
+            if (head[i] != SIGNATURE[i]) return -1;
+        }
+        int offset = SIGNATURE.length;
+        // Each chunk: a length, a type, the data, a CRC.
+        while (offset + 8 <= length) {
+            int chunkLength = ((head[offset] & 0xff) << 24) | ((head[offset + 1] & 0xff) << 16)
+                    | ((head[offset + 2] & 0xff) << 8) | (head[offset + 3] & 0xff);
+            String type = new String(head, offset + 4, 4, StandardCharsets.US_ASCII);
+            if (type.equals("acTL")) {
+                // num_frames, then num_plays.
+                int plays = offset + 12;
+                if (plays + 4 > length) return -1;
+                return ((head[plays] & 0x7f) << 24) | ((head[plays + 1] & 0xff) << 16)
+                        | ((head[plays + 2] & 0xff) << 8) | (head[plays + 3] & 0xff);
+            }
+            if (type.equals("IDAT") || chunkLength < 0) return -1;
+            offset += 12 + chunkLength;
+        }
+        return -1;
+    }
+
+    private static boolean animates(Options options) {
+        return !Boolean.TRUE.equals(options.get(GifOptions.DISABLE_ANIMATION));
+    }
+
+    private static int plays(@NonNull ByteBuffer source) {
+        ByteBuffer copy = source.duplicate();
+        byte[] head = new byte[Math.min(HEAD_LENGTH, copy.remaining())];
+        copy.get(head);
+        return plays(head, head.length);
+    }
+
+    private static final class BufferDecoder implements ResourceDecoder<ByteBuffer, Drawable> {
+        @Override
+        public boolean handles(@NonNull ByteBuffer source, @NonNull Options options) {
+            return animates(options) && plays(source) >= 0;
+        }
+
+        @Nullable
+        @Override
+        public Resource<Drawable> decode(@NonNull ByteBuffer source, int width, int height, @NonNull Options options)
+                throws IOException {
+            return FastImageApngRenderer.decode(source.duplicate(), plays(source));
+        }
+    }
+
+    private static final class StreamDecoder implements ResourceDecoder<InputStream, Drawable> {
+        @Override
+        public boolean handles(@NonNull InputStream source, @NonNull Options options) throws IOException {
+            if (!animates(options)) return false;
+            byte[] head = new byte[HEAD_LENGTH];
+            source.mark(HEAD_LENGTH);
+            int read = 0;
+            try {
+                while (read < head.length) {
+                    int count = source.read(head, read, head.length - read);
+                    if (count < 0) break;
+                    read += count;
+                }
+            } finally {
+                source.reset();
+            }
+            return plays(head, read) >= 0;
+        }
+
+        // Read whole: APNG4Android reads frames from it as it plays.
+        @Nullable
+        @Override
+        public Resource<Drawable> decode(@NonNull InputStream source, int width, int height, @NonNull Options options)
+                throws IOException {
+            ByteBuffer data = ByteBufferUtil.fromStream(source);
+            return FastImageApngRenderer.decode(data, plays(data));
+        }
+    }
+}