// build.gradle依赖对应的版本就可以玩起来了
implementation "com.airbnb.android:lottie:$lottieVersion"

#LottieAnimationView
public void setAnimation(final String assetName);

#LottieAnimationView
public void setAnimationFromUrl(String url);

#LottieAnimationView
public void setComposition(@NonNull LottieComposition composition);

#LottieCompositionFactory
public static LottieResult<LottieComposition> fromXXXSync(XXX xxx  ...);

#LottieCompositionFactory
// 最终方法
public static LottieResult<LottieComposition> fromJsonReaderSync(JsonReader reader, @Nullable String cacheKey);

#LottieResult<LottieComposition>
@Nullable public LottieComposition getValue();

#LottieCompositionFactory
public static LottieTask<LottieComposition> fromXXX(XXX xxx ...);

#LottieTask<LottieComposition
public synchronized LottieTask<LottieComposition> addListener(LottieListener<LottieComposition> listener)

public interface LottieListener<LottieComposition> {
  void onResult(LottieComposition result);
}

public class LottieDrawable extends Drawable implements Drawable.Callback, Animatable

#LottieAnimationView
public <T> void addValueCallback(KeyPath keyPath, T property, LottieValueCallback<T> callback);

#LottieAnimationView
// 通过此方法可以获取传参相关的所有KeyPath，可传通配符*和全匹配符**
public List<KeyPath> resolveKeyPath(KeyPath keyPath);

mPetActionCore.setImageAssetDelegate(new ImageAssetDelegate() {
    @Override
    public Bitmap fetchBitmap(LottieImageAsset asset) {
		// 如果传null，Lottie会不断获取，知道不为null为止，原理在后面会讲解
		return null;
    }
});

// LottieImageAsset属性
public class LottieImageAsset {
  private final int width;
  private final int height;
  private final String id;
  private final String fileName;
  private final String dirName;
  @Nullable private Bitmap bitmap;
}

mPetActionCore.setFontAssetDelegate(new FontAssetDelegate(){
    // 可以通过fontFamily加载对应Typeface
    public Typeface fetchFont(String fontFamily) {
    }
    // 可以通过fontFamily返回assets的字体文件路径
    public String getFontPath(String fontFamily) {
    }
});

mPetActionCore.setTextDelegate(new TextDelegate(mPetActionCore) {
    // 一些列替换文本的方法
    ...
});

// 开启性能检测，最好判断环境，例如在测试环境才开启
// 这里需要注意，该设置必须在设置LottieComposition之后，源码是最好的老师，不懂就去看看，这个后面源码分析就不作分析了
PerformanceTracker performanceTracker = mPetActionCore.getPerformanceTracker();
if (performanceTracker != null) {
    mPetActionCore.setPerformanceTrackingEnabled(true);
}

// 通过该方法可以打印每个图层渲染所需要的时间
// 注意，该方法必须在执行动画之后调用
PerformanceTracker performanceTracker = mPetActionCore.getPerformanceTracker();
if (performanceTracker != null) {
    List<Pair<String, Float>> sortedRenderTimes = performanceTracker.getSortedRenderTimes();
    Log.d(TAG, "各图层渲染时间:");
    for (int i = 0; i < sortedRenderTimes.size(); i++) {
        Pair<String, Float> layer = sortedRenderTimes.get(i);
        Log.d(TAG, String.format("\t\t%30s:%.2f", layer.first, layer.second));
    }
}

// 这里传授一个动画帧率是否稳定的黑科技，就是打印动画执行进度，如果打印的内容比平时少，说明就是丢帧了
// 也可以通过Choreographer，Lottie内部就是通过它刷新的
mPetActionCore.addAnimatorUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
    @Override
    public void onAnimationUpdate(ValueAnimator animation) {
        Log.d(TAG, "ActionType:" + mRunningActionType + " onAnimationUpdate--->" + animation.getAnimatedFraction());
    }
});

Log.w(VIEW_LOG_TAG, getClass().getSimpleName() + " not displayed because it is"
            + " too large to fit into a software layer (or drawing cache), needs "
            + projectedBitmapSize + " bytes, only "
            + drawingCacheSize + " available");

lottieAnimationView.setAnimation("xxx.json");
lottieAnimationView.playAnimation();

#LottieAnimationView
public void setAnimation(final String assetName) {
    ...
    setCompositionTask(LottieCompositionFactory.fromAsset(getContext(), assetName));
}

private void setCompositionTask(LottieTask<LottieComposition> compositionTask) {
    ...
    this.compositionTask = compositionTask
            .addListener(loadedListener)
            .addFailureListener(failureListener);
}

#LottieCompositionFactory
public static LottieTask<LottieComposition> fromAsset(Context context, final String fileName) {
    final Context appContext = context.getApplicationContext();
    // 这里大致判断是个异步任务，call里是个同步获取
    return cache(fileName, new Callable<LottieResult<LottieComposition>>() {
      @Override public LottieResult<LottieComposition> call() {
        return fromAssetSync(appContext, fileName);
      }
    });
}
#LottieCompositionFactory
private static LottieTask<LottieComposition> cache(
          @Nullable final String cacheKey, Callable<LottieResult<LottieComposition>> callable) {
    final LottieComposition cachedComposition = LottieCompositionCache.getInstance().get(cacheKey);
    //  LottieCompositionCache是一个根据cacheKey存储LottieComposition的缓存类，内部实现是LruCache
    if (cachedComposition != null) {
      return new LottieTask<>(new Callable<LottieResult<LottieComposition>>() {
        @Override
        public LottieResult<LottieComposition> call() {
          // 读取到缓存直接封装成LottieResult，LottieTask直接返回
          return new LottieResult<>(cachedComposition);
        }
      });
    }
    // 可以认为是二级缓存，但不完全是，taskCache是用于防止LottieTask重复创建的缓存
    if (taskCache.containsKey(cacheKey)) {
      // 如果当前cacheKey已存在创建的LottieTask正在执行任务就直接返回
      return taskCache.get(cacheKey);
    }
    // 如果都没缓存的情况，创建LottieTask，传入callable
    LottieTask<LottieComposition> task = new LottieTask<>(callable);
    task.addListener(new LottieListener<LottieComposition>() {
      @Override public void onResult(LottieComposition result) {
        if (cacheKey != null) {
          // 对应开头，任务加载成功根据cacheKey缓存
          LottieCompositionCache.getInstance().put(cacheKey, result);
        }
        // 任务结束，正在执行任务缓存移除
        taskCache.remove(cacheKey);
      }
    });
    task.addFailureListener(new LottieListener<Throwable>() {
      @Override public void onResult(Throwable result) {
        // 任务失败，正在执行任务缓存移除
        taskCache.remove(cacheKey);
      }
    });
    // 把当前任务存储正在执行列表，保证正在执行不重复创建
    taskCache.put(cacheKey, task);
    return task;
}

#LottieTask
public LottieTask(Callable<LottieResult<T>> runnable) {
    this(runnable, false);
}
#LottieTask
LottieTask(Callable<LottieResult<T>> runnable, boolean runNow) {
    task = new FutureTask<>(runnable);
    if (runNow) {
      try {
        setResult(runnable.call());
      } catch (Throwable e) {
        setResult(new LottieResult<T>(e));
      }
    } else {
      // 必然会走else，通过线程池执行任务
      EXECUTOR.execute(task);
      startTaskObserverIfNeeded();
    }
 }

#LottieTask
private synchronized void startTaskObserverIfNeeded() {
    // 如果线程存活或者已经知道结果，直接return
    if (taskObserverAlive() || result != null) {
      return;
    }
    taskObserver = new Thread("LottieTaskObserver") {
      private boolean taskComplete = false;
      @Override public void run() {
        // 死循环
        while (true) {
          // 线程被中断或者任务完成直接结束循环
          if (isInterrupted() || taskComplete) {
            return;
          }
          // 判断任务是否执行完成
          if (task.isDone()) {
            try {
              // 赋值结果
              setResult(task.get());
            } catch (InterruptedException | ExecutionException e) {
              setResult(new LottieResult<T>(e));
            }
            taskComplete = true;
            // 停止检测任务
            stopTaskObserverIfNeeded();
          }
        }
      }
    };
    // 线程开始执行
    taskObserver.start();
}
#LottieTask
private void setResult(@Nullable LottieResult<T> result) {
    // 本地缓存并通知回调
    this.result = result;
    notifyListeners();
}
#LottieTask
private void notifyListeners() {
    // 执行是在子线程，所以需要切到主线程
    handler.post(new Runnable() {
      @Override public void run() {
        if (result == null || task.isCancelled()) {
          return;
        }
        // 通知回调
        LottieResult<T> result = LottieTask.this.result;
        if (result.getValue() != null) {
          notifySuccessListeners(result.getValue());
        } else {
          notifyFailureListeners(result.getException());
        }
      }
    });
}
#LottieTask
private void notifySuccessListeners(T value) {
    // 通知回调
    List<LottieListener<T>> listenersCopy = new ArrayList<>(successListeners);
    for (LottieListener<T> l : listenersCopy) {
      l.onResult(value);
    }
}
#LottieTask
public synchronized LottieTask<T> addListener(LottieListener<T> listener) {
    if (result != null && result.getValue() != null) {
      listener.onResult(result.getValue());
    }
    successListeners.add(listener);
    // 这里解释下为什么addListener也会开启检测任务，在stopTaskObserverIfNeeded会判断successListeners为空就会中断检测任务，作者想的挺多
    startTaskObserverIfNeeded();
    return this;
}

#LottieCompositionFactory
public static LottieResult<LottieComposition> fromAssetSync(Context context, String fileName) {
	...
	// 创建cacheKey
	String cacheKey = "asset_" + fileName;
	if (fileName.endsWith(".zip")) {
		// 通过zip加载，其实内部还是fromJsonInputStreamSync
		return fromZipStreamSync(new ZipInputStream(context.getAssets().open(fileName)), cacheKey);
	}
	return fromJsonInputStreamSync(context.getAssets().open(fileName), cacheKey);
	...
}
#LottieCompositionFactory
public static LottieResult<LottieComposition> fromJsonInputStreamSync(InputStream stream, @Nullable String cacheKey) {
    return fromJsonInputStreamSync(stream, cacheKey, true);
}
#LottieCompositionFactory
private static LottieResult<LottieComposition> fromJsonInputStreamSync(InputStream stream, @Nullable String cacheKey, boolean close) {
	...
	// 无论你是通过什么类型加载，最后都是通过fromJsonReaderSync
	return fromJsonReaderSync(new JsonReader(new InputStreamReader(stream)), cacheKey);
}
#LottieCompositionFactory
public static LottieResult<LottieComposition> fromJsonReaderSync(JsonReader reader, @Nullable String cacheKey) {
	...
	// 开始解析，核心部分
	LottieComposition composition = LottieCompositionParser.parse(reader);
	// 这里又一次缓存
	LottieCompositionCache.getInstance().put(cacheKey, composition);
	return new LottieResult<>(composition);
}
#LottieCompositionParser
// JsonReader可能很多人很少用，这是Android提供用来解析json
public static LottieComposition parse(JsonReader reader) throws IOException {
    // 屏幕密度，用来适配
    float scale = Utils.dpScale();
    // 首帧
    float startFrame = 0f;
    // 结束帧
    float endFrame = 0f;
    // 帧率
    float frameRate = 0f;
    // 根据Layer的id存储Layer
    final LongSparseArray<Layer> layerMap = new LongSparseArray<>();
    // 首层能解析出来的Layer
    final List<Layer> layers = new ArrayList<>();
    // 动画宽高
    int width = 0;
    int height = 0;
    // 根据assets层id存储Layer集合
    Map<String, List<Layer>> precomps = new HashMap<>();
    // 根据assets层id存储assets相关信息
    Map<String, LottieImageAsset> images = new HashMap<>();
    // 根据字体名字存储字体相关信息，不作介绍
    Map<String, Font> fonts = new HashMap<>();
    // 根据编码hashcode存储编码相关信息，不作介绍
    SparseArrayCompat<FontCharacter> characters = new SparseArrayCompat<>();
    // 初始化LottieComposition
    LottieComposition composition = new LottieComposition();
    reader.beginObject();
    while (reader.hasNext()) {
      // 根据json解析，没写注解的参考上方注解
      switch (reader.nextName()) {
        case "w":
          width = reader.nextInt();
          break;
        case "h":
          height = reader.nextInt();
          break;
        case "ip":
          startFrame = (float) reader.nextDouble();
          break;
        case "op":
          endFrame = (float) reader.nextDouble() - 0.01f;
          break;
        case "fr":
          frameRate = (float) reader.nextDouble();
          break;
        case "v":
          // 解析bodymovin版本
          break;
        case "layers":
          // 解析图层，不作分析，意义不大，重要的类Layer
          parseLayers(reader, composition, layers, layerMap);
          break;
        case "assets":
          // 解析位图信息，重要的类LottieImageAsset
          parseAssets(reader, composition, precomps, images);
          break;
        case "fonts":
          parseFonts(reader, fonts);
          break;
        case "chars":
          parseChars(reader, composition, characters);
          break;
        default:
          reader.skipValue();
      }
    }
    reader.endObject();
    // 根据屏幕密度重新调整宽高
    int scaledWidth = (int) (width * scale);
    int scaledHeight = (int) (height * scale);
    Rect bounds = new Rect(0, 0, scaledWidth, scaledHeight);
    // composition开始初始化，至此composition结构也不用看了，就是这些
    composition.init(bounds, startFrame, endFrame, frameRate, layers, layerMap, precomps,
        images, characters, fonts);
    return composition;
}
// 具体怎么解析出来不贴代码，真的很繁琐，看看上面就懂了，而且这个意义并不大
public class Layer {
	// 就是shape，各种形状
	private final List<ContentModel> shapes;
	// 内部引用LottieComposition，可能是想单layer获取全局信息，只看到了字体有用到
	private final LottieComposition composition;
	// 图层命名
	private final String layerName;
	// 图层id
	private final long layerId;
	// 图层类型，目前有组合，固态（纯色填充），位图，Null（不作任何事情），Shape，文本，Unknown（不认识，可能手动改的吧）
	private final LayerType layerType;
	// 父层id
	private final long parentId;
	// 引用id，用于获取位图
	@Nullable private final String refId;
	// 蒙版信息，支持3种模式，相加，相减，交集模式
	private final List<Mask> masks;
	// 变化属性，锚点，位置，旋转，缩放，透明度
	private final AnimatableTransform transform;
	// 填充宽度
	private final int solidWidth;
	// 填充高度
	private final int solidHeight;
	// 填充色
	private final int solidColor;
	// 快进比例
	private final float timeStretch;
	// 开始帧
	private final float startFrame;
	// 组合层宽度
	private final int preCompWidth;
	// 组合层高度
	private final int preCompHeight;
	// 文本关键帧动画
	@Nullable private final AnimatableTextFrame text;
	// 文本颜色，边框宽，边框颜色，追踪关键帧动画
	@Nullable private final AnimatableTextProperties textProperties;
	// 时间重置关键帧动画
	@Nullable private final AnimatableFloatValue timeRemapping;
	// 起始结束关键帧动画
	private final List<Keyframe<Float>> inOutKeyframes;
	// 遮罩类型，支持两种，正常和反转
	private final MatteType matteType;
}

public class LottieImageAsset {
	// 位图宽度
	private final int width;
	// 位图高度
	private final int height;
	// 位图id
	private final String id;
	// 位图命名
	private final String fileName;
	// 位图相对目录名，这个是相对设计师给你文件
	private final String dirName;
	// 当前已缓存的bitmap
	@Nullable private Bitmap bitmap;
}

#LottieAnimationView
private final LottieListener<LottieComposition> loadedListener = new LottieListener<LottieComposition>() {
    @Override public void onResult(LottieComposition composition) {
      // 突然到这里，一直云里雾里的同学可能更加懵逼了
      // 加载并解析构建成LottieComposition，LottieAnimationView设置
      setComposition(composition);
    }
};

#LottieAnimationView
public void setComposition(@NonNull LottieComposition composition) {
    ...
    // lottieDrawable设置composition
    boolean isNewComposition = lottieDrawable.setComposition(composition);
    ...
    // LottieAnimationView设置drawable
    setImageDrawable(lottieDrawable);
    ...
}

#LottieDrawable
@Override public void draw(@NonNull Canvas canvas) {
    ...
    // 核心渲染，compositionLayer怎么来的？貌似LottieDrawable的setComposition还有一些文章
    compositionLayer.draw(canvas, matrix, alpha);
    ...
}
#LottieDrawable
public boolean setComposition(LottieComposition composition) {
    ...
    buildCompositionLayer();
    ...
}
#LottieDrawable
private void buildCompositionLayer() {
    // 又构建了个新玩意CompositionLayer，这就是组合/合成图层
    compositionLayer = new CompositionLayer(
        this, LayerParser.parse(composition), composition.getLayers(), composition);
}
// CompositionLayer集成BaseLayer
public class CompositionLayer extends BaseLayer {
	...
	private final List<BaseLayer> layers = new ArrayList<>();
	...
	// layerModel是手动构建命名为__container，当然指的是LottieDrawable里边的
	public CompositionLayer(LottieDrawable lottieDrawable, Layer layerModel, List<Layer> layerModels,
      LottieComposition composition) {
		...
		// 把所有layer转化成BaseLayer
		for (int i = layerModels.size() - 1; i >= 0; i--) {
		  Layer lm = layerModels.get(i);
		  BaseLayer layer = BaseLayer.forModel(lm, lottieDrawable, composition);
		  ...
		  layers.add(0, layer);
		  ...
		}
		...
      }
      ...
}
#BaseLayer
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:
        return null;
    }
}
#BaseLayer
// 再回到LottieDrawable的draw方法，里边通过CompositionLayer调用draw方法，而CompositionLayer继承BaseLayer
@Override
public void draw(Canvas canvas, Matrix parentMatrix, int parentAlpha) {
	...
	drawLayer(canvas, matrix, alpha);
	...
}
#CompositionLayer
@Override void drawLayer(Canvas canvas, Matrix parentMatrix, int parentAlpha) {
    ...
    for (int i = layers.size() - 1; i >= 0 ; i--) {
		...
		// 这里BaseLayer就是上边通过layer转化后的
		BaseLayer layer = layers.get(i);
		layer.draw(canvas, parentMatrix, parentAlpha);
		...
    }
    ...
}
// 这里只挑选场景Image作讲解，主要为了解释前面的坑，其它的感兴趣可以看源码
public class ImageLayer extends BaseLayer {
	...
	@Override public void drawLayer(@NonNull Canvas canvas, Matrix parentMatrix, int parentAlpha) {
	    // 获取bitmap
	    Bitmap bitmap = getBitmap();
	    ...
	    // 最后作draw，很简单
	    canvas.drawBitmap(bitmap, src, dst , paint);
	    ...
	}
	@Nullable
	private Bitmap getBitmap() {
		// refId前面介绍的引用id
		String refId = layerModel.getRefId();
		return lottieDrawable.getImageAsset(refId);
	}
	...
}
#LottieDrawable
@Nullable public Bitmap getImageAsset(String id) {
	ImageAssetManager bm = getImageAssetManager();
	if (bm != null) {
	  return bm.bitmapForId(id);
	}
	return null;
}
#LottieDrawable
private ImageAssetManager getImageAssetManager() {
	...
	// 注意这，一旦创建过，不会第二次构建
	if (imageAssetManager == null) {
	  imageAssetManager = new ImageAssetManager(getCallback(),
	      imageAssetsFolder, imageAssetDelegate, composition.getImages());
	}
	return imageAssetManager;
}
#ImageAssetManager
@Nullable public Bitmap bitmapForId(String id) {
	// 解析的时候存储的
	LottieImageAsset asset = imageAssets.get(id);
	// 如果LottieImageAsset已经有缓存bitmap直接返回
	Bitmap bitmap = asset.getBitmap();
	if (bitmap != null) {
	  return bitmap;
	}
	// 如果有设置代理直接从代理里面取
	// 这也为什么声称可以一直取直到取到，不停绘制不停取，不是废话吗，太让我失望了（手动狗头）
	if (delegate != null) {
	  bitmap = delegate.fetchBitmap(asset);
	  if (bitmap != null) {
	    // 就是上面的缓存
	    putBitmap(id, bitmap);
	  }
	  return bitmap;
	}
	...
	if (filename.startsWith("data:") && filename.indexOf("base64,") > 0) {
	  // 解析到base64格式创建返回
	  byte[] data = Base64.decode(filename.substring(filename.indexOf(',') + 1), Base64.DEFAULT);
	  ...
	  bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, opts);
	  return putBitmap(id, bitmap);
	}
	...
	// 默认通过assets目录
	InputStream is = context.getAssets().open(imagesFolder + filename);
	...
	bitmap = BitmapFactory.decodeStream(is, null, opts);
	// 综上可知，通过外部设置一共就两种，通过设置aseets图片目录，设置图片代理，那么在这两种方式切换就很容易出问题，出现乱码，为什么？因为ImageAssetManager只有setDelegate方法而没有setImagesFolder方法
	// imagesFolder只能通过构造方法传入，只能一次机会，所以你前一次通过delegate方式获取图片，而第二次通过imagesFolder方式获取图片是有问题的，imagesFolder并不会改变
	return putBitmap(id, bitmap);
}

@BindLayout(layoutId = R.layout.item_type_one)
public class TypeOneViewHolder extends BaseViewHolder<MultiTypeEntity> {
    ...
    @Override
    protected void showData(MultiTypeEntity data, int position) {
        super.showData(data, position);
        ((TextView) itemView).setText("type:" + data.getItemType() + " isVisible:" + mSubject.isVisible());
    }
    ...
}

// 这里需要一个注意点，如果你采用的MTRVA的标准模式，也就是带level的模式，同时又是通过注解绑定就需要空注册，非注解而是下面这种无需空注册
mHelper.registerModule(0)
        .type(TypeOne.TYPE)
        .layoutResId(R.layout.item_type_one)
        .register();
        
// 空注册
mHelper.registerModule(Integer.MIN_VALUE).register();

@NonNull
@Override
public final CrazyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
    mContext = parent.getContext();
    LayoutInflater inflater = LayoutInflater.from(mContext);
    // 在这，我们获取到组件的class对象
    Class<? extends CrazyViewHolder> vhClass = mResourceManager.get(viewType);
    // 通过注解获取布局文件
    BindLayout layoutAnnotation = vhClass.getAnnotation(BindLayout.class);
    int layoutId;
    if (layoutAnnotation == null) {
        // 如果拿不到注解就会MTRVA去拿
        layoutId = mHelper.getLayoutId(viewType);
    } else {
        layoutId = layoutAnnotation.layoutId();
    }
    if (layoutId == 0) {
        // 如果都拿不到，就会抛出异常
        throw new RuntimeException("请在子组件中使用BindLayout注解绑定layoutId或者通过AdapterHelper注册layoutId");
    }
    // 通过布局文件id创建view
    View view = getItemView(inflater, parent, layoutId);
    // 通过反射创建组件
    CrazyViewHolder viewHolder = createCrazyViewHolder(vhClass, view);
    CrazyViewHolder vh = viewHolder == null ? new CrazyViewHolder(view) : viewHolder;
    // 子Adapter可以对组件特殊处理
    onViewHolderCreated(vh);
    return vh;
}

// 多用于动态注册，key为itemType
public final void register(int itemType, Class<? extends CrazyViewHolder> vhClass) {
    mResourceManager.put(itemType, vhClass);
}
// 例子
register(TypeOne.TYPE, TypeOneViewHolder.class);

// 自己创建一个map集合传入
public CrazyAdapter(@NonNull RecyclerViewAdapterHelper<T> helper, @NonNull SparseArray<Class<? extends CrazyViewHolder>> manager) {
    ...
}

// 出生
public CrazyViewHolder(@NonNull View itemView) {
    super(itemView);
}
// 出现
protected void onViewAttachedToWindow() {
}
// 消失
protected void onViewDetachedFromWindow() {
}
// 死亡，开始轮回
protected void onViewRecycled() {
}

组件和主容器通信需要一个桥梁，这里提供一个接口，一般为Adapter实现该接口
public interface ComponentSubject {

    // 获取主容器的上拉加载状态
    int loadMoreState();

    // 除了拉模式，还有推模式，但是推模式最好需要一个响应的过程，这里提供标识接口IEvent
    // 标识接口你可以实现各种各样的功能，除了上拉加载，你也可以实现主容器的生命周期监听等等
    void notifyEvent(@NonNull Object event, @Nullable IEvent callback);
}

@Override
public void notifyEvent(@NonNull Object event, @Nullable IEvent iEvent) {
    // 可以把该事件通知给主容器
    if (mEventCallback != null) {
        mEventCallback.onEvent(event, iEvent);
    }
    // 当然也可以把该事件由Adapter处理，主容器和组件通信需要Adapter协调，起到封装隔离的作用，具体看你的业务场景，没有具体的架构
    if (event instanceof LoadMore && iEvent instanceof LoadMoreEvent) {
        // 一切的上拉加载真正的逻辑处理全由LoadMoreHelper处理
        mLoadMoreHelper.handleLoadMoreEvent((LoadMore) event, (LoadMoreEvent) iEvent);
    }
}

public class LoadMoreHelper {
    ...
    // 开启上拉加载
    public void setLoadMoreEnable(boolean loadMoreEnable) {
        ...
    }
    // 加载状态
    public int loadMoreState() {
        return loadMoreState;
    }
    // 隐藏上拉加载
    public void loadMoreGone() {
        ...
    }
    // 开始加载
    private void loadMoreLoading() {
        ...
    }
    // 加载完成
    public void loadMoreCompleted() {
        ...
    }
    // 加载失败
    public void loadMoreFailed() {
        ...
    }
    // 加载结束
    public void loadMoreEnd() {
        loadMoreState = LoadMoreViewHolder.STATE_END;
        if (loadMoreEvents == null) {
            return;
        }
        for (LoadMoreEvent event : loadMoreEvents) {
            event.onEnd();
        }
    }
    // 默认加载
    public void loadMoreDefault() {
        ...
    }
    // 处理一些组件的通知时间，例如上拉加载初始化，开始加载等等
    public void handleLoadMoreEvent(@NonNull LoadMore loadMore, @NonNull LoadMoreEvent event) {
        if (loadMore.state == LoadMore.STATE_INIT) {
            if (loadMoreEvents == null) {
                loadMoreEvents = new HashSet<>();
            }
            loadMoreEvents.add(event);
            return;
        }
        ...
    }
    ...
}

public class LoadMoreViewHolder extends BaseViewHolder implements LoadMoreEvent{
	...
	@Override
    public void onEnd() {
        // 组件处理加载结束的UI逻辑
        ...
    }
    ...
}

public interface LoadMoreEvent extends IEvent {
    // 默认
    void onDefault();
    // 隐藏
    void onGone();
    // 加载
    void onLoading();
    // 失败
    void onFailed();
    // 完成
    void onCompleted();
    // 结束
    void onEnd();
}

Observable
        .create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                int i = 0;
                while (true) {
                    // 无限发射数据
                    e.onNext(i++);
                }
            }
        })
        .subscribeOn(Schedulers.newThread())
        .observeOn(Schedulers.newThread())
        .subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                // 每隔5s处理事件，期间将有大量的事件被存储
                Thread.sleep(5000);
            }
        });