四 Glide对生命周期的监听

4.1 Glide对FragmentActivity的监听

调用Glide.with(fragmentActivity)

Glide.java

  
  @NonNull
  public static RequestManager with(@NonNull FragmentActivity activity) {
    return getRetriever(activity).get(activity);
  }
  
   @NonNull
  public static RequestManager with(@NonNull Activity activity) {
    return getRetriever(activity).get(activity);
  }

getRetriever(activity)

Glide.java

   @NonNull
  private static RequestManagerRetriever getRetriever(@Nullable Context context) {
    // Context could be null for other reasons (ie the user passes in null), but in practice it will
    // only occur due to errors with the Fragment lifecycle.
    Preconditions.checkNotNull(
        context,
        "You cannot start a load on a not yet attached View or a Fragment where getActivity() "
            + "returns null (which usually occurs when getActivity() is called before the Fragment "
            + "is attached or after the Fragment is destroyed).");
    return Glide.get(context).getRequestManagerRetriever();
  }

Glide.get(context)是Glide初始化配置部分，详见Glide配置初始化。 通过配置获取requestManagerRetriever，如果requestManagerRetriever未null，那么在配置的时候会默认初始化一个
RequestManagerRetriever 创建RequestManager并接收Activity和Fragment的生命周期回调的

 GlideBuilder.java

@NonNull
  Glide build(@NonNull Context context) {
    ···
    RequestManagerRetriever requestManagerRetriever =
        new RequestManagerRetriever(requestManagerFactory);

    return new Glide(
        context,
        engine,
        memoryCache,
        bitmapPool,
        arrayPool,
        requestManagerRetriever,
        connectivityMonitorFactory,
        logLevel,
        defaultRequestOptionsFactory,
        defaultTransitionOptions,
        defaultRequestListeners,
        isLoggingRequestOriginsEnabled,
        isImageDecoderEnabledForBitmaps);
  }
  

获取requestManagerRetriever后调用RequestManagerRetriever的get方法

RequestManagerRetriever.java
  
 @NonNull
  public RequestManager get(@NonNull FragmentActivity activity) {
  	//如果不是在主线程，获取全局的Context
    if (Util.isOnBackgroundThread()) {
      return get(activity.getApplicationContext());
    } else {
      // 判断Activity是否销毁
      assertNotDestroyed(activity);
      //获取FragmentManager
      FragmentManager fm = activity.getSupportFragmentManager();
  	  //创建RequestManager
      return supportFragmentGet(activity, fm, /*parentHint=*/ null, isActivityVisible(activity));
    }
  }
  
  
  

RequestManagerRetriever的get(activity.getApplicationContext());多重判断Context然后返回RequestManager

RequestManagerRetriever.java
  
 @NonNull
  public RequestManager get(@NonNull Context context) {
    if (context == null) {
      throw new IllegalArgumentException("You cannot start a load on a null Context");
  		//如果是在主线程并且不是Application的Context
    } else if (Util.isOnMainThread() && !(context instanceof Application)) {
      if (context instanceof FragmentActivity) {
  		//通过FragmentActivity获取RequestManager
        return get((FragmentActivity) context);
      } else if (context instanceof Activity) {
 		//通过Activity获取RequestManager
        return get((Activity) context);
      } else if (context instanceof ContextWrapper
          // Only unwrap a ContextWrapper if the baseContext has a non-null application context.
          // Context#createPackageContext may return a Context without an Application instance,
          // in which case a ContextWrapper may be used to attach one.
          && ((ContextWrapper) context).getBaseContext().getApplicationContext() != null) {
 		 //通过ContextWrapper获取RequestManager
        return get(((ContextWrapper) context).getBaseContext());
      }
    }
	//通过全局的Content创建RequestManager
    return getApplicationManager(context);
  }

get((FragmentActivity) context);创建RequestManager最后会调用supportFragmentGet(activity, fm, /parentHint=/ null, isActivityVisible(activity));

RequestManagerRetriever.java
  
  @NonNull
  private RequestManager supportFragmentGet(
      @NonNull Context context,
      @NonNull FragmentManager fm,
      @Nullable Fragment parentHint,
      boolean isParentVisible) {
    SupportRequestManagerFragment current =
        getSupportRequestManagerFragment(fm, parentHint, isParentVisible);
    RequestManager requestManager = current.getRequestManager();
    if (requestManager == null) {
      // TODO(b/27524013): Factor out this Glide.get() call
      //初始化Glide配置
      Glide glide = Glide.get(context);
  	  //通过工厂方法创建requestManager，这个requestManager工厂方法可以在外部配置，创建requestManager的时候就会注册相关Activity生命周期的回调
      requestManager =
          factory.build(
              glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
  	  //设置RequestManager
      current.setRequestManager(requestManager);
    }
  	//返回requestManager
    return requestManager;
  }

getSupportRequestManagerFragment(fm, parentHint, isParentVisible); 返回SupportRequestManagerFragment，它是一个绑定在Activity上不显示的Fragment用于监听Activity的状态

 RequestManagerRetriever.java

 @NonNull
  private SupportRequestManagerFragment getSupportRequestManagerFragment(
      @NonNull final FragmentManager fm, @Nullable Fragment parentHint, boolean isParentVisible) {
  	//通过tag找到Fragment
    SupportRequestManagerFragment current =
        (SupportRequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
    if (current == null) {
  	  //如果缓存了那么取出缓存的
      current = pendingSupportRequestManagerFragments.get(fm);
      if (current == null) {
  		//没有缓存需要创建一个，创建ActivityFragmentLifecycle，监听生命周期
        current = new SupportRequestManagerFragment();
  		//这是隐藏Fragment用于监听
        current.setParentFragmentHint(parentHint);
        if (isParentVisible) {
  		  //调用生命周期onStart()
          current.getGlideLifecycle().onStart();
        }
  		//添加到荤菜
        pendingSupportRequestManagerFragments.put(fm, current);
        fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
  		//删除FragmentManager
        handler.obtainMessage(ID_REMOVE_SUPPORT_FRAGMENT_MANAGER, fm).sendToTarget();
      }
    }
    return current;
  }

current.setParentFragmentHint(parentHint);设置隐藏放入Fragment

 SupportRequestManagerFragment.java 
  
  /**
   * Sets a hint for which fragment is our parent which allows the fragment to return correct
   * information about its parents before pending fragment transactions have been executed.
   */
  void setParentFragmentHint(@Nullable Fragment parentFragmentHint) {
    this.parentFragmentHint = parentFragmentHint;
    if (parentFragmentHint == null || parentFragmentHint.getContext() == null) {
      return;
    }
  	//获取FragmentManager
    FragmentManager rootFragmentManager = getRootFragmentManager(parentFragmentHint);
    if (rootFragmentManager == null) {
      return;
    }
    registerFragmentWithRoot(parentFragmentHint.getContext(), rootFragmentManager);
  }

getRootFragmentManager(parentFragmentHint);获取FragmentManager

 SupportRequestManagerFragment.java   
  
  @Nullable
  private static FragmentManager getRootFragmentManager(@NonNull Fragment fragment) {
    while (fragment.getParentFragment() != null) {
      fragment = fragment.getParentFragment();
    }
    return fragment.getFragmentManager();
  }

registerFragmentWithRoot(parentFragmentHint.getContext(), rootFragmentManager); 真的开始注册Fragment

SupportRequestManagerFragment.java   
  
 private void registerFragmentWithRoot(
      @NonNull Context context, @NonNull FragmentManager fragmentManager) {
  	//先remove rootRequestManagerFragment中的Fragment
    unregisterFragmentWithRoot();
  	//获取全局的rootRequestManagerFragment
    rootRequestManagerFragment =
        Glide.get(context)
            .getRequestManagerRetriever()
            .getSupportRequestManagerFragment(context, fragmentManager);
    if (!equals(rootRequestManagerFragment)) {
  	  //将rootRequestManagerFragment添加到childRequestManagerFragments统一管理
      rootRequestManagerFragment.addChildRequestManagerFragment(this);
    }
  }

生命周期的监听是在创建requestManager的时候实现的

RequestManager.java

  RequestManager(
      Glide glide,
      Lifecycle lifecycle,
      RequestManagerTreeNode treeNode,
      RequestTracker requestTracker,
      ConnectivityMonitorFactory factory,
      Context context) {
    this.glide = glide;
    this.lifecycle = lifecycle;
    this.treeNode = treeNode;
    this.requestTracker = requestTracker;
    this.context = context;

    connectivityMonitor =
        factory.build(
            context.getApplicationContext(),
            new RequestManagerConnectivityListener(requestTracker));

    // If we're the application level request manager, we may be created on a background thread.
    // In that case we cannot risk synchronously pausing or resuming requests, so we hack around the
    // issue by delaying adding ourselves as a lifecycle listener by posting to the main thread.
    // This should be entirely safe.
  	//这段代码就是添加生命周期监听的
    if (Util.isOnBackgroundThread()) {
      mainHandler.post(addSelfToLifecycle);
    } else {
      lifecycle.addListener(this);
    }
    lifecycle.addListener(connectivityMonitor);

    defaultRequestListeners =
        new CopyOnWriteArrayList<>(glide.getGlideContext().getDefaultRequestListeners());
    setRequestOptions(glide.getGlideContext().getDefaultRequestOptions());

    glide.registerRequestManager(this);
  }  

4.2 Glide对Activity的监听

调用Glide.with(activity) ，这个与FragmentActivity类似也是先获取，RequestManagerRetriever，然后获取RequestManager 只是调用的包不一样，内部也是创建了一个隐藏的Fragment监听生命周期

 Glide.java

  @NonNull
  public static RequestManager with(@NonNull Activity activity) {
    return getRetriever(activity).get(activity);
  }

获取RequestManager

RequestManagerRetriever.java
  
 public RequestManager get(@NonNull Activity activity) {
    if (Util.isOnBackgroundThread()) {
      return get(activity.getApplicationContext());
    } else {
      assertNotDestroyed(activity);
      android.app.FragmentManager fm = activity.getFragmentManager();
      return fragmentGet(activity, fm, /*parentHint=*/ null, isActivityVisible(activity));
    }
  }

RequestManagerRetriever.java 

 private RequestManager fragmentGet(
      @NonNull Context context,
      @NonNull android.app.FragmentManager fm,
      @Nullable android.app.Fragment parentHint,
      boolean isParentVisible) {
    RequestManagerFragment current = getRequestManagerFragment(fm, parentHint, isParentVisible);
    RequestManager requestManager = current.getRequestManager();
    if (requestManager == null) {
      // TODO(b/27524013): Factor out this Glide.get() call.
  	 //初始化glide 
      Glide glide = Glide.get(context);
  	  //通过工厂方法获取requestManager
      requestManager =
          factory.build(
              glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
  	  //将requestManager设置到Fragment中响应生命周期
      current.setRequestManager(requestManager);
    }
    return requestManager;
  }

将RequestManagerFragment注册目标到生命周期中

RequestManagerRetriever.java
  
 private RequestManagerFragment getRequestManagerFragment(
      @NonNull final android.app.FragmentManager fm,
      @Nullable android.app.Fragment parentHint,
      boolean isParentVisible) {
    RequestManagerFragment current = (RequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
    if (current == null) {
      current = pendingRequestManagerFragments.get(fm);
      if (current == null) {
        current = new RequestManagerFragment();
        current.setParentFragmentHint(parentHint);
        if (isParentVisible) {
          current.getGlideLifecycle().onStart();
        }
        pendingRequestManagerFragments.put(fm, current);
        fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
        handler.obtainMessage(ID_REMOVE_FRAGMENT_MANAGER, fm).sendToTarget();
      }
    }
    return current;
  }

4.3 Glide对Activity生命周期监听总结

1 activity初始化Glide配置获取RequestManagerRetriever，如果没有配置使用默认，这个类管理了所有的生命周期监听
2 通过传进来的Activity获取FragmentManager，设置一个不显示的Fragment用于监听生命周期
3 将Fragment和RequestManager绑定，返回requestManager
4 监听生命周期回调，是在创建RequestManager的时候

4.4 Glide对Fragment生命周期的监听

调用Glide.with(fragment); fragment.getContext()初始化Glide，获取RequestManagerRetriever

Glide.java

  @NonNull
  public static RequestManager with(@NonNull Fragment fragment) {
    return getRetriever(fragment.getContext()).get(fragment);
  }

RequestManagerRetriever.java  
  
  @NonNull
  public RequestManager get(@NonNull Fragment fragment) {
    Preconditions.checkNotNull(
        fragment.getContext(),
        "You cannot start a load on a fragment before it is attached or after it is destroyed");
    if (Util.isOnBackgroundThread()) {
  	  //如果是后台线程使用Application的Context
      return get(fragment.getContext().getApplicationContext());
    } else {
      FragmentManager fm = fragment.getChildFragmentManager();
  	  //这里的逻辑和FragmentActivity一致了 
      return supportFragmentGet(fragment.getContext(), fm, fragment, fragment.isVisible());
    }
  }

4.5 Glide对Fragment生命周期监听总结

1 fragment.getContext()初始化Glide配置获取RequestManagerRetriever，如果没有配置使用默认，这个类管理了所有的生命周期监听
2 通过传进来的fragment获取FragmentManager（fragment.getChildFragmentManager()），设置一个不显示的Fragment用于监听生命周期
3 将RequestManagerFragment和RequestManager绑定，返回requestManager
4 监听生命周期回调，是在创建RequestManager的时候

4.6 Glide对View生命周期的监听

调用Glide.with(view); 通过view的Context，创建RequestManagerRetriever

Glide.java

  @NonNull
  public static RequestManager with(@NonNull View view) {
    return getRetriever(view.getContext()).get(view);
  }

RequestManagerRetriever.java

 public RequestManager get(@NonNull View view) {
    if (Util.isOnBackgroundThread()) {
  	  //如果是子线程获取全局的context 
      return get(view.getContext().getApplicationContext());
    }

    Preconditions.checkNotNull(view);
    Preconditions.checkNotNull(
        view.getContext(), "Unable to obtain a request manager for a view without a Context");
  	//通过View的Context获取Activity
    Activity activity = findActivity(view.getContext());
    // The view might be somewhere else, like a service.
    if (activity == null) {
  	  //如果Activity是null那么通过全局的Context创建requestmanager
      return get(view.getContext().getApplicationContext());
    }

    // Support Fragments.
    // Although the user might have non-support Fragments attached to FragmentActivity, searching
    // for non-support Fragments is so expensive pre O and that should be rare enough that we
    // prefer to just fall back to the Activity directly.
  	//如果是FragmentActivity获取Activity中的所有的Fragment，如果View存在在Fragment中返回Fragment，如果不存在返回FragmentActivity
    if (activity instanceof FragmentActivity) {
      Fragment fragment = findSupportFragment(view, (FragmentActivity) activity);
  	  //创建requestmanager
      return fragment != null ? get(fragment) : get((FragmentActivity) activity);
    }

    // Standard Fragments.
    //如果是Activity获取Activity中的所有的Fragment，如果View存在在Fragment中返回Fragment，如果不存在返回Activity
    android.app.Fragment fragment = findFragment(view, activity);
    if (fragment == null) {
      //创建requestmanager
      return get(activity);
    }
  	//创建requestmanager
    return get(fragment);
  }

RequestManagerRetriever.java  
  
  @Nullable
  private static Activity findActivity(@NonNull Context context) {
    if (context instanceof Activity) {
      return (Activity) context;
    } else if (context instanceof ContextWrapper) {
      return findActivity(((ContextWrapper) context).getBaseContext());
    } else {
      return null;
    }
  }

4.7 Glide对View生命周期监听总结

1 view.getContext()初始化Glide配置获取RequestManagerRetriever，如果没有配置使用默认，这个类管理了所有的生命周期监听
2 根据View的Context类型不同分别处理，如果不是Activity难么返回全局context创建的requestmanager，如果View在Fragment中返回Fragment创建的requestmanager，否则返回Actcity创建的requestmanager

4.8 Glide对全局Context生命周期监听

Glide.with(fragmentActivity), 通过Context获取Glide配置RequestManagerRetriever，会调用到

RequestManagerRetriever.java
  
public RequestManager get(@NonNull Context context) {
    if (context == null) {
      throw new IllegalArgumentException("You cannot start a load on a null Context");
    } else if (Util.isOnMainThread() && !(context instanceof Application)) {
      if (context instanceof FragmentActivity) {
        return get((FragmentActivity) context);
      } else if (context instanceof Activity) {
        return get((Activity) context);
      } else if (context instanceof ContextWrapper
          // Only unwrap a ContextWrapper if the baseContext has a non-null application context.
          // Context#createPackageContext may return a Context without an Application instance,
          // in which case a ContextWrapper may be used to attach one.
          && ((ContextWrapper) context).getBaseContext().getApplicationContext() != null) {
        return get(((ContextWrapper) context).getBaseContext());
      }
    }
	//这里处理全局的reqquestManager
    return getApplicationManager(context);
  }

 RequestManagerRetriever.java
 
 private RequestManager getApplicationManager(@NonNull Context context) {
    // Either an application context or we're on a background thread.
    if (applicationManager == null) {
      synchronized (this) {
        if (applicationManager == null) {
          // Normally pause/resume is taken care of by the fragment we add to the fragment or
          // activity. However, in this case since the manager attached to the application will not
          // receive lifecycle events, we must force the manager to start resumed using
          // ApplicationLifecycle.

          // TODO(b/27524013): Factor out this Glide.get() call.
 		  //获取全局配置
          Glide glide = Glide.get(context.getApplicationContext());
  		  //通过工厂方法创建RequestManager
          applicationManager =
              factory.build(
                  glide,
                  new ApplicationLifecycle(),
                  new EmptyRequestManagerTreeNode(),
                  context.getApplicationContext());
        }
      }
    }
    return applicationManager;
  }

全局的生命周期

ApplicationLifecycle.java
  
class ApplicationLifecycle implements Lifecycle {
  @Override
  public void addListener(@NonNull LifecycleListener listener) {
    listener.onStart();
  }

  @Override
  public void removeListener(@NonNull LifecycleListener listener) {
    // Do nothing.
  }
}

RequestManager.java  
  
/**
   * Lifecycle callback that registers for connectivity events (if the
   * android.permission.ACCESS_NETWORK_STATE permission is present) and restarts failed or paused
   * requests.
   */
  @Override
  public synchronized void onStart() {
  	//恢复请求
    resumeRequests();
  	//恢复显示
    targetTracker.onStart();
  }

RequestManager.java  
  
 /**
   * Restarts any loads that have not yet completed.
   *
   * @see #isPaused()
   * @see #pauseRequests()
   */
  public synchronized void resumeRequests() {
  	//requestTracker负责管理请求
    requestTracker.resumeRequests();
  }

 RequestManager.java  
 
  @Override
  public void onStart() {
    for (Target<?> target : Util.getSnapshot(targets)) {
      target.onStart();
    }
  } 

RequestManager.java  

 /**
   * Lifecycle callback that unregisters for connectivity events (if the
   * android.permission.ACCESS_NETWORK_STATE permission is present) and pauses in progress loads.
   */
  @Override
  public synchronized void onStop() {
	//暂停网络请你去
    pauseRequests();
	//目标显示停止
    targetTracker.onStop();
  }

RequestManager.java 
 
@Override
  public synchronized void onDestroy() {
	//目标销毁
    targetTracker.onDestroy();
	//清空
    for (Target<?> target : targetTracker.getAll()) {
      clear(target);
    }
    targetTracker.clear();
  	//清空请求
    requestTracker.clearRequests();
  	//移除生命周期监听
    lifecycle.removeListener(this);
  	//移除连接监听
    lifecycle.removeListener(connectivityMonitor);
  	//移除线程runnable
    mainHandler.removeCallbacks(addSelfToLifecycle);
  	//解除RequestManager
    glide.unregisterRequestManager(this);
  }