RequestManagerRetriever

Glide在構(gòu)造時(shí)創(chuàng)建了RequestManagerRetriever，用于根據(jù)參數(shù)（Application、Activity、FragmentActivity濒生、Fragment、View）獲取RequestManager。

如果沒有創(chuàng)建RequestManager润绎，則會(huì)通過RequestManagerFactory創(chuàng)建。

// RequestManagerRetriever.java

private volatile RequestManager applicationManager;

public RequestManagerRetriever(@Nullable RequestManagerFactory factory) {
    // 如果沒有
    this.factory = factory != null ? factory : DEFAULT_FACTORY;
    handler = new Handler(Looper.getMainLooper(), this /* Callback */);
}


// RequestManager工廠類
public interface RequestManagerFactory {
    @NonNull
    RequestManager build(
        @NonNull Glide glide,
        @NonNull Lifecycle lifecycle,
        @NonNull RequestManagerTreeNode requestManagerTreeNode,
        @NonNull Context context);
}

private static final RequestManagerFactory DEFAULT_FACTORY =
      new RequestManagerFactory() {
        @NonNull
        @Override
        public RequestManager build(
            @NonNull Glide glide,
            @NonNull Lifecycle lifecycle,
            @NonNull RequestManagerTreeNode requestManagerTreeNode,
            @NonNull Context context) {
          return new RequestManager(glide, lifecycle, requestManagerTreeNode, context);
        }
      };
      
      
public RequestManager get(@NonNull Context context) {
    if (context == null) {
      // ... 省略拋異常代碼
    } else if (Util.isOnMainThread() && !(context instanceof Application)) {
    
      // 如果是在主線程匙监，且context不是Application凡橱，則獲取對(duì)應(yīng)頁面（Activity、Fragment）的RequestManager（該RequestManger對(duì)應(yīng)著一個(gè)RequestManagerFragment）
      
      if (context instanceof FragmentActivity) {
        return get((FragmentActivity) context);
      } else if (context instanceof Activity) {
        return get((Activity) context);
      } else if (context instanceof ContextWrapper
          && ((ContextWrapper) context).getBaseContext().getApplicationContext() != null) {
        return get(((ContextWrapper) context).getBaseContext());
      }
    }

    // 如果是在子線程或context是Application亭姥，則返回ApplicationManager（跟隨應(yīng)用生命周期）
    return getApplicationManager(context);
}

private RequestManager getApplicationManager(@NonNull Context context) {
    
    if (applicationManager == null) {
      synchronized (this) {
        if (applicationManager == null) {
          Glide glide = Glide.get(context.getApplicationContext());
          
          // 利用工廠類創(chuàng)建一個(gè)跟隨應(yīng)用聲明周期的RequestManger
          applicationManager =
              factory.build(
                  glide,
                  new ApplicationLifecycle(),
                  new EmptyRequestManagerTreeNode(),
                  context.getApplicationContext());
        }
      }
    }

    return applicationManager;
}

public RequestManager get(FragmentActivity activity) {
    if (Util.isOnBackgroundThread()) {
      return get(activity.getApplicationContext());
    } else {
      assertNotDestroyed(activity);
      
      // 獲取SupportFragmentManger稼钩，用于查找或添加SupportRequestMangerFragment，之后利用SupportRequestMangerFragment獲取RequestManger
      FragmentManager fm = activity.getSupportFragmentManager();
      return supportFragmentGet(activity, fm, /*parentHint=*/ null, isActivityVisible(activity));
    }
}

private RequestManager supportFragmentGet(
      @NonNull Context context,
      @NonNull FragmentManager fm,
      @Nullable Fragment parentHint,
      boolean isParentVisible) {

    // 獲取SupportRequestManagerFragment
    SupportRequestManagerFragment current =
        getSupportRequestManagerFragment(fm, parentHint, isParentVisible);
        
    // 從SupportRequestManagerFragment中獲取RequestManger
    RequestManager requestManager = current.getRequestManager();
    
    // 如果SupportRequestManagerFragment沒有RequetManger达罗，則創(chuàng)建RequestManager并設(shè)置給SupportRequestManagerFragment
    if (requestManager == null) {
      
      Glide glide = Glide.get(context);
      requestManager =
          factory.build(
              glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
      current.setRequestManager(requestManager);
    }
    return requestManager;
}


// 正在通過FragmentManger添加的RequestManagerFragment坝撑，之后會(huì)通過handler從該集合中移除
final Map<android.app.FragmentManager, RequestManagerFragment> pendingRequestManagerFragments =
      new HashMap<>();
      
final Map<FragmentManager, SupportRequestManagerFragment> pendingSupportRequestManagerFragments =
      new HashMap<>();

@NonNull
private SupportRequestManagerFragment getSupportRequestManagerFragment(
      @NonNull final FragmentManager fm, @Nullable Fragment parentHint, boolean isParentVisible) {
    
    // 是否有已經(jīng)添加了的RequeetFragment
    SupportRequestManagerFragment current =
        (SupportRequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
    if (current == null) {
      
      // 是否有正在添加的RSupportequestFragment静秆，沒有的話，創(chuàng)建一個(gè)巡李，并通過FragmentManager添加抚笔，同時(shí)放入pendingSupportRequestManagerFragments中，待添加完成后會(huì)通過Handler從集合中移除
      current = pendingSupportRequestManagerFragments.get(fm);
      if (current == null) {
        current = new SupportRequestManagerFragment();
        current.setParentFragmentHint(parentHint);
        if (isParentVisible) {
          current.getGlideLifecycle().onStart();
        }
        pendingSupportRequestManagerFragments.put(fm, current);
        fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
        
        // handler發(fā)送消息侨拦，從列表中移除正在添加的fragment
        handler.obtainMessage(ID_REMOVE_SUPPORT_FRAGMENT_MANAGER, fm).sendToTarget();
      }
    }
    return current;
}

其他get(Activity)殊橙、get(Fragment)、get(View)都差不多

public RequestManager get(@NonNull View view) {
    if (Util.isOnBackgroundThread()) {
      return get(view.getContext().getApplicationContext());
    }

    ...
    // 找到context對(duì)應(yīng)的Activity
    Activity activity = findActivity(view.getContext());
    
    if (activity == null) {
      return get(view.getContext().getApplicationContext());
    }

    
    if (activity instanceof FragmentActivity) {
      // 遞歸遍歷view的parent狱从，如果view的哪個(gè)parent是已經(jīng)Added的SupportFragment的rootView膨蛮，則返回該Fragment
      Fragment fragment = findSupportFragment(view, (FragmentActivity) activity);
      
      // 獲取Fragment或Activity的SupportRequestManagerFragment的RequestManaager
      return fragment != null ? get(fragment) : get((FragmentActivity) activity);
    }

    // 和findSupportFragment(...)類似，只是這里返回的是android.app.Fragment
    android.app.Fragment fragment = findFragment(view, activity);
    if (fragment == null) {
      return get(activity);
    }
    return get(fragment);
}


// 臨時(shí)map季研，存儲(chǔ)Fragment和它的rootView
private final ArrayMap<View, Fragment> tempViewToSupportFragment = new ArrayMap<>();

// 遞歸遍歷view的parent敞葛，如果view或view的哪個(gè)parent是已經(jīng)Added的Fragment的rootView，則返回該Fragment   
private Fragment findSupportFragment(@NonNull View target, @NonNull FragmentActivity activity) {
    tempViewToSupportFragment.clear();
    
    // 獲取Activity已添加的所有Fragment及每個(gè)Fragment的子Fragment与涡，及對(duì)應(yīng)的fragment的RootView
    findAllSupportFragmentsWithViews(
        activity.getSupportFragmentManager().getFragments(), tempViewToSupportFragment);
        
    // 如果view或者view的parent是某個(gè)已Added的fragment的rootView惹谐，則返回該Fragment    
    Fragment result = null;
    View activityRoot = activity.findViewById(android.R.id.content);
    View current = target;
    while (!current.equals(activityRoot)) {
      result = tempViewToSupportFragment.get(current);
      if (result != null) {
        break;
      }
      if (current.getParent() instanceof View) {
        current = (View) current.getParent();
      } else {
        break;
      }
    }

    tempViewToSupportFragment.clear();
    return result;
}

// 遍歷topLevelFragments及每個(gè)Fragment的子Fragment，將Fragment和對(duì)應(yīng)的rootView放入臨時(shí)map中
private static void findAllSupportFragmentsWithViews(
      @Nullable Collection<Fragment> topLevelFragments, @NonNull Map<View, Fragment> result) {
    if (topLevelFragments == null) {
      return;
    }
    for (Fragment fragment : topLevelFragments) {
      FragmentManager may contain null values, see #1991.
      if (fragment == null || fragment.getView() == null) {
        continue;
      }
      result.put(fragment.getView(), fragment);
      findAllSupportFragmentsWithViews(fragment.getChildFragmentManager().getFragments(), result);
    }
}

get(view)的主要工作是：
遍歷該View及其parent驼卖，如果該view或其parent是該view所在的Activity的某個(gè)已經(jīng)added的Fragment的rootView氨肌，則返回該Fragment的SupportRequestManagerFragment/RequestManagerFragment的RequestManager；如果該view所在的Activity沒有添加Fragment或該view及其parent不是某個(gè)Fragment的rootView款慨，則獲取該view所在的Activity的SupportRequestManagerFragment/RequestManagerFragment的RequestManager儒飒。

public RequestManager get(@NonNull Fragment fragment) {
    
    if (Util.isOnBackgroundThread()) {
      return get(fragment.getContext().getApplicationContext());
    } else {
      FragmentManager fm = fragment.getChildFragmentManager();
      
      // 找到Fragment已添加的SupportRequestManagerFragment，并返回其RequestManager
      return supportFragmentGet(fragment.getContext(), fm, fragment, fragment.isVisible());
    }
}

get(androidx.fragment.app.Fragment)和get(android.app.Fragment)差不多檩奠，都是找到Fragment已添加的SupportRequestManagerFragment/RequestManagerFragment桩了，并返回其RequestManager。

RequestManagerFragment

內(nèi)含lifecycle埠戳，當(dāng)RequestManagerFragment聲明周期發(fā)生變化時(shí)井誉，會(huì)通過lifecycle通知LifecycleListener，而RequestManager實(shí)現(xiàn)了LifecycleListener整胃，并在創(chuàng)建時(shí)被添加到了lifecycle颗圣。

RequestManger

用于生成RequestBuilder、控制Request屁使，內(nèi)部使用RequestTracker控制Request的開始在岂、暫停、銷毀等蛮寂。

RequestManager(
      Glide glide,
      Lifecycle lifecycle,
      RequestManagerTreeNode treeNode,
      RequestTracker requestTracker,
      ConnectivityMonitorFactory factory,
      Context context) {
      
    this.glide = glide;
    this.lifecycle = lifecycle;
    this.requestTracker = requestTracker;
    if (Util.isOnBackgroundThread()) {
      mainHandler.post(addSelfToLifecycle);
    } else {
      lifecycle.addListener(this);
    }
    ...
    
}

public synchronized void pauseRequests() {
    requestTracker.pauseRequests();
}

public synchronized void resumeRequests() {
    requestTracker.resumeRequests();
}

synchronized void track(Target<?> target, Request request) {
    targetTracker.track(target);

    // 內(nèi)部調(diào)用Request#begin()開始請(qǐng)求數(shù)據(jù)
    requestTracker.runRequest(request);
}

...

@Override
public synchronized void onStart() {
    resumeRequests();
    targetTracker.onStart();
}

...

public <ResourceType> RequestBuilder<ResourceType> as(Class<ResourceType> resourceClass) {
    return new RequestBuilder<>(glide, this, resourceClass, context);
}

public RequestBuilder<Drawable> asDrawable() {
    return as(Drawable.class);
}

public RequestBuilder<Drawable> load(@Nullable String string) {
    return asDrawable().load(string);
}

...

RequestBuilder

用于生成Request蔽午。

// load方法會(huì)保存請(qǐng)求參數(shù)model
public RequestBuilder<TranscodeType> load(@Nullable Object model) {
    return loadGeneric(model);
}


private RequestBuilder<TranscodeType> loadGeneric(@Nullable Object model) {
    this.model = model;
    isModelSet = true;
    return this;
}

// 構(gòu)造request，并啟動(dòng)
private <Y extends Target<TranscodeType>> Y into(
      Y target,
      RequestListener<TranscodeType> targetListener,
      BaseRequestOptions<?> options,
      Executor callbackExecutor) {
    ...

    Request request = buildRequest(target, targetListener, options, callbackExecutor);

    Request previous = target.getRequest();
    
    // 如果request和target之前的request一樣酬蹋，且之前的request未完成或能使用內(nèi)存中已完成的request及老，則復(fù)用reqeust
    if (request.isEquivalentTo(previous)
        && !isSkipMemoryCacheWithCompletePreviousRequest(options, previous)) {
      
      // 如果請(qǐng)求完成抽莱，調(diào)用begin()重新開始確保重新傳遞結(jié)果，觸發(fā) RequestListeners 和 Targets骄恶。如果請(qǐng)求失敗食铐，調(diào)用begin()重新開始將重新啟動(dòng)請(qǐng)求，給它一次完成的機(jī)會(huì)僧鲁。如果請(qǐng)求已經(jīng)在運(yùn)行虐呻，我們可以讓它繼續(xù)運(yùn)行而不會(huì)中斷。
      if (!Preconditions.checkNotNull(previous).isRunning()) {
        
        previous.begin();
      }
      return target;
    }

    // 清除requestManager中保存的target和對(duì)應(yīng)的Request（如果有的話悔捶，會(huì)分別從targetTracker和requestTracker中移除target和request铃慷，并將target.setRequest(null)）
    requestManager.clear(target);
    target.setRequest(request);
    // 將target和對(duì)應(yīng)的request保存在requestManager中单芜，并啟動(dòng)請(qǐng)求(request.begin())
    requestManager.track(target, request);

    return target;
}

// buildRequest(...)直接走的這個(gè)方法
private Request buildRequestRecursive(
      Object requestLock,
      Target<TranscodeType> target,
      @Nullable RequestListener<TranscodeType> targetListener,
      @Nullable RequestCoordinator parentCoordinator,
      TransitionOptions<?, ? super TranscodeType> transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight,
      BaseRequestOptions<?> requestOptions,
      Executor callbackExecutor) {

    ... // 省略一些代碼

    Request mainRequest =
        buildThumbnailRequestRecursive(
            requestLock,
            target,
            targetListener,
            parentCoordinator,
            transitionOptions,
            priority,
            overrideWidth,
            overrideHeight,
            requestOptions,
            callbackExecutor);

    if (errorRequestCoordinator == null) {
      return mainRequest;
    }

    ... // 省略一些代碼
}

private Request buildThumbnailRequestRecursive(
      Object requestLock,
      Target<TranscodeType> target,
      RequestListener<TranscodeType> targetListener,
      RequestCoordinator parentCoordinator,
      TransitionOptions<?, ? super TranscodeType> transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight,
      BaseRequestOptions<?> requestOptions,
      Executor callbackExecutor) {
    if (thumbnailBuilder != null) {
      ...
      return coordinator;
    } else if (thumbSizeMultiplier != null) {
      ...
      return coordinator;
    } else {
      // Base case: no thumbnail.
      return obtainRequest(
          requestLock,
          target,
          targetListener,
          requestOptions,
          parentCoordinator,
          transitionOptions,
          priority,
          overrideWidth,
          overrideHeight,
          callbackExecutor);
    }
}

private Request obtainRequest(
      Object requestLock,
      Target<TranscodeType> target,
      RequestListener<TranscodeType> targetListener,
      BaseRequestOptions<?> requestOptions,
      RequestCoordinator requestCoordinator,
      TransitionOptions<?, ? super TranscodeType> transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight,
      Executor callbackExecutor) {
      
    // 返回一個(gè)SingleRequest
    return SingleRequest.obtain(
        context,
        glideContext,
        requestLock,
        model,
        transcodeClass,
        requestOptions,
        overrideWidth,
        overrideHeight,
        priority,
        target,
        targetListener,
        requestListeners,
        requestCoordinator,
        glideContext.getEngine(), // 獲取engine
        transitionOptions.getTransitionFactory(),
        callbackExecutor);
}

SingleRequest

public final class SingleRequest<R> implements Request, SizeReadyCallback, ResourceCallback {
    
    
    public static <R> SingleRequest<R> obtain(
      ...
      Object model,
      Class<R> transcodeClass,
      BaseRequestOptions<?> requestOptions,
      int overrideWidth,
      int overrideHeight,
      Target<R> target,
      RequestListener<R> targetListener,
      Engine engine,
      Executor callbackExecutor) {
        return new SingleRequest<>(
            ...
            model,
            transcodeClass,
            requestOptions,
            overrideWidth,
            overrideHeight,
            target,
            targetListener,
            engine,
            callbackExecutor);
    }

    private SingleRequest(
      ...
      @Nullable Object model,
      Class<R> transcodeClass,
      BaseRequestOptions<?> requestOptions,
      int overrideWidth,
      int overrideHeight,
      Target<R> target,
      RequestListener<R> targetListener,
      Engine engine,
      Executor callbackExecutor) {
        this.model = model;
        this.transcodeClass = transcodeClass;
        this.requestOptions = requestOptions;
        this.overrideWidth = overrideWidth;
        this.overrideHeight = overrideHeight;
        this.target = target;
        this.targetListener = targetListener;
        this.engine = engine;
        this.callbackExecutor = callbackExecutor;
        status = Status.PENDING;
        ...
    }
    
    
  // 開始執(zhí)行請(qǐng)求
  @Override
  public void begin() {
    synchronized (requestLock) {
      ...
      if (model == null) {
        ...
        onLoadFailed(new GlideException("Received null model"), logLevel);
        return;
      }

      if (status == Status.RUNNING) {
        throw new IllegalArgumentException("Cannot restart a running request");
      }

      // 如果我們?cè)谡?qǐng)求完成后重新啟動(dòng)請(qǐng)求時(shí)（通常通過諸如 notifyDataSetChanged 之類的方式蜕该，它啟動(dòng)對(duì)相同目標(biāo)或視圖的相同請(qǐng)求），我們可以簡(jiǎn)單地使用我們上次檢索到的資源和大小并跳過獲取新大小, 開始新的加載等洲鸠。如果用戶需要在視圖大小更改后重新啟動(dòng)請(qǐng)求堂淡，則需要在開始新加載之前顯式清除視圖或目標(biāo)。
      if (status == Status.COMPLETE) {
        onResourceReady(resource, DataSource.MEMORY_CACHE);
        return;
      }

      // 如果請(qǐng)求不是運(yùn)行中或完成狀態(tài)扒腕，重新啟動(dòng)它可以被看作是一個(gè)新的請(qǐng)求绢淀，且可以從頭開始執(zhí)行。
      status = Status.WAITING_FOR_SIZE;
      if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
        // 如果設(shè)置了overrideWidth和overrideHeight瘾腰，則修改status為running皆的，并通過engine開始加載圖片
        onSizeReady(overrideWidth, overrideHeight);
      } else {
        // 沒有size，則先通過Target獲取大小
        target.getSize(this);
      }

      if ((status == Status.RUNNING || status == Status.WAITING_FOR_SIZE)
          && canNotifyStatusChanged()) {
          
          // 獲取placeHolderDrawable蹋盆，并回調(diào)target#onLoadStarted(drawable)费薄，如果是ImageViewTarget則會(huì)讓ImageView加載drawable
        target.onLoadStarted(getPlaceholderDrawable());
      }
      
    }
  }
  
  
  public void onSizeReady(int width, int height) {
    stateVerifier.throwIfRecycled();
    synchronized (requestLock) {
      
      if (status != Status.WAITING_FOR_SIZE) {
        return;
      }
      status = Status.RUNNING;

      ... // 省略部分對(duì)width和height的操作，主要是乘以sizeMultiplier
      
      // 加載圖片
      loadStatus =
          engine.load(
              glideContext,
              model,
              requestOptions.getSignature(),
              this.width,
              this.height,
              requestOptions.getResourceClass(),
              transcodeClass,
              priority,
              requestOptions.getDiskCacheStrategy(),
              requestOptions.getTransformations(),
              requestOptions.isTransformationRequired(),
              requestOptions.isScaleOnlyOrNoTransform(),
              requestOptions.getOptions(),
              requestOptions.isMemoryCacheable(),
              requestOptions.getUseUnlimitedSourceGeneratorsPool(),
              requestOptions.getUseAnimationPool(),
              requestOptions.getOnlyRetrieveFromCache(),
              this,
              callbackExecutor);

      ...
    }
  }
  
  
  public void onResourceReady(Resource<?> resource, DataSource dataSource) {
    ...
    Resource<?> toRelease = null;
    try {
      synchronized (requestLock) {
        loadStatus = null;
        if (resource == null) {
          GlideException exception = new GlideException("...");
          onLoadFailed(exception);
          return;
        }

        // transcodeClass就是我們想要的類型栖雾，例如Drawable楞抡、Bitmap...
        Object received = resource.get();
        if (received == null || !transcodeClass.isAssignableFrom(received.getClass())) {
          toRelease = resource;
          this.resource = null;
          GlideException exception = new GlideException("..."));
          onLoadFailed(exception);
          return;
        }

        ...
        
        // 資源準(zhǔn)備好后通知target加載資源
        onResourceReady((Resource<R>) resource, (R) received, dataSource);
      }
    } finally {
      // 資源沒有被使用需要釋放掉
      if (toRelease != null) {
        engine.release(toRelease);
      }
    }
  }
  
  private void onResourceReady(Resource<R> resource, R result, DataSource dataSource) {
    
    boolean isFirstResource = isFirstReadyResource();
    
    // 修改狀態(tài)為complete
    status = Status.COMPLETE;
    this.resource = resource;

    isCallingCallbacks = true;
    try {
    
      // 是否有任何RequestListener已經(jīng)通過onResourceReady(...)通知target加載了資源
      boolean anyListenerHandledUpdatingTarget = false;
      if (requestListeners != null) {
        for (RequestListener<R> listener : requestListeners) {
          anyListenerHandledUpdatingTarget |=
              listener.onResourceReady(result, model, target, dataSource, isFirstResource);
        }
      }
      anyListenerHandledUpdatingTarget |=
          targetListener != null
              && targetListener.onResourceReady(result, model, target, dataSource, isFirstResource);

      // 如果還沒有通過RequestListener#onResourceReady(...)更新target，則直接調(diào)用Target#onResourceReady(...)通知target加載資源
      if (!anyListenerHandledUpdatingTarget) {
        Transition<? super R> animation = animationFactory.build(dataSource, isFirstResource);
        target.onResourceReady(result, animation);
      }
    } finally {
      isCallingCallbacks = false;
    }

    // 通知父RequestCoordinator請(qǐng)求成功了
    notifyLoadSuccess();
  }
    
}