@quicktvui/ai 1.0.8 → 1.0.9

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

@@ -0,0 +1,336 @@
+package quicktvui.support.lottie.animation.keyframe;
+
+import static quicktvui.support.lottie.LottieProperty.TRANSFORM_ANCHOR_POINT;
+import static quicktvui.support.lottie.LottieProperty.TRANSFORM_END_OPACITY;
+import static quicktvui.support.lottie.LottieProperty.TRANSFORM_OPACITY;
+import static quicktvui.support.lottie.LottieProperty.TRANSFORM_POSITION;
+import static quicktvui.support.lottie.LottieProperty.TRANSFORM_POSITION_X;
+import static quicktvui.support.lottie.LottieProperty.TRANSFORM_POSITION_Y;
+import static quicktvui.support.lottie.LottieProperty.TRANSFORM_ROTATION;
+import static quicktvui.support.lottie.LottieProperty.TRANSFORM_SCALE;
+import static quicktvui.support.lottie.LottieProperty.TRANSFORM_SKEW;
+import static quicktvui.support.lottie.LottieProperty.TRANSFORM_SKEW_ANGLE;
+import static quicktvui.support.lottie.LottieProperty.TRANSFORM_START_OPACITY;
+
+import android.graphics.Matrix;
+import android.graphics.PointF;
+
+import android.support.annotation.Nullable;
+import java.util.Collections;
+
+import quicktvui.support.lottie.model.animatable.AnimatableTransform;
+import quicktvui.support.lottie.model.layer.BaseLayer;
+import quicktvui.support.lottie.value.Keyframe;
+import quicktvui.support.lottie.value.LottieValueCallback;
+import quicktvui.support.lottie.value.ScaleXY;
+
+public class TransformKeyframeAnimation {
+  private final Matrix matrix = new Matrix();
+  private final Matrix skewMatrix1;
+  private final Matrix skewMatrix2;
+  private final Matrix skewMatrix3;
+  private final float[] skewValues;
+
+  @Nullable private BaseKeyframeAnimation<PointF, PointF> anchorPoint;
+  @Nullable private BaseKeyframeAnimation<?, PointF> position;
+  @Nullable private BaseKeyframeAnimation<ScaleXY, ScaleXY> scale;
+  @Nullable private BaseKeyframeAnimation<Float, Float> rotation;
+  @Nullable private BaseKeyframeAnimation<Integer, Integer> opacity;
+  @Nullable private FloatKeyframeAnimation skew;
+  @Nullable private FloatKeyframeAnimation skewAngle;
+
+  // Used for repeaters
+  @Nullable private BaseKeyframeAnimation<?, Float> startOpacity;
+  @Nullable private BaseKeyframeAnimation<?, Float> endOpacity;
+
+  public TransformKeyframeAnimation(AnimatableTransform animatableTransform) {
+    anchorPoint = animatableTransform.getAnchorPoint() == null ? null : animatableTransform.getAnchorPoint().createAnimation();
+    position = animatableTransform.getPosition() == null ? null : animatableTransform.getPosition().createAnimation();
+    scale = animatableTransform.getScale() == null ? null : animatableTransform.getScale().createAnimation();
+    rotation = animatableTransform.getRotation() == null ? null : animatableTransform.getRotation().createAnimation();
+    skew = animatableTransform.getSkew() == null ? null : (FloatKeyframeAnimation) animatableTransform.getSkew().createAnimation();
+    if (skew != null) {
+      skewMatrix1 = new Matrix();
+      skewMatrix2 = new Matrix();
+      skewMatrix3 = new Matrix();
+      skewValues = new float[9];
+    } else {
+      skewMatrix1 = null;
+      skewMatrix2 = null;
+      skewMatrix3 = null;
+      skewValues = null;
+    }
+    skewAngle = animatableTransform.getSkewAngle() == null ? null : (FloatKeyframeAnimation) animatableTransform.getSkewAngle().createAnimation();
+    if (animatableTransform.getOpacity() != null) {
+      opacity = animatableTransform.getOpacity().createAnimation();
+    }
+    if (animatableTransform.getStartOpacity() != null) {
+      startOpacity = animatableTransform.getStartOpacity().createAnimation();
+    } else {
+      startOpacity = null;
+    }
+    if (animatableTransform.getEndOpacity() != null) {
+      endOpacity = animatableTransform.getEndOpacity().createAnimation();
+    } else {
+      endOpacity = null;
+    }
+  }
+
+  public void addAnimationsToLayer(BaseLayer layer) {
+    layer.addAnimation(opacity);
+    layer.addAnimation(startOpacity);
+    layer.addAnimation(endOpacity);
+
+    layer.addAnimation(anchorPoint);
+    layer.addAnimation(position);
+    layer.addAnimation(scale);
+    layer.addAnimation(rotation);
+    layer.addAnimation(skew);
+    layer.addAnimation(skewAngle);
+  }
+
+  public void addListener(final BaseKeyframeAnimation.AnimationListener listener) {
+    if (opacity != null) {
+      opacity.addUpdateListener(listener);
+    }
+    if (startOpacity != null) {
+      startOpacity.addUpdateListener(listener);
+    }
+    if (endOpacity != null) {
+      endOpacity.addUpdateListener(listener);
+    }
+
+    if (anchorPoint != null) {
+      anchorPoint.addUpdateListener(listener);
+    }
+    if (position != null) {
+      position.addUpdateListener(listener);
+    }
+    if (scale != null) {
+      scale.addUpdateListener(listener);
+    }
+    if (rotation != null) {
+      rotation.addUpdateListener(listener);
+    }
+    if (skew != null) {
+      skew.addUpdateListener(listener);
+    }
+    if (skewAngle != null) {
+      skewAngle.addUpdateListener(listener);
+    }
+  }
+
+  public void setProgress(float progress) {
+    if (opacity != null) {
+      opacity.setProgress(progress);
+    }
+    if (startOpacity != null) {
+      startOpacity.setProgress(progress);
+    }
+    if (endOpacity != null) {
+      endOpacity.setProgress(progress);
+    }
+
+    if (anchorPoint != null) {
+      anchorPoint.setProgress(progress);
+    }
+    if (position != null) {
+      position.setProgress(progress);
+    }
+    if (scale != null) {
+      scale.setProgress(progress);
+    }
+    if (rotation != null) {
+      rotation.setProgress(progress);
+    }
+    if (skew != null) {
+      skew.setProgress(progress);
+    }
+    if (skewAngle != null) {
+      skewAngle.setProgress(progress);
+    }
+  }
+
+  @Nullable public BaseKeyframeAnimation<?, Integer> getOpacity() {
+    return opacity;
+  }
+
+  @Nullable public BaseKeyframeAnimation<?, Float> getStartOpacity() {
+    return startOpacity;
+  }
+
+  @Nullable public BaseKeyframeAnimation<?, Float> getEndOpacity() {
+    return endOpacity;
+  }
+
+  public Matrix getMatrix() {
+    matrix.reset();
+    BaseKeyframeAnimation<?, PointF> position = this.position;
+    if (position != null) {
+      PointF positionValue = position.getValue();
+      if (positionValue != null && (positionValue.x != 0 || positionValue.y != 0)) {
+        matrix.preTranslate(positionValue.x, positionValue.y);
+      }
+    }
+
+    BaseKeyframeAnimation<Float, Float> rotation = this.rotation;
+    if (rotation != null) {
+      float rotationValue;
+      if (rotation instanceof ValueCallbackKeyframeAnimation) {
+        rotationValue = rotation.getValue();
+      } else {
+        rotationValue = ((FloatKeyframeAnimation) rotation).getFloatValue();
+      }
+      if (rotationValue != 0f) {
+        matrix.preRotate(rotationValue);
+      }
+    }
+
+    FloatKeyframeAnimation skew = this.skew;
+    if (skew != null) {
+      float mCos = skewAngle == null ? 0f : (float) Math.cos(Math.toRadians(-skewAngle.getFloatValue() + 90));
+      float mSin = skewAngle == null ? 1f : (float) Math.sin(Math.toRadians(-skewAngle.getFloatValue() + 90));
+      float aTan = (float) Math.tan(Math.toRadians(skew.getFloatValue()));
+      clearSkewValues();
+      skewValues[0] = mCos;
+      skewValues[1] = mSin;
+      skewValues[3] = -mSin;
+      skewValues[4] = mCos;
+      skewValues[8] = 1f;
+      skewMatrix1.setValues(skewValues);
+      clearSkewValues();
+      skewValues[0] = 1f;
+      skewValues[3] = aTan;
+      skewValues[4] = 1f;
+      skewValues[8] = 1f;
+      skewMatrix2.setValues(skewValues);
+      clearSkewValues();
+      skewValues[0] = mCos;
+      skewValues[1] = -mSin;
+      skewValues[3] = mSin;
+      skewValues[4] = mCos;
+      skewValues[8] = 1;
+      skewMatrix3.setValues(skewValues);
+      skewMatrix2.preConcat(skewMatrix1);
+      skewMatrix3.preConcat(skewMatrix2);
+
+      matrix.preConcat(skewMatrix3);
+    }
+
+    BaseKeyframeAnimation<ScaleXY, ScaleXY> scale = this.scale;
+    if (scale != null) {
+      ScaleXY scaleTransform = scale.getValue();
+      if (scaleTransform.getScaleX() != 1f || scaleTransform.getScaleY() != 1f) {
+        matrix.preScale(scaleTransform.getScaleX(), scaleTransform.getScaleY());
+      }
+    }
+
+    BaseKeyframeAnimation<PointF, PointF> anchorPoint = this.anchorPoint;
+    if (anchorPoint != null) {
+      PointF anchorPointValue = anchorPoint.getValue();
+      if (anchorPointValue != null && anchorPointValue.x != 0 || anchorPointValue.y != 0) {
+        matrix.preTranslate(-anchorPointValue.x, -anchorPointValue.y);
+      }
+    }
+
+    return matrix;
+  }
+
+  private void clearSkewValues() {
+    for (int i = 0; i < 9; i++) {
+      skewValues[i] = 0f;
+    }
+  }
+
+  /**
+   * TODO: see if we can use this for the main {@link #getMatrix()} method.
+   */
+  public Matrix getMatrixForRepeater(float amount) {
+    PointF position = this.position == null ? null : this.position.getValue();
+    ScaleXY scale = this.scale == null ? null : this.scale.getValue();
+
+    matrix.reset();
+    if (position != null) {
+      matrix.preTranslate(position.x * amount, position.y * amount);
+    }
+    if (scale != null) {
+      matrix.preScale(
+          (float) Math.pow(scale.getScaleX(), amount),
+          (float) Math.pow(scale.getScaleY(), amount));
+    }
+    if (this.rotation != null) {
+      float rotation = this.rotation.getValue();
+      PointF anchorPoint = this.anchorPoint == null ? null : this.anchorPoint.getValue();
+      matrix.preRotate(rotation * amount, anchorPoint == null ? 0f : anchorPoint.x, anchorPoint == null ? 0f : anchorPoint.y);
+    }
+
+    return matrix;
+  }
+
+  /**
+   * Returns whether the callback was applied.
+   */
+  @SuppressWarnings("unchecked")
+  public <T> boolean applyValueCallback(T property, @Nullable LottieValueCallback<T> callback) {
+    if (property == TRANSFORM_ANCHOR_POINT) {
+      if (anchorPoint == null) {
+        anchorPoint = new ValueCallbackKeyframeAnimation<>((LottieValueCallback<PointF>) callback, new PointF());
+      } else {
+        anchorPoint.setValueCallback((LottieValueCallback<PointF>) callback);
+      }
+    } else if (property == TRANSFORM_POSITION) {
+      if (position == null) {
+        position = new ValueCallbackKeyframeAnimation<>((LottieValueCallback<PointF>) callback, new PointF());
+      } else {
+        position.setValueCallback((LottieValueCallback<PointF>) callback);
+      }
+    } else if (property == TRANSFORM_POSITION_X && position instanceof SplitDimensionPathKeyframeAnimation) {
+      ((SplitDimensionPathKeyframeAnimation) position).setXValueCallback((LottieValueCallback<Float>) callback);
+    } else if (property == TRANSFORM_POSITION_Y && position instanceof SplitDimensionPathKeyframeAnimation) {
+      ((SplitDimensionPathKeyframeAnimation) position).setYValueCallback((LottieValueCallback<Float>) callback);
+    } else if (property == TRANSFORM_SCALE) {
+      if (scale == null) {
+        scale = new ValueCallbackKeyframeAnimation<>((LottieValueCallback<ScaleXY>) callback, new ScaleXY());
+      } else {
+        scale.setValueCallback((LottieValueCallback<ScaleXY>) callback);
+      }
+    } else if (property == TRANSFORM_ROTATION) {
+      if (rotation == null) {
+        rotation = new ValueCallbackKeyframeAnimation<>((LottieValueCallback<Float>) callback, 0f);
+      } else {
+        rotation.setValueCallback((LottieValueCallback<Float>) callback);
+      }
+    } else if (property == TRANSFORM_OPACITY) {
+      if (opacity == null) {
+        opacity = new ValueCallbackKeyframeAnimation<>((LottieValueCallback<Integer>) callback, 100);
+      } else {
+        opacity.setValueCallback((LottieValueCallback<Integer>) callback);
+      }
+    } else if (property == TRANSFORM_START_OPACITY) {
+      if (startOpacity == null) {
+        startOpacity = new ValueCallbackKeyframeAnimation<>((LottieValueCallback<Float>) callback, 100f);
+      } else {
+        startOpacity.setValueCallback((LottieValueCallback<Float>) callback);
+      }
+    } else if (property == TRANSFORM_END_OPACITY) {
+      if (endOpacity == null) {
+        endOpacity = new ValueCallbackKeyframeAnimation<>((LottieValueCallback<Float>) callback, 100f);
+      } else {
+        endOpacity.setValueCallback((LottieValueCallback<Float>) callback);
+      }
+    } else if (property == TRANSFORM_SKEW) {
+      if (skew == null) {
+        skew = new FloatKeyframeAnimation(Collections.singletonList(new Keyframe<>(0f)));
+      }
+      skew.setValueCallback((LottieValueCallback<Float>) callback);
+    } else if (property == TRANSFORM_SKEW_ANGLE) {
+      if (skewAngle == null) {
+        skewAngle = new FloatKeyframeAnimation(Collections.singletonList(new Keyframe<>(0f)));
+      }
+      skewAngle.setValueCallback((LottieValueCallback<Float>) callback);
+    } else {
+      return false;
+    }
+    return true;
+  }
+}

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

@@ -0,0 +1,49 @@
+package quicktvui.support.lottie.animation.keyframe;
+
+import android.support.annotation.Nullable;
+
+import java.util.Collections;
+
+import quicktvui.support.lottie.value.Keyframe;
+import quicktvui.support.lottie.value.LottieValueCallback;
+
+public class ValueCallbackKeyframeAnimation<K, A> extends BaseKeyframeAnimation<K, A> {
+  private final A valueCallbackValue;
+
+  public ValueCallbackKeyframeAnimation(LottieValueCallback<A> valueCallback) {
+    this(valueCallback, null);
+  }
+
+  public ValueCallbackKeyframeAnimation(LottieValueCallback<A> valueCallback, @Nullable A valueCallbackValue) {
+    super(Collections.emptyList());
+    setValueCallback(valueCallback);
+    this.valueCallbackValue = valueCallbackValue;
+  }
+
+  @Override public void setProgress(float progress) {
+    this.progress = progress;
+  }
+
+  /**
+   * If this doesn't return 1, then {@link #setProgress(float)} will always clamp the progress
+   * to 0.
+   */
+  @Override float getEndProgress() {
+    return 1f;
+  }
+
+  @Override public void notifyListeners() {
+    if (this.valueCallback != null) {
+      super.notifyListeners();
+    }
+  }
+
+  @Override public A getValue() {
+    //noinspection ConstantConditions
+    return valueCallback.getValueInternal(0f, 0f, valueCallbackValue, valueCallbackValue, getProgress(), getProgress(), getProgress());
+  }
+
+  @Override A getValue(Keyframe<K> keyframe, float keyframeProgress) {
+    return getValue();
+  }
+}

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

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

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

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

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

@@ -0,0 +1,129 @@
+package quicktvui.support.lottie.manager;
+
+import android.content.res.AssetManager;
+import android.graphics.Typeface;
+import android.graphics.drawable.Drawable;
+import android.view.View;
+
+import android.support.annotation.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import quicktvui.support.lottie.FontAssetDelegate;
+import quicktvui.support.lottie.model.Font;
+import quicktvui.support.lottie.model.MutablePair;
+import quicktvui.support.lottie.utils.Logger;
+
+public class FontAssetManager {
+  private final MutablePair<String> tempPair = new MutablePair<>();
+
+  /**
+   * Pair is (fontName, fontStyle)
+   */
+  private final Map<MutablePair<String>, Typeface> fontMap = new HashMap<>();
+  /**
+   * Map of font families to their fonts. Necessary to create a font with a different style
+   */
+  private final Map<String, Typeface> fontFamilies = new HashMap<>();
+  private final AssetManager assetManager;
+  @Nullable private FontAssetDelegate delegate;
+  private String defaultFontFileExtension = ".ttf";
+
+  public FontAssetManager(Drawable.Callback callback, @Nullable FontAssetDelegate delegate) {
+    this.delegate = delegate;
+    if (!(callback instanceof View)) {
+      Logger.warning("LottieDrawable must be inside of a view for images to work.");
+      assetManager = null;
+      return;
+    }
+
+    assetManager = ((View) callback).getContext().getAssets();
+  }
+
+  public void setDelegate(@Nullable FontAssetDelegate assetDelegate) {
+    this.delegate = assetDelegate;
+  }
+
+  /**
+   * Sets the default file extension (include the `.`).
+   * <p>
+   * e.g. `.ttf` `.otf`
+   * <p>
+   * Defaults to `.ttf`
+   */
+  @SuppressWarnings("unused") public void setDefaultFontFileExtension(String defaultFontFileExtension) {
+    this.defaultFontFileExtension = defaultFontFileExtension;
+  }
+
+  public Typeface getTypeface(Font font) {
+    tempPair.set(font.getFamily(), font.getStyle());
+    Typeface typeface = fontMap.get(tempPair);
+    if (typeface != null) {
+      return typeface;
+    }
+    Typeface typefaceWithDefaultStyle = getFontFamily(font);
+    typeface = typefaceForStyle(typefaceWithDefaultStyle, font.getStyle());
+    fontMap.put(tempPair, typeface);
+    return typeface;
+  }
+
+  private Typeface getFontFamily(Font font) {
+    String fontFamily = font.getFamily();
+    Typeface defaultTypeface = fontFamilies.get(fontFamily);
+    if (defaultTypeface != null) {
+      return defaultTypeface;
+    }
+
+    Typeface typeface = null;
+    String fontStyle = font.getStyle();
+    String fontName = font.getName();
+    if (delegate != null) {
+      typeface = delegate.fetchFont(fontFamily, fontStyle, fontName);
+      if (typeface == null) {
+        typeface = delegate.fetchFont(fontFamily);
+      }
+    }
+
+    if (delegate != null && typeface == null) {
+      String path = delegate.getFontPath(fontFamily, fontStyle, fontName);
+      if (path == null) {
+        path = delegate.getFontPath(fontFamily);
+      }
+      if (path != null) {
+        typeface = Typeface.createFromAsset(assetManager, path);
+      }
+    }
+
+    if (font.getTypeface() != null) {
+      return font.getTypeface();
+    }
+
+    if (typeface == null) {
+      String path = "fonts/" + fontFamily + defaultFontFileExtension;
+      typeface = Typeface.createFromAsset(assetManager, path);
+    }
+
+    fontFamilies.put(fontFamily, typeface);
+    return typeface;
+  }
+
+  private Typeface typefaceForStyle(Typeface typeface, String style) {
+    int styleInt = Typeface.NORMAL;
+    boolean containsItalic = style.contains("Italic");
+    boolean containsBold = style.contains("Bold");
+    if (containsItalic && containsBold) {
+      styleInt = Typeface.BOLD_ITALIC;
+    } else if (containsItalic) {
+      styleInt = Typeface.ITALIC;
+    } else if (containsBold) {
+      styleInt = Typeface.BOLD;
+    }
+
+    if (typeface.getStyle() == styleInt) {
+      return typeface;
+    }
+
+    return Typeface.create(typeface, styleInt);
+  }
+}

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

@@ -0,0 +1,151 @@
+package quicktvui.support.lottie.manager;
+
+import android.app.Application;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.drawable.Drawable;
+import android.text.TextUtils;
+import android.util.Base64;
+import android.view.View;
+
+import android.support.annotation.Nullable;
+
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Map;
+
+import quicktvui.support.lottie.ImageAssetDelegate;
+import quicktvui.support.lottie.LottieImageAsset;
+import quicktvui.support.lottie.utils.Logger;
+import quicktvui.support.lottie.utils.Utils;
+
+public class ImageAssetManager {
+  private static final Object bitmapHashLock = new Object();
+  @Nullable private final Context context;
+  private final String imagesFolder;
+  @Nullable private ImageAssetDelegate delegate;
+  private final Map<String, LottieImageAsset> imageAssets;
+
+  public ImageAssetManager(Drawable.Callback callback, String imagesFolder,
+      ImageAssetDelegate delegate, Map<String, LottieImageAsset> imageAssets) {
+    if (!TextUtils.isEmpty(imagesFolder) && imagesFolder.charAt(imagesFolder.length() - 1) != '/') {
+      this.imagesFolder = imagesFolder + '/';
+    } else {
+      this.imagesFolder = imagesFolder;
+    }
+    this.imageAssets = imageAssets;
+    setDelegate(delegate);
+    if (!(callback instanceof View)) {
+      context = null;
+      return;
+    }
+
+    context = ((View) callback).getContext().getApplicationContext();
+  }
+
+  public void setDelegate(@Nullable ImageAssetDelegate assetDelegate) {
+    this.delegate = assetDelegate;
+  }
+
+  /**
+   * Returns the previously set bitmap or null.
+   */
+  @Nullable public Bitmap updateBitmap(String id, @Nullable Bitmap bitmap) {
+    if (bitmap == null) {
+      LottieImageAsset asset = imageAssets.get(id);
+      Bitmap ret = asset.getBitmap();
+      asset.setBitmap(null);
+      return ret;
+    }
+    Bitmap prevBitmap = imageAssets.get(id).getBitmap();
+    putBitmap(id, bitmap);
+    return prevBitmap;
+  }
+
+  @Nullable public LottieImageAsset getImageAssetById(String id) {
+    return imageAssets.get(id);
+  }
+
+  @Nullable public Bitmap bitmapForId(String id) {
+    LottieImageAsset asset = imageAssets.get(id);
+    if (asset == null) {
+      return null;
+    }
+
+    Bitmap bitmap = asset.getBitmap();
+    if (bitmap != null) {
+      return bitmap;
+    }
+
+    if (delegate != null) {
+      bitmap = delegate.fetchBitmap(asset);
+      if (bitmap != null) {
+        putBitmap(id, bitmap);
+      }
+      return bitmap;
+    }
+    Context context = this.context;
+    if (context == null) {
+      // If there is no context, the image has to be embedded or provided via
+      // a delegate.
+      return null;
+    }
+
+    String filename = asset.getFileName();
+    BitmapFactory.Options opts = new BitmapFactory.Options();
+    opts.inScaled = true;
+    opts.inDensity = 160;
+
+    if (filename.startsWith("data:") && filename.indexOf("base64,") > 0) {
+      // Contents look like a base64 data URI, with the format data:image/png;base64,<data>.
+      byte[] data;
+      try {
+        data = Base64.decode(filename.substring(filename.indexOf(',') + 1), Base64.DEFAULT);
+      } catch (IllegalArgumentException e) {
+        Logger.warning("data URL did not have correct base64 format.", e);
+        return null;
+      }
+      bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, opts);
+      return putBitmap(id, bitmap);
+    }
+
+    InputStream is;
+    try {
+      if (TextUtils.isEmpty(imagesFolder)) {
+        throw new IllegalStateException("You must set an images folder before loading an image." +
+            " Set it with LottieComposition#setImagesFolder or LottieDrawable#setImagesFolder");
+      }
+      is = context.getAssets().open(imagesFolder + filename);
+    } catch (IOException e) {
+      Logger.warning("Unable to open asset.", e);
+      return null;
+    }
+
+    try {
+      bitmap = BitmapFactory.decodeStream(is, null, opts);
+    } catch (IllegalArgumentException e) {
+      Logger.warning("Unable to decode image `" + id + "`.", e);
+      return null;
+    }
+    if (bitmap == null) {
+      Logger.warning("Decoded image `" + id + "` is null.");
+      return null;
+    }
+    bitmap = Utils.resizeBitmapIfNeeded(bitmap, asset.getWidth(), asset.getHeight());
+    return putBitmap(id, bitmap);
+  }
+
+  public boolean hasSameContext(Context context) {
+    Context contextToCompare = this.context instanceof Application ? context.getApplicationContext() : context;
+    return contextToCompare == this.context;
+  }
+
+  private Bitmap putBitmap(String key, @Nullable Bitmap bitmap) {
+    synchronized (bitmapHashLock) {
+      imageAssets.get(key).setBitmap(bitmap);
+      return bitmap;
+    }
+  }
+}

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

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