@quicktvui/ai 1.0.7 → 1.0.9

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/animation/keyframe/BaseKeyframeAnimation.java

@@ -0,0 +1,356 @@
+package quicktvui.support.lottie.animation.keyframe;
+
+import android.support.annotation.FloatRange;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import quicktvui.support.lottie.L;
+import quicktvui.support.lottie.value.Keyframe;
+import quicktvui.support.lottie.value.LottieValueCallback;
+
+/**
+ * @param <K> Keyframe type
+ * @param <A> Animation type
+ */
+public abstract class BaseKeyframeAnimation<K, A> {
+  public interface AnimationListener {
+    void onValueChanged();
+  }
+
+  // This is not a Set because we don't want to create an iterator object on every setProgress.
+  final List<AnimationListener> listeners = new ArrayList<>(1);
+  private boolean isDiscrete = false;
+
+  private final KeyframesWrapper<K> keyframesWrapper;
+  protected float progress = 0f;
+  @Nullable protected LottieValueCallback<A> valueCallback;
+
+  @Nullable private A cachedGetValue = null;
+
+  private float cachedStartDelayProgress = -1f;
+  private float cachedEndProgress = -1f;
+
+  BaseKeyframeAnimation(List<? extends Keyframe<K>> keyframes) {
+    keyframesWrapper = wrap(keyframes);
+  }
+
+  public void setIsDiscrete() {
+    isDiscrete = true;
+  }
+
+  public void addUpdateListener(AnimationListener listener) {
+    listeners.add(listener);
+  }
+
+  public void setProgress(@FloatRange(from = 0f, to = 1f) float progress) {
+    L.beginSection("BaseKeyframeAnimation#setProgress");
+    if (keyframesWrapper.isEmpty()) {
+      L.endSection("BaseKeyframeAnimation#setProgress");
+      return;
+    }
+    if (progress < getStartDelayProgress()) {
+      progress = getStartDelayProgress();
+    } else if (progress > getEndProgress()) {
+      progress = getEndProgress();
+    }
+
+    if (progress == this.progress) {
+      L.endSection("BaseKeyframeAnimation#setProgress");
+      return;
+    }
+    this.progress = progress;
+    if (keyframesWrapper.isValueChanged(progress)) {
+      notifyListeners();
+    }
+    L.endSection("BaseKeyframeAnimation#setProgress");
+  }
+
+  public void notifyListeners() {
+    L.beginSection("BaseKeyframeAnimation#notifyListeners");
+    for (int i = 0; i < listeners.size(); i++) {
+      listeners.get(i).onValueChanged();
+    }
+    L.endSection("BaseKeyframeAnimation#notifyListeners");
+  }
+
+  protected Keyframe<K> getCurrentKeyframe() {
+    L.beginSection("BaseKeyframeAnimation#getCurrentKeyframe");
+    final Keyframe<K> keyframe = keyframesWrapper.getCurrentKeyframe();
+    L.endSection("BaseKeyframeAnimation#getCurrentKeyframe");
+    return keyframe;
+  }
+
+  /**
+   * Returns the progress into the current keyframe between 0 and 1. This does not take into account
+   * any interpolation that the keyframe may have.
+   */
+  float getLinearCurrentKeyframeProgress() {
+    if (isDiscrete) {
+      return 0f;
+    }
+
+    Keyframe<K> keyframe = getCurrentKeyframe();
+    if (keyframe.isStatic()) {
+      return 0f;
+    }
+    float progressIntoFrame = progress - keyframe.getStartProgress();
+    float keyframeProgress = keyframe.getEndProgress() - keyframe.getStartProgress();
+    return progressIntoFrame / keyframeProgress;
+  }
+
+  /**
+   * Takes the value of {@link #getLinearCurrentKeyframeProgress()} and interpolates it with
+   * the current keyframe's interpolator.
+   */
+  protected float getInterpolatedCurrentKeyframeProgress() {
+    Keyframe<K> keyframe = getCurrentKeyframe();
+    // Keyframe should not be null here but there seems to be a Xiaomi Android 10 specific crash.
+    // https://github.com/airbnb/lottie-android/issues/2050
+    if (keyframe == null || keyframe.isStatic()) {
+      return 0f;
+    }
+    //noinspection ConstantConditions
+    return keyframe.interpolator.getInterpolation(getLinearCurrentKeyframeProgress());
+  }
+
+  @FloatRange(from = 0f, to = 1f)
+  private float getStartDelayProgress() {
+    if (cachedStartDelayProgress == -1f) {
+      cachedStartDelayProgress = keyframesWrapper.getStartDelayProgress();
+    }
+    return cachedStartDelayProgress;
+  }
+
+  @FloatRange(from = 0f, to = 1f)
+  float getEndProgress() {
+    if (cachedEndProgress == -1f) {
+      cachedEndProgress = keyframesWrapper.getEndProgress();
+    }
+    return cachedEndProgress;
+  }
+
+  public A getValue() {
+    A value;
+
+    float linearProgress = getLinearCurrentKeyframeProgress();
+    if (valueCallback == null && keyframesWrapper.isCachedValueEnabled(linearProgress)) {
+      return cachedGetValue;
+    }
+    final Keyframe<K> keyframe = getCurrentKeyframe();
+
+    if (keyframe.xInterpolator != null && keyframe.yInterpolator != null) {
+      float xProgress = keyframe.xInterpolator.getInterpolation(linearProgress);
+      float yProgress = keyframe.yInterpolator.getInterpolation(linearProgress);
+      value = getValue(keyframe, linearProgress, xProgress, yProgress);
+    } else {
+      float progress = getInterpolatedCurrentKeyframeProgress();
+      value = getValue(keyframe, progress);
+    }
+
+    cachedGetValue = value;
+    return value;
+  }
+
+  public float getProgress() {
+    return progress;
+  }
+
+  public void setValueCallback(@Nullable LottieValueCallback<A> valueCallback) {
+    if (this.valueCallback != null) {
+      this.valueCallback.setAnimation(null);
+    }
+    this.valueCallback = valueCallback;
+    if (valueCallback != null) {
+      valueCallback.setAnimation(this);
+    }
+  }
+
+  /**
+   * keyframeProgress will be [0, 1] unless the interpolator has overshoot in which case, this
+   * should be able to handle values outside of that range.
+   */
+  abstract A getValue(Keyframe<K> keyframe, float keyframeProgress);
+
+  /**
+   * Similar to {@link #getValue(Keyframe, float)} but used when an animation has separate interpolators for the X and Y axis.
+   */
+  protected A getValue(Keyframe<K> keyframe, float linearKeyframeProgress, float xKeyframeProgress, float yKeyframeProgress) {
+    throw new UnsupportedOperationException("This animation does not support split dimensions!");
+  }
+
+  private static <T> KeyframesWrapper<T> wrap(List<? extends Keyframe<T>> keyframes) {
+    if (keyframes.isEmpty()) {
+      return new EmptyKeyframeWrapper<>();
+    }
+    if (keyframes.size() == 1) {
+      return new SingleKeyframeWrapper<>(keyframes);
+    }
+    return new KeyframesWrapperImpl<>(keyframes);
+  }
+
+  private interface KeyframesWrapper<T> {
+    boolean isEmpty();
+
+    boolean isValueChanged(float progress);
+
+    Keyframe<T> getCurrentKeyframe();
+
+    @FloatRange(from = 0f, to = 1f)
+    float getStartDelayProgress();
+
+    @FloatRange(from = 0f, to = 1f)
+    float getEndProgress();
+
+    boolean isCachedValueEnabled(float progress);
+  }
+
+  private static final class EmptyKeyframeWrapper<T> implements KeyframesWrapper<T> {
+    @Override
+    public boolean isEmpty() {
+      return true;
+    }
+
+    @Override
+    public boolean isValueChanged(float progress) {
+      return false;
+    }
+
+    @Override
+    public Keyframe<T> getCurrentKeyframe() {
+      throw new IllegalStateException("not implemented");
+    }
+
+    @Override
+    public float getStartDelayProgress() {
+      return 0f;
+    }
+
+    @Override
+    public float getEndProgress() {
+      return 1f;
+    }
+
+    @Override
+    public boolean isCachedValueEnabled(float progress) {
+      throw new IllegalStateException("not implemented");
+    }
+  }
+
+  private static final class SingleKeyframeWrapper<T> implements KeyframesWrapper<T> {
+    @NonNull
+    private final Keyframe<T> keyframe;
+    private float cachedInterpolatedProgress = -1f;
+
+    SingleKeyframeWrapper(List<? extends Keyframe<T>> keyframes) {
+      this.keyframe = keyframes.get(0);
+    }
+
+    @Override
+    public boolean isEmpty() {
+      return false;
+    }
+
+    @Override
+    public boolean isValueChanged(float progress) {
+      return !keyframe.isStatic();
+    }
+
+    @Override
+    public Keyframe<T> getCurrentKeyframe() {
+      return keyframe;
+    }
+
+    @Override
+    public float getStartDelayProgress() {
+      return keyframe.getStartProgress();
+    }
+
+    @Override
+    public float getEndProgress() {
+      return keyframe.getEndProgress();
+    }
+
+    @Override
+    public boolean isCachedValueEnabled(float progress) {
+      if (cachedInterpolatedProgress == progress) {
+        return true;
+      }
+      cachedInterpolatedProgress = progress;
+      return false;
+    }
+  }
+
+  private static final class KeyframesWrapperImpl<T> implements KeyframesWrapper<T> {
+    private final List<? extends Keyframe<T>> keyframes;
+    @NonNull
+    private Keyframe<T> currentKeyframe;
+    private Keyframe<T> cachedCurrentKeyframe = null;
+    private float cachedInterpolatedProgress = -1f;
+
+    KeyframesWrapperImpl(List<? extends Keyframe<T>> keyframes) {
+      this.keyframes = keyframes;
+      currentKeyframe = findKeyframe(0);
+    }
+
+    @Override
+    public boolean isEmpty() {
+      return false;
+    }
+
+    @Override
+    public boolean isValueChanged(float progress) {
+      if (currentKeyframe.containsProgress(progress)) {
+        return !currentKeyframe.isStatic();
+      }
+      currentKeyframe = findKeyframe(progress);
+      return true;
+    }
+
+    private Keyframe<T> findKeyframe(float progress) {
+      Keyframe<T> keyframe = keyframes.get(keyframes.size() - 1);
+      if (progress >= keyframe.getStartProgress()) {
+        return keyframe;
+      }
+      for (int i = keyframes.size() - 2; i >= 1; i--) {
+        keyframe = keyframes.get(i);
+        if (currentKeyframe == keyframe) {
+          continue;
+        }
+        if (keyframe.containsProgress(progress)) {
+          return keyframe;
+        }
+      }
+      return keyframes.get(0);
+    }
+
+    @Override
+    @NonNull
+    public Keyframe<T> getCurrentKeyframe() {
+      return currentKeyframe;
+    }
+
+    @Override
+    public float getStartDelayProgress() {
+      return keyframes.get(0).getStartProgress();
+    }
+
+    @Override
+    public float getEndProgress() {
+      return keyframes.get(keyframes.size() - 1).getEndProgress();
+    }
+
+    @Override
+    public boolean isCachedValueEnabled(float progress) {
+      if (cachedCurrentKeyframe == currentKeyframe
+          && cachedInterpolatedProgress == progress) {
+        return true;
+      }
+      cachedCurrentKeyframe = currentKeyframe;
+      cachedInterpolatedProgress = progress;
+      return false;
+    }
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/animation/keyframe/ColorKeyframeAnimation.java

@@ -0,0 +1,46 @@
+package quicktvui.support.lottie.animation.keyframe;
+
+import java.util.List;
+
+import quicktvui.support.lottie.utils.GammaEvaluator;
+import quicktvui.support.lottie.utils.MiscUtils;
+import quicktvui.support.lottie.value.Keyframe;
+
+public class ColorKeyframeAnimation extends KeyframeAnimation<Integer> {
+
+  public ColorKeyframeAnimation(List<Keyframe<Integer>> keyframes) {
+    super(keyframes);
+  }
+
+  @Override
+  Integer getValue(Keyframe<Integer> keyframe, float keyframeProgress) {
+    return getIntValue(keyframe, keyframeProgress);
+  }
+
+  /**
+   * Optimization to avoid autoboxing.
+   */
+  public int getIntValue(Keyframe<Integer> keyframe, float keyframeProgress) {
+    if (keyframe.startValue == null || keyframe.endValue == null) {
+      throw new IllegalStateException("Missing values for keyframe.");
+    }
+
+    if (valueCallback != null) {
+      //noinspection ConstantConditions
+      Integer value = valueCallback.getValueInternal(keyframe.startFrame, keyframe.endFrame, keyframe.startValue,
+          keyframe.endValue, keyframeProgress, getLinearCurrentKeyframeProgress(), getProgress());
+      if (value != null) {
+        return value;
+      }
+    }
+
+    return GammaEvaluator.evaluate(MiscUtils.clamp(keyframeProgress, 0f, 1f), keyframe.startValue, keyframe.endValue);
+  }
+
+  /**
+   * Optimization to avoid autoboxing.
+   */
+  public int getIntValue() {
+    return getIntValue(getCurrentKeyframe(), getInterpolatedCurrentKeyframeProgress());
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/animation/keyframe/DropShadowKeyframeAnimation.java

@@ -0,0 +1,100 @@
+package quicktvui.support.lottie.animation.keyframe;
+
+import android.graphics.Color;
+import android.graphics.Paint;
+
+import android.support.annotation.Nullable;
+
+import quicktvui.support.lottie.model.layer.BaseLayer;
+import quicktvui.support.lottie.parser.DropShadowEffect;
+import quicktvui.support.lottie.value.LottieFrameInfo;
+import quicktvui.support.lottie.value.LottieValueCallback;
+
+public class DropShadowKeyframeAnimation implements BaseKeyframeAnimation.AnimationListener {
+  private static final double DEG_TO_RAD = Math.PI / 180.0;
+
+  private final BaseKeyframeAnimation.AnimationListener listener;
+  private final BaseKeyframeAnimation<Integer, Integer> color;
+  private final BaseKeyframeAnimation<Float, Float> opacity;
+  private final BaseKeyframeAnimation<Float, Float> direction;
+  private final BaseKeyframeAnimation<Float, Float> distance;
+  private final BaseKeyframeAnimation<Float, Float> radius;
+
+  private boolean isDirty = true;
+
+  public DropShadowKeyframeAnimation(BaseKeyframeAnimation.AnimationListener listener, BaseLayer layer, DropShadowEffect dropShadowEffect) {
+    this.listener = listener;
+    color = dropShadowEffect.getColor().createAnimation();
+    color.addUpdateListener(this);
+    layer.addAnimation(color);
+    opacity = dropShadowEffect.getOpacity().createAnimation();
+    opacity.addUpdateListener(this);
+    layer.addAnimation(opacity);
+    direction = dropShadowEffect.getDirection().createAnimation();
+    direction.addUpdateListener(this);
+    layer.addAnimation(direction);
+    distance = dropShadowEffect.getDistance().createAnimation();
+    distance.addUpdateListener(this);
+    layer.addAnimation(distance);
+    radius = dropShadowEffect.getRadius().createAnimation();
+    radius.addUpdateListener(this);
+    layer.addAnimation(radius);
+  }
+
+  @Override public void onValueChanged() {
+    isDirty = true;
+    listener.onValueChanged();
+  }
+
+  public void applyTo(Paint paint) {
+    if (!isDirty) {
+      return;
+    }
+    isDirty = false;
+
+    double directionRad = ((double) direction.getValue()) * DEG_TO_RAD;
+    float distance = this.distance.getValue();
+    float x = ((float) Math.sin(directionRad)) * distance;
+    float y = ((float) Math.cos(directionRad + Math.PI)) * distance;
+    int baseColor = color.getValue();
+    int opacity = Math.round(this.opacity.getValue());
+    int color = Color.argb(opacity, Color.red(baseColor), Color.green(baseColor), Color.blue(baseColor));
+    float radius = this.radius.getValue();
+    paint.setShadowLayer(radius, x, y, color);
+  }
+
+  public void setColorCallback(@Nullable LottieValueCallback<Integer> callback) {
+   color.setValueCallback(callback);
+  }
+
+  public void setOpacityCallback(@Nullable final LottieValueCallback<Float> callback) {
+    if (callback == null) {
+      opacity.setValueCallback(null);
+      return;
+    }
+    opacity.setValueCallback(new LottieValueCallback<Float>() {
+      @Nullable
+      @Override
+      public Float getValue(LottieFrameInfo<Float> frameInfo) {
+        Float value = callback.getValue(frameInfo);
+        if (value == null) {
+          return null;
+        }
+        // Convert [0,100] to [0,255] because other dynamic properties use [0,100].
+        return value * 2.55f;
+      }
+    });
+  }
+
+  public void setDirectionCallback(@Nullable LottieValueCallback<Float> callback) {
+    direction.setValueCallback(callback);
+  }
+
+  public void setDistanceCallback(@Nullable LottieValueCallback<Float> callback) {
+    distance.setValueCallback(callback);
+  }
+
+  public void setRadiusCallback(@Nullable LottieValueCallback<Float> callback) {
+    radius.setValueCallback(callback);
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/animation/keyframe/FloatKeyframeAnimation.java

@@ -0,0 +1,45 @@
+package quicktvui.support.lottie.animation.keyframe;
+
+import java.util.List;
+
+import quicktvui.support.lottie.utils.MiscUtils;
+import quicktvui.support.lottie.value.Keyframe;
+
+public class FloatKeyframeAnimation extends KeyframeAnimation<Float> {
+
+  public FloatKeyframeAnimation(List<Keyframe<Float>> keyframes) {
+    super(keyframes);
+  }
+
+  @Override Float getValue(Keyframe<Float> keyframe, float keyframeProgress) {
+    return getFloatValue(keyframe, keyframeProgress);
+  }
+
+  /**
+   * Optimization to avoid autoboxing.
+   */
+  float getFloatValue(Keyframe<Float> keyframe, float keyframeProgress) {
+    if (keyframe.startValue == null || keyframe.endValue == null) {
+      throw new IllegalStateException("Missing values for keyframe.");
+    }
+
+    if (valueCallback != null) {
+      //noinspection ConstantConditions
+      Float value = valueCallback.getValueInternal(keyframe.startFrame, keyframe.endFrame,
+          keyframe.startValue, keyframe.endValue,
+          keyframeProgress, getLinearCurrentKeyframeProgress(), getProgress());
+      if (value != null) {
+        return value;
+      }
+    }
+
+    return MiscUtils.lerp(keyframe.getStartValueFloat(), keyframe.getEndValueFloat(), keyframeProgress);
+  }
+
+  /**
+   * Optimization to avoid autoboxing.
+   */
+  public float getFloatValue() {
+    return getFloatValue(getCurrentKeyframe(), getInterpolatedCurrentKeyframeProgress());
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/animation/keyframe/GradientColorKeyframeAnimation.java

@@ -0,0 +1,22 @@
+package quicktvui.support.lottie.animation.keyframe;
+
+import java.util.List;
+
+import quicktvui.support.lottie.model.content.GradientColor;
+import quicktvui.support.lottie.value.Keyframe;
+
+public class GradientColorKeyframeAnimation extends KeyframeAnimation<GradientColor> {
+  private final GradientColor gradientColor;
+
+  public GradientColorKeyframeAnimation(List<Keyframe<GradientColor>> keyframes) {
+    super(keyframes);
+    GradientColor startValue = keyframes.get(0).startValue;
+    int size = startValue == null ? 0 : startValue.getSize();
+    gradientColor = new GradientColor(new float[size], new int[size]);
+  }
+
+  @Override GradientColor getValue(Keyframe<GradientColor> keyframe, float keyframeProgress) {
+    gradientColor.lerp(keyframe.startValue, keyframe.endValue, keyframeProgress);
+    return gradientColor;
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/animation/keyframe/IntegerKeyframeAnimation.java

@@ -0,0 +1,46 @@
+package quicktvui.support.lottie.animation.keyframe;
+
+import java.util.List;
+
+import quicktvui.support.lottie.utils.MiscUtils;
+import quicktvui.support.lottie.value.Keyframe;
+
+public class IntegerKeyframeAnimation extends KeyframeAnimation<Integer> {
+
+  public IntegerKeyframeAnimation(List<Keyframe<Integer>> keyframes) {
+    super(keyframes);
+  }
+
+  @Override
+  Integer getValue(Keyframe<Integer> keyframe, float keyframeProgress) {
+    return getIntValue(keyframe, keyframeProgress);
+  }
+
+  /**
+   * Optimization to avoid autoboxing.
+   */
+  int getIntValue(Keyframe<Integer> keyframe, float keyframeProgress) {
+    if (keyframe.startValue == null || keyframe.endValue == null) {
+      throw new IllegalStateException("Missing values for keyframe.");
+    }
+
+    if (valueCallback != null) {
+      //noinspection ConstantConditions
+      Integer value = valueCallback.getValueInternal(keyframe.startFrame, keyframe.endFrame,
+          keyframe.startValue, keyframe.endValue,
+          keyframeProgress, getLinearCurrentKeyframeProgress(), getProgress());
+      if (value != null) {
+        return value;
+      }
+    }
+
+    return MiscUtils.lerp(keyframe.getStartValueInt(), keyframe.getEndValueInt(), keyframeProgress);
+  }
+
+  /**
+   * Optimization to avoid autoboxing.
+   */
+  public int getIntValue() {
+    return getIntValue(getCurrentKeyframe(), getInterpolatedCurrentKeyframeProgress());
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/animation/keyframe/KeyframeAnimation.java

@@ -0,0 +1,11 @@
+package quicktvui.support.lottie.animation.keyframe;
+
+import java.util.List;
+
+import quicktvui.support.lottie.value.Keyframe;
+
+abstract class KeyframeAnimation<T> extends BaseKeyframeAnimation<T, T> {
+  KeyframeAnimation(List<? extends Keyframe<T>> keyframes) {
+    super(keyframes);
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/animation/keyframe/MaskKeyframeAnimation.java

@@ -0,0 +1,40 @@
+package quicktvui.support.lottie.animation.keyframe;
+
+import android.graphics.Path;
+
+
+import java.util.ArrayList;
+import java.util.List;
+
+import quicktvui.support.lottie.model.animatable.AnimatableIntegerValue;
+import quicktvui.support.lottie.model.content.Mask;
+import quicktvui.support.lottie.model.content.ShapeData;
+
+public class MaskKeyframeAnimation {
+  private final List<BaseKeyframeAnimation<ShapeData, Path>> maskAnimations;
+  private final List<BaseKeyframeAnimation<Integer, Integer>> opacityAnimations;
+  private final List<Mask> masks;
+
+  public MaskKeyframeAnimation(List<Mask> masks) {
+    this.masks = masks;
+    this.maskAnimations = new ArrayList<>(masks.size());
+    this.opacityAnimations = new ArrayList<>(masks.size());
+    for (int i = 0; i < masks.size(); i++) {
+      this.maskAnimations.add(masks.get(i).getMaskPath().createAnimation());
+      AnimatableIntegerValue opacity = masks.get(i).getOpacity();
+      opacityAnimations.add(opacity.createAnimation());
+    }
+  }
+
+  public List<Mask> getMasks() {
+    return masks;
+  }
+
+  public List<BaseKeyframeAnimation<ShapeData, Path>> getMaskAnimations() {
+    return maskAnimations;
+  }
+
+  public List<BaseKeyframeAnimation<Integer, Integer>> getOpacityAnimations() {
+    return opacityAnimations;
+  }
+}