Implement setting loop counts for animated images

Reviewed By: kartavya-ramnani

Differential Revision: D78413066

fbshipit-source-id: de8cf75054665d4a73189ec9fa9d8ede1942eb1d

Author: Andy-Wu25

animated-base/src/main/java/com/facebook/fresco/animation/factory/DefaultBitmapAnimationDrawableFactory.java

@@ -37,6 +37,7 @@
 import com.facebook.fresco.animation.drawable.AnimatedDrawable2;
 import com.facebook.fresco.animation.drawable.KAnimatedDrawable2;
 import com.facebook.fresco.middleware.HasExtraData;
+import com.facebook.fresco.vito.options.AnimatedOptions;
 import com.facebook.fresco.vito.options.ImageOptions;
 import com.facebook.fresco.vito.options.ImageOptionsDrawableFactory;
 import com.facebook.fresco.vito.options.RoundingOptions;
@@ -196,6 +197,11 @@ private AnimationBackend createAnimationBackend(
       roundingOptions = imageOptions.getRoundingOptions();
     }
 
+    AnimatedOptions animatedOptions = null;
+    if (imageOptions != null) {
+      animatedOptions = imageOptions.getAnimatedOptions();
+    }
+
     if (mUseNewBitmapRender.get()) {
       bitmapFramePreparationStrategy =
           new FrameLoaderStrategy(
@@ -218,7 +224,8 @@ private AnimationBackend createAnimationBackend(
             mUseNewBitmapRender.get(),
             bitmapFramePreparationStrategy,
             bitmapFramePreparer,
-            roundingOptions);
+            roundingOptions,
+            animatedOptions);
 
     return AnimationBackendDelegateWithInactivityCheck.createForBackend(
         bitmapAnimationBackend, mMonotonicClock, mScheduledExecutorServiceForUiThread);

animated-drawable/src/main/java/com/facebook/fresco/animation/bitmap/BitmapAnimationBackend.kt

@@ -27,6 +27,7 @@ import com.facebook.fresco.animation.backend.AnimationBackendDelegateWithInactiv
 import com.facebook.fresco.animation.backend.AnimationInformation
 import com.facebook.fresco.animation.bitmap.preparation.BitmapFramePreparationStrategy
 import com.facebook.fresco.animation.bitmap.preparation.BitmapFramePreparer
+import com.facebook.fresco.vito.options.AnimatedOptions
 import com.facebook.fresco.vito.options.RoundingOptions
 import com.facebook.imagepipeline.bitmaps.PlatformBitmapFactory
 
@@ -38,7 +39,9 @@ import com.facebook.imagepipeline.bitmaps.PlatformBitmapFactory
  * [BitmapFrameRenderer] is used to render frames to the bitmaps acquired from the
  * [BitmapFrameCache].
  */
-class BitmapAnimationBackend(
+class BitmapAnimationBackend
+@JvmOverloads
+constructor(
     private val platformBitmapFactory: PlatformBitmapFactory,
     private val bitmapFrameCache: BitmapFrameCache,
     private val animationInformation: AnimationInformation,
@@ -47,6 +50,7 @@ class BitmapAnimationBackend(
     private val bitmapFramePreparationStrategy: BitmapFramePreparationStrategy?,
     private val bitmapFramePreparer: BitmapFramePreparer?,
     roundingOptions: RoundingOptions? = null,
+    private val animatedOptions: AnimatedOptions? = null,
 ) : AnimationBackend, InactivityListener {
 
   private val isCircular: Boolean = roundingOptions?.isCircular == true
@@ -135,7 +139,18 @@ class BitmapAnimationBackend(
 
   override fun getLoopDurationMs(): Int = animationInformation.loopDurationMs
 
-  override fun getLoopCount(): Int = animationInformation.loopCount
+  override fun getLoopCount(): Int {
+    // If no animated options are set, use the default loop count
+    if (animatedOptions == null) {
+      return animationInformation.loopCount
+    }
+
+    return when (animatedOptions.loopCount) {
+      AnimatedOptions.LOOP_COUNT_INFINITE -> AnimationInformation.LOOP_COUNT_INFINITE
+      AnimatedOptions.LOOP_COUNT_STATIC -> 1
+      else -> animatedOptions.loopCount
+    }
+  }
 
   override fun drawFrame(parent: Drawable, canvas: Canvas, frameNumber: Int): Boolean {
     frameListener?.onDrawFrameStart(this, frameNumber)

vito/options/src/main/java/com/facebook/fresco/vito/options/AnimatedOptions.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.fresco.vito.options
+
+@Suppress("KtDataClass")
+data class AnimatedOptions(
+    val loopCount: Int,
+) {
+
+  fun isInfinite(): Boolean = loopCount == LOOP_COUNT_INFINITE
+
+  fun isStatic(): Boolean = loopCount == LOOP_COUNT_STATIC
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) {
+      return true
+    }
+    if (javaClass != other?.javaClass) {
+      return false
+    }
+
+    val otherOptions = other as? AnimatedOptions ?: return false
+
+    return loopCount == otherOptions.loopCount
+  }
+
+  override fun hashCode(): Int {
+    return loopCount.hashCode()
+  }
+
+  @Suppress("BooleanLiteralArgument")
+  companion object {
+    const val LOOP_COUNT_INFINITE: Int = 0
+    const val LOOP_COUNT_STATIC: Int = 1
+    val INFINITE: AnimatedOptions = AnimatedOptions(LOOP_COUNT_INFINITE)
+    val STATIC_FIRST_FRAME: AnimatedOptions = AnimatedOptions(LOOP_COUNT_STATIC)
+
+    @JvmStatic fun infinite(): AnimatedOptions = INFINITE
+
+    @JvmStatic fun static(): AnimatedOptions = STATIC_FIRST_FRAME
+
+    @JvmStatic fun loop(loopCount: Int): AnimatedOptions = AnimatedOptions(loopCount)
+  }
+}

vito/options/src/main/java/com/facebook/fresco/vito/options/DecodedImageOptions.kt

@@ -24,6 +24,7 @@ open class DecodedImageOptions(builder: Builder<*>) : EncodedImageOptions(builde
   val postprocessor: Postprocessor? = builder.postprocessor
   val imageDecodeOptions: ImageDecodeOptions? = builder.imageDecodeOptions
   val roundingOptions: RoundingOptions? = builder.roundingOptions
+  val animatedOptions: AnimatedOptions? = builder.animatedOptions
   val borderOptions: BorderOptions? = builder.borderOptions
   val actualImageScaleType: ScalingUtils.ScaleType = builder.actualImageScaleType
   val actualImageFocusPoint: PointF? = builder.actualFocusPoint
@@ -49,6 +50,7 @@ open class DecodedImageOptions(builder: Builder<*>) : EncodedImageOptions(builde
         !Objects.equal(postprocessor, other.postprocessor) ||
         !Objects.equal(imageDecodeOptions, other.imageDecodeOptions) ||
         !Objects.equal(roundingOptions, other.roundingOptions) ||
+        !Objects.equal(animatedOptions, other.animatedOptions) ||
         !Objects.equal(borderOptions, other.borderOptions) ||
         !Objects.equal(actualImageScaleType, other.actualImageScaleType) ||
         !Objects.equal(actualImageFocusPoint, other.actualImageFocusPoint) ||
@@ -68,6 +70,7 @@ open class DecodedImageOptions(builder: Builder<*>) : EncodedImageOptions(builde
     result = 31 * result + (postprocessor?.hashCode() ?: 0)
     result = 31 * result + (imageDecodeOptions?.hashCode() ?: 0)
     result = 31 * result + (roundingOptions?.hashCode() ?: 0)
+    result = 31 * result + (animatedOptions?.hashCode() ?: 0)
     result = 31 * result + (borderOptions?.hashCode() ?: 0)
     result = 31 * result + actualImageScaleType.hashCode()
     result = 31 * result + (actualImageFocusPoint?.hashCode() ?: 0)
@@ -88,6 +91,7 @@ open class DecodedImageOptions(builder: Builder<*>) : EncodedImageOptions(builde
           .add("postprocessor", postprocessor)
           .add("imageDecodeOptions", imageDecodeOptions)
           .add("roundingOptions", roundingOptions)
+          .add("animatedOptions", animatedOptions)
           .add("borderOptions", borderOptions)
           .add("actualImageScaleType", actualImageScaleType)
           .add("actualImageFocusPoint", actualImageFocusPoint)
@@ -103,6 +107,7 @@ open class DecodedImageOptions(builder: Builder<*>) : EncodedImageOptions(builde
     internal var postprocessor: Postprocessor? = null
     internal var imageDecodeOptions: ImageDecodeOptions? = null
     internal var roundingOptions: RoundingOptions? = null
+    internal var animatedOptions: AnimatedOptions? = null
     internal var borderOptions: BorderOptions? = null
     internal var actualImageScaleType: ScalingUtils.ScaleType = ScalingUtils.ScaleType.CENTER_CROP
     internal var actualFocusPoint: PointF? = null
@@ -120,6 +125,7 @@ open class DecodedImageOptions(builder: Builder<*>) : EncodedImageOptions(builde
       postprocessor = decodedImageOptions.postprocessor
       imageDecodeOptions = decodedImageOptions.imageDecodeOptions
       roundingOptions = decodedImageOptions.roundingOptions
+      animatedOptions = decodedImageOptions.animatedOptions
       borderOptions = decodedImageOptions.borderOptions
       actualImageScaleType = decodedImageOptions.actualImageScaleType
       actualFocusPoint = decodedImageOptions.actualImageFocusPoint
@@ -165,6 +171,16 @@ open class DecodedImageOptions(builder: Builder<*>) : EncodedImageOptions(builde
       this.roundingOptions = roundingOptions
     }
 
+    /**
+     * Set the animated options to be used or null if default animation behavior should be used.
+     *
+     * @param animatedOptions the animated options to use
+     * @return the builder
+     */
+    fun animated(animatedOptions: AnimatedOptions?): T = modify {
+      this.animatedOptions = animatedOptions
+    }
+
     fun borders(borderOptions: BorderOptions?): T = modify { this.borderOptions = borderOptions }
 
     fun scale(actualImageScaleType: ScalingUtils.ScaleType?): T = modify {