mat-reding-1525395-unsplash.jpg

0. 前言

你好，我是程序亦非猿，阿里資深無線開發工程師一枚。
歡迎關注我的公眾號：程序亦非猿

自我在內網發布了一篇關于 Lottie 的原理分析的文章之后，就不斷有同事來找我詢問關于 Lottie 的各種東西，最近又有同事來問，就想著可能對大家也會有所幫助，就稍作處理后分享出來。

需要注意的是，這文章寫于兩年前，基本版本 2.0.0-beta3，雖然我看過最新版本，主要的類沒有什么差別，不過可能還是會存在一些差異。

可以感受一下我兩年前的實力。:-D

1. Lottie 是什么？

Render After Effects animations natively on Android and iOS

Lottie 是 airbnb 發布的庫，它可以將 AE 制作的動畫 在 Android&iOS上以 native 代碼渲染出來，目前還支持了 RN 平臺。

來看幾個官方給出的動畫效果案例：

[圖片上傳失敗...(image-207758-1555986322657)]

[圖片上傳失敗...(image-6336b8-1555986322657)]

有沒有很炫酷？

就拿第一個動畫 Jump-through 舉例，如果讓你來實現它，你能在多少時間內完成？三天？一個禮拜？ google 的 Nick Butcher 剛好有一篇文章寫 Jump-through 的動畫實現，講述了整個實現過程，從文章里可以看出實現這個動畫并不容易，有興趣的可以看看 Animation: Jump-through。

但是現在有了 Lottie，只要設計師用 AE 設計動畫，利用 bodymovin 導出 ，導入到 assets, 再寫下面那么點代碼就可以實現了！

LottieAnimationView animationView = (LottieAnimationView) findViewById(R.id.animation_view);
animationView.setAnimation("PinJump.json");
animationView.loop(true);
animationView.playAnimation();

不用寫自定義 View！不用畫 Path！不用去計算這個點那個點！

是不是超級方便？！！！

這么方便的背后，原理是什么呢？

<a name="489878a0"></a>

2. TL;DR

bodymovin 將 AE 動畫導出為 ,該 描述了該動畫，而 lottie-android 的原理就是將 描述的動畫用 native code 翻譯出來， 其核心原理是 canvas 繪制。對，lottie 的動畫是靠純 canvas 畫出來的！！！動起來則是靠的屬性動畫。(ValueAnimator.ofFloat(0f, 1f); )

說具體點就是 lottie 隨屬性動畫修改 progress，每一個 Layer 根據當前的 progress 繪制所對應的幀內容，progress 值變為1，動畫結束。（有點類似于幀動畫）

當然說說簡單，lottie其實做了非常多的工作，后續將詳細解析 lottie-android 的實現原理。

<a name="efc22b8e"></a>

3. Lottie 關鍵類介紹

Lottie 提供了一個 LottieAnimationView 給用戶使用，而實際 Lottie 的核心是 LottieDrawable，它承載了所有的繪制工作，LottieAnimationView則是對LottieDrawable 的封裝，再附加了一些例如 解析 的功能。

• LottieComposition 是 對應的 Model，承載 的所有信息。
• CompositionLayer 是 layer 的集合。
• ImageAssetBitmapManager 負責管理動畫所需的圖片資源。

它們的關系：

[圖片上傳失敗...(image-ae8cb8-1555986176840)]

<a name="4879d65c"></a>

4. 文件的屬性含義

bodymovin 導出的 包含了動畫的一切信息, 動畫的關鍵幀信息，動畫該怎么做，做什么都包含在 里，Lottie 里所有的 Model 的數據都來自于這個 ( 該 對應的 Model 是LottieComposition)，所以要理解 Lottie 的原理，理解 的屬性是第一步。

屬性非常多，而且不同的動畫的 也有很大的差別，所以這里只講解部分重要的屬性。

<a name="424b1c61"></a>

4.1 文件最外部的結構

的最外層長這樣：

{
  "v": "4.5.9",
  "fr": 15,
  "ip": 0,
  "op": 75,
  "w": 500,
  "h": 500,
  "ddd": 0,
  "assets":[]
  "layers":[]
 }

屬性的含義：

從這里可以獲取 設計的動畫的寬高，幀相關的信息，動畫所需要的圖片資源的信息以及圖層信息。

<a name="854203e2"></a>

a) assets

圖片資源信息, 相關類 LottieImageAsset、 ImageAssetBitmapManager。

"assets": [
    {
      "id": "image_0",
      "w": 500,
      "h": 500,
      "u": "images/",
      "p": "voice_thinking_image_0.png"
    }
  ]

屬性的含義：

<a name="beb42690"></a>

b) layers

圖層信息，相關類：Layer、BaseLayer以及 BaseLayer 的實現類。

{
    "ddd": 0,
    "ind": 0,
    "ty": 2,
    "nm": "btnSlice.png",
    "cl": "png",
    "refId": "image_0",
    "ks": {....},
    "ao": 0,
    "ip": 0,
    "op": 90.0000036657751,
    "st": 0,
    "bm": 0,
    "sr": 1
}

屬性的含義：

Layer 可以理解為圖層，跟 PS 等工具的概念相同，每個 Layer 負責繪制自己的內容。

在 Lottie 里擁有不同的 Layer，目前有 PreComp,Solid,Image,Null,Shape,Text ，各個 Layer 擁有的屬性各不相同，這里只指出共有的屬性。

下圖為 Layer 相關類圖：

[圖片上傳失敗...(image-ad8301-1555986176840)]

<a name="4afd9264"></a>

5. Lottie 的適配原理

在開始使用 Lottie 的時候，我們團隊設計動畫走的跟設計圖片一樣的路子，想設計2x,3x 多份資源進行適配。但是，通過閱讀源碼發現其實 Lottie本身在 Android 平臺已經做了適配工作，而且適配原理很簡單，解析 時，從 讀取寬高之后 會再乘以手機的密度。再在使用的時候判斷適配后的寬高是否超過屏幕的寬高，如果超過則再進行縮放。以此保障 Lottie 在 Android 平臺的顯示效果。

核心代碼如下：

//LottieComposition.fromSync
  float scale = res.getDisplayMetrics().density;
  int width = .optInt("w", -1);
  int height = .optInt("h", -1);

  if (width != -1 && height != -1) {
    int scaledWidth = (int) (width * scale);
    int scaledHeight = (int) (height * scale);
    bounds = new Rect(0, 0, scaledWidth, scaledHeight);
  }
  
  //LottieAnimationView.setComposition 

    int screenWidth = Utils.getScreenWidth(getContext());
    int screenHeight = Utils.getScreenHeight(getContext());
    int compWidth = composition.getBounds().width();
    int compHeight = composition.getBounds().height();
    if (compWidth > screenWidth ||
        compHeight > screenHeight) {
      float xScale = screenWidth / (float) compWidth;
      float yScale = screenHeight / (float) compHeight;
      setScale(Math.min(xScale, yScale));
      Log.w(L.TAG, String.format(
          "Composition larger than the screen %dx%d vs %dx%d. Scaling down.",
          compWidth, compHeight, screenWidth, screenHeight));
    }

這里值得一提的是，設計師在設計動畫時要注意，需要設計的是1X 的動畫，而不是2X or 3X or 4X。

目前手淘用的方案是 按4X 來設計(1X看不清元素)，然后再縮小為1X，圖片資源是4X。

<a name="2dc96526"></a>

6. Lottie的繪制原理

LottieAnimationView 本身是個 ImageView，所以它的繪制流程跟 ImageView 一樣，所有的繪制其實在 LottieDrawable 控制的。

接下去看看它的源碼實現：

// LottieDrawable
@Override public void draw(@NonNull Canvas canvas) {
    if (compositionLayer == null) {
      return;
    }
    float scale = this.scale;
    if (compositionLayer.hasMatte()) {
      scale = Math.min(this.scale, getMaxScale(canvas));
    }

    matrix.reset();
    matrix.preScale(scale, scale);
    compositionLayer.draw(canvas, matrix, alpha);
  }

可以看到在 draw方法里調用了 compositionLayer.draw方法，由于 CompositionLayer 繼承了 BaseLayer，所以需要跟進 BaseLayer ，繼續跟蹤：

// BaseLayer.draw
  @Override
  public void draw(Canvas canvas, Matrix parentMatrix, int parentAlpha) {
    if (!visible) {
      return;
    }
    buildParentLayerListIfNeeded();
    //矩陣變換處理
    //....
    if (!hasMatteOnThisLayer() && !hasMasksOnThisLayer()) {
      matrix.preConcat(transform.getMatrix());
      //繪制 layer
      drawLayer(canvas, matrix, alpha);
      return;
    }
    //draw matteLayer& maskLayer
    //...
    canvas.restore();
  }

刪除了多余代碼，只保留核心代碼，可以看到 draw 方法里調用了抽象方法 drawLayer，在這里的實現在 CompositionLayer ，一起來看看：

@Override void drawLayer(Canvas canvas, Matrix parentMatrix, int parentAlpha) {
    //...
    for (int i = layers.size() - 1; i >= 0 ; i--) {
      boolean nonEmptyClip = true;
      if (!newClipRect.isEmpty()) {
        nonEmptyClip = canvas.clipRect(newClipRect);
      }
      if (nonEmptyClip) {
        layers.get(i).draw(canvas, parentMatrix, parentAlpha);
      }
    }
    //...
  }

上面的代碼中的 layers 是該動畫所包含的層，在 CompositionLayer 的 drawLayer 方法里遍歷了動畫所有的層，并調用layers 的 draw 方法，這樣就完成了所有的繪制。

<a name="df5cc73c"></a>

7. Lottie的動畫原理

上一小節講了 Lottie 的繪制原理，但是 Lottie 是用來做動畫的，光理解它的繪制原理是不夠的，對于動畫，更重要的是它怎么動起來的。

接下來就分析一下 Lottie 的動畫原理。

Lottie 動畫起始于 LottieAnimationView.playAnimation，接著調用 LottieDrawable 的同名方法，與繪制相同，動畫也是 LottieDrawable 控制的，來看看代碼：

//     animator 的申明
private final ValueAnimator animator = ValueAnimator.ofFloat(0f, 1f);

  private void playAnimation(boolean setStartTime) {
    if (compositionLayer == null) {
      playAnimationWhenCompositionAdded = true;
      reverseAnimationWhenCompositionAdded = false;
      return;
    }
    if (setStartTime) {
      animator.setCurrentPlayTime((long) (progress * animator.getDuration()));
    }
    animator.start();
  }

playAnimation 方法其實只是開啟了一個屬性動畫，那么后續動畫是怎么動起來的呢？這就必須要看動畫的監聽了：

animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
      @Override public void onAnimationUpdate(ValueAnimator animation) {
        if (systemAnimationsAreDisabled) {
          animator.cancel();
          setProgress(1f);
        } else {
          setProgress((float) animation.getAnimatedValue());
        }
      }
    });

在 animator 進行的過程中回去調用 setProgress方法,下面跟蹤一下代碼：

//LottieDrawable
  public void setProgress(@FloatRange(from = 0f, to = 1f) float progress) {
    this.progress = progress;
    if (compositionLayer != null) {
      compositionLayer.setProgress(progress);
    }
  }
  
  //CompositionLayer
  @Override public void setProgress(@FloatRange(from = 0f, to = 1f) float progress) {
    super.setProgress(progress);
    progress -= layerModel.getStartProgress();
    for (int i = layers.size() - 1; i >= 0; i--) {
      layers.get(i).setProgress(progress);
    }
  }

//BaseLayer
  void setProgress(@FloatRange(from = 0f, to = 1f) float progress) {
    //...
    for (int i = 0; i < animations.size(); i++) {
      animations.get(i).setProgress(progress);
    }
  }

//BaseKeyframeAnimation
  void setProgress(@FloatRange(from = 0f, to = 1f) float progress) {
    if (progress < getStartDelayProgress()) {
      progress = 0f;
    } else if (progress > getEndProgress()) {
      progress = 1f;
    }

    if (progress == this.progress) {
      return;
    }
    this.progress = progress;

    for (int i = 0; i < listeners.size(); i++) {
      listeners.get(i).onValueChanged();
    }
  }

//BaseLayer
  @Override public void onValueChanged() {
    invalidateSelf();
  }

//BaseLayer
  private void invalidateSelf() {
    lottieDrawable.invalidateSelf();
  }

上面列出了后續流程的主要代碼，可以看到，setProgress 的最后觸發了每個 layer 的 invalidateSelf，這都會讓 lottieDrawable 重新繪制，然后重走一遍繪制流程，這樣隨著 animator 動畫的進行，lottieDrawable 不斷的繪制，就展現出了一個完整的動畫。

PS: 動畫過程中的一些變量比如 scale，都是由BaseKeyframeAnimation控制，但這個偏于細節，這里就不講了。

動畫原理流程稍微有點長，也稍微有些復雜，我繪制了一張圖梳理了一下整體的流程，方便理解：

這里的圖片死活上傳不上去，誒，簡書藥丸啊。

麻煩各位移步：https://juejin.im/post/5cbe760cf265da03a85ac0a8

8. 總結

個人覺得 Lottie 是個非常非常棒的項目，甚至可以說是個偉大的項目。

Lottie 極大的縮減了動畫的開發成本，給 APP 增加非常強力的動畫能力，不需要各個端再自己去實現，而且目前 Lottie 已經支持了非常多的 AE 動畫效果，通過 Lottie 可以輕松實現很多酷炫的效果，所以現在做動效考驗的是設計同學的設計能力了，哈哈。

本文只針對重點原理進行分析，歡迎留言討論交流。

9. 資料

1. lottie-android : https://github.com/airbnb/lottie-android
2. Introducing Lottie: https://medium.com/airbnb-engineering/introducing-lottie-4ff4a0afac0e
3. design-lottie: https://airbnb.design/lottie/
4. bodymovin: https://github.com/bodymovin/bodymovin
5. Animation: Jump-through: https://medium.com/google-developers/animation-jump-through-861f4f5b3de4