import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
public static AnimatableTextProperties parse(
    JsonReader reader, LottieComposition composition) throws IOException {
  AnimatableTextProperties anim = null;

  reader.beginObject();
  while (reader.hasNext()) {
    switch (reader.nextName()) {
      case "a":
        anim = parseAnimatableTextProperties(reader, composition);
        break;
      default:
        reader.skipValue();
    }
  }
  reader.endObject();
  if (anim == null) {
    // Not sure if this is possible.
    return new AnimatableTextProperties(null, null, null, null);
  }
  return anim;
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
private static void parseLayers(JsonReader reader, LottieComposition composition,
    List<Layer> layers, LongSparseArray<Layer> layerMap) throws IOException {
  int imageCount = 0;
  reader.beginArray();
  while (reader.hasNext()) {
    Layer layer = LayerParser.parse(reader, composition);
    if (layer.getLayerType() == Layer.LayerType.Image) {
      imageCount++;
    }
    layers.add(layer);
    layerMap.put(layer.getId(), layer);

    if (imageCount > 4) {
      L.warn("You have " + imageCount + " images. Lottie should primarily be " +
          "used with shapes. If you are using Adobe Illustrator, convert the Illustrator layers" +
          " to shape layers.");
    }
  }
  reader.endArray();
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
static ShapePath parse(
    JsonReader reader, LottieComposition composition) throws IOException {
  String name = null;
  int ind = 0;
  AnimatableShapeValue shape = null;

  while (reader.hasNext()) {
    switch (reader.nextName()) {
      case "nm":
        name = reader.nextString();
        break;
      case "ind":
        ind = reader.nextInt();
        break;
      case "ks":
        shape = AnimatableValueParser.parseShapeData(reader, composition);
        break;
      default:
        reader.skipValue();
    }
  }

  return new ShapePath(name, ind, shape);
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
@SuppressWarnings("SameParameterValue")
public static boolean isAtLeastVersion(LottieComposition composition, int major, int minor, int
    patch) {
  if (composition.getMajorVersion() < major) {
    return false;
  } else if (composition.getMajorVersion() > major) {
    return true;
  }

  if (composition.getMinorVersion() < minor) {
    return false;
  } else if (composition.getMinorVersion() > minor) {
    return true;
  }

  return composition.getPatchVersion() >= patch;
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
@Nullable
static BaseLayer forModel(
  Layer layerModel, LottieDrawable drawable, LottieComposition composition) {
  switch (layerModel.getLayerType()) {
    case Shape:
      return new ShapeLayer(drawable, layerModel);
    case PreComp:
      return new CompositionLayer(drawable, layerModel,
          composition.getPrecomps(layerModel.getRefId()), composition);
    case Solid:
      return new SolidLayer(drawable, layerModel);
    case Image:
      return new ImageLayer(drawable, layerModel);
    case Null:
      return new NullLayer(drawable, layerModel);
    case Text:
      return new TextLayer(drawable, layerModel);
    case Unknown:
    default:
      // Do nothing
      L.warn("Unknown layer type " + layerModel.getLayerType());
      return null;
  }
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (data != null) {
        if (requestCode == REQUEST_FILE) {
            if (getFileName(data.getData()).substring(getFileName(data.getData()).lastIndexOf(".") + 1, getFileName(data.getData()).length()).equals("json")) {
                try {
                    JsonData jsonData = new JsonData(getFileName(data.getData()), "json");
                    mBinding.setJsonData(jsonData);
                    mAnimationView.setImageAssetsFolder("/storage/emulated/0/Download/");
                    InputStream fis = getContentResolver().openInputStream(data.getData());
                    LottieComposition.Factory
                            .fromInputStream(this, fis, new OnCompositionLoadedListener() {
                                @Override
                                public void onCompositionLoaded(LottieComposition composition) {
                                    setComposition(composition);
                                }
                            });
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                    Toast.makeText(MainActivity.this, getString(R.string.message_error_01), Toast.LENGTH_SHORT).show();
                }
            } else {
                Toast.makeText(MainActivity.this, getString(R.string.message_error_02), Toast.LENGTH_SHORT).show();
            }
        }
    }
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
private LottieDrawable createLottieDrawable(String filename) {
    final LottieDrawable lottieDrawable = new LottieDrawable();

    LottieComposition.Factory.fromAssetFileName(this, filename,
            new OnCompositionLoadedListener() {
                @Override
                public void onCompositionLoaded(@Nullable LottieComposition composition) {
                    lottieDrawable.setComposition(composition);
                    lottieDrawable.loop(true);
                    lottieDrawable.playAnimation();
                }
            });

    return lottieDrawable;
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
static ShapeFill parse(
    JsonReader reader, LottieComposition composition) throws IOException {
  AnimatableColorValue color = null;
  boolean fillEnabled = false;
  AnimatableIntegerValue opacity = null;
  String name = null;
  int fillTypeInt = 1;

  while (reader.hasNext()) {
    switch (reader.nextName()) {
      case "nm":
        name = reader.nextString();
        break;
      case "c":
        color = AnimatableValueParser.parseColor(reader, composition);
        break;
      case "o":
        opacity = AnimatableValueParser.parseInteger(reader, composition);
        break;
      case "fillEnabled":
        fillEnabled = reader.nextBoolean();
        break;
      case "r":
        fillTypeInt = reader.nextInt();
        break;
      default:
        reader.skipValue();
    }
  }

  Path.FillType fillType = fillTypeInt == 1 ? Path.FillType.WINDING : Path.FillType.EVEN_ODD;
  return new ShapeFill(name, fillEnabled, fillType, color, opacity);
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
static <T> Keyframe<T> parse(JsonReader reader, LottieComposition composition,
    float scale, ValueParser<T> valueParser, boolean animated) throws IOException {

  if (animated) {
    return parseKeyframe(composition, reader, scale, valueParser);
  } else {
    return parseStaticValue(reader, scale, valueParser);
  }
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
static <T> List<Keyframe<T>> parse(JsonReader reader,
    LottieComposition composition, float scale, ValueParser<T> valueParser)
    throws IOException {
  List<Keyframe<T>> keyframes = new ArrayList<>();

  if (reader.peek() == JsonToken.STRING) {
    composition.addWarning("Lottie doesn't support expressions.");
    return keyframes;
  }

  reader.beginObject();
  while (reader.hasNext()) {
    switch (reader.nextName()) {
      case "k":
        if (reader.peek() == JsonToken.BEGIN_ARRAY) {
          reader.beginArray();

          if (reader.peek() == JsonToken.NUMBER) {
            // For properties in which the static value is an array of numbers.
            keyframes.add(
                KeyframeParser.parse(reader, composition, scale, valueParser, false));
          } else {
            while (reader.hasNext()) {
              keyframes.add(KeyframeParser.parse(reader, composition, scale, valueParser, true));
            }
          }
          reader.endArray();
        } else {
          keyframes.add(KeyframeParser.parse(reader, composition, scale, valueParser, false));
        }
        break;
      default:
        reader.skipValue();
    }
  }
  reader.endObject();

  setEndFrames(keyframes);
  return keyframes;
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
private static AnimatableTextProperties parseAnimatableTextProperties(
    JsonReader reader, LottieComposition composition) throws IOException {
  AnimatableColorValue color = null;
  AnimatableColorValue stroke = null;
  AnimatableFloatValue strokeWidth = null;
  AnimatableFloatValue tracking = null;

  reader.beginObject();
  while (reader.hasNext()) {
    switch (reader.nextName()) {
      case "fc":
        color = AnimatableValueParser.parseColor(reader, composition);
        break;
      case "sc":
        stroke = AnimatableValueParser.parseColor(reader, composition);
        break;
      case "sw":
        strokeWidth = AnimatableValueParser.parseFloat(reader, composition);
        break;
      case "t":
        tracking = AnimatableValueParser.parseFloat(reader, composition);
        break;
      default:
        reader.skipValue();
    }
  }
  reader.endObject();

  return new AnimatableTextProperties(color, stroke, strokeWidth, tracking);
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
private static void parseChars(
    JsonReader reader, LottieComposition composition,
    SparseArrayCompat<FontCharacter> characters) throws IOException {
  reader.beginArray();
  while (reader.hasNext()) {
    FontCharacter character = FontCharacterParser.parse(reader, composition);
    characters.put(character.hashCode(), character);
  }
  reader.endArray();
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
static Mask parse(
    JsonReader reader, LottieComposition composition) throws IOException {
  Mask.MaskMode maskMode = null;
  AnimatableShapeValue maskPath = null;
  AnimatableIntegerValue opacity = null;

  reader.beginObject();
  while (reader.hasNext()) {
    String mode = reader.nextName();
    switch (mode) {
      case "mode":
        switch (reader.nextString()) {
          case "a":
            maskMode = Mask.MaskMode.MaskModeAdd;
            break;
          case "s":
            maskMode = Mask.MaskMode.MaskModeSubtract;
            break;
          case "i":
            maskMode = Mask.MaskMode.MaskModeIntersect;
            break;
          default:
            Log.w(L.TAG, "Unknown mask mode " + mode + ". Defaulting to Add.");
            maskMode = Mask.MaskMode.MaskModeAdd;
        }
        break;
      case "pt":
        maskPath = AnimatableValueParser.parseShapeData(reader, composition);
        break;
      case "o":
        opacity = AnimatableValueParser.parseInteger(reader, composition);
        break;
      default:
        reader.skipValue();
    }
  }
  reader.endObject();

  return new Mask(maskMode, maskPath, opacity);
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
static RectangleShape parse(
    JsonReader reader, LottieComposition composition) throws IOException {
  String name = null;
  AnimatableValue<PointF, PointF> position = null;
  AnimatablePointValue size = null;
  AnimatableFloatValue roundedness = null;

  while (reader.hasNext()) {
    switch (reader.nextName()) {
      case "nm":
        name = reader.nextString();
        break;
      case "p":
        position =
            AnimatablePathValueParser.parseSplitPath(reader, composition);
        break;
      case "s":
        size = AnimatableValueParser.parsePoint(reader, composition);
        break;
      case "r":
        roundedness = AnimatableValueParser.parseFloat(reader, composition);
        break;
      default:
        reader.skipValue();
    }
  }

  return new RectangleShape(name, position, size, roundedness);
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
static PathKeyframe parse(
    JsonReader reader, LottieComposition composition) throws IOException {
  boolean animated = reader.peek() == JsonToken.BEGIN_OBJECT;
  Keyframe<PointF> keyframe = KeyframeParser.parse(
      reader, composition, Utils.dpScale(), PathParser.INSTANCE, animated);

  return new PathKeyframe(composition, keyframe);
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
public static Layer parse(LottieComposition composition) {
  Rect bounds = composition.getBounds();
  return new Layer(
      Collections.<ContentModel>emptyList(), composition, "__container", -1,
      Layer.LayerType.PreComp, -1, null, Collections.<Mask>emptyList(),
      new AnimatableTransform(), 0, 0, 0, 0, 0,
      bounds.width(), bounds.height(), null, null, Collections.<Keyframe<Float>>emptyList(),
      Layer.MatteType.None, null);
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
static CircleShape parse(
    JsonReader reader, LottieComposition composition) throws IOException {
  String name = null;
  AnimatableValue<PointF, PointF> position = null;
  AnimatablePointValue size = null;
  boolean reversed = false;

  while (reader.hasNext()) {
    switch (reader.nextName()) {
      case "nm":
        name = reader.nextString();
        break;
      case "p":
        position = AnimatablePathValueParser.parseSplitPath(reader, composition);
        break;
      case "s":
        size = AnimatableValueParser.parsePoint(reader, composition);
        break;
      case "d":
        // "d" is 2 for normal and 3 for reversed.
        reversed = reader.nextInt() == 3;
        break;
      default:
        reader.skipValue();
    }
  }

  return new CircleShape(name, position, size, reversed);
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
static ShapeTrimPath parse(
    JsonReader reader, LottieComposition composition) throws IOException {
  String name = null;
  ShapeTrimPath.Type type = null;
  AnimatableFloatValue start = null;
  AnimatableFloatValue end = null;
  AnimatableFloatValue offset = null;

  while (reader.hasNext()) {
    switch (reader.nextName()) {
      case "s":
        start = AnimatableValueParser.parseFloat(reader, composition, false);
        break;
      case "e":
        end = AnimatableValueParser.parseFloat(reader, composition, false);
        break;
      case "o":
        offset = AnimatableValueParser.parseFloat(reader, composition, false);
        break;
      case "nm":
        name = reader.nextString();
        break;
      case "m":
        type = ShapeTrimPath.Type.forId(reader.nextInt());
        break;
      default:
        reader.skipValue();
    }
  }

  return new ShapeTrimPath(name, type, start, end, offset);
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
static ShapeGroup parse(
    JsonReader reader, LottieComposition composition) throws IOException {
  String name = null;
  List<ContentModel> items = new ArrayList<>();

  while (reader.hasNext()) {
    switch (reader.nextName()) {
      case "nm":
        name = reader.nextString();
        break;
      case "it":
        reader.beginArray();
        while (reader.hasNext()) {
          ContentModel newItem = ContentModelParser.parse(reader, composition);
          if (newItem != null) {
            items.add(newItem);
          }
        }
        reader.endArray();
        break;
      default:
        reader.skipValue();
    }
  }

  return new ShapeGroup(name, items);
}
 

import com.airbnb.lottie.LottieComposition; //导入依赖的package包/类
static Repeater parse(
    JsonReader reader, LottieComposition composition) throws IOException {
  String name = null;
  AnimatableFloatValue copies = null;
  AnimatableFloatValue offset = null;
  AnimatableTransform transform = null;

  while (reader.hasNext()) {
    switch (reader.nextName()) {
      case "nm":
        name = reader.nextString();
        break;
      case "c":
        copies = AnimatableValueParser.parseFloat(reader, composition, false);
        break;
      case "o":
        offset = AnimatableValueParser.parseFloat(reader, composition, false);
        break;
      case "tr":
        transform = AnimatableTransformParser.parse(reader, composition);
        break;
      default:
        reader.skipValue();
    }
  }

  return new Repeater(name, copies, offset, transform);
}