Allow shape contents to have dynamic properties for its path (#2439)

Fixes #2389

lottie-compose/src/main/java/com/airbnb/lottie/compose/LottieDynamicProperties.kt

@@ -2,6 +2,7 @@ package com.airbnb.lottie.compose
 
 import android.graphics.Bitmap
 import android.graphics.ColorFilter
+import android.graphics.Path
 import android.graphics.PointF
 import android.graphics.Typeface
 import androidx.compose.runtime.Composable
@@ -102,6 +103,7 @@ class LottieDynamicProperties internal constructor(
     private val typefaceProperties: List<LottieDynamicProperty<Typeface>>,
     private val bitmapProperties: List<LottieDynamicProperty<Bitmap>>,
     private val charSequenceProperties: List<LottieDynamicProperty<CharSequence>>,
+    private val pathProperties: List<LottieDynamicProperty<Path>>,
 ) {
     @Suppress("UNCHECKED_CAST")
     constructor(properties: List<LottieDynamicProperty<*>>) : this(
@@ -114,6 +116,7 @@ class LottieDynamicProperties internal constructor(
         properties.filter { it.property is Typeface } as List<LottieDynamicProperty<Typeface>>,
         properties.filter { it.property is Bitmap } as List<LottieDynamicProperty<Bitmap>>,
         properties.filter { it.property is CharSequence } as List<LottieDynamicProperty<CharSequence>>,
+        properties.filter { it.property is Path } as List<LottieDynamicProperty<Path>>,
     )
 
     internal fun addTo(drawable: LottieDrawable) {
@@ -144,6 +147,9 @@ class LottieDynamicProperties internal constructor(
         charSequenceProperties.forEach { p ->
             drawable.addValueCallback(p.keyPath, p.property, p.callback.toValueCallback())
         }
+        pathProperties.forEach { p ->
+            drawable.addValueCallback(p.keyPath, p.property, p.callback.toValueCallback())
+        }
     }
 
     internal fun removeFrom(drawable: LottieDrawable) {
@@ -174,11 +180,14 @@ class LottieDynamicProperties internal constructor(
         charSequenceProperties.forEach { p ->
             drawable.addValueCallback(p.keyPath, p.property, null as LottieValueCallback<CharSequence>?)
         }
+        pathProperties.forEach { p ->
+            drawable.addValueCallback(p.keyPath, p.property, null as LottieValueCallback<Path>?)
+        }
     }
 }
 
 private fun <T> ((frameInfo: LottieFrameInfo<T>) -> T).toValueCallback() = object : LottieValueCallback<T>() {
     override fun getValue(frameInfo: LottieFrameInfo<T>): T {
         return invoke(frameInfo)
     }
-}
+}

lottie/src/main/java/com/airbnb/lottie/LottieProperty.java

@@ -2,6 +2,7 @@
 
 import android.graphics.Bitmap;
 import android.graphics.ColorFilter;
+import android.graphics.Path;
 import android.graphics.PointF;
 import android.graphics.Typeface;
 
@@ -220,4 +221,15 @@ public interface LottieProperty {
    * Replace the text for a text layer.
    */
   CharSequence TEXT = "dynamic_text";
+
+  /**
+   * Replace a path. This can only be used on path contents. For other shapes such as rectangles and polystars,
+   * use LottieProperties corresponding to their specific properties.
+   * <p>
+   * If you need to do any operations on the path such as morphing, use the Jetpack androidx.graphics.path library.
+   * <p>
+   * In After Effects, any of those other shapes can be converted to a bezier path by right clicking it and
+   * selecting "Convert To Bezier Path".
+   */
+  Path PATH = new Path();
 }

lottie/src/main/java/com/airbnb/lottie/animation/content/ShapeContent.java

@@ -5,16 +5,20 @@
 import androidx.annotation.Nullable;
 
 import com.airbnb.lottie.LottieDrawable;
+import com.airbnb.lottie.LottieProperty;
 import com.airbnb.lottie.animation.keyframe.BaseKeyframeAnimation;
 import com.airbnb.lottie.animation.keyframe.ShapeKeyframeAnimation;
+import com.airbnb.lottie.model.KeyPath;
 import com.airbnb.lottie.model.content.ShapePath;
 import com.airbnb.lottie.model.content.ShapeTrimPath;
 import com.airbnb.lottie.model.layer.BaseLayer;
+import com.airbnb.lottie.utils.MiscUtils;
+import com.airbnb.lottie.value.LottieValueCallback;
 
 import java.util.ArrayList;
 import java.util.List;
 
-public class ShapeContent implements PathContent, BaseKeyframeAnimation.AnimationListener {
+public class ShapeContent implements PathContent, BaseKeyframeAnimation.AnimationListener, KeyPathElementContent {
   private final Path path = new Path();
 
   private final String name;
@@ -65,7 +69,7 @@ private void invalidate() {
   }
 
   @Override public Path getPath() {
-    if (isPathValid) {
+    if (isPathValid && !shapeAnimation.hasValueCallback()) {
       return path;
     }
 
@@ -94,4 +98,17 @@ private void invalidate() {
   @Override public String getName() {
     return name;
   }
+
+  @Override public void resolveKeyPath(
+      KeyPath keyPath, int depth, List<KeyPath> accumulator, KeyPath currentPartialKeyPath) {
+    MiscUtils.resolveKeyPath(keyPath, depth, accumulator, currentPartialKeyPath, this);
+  }
+
+  @SuppressWarnings("unchecked")
+  @Override
+  public <T> void addValueCallback(T property, @Nullable LottieValueCallback<T> callback) {
+    if (property == LottieProperty.PATH) {
+      shapeAnimation.setValueCallback((LottieValueCallback<Path>) callback);
+    }
+  }
 }

lottie/src/main/java/com/airbnb/lottie/animation/keyframe/BaseKeyframeAnimation.java

@@ -168,6 +168,10 @@ public void setValueCallback(@Nullable LottieValueCallback<A> valueCallback) {
     }
   }
 
+  public boolean hasValueCallback() {
+    return valueCallback != null;
+  }
+
   /**
    * keyframeProgress will be [0, 1] unless the interpolator has overshoot in which case, this
    * should be able to handle values outside of that range.

lottie/src/main/java/com/airbnb/lottie/animation/keyframe/ShapeKeyframeAnimation.java

@@ -14,6 +14,8 @@
 public class ShapeKeyframeAnimation extends BaseKeyframeAnimation<ShapeData, Path> {
   private final ShapeData tempShapeData = new ShapeData();
   private final Path tempPath = new Path();
+  private Path valueCallbackStartPath;
+  private Path valueCallbackEndPath;
 
   private List<ShapeModifierContent> shapeModifiers;
 
@@ -33,6 +35,20 @@ public ShapeKeyframeAnimation(List<Keyframe<ShapeData>> keyframes) {
       }
     }
     MiscUtils.getPathFromData(modifiedShapeData, tempPath);
+    if (valueCallback != null) {
+      if (valueCallbackStartPath == null) {
+        valueCallbackStartPath = new Path();
+        valueCallbackEndPath = new Path();
+      }
+      MiscUtils.getPathFromData(startShapeData, valueCallbackStartPath);
+      if (endShapeData != null) {
+        MiscUtils.getPathFromData(endShapeData, valueCallbackEndPath);
+      }
+
+      return valueCallback.getValueInternal(keyframe.startFrame, keyframe.endFrame,
+          valueCallbackStartPath, endShapeData ==  null ? valueCallbackStartPath : valueCallbackEndPath,
+          keyframeProgress, getLinearCurrentKeyframeProgress(), getProgress());
+    }
     return tempPath;
   }