Glide生命周期时间监听流程逻辑

Glide 如何实现的生命周期监听

问题？？

1. 使用过Glide的，都知道Glide加载图片生命周期跟随activity 或者 Fragemnt,那么glide是如何实现对activity、fragment 生命周期的监听的呢？
2. 那他们绑定的具体的逻辑是什么呢 ？

解释

• 对于第一个问题

  • 通过上一篇文章 我们知道其内部是通过 给宿主添加一个RequestManagerFragment（无界面Fragment）并通过 ActivityFragmentLifecycle 添加监听事件 完成的 生命周期绑定

• 对于第二个问题 要从生命周期的绑定步骤说起

  • 1. 创建 RequestManagerFragment

       • public class RequestManagerFragment extends Fragment {
             private final ActivityFragmentLifecycle lifecycle;
             public RequestManagerFragment() {
                 this(new ActivityFragmentLifecycle());
             }
             RequestManagerFragment(ActivityFragmentLifecycle lifecycle) {
                 this.lifecycle = lifecycle;
             }
             @Override
             public void onStart() {
                 super.onStart();
                 lifecycle.onStart();
             }
             @Override
             public void onStop() {
                 super.onStop();
                 lifecycle.onStop();
             }
             @Override
             public void onDestroy() {
                 super.onDestroy();
                 lifecycle.onDestroy();
             }
         }
         

       • 该Fragment内创建了一个ActivityFragmentLifecycle，并重写了Fragment生命周期相关方法onStart(),onPause(),onDestroy(),并在这些生命周期方法内调用了ActivityFragmentLifecycle对应的生命周期方法

    2. 将RequestManagerFragment添加到宿主Activity或者Framgnt上

       • RequestManagerFragment getRequestManagerFragment(final android.app.FragmentManager fm) {
             RequestManagerFragment current= new RequestManagerFragment();
             pendingRequestManagerFragments.put(fm, current);   fm.beginTransaction().add(current,FRAGMENT_TAG).commitAllowingStateLoss();}
         

       • 上面代码实现了宿主绑定，只要完成宿主绑定就能监听宿主的生命周期了，应为Fragment同步于activity，或者Fragemnt 的生命周期

    3. 创建RequestManager

       • public class RequestManager implements LifecycleListener {
             public RequestManager(Context context, Lifecycle lifecycle, RequestManagerTreeNode treeNode) {
                 this(context, lifecycle, treeNode, new RequestTracker(), new ConnectivityMonitorFactory());
             }
         
             RequestManager(Context context, final Lifecycle lifecycle, RequestManagerTreeNode treeNode,
                     RequestTracker requestTracker, ConnectivityMonitorFactory factory) {
                 this.lifecycle = lifecycle;
                 // 添加LifecycleListener监听事件
                 lifecycle.addListener(this);
             }
             @Override
             public void onStart() {
                 resumeRequests();
             }
             @Override
             public void onStop() {
                 pauseRequests();
             }
             @Override
             public void onDestroy() {
                 requestTracker.clearRequests();
             }
         }
         

       • 将 RequestManagerFragment内的ActivityFragmentLifecycle传递进去

       • RequestManager实现了LifecycleListener

       • 给ActivityFragmentLifecycle添加LifecycleListener事件

  • 通过上面代码加描述我们知道 生命周期事件的传递是通过ActivityFragmentLifecycle完成的

    • class ActivityFragmentLifecycle implements Lifecycle {
          private final Set<LifecycleListener> lifecycleListeners =
                  Collections.newSetFromMap(new WeakHashMap<LifecycleListener, Boolean>());
          private boolean isStarted;
          private boolean isDestroyed;
          @Override
          public void addListener(LifecycleListener listener) {
              lifecycleListeners.add(listener);
      
              if (isDestroyed) {
                  listener.onDestroy();
              } else if (isStarted) {
                  listener.onStart();
              } else {
                  listener.onStop();
              }
          }
         // 遍历集合 通知监听器
          void onStart() {
              isStarted = true;
              for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
                  lifecycleListener.onStart();
              }
          }
      // 遍历集合 通知监听器
          void onStop() {
              isStarted = false;
              for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
                  lifecycleListener.onStop();
              }
          }
      // 遍历集合 通知监听器
          void onDestroy() {
              isDestroyed = true;
              for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
                  lifecycleListener.onDestroy();
              }
          }
      }
      

    • ActivityFragmentLifecycle实现了Lifecycle接口

    • 在其addListener方法内将LifecycleListener 添加到了lifecycleListeners集合中

    • 在对应的生命周期方法中遍历集合，去调用LifecycleListener对应生命周期的方法，通知监听器

  • 所以第二个问题的整体流程串联起来

    注

    RequestManagerFragment简称RMF

    ActivityFragmentLifecycle简称 `AFL``

    RequestManager 简称 RM

    • RMF内部创建了AFL并重写了Fragment的生命周期方法，并在对应生命周期方法中调用了AFL的对应的方法，AFL 对应方法内部又是遍历LifecycleListener集合，逐一调用LifecycleListener对应生命周期的方法来通知监听器。
    • 而在RM创建的过程中传递进来了RMF内的AFL，RM实现了LifecycleListener，并给AFL设置了监听器（RMF和RM之间则是通过AFL和给AFL设置的LifecycleListener 回调实现的监听）
    • 示例
      • 此时当宿主Activity，Fragment 触发onStart最先到达了RMF的onStart()，
      • 在RM的onStart中AFL又调用了AFL的onStart()
      • AFL的onStart()中又调用了LifecycleListener 的onStart()来通知RM中的监听器
        • LifecycleListener 就是在RM创建时给AFL设置的LifecycleListener 因为RM实现了LifecycleListener 所以当LifecycleListener 调用onStart()时RM能接收到通知
      • 传递过程如图
        

总结

• 通过给宿主绑定一个空界面的Fragemnt 实现对宿主生命周期的监听

• 实际上生命周期监听传递逻辑就是通过回调接口LifecycleListener 实现的

• RMF和RM 持有共同的对象AFL，RM实现了LifecycleListener 重写了其生命周期监听方法，将LifecycleListener 设置给了AFL，AFL又在RMF对应的生命周期中触发了LifecycleListener 对应的生命周期方法，就这样完成了生命周期的监听

• 有点乱 本质上就是个回调 写这么多我也不知咋描述了。。。。