@quicktvui/ai 1.0.8 → 1.0.9

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/animation/content/RoundedCornersContent.java

@@ -0,0 +1,225 @@
+package quicktvui.support.lottie.animation.content;
+
+import android.graphics.PointF;
+
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import quicktvui.support.lottie.LottieDrawable;
+import quicktvui.support.lottie.animation.keyframe.BaseKeyframeAnimation;
+import quicktvui.support.lottie.model.CubicCurveData;
+import quicktvui.support.lottie.model.content.RoundedCorners;
+import quicktvui.support.lottie.model.content.ShapeData;
+import quicktvui.support.lottie.model.layer.BaseLayer;
+
+public class RoundedCornersContent implements ShapeModifierContent, BaseKeyframeAnimation.AnimationListener {
+  /**
+   * Copied from:
+   * https://github.com/airbnb/lottie-web/blob/bb71072a26e03f1ca993da60915860f39aae890b/player/js/utils/common.js#L47
+   */
+  private static final float ROUNDED_CORNER_MAGIC_NUMBER = 0.5519f;
+
+  private final LottieDrawable lottieDrawable;
+  private final String name;
+  private final BaseKeyframeAnimation<Float, Float> roundedCorners;
+  @Nullable private ShapeData shapeData;
+
+  public RoundedCornersContent(LottieDrawable lottieDrawable, BaseLayer layer, RoundedCorners roundedCorners) {
+    this.lottieDrawable = lottieDrawable;
+    this.name = roundedCorners.getName();
+    this.roundedCorners = roundedCorners.getCornerRadius().createAnimation();
+    layer.addAnimation(this.roundedCorners);
+    this.roundedCorners.addUpdateListener(this);
+  }
+
+  @Override public String getName() {
+    return name;
+  }
+
+  @Override public void onValueChanged() {
+    lottieDrawable.invalidateSelf();
+  }
+
+  @Override public void setContents(List<Content> contentsBefore, List<Content> contentsAfter) {
+    // Do nothing.
+  }
+
+  public BaseKeyframeAnimation<Float, Float> getRoundedCorners() {
+    return roundedCorners;
+  }
+
+  /**
+   * Rounded corner algorithm:
+   * Iterate through each vertex.
+   * If a vertex is a sharp corner, it rounds it.
+   * If a vertex has control points, it is already rounded, so it does nothing.
+   * <p>
+   * To round a vertex:
+   * Split the vertex into two.
+   * Move vertex 1 directly towards the previous vertex.
+   * Set vertex 1's in control point to itself so it is not rounded on that side.
+   * Extend vertex 1's out control point towards the original vertex.
+   * <p>
+   * Repeat for vertex 2:
+   * Move vertex 2 directly towards the next vertex.
+   * Set vertex 2's out point to itself so it is not rounded on that side.
+   * Extend vertex 2's in control point towards the original vertex.
+   * <p>
+   * The distance that the vertices and control points are moved are relative to the
+   * shape's vertex distances and the roundedness set in the animation.
+   */
+  @Override public ShapeData modifyShape(ShapeData startingShapeData) {
+    List<CubicCurveData> startingCurves = startingShapeData.getCurves();
+    if (startingCurves.size() <= 2) {
+      return startingShapeData;
+    }
+    float roundedness = roundedCorners.getValue();
+    if (roundedness == 0f) {
+      return startingShapeData;
+    }
+
+    ShapeData modifiedShapeData = getShapeData(startingShapeData);
+    modifiedShapeData.setInitialPoint(startingShapeData.getInitialPoint().x, startingShapeData.getInitialPoint().y);
+    List<CubicCurveData> modifiedCurves = modifiedShapeData.getCurves();
+    int modifiedCurvesIndex = 0;
+    boolean isClosed = startingShapeData.isClosed();
+
+    // i represents which vertex we are currently on. Refer to the docs of CubicCurveData prior to working with
+    // this code.
+    // When i == 0
+    //    vertex=ShapeData.initialPoint
+    //    inCp=if closed vertex else curves[size - 1].cp2
+    //    outCp=curves[0].cp1
+    // When i == 1
+    //    vertex=curves[0].vertex
+    //    inCp=curves[0].cp2
+    //    outCp=curves[1].cp1.
+    // When i == size - 1
+    //    vertex=curves[size - 1].vertex
+    //    inCp=curves[size - 1].cp2
+    //    outCp=if closed vertex else curves[0].cp1
+    for (int i = 0; i < startingCurves.size(); i++) {
+      CubicCurveData startingCurve = startingCurves.get(i);
+      CubicCurveData previousCurve = startingCurves.get(floorMod(i - 1, startingCurves.size()));
+      CubicCurveData previousPreviousCurve = startingCurves.get(floorMod(i - 2, startingCurves.size()));
+      PointF vertex = (i == 0 && !isClosed) ? startingShapeData.getInitialPoint() : previousCurve.getVertex();
+      PointF inPoint = (i == 0 && !isClosed) ? vertex : previousCurve.getControlPoint2();
+      PointF outPoint = startingCurve.getControlPoint1();
+      PointF previousVertex = previousPreviousCurve.getVertex();
+      PointF nextVertex = startingCurve.getVertex();
+
+      // We can't round the corner of the end of a non-closed curve.
+      boolean isEndOfCurve = !startingShapeData.isClosed() && (i == 0 && i == startingCurves.size() - 1);
+      if (inPoint.equals(vertex) && outPoint.equals(vertex) && !isEndOfCurve) {
+        // This vertex is a point. Round its corners
+        float dxToPreviousVertex = vertex.x - previousVertex.x;
+        float dyToPreviousVertex = vertex.y - previousVertex.y;
+        float dxToNextVertex = nextVertex.x - vertex.x;
+        float dyToNextVertex = nextVertex.y - vertex.y;
+
+        float dToPreviousVertex = (float) Math.hypot(dxToPreviousVertex, dyToPreviousVertex);
+        float dToNextVertex = (float) Math.hypot(dxToNextVertex, dyToNextVertex);
+
+        float previousVertexPercent = Math.min(roundedness / dToPreviousVertex, 0.5f);
+        float nextVertexPercent = Math.min(roundedness / dToNextVertex, 0.5f);
+
+        // Split the vertex into two and move each vertex towards the previous/next vertex.
+        float newVertex1X = vertex.x + (previousVertex.x - vertex.x) * previousVertexPercent;
+        float newVertex1Y = vertex.y + (previousVertex.y - vertex.y) * previousVertexPercent;
+        float newVertex2X = vertex.x + (nextVertex.x - vertex.x) * nextVertexPercent;
+        float newVertex2Y = vertex.y + (nextVertex.y - vertex.y) * nextVertexPercent;
+
+        // Extend the new vertex control point towards the original vertex.
+        float newVertex1OutPointX = newVertex1X - (newVertex1X - vertex.x) * ROUNDED_CORNER_MAGIC_NUMBER;
+        float newVertex1OutPointY = newVertex1Y - (newVertex1Y - vertex.y) * ROUNDED_CORNER_MAGIC_NUMBER;
+        float newVertex2InPointX = newVertex2X - (newVertex2X - vertex.x) * ROUNDED_CORNER_MAGIC_NUMBER;
+        float newVertex2InPointY = newVertex2Y - (newVertex2Y - vertex.y) * ROUNDED_CORNER_MAGIC_NUMBER;
+
+        // Remap vertex/in/out point to CubicCurveData.
+        // Refer to the docs for CubicCurveData for more info on the difference.
+        CubicCurveData previousCurveData = modifiedCurves.get(floorMod(modifiedCurvesIndex - 1, modifiedCurves.size()));
+        CubicCurveData currentCurveData = modifiedCurves.get(modifiedCurvesIndex);
+        previousCurveData.setControlPoint2(newVertex1X, newVertex1Y);
+        previousCurveData.setVertex(newVertex1X, newVertex1Y);
+        if (i == 0) {
+          modifiedShapeData.setInitialPoint(newVertex1X, newVertex1Y);
+        }
+        currentCurveData.setControlPoint1(newVertex1OutPointX, newVertex1OutPointY);
+        modifiedCurvesIndex++;
+
+        previousCurveData = currentCurveData;
+        currentCurveData = modifiedCurves.get(modifiedCurvesIndex);
+        previousCurveData.setControlPoint2(newVertex2InPointX, newVertex2InPointY);
+        previousCurveData.setVertex(newVertex2X, newVertex2Y);
+        currentCurveData.setControlPoint1(newVertex2X, newVertex2Y);
+        modifiedCurvesIndex++;
+      } else {
+        // This vertex is not a point. Don't modify it. Refer to the documentation above and for CubicCurveData for mapping a vertex
+        // oriented point to CubicCurveData (path segments).
+        CubicCurveData previousCurveData = modifiedCurves.get(floorMod(modifiedCurvesIndex - 1, modifiedCurves.size()));
+        CubicCurveData currentCurveData = modifiedCurves.get(modifiedCurvesIndex);
+        previousCurveData.setControlPoint2(previousCurve.getControlPoint2().x, previousCurve.getControlPoint2().y);
+        previousCurveData.setVertex(previousCurve.getVertex().x, previousCurve.getVertex().y);
+        currentCurveData.setControlPoint1(startingCurve.getControlPoint1().x, startingCurve.getControlPoint1().y);
+        modifiedCurvesIndex++;
+      }
+    }
+    return modifiedShapeData;
+  }
+
+  /**
+   * Returns a shape data with the correct number of vertices for the rounded corners shape.
+   * This just returns the object. It does not update any values within the shape.
+   */
+  @NonNull
+  private ShapeData getShapeData(ShapeData startingShapeData) {
+    List<CubicCurveData> startingCurves = startingShapeData.getCurves();
+    boolean isClosed = startingShapeData.isClosed();
+    int vertices = 0;
+    for (int i = startingCurves.size() - 1; i >= 0; i--) {
+      CubicCurveData startingCurve = startingCurves.get(i);
+      CubicCurveData previousCurve = startingCurves.get(floorMod(i - 1, startingCurves.size()));
+      PointF vertex = (i == 0 && !isClosed) ? startingShapeData.getInitialPoint() : previousCurve.getVertex();
+      PointF inPoint = (i == 0 && !isClosed) ? vertex : previousCurve.getControlPoint2();
+      PointF outPoint = startingCurve.getControlPoint1();
+
+      boolean isEndOfCurve = !startingShapeData.isClosed() && (i == 0 && i == startingCurves.size() - 1);
+      if (inPoint.equals(vertex) && outPoint.equals(vertex) && !isEndOfCurve) {
+        vertices += 2;
+      } else {
+        vertices += 1;
+      }
+    }
+    if (shapeData == null || shapeData.getCurves().size() != vertices) {
+      List<CubicCurveData> newCurves = new ArrayList<>(vertices);
+      for (int i = 0; i < vertices; i++) {
+        newCurves.add(new CubicCurveData());
+      }
+      shapeData = new ShapeData(new PointF(0f, 0f), false, newCurves);
+    }
+    shapeData.setClosed(isClosed);
+    return shapeData;
+  }
+
+  /**
+   * Copied from the API 24+ AOSP source.
+   */
+  private static int floorMod(int x, int y) {
+    return x - floorDiv(x, y) * y;
+  }
+
+  /**
+   * Copied from the API 24+ AOSP source.
+   */
+  private static int floorDiv(int x, int y) {
+    int r = x / y;
+    // if the signs are different and modulo not zero, round down
+    if ((x ^ y) < 0 && (r * y != x)) {
+      r--;
+    }
+    return r;
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/animation/content/ShapeContent.java

@@ -0,0 +1,98 @@
+package quicktvui.support.lottie.animation.content;
+
+import android.graphics.Path;
+
+import android.support.annotation.Nullable;
+
+
+import java.util.ArrayList;
+import java.util.List;
+
+import quicktvui.support.lottie.LottieDrawable;
+import quicktvui.support.lottie.animation.keyframe.BaseKeyframeAnimation;
+import quicktvui.support.lottie.animation.keyframe.ShapeKeyframeAnimation;
+import quicktvui.support.lottie.model.content.ShapePath;
+import quicktvui.support.lottie.model.content.ShapeTrimPath;
+import quicktvui.support.lottie.model.layer.BaseLayer;
+
+public class ShapeContent implements PathContent, BaseKeyframeAnimation.AnimationListener {
+  private final Path path = new Path();
+
+  private final String name;
+  private final boolean hidden;
+  private final LottieDrawable lottieDrawable;
+  private final ShapeKeyframeAnimation shapeAnimation;
+  @Nullable private List<ShapeModifierContent> shapeModifierContents;
+
+  private boolean isPathValid;
+  private final CompoundTrimPathContent trimPaths = new CompoundTrimPathContent();
+
+  public ShapeContent(LottieDrawable lottieDrawable, BaseLayer layer, ShapePath shape) {
+    name = shape.getName();
+    hidden = shape.isHidden();
+    this.lottieDrawable = lottieDrawable;
+    shapeAnimation = shape.getShapePath().createAnimation();
+    layer.addAnimation(shapeAnimation);
+    shapeAnimation.addUpdateListener(this);
+  }
+
+  @Override public void onValueChanged() {
+    invalidate();
+  }
+
+  private void invalidate() {
+    isPathValid = false;
+    lottieDrawable.invalidateSelf();
+  }
+
+  @Override public void setContents(List<Content> contentsBefore, List<Content> contentsAfter) {
+    @Nullable List<ShapeModifierContent> shapeModifierContents = null;
+    for (int i = 0; i < contentsBefore.size(); i++) {
+      Content content = contentsBefore.get(i);
+      if (content instanceof TrimPathContent &&
+          ((TrimPathContent) content).getType() == ShapeTrimPath.Type.SIMULTANEOUSLY) {
+        // Trim path individually will be handled by the stroke where paths are combined.
+        TrimPathContent trimPath = (TrimPathContent) content;
+        trimPaths.addTrimPath(trimPath);
+        trimPath.addListener(this);
+      } else if (content instanceof ShapeModifierContent) {
+        if (shapeModifierContents == null) {
+          shapeModifierContents = new ArrayList<>();
+        }
+        shapeModifierContents.add((ShapeModifierContent) content);
+      }
+    }
+    shapeAnimation.setShapeModifiers(shapeModifierContents);
+  }
+
+  @Override public Path getPath() {
+    if (isPathValid) {
+      return path;
+    }
+
+    path.reset();
+
+    if (hidden) {
+      isPathValid = true;
+      return path;
+    }
+
+    Path shapeAnimationPath = shapeAnimation.getValue();
+    if (shapeAnimationPath == null) {
+      // It is unclear why this ever returns null but it seems to in rare cases.
+      // https://github.com/airbnb/lottie-android/issues/1632
+      return path;
+    }
+    path.set(shapeAnimationPath);
+    path.setFillType(Path.FillType.EVEN_ODD);
+
+    trimPaths.apply(path);
+
+    isPathValid = true;
+    return path;
+  }
+
+  @Override public String getName() {
+    return name;
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/animation/content/ShapeModifierContent.java

@@ -0,0 +1,7 @@
+package quicktvui.support.lottie.animation.content;
+
+import quicktvui.support.lottie.model.content.ShapeData;
+
+public interface ShapeModifierContent extends Content {
+  ShapeData modifyShape(ShapeData shapeData);
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/animation/content/StrokeContent.java

@@ -0,0 +1,77 @@
+package quicktvui.support.lottie.animation.content;
+
+import static quicktvui.support.lottie.LottieProperty.STROKE_COLOR;
+
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Matrix;
+
+import android.support.annotation.Nullable;
+
+import quicktvui.support.lottie.LottieDrawable;
+import quicktvui.support.lottie.LottieProperty;
+import quicktvui.support.lottie.animation.keyframe.BaseKeyframeAnimation;
+import quicktvui.support.lottie.animation.keyframe.ColorKeyframeAnimation;
+import quicktvui.support.lottie.animation.keyframe.ValueCallbackKeyframeAnimation;
+import quicktvui.support.lottie.model.content.ShapeStroke;
+import quicktvui.support.lottie.model.layer.BaseLayer;
+import quicktvui.support.lottie.value.LottieValueCallback;
+
+
+public class StrokeContent extends BaseStrokeContent {
+
+  private final BaseLayer layer;
+  private final String name;
+  private final boolean hidden;
+  private final BaseKeyframeAnimation<Integer, Integer> colorAnimation;
+  @Nullable private BaseKeyframeAnimation<ColorFilter, ColorFilter> colorFilterAnimation;
+
+  public StrokeContent(final LottieDrawable lottieDrawable, BaseLayer layer, ShapeStroke stroke) {
+    super(lottieDrawable, layer, stroke.getCapType().toPaintCap(),
+        stroke.getJoinType().toPaintJoin(), stroke.getMiterLimit(), stroke.getOpacity(),
+        stroke.getWidth(), stroke.getLineDashPattern(), stroke.getDashOffset());
+    this.layer = layer;
+    name = stroke.getName();
+    hidden = stroke.isHidden();
+    colorAnimation = stroke.getColor().createAnimation();
+    colorAnimation.addUpdateListener(this);
+    layer.addAnimation(colorAnimation);
+  }
+
+  @Override public void draw(Canvas canvas, Matrix parentMatrix, int parentAlpha) {
+    if (hidden) {
+      return;
+    }
+    paint.setColor(((ColorKeyframeAnimation) colorAnimation).getIntValue());
+    if (colorFilterAnimation != null) {
+      paint.setColorFilter(colorFilterAnimation.getValue());
+    }
+    super.draw(canvas, parentMatrix, parentAlpha);
+  }
+
+  @Override public String getName() {
+    return name;
+  }
+
+  @SuppressWarnings("unchecked")
+  @Override
+  public <T> void addValueCallback(T property, @Nullable LottieValueCallback<T> callback) {
+    super.addValueCallback(property, callback);
+    if (property == STROKE_COLOR) {
+      colorAnimation.setValueCallback((LottieValueCallback<Integer>) callback);
+    } else if (property == LottieProperty.COLOR_FILTER) {
+      if (colorFilterAnimation != null) {
+        layer.removeAnimation(colorFilterAnimation);
+      }
+
+      if (callback == null) {
+        colorFilterAnimation = null;
+      } else {
+        colorFilterAnimation =
+            new ValueCallbackKeyframeAnimation<>((LottieValueCallback<ColorFilter>) callback);
+        colorFilterAnimation.addUpdateListener(this);
+        layer.addAnimation(colorAnimation);
+      }
+    }
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/animation/content/TrimPathContent.java

@@ -0,0 +1,75 @@
+package quicktvui.support.lottie.animation.content;
+
+
+import java.util.ArrayList;
+import java.util.List;
+
+import quicktvui.support.lottie.animation.keyframe.BaseKeyframeAnimation;
+import quicktvui.support.lottie.model.content.ShapeTrimPath;
+import quicktvui.support.lottie.model.layer.BaseLayer;
+
+public class TrimPathContent implements Content, BaseKeyframeAnimation.AnimationListener {
+
+  private final String name;
+  private final boolean hidden;
+  private final List<BaseKeyframeAnimation.AnimationListener> listeners = new ArrayList<>();
+  private final ShapeTrimPath.Type type;
+  private final BaseKeyframeAnimation<?, Float> startAnimation;
+  private final BaseKeyframeAnimation<?, Float> endAnimation;
+  private final BaseKeyframeAnimation<?, Float> offsetAnimation;
+
+  public TrimPathContent(BaseLayer layer, ShapeTrimPath trimPath) {
+    name = trimPath.getName();
+    hidden = trimPath.isHidden();
+    type = trimPath.getType();
+    startAnimation = trimPath.getStart().createAnimation();
+    endAnimation = trimPath.getEnd().createAnimation();
+    offsetAnimation = trimPath.getOffset().createAnimation();
+
+    layer.addAnimation(startAnimation);
+    layer.addAnimation(endAnimation);
+    layer.addAnimation(offsetAnimation);
+
+    startAnimation.addUpdateListener(this);
+    endAnimation.addUpdateListener(this);
+    offsetAnimation.addUpdateListener(this);
+  }
+
+  @Override public void onValueChanged() {
+    for (int i = 0; i < listeners.size(); i++) {
+      listeners.get(i).onValueChanged();
+    }
+  }
+
+  @Override public void setContents(List<Content> contentsBefore, List<Content> contentsAfter) {
+    // Do nothing.
+  }
+
+  @Override public String getName() {
+    return name;
+  }
+
+  void addListener(BaseKeyframeAnimation.AnimationListener listener) {
+    listeners.add(listener);
+  }
+
+  ShapeTrimPath.Type getType() {
+    return type;
+  }
+
+  public BaseKeyframeAnimation<?, Float> getStart() {
+    return startAnimation;
+  }
+
+  public BaseKeyframeAnimation<?, Float> getEnd() {
+    return endAnimation;
+  }
+
+  public BaseKeyframeAnimation<?, Float> getOffset() {
+    return offsetAnimation;
+  }
+
+  public boolean isHidden() {
+    return hidden;
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/animation/content/package-info.java

@@ -0,0 +1,6 @@
+@RestrictTo(LIBRARY)
+package quicktvui.support.lottie.animation.content;
+
+import static android.support.annotation.RestrictTo.Scope.LIBRARY;
+
+import android.support.annotation.RestrictTo;