react-native-fast-image 8.29.0 → 8.30.1

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/FFFastImageSource.m

@@ -17,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");
@@ -61,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;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-fast-image",
-    "version": "8.29.0",
+    "version": "8.30.1",
     "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",