@quicktvui/ai 1.0.8 → 1.0.9

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/model/CubicCurveData.java

@@ -0,0 +1,91 @@
+package quicktvui.support.lottie.model;
+
+import static android.support.annotation.RestrictTo.Scope.LIBRARY;
+
+import android.annotation.SuppressLint;
+import android.graphics.PointF;
+
+import android.support.annotation.NonNull;
+import android.support.annotation.RestrictTo;
+
+/**
+ * One cubic path operation. CubicCurveData is structured such that it is easy to iterate through
+ * it and build a path. However, it is modeled differently than most path operations.
+ *
+ * CubicCurveData
+ * |                     - vertex
+ * |                   /
+ * |    cp1          cp2
+ * |   /
+ * |  |
+ * | /
+ * --------------------------
+ *
+ * When incrementally building a path, it will already have a "current point" so that is
+ * not captured in this data structure.
+ * The control points here represent {@link android.graphics.Path#cubicTo(float, float, float, float, float, float)}.
+ *
+ * Most path operations are centered around a vertex and its in control point and out control point like this:
+ * |           outCp
+ * |          /
+ * |         |
+ * |         v
+ * |        /
+ * |      inCp
+ * --------------------------
+ */
+@RestrictTo(LIBRARY)
+public class CubicCurveData {
+  private final PointF controlPoint1;
+  private final PointF controlPoint2;
+  private final PointF vertex;
+
+  public CubicCurveData() {
+    controlPoint1 = new PointF();
+    controlPoint2 = new PointF();
+    vertex = new PointF();
+  }
+
+  public CubicCurveData(PointF controlPoint1, PointF controlPoint2, PointF vertex) {
+    this.controlPoint1 = controlPoint1;
+    this.controlPoint2 = controlPoint2;
+    this.vertex = vertex;
+  }
+
+  public void setControlPoint1(float x, float y) {
+    controlPoint1.set(x, y);
+  }
+
+  public PointF getControlPoint1() {
+    return controlPoint1;
+  }
+
+  public void setControlPoint2(float x, float y) {
+    controlPoint2.set(x, y);
+  }
+
+  public PointF getControlPoint2() {
+    return controlPoint2;
+  }
+
+  public void setVertex(float x, float y) {
+    vertex.set(x, y);
+  }
+
+  public void setFrom(CubicCurveData curveData) {
+    setVertex(curveData.vertex.x, curveData.vertex.y);
+    setControlPoint1(curveData.controlPoint1.x, curveData.controlPoint1.y);
+    setControlPoint2(curveData.controlPoint2.x, curveData.controlPoint2.y);
+  }
+
+  public PointF getVertex() {
+    return vertex;
+  }
+
+  @SuppressLint("DefaultLocale")
+  @NonNull
+  @Override public String toString() {
+    return String.format("v=%.2f,%.2f cp1=%.2f,%.2f cp2=%.2f,%.2f",
+        vertex.x, vertex.y, controlPoint1.x, controlPoint1.y, controlPoint2.x, controlPoint2.y);
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/model/DocumentData.java

@@ -0,0 +1,76 @@
+package quicktvui.support.lottie.model;
+
+import static android.support.annotation.RestrictTo.Scope.LIBRARY;
+
+import android.graphics.PointF;
+
+import android.support.annotation.ColorInt;
+import android.support.annotation.Nullable;
+import android.support.annotation.RestrictTo;
+
+@RestrictTo(LIBRARY)
+public class DocumentData {
+
+  public enum Justification {
+    LEFT_ALIGN,
+    RIGHT_ALIGN,
+    CENTER
+  }
+
+  public String text;
+  public String fontName;
+  public float size;
+  public Justification justification;
+  public int tracking;
+  /** Extra space in between lines. */
+  public float lineHeight;
+  public float baselineShift;
+  @ColorInt public int color;
+  @ColorInt public int strokeColor;
+  public float strokeWidth;
+  public boolean strokeOverFill;
+  @Nullable public PointF boxPosition;
+  @Nullable public PointF boxSize;
+
+
+  public DocumentData(String text, String fontName, float size, Justification justification, int tracking,
+      float lineHeight, float baselineShift, @ColorInt int color, @ColorInt int strokeColor,
+      float strokeWidth, boolean strokeOverFill, PointF boxPosition, PointF boxSize) {
+    set(text, fontName, size, justification, tracking, lineHeight, baselineShift, color, strokeColor, strokeWidth, strokeOverFill, boxPosition, boxSize);
+  }
+
+  public DocumentData() {
+  }
+
+  public void set(String text, String fontName, float size, Justification justification, int tracking,
+      float lineHeight, float baselineShift, @ColorInt int color, @ColorInt int strokeColor,
+      float strokeWidth, boolean strokeOverFill, PointF boxPosition, PointF boxSize) {
+    this.text = text;
+    this.fontName = fontName;
+    this.size = size;
+    this.justification = justification;
+    this.tracking = tracking;
+    this.lineHeight = lineHeight;
+    this.baselineShift = baselineShift;
+    this.color = color;
+    this.strokeColor = strokeColor;
+    this.strokeWidth = strokeWidth;
+    this.strokeOverFill = strokeOverFill;
+    this.boxPosition = boxPosition;
+    this.boxSize = boxSize;
+  }
+
+  @Override public int hashCode() {
+    int result;
+    long temp;
+    result = text.hashCode();
+    result = 31 * result + fontName.hashCode();
+    result = (int) (31 * result + size);
+    result = 31 * result + justification.ordinal();
+    result = 31 * result + tracking;
+    temp = Float.floatToRawIntBits(lineHeight);
+    result = 31 * result + (int) (temp ^ (temp >>> 32));
+    result = 31 * result + color;
+    return result;
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/model/Font.java

@@ -0,0 +1,52 @@
+package quicktvui.support.lottie.model;
+
+import static android.support.annotation.RestrictTo.Scope.LIBRARY;
+
+import android.graphics.Typeface;
+
+import android.support.annotation.Nullable;
+import android.support.annotation.RestrictTo;
+
+@RestrictTo(LIBRARY)
+public class Font {
+
+  private final String family;
+  private final String name;
+  private final String style;
+  private final float ascent;
+
+  @Nullable
+  private Typeface typeface;
+
+  public Font(String family, String name, String style, float ascent) {
+    this.family = family;
+    this.name = name;
+    this.style = style;
+    this.ascent = ascent;
+  }
+
+  @SuppressWarnings("unused") public String getFamily() {
+    return family;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public String getStyle() {
+    return style;
+  }
+
+  @SuppressWarnings("unused") float getAscent() {
+    return ascent;
+  }
+
+  @Nullable
+  public Typeface getTypeface() {
+    return typeface;
+  }
+
+  public void setTypeface(@Nullable Typeface typeface) {
+    this.typeface = typeface;
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/model/FontCharacter.java

@@ -0,0 +1,49 @@
+package quicktvui.support.lottie.model;
+
+import static android.support.annotation.RestrictTo.Scope.LIBRARY;
+
+import android.support.annotation.RestrictTo;
+
+import java.util.List;
+
+import quicktvui.support.lottie.model.content.ShapeGroup;
+
+@RestrictTo(LIBRARY)
+public class FontCharacter {
+
+  public static int hashFor(char character, String fontFamily, String style) {
+    int result = (int) character;
+    result = 31 * result + fontFamily.hashCode();
+    result = 31 * result + style.hashCode();
+    return result;
+  }
+
+  private final List<ShapeGroup> shapes;
+  private final char character;
+  private final double size;
+  private final double width;
+  private final String style;
+  private final String fontFamily;
+
+  public FontCharacter(List<ShapeGroup> shapes, char character, double size,
+      double width, String style, String fontFamily) {
+    this.shapes = shapes;
+    this.character = character;
+    this.size = size;
+    this.width = width;
+    this.style = style;
+    this.fontFamily = fontFamily;
+  }
+
+  public List<ShapeGroup> getShapes() {
+    return shapes;
+  }
+
+  public double getWidth() {
+    return width;
+  }
+
+  @Override public int hashCode() {
+    return hashFor(character, fontFamily, style);
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/model/KeyPath.java

@@ -0,0 +1,243 @@
+package quicktvui.support.lottie.model;
+
+import android.support.annotation.CheckResult;
+import android.support.annotation.Nullable;
+import android.support.annotation.RestrictTo;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Defines which content to target.
+ * The keypath can contain wildcards ('*') with match exactly 1 item.
+ * or globstars ('**') which match 0 or more items. or KeyPath.COMPOSITION
+ * to represent the root composition layer.
+ * <p>
+ * For example, if your content were arranged like this:
+ * Gabriel (Shape Layer)
+ * Body (Shape Group)
+ * Left Hand (Shape)
+ * Fill (Fill)
+ * Transform (Transform)
+ * ...
+ * Brandon (Shape Layer)
+ * Body (Shape Group)
+ * Left Hand (Shape)
+ * Fill (Fill)
+ * Transform (Transform)
+ * ...
+ * <p>
+ * <p>
+ * You could:
+ * Match Gabriel left hand fill:
+ * new KeyPath("Gabriel", "Body", "Left Hand", "Fill");
+ * Match Gabriel and Brandon's left hand fill:
+ * new KeyPath("*", "Body", Left Hand", "Fill");
+ * Match anything with the name Fill:
+ * new KeyPath("**", "Fill");
+ * Target the the root composition layer:
+ * KeyPath.COMPOSITION
+ * <p>
+ * <p>
+ * NOTE: Content that are part of merge paths or repeaters cannot currently be resolved with
+ * a {@link KeyPath}. This may be fixed in the future.
+ */
+public class KeyPath {
+  /**
+   * A singleton KeyPath that targets on the root composition layer.
+   * This is useful if you want to apply transformer to the animation as a whole.
+   */
+  public final static KeyPath COMPOSITION = new KeyPath("COMPOSITION");
+
+  private final List<String> keys;
+  @Nullable private KeyPathElement resolvedElement;
+
+  public KeyPath(String... keys) {
+    this.keys = Arrays.asList(keys);
+  }
+
+  /**
+   * Copy constructor. Copies keys as well.
+   */
+  private KeyPath(KeyPath keyPath) {
+    keys = new ArrayList<>(keyPath.keys);
+    resolvedElement = keyPath.resolvedElement;
+  }
+
+  /**
+   * Returns a new KeyPath with the key added.
+   * This is used during keypath resolution. Children normally don't know about all of their parent
+   * elements so this is used to keep track of the fully qualified keypath.
+   * This returns a key keypath because during resolution, the full keypath element tree is walked
+   * and if this modified the original copy, it would remain after popping back up the element tree.
+   */
+  @CheckResult
+  @RestrictTo(RestrictTo.Scope.LIBRARY)
+  public KeyPath addKey(String key) {
+    KeyPath newKeyPath = new KeyPath(this);
+    newKeyPath.keys.add(key);
+    return newKeyPath;
+  }
+
+  /**
+   * Return a new KeyPath with the element resolved to the specified {@link KeyPathElement}.
+   */
+  @RestrictTo(RestrictTo.Scope.LIBRARY)
+  public KeyPath resolve(KeyPathElement element) {
+    KeyPath keyPath = new KeyPath(this);
+    keyPath.resolvedElement = element;
+    return keyPath;
+  }
+
+  /**
+   * Returns a {@link KeyPathElement} that this has been resolved to. KeyPaths get resolved with
+   * resolveKeyPath on LottieDrawable or LottieAnimationView.
+   */
+  @RestrictTo(RestrictTo.Scope.LIBRARY)
+  @Nullable
+  public KeyPathElement getResolvedElement() {
+    return resolvedElement;
+  }
+
+  /**
+   * Returns whether they key matches at the specified depth.
+   */
+  @SuppressWarnings("RedundantIfStatement")
+  @RestrictTo(RestrictTo.Scope.LIBRARY)
+  public boolean matches(String key, int depth) {
+    if (isContainer(key)) {
+      // This is an artificial layer we programatically create.
+      return true;
+    }
+    if (depth >= keys.size()) {
+      return false;
+    }
+    if (keys.get(depth).equals(key) ||
+        keys.get(depth).equals("**") ||
+        keys.get(depth).equals("*")) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * For a given key and depth, returns how much the depth should be incremented by when
+   * resolving a keypath to children.
+   * <p>
+   * This can be 0 or 2 when there is a globstar and the next key either matches or doesn't match
+   * the current key.
+   */
+  @RestrictTo(RestrictTo.Scope.LIBRARY)
+  public int incrementDepthBy(String key, int depth) {
+    if (isContainer(key)) {
+      // If it's a container then we added programatically and it isn't a part of the keypath.
+      return 0;
+    }
+    if (!keys.get(depth).equals("**")) {
+      // If it's not a globstar then it is part of the keypath.
+      return 1;
+    }
+    if (depth == keys.size() - 1) {
+      // The last key is a globstar.
+      return 0;
+    }
+    if (keys.get(depth + 1).equals(key)) {
+      // We are a globstar and the next key is our current key so consume both.
+      return 2;
+    }
+    return 0;
+  }
+
+  /**
+   * Returns whether the key at specified depth is fully specific enough to match the full set of
+   * keys in this keypath.
+   */
+  @RestrictTo(RestrictTo.Scope.LIBRARY)
+  public boolean fullyResolvesTo(String key, int depth) {
+    if (depth >= keys.size()) {
+      return false;
+    }
+    boolean isLastDepth = depth == keys.size() - 1;
+    String keyAtDepth = keys.get(depth);
+    boolean isGlobstar = keyAtDepth.equals("**");
+
+    if (!isGlobstar) {
+      boolean matches = keyAtDepth.equals(key) || keyAtDepth.equals("*");
+      return (isLastDepth || (depth == keys.size() - 2 && endsWithGlobstar())) && matches;
+    }
+
+    boolean isGlobstarButNextKeyMatches = !isLastDepth && keys.get(depth + 1).equals(key);
+    if (isGlobstarButNextKeyMatches) {
+      return depth == keys.size() - 2 ||
+          (depth == keys.size() - 3 && endsWithGlobstar());
+    }
+
+    if (isLastDepth) {
+      return true;
+    }
+    if (depth + 1 < keys.size() - 1) {
+      // We are a globstar but there is more than 1 key after the globstar we we can't fully match.
+      return false;
+    }
+    // Return whether the next key (which we now know is the last one) is the same as the current
+    // key.
+    return keys.get(depth + 1).equals(key);
+  }
+
+  /**
+   * Returns whether the keypath resolution should propagate to children. Some keypaths resolve
+   * to content other than leaf contents (such as a layer or content group transform) so sometimes
+   * this will return false.
+   */
+  @SuppressWarnings("SimplifiableIfStatement")
+  @RestrictTo(RestrictTo.Scope.LIBRARY)
+  public boolean propagateToChildren(String key, int depth) {
+    if ("__container".equals(key)) {
+      return true;
+    }
+    return depth < keys.size() - 1 || keys.get(depth).equals("**");
+  }
+
+  /**
+   * We artificially create some container groups (like a root ContentGroup for the entire animation
+   * and for the contents of a ShapeLayer).
+   */
+  private boolean isContainer(String key) {
+    return "__container".equals(key);
+  }
+
+  private boolean endsWithGlobstar() {
+    return keys.get(keys.size() - 1).equals("**");
+  }
+
+  public String keysToString() {
+    return keys.toString();
+  }
+
+  @Override public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+
+    KeyPath keyPath = (KeyPath) o;
+
+    if (!keys.equals(keyPath.keys)) {
+      return false;
+    }
+    return resolvedElement != null ? resolvedElement.equals(keyPath.resolvedElement) : keyPath.resolvedElement == null;
+  }
+
+  @Override public int hashCode() {
+    int result = keys.hashCode();
+    result = 31 * result + (resolvedElement != null ? resolvedElement.hashCode() : 0);
+    return result;
+  }
+
+  @Override public String toString() {
+    return "KeyPath{" + "keys=" + keys + ",resolved=" + (resolvedElement != null) + '}';
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/model/KeyPathElement.java

@@ -0,0 +1,41 @@
+package quicktvui.support.lottie.model;
+
+import static android.support.annotation.RestrictTo.Scope.LIBRARY;
+
+import android.support.annotation.Nullable;
+import android.support.annotation.RestrictTo;
+
+import java.util.List;
+
+import quicktvui.support.lottie.value.LottieValueCallback;
+
+/**
+ * Any item that can be a part of a {@link KeyPath} should implement this.
+ */
+@RestrictTo(LIBRARY)
+public interface KeyPathElement {
+
+  /**
+   * Called recursively during keypath resolution.
+   * <p>
+   * The overridden method should just call:
+   * MiscUtils.resolveKeyPath(keyPath, depth, accumulator, currentPartialKeyPath, this);
+   *
+   * @param keyPath               The full keypath being resolved.
+   * @param depth                 The current depth that this element should be checked at in the keypath.
+   * @param accumulator           A list of fully resolved keypaths. If this element fully matches the
+   *                              keypath then it should add itself to this list.
+   * @param currentPartialKeyPath A keypath that contains all parent element of this one.
+   *                              This element should create a copy of this and append itself
+   *                              with KeyPath#addKey when it adds itself to the accumulator
+   *                              or propagates resolution to its children.
+   */
+  void resolveKeyPath(
+      KeyPath keyPath, int depth, List<KeyPath> accumulator, KeyPath currentPartialKeyPath);
+
+  /**
+   * The overridden method should handle appropriate properties and set value callbacks on their
+   * animations.
+   */
+  <T> void addValueCallback(T property, @Nullable LottieValueCallback<T> callback);
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/model/LottieCompositionCache.java

@@ -0,0 +1,50 @@
+package quicktvui.support.lottie.model;
+
+import android.support.annotation.Nullable;
+import android.support.annotation.RestrictTo;
+import android.support.annotation.VisibleForTesting;
+import android.support.v4.util.LruCache;
+
+import quicktvui.support.lottie.LottieComposition;
+
+@RestrictTo(RestrictTo.Scope.LIBRARY)
+public class LottieCompositionCache {
+
+  private static final LottieCompositionCache INSTANCE = new LottieCompositionCache();
+
+  public static LottieCompositionCache getInstance() {
+    return INSTANCE;
+  }
+
+  private final LruCache<String, LottieComposition> cache = new LruCache<>(20);
+
+  @VisibleForTesting LottieCompositionCache() {
+  }
+
+  @Nullable
+  public LottieComposition get(@Nullable String cacheKey) {
+    if (cacheKey == null) {
+      return null;
+    }
+    return cache.get(cacheKey);
+  }
+
+  public void put(@Nullable String cacheKey, LottieComposition composition) {
+    if (cacheKey == null) {
+      return;
+    }
+    cache.put(cacheKey, composition);
+  }
+
+  public void clear() {
+    cache.evictAll();
+  }
+
+  /**
+   * Set the maximum number of compositions to keep cached in memory.
+   * This must be {@literal >} 0.
+   */
+  public void resize(int size) {
+    cache.resize(size);
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/model/Marker.java

@@ -0,0 +1,37 @@
+package quicktvui.support.lottie.model;
+
+public class Marker {
+  private static final String CARRIAGE_RETURN = "\r";
+
+  private final String name;
+  public final float startFrame;
+  public final float durationFrames;
+
+  public Marker(String name, float startFrame, float durationFrames) {
+    this.name = name;
+    this.durationFrames = durationFrames;
+    this.startFrame = startFrame;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public float getStartFrame() {
+    return startFrame;
+  }
+
+  public float getDurationFrames() {
+    return durationFrames;
+  }
+
+  public boolean matchesName(String name) {
+    if (this.name.equalsIgnoreCase(name)) {
+      return true;
+    }
+
+    // It is easy for a designer to accidentally include an extra newline which will cause the name to not match what they would
+    // expect. This is a convenience to precent unneccesary confusion.
+    return this.name.endsWith(CARRIAGE_RETURN) && this.name.substring(0, this.name.length() - 1).equalsIgnoreCase(name);
+  }
+}

package/rules/.source/sdk/support/lottie-view/src/main/java/quicktvui/support/lottie/model/MutablePair.java

@@ -0,0 +1,57 @@
+package quicktvui.support.lottie.model;
+
+import static android.support.annotation.RestrictTo.Scope.LIBRARY;
+
+import android.support.annotation.Nullable;
+import android.support.annotation.RestrictTo;
+import android.support.v4.util.Pair;
+
+/**
+ * Non final version of {@link Pair}.
+ */
+@RestrictTo(LIBRARY)
+public class MutablePair<T> {
+  @Nullable T first;
+  @Nullable T second;
+
+  public void set(T first, T second) {
+    this.first = first;
+    this.second = second;
+  }
+
+  /**
+   * Checks the two objects for equality by delegating to their respective
+   * {@link Object#equals(Object)} methods.
+   *
+   * @param o the {@link Pair} to which this one is to be checked for equality
+   * @return true if the underlying objects of the Pair are both considered
+   * equal
+   */
+  @Override
+  public boolean equals(Object o) {
+    if (!(o instanceof Pair)) {
+      return false;
+    }
+    Pair<?, ?> p = (Pair<?, ?>) o;
+    return objectsEqual(p.first, first) && objectsEqual(p.second, second);
+  }
+
+  private static boolean objectsEqual(Object a, Object b) {
+    return a == b || (a != null && a.equals(b));
+  }
+
+  /**
+   * Compute a hash code using the hash codes of the underlying objects
+   *
+   * @return a hashcode of the Pair
+   */
+  @Override
+  public int hashCode() {
+    return (first == null ? 0 : first.hashCode()) ^ (second == null ? 0 : second.hashCode());
+  }
+
+  @Override
+  public String toString() {
+    return "Pair{" + first + " " + second + "}";
+  }
+}