@quicktvui/ai 1.0.8 → 1.0.9

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

@@ -0,0 +1,79 @@
+package quicktvui.support.lottie;
+
+import android.graphics.Bitmap;
+
+import android.support.annotation.Nullable;
+import android.support.annotation.RestrictTo;
+
+/**
+ * Data class describing an image asset embedded in a Lottie json file.
+ */
+public class LottieImageAsset {
+  private final int width;
+  private final int height;
+  private final String id;
+  private final String fileName;
+  private final String dirName;
+  /**
+   * Pre-set a bitmap for this asset
+   */
+  @Nullable private Bitmap bitmap;
+
+  @RestrictTo(RestrictTo.Scope.LIBRARY)
+  public LottieImageAsset(int width, int height, String id, String fileName, String dirName) {
+    this.width = width;
+    this.height = height;
+    this.id = id;
+    this.fileName = fileName;
+    this.dirName = dirName;
+  }
+
+  public int getWidth() {
+    return width;
+  }
+
+  public int getHeight() {
+    return height;
+  }
+
+  /**
+   * The reference id in the json file.
+   */
+  public String getId() {
+    return id;
+  }
+
+  public String getFileName() {
+    return fileName;
+  }
+
+  @SuppressWarnings("unused") public String getDirName() {
+    return dirName;
+  }
+
+  /**
+   * Returns the bitmap that has been stored for this image asset if one was explicitly set.
+   */
+  @Nullable public Bitmap getBitmap() {
+    return bitmap;
+  }
+
+  /**
+   * Permanently sets the bitmap on this LottieImageAsset. This will:
+   * 1) Overwrite any existing Bitmaps.
+   * 2) Apply to *all* animations that use this LottieComposition.
+   *
+   * If you only want to replace the bitmap for this animation, use dynamic properties
+   * with {@link LottieProperty#IMAGE}.
+   */
+  public void setBitmap(@Nullable Bitmap bitmap) {
+    this.bitmap = bitmap;
+  }
+
+  /**
+   * Returns whether this asset has an embedded Bitmap or whether the fileName is a base64 encoded bitmap.
+   */
+  public boolean hasBitmap() {
+    return bitmap != null || (fileName.startsWith("data:") && fileName.indexOf("base64,") > 0);
+  }
+}

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

@@ -0,0 +1,8 @@
+package quicktvui.support.lottie;
+
+/**
+ * Receive a result with either the value or exception for a {@link LottieTask}
+ */
+public interface LottieListener<T> {
+  void onResult(T result);
+}

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

@@ -0,0 +1,17 @@
+package quicktvui.support.lottie;
+
+/**
+ * Give ability to integrators to provide another logging mechanism.
+ */
+public interface LottieLogger {
+
+  void debug(String message);
+
+  void debug(String message, Throwable exception);
+
+  void warning(String message);
+
+  void warning(String message, Throwable exception);
+
+  void error(String message, Throwable exception);
+}

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

@@ -0,0 +1,5 @@
+package quicktvui.support.lottie;
+
+public interface LottieOnCompositionLoadedListener {
+  void onCompositionLoaded(LottieComposition composition);
+}

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

@@ -0,0 +1,223 @@
+package quicktvui.support.lottie;
+
+import android.graphics.Bitmap;
+import android.graphics.ColorFilter;
+import android.graphics.PointF;
+import android.graphics.Typeface;
+
+import quicktvui.support.lottie.value.LottieValueCallback;
+import quicktvui.support.lottie.value.ScaleXY;
+
+/**
+ * Property values are the same type as the generic type of their corresponding
+ * {@link LottieValueCallback}. With this, we can use generics to maintain type safety
+ * of the callbacks.
+ * <p>
+ * Supported properties:
+ * Transform:
+ * {@link #TRANSFORM_ANCHOR_POINT}
+ * {@link #TRANSFORM_POSITION}
+ * {@link #TRANSFORM_OPACITY}
+ * {@link #TRANSFORM_SCALE}
+ * {@link #TRANSFORM_ROTATION}
+ * {@link #TRANSFORM_SKEW}
+ * {@link #TRANSFORM_SKEW_ANGLE}
+ * <p>
+ * Fill:
+ * {@link #COLOR} (non-gradient)
+ * {@link #OPACITY}
+ * {@link #COLOR_FILTER}
+ * <p>
+ * Stroke:
+ * {@link #COLOR} (non-gradient)
+ * {@link #STROKE_WIDTH}
+ * {@link #OPACITY}
+ * {@link #COLOR_FILTER}
+ * <p>
+ * Ellipse:
+ * {@link #POSITION}
+ * {@link #ELLIPSE_SIZE}
+ * <p>
+ * Polystar:
+ * {@link #POLYSTAR_POINTS}
+ * {@link #POLYSTAR_ROTATION}
+ * {@link #POSITION}
+ * {@link #POLYSTAR_INNER_RADIUS} (star)
+ * {@link #POLYSTAR_OUTER_RADIUS}
+ * {@link #POLYSTAR_INNER_ROUNDEDNESS} (star)
+ * {@link #POLYSTAR_OUTER_ROUNDEDNESS}
+ * <p>
+ * Repeater:
+ * All transform properties
+ * {@link #REPEATER_COPIES}
+ * {@link #REPEATER_OFFSET}
+ * {@link #TRANSFORM_ROTATION}
+ * {@link #TRANSFORM_START_OPACITY}
+ * {@link #TRANSFORM_END_OPACITY}
+ * <p>
+ * Layers:
+ * All transform properties
+ * {@link #TIME_REMAP} (composition layers only)
+ */
+public interface LottieProperty {
+  /**
+   * ColorInt
+   **/
+  Integer COLOR = 1;
+  Integer STROKE_COLOR = 2;
+  /**
+   * Opacity value are 0-100 to match after effects
+   **/
+  Integer TRANSFORM_OPACITY = 3;
+  /**
+   * [0,100]
+   */
+  Integer OPACITY = 4;
+  Integer DROP_SHADOW_COLOR = 5;
+  /**
+   * In Px
+   */
+  PointF TRANSFORM_ANCHOR_POINT = new PointF();
+  /**
+   * In Px
+   */
+  PointF TRANSFORM_POSITION = new PointF();
+  /**
+   * When split dimensions is enabled. In Px
+   */
+  Float TRANSFORM_POSITION_X = 15f;
+  /**
+   * When split dimensions is enabled. In Px
+   */
+  Float TRANSFORM_POSITION_Y = 16f;
+  /**
+   * In Px
+   */
+  Float BLUR_RADIUS = 17f;
+  /**
+   * In Px
+   */
+  PointF ELLIPSE_SIZE = new PointF();
+  /**
+   * In Px
+   */
+  PointF RECTANGLE_SIZE = new PointF();
+  /**
+   * In degrees
+   */
+  Float CORNER_RADIUS = 0f;
+  /**
+   * In Px
+   */
+  PointF POSITION = new PointF();
+  ScaleXY TRANSFORM_SCALE = new ScaleXY();
+  /**
+   * In degrees
+   */
+  Float TRANSFORM_ROTATION = 1f;
+  /**
+   * 0-85
+   */
+  Float TRANSFORM_SKEW = 0f;
+  /**
+   * In degrees
+   */
+  Float TRANSFORM_SKEW_ANGLE = 0f;
+  /**
+   * In Px
+   */
+  Float STROKE_WIDTH = 2f;
+  Float TEXT_TRACKING = 3f;
+  Float REPEATER_COPIES = 4f;
+  Float REPEATER_OFFSET = 5f;
+  Float POLYSTAR_POINTS = 6f;
+  /**
+   * In degrees
+   */
+  Float POLYSTAR_ROTATION = 7f;
+  /**
+   * In Px
+   */
+  Float POLYSTAR_INNER_RADIUS = 8f;
+  /**
+   * In Px
+   */
+  Float POLYSTAR_OUTER_RADIUS = 9f;
+  /**
+   * [0,100]
+   */
+  Float POLYSTAR_INNER_ROUNDEDNESS = 10f;
+  /**
+   * [0,100]
+   */
+  Float POLYSTAR_OUTER_ROUNDEDNESS = 11f;
+  /**
+   * [0,100]
+   */
+  Float TRANSFORM_START_OPACITY = 12f;
+  /**
+   * [0,100]
+   */
+  Float TRANSFORM_END_OPACITY = 12.1f;
+  /**
+   * The time value in seconds
+   */
+  Float TIME_REMAP = 13f;
+  /**
+   * In Dp
+   */
+  Float TEXT_SIZE = 14f;
+  /**
+   * [0,100]
+   * Lottie Android resolved drop shadows on drawing content such as fills and strokes.
+   * If a drop shadow is applied to a layer, the dynamic properties must be set on all
+   * of its child elements that draw. The easiest way to do this is to append "**" to your
+   * Keypath after the layer name.
+   */
+  Float DROP_SHADOW_OPACITY = 15f;
+  /**
+   * Degrees from 12 o'clock.
+   * Lottie Android resolved drop shadows on drawing content such as fills and strokes.
+   * If a drop shadow is applied to a layer, the dynamic properties must be set on all
+   * of its child elements that draw. The easiest way to do this is to append "**" to your
+   * Keypath after the layer name.
+   */
+  Float DROP_SHADOW_DIRECTION = 16f;
+  /**
+   * In Px
+   * Lottie Android resolved drop shadows on drawing content such as fills and strokes.
+   * If a drop shadow is applied to a layer, the dynamic properties must be set on all
+   * of its child elements that draw. The easiest way to do this is to append "**" to your
+   * Keypath after the layer name.
+   */
+  Float DROP_SHADOW_DISTANCE = 17f;
+  /**
+   * In Px
+   * Lottie Android resolved drop shadows on drawing content such as fills and strokes.
+   * If a drop shadow is applied to a layer, the dynamic properties must be set on all
+   * of its child elements that draw. The easiest way to do this is to append "**" to your
+   * Keypath after the layer name.
+   */
+  Float DROP_SHADOW_RADIUS = 18f;
+  /**
+   * Set the color filter for an entire drawable content. Can be applied to fills, strokes, images, and solids.
+   */
+  ColorFilter COLOR_FILTER = new ColorFilter();
+  /**
+   * Array of ARGB colors that map to position stops in the original gradient.
+   * For example, a gradient from red to blue could be remapped with [0xFF00FF00, 0xFFFF00FF] (green to purple).
+   */
+  Integer[] GRADIENT_COLOR = new Integer[0];
+  /**
+   * Set on text layers.
+   */
+  Typeface TYPEFACE = Typeface.DEFAULT;
+  /**
+   * Set on image layers.
+   */
+  Bitmap IMAGE = Bitmap.createBitmap(1, 1, Bitmap.Config.ALPHA_8);
+  /**
+   * Replace the text for a text layer.
+   */
+  CharSequence TEXT = "dynamic_text";
+}

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

@@ -0,0 +1,55 @@
+package quicktvui.support.lottie;
+
+import android.support.annotation.Nullable;
+
+import java.util.Arrays;
+
+/**
+ * Contains class to hold the resulting value of an async task or an exception if it failed.
+ * <p>
+ * Either value or exception will be non-null.
+ */
+public final class LottieResult<V> {
+
+  @Nullable private final V value;
+  @Nullable private final Throwable exception;
+
+  public LottieResult(V value) {
+    this.value = value;
+    exception = null;
+  }
+
+  public LottieResult(Throwable exception) {
+    this.exception = exception;
+    value = null;
+  }
+
+  @Nullable public V getValue() {
+    return value;
+  }
+
+  @Nullable public Throwable getException() {
+    return exception;
+  }
+
+  @Override public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (!(o instanceof LottieResult)) {
+      return false;
+    }
+    LottieResult<?> that = (LottieResult<?>) o;
+    if (getValue() != null && getValue().equals(that.getValue())) {
+      return true;
+    }
+    if (getException() != null && that.getException() != null) {
+      return getException().toString().equals(getException().toString());
+    }
+    return false;
+  }
+
+  @Override public int hashCode() {
+    return Arrays.hashCode(new Object[]{getValue(), getException()});
+  }
+}

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

@@ -0,0 +1,185 @@
+package quicktvui.support.lottie;
+
+import android.os.Handler;
+import android.os.Looper;
+
+import android.support.annotation.Nullable;
+import android.support.annotation.RestrictTo;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+import java.util.concurrent.FutureTask;
+
+import quicktvui.support.lottie.utils.Logger;
+
+/**
+ * Helper to run asynchronous tasks with a result.
+ * Results can be obtained with {@link #addListener(LottieListener)}.
+ * Failures can be obtained with {@link #addFailureListener(LottieListener)}.
+ * <p>
+ * A task will produce a single result or a single failure.
+ */
+@SuppressWarnings("UnusedReturnValue") public class LottieTask<T> {
+
+  /**
+   * Set this to change the executor that LottieTasks are run on. This will be the executor that composition parsing and url
+   * fetching happens on.
+   * <p>
+   * You may change this to run deserialization synchronously for testing.
+   */
+  @SuppressWarnings("WeakerAccess")
+  public static Executor EXECUTOR = Executors.newCachedThreadPool();
+
+  /* Preserve add order. */
+  private final Set<LottieListener<T>> successListeners = new LinkedHashSet<>(1);
+  private final Set<LottieListener<Throwable>> failureListeners = new LinkedHashSet<>(1);
+  private final Handler handler = new Handler(Looper.getMainLooper());
+
+  @Nullable private volatile LottieResult<T> result = null;
+
+  @RestrictTo(RestrictTo.Scope.LIBRARY)
+  public LottieTask(Callable<LottieResult<T>> runnable) {
+    this(runnable, false);
+  }
+
+  /**
+   * runNow is only used for testing.
+   */
+  @RestrictTo(RestrictTo.Scope.LIBRARY) LottieTask(Callable<LottieResult<T>> runnable, boolean runNow) {
+    if (runNow) {
+      try {
+        setResult(runnable.call());
+      } catch (Throwable e) {
+        setResult(new LottieResult<>(e));
+      }
+    } else {
+      EXECUTOR.execute(new LottieFutureTask(runnable));
+    }
+  }
+
+  private void setResult(@Nullable LottieResult<T> result) {
+    if (this.result != null) {
+      throw new IllegalStateException("A task may only be set once.");
+    }
+    this.result = result;
+    notifyListeners();
+  }
+
+  /**
+   * Add a task listener. If the task has completed, the listener will be called synchronously.
+   *
+   * @return the task for call chaining.
+   */
+  public synchronized LottieTask<T> addListener(LottieListener<T> listener) {
+    LottieResult<T> result = this.result;
+    if (result != null && result.getValue() != null) {
+      listener.onResult(result.getValue());
+    }
+
+    successListeners.add(listener);
+    return this;
+  }
+
+  /**
+   * Remove a given task listener. The task will continue to execute so you can re-add
+   * a listener if necessary.
+   *
+   * @return the task for call chaining.
+   */
+  public synchronized LottieTask<T> removeListener(LottieListener<T> listener) {
+    successListeners.remove(listener);
+    return this;
+  }
+
+  /**
+   * Add a task failure listener. This will only be called in the even that an exception
+   * occurs. If an exception has already occurred, the listener will be called immediately.
+   *
+   * @return the task for call chaining.
+   */
+  public synchronized LottieTask<T> addFailureListener(LottieListener<Throwable> listener) {
+    LottieResult<T> result = this.result;
+    if (result != null && result.getException() != null) {
+      listener.onResult(result.getException());
+    }
+
+    failureListeners.add(listener);
+    return this;
+  }
+
+  /**
+   * Remove a given task failure listener. The task will continue to execute so you can re-add
+   * a listener if necessary.
+   *
+   * @return the task for call chaining.
+   */
+  public synchronized LottieTask<T> removeFailureListener(LottieListener<Throwable> listener) {
+    failureListeners.remove(listener);
+    return this;
+  }
+
+  private void notifyListeners() {
+    // Listeners should be called on the main thread.
+    handler.post(() -> {
+      // Local reference in case it gets set on a background thread.
+      LottieResult<T> result = LottieTask.this.result;
+      if (result == null) {
+        return;
+      }
+      if (result.getValue() != null) {
+        notifySuccessListeners(result.getValue());
+      } else {
+        notifyFailureListeners(result.getException());
+      }
+    });
+  }
+
+  private synchronized void notifySuccessListeners(T value) {
+    // Allows listeners to remove themselves in onResult.
+    // Otherwise we risk ConcurrentModificationException.
+    List<LottieListener<T>> listenersCopy = new ArrayList<>(successListeners);
+    for (LottieListener<T> l : listenersCopy) {
+      l.onResult(value);
+    }
+  }
+
+  private synchronized void notifyFailureListeners(Throwable e) {
+    // Allows listeners to remove themselves in onResult.
+    // Otherwise we risk ConcurrentModificationException.
+    List<LottieListener<Throwable>> listenersCopy = new ArrayList<>(failureListeners);
+    if (listenersCopy.isEmpty()) {
+      Logger.warning("Lottie encountered an error but no failure listener was added:", e);
+      return;
+    }
+
+    for (LottieListener<Throwable> l : listenersCopy) {
+      l.onResult(e);
+    }
+  }
+
+  private class LottieFutureTask extends FutureTask<LottieResult<T>> {
+    LottieFutureTask(Callable<LottieResult<T>> callable) {
+      super(callable);
+    }
+
+    @Override
+    protected void done() {
+      if (isCancelled()) {
+        // We don't need to notify and listeners if the task is cancelled.
+        return;
+      }
+
+      try {
+        setResult(get());
+      } catch (InterruptedException | ExecutionException e) {
+        setResult(new LottieResult<>(e));
+      }
+    }
+  }
+}

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

@@ -0,0 +1,11 @@
+package quicktvui.support.lottie;
+
+/**
+ * Register this listener via {@link LottieCompositionFactory#registerLottieTaskIdleListener(LottieTaskIdleListener)}.
+ *
+ * Can be used to create an espresso idle resource. Refer to {@link LottieCompositionFactory#registerLottieTaskIdleListener(LottieTaskIdleListener)}
+ * for more information.
+ */
+public interface LottieTaskIdleListener {
+  void onIdleChanged(boolean idle);
+}

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

@@ -0,0 +1,15 @@
+package quicktvui.support.lottie;
+
+import android.support.annotation.Nullable;
+
+/**
+ * @see LottieCompositionFactory
+ * @see LottieResult
+ */
+@Deprecated
+public interface OnCompositionLoadedListener {
+  /**
+   * Composition will be null if there was an error loading it. Check logcat for more details.
+   */
+  void onCompositionLoaded(@Nullable LottieComposition composition);
+}

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

@@ -0,0 +1,97 @@
+package quicktvui.support.lottie;
+
+import android.support.v4.util.ArraySet;
+import android.support.v4.util.Pair;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import quicktvui.support.lottie.utils.MeanCalculator;
+
+public class PerformanceTracker {
+
+  public interface FrameListener {
+    void onFrameRendered(float renderTimeMs);
+  }
+
+  private boolean enabled = false;
+  private final Set<FrameListener> frameListeners = new ArraySet<>();
+  private final Map<String, MeanCalculator> layerRenderTimes = new HashMap<>();
+  private final Comparator<Pair<String, Float>> floatComparator =
+      new Comparator<Pair<String, Float>>() {
+        @Override public int compare(Pair<String, Float> o1, Pair<String, Float> o2) {
+          float r1 = o1.second;
+          float r2 = o2.second;
+          if (r2 > r1) {
+            return 1;
+          } else if (r1 > r2) {
+            return -1;
+          }
+          return 0;
+        }
+      };
+
+  void setEnabled(boolean enabled) {
+    this.enabled = enabled;
+  }
+
+  public void recordRenderTime(String layerName, float millis) {
+    if (!enabled) {
+      return;
+    }
+    MeanCalculator meanCalculator = layerRenderTimes.get(layerName);
+    if (meanCalculator == null) {
+      meanCalculator = new MeanCalculator();
+      layerRenderTimes.put(layerName, meanCalculator);
+    }
+    meanCalculator.add(millis);
+
+    if (layerName.equals("__container")) {
+      for (FrameListener listener : frameListeners) {
+        listener.onFrameRendered(millis);
+      }
+    }
+  }
+
+  public void addFrameListener(FrameListener frameListener) {
+    frameListeners.add(frameListener);
+  }
+
+  @SuppressWarnings("unused") public void removeFrameListener(FrameListener frameListener) {
+    frameListeners.remove(frameListener);
+  }
+
+  public void clearRenderTimes() {
+    layerRenderTimes.clear();
+  }
+
+  public void logRenderTimes() {
+    if (!enabled) {
+      return;
+    }
+    List<Pair<String, Float>> sortedRenderTimes = getSortedRenderTimes();
+    Log.d(L.TAG, "Render times:");
+    for (int i = 0; i < sortedRenderTimes.size(); i++) {
+      Pair<String, Float> layer = sortedRenderTimes.get(i);
+      Log.d(L.TAG, String.format("\t\t%30s:%.2f", layer.first, layer.second));
+    }
+  }
+
+  public List<Pair<String, Float>> getSortedRenderTimes() {
+    if (!enabled) {
+      return Collections.emptyList();
+    }
+    List<Pair<String, Float>> sortedRenderTimes = new ArrayList<>(layerRenderTimes.size());
+    for (Map.Entry<String, MeanCalculator> e : layerRenderTimes.entrySet()) {
+      sortedRenderTimes.add(new Pair<>(e.getKey(), e.getValue().getMean()));
+    }
+    Collections.sort(sortedRenderTimes, floatComparator);
+    return sortedRenderTimes;
+  }
+}