react-native-fast-image 8.28.1 → 8.30.0

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

@@ -13,11 +13,14 @@ import android.graphics.Paint;
 import android.graphics.PorterDuff;
 import android.graphics.PorterDuffXfermode;
 import android.graphics.Shader;
+import android.graphics.drawable.AnimatedImageDrawable;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
+import android.os.Build;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
 import androidx.appcompat.widget.AppCompatImageView;
 import androidx.core.view.ViewCompat;
 
@@ -29,6 +32,7 @@ import com.bumptech.glide.load.model.GlideUrl;
 import com.bumptech.glide.load.resource.bitmap.DownsampleStrategy;
 import com.bumptech.glide.load.resource.drawable.DrawableTransitionOptions;
 import com.bumptech.glide.load.resource.gif.GifDrawable;
+import com.bumptech.glide.request.Request;
 import com.bumptech.glide.request.RequestOptions;
 import com.bumptech.glide.request.target.DrawableImageViewTarget;
 import com.bumptech.glide.request.target.SizeReadyCallback;
@@ -179,6 +183,17 @@ class FastImageViewWithUrl extends AppCompatImageView {
                 mOwnGif.startFromFirstFrame();
             }
         }
+        if (getDrawable() instanceof FastImageAnimatable) {
+            ((FastImageAnimatable) getDrawable()).setLoopCount(mLoopCount, !mPaused);
+        }
+        if (mAnimated != null && getDrawable() == mAnimated && Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            AnimatedImageDrawable animated = (AnimatedImageDrawable) mAnimated;
+            applyRepeatCount(animated);
+            if (!mPaused) {
+                animated.stop();
+                animated.start();
+            }
+        }
     }
 
     // Pauses GIFs on the frame they're showing (the view's own animation).
@@ -359,6 +374,18 @@ class FastImageViewWithUrl extends AppCompatImageView {
                 FastImageGif.resume(mOwnGif);
             }
         }
+        if (getDrawable() instanceof FastImageAnimatable) {
+            ((FastImageAnimatable) getDrawable()).setPaused(paused);
+        }
+        if (mAnimated != null && getDrawable() == mAnimated && Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            if (paused) {
+                ((AnimatedImageDrawable) mAnimated).stop();
+            } else {
+                // Plays from its first frame: an AnimatedImageDrawable has no
+                // way to resume.
+                ((AnimatedImageDrawable) mAnimated).start();
+            }
+        }
     }
 
     // The GIF this view shows as its own animation (FastImageGif), recycled
@@ -366,12 +393,20 @@ class FastImageViewWithUrl extends AppCompatImageView {
     @Nullable
     private GifDrawable mOwnGif;
 
+    // An animated WebP or AVIF this view shows: an AnimatedImageDrawable, which
+    // Glide 4.15+ decodes with Android's ImageDecoder (API 28+; AVIF 31+).
+    @Nullable
+    private Drawable mAnimated;
+
     // Shows each GIF as this view's own animation. Glide's target also starts
     // and stops it with the Activity, as it does Glide's own GifDrawable.
     private final class OwnGifTarget extends DrawableImageViewTarget {
         // Shown instead of the placeholder while loading (see shownCopy).
         @Nullable
         private Drawable mMeanwhile;
+        // Counts images ready (a thumbnail, then the image), so a copy
+        // decoded for one isn't shown over a later one.
+        private int mReady = 0;
 
         OwnGifTarget(@Nullable Drawable meanwhile) {
             super(FastImageViewWithUrl.this);
@@ -387,6 +422,7 @@ class FastImageViewWithUrl extends AppCompatImageView {
 
         @Override
         public void onResourceReady(@NonNull Drawable resource, @Nullable Transition<? super Drawable> transition) {
+            int ready = ++mReady;
             if (resource instanceof BitmapDrawable) {
                 if (mPixelated) {
                     // Scaled by the view without filtering: sharp pixels.
@@ -406,9 +442,48 @@ class FastImageViewWithUrl extends AppCompatImageView {
                     return;
                 }
             }
+            if (resource instanceof FastImageAnimatable) {
+                // An APNG: each view's is its own (FastImageApngRenderer).
+                FastImageAnimatable animatable = (FastImageAnimatable) resource;
+                animatable.setLoopCount(mLoopCount, false);
+                // The target starts it; paused, it stays on its first frame.
+                super.onResourceReady(resource, transition);
+                if (mPaused) animatable.setPaused(true);
+                return;
+            }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && resource instanceof AnimatedImageDrawable) {
+                if (!FastImageAnimated.shownElsewhere(resource, FastImageViewWithUrl.this)) {
+                    showAnimated((AnimatedImageDrawable) resource, transition);
+                    return;
+                }
+                // Another view shows it: this one shows its own, once it's
+                // decoded (meanwhile, what it showed), if it's still this
+                // view's latest image. Failing that, it shares that view's.
+                Drawable shared = resource;
+                FastImageAnimated.copy(resource, copy -> {
+                    Request request = getRequest();
+                    if (ready != mReady || request == null || !request.isComplete()) return;
+                    showAnimated((AnimatedImageDrawable) (copy != null ? copy : shared), transition);
+                });
+                return;
+            }
             super.onResourceReady(resource, transition);
         }
 
+        @RequiresApi(Build.VERSION_CODES.P)
+        private void showAnimated(AnimatedImageDrawable animated, @Nullable Transition<? super Drawable> transition) {
+            applyRepeatCount(animated);
+            // From its first frame, with this view's repeat count: the target
+            // starts it, but a drawable another view showed can still be
+            // playing (start() does nothing then), and a repeat count set
+            // during a play doesn't always apply to that play. Paused, it
+            // waits on its first frame.
+            animated.stop();
+            super.onResourceReady(animated, transition);
+            mAnimated = animated;
+            if (mPaused) animated.stop();
+        }
+
         // The target starts animations again when the Activity does: not a
         // paused one, and the view's own GIF continues its loop count (start()
         // would count again).
@@ -431,6 +506,9 @@ class FastImageViewWithUrl extends AppCompatImageView {
                 mOwnGif.recycle();
                 mOwnGif = null;
             }
+            if (mAnimated != null && mAnimated != resource) {
+                mAnimated = null;
+            }
         }
     }
 
@@ -440,6 +518,21 @@ class FastImageViewWithUrl extends AppCompatImageView {
                 : mLoopCount);
     }
 
+    // The loop prop for an animated WebP or AVIF: its repeat count is the
+    // plays after the first. Not set, it plays as many times as the file says:
+    // the repeat count it was decoded with, which an earlier loop (this
+    // view's, or another view's that showed the same drawable) may have
+    // changed.
+    @RequiresApi(Build.VERSION_CODES.P)
+    private void applyRepeatCount(AnimatedImageDrawable animated) {
+        if (mLoopCount == -1) {
+            Integer own = FastImageAnimated.repeatCount(animated);
+            if (own != null) animated.setRepeatCount(own);
+            return;
+        }
+        animated.setRepeatCount(mLoopCount == 0 ? AnimatedImageDrawable.REPEAT_INFINITE : mLoopCount - 1);
+    }
+
     // resizeMode repeat: the image (a GIF's first frame) repeated from the
     // top-left at its own size, scaled down to fit the view if it's larger,
     // as React Native's Image does. The view fills with it (FIT_XY).

package/dist/index.d.ts

@@ -133,9 +133,10 @@ export interface FastImageProps extends AccessibilityProps, ViewProps {
      */
     recyclingKey?: string | null;
     /**
-     * How many times an animated image (GIF, animated WebP) plays: the file's
-     * own loop count by default, `true` to loop forever, `false` to play once,
-     * or a number of times. Changing it restarts the animation.
+     * How many times an animated image (GIF, animated WebP, APNG, and animated
+     * AVIF on Android) plays: the file's own loop count by default, `true` to
+     * loop forever, `false` to play once, or a number of times. Changing it
+     * restarts the animation.
      */
     loop?: boolean | number;
     /**
@@ -147,9 +148,11 @@ export interface FastImageProps extends AccessibilityProps, ViewProps {
      */
     imageRendering?: 'auto' | 'smooth' | 'pixelated';
     /**
-     * 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.
      */
     paused?: boolean;
     /**

package/ios/FastImage/FFFAnimatedWebPCoder.h

@@ -0,0 +1,10 @@
+#import <SDWebImageWebPCoder/SDImageWebPCoder.h>
+
+// libwebp's WebP coder (SDWebImageWebPCoder), for animated WebPs only:
+// SDWebImage's own coders decode a WebP's first frame. Still WebPs keep
+// ImageIO's decoder. Registered with SDWebImage's coders by FFFastImageSource.
+@interface FFFAnimatedWebPCoder : SDImageWebPCoder
+
+@property (nonatomic, class, readonly, nonnull) FFFAnimatedWebPCoder* sharedCoder;
+
+@end

package/ios/FastImage/FFFAnimatedWebPCoder.m

@@ -0,0 +1,41 @@
+#import "FFFAnimatedWebPCoder.h"
+
+// Whether the data is an animated WebP: a RIFF WEBP file whose first chunk is
+// VP8X (the extended format) with the animation flag set. The header comes
+// first, so a partial download can be checked too.
+static BOOL FFFIsAnimatedWebP(NSData* data) {
+    if (data.length < 21) {
+        return NO;
+    }
+    const uint8_t* bytes = data.bytes;
+    return memcmp(bytes, "RIFF", 4) == 0
+        && memcmp(bytes + 8, "WEBPVP8X", 8) == 0
+        && (bytes[20] & 0x02) != 0;
+}
+
+@implementation FFFAnimatedWebPCoder
+
+// SDImageWebPCoder's sharedCoder is always one of its own.
++ (FFFAnimatedWebPCoder*) sharedCoder {
+    static FFFAnimatedWebPCoder* coder;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        coder = [FFFAnimatedWebPCoder new];
+    });
+    return coder;
+}
+
+- (BOOL) canDecodeFromData: (NSData*)data {
+    return FFFIsAnimatedWebP(data);
+}
+
+- (BOOL) canIncrementalDecodeFromData: (NSData*)data {
+    return FFFIsAnimatedWebP(data);
+}
+
+// Only for decoding: encoding WebP is left to the coders that did it before.
+- (BOOL) canEncodeToFormat: (SDImageFormat)format {
+    return NO;
+}
+
+@end

package/ios/FastImage/FFFastImageSource.m

@@ -6,6 +6,8 @@
 #import <SDWebImage/SDWebImageDownloaderOperation.h>
 #import <SDWebImage/NSData+ImageContentType.h>
 #import <SDWebImage/SDImageCodersManager.h>
+#import <SDWebImage/SDImageAWebPCoder.h>
+#import "FFFAnimatedWebPCoder.h"
 #import <objc/message.h>
 
 // In FFFastImageView.m.
@@ -15,7 +17,7 @@ static NSUInteger const FFFWebCacheSize = 50 * 1024 * 1024;
 
 // The photo's own size in pixels, looked up by its identifier (the url after
 // ph://), or zero. Through the runtime, as the Photos framework is only there
-// when the app links it (with SDWebImagePhotosPlugin). Kept once looked up.
+// with SDWebImagePhotosPlugin (on iOS, always). Kept once looked up.
 static CGSize FFFLookUpPhotoPixelSize(NSURL *url)
 {
     Class assetClass = NSClassFromString(@"PHAsset");
@@ -59,11 +61,11 @@ static CGSize FFFPhotoPixelSize(NSURL *url)
 }
 
 // Loads photo library images (ph://<localIdentifier>) with
-// SDWebImagePhotosPlugin's loader when the app has it (the pod): FastImage
-// finds it at runtime, so it doesn't depend on it or on the Photos framework.
-// Its own instance, so the app's use of the plugin is left as it is. Without
-// the plugin, or for a source it can't load (assets-library://), the load
-// fails with `failure`.
+// SDWebImagePhotosPlugin's loader: a dependency on iOS (the podspec), found
+// at runtime so that tvOS builds without it (an app can add it there). Its
+// own instance, so the app's use of the plugin is left as it is. Without the
+// plugin, or for a source it can't load (assets-library://), the load fails
+// with `failure`.
 @interface FFFPhotosLoader : NSObject <SDImageLoader>
 @property (nonatomic, strong) id<SDImageLoader> plugin;
 @property (nonatomic, copy) NSString *failure;
@@ -243,7 +245,22 @@ static id<SDImageCoder> FFFSVGCoder;
     if (self != [FFFastImageSource class]) {
         return;
     }
-    // Registered with SDWebImage's coders, as the pod's setup does (unless
+    // Animated WebP: SDWebImage's own coders only decode a WebP's first frame
+    // (with ImageIO), so libwebp's coder decodes animated ones (still ones
+    // keep ImageIO's). Not if the app has registered a WebP coder (libwebp's,
+    // or ImageIO's animated one), which is its choice.
+    BOOL hasWebPCoder = NO;
+    for (id<SDImageCoder> registered in SDImageCodersManager.sharedManager.coders) {
+        if ([registered isKindOfClass:[SDImageWebPCoder class]] || [registered isKindOfClass:[SDImageAWebPCoder class]]) {
+            hasWebPCoder = YES;
+            break;
+        }
+    }
+    if (!hasWebPCoder) {
+        [SDImageCodersManager.sharedManager addCoder:FFFAnimatedWebPCoder.sharedCoder];
+    }
+
+    // SVG: registered with SDWebImage's coders, as the pod's setup does (unless
     // the app has already): SDWebImage then picks it for SVG data, including
     // for FastImage's animated and downsampled image classes. Giving the
     // coder per load instead (SDWebImageContextImageCoder) would make it the

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-fast-image",
-    "version": "8.28.1",
+    "version": "8.30.0",
     "description": "FastImage, performant React Native image component.",
     "keywords": [
         "cache",
@@ -28,6 +28,8 @@
         "android/build.gradle",
         "android/consumer-rules.pro",
         "android/src/main",
+        "android/src/glide-4.15",
+        "android/src/glide-older",
         "ios/FastImage",
         "ios/FastImage.xcodeproj/project.pbxproj",
         "ios/FastImage.xcodeproj/xcshareddata",