Android：這是一份全面 & 詳細的圖片載入庫Glide原始碼分析

Carson_Ho發表於2018-03-21

AndroidIDE原始碼

前言

Glide，該功能非常強大 Android 圖片載入開源框架相信大家並不陌生
正由於他的功能強大，所以它的原始碼非常複雜，這導致很多人望而卻步
本人嘗試將 Glide 的功能進行分解，並單獨針對每個功能進行原始碼分析，從而降低Glide原始碼的複雜度。

接下來，我將推出一系列關於 Glide的功能原始碼分析，有興趣可以繼續關注

今天，我將主要原始碼分析Glide的基礎功能：圖片載入 ，希望你們會喜歡。

由於文章較長，希望讀者先收藏 & 預留足夠時間進行檢視。

1. 簡介

定義：Google開發者Sam sjudd出品的一個Android開源庫
作用：圖片載入
具體功能列表

注：從上面可看出，Glide不僅解決了圖片非同步載入的問題，還解決了Android載入圖片時的一些常見問題，功能十分強大。

2. 與主流圖片開源庫對比

關於Glide與主流圖片開源庫（Universal-Image-Loader、Picasso、Fresco），請看文章：3分鐘全面瞭解Android主流圖片載入庫

3. 具體使用

關於Glide的各種使用方法，請看文章：Android圖片載入庫：最全面解析Glide用法

4. 原始碼分析

在進行原始碼分析前，有幾點需要特別說明：

本次原始碼分析是基於 Glide 3.7.0，版本下載地址
本次原始碼分析是主要分析Glide的基本功能：圖片載入，所以關於其他功能的程式碼本文一律忽略

因為Glide的功能實在太多了，所以原始碼非常複雜，無法同時分析多個功能。但其他功能將下Glide的系列文章繼續分析。

Glide原始碼較為難懂、難分析的其中一個原因是：許多物件都是很早之前就初始化好，而並非在使用前才初始化。所以當真正使用該物件時，開發者可能已經忘記是在哪裡初始化、該物件是作什麼用的了。所以本文會在每個階段進行一次總結，而讀者則需要經常往返看該總結，從而解決上述問題。

下面，我們將根據 Glide 的載入圖片的使用步驟一步步原始碼分析。

Glide 的使用步驟如下：

Glide.with(this).load(url).into(imageView);
// 引數說明
// 引數1：Context context
// Context對於很多Android API的呼叫都是必須的，這裡就不多說了

// 引數2：String imageUrl：被載入影象的Url地址
// 大多情況下，一個字串代表一個網路圖片的URL

// 引數3：ImageView targetImageView：圖片最終要展示的地方。
複製程式碼

所以Glide的原始碼分析分為三步：
1. .with（）
2. .load（）
3. .into（）

4.1 with（）

定義：Glide 類中的靜態方法，根據傳入不同引數進行方法過載
作用：
1. 得到一個RequestManager物件
2. 根據傳入with()方法的引數 將Glide圖片載入的生命週期與Activity/Fragment的生命週期進行繫結，從而實現自動執行請求，暫停操作
下面先說明一些重要物件名

具體原始碼

public class Glide {
    ...

    // with()過載種類非常多，根據傳入的引數可分為：
    // 1. 非Application型別的引數（Activity & Fragment  ）
    // 2. Application型別的引數（Context）
    // 下面將詳細分析

// 引數1：Application型別
 public static RequestManager with(Context context) {
        RequestManagerRetriever retriever = RequestManagerRetriever.get();
        // 步驟1：呼叫RequestManagerRetriever類的靜態get()獲得RequestManagerRetriever物件 - 單例實現
        return retriever.get(context);
        // 步驟2：呼叫RequestManagerRetriever例項的get()獲取RequestManager物件 & 繫結圖片載入的生命週期 ->>分析1
    }

// 引數2：非Application型別（Activity & Fragment ）
    public static RequestManager with(Activity activity) {
        RequestManagerRetriever retriever = RequestManagerRetriever.get();
        return retriever.get(activity);
    }

    public static RequestManager with(Fragment fragment) {
        RequestManagerRetriever retriever = RequestManagerRetriever.get();
        return retriever.get(fragment);

  @TargetApi(Build.VERSION_CODES.HONEYCOMB)
    public static RequestManager with(android.app.Fragment fragment) {
        RequestManagerRetriever retriever = RequestManagerRetriever.get();
        return retriever.get(fragment);
    }

    }
}

<-- 分析1：RequestManagerRetriever物件的例項 get（）-->
// 作用：
  // 1. 獲取RequestManager物件
  // 2. 將圖片載入的生命週期與Activity/Fragment的生命週期進行繫結

  public class RequestManagerRetriever implements Handler.Callback {
      ...

    // 例項的get（）過載種類很多，引數分為：（與with（）類似）
    // 1. Application型別（Context）
    // 2. 非Application型別（Activity & Fragment ）- >>分析3
    // 下面會詳細分析

// 引數1：Application型別（Context） 
   public RequestManager get(Context context) {
        return getApplicationManager(context);
        // 呼叫getApplicationManager（）最終獲取一個RequestManager物件 ->>分析2
        // 因為Application物件的生命週期即App的生命週期
        // 所以Glide載入圖片的生命週期是自動與應用程式的生命週期繫結，不需要做特殊處理（若應用程式關閉，Glide的載入也會終止）
    }

// 引數2：非Application型別（Activity & Fragment  ）
// 將Glide載入圖片的生命週期與Activity生命週期同步的具體做法：向當前的Activity新增一個隱藏的Fragment
// 原因：因Fragment的生命週期 與 Activity 的是同步的，通過新增隱藏的Fragment 從而監聽Activity的生命週期，從而實現Glide載入圖片的生命週期與Activity的生命週期 進行同步。
 @TargetApi(Build.VERSION_CODES.HONEYCOMB)
    public RequestManager get(Activity activity) {
        if (Util.isOnBackgroundThread() || Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
            return get(activity.getApplicationContext());
        } else {

            assertNotDestroyed(activity);
             //判斷activity是否已經銷燬

            android.app.FragmentManager fm = activity.getFragmentManager();
            // 獲取FragmentManager 物件
            
            return fragmentGet(activity, fm);
           // 通過fragmentGet返回RequestManager->>分析4
           
           
        }
    }

    public RequestManager get(FragmentActivity activity) {
      // 邏輯同上，此處不作過多描述
      ...

    }

    public RequestManager get(Fragment fragment) {
        // 邏輯同上，此處不作過多描述
      ...
    }

}

<-- 分析2：getApplicationManager（context）-->
private RequestManager getApplicationManager(Context context) {

      ...

        Glide glide = Glide.get(context);
        // 通過單例模式建立Glide例項 ->>分析3
        applicationManager =
            new RequestManager(
                glide, new ApplicationLifecycle(), new EmptyRequestManagerTreeNode());
      }
    }
  }
  return applicationManager;
}

<-- 分析3：Glide.get(context) -->
public static Glide get(Context context) {
  if (glide == null) {
  // 單例模式的體現
    synchronized (Glide.class) {
      if (glide == null) {
        Context applicationContext = context.getApplicationContext();
        
        List<GlideModule> modules = new ManifestParser(applicationContext).parse();
        // 解析清單檔案配置的自定義GlideModule的metadata標籤，返回一個GlideModule集合

        GlideBuilder builder = new GlideBuilder(applicationContext);
        // 步驟1：建立GlideBuilder物件
        for (GlideModule module : modules) {
          module.applyOptions(applicationContext, builder);
        }
        glide = builder.createGlide();
        // 步驟2：根據GlideBuilder物件建立Glide例項
        // GlideBuilder會為Glide設定一預設配置，如：Engine，RequestOptions，GlideExecutor，MemorySizeCalculator
       
        for (GlideModule module : modules) {
          module.registerComponents(applicationContext, glide.registry);
           // 步驟3：利用GlideModule 進行延遲性的配置和ModelLoaders的註冊
        }
      }
    }
  }
  return glide;
}
// 回到分析1 進入 分析2的地方


<--分析4：fragmentGet(） -->
// 作用：
           // 1. 建立Fragment
           // 2. 向當前的Activity中新增一個隱藏的Fragment
           // 3. 將RequestManager與該隱藏的Fragment進行繫結
 RequestManager fragmentGet(Context context, android.app.FragmentManager fm) {
     
        RequestManagerFragment current = getRequestManagerFragment(fm);
        // 獲取RequestManagerFragment
        // 作用：利用Fragment進行請求的生命週期管理 

        RequestManager requestManager = current.getRequestManager();

        // 若requestManager 為空，即首次載入初始化requestManager 
        if (requestManager == null) {
            // 建立RequestManager傳入Lifecycle實現類，如ActivityFragmentLifecycle
            requestManager = new RequestManager(context, current.getLifecycle(), current.getRequestManagerTreeNode());
            current.setRequestManager(requestManager);
            // 呼叫setRequestManager設定到RequestManagerFragment 
        }
        return requestManager;
    }

複製程式碼

總結

with（）是為得到一個RequestManager物件從而將Glide載入圖片週期與Activity 和Fragment進行繫結，從而管理Glide載入圖片週期

最終返回RequestManager物件

由於本文主要講解圖片載入的功能，所以關於載入圖片生命週期的內容暫時不講解。

4.2 load（）

定義由於 .with() 返回的是一個RequestManager物件，所以第2步中呼叫的是 RequestManager 類的 load()
作用預先建立好對圖片進行一系列操作（載入、編解碼、轉碼）的物件，並全部封裝到 DrawableTypeRequest `物件中。

Glide 支援載入圖片的URL字串、圖片本地路徑等，因此RequestManager 類存在load()的過載

此處主要講解最常見的載入圖片 URL 字串的load()，即load(String url)

具體過程

public class RequestManager implements LifecycleListener {

    // 僅貼出關鍵程式碼
    ...

     public DrawableTypeRequest<String> load(String string) {
        return (DrawableTypeRequest<String>) fromString().load(string);
        // 先呼叫fromString（）再呼叫load（）
        // load（）作用：傳入圖片URL地址
       // fromString（）作用 ->>分析1
       
    }

<-- 分析1：fromString（）-->
    public DrawableTypeRequest<String> fromString() {
        return loadGeneric(String.class);
         // loadGeneric（）的作用 ->>分析2
    }

<-- 分析2：loadGeneric（）-->
    private <T> DrawableTypeRequest<T> loadGeneric(Class<T> modelClass) {

        ModelLoader<T, InputStream> streamModelLoader = Glide.buildStreamModelLoader(modelClass, context);
        // 建立第1個ModelLoader物件；作用：載入圖片
        // Glide會根據load()方法傳入不同型別引數，得到不同的ModelLoader物件
        // 此處傳入引數是String.class，因此得到的是StreamStringLoader物件（實現了ModelLoader介面）

        ModelLoader<T, ParcelFileDescriptor> fileDescriptorModelLoader = Glide.buildFileDescriptorModelLoader(modelClass, context);
         // 建立第2個ModelLoader物件，作用同上：載入圖片
        // 此處得到的是FileDescriptorModelLoader物件

        return optionsApplier.apply(
                new DrawableTypeRequest<T>(modelClass, streamModelLoader, fileDescriptorModelLoader, context,
                        glide, requestTracker, lifecycle, optionsApplier));
            // 建立DrawableTypeRequest物件 & 傳入剛才建立的ModelLoader物件 和 其他初始化配置的引數
            // DrawableTypeRequest類分析 ->>分析3
    }

    ...


<-- 分析3：DrawableTypeRequest類（）-->
public class DrawableTypeRequest<ModelType> extends DrawableRequestBuilder<ModelType> implements DownloadOptions {

// 關注1：構造方法
      DrawableTypeRequest(Class<ModelType> modelClass, ModelLoader<ModelType, InputStream> streamModelLoader,
            ModelLoader<ModelType, ParcelFileDescriptor> fileDescriptorModelLoader, Context context, Glide glide,
            RequestTracker requestTracker, Lifecycle lifecycle, RequestManager.OptionsApplier optionsApplier) {
        super(context, modelClass,
                buildProvider(glide, streamModelLoader, fileDescriptorModelLoader, GifBitmapWrapper.class,
                        GlideDrawable.class, null),
                glide, requestTracker, lifecycle);
      // 呼叫buildProvider()方法 -->分析4
      // 並把上述建立的streamModelLoader和fileDescriptorModelLoader等引數傳入到buildProvider()中

// 關注2：DrawableTypeRequest類主要提供2個方法： asBitmap() & asGif() 

    // asBitmap()作用：強制載入 靜態圖片
    public BitmapTypeRequest<ModelType> asBitmap() {
        return optionsApplier.apply(new BitmapTypeRequest<ModelType>(this, streamModelLoader,
                fileDescriptorModelLoader, optionsApplier));
        // 建立BitmapTypeRequest物件
    }

    // asGif() 作用：強制載入 動態圖片
    public GifTypeRequest<ModelType> asGif() {
        return optionsApplier.apply(new GifTypeRequest<ModelType>(this, streamModelLoader, optionsApplier));
        // 建立GifTypeRequest物件

        // 注：若沒指定，則預設使用DrawableTypeRequest
    }

}

<-- 分析4：buildProvider(）-->
private static <A, Z, R> FixedLoadProvider<A, ImageVideoWrapper, Z, R> buildProvider(Glide glide,
            ModelLoader<A, InputStream> streamModelLoader,
            ModelLoader<A, ParcelFileDescriptor> fileDescriptorModelLoader, Class<Z> resourceClass,
            Class<R> transcodedClass,
            ResourceTranscoder<Z, R> transcoder) {

        if (transcoder == null) {
            transcoder = glide.buildTranscoder(resourceClass, transcodedClass);
            // 建立GifBitmapWrapperDrawableTranscoder物件（實現了ResourceTranscoder介面）
            // 作用：對圖片進行轉碼
        }

        DataLoadProvider<ImageVideoWrapper, Z> dataLoadProvider = glide.buildDataProvider(ImageVideoWrapper.class,
                resourceClass);
        // 建立ImageVideoGifDrawableLoadProvider物件（實現了DataLoadProvider介面）
        // 作用：對圖片進行編解碼

        ImageVideoModelLoader<A> modelLoader = new ImageVideoModelLoader<A>(streamModelLoader,
                fileDescriptorModelLoader);
        // 建立ImageVideoModelLoader
        // 並把上面建立的兩個ModelLoader：streamModelLoader和fileDescriptorModelLoader封裝到了ImageVideoModelLoader中

        return new FixedLoadProvider<A, ImageVideoWrapper, Z, R>(modelLoader, transcoder, dataLoadProvider);
       // 建立FixedLoadProvider物件
       // 把上面建立的GifBitmapWrapperDrawableTranscoder、ImageVideoModelLoader、ImageVideoGifDrawableLoadProvider都封裝進去
      // 注：FixedLoadProvider物件就是第3步into（）中onSizeReady()的loadProvider物件
    }
      // 回到分析3的關注點2

複製程式碼

在RequestManager的load()中，通過fromString()最終返回一個DrawableTypeRequest物件，並呼叫該物件的load() 傳入圖片的URL地址

請回看分析1上面的程式碼

但從上面的分析3可看出，DrawableTypeRequest類中並沒有load()和第3步需要分析的into（），所以load() 和 into（） 是在DrawableTypeRequest類的父類中：DrawableRequestBuilder類中。繼承關係如下：

public class DrawableRequestBuilder<ModelType>
        extends GenericRequestBuilder<ModelType, ImageVideoWrapper, GifBitmapWrapper, GlideDrawable>
        implements BitmapOptions, DrawableOptions {

        ... 

// 最終load()方法返回的其實就是一個DrawableTypeRequest物件
@Override
    public Target<GlideDrawable> into(ImageView view) {
        return super.into(view);
    }

// 特別注意：DrawableRequestBuilder類中有很多使用Glide的API方法，此處不做過多描述

}
複製程式碼

至此，第2步的 load（）分析完成

總結

load（）中預先建立好對圖片進行一系列操作（載入、編解碼、轉碼）的物件，並全部封裝到 DrawableTypeRequest物件中。

4.3 into（）

作用：構建網路請求物件並執行該網路請求

即獲取圖片資源 & 載入圖片並顯示

總體邏輯如下:
詳細過程：

在第2步的RequestManager的load()中，最終返回一個DrawableTypeRequest物件

封裝好了對圖片進行一系列操作（載入、編解碼、轉碼）的物件

但 DrawableTypeRequest類中並沒有load()和第3步需要分析的into（），所以load() 和 into（） 是在DrawableTypeRequest類的父類中：DrawableRequestBuilder類

繼承關係如下

所以，第三步是呼叫DrawableRequestBuilder類的 into（）完成圖片的最終載入。

public class DrawableRequestBuilder<ModelType>
        extends GenericRequestBuilder<ModelType, ImageVideoWrapper, GifBitmapWrapper, GlideDrawable>
        implements BitmapOptions, DrawableOptions {

 @Override
    public Target<GlideDrawable> into(ImageView view) {
        return super.into(view);
  // 呼叫DrawableRequestBuilder的父類GenericRequestBuilder的into() ->>分析1
    }
}

<-- 分析1：GenericRequestBuilder類的into（）-->
public class GenericRequestBuilder<ModelType> {

  ...

  public Target<TranscodeType> into(ImageView view) {

  // 判斷是否在主執行緒(跟新UI只能在主執行緒)
  // 此處邏輯先不講解，後面會詳細說明，直接跳到方法的最後一行
    Util.assertMainThread();
    if (view == null) {
        throw new IllegalArgumentException("You must pass in a non null View");
    }
    if (!isTransformationSet && view.getScaleType() != null) {
        switch (view.getScaleType()) {
            case CENTER_CROP:
                applyCenterCrop();
                break;
            case FIT_CENTER:
            case FIT_START:
            case FIT_END:
                applyFitCenter();
                break;
            //$CASES-OMITTED$
            default:
                // Do nothing.
        }
    }
    return into(glide.buildImageViewTarget(view, transcodeClass));
    // 建立Target物件：用於最終展示圖片 ->>分析2
    // 從分析3回來
  }
}

<-- 分析2：buildImageViewTarget（）-->
<R> Target<R> buildImageViewTarget(ImageView imageView, Class<R> transcodedClass) {
    return imageViewTargetFactory.buildTarget(imageView, transcodedClass);
    // ->>分析3

}

<-- 分析3：ImageViewTargetFactory的buildTarget()-->

public class ImageViewTargetFactory {

    public <Z> Target<Z> buildTarget(ImageView view, Class<Z> clazz) {


        // 根據傳入的class引數構建不同的Target物件，分為三種情況：
        // 情況1：若載入圖片時呼叫了asBitmap()，那麼構建的是BitmapImageViewTarget物件
       // 情況2：否則構建的是GlideDrawableImageViewTarget物件
       // 情況3：DrawableImageViewTarget物件基本用不到，此處忽略
       // 具體請看以下程式碼
        if (GlideDrawable.class.isAssignableFrom(clazz)) {
            return (Target<Z>) new GlideDrawableImageViewTarget(view);
        } else if (Bitmap.class.equals(clazz)) {
            return (Target<Z>) new BitmapImageViewTarget(view);    
        } else if (Drawable.class.isAssignableFrom(clazz)) {
            return (Target<Z>) new DrawableImageViewTarget(view);   
        } else {
            throw new IllegalArgumentException("Unhandled class: " + clazz
                    + ", try .as*(Class).transcode(ResourceTranscoder)");
        }
    }
}
複製程式碼

此處得到了GlideDrawableImageViewTarget物件（大多數情況下）
回到上面分析1 - GenericRequestBuilder 類的 into（）最後一行：將GlideDrawableImageViewTarget物件傳入到GenericRequestBuilder的into(Target target)中

我們繼續看 GenericRequestBuilder的into(Target target) 的原始碼：

public <Y extends Target<TranscodeType>> Y into(Y target) {

    Request request = buildRequest(target);
    // 關注1：構建Request物件：發出載入圖片請求
    target.setRequest(request);
    // 將請求設定到target
    lifecycle.addListener(target);
    // 將target加入到lifecycle
    requestTracker.runRequest(request);
    // 關注2：執行網路請求Request
    return target;

}
複製程式碼

此處是 傳送載入圖片網路請求
有2個關注點：構建 Request 物件 & 執行 Request

4.3.1 構建Request物件

作用建立 GenericRequest 物件 & 初始化（即將 load（）中的API引數賦值到GenericRequest物件中）

<-- 分析4：buildRequest() -->
// 作用：構建Request物件
private Request buildRequest(Target<TranscodeType> target) {
    return buildRequestRecursive(target, null);
    // 往下呼叫
}

private Request buildRequestRecursive(Target<TranscodeType> target, ThumbnailRequestCoordinator parentCoordinator) {
        // 90%的程式碼用於處理縮圖，此處僅關注主流程，即如何構建Request物件
        // 僅貼出關鍵程式碼（如何構建Request物件）  
        ... 

        ThumbnailRequestCoordinator coordinator = new ThumbnailRequestCoordinator(parentCoordinator);
        Request fullRequest = obtainRequest(target, sizeMultiplier, priority, coordinator);
        // 往下呼叫
        
private Request obtainRequest(Target<TranscodeType> target, float sizeMultiplier, Priority priority,
        RequestCoordinator requestCoordinator) {

    return GenericRequest.obtain(
            loadProvider,
            model,
            signature,
            context,
            priority,
            target,
            sizeMultiplier,
            placeholderDrawable,
            placeholderId,
            errorPlaceholder,
            errorId,
            fallbackDrawable,
            fallbackResource,
            requestListener,
            requestCoordinator,
            glide.getEngine(),
            transformation,
            transcodeClass,
            isCacheable,
            animationFactory,
            overrideWidth,
            overrideHeight,
            diskCacheStrategy);
    // 呼叫了GenericRequest的obtain()
    // 作用：將在load()中呼叫的所有API引數都組裝到Request物件當中 -->分析5
}

<-- 分析5：GenericRequest的obtain()  -->
public final class GenericRequest<A, T, Z, R> implements Request, SizeReadyCallback,
        ResourceCallback {
    // 僅貼出關鍵程式碼
    ...

    public static <A, T, Z, R> GenericRequest<A, T, Z, R> obtain(
            LoadProvider<A, T, Z, R> loadProvider,
            A model,
            Key signature,
            Context context,
            Priority priority,
            Target<R> target,
            float sizeMultiplier,
            Drawable placeholderDrawable,
            int placeholderResourceId,
            Drawable errorDrawable,
            int errorResourceId,
            Drawable fallbackDrawable,
            int fallbackResourceId,
            RequestListener<? super A, R> requestListener,
            RequestCoordinator requestCoordinator,
            Engine engine,
            Transformation<Z> transformation,
            Class<R> transcodeClass,
            boolean isMemoryCacheable,
            GlideAnimationFactory<R> animationFactory,
            int overrideWidth,
            int overrideHeight,
            DiskCacheStrategy diskCacheStrategy) {
        @SuppressWarnings("unchecked")
        GenericRequest<A, T, Z, R> request = (GenericRequest<A, T, Z, R>) REQUEST_POOL.poll();
        if (request == null) {
            request = new GenericRequest<A, T, Z, R>();
            // 建立GenericRequest物件
        }
        // init（）作用：將傳入的Load（）中的API引數賦值到GenericRequest的成員變數
        request.init(loadProvider,
                model,
                signature,
                context,
                priority,
                target,
                sizeMultiplier,
                placeholderDrawable,
                placeholderResourceId,
                errorDrawable,
                errorResourceId,
                fallbackDrawable,
                fallbackResourceId,
                requestListener,
                requestCoordinator,
                engine,
                transformation,
                transcodeClass,
                isMemoryCacheable,
                animationFactory,
                overrideWidth,
                overrideHeight,
                diskCacheStrategy);
        return request;
        // 返回GenericRequest物件
    }

    ...
}
複製程式碼

至此，一個傳送載入圖片的網路請求 Request 物件GenericRequest 建立完畢。

本文主要針對圖片載入功能，關於傳送載入圖片的網路請求細節將在下篇文章進行描述。

總結

4.3.2 執行網路請求物件Request

public <Y extends Target<TranscodeType>> Y into(Y target) {

    Request request = buildRequest(target);
    // 關注1：構建Request物件：發出載入圖片請求
    target.setRequest(request);
    lifecycle.addListener(target);
    requestTracker.runRequest(request);
    // 關注2：執行Request ->>分析6
    return target;
}
複製程式碼

/**
  * 步驟1：載入前
**/
<-- 分析6：runRequest(request) -->
public void runRequest(Request request) {
    // 此時的Request是GenericRequest物件
    requests.add(request);
    // 將每個提交的請求加入到一個set中：管理請求
    
    // 判斷Glide當前是否處於暫停狀態    
    if (!isPaused) {
        // 若不處於暫停狀態，則呼叫GenericRequest的begin()來執行Request ->>分析7
        request.begin();
    } else {
        // 若處於暫停，則先將Request新增到待執行佇列裡面，等暫停狀態解除後再執行
        pendingRequests.add(request);
    }
}

/**
  * 步驟2：載入時
**/
<-- 分析7：GenericRequest的begin() -->
public void begin() {

// 有2個關注點

// 關注1
    // model = 第2步load()傳入的圖片URL地址
    // 若model（）等於null，會呼叫onException()
    // onException()內部呼叫setErrorPlaceholder()
    if (model == null) {
        onException(null);
        return;
    }
    status = Status.WAITING_FOR_SIZE;

// 關注2：
// 圖片載入情況分兩種：
// 1. 開發者使用了override() API為圖片指定了一個固定的寬高
// 2. 無使用

// 情況1：使用了override() API為圖片指定了一個固定的寬高
    if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
        onSizeReady(overrideWidth, overrideHeight);
        // 呼叫onSizeReady()載入

// 否則，則是情況2，呼叫target.getSize()
    } else {
        target.getSize(this);
        // target.getSize()的內部會根據ImageView的layout_width和layout_height值做一系列的計算，來算出圖片顯示的寬高
        // 計算後，也會呼叫onSizeReady()方法進行載入
    }
    if (!isComplete() && !isFailed() && canNotifyStatusChanged()) {
        target.onLoadStarted(getPlaceholderDrawable());
        // 從分析8看回來的：在圖片請求開始前，會先使用Loading佔點陣圖代替最終的圖片顯示
    }

}
複製程式碼

在begin（）方法中有兩個關注點：

關注點1：若model（第2步load()傳入的圖片URL地址）等於null，會呼叫onException()
關注點2：圖片載入情況下面將詳細說明

關注1

若model（第2步load()傳入的圖片URL地址）等於null，會呼叫onException()（內部呼叫setErrorPlaceholder()）

private void setErrorPlaceholder(Exception e) {

    Drawable error = model == null ? getFallbackDrawable() : null;

    // 若有error的佔點陣圖，則採用先獲取error的佔點陣圖
    if (error == null) {
      error = getErrorDrawable();
    }
    // 若沒有error的佔點陣圖，則再去獲取一個loading佔點陣圖
    if (error == null) {
        error = getPlaceholderDrawable();
    }
    target.onLoadFailed(e, error);
    // 將佔點陣圖（error / loading）傳入到onLoadFailed（）中 ->>分析8
}

<-- 分析8：onLoadFailed（） -->
public abstract class ImageViewTarget<Z> extends ViewTarget<ImageView, Z> implements GlideAnimation.ViewAdapter {
    ...

    @Override
    public void onLoadFailed(Exception e, Drawable errorDrawable) {
        view.setImageDrawable(errorDrawable);
        // 將該error佔點陣圖顯示到ImageView
    }

    @Override
    public void onLoadStarted(Drawable placeholder) {
        view.setImageDrawable(placeholder);
        // 在圖片請求開始前，會先使用Loading佔點陣圖代替最終的圖片顯示
        // 在begin（）時呼叫（回看分析7）
    }



    ...
}
複製程式碼

所以此處顯示出Glide的用法：

若傳入圖片的url為 Null，會採用error / loading的佔點陣圖進行代替
圖片請求開始前，會先使用 Loading 佔點陣圖代替最終的圖片顯示

關注2

圖片載入情況（重點關注）

<-- 分析7：GenericRequest的begin() -->
public void begin() {

// 關注1（請跳過，直接看關注2）
    // 若model（第2步load()傳入的圖片URL地址）等於null，會呼叫onException()
    // onException()內部呼叫setErrorPlaceholder()
    if (model == null) {
        onException(null);
        return;
    }
    status = Status.WAITING_FOR_SIZE;

// 關注2：
  // 圖片載入情況分兩種：
    // 1. 為圖片指定載入固定的寬高（使用override() 的API）
    // 2. 無指定載入的寬高

// 情況1：為圖片指定載入固定的寬高（使用override() 的API）
    if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
        onSizeReady(overrideWidth, overrideHeight);
        // 呼叫onSizeReady()載入->>分析9

// 否則，則是情況2：無指定載入的寬高
    } else {
        target.getSize(this);
        // target.getSize()會根據ImageView的layout_width和layout_height值做一系列的計算，來算出圖片顯示的寬高
        // 計算後，最終也會呼叫onSizeReady()進行載入
    }
    
 
}

<-- 分析9：onSizeReady()-->
public void onSizeReady(int width, int height) {

    // loadProvider 物件 即 第2步load（）中的FixedLoadProvider物件 
    // 裡面封裝了GifBitmapWrapperDrawableTranscoder、ImageVideoModelLoader、ImageVideoGifDrawableLoadProvider物件）
    // ->>請回看第2步load（）中的 分析3：DrawableTypeRequest類

    ModelLoader<A, T> modelLoader = loadProvider.getModelLoader();
    // 從loadProvider 物件中獲取ImageVideoModelLoader物件
    ResourceTranscoder<Z, R> transcoder = loadProvider.getTranscoder();
    // 從loadProvider 物件中獲取GifBitmapWrapperDrawableTranscoder物件

    final DataFetcher<T> dataFetcher = modelLoader.getResourceFetcher(model, width, height);
    // ->>分析10
    // 建立ImageVideoFetcher物件（傳入HttpUrlFetcher物件）
  
    loadStatus = engine.load(signature, width, height, dataFetcher, loadProvider, transformation, transcoder,
            priority, isMemoryCacheable, diskCacheStrategy, this);
    // 將上述獲得的ImageVideoFetcher、GifBitmapWrapperDrawableTranscoder等一起傳入到了Engine的load()方法中 ->>分析11

    }
    ...
}

<--分析10：ImageVideoModelLoader的getResourceFetcher() -->

public class ImageVideoModelLoader<A> implements ModelLoader<A, ImageVideoWrapper> {
  
    @Override
    public DataFetcher<ImageVideoWrapper> getResourceFetcher(A model, int width, int height) {
        
         DataFetcher<ParcelFileDescriptor> fileDescriptorFetcher = null;
         if (fileDescriptorLoader != null) {
            fileDescriptorFetcher = fileDescriptorLoader.getResourceFetcher(model, width, height);
            // fileDescriptorLoader是在第2步load（）中建立的FileDescriptorModelLoader：用於載入圖片
           // 呼叫FileDescriptorModelLoader的getResourceFetcher()會得到一個HttpUrlFetcher物件
        }

        DataFetcher<InputStream> streamFetcher = null;
        if (streamLoader != null) {
            streamFetcher = streamLoader.getResourceFetcher(model, width, height);
            // streamLoader是在第2步load（）中建立的StreamStringLoader：用於載入圖片
           // 呼叫streamLoader的getResourceFetcher()會得到一個HttpUrlFetcher物件
        }
      

        if (streamFetcher != null || fileDescriptorFetcher != null) {
            return new ImageVideoFetcher(streamFetcher, fileDescriptorFetcher);
        // 建立ImageVideoFetcher物件，並把上述獲得的2個HttpUrlFetcher物件傳進去
        // 即呼叫ImageVideoModelLoader的getResourceFetcher()得到的是ImageVideoFetcher
        } else {
            return null;
        }
    }
} 
// 回到分析9原處
複製程式碼

<-- 分析11：Engine的load() -->
public class Engine implements EngineJobListener,
        MemoryCache.ResourceRemovedListener,
        EngineResource.ResourceListener {

      ...
      // 省略關鍵程式碼

        EngineJob engineJob = engineJobFactory.build(key, isMemoryCacheable);
        // 建立EngineJob物件
        // 作用：開啟執行緒（作非同步載入圖片）

        DecodeJob<T, Z, R> decodeJob = new DecodeJob<T, Z, R>(key, width, height, fetcher, loadProvider, transformation,
                transcoder, diskCacheProvider, diskCacheStrategy, priority);
        // 建立DecodeJob物件
        // 作用：對圖片解碼（較複雜，下面會詳細說明）

        EngineRunnable runnable = new EngineRunnable(engineJob, decodeJob, priority);
        // 建立EngineRunnable物件
        jobs.put(key, engineJob);
        engineJob.addCallback(cb);
        engineJob.start(runnable);
        // 執行EngineRunnable物件
        // 即在子執行緒中執行EngineRunnable的run()方法 ->>分析12

        return new LoadStatus(cb, engineJob);
    }

    ...
}

<--分析12：EngineRunnable的run() -->
    @Override
    public void run() {
   
    try {
        resource = decode();
        // 呼叫decode() 並 返回了一個Resource物件 ->>分析13

    } catch (Exception e) {
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            Log.v(TAG, "Exception decoding", e);
        }
       ...
}

<--分析13：decode() -->
private Resource<?> decode() throws Exception {

// 分兩種情況：從快取當中讀（解碼）圖片 & 不從快取中讀（解碼）圖片

    if (isDecodingFromCache()) {
    // 若從快取中decode圖片：執行decodeFromCache()
    // 本文先不討論快取情況
        return decodeFromCache();
    } else {
        // 不從快取中讀（解碼）圖片：執行decodeFromSource()  ->>分析14
        return decodeFromSource();
    }
}

<--分析14：decodeFromSource()  -->
private Resource<?> decodeFromSource() throws Exception {
    return decodeJob.decodeFromSource();
    // 呼叫了DecodeJob的decodeFromSource()方法 ->>分析15
}


<--分析15：DecodeJob.decodeFromSource() -->
class DecodeJob<A, T, Z> {
    ...

   public Resource<Z> decodeFromSource() throws Exception {
        Resource<T> decoded = decodeSource();
        // 獲得Resource物件 ->>分析16
        return transformEncodeAndTranscode(decoded);
        // 呼叫transformEncodeAndTranscode()方法來處理該Resource物件。
    }

<--分析16： decodeSource()  -->
    private Resource<T> decodeSource() throws Exception {
    ...

        try {
            final A data = fetcher.loadData(priority);
            // 該fetcher是在分析10：onSizeReady()中得到的ImageVideoFetcher物件
            // 即呼叫ImageVideoFetcher的loadData() - >>分析17

            // 從分析17回來時看這裡：
            decoded = decodeFromSourceData(data);
            // 將分析17建立的ImageVideoWrapper物件傳入到decodeFromSourceData()，解碼該物件 -->分析19

      }

    ...
}

<--分析17： fetcher.loadData（）  -->
@Override
public ImageVideoWrapper loadData(Priority priority) throws Exception {
    InputStream is = null;

    if (streamFetcher != null) {
        try {
            is = streamFetcher.loadData(priority);
           // 該streamFetcher是建立ImageVideoFetcher物件時傳入的HttpUrlFetcher
          // 因此這裡呼叫的是HttpUrlFetcher的loadData() ->>分析18
        } catch (Exception e) {

    return new ImageVideoWrapper(is, fileDescriptor);
    // 從分析18回來時看這裡
    // 建立ImageVideoWrapper物件 & 傳入分析18建立的InputStream ->>回到分析16
}


<--分析18：HttpUrlFetcher的loadData（）  -->
// 此處是網路請求的程式碼
public class HttpUrlFetcher implements DataFetcher<InputStream> {

    @Override
    public InputStream loadData(Priority priority) throws Exception {
        return loadDataWithRedirects(glideUrl.toURL(), 0 /*redirects*/, null /*lastUrl*/, glideUrl.getHeaders());
        // 繼續往下看
    }

    private InputStream loadDataWithRedirects(URL url, int redirects, URL lastUrl, Map<String, String> headers)
           ...

        // 靜態工廠模式建立HttpURLConnection物件
        urlConnection = connectionFactory.build(url);
        for (Map.Entry<String, String> headerEntry : headers.entrySet()) {
          urlConnection.addRequestProperty(headerEntry.getKey(), headerEntry.getValue());
        }
        //設定請求引數
        //設定連線超時時間2500ms
        urlConnection.setConnectTimeout(2500);
        //設定讀取超時時間2500ms
        urlConnection.setReadTimeout(2500);
        //不使用http快取
        urlConnection.setUseCaches(false);
        urlConnection.setDoInput(true);

        // Connect explicitly to avoid errors in decoders if connection fails.
        urlConnection.connect();
        if (isCancelled) {
            return null;
        }
        final int statusCode = urlConnection.getResponseCode();
        if (statusCode / 100 == 2) {
              //請求成功
            return getStreamForSuccessfulRequest(urlConnection);
            // 繼續往下看
        } 
    }

      private InputStream getStreamForSuccessfulRequest(HttpURLConnection urlConnection)
            throws IOException {
        if (TextUtils.isEmpty(urlConnection.getContentEncoding())) {
            int contentLength = urlConnection.getContentLength();
            stream = ContentLengthInputStream.obtain(urlConnection.getInputStream(), contentLength);
        } else {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "Got non empty content encoding: " + urlConnection.getContentEncoding());
            }
            stream = urlConnection.getInputStream();
        }
        return stream;
        // 最終返回InputStream物件（但還沒開始讀取資料）
        // 回到分析17中的最後一行
    }
        
    }
}



複製程式碼

分析19：圖片的解碼


<--分析19：decodeFromSourceData()（）  -->
private Resource<T> decodeFromSourceData(A data) throws IOException {

        decoded = loadProvider.getSourceDecoder().decode(data, width, height);
        // 呼叫loadProvider.getSourceDecoder()得到的是GifBitmapWrapperResourceDecoder物件
        // 即呼叫GifBitmapWrapperResourceDecoder物件的decode()來對圖片進行解碼 ->>分析20
    
    return decoded;
}

<--分析20：GifBitmapWrapperResourceDecoder物件的decode()  -->
    public class GifBitmapWrapperResourceDecoder implements ResourceDecoder<ImageVideoWrapper, GifBitmapWrapper> {

    ...

    @Override
    public Resource<GifBitmapWrapper> decode(ImageVideoWrapper source, int width, int height) throws IOException {

            wrapper = decode(source, width, height, tempBytes);
            // 傳入引數，並呼叫了另外一個decode（）進行過載 ->>分析21

    }

<--分析21：過載的decode（） -->
    private GifBitmapWrapper decode(ImageVideoWrapper source, int width, int height, byte[] bytes) throws IOException {
        final GifBitmapWrapper result;
        if (source.getStream() != null) {
            result = decodeStream(source, width, height, bytes);
            // 作用：從伺服器返回的流當中讀取資料- >>分析22
            
        } else {
            result = decodeBitmapWrapper(source, width, height);
        }
        return result;
    }

<--分析22：decodeStream（） -->
// 作用：從伺服器返回的流當中讀取資料
// 讀取方式：
        // 1. 從流中讀取2個位元組的資料：判斷該圖是GIF圖還是普通的靜圖
        // 2. 若是GIF圖，就呼叫decodeGifWrapper() 解碼
        // 3. 若普通靜圖，就呼叫decodeBitmapWrapper() 解碼
        // 此處僅分析 對於靜圖解碼
    private GifBitmapWrapper decodeStream(ImageVideoWrapper source, int width, int height, byte[] bytes)
            throws IOException {
        
        // 步驟1：從流中讀取兩個2位元組資料進行圖片型別的判斷
        InputStream bis = streamFactory.build(source.getStream(), bytes);
        bis.mark(MARK_LIMIT_BYTES);
        ImageHeaderParser.ImageType type = parser.parse(bis);
        bis.reset();
        GifBitmapWrapper result = null;

        // 步驟2：若是GIF圖，就呼叫decodeGifWrapper() 解碼
        if (type == ImageHeaderParser.ImageType.GIF) {
            result = decodeGifWrapper(bis, width, height);
        }

        // 步驟3：若是普通靜圖，就呼叫decodeBitmapWrapper()解碼
        if (result == null) {
            ImageVideoWrapper forBitmapDecoder = new ImageVideoWrapper(bis, source.getFileDescriptor());
            result = decodeBitmapWrapper(forBitmapDecoder, width, height);
            // ->>分析23
        }
        return result;
    }

<-- 分析23：decodeBitmapWrapper() -->
    private GifBitmapWrapper decodeBitmapWrapper(ImageVideoWrapper toDecode, int width, int height) throws IOException {
        GifBitmapWrapper result = null;
        Resource<Bitmap> bitmapResource = bitmapDecoder.decode(toDecode, width, height);
       //  bitmapDecoder是一個ImageVideoBitmapDecoder物件
       // 即呼叫ImageVideoBitmapDecoder物件的decode（）->>分析24
        if (bitmapResource != null) {
            result = new GifBitmapWrapper(bitmapResource, null);
        }
        return result;
    }

    ...
}

<-- 分析24：ImageVideoBitmapDecoder.decode() -->
public class ImageVideoBitmapDecoder implements ResourceDecoder<ImageVideoWrapper, Bitmap> {

    ...

    @Override
    public Resource<Bitmap> decode(ImageVideoWrapper source, int width, int height) throws IOException {
        Resource<Bitmap> result = null;
        InputStream is = source.getStream();
        // 步驟1：獲取到伺服器返回的InputStream
        if (is != null) {
            try {
                result = streamDecoder.decode(is, width, height);
                // 步驟2：呼叫streamDecoder.decode()進行解碼
                // streamDecode是一個StreamBitmapDecoder物件 ->>分析25

            } catch (IOException e) {
    ...
}

<-- 分析25：StreamBitmapDecoder.decode() -->
public class StreamBitmapDecoder implements ResourceDecoder<InputStream, Bitmap> {

    ...

    @Override
    public Resource<Bitmap> decode(InputStream source, int width, int height) {
        Bitmap bitmap = downsampler.decode(source, bitmapPool, width, height, decodeFormat);
        // Downsampler的decode() ->>分析26

        // 從分析26回來看這裡：
        return BitmapResource.obtain(bitmap, bitmapPool);
        // 作用：將分析26中返回的Bitmap物件包裝成Resource<Bitmap>物件
        // 因為decode()返回的是一個Resource<Bitmap>物件；而從Downsampler中得到的是一個Bitmap物件，需要進行型別的轉換
        // 經過這樣一層包裝後，如果還需要獲取Bitmap，只需要呼叫Resource<Bitmap>的get()即可
        // 接下來，我們需要一層層地向上返回（請向下看直到跳出該程式碼塊）
    }

    ...
}

<-- 分析26：downsampler.decode（）  -->
// 主要作用：讀取伺服器返回的InputStream & 載入圖片
// 其他作用：對圖片的壓縮、旋轉、圓角等邏輯處理
public abstract class Downsampler implements BitmapDecoder<InputStream> {

    ...

    @Override
    public Bitmap decode(InputStream is, BitmapPool pool, int outWidth, int outHeight, DecodeFormat decodeFormat) {
        final ByteArrayPool byteArrayPool = ByteArrayPool.get();
        final byte[] bytesForOptions = byteArrayPool.getBytes();
        final byte[] bytesForStream = byteArrayPool.getBytes();
        final BitmapFactory.Options options = getDefaultOptions();
        // Use to fix the mark limit to avoid allocating buffers that fit entire images.
        RecyclableBufferedInputStream bufferedStream = new RecyclableBufferedInputStream(
                is, bytesForStream);
        // Use to retrieve exceptions thrown while reading.
        // TODO(#126): when the framework no longer returns partially decoded Bitmaps or provides a way to determine
        // if a Bitmap is partially decoded, consider removing.
        ExceptionCatchingInputStream exceptionStream =
                ExceptionCatchingInputStream.obtain(bufferedStream);
        // Use to read data.
        // Ensures that we can always reset after reading an image header so that we can still attempt to decode the
        // full image even when the header decode fails and/or overflows our read buffer. See #283.
        MarkEnforcingInputStream invalidatingStream = new MarkEnforcingInputStream(exceptionStream);
        try {
            exceptionStream.mark(MARK_POSITION);
            int orientation = 0;
            try {
                orientation = new ImageHeaderParser(exceptionStream).getOrientation();
            } catch (IOException e) {
                if (Log.isLoggable(TAG, Log.WARN)) {
                    Log.w(TAG, "Cannot determine the image orientation from header", e);
                }
            } finally {
                try {
                    exceptionStream.reset();
                } catch (IOException e) {
                    if (Log.isLoggable(TAG, Log.WARN)) {
                        Log.w(TAG, "Cannot reset the input stream", e);
                    }
                }
            }
            options.inTempStorage = bytesForOptions;
            final int[] inDimens = getDimensions(invalidatingStream, bufferedStream, options);
            final int inWidth = inDimens[0];
            final int inHeight = inDimens[1];
            final int degreesToRotate = TransformationUtils.getExifOrientationDegrees(orientation);
            final int sampleSize = getRoundedSampleSize(degreesToRotate, inWidth, inHeight, outWidth, outHeight);
            final Bitmap downsampled =
                    downsampleWithSize(invalidatingStream, bufferedStream, options, pool, inWidth, inHeight, sampleSize,
                            decodeFormat);
            // BitmapFactory swallows exceptions during decodes and in some cases when inBitmap is non null, may catch
            // and log a stack trace but still return a non null bitmap. To avoid displaying partially decoded bitmaps,
            // we catch exceptions reading from the stream in our ExceptionCatchingInputStream and throw them here.
            final Exception streamException = exceptionStream.getException();
            if (streamException != null) {
                throw new RuntimeException(streamException);
            }
            Bitmap rotated = null;
            if (downsampled != null) {
                rotated = TransformationUtils.rotateImageExif(downsampled, pool, orientation);
                if (!downsampled.equals(rotated) && !pool.put(downsampled)) {
                    downsampled.recycle();
                }
            }
            return rotated;
        } finally {
            byteArrayPool.releaseBytes(bytesForOptions);
            byteArrayPool.releaseBytes(bytesForStream);
            exceptionStream.release();
            releaseOptions(options);
        }
    }

    private Bitmap downsampleWithSize(MarkEnforcingInputStream is, RecyclableBufferedInputStream  bufferedStream,
            BitmapFactory.Options options, BitmapPool pool, int inWidth, int inHeight, int sampleSize,
            DecodeFormat decodeFormat) {
        // Prior to KitKat, the inBitmap size must exactly match the size of the bitmap we're decoding.
        Bitmap.Config config = getConfig(is, decodeFormat);
        options.inSampleSize = sampleSize;
        options.inPreferredConfig = config;
        if ((options.inSampleSize == 1 || Build.VERSION_CODES.KITKAT <= Build.VERSION.SDK_INT) && shouldUsePool(is)) {
            int targetWidth = (int) Math.ceil(inWidth / (double) sampleSize);
            int targetHeight = (int) Math.ceil(inHeight / (double) sampleSize);
            // BitmapFactory will clear out the Bitmap before writing to it, so getDirty is safe.
            setInBitmap(options, pool.getDirty(targetWidth, targetHeight, config));
        }
        return decodeStream(is, bufferedStream, options);
    }

    /**
     * A method for getting the dimensions of an image from the given InputStream.
     *
     * @param is The InputStream representing the image.
     * @param options The options to pass to
     *          {@link BitmapFactory#decodeStream(InputStream, android.graphics.Rect,
     *              BitmapFactory.Options)}.
     * @return an array containing the dimensions of the image in the form {width, height}.
     */
    public int[] getDimensions(MarkEnforcingInputStream is, RecyclableBufferedInputStream bufferedStream,
            BitmapFactory.Options options) {
        options.inJustDecodeBounds = true;
        decodeStream(is, bufferedStream, options);
        options.inJustDecodeBounds = false;
        return new int[] { options.outWidth, options.outHeight };
    }

    private static Bitmap decodeStream(MarkEnforcingInputStream is, RecyclableBufferedInputStream bufferedStream,
            BitmapFactory.Options options) {
         if (options.inJustDecodeBounds) {
             // This is large, but jpeg headers are not size bounded so we need something large enough to minimize
             // the possibility of not being able to fit enough of the header in the buffer to get the image size so
             // that we don't fail to load images. The BufferedInputStream will create a new buffer of 2x the
             // original size each time we use up the buffer space without passing the mark so this is a maximum
             // bound on the buffer size, not a default. Most of the time we won't go past our pre-allocated 16kb.
             is.mark(MARK_POSITION);
         } else {
             // Once we've read the image header, we no longer need to allow the buffer to expand in size. To avoid
             // unnecessary allocations reading image data, we fix the mark limit so that it is no larger than our
             // current buffer size here. See issue #225.
             bufferedStream.fixMarkLimit();
         }

        final Bitmap result = BitmapFactory.decodeStream(is, null, options);
        return result;
        // decode()方法執行後會返回一個Bitmap物件
        // 此時圖片已經被載入出來
        // 接下來的工作是讓載入了的Bitmap顯示到介面上
        // 請回到分析25
    }

    ...
}

複製程式碼

步驟3：返回圖片資源

載入完圖片後，需要一層層向上返回

返回路徑 StreamBitmapDecoder（分析25）-> ImageVideoBitmapDecoder（分析24）-> GifBitmapWrapperResourceDecoder``decodeBitmapWrapper()（分析23）
由於隔得太遠，我重新把（分析23）decodeBitmapWrapper()貼出

<-- 分析23：decodeBitmapWrapper -->
private GifBitmapWrapper decodeBitmapWrapper(ImageVideoWrapper toDecode, int width, int height) throws IOException {
    GifBitmapWrapper result = null;
    Resource<Bitmap> bitmapResource = bitmapDecoder.decode(toDecode, width, height);
    if (bitmapResource != null) {
        result = new GifBitmapWrapper(bitmapResource, null);
        // 將Resource<Bitmap>封裝到了一個GifBitmapWrapper物件
    }
    return result;
   // 最終返回的是一個GifBitmapWrapper物件：既能封裝GIF，又能封裝Bitmap，從而保證了不管是什麼型別的圖片，Glide都能載入
   // 接下來我們分析下GifBitmapWrapper（） ->>分析27
}

<-- 分析27：GifBitmapWrapper（） -->
// 作用：分別對gifResource和bitmapResource做了一層封裝
public class GifBitmapWrapper {
    private final Resource<GifDrawable> gifResource;
    private final Resource<Bitmap> bitmapResource;

    public GifBitmapWrapper(Resource<Bitmap> bitmapResource, Resource<GifDrawable> gifResource) {
        if (bitmapResource != null && gifResource != null) {
            throw new IllegalArgumentException("Can only contain either a bitmap resource or a gif resource, not both");
        }
        if (bitmapResource == null && gifResource == null) {
            throw new IllegalArgumentException("Must contain either a bitmap resource or a gif resource");
        }
        this.bitmapResource = bitmapResource;
        this.gifResource = gifResource;
    }

    /**
     * Returns the size of the wrapped resource.
     */
    public int getSize() {
        if (bitmapResource != null) {
            return bitmapResource.getSize();
        } else {
            return gifResource.getSize();
        }
    }

    /**
     * Returns the wrapped {@link Bitmap} resource if it exists, or null.
     */
    public Resource<Bitmap> getBitmapResource() {
        return bitmapResource;
    }

    /**
     * Returns the wrapped {@link GifDrawable} resource if it exists, or null.
     */
    public Resource<GifDrawable> getGifResource() {
        return gifResource;
    }
}

複製程式碼

然後該GifBitmapWrapper物件會一直向上返回
直到返回到GifBitmapWrapperResourceDecoder的decode()時（分析20），會對GifBitmapWrapper物件再做一次封裝，如下所示：

此處將上面的分析20再次貼上過來

<--分析20：GifBitmapWrapperResourceDecoder物件的decode()  -->
public class GifBitmapWrapperResourceDecoder implements ResourceDecoder<ImageVideoWrapper, GifBitmapWrapper> {

    ...
    @Override
    public Resource<GifBitmapWrapper> decode(ImageVideoWrapper source, int width, int height) throws IOException {

        try {
            wrapper = decode(source, width, height, tempBytes);
        } finally {
            pool.releaseBytes(tempBytes);
        }

        // 直接看這裡
        return wrapper != null ? new GifBitmapWrapperResource(wrapper) : null;
        // 將GifBitmapWrapper封裝到一個GifBitmapWrapperResource物件中（Resource<GifBitmapWrapper>型別） 並返回
        // 該GifBitmapWrapperResource和上述的BitmapResource類似- 實現了Resource介面，可通過get()來獲取封裝的具體內容
        // GifBitmapWrapperResource（）原始碼分析 - >>分析28
    }

<-- 分析28： GifBitmapWrapperResource（）-->
// 作用：經過這層封裝後，我們從網路上得到的圖片就能夠以Resource介面的形式返回，並且還能同時處理Bitmap圖片和GIF圖片這兩種情況。
public class GifBitmapWrapperResource implements Resource<GifBitmapWrapper> {
    private final GifBitmapWrapper data;

    public GifBitmapWrapperResource(GifBitmapWrapper data) {
        if (data == null) {
            throw new NullPointerException("Data must not be null");
        }
        this.data = data;
    }

    @Override
    public GifBitmapWrapper get() {
        return data;
    }

    @Override
    public int getSize() {
        return data.getSize();
    }

    @Override
    public void recycle() {
        Resource<Bitmap> bitmapResource = data.getBitmapResource();
        if (bitmapResource != null) {
            bitmapResource.recycle();
        }
        Resource<GifDrawable> gifDataResource = data.getGifResource();
        if (gifDataResource != null) {
            gifDataResource.recycle();
        }
    }
}
複製程式碼

繼續返回到DecodeJob的decodeFromSourceData()（分析19）中：

<-- 分析19：decodeFromSourceData()（）  -->
private Resource<T> decodeFromSourceData(A data) throws IOException {

        decoded = loadProvider.getSourceDecoder().decode(data, width, height);

    return decoded;
    // 該方法返回的是一個`Resource<T>`物件，其實就是Resource<GifBitmapWrapper>物件
}
複製程式碼

繼續向上返回，最終返回到DecodeJob的decodeFromSource()中（分析15）
如下所示：

<-- 分析15：DecodeJob的decodeFromSource()  -->
class DecodeJob<A, T, Z> {
    ...

 public Resource<Z> decodeFromSource() throws Exception {
        Resource<T> decoded = decodeSource();
        // 返回到這裡，最終得到了這個Resource<T>物件，即Resource<GifBitmapWrapper>物件
        return transformEncodeAndTranscode(decoded);
        // 作用：將該Resource<T>物件 轉換成 Resource<Z>物件 -->分析29
    }


<--分析29：transformEncodeAndTranscode（） -->
private Resource<Z> transformEncodeAndTranscode(Resource<T> decoded) {

    Resource<Z> result = transcode(transformed);
     // 把Resource<T>物件轉換成Resource<Z>物件 ->>分析30
    if (Log.isLoggable(TAG, Log.VERBOSE)) {
        logWithTimeAndKey("Transcoded transformed from source", startTime);
    }
    return result;
}

<-- 分析30：transcode(transformed)  -->

private Resource<Z> transcode(Resource<T> transformed) {
    if (transformed == null) {
        return null;
    }
    return transcoder.transcode(transformed);
    // 呼叫了transcoder的transcode()
    // 這裡的transcoder就是第二步load（）中的GifBitmapWrapperDrawableTranscoder物件（回看下第2步生成物件的表） 
    // 接下來請看 ->>分析31
}

<-- 分析31：GifBitmapWrapperDrawableTranscoder.transcode(transformed) -->
// 作用：轉碼，即從Resource<GifBitmapWrapper>中取出GifBitmapWrapper物件，然後再從GifBitmapWrapper中取出Resource<Bitmap>物件。
// 因為GifBitmapWrapper是無法直接顯示到ImageView上的，只有Bitmap或者Drawable才能顯示到ImageView上。

public class GifBitmapWrapperDrawableTranscoder implements ResourceTranscoder<GifBitmapWrapper, GlideDrawable> {

...

    @Override
    public Resource<GlideDrawable> transcode(Resource<GifBitmapWrapper> toTranscode) {
        GifBitmapWrapper gifBitmap = toTranscode.get();
        // 步驟1：從Resource<GifBitmapWrapper>中取出GifBitmapWrapper物件（上面提到的呼叫get（）進行提取）
        Resource<Bitmap> bitmapResource = gifBitmap.getBitmapResource();
        // 步驟2：從GifBitmapWrapper中取出Resource<Bitmap>物件

        final Resource<? extends GlideDrawable> result;


        // 接下來做了一個判斷：

        // 1. 若Resource<Bitmap>不為空
        if (bitmapResource != null) {
            result = bitmapDrawableResourceTranscoder.transcode(bitmapResource);
            // 則需要再做一次轉碼：將Bitmap轉換成Drawable物件
            // 因為要保證靜圖和動圖的型別一致性，否則難以處理->>分析32
        } else {

      // 2. 若Resource<Bitmap>為空（說明此時載入的是GIF圖）
      // 那麼直接呼叫getGifResource()方法將圖片取出
      // 因為Glide用於載入GIF圖片是使用的GifDrawable這個類，它本身就是一個Drawable物件
            result = gifBitmap.getGifResource();
        }
        return (Resource<GlideDrawable>) result;
    }

    ...
}

<-- 分析32：bitmapDrawableResourceTranscoder.transcode(bitmapResource)-->
// 作用：再做一次轉碼：將Bitmap轉換成Drawable物件
public class GlideBitmapDrawableTranscoder implements ResourceTranscoder<Bitmap, GlideBitmapDrawable> {

...

    @Override
    public Resource<GlideBitmapDrawable> transcode(Resource<Bitmap> toTranscode) {

        GlideBitmapDrawable drawable = new GlideBitmapDrawable(resources, toTranscode.get());
        // 建立GlideBitmapDrawable物件，並把Bitmap封裝到裡面

        return new GlideBitmapDrawableResource(drawable, bitmapPool);
        // 對GlideBitmapDrawable再進行一次封裝，返回Resource<GlideBitmapDrawable>物件
    }

}

複製程式碼

此時，無論是靜圖的 Resource<GlideBitmapDrawable> 物件，還是動圖的Resource<GifDrawable> 物件，它們都屬於父類Resource<GlideDrawable>物件
因此transcode()返回的是Resource<GlideDrawable>物件，即轉換過後的Resource<Z>

所以，分析15DecodeJob的decodeFromSource()中，得到的Resource物件是 Resource<GlideDrawable>物件

步驟4：在主執行緒顯示圖片

繼續向上返回，最終返回到 EngineRunnable 的 run() 中（分析12）

重新貼出這部分程式碼

<--分析12：EngineRunnable的run() -->
@Override
public void run() {

    try {
        resource = decode();
        // 最終得到了Resource<GlideDrawable>物件
        // 接下來的工作：將該圖片顯示出來

    } catch (Exception e) {
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            Log.v(TAG, "Exception decoding", e);
        }
        exception = e;
    }
    if (isCancelled) {
        if (resource != null) {
            resource.recycle();
        }
        return;
    }
    if (resource == null) {
        onLoadFailed(exception);
    } else {
        onLoadComplete(resource);
        // 表示圖片載入已經完成 ->>分析33
    }
}

<-- 分析33：  onLoadComplete(resource) -->
private void onLoadComplete(Resource resource) {
    manager.onResourceReady(resource);
    // 該manager即EngineJob物件
    // 實際上呼叫的是EngineJob的onResourceReady() - >>分析34
}

<-- 分析34：EngineJob的onResourceReady() ： -->
class EngineJob implements EngineRunnable.EngineRunnableManager {
    ...

    private static final Handler MAIN_THREAD_HANDLER = new Handler(Looper.getMainLooper(), new MainThreadCallback());
    // 建立執行緒，並繫結主執行緒的Looper
    private final List<ResourceCallback> cbs = new ArrayList<ResourceCallback>();

    @Override
    public void onResourceReady(final Resource<?> resource) {
        this.resource = resource;
        MAIN_THREAD_HANDLER.obtainMessage(MSG_COMPLETE, this).sendToTarget();
       // 使用Handler發出一條 MSG_COMPLETE 訊息
      // 那麼在MainThreadCallback的handleMessage()方法中就會收到這條訊息 ->>分析35
      // 從此處開始，所有邏輯又回到主執行緒中進行了，即更新UI

    }

<-- 分析35：MainThreadCallback的handleMessage()-->
    private static class MainThreadCallback implements Handler.Callback {

        @Override
        public boolean handleMessage(Message message) {
            if (MSG_COMPLETE == message.what || MSG_EXCEPTION == message.what) {
                EngineJob job = (EngineJob) message.obj;
                if (MSG_COMPLETE == message.what) {
                    job.handleResultOnMainThread();
                    // 呼叫 EngineJob的handleResultOnMainThread() ->>分析36
                } else {
                    job.handleExceptionOnMainThread();
                }
                return true;
            }
            return false;
        }
    }

    ...
}

<-- 分析36：handleResultOnMainThread() -->
private void handleResultOnMainThread() {

        // 通過迴圈，呼叫了所有ResourceCallback的onResourceReady()
        for (ResourceCallback cb : cbs) {
            if (!isInIgnoredCallbacks(cb)) {
                engineResource.acquire();
                cb.onResourceReady(engineResource);
                // ResourceCallback 是在addCallback()方法當中新增的->>分析37
            }
        }
        engineResource.release();
    }

<-- 分析37：addCallback() -->
//
    public void addCallback(ResourceCallback cb) {
        Util.assertMainThread();
        if (hasResource) {
            cb.onResourceReady(engineResource);
            // 會向cbs集合中去新增ResourceCallback
        } else if (hasException) {
            cb.onException(exception);
        } else {
            cbs.add(cb);
        }
    }

// 而addCallback()是在分析11：Engine的load()中呼叫的：
<-- 上面的分析11：Engine的load() -->
public class Engine implements EngineJobListener,
        MemoryCache.ResourceRemovedListener,
        EngineResource.ResourceListener {

      ...

      public <T, Z, R> LoadStatus load(Key signature, int width, int height, DataFetcher<T> fetcher,
            DataLoadProvider<T, Z> loadProvider, Transformation<Z> transformation, ResourceTranscoder<Z, R> transcoder, Priority priority, 
            boolean isMemoryCacheable, DiskCacheStrategy diskCacheStrategy, ResourceCallback cb) {

              engineJob.addCallback(cb);
           // 呼叫addCallback()註冊了一個ResourceCallback
           // 上述引數cb是load()傳入的的最後一個引數
            // 而load（）是在GenericRequest的onSizeReady()呼叫的->>回到分析9（下面重新貼多了一次）
        return new LoadStatus(cb, engineJob);
    }

    ...
}

<-- 上面的分析9：onSizeReady() -->
public void onSizeReady(int width, int height) {

... 
    loadStatus = engine.load(signature, width, height, dataFetcher, loadProvider, transformation, transcoder,
            priority, isMemoryCacheable, diskCacheStrategy, this);
            // load（）最後一個引數是this
            // 所以，ResourceCallback型別引數cb是this
            // 而GenericRequest本身實現了ResourceCallback介面
            // 因此，EngineJob的回撥 = cb.onResourceReady(engineResource) = 最終回撥GenericRequest的onResourceReady() -->>分析6

    }
}

<-- 分析38：GenericRequest的onResourceReady() -->
// onResourceReady()存在兩個方法過載

// 過載1
public void onResourceReady(Resource<?> resource) {
    Object received = resource.get();
    // 獲取封裝的圖片物件（GlideBitmapDrawable物件 或 GifDrawable物件

       onResourceReady(resource, (R) received);
      // 然後將該獲得的圖片物件傳入到了onResourceReady()的過載方法中 ->>看過載2
}


// 過載2
private void onResourceReady(Resource<?> resource, R result) {
    
        ...

        target.onResourceReady(result, animation);
        // Target是在第3步into()的最後1行呼叫glide.buildImageViewTarget()方法來構建出的Target：GlideDrawableImageViewTarget物件
        // ->>分析39

    }

<-- 分析39：GlideDrawableImageViewTarget.onResourceReady  -->
public class GlideDrawableImageViewTarget extends ImageViewTarget<GlideDrawable> {

    @Override
    public void onResourceReady(GlideDrawable resource, GlideAnimation<? super GlideDrawable> animation) {
        if (!resource.isAnimated()) {
            float viewRatio = view.getWidth() / (float) view.getHeight();
            float drawableRatio = resource.getIntrinsicWidth() / (float) resource.getIntrinsicHeight();
            if (Math.abs(viewRatio - 1f) <= SQUARE_RATIO_MARGIN
                    && Math.abs(drawableRatio - 1f) <= SQUARE_RATIO_MARGIN) {
                resource = new SquaringDrawable(resource, view.getWidth());
            }
        }
        super.onResourceReady(resource, animation);
        // 若是靜態圖片，就呼叫父類的.onResourceReady() 將GlideDrawable顯示到ImageView上
        // GlideDrawableImageViewTarget的父類是ImageViewTarget ->>分析40
        this.resource = resource;
        resource.setLoopCount(maxLoopCount);
        resource.start();
        // 如果是GIF圖片，就呼叫resource.start()方法開始播放圖片
    }

    @Override
    protected void setResource(GlideDrawable resource) {
        view.setImageDrawable(resource);
    }

 ...
}

<-- 分析40：ImageViewTarget.onResourceReady（） -->
public abstract class ImageViewTarget<Z> extends ViewTarget<ImageView, Z> implements GlideAnimation.ViewAdapter {

    ...

    @Override
    public void onResourceReady(Z resource, GlideAnimation<? super Z> glideAnimation) {
        if (glideAnimation == null || !glideAnimation.animate(resource, this)) {
            setResource(resource);
            // 繼續往下看
        }
    }

    protected abstract void setResource(Z resource);
    // setResource()是一個抽象方法
   // 需要在子類具體實現：請回看上面分析39子類GlideDrawableImageViewTarget類重寫的setResource()：呼叫view.setImageDrawable()，而這個view就是ImageView
  // 即setResource()的具體實現是呼叫ImageView的setImageDrawable() 並 傳入圖片，於是就實現了圖片顯示。

}
複製程式碼

終於，靜圖 / Gif圖成功顯示出來

總結

至此，Glide的基本功能 圖片載入的全功能解析完畢。

5. 總結

一圖總結Glide的基本功能 圖片載入的全過程

下面我將繼續對 Glide 的其他功能進行原始碼分析 ，有興趣可以繼續關注Carson_Ho的安卓開發筆記

請點贊！因為你的鼓勵是我寫作的最大動力！

Android：這是一份全面 & 詳細的Retrofit 2.0 原始碼分析指南
2018-03-07
Android原始碼
Java：這是一份詳細&全面的HashMap 1.7 原始碼分析
2018-03-14
JavaHashMap原始碼
Android 圖片載入庫Glide知其然知其所以然之載入
2019-05-10
AndroidIDE
Glide 原始碼分析(一)：圖片壓縮
2018-11-28
IDE原始碼
glide圖片載入原理
2018-08-07
IDE
Android9.0使用Glide載入圖片問題
2019-06-26
AndroidIDE
Android圖片載入庫Glide 知其然知其所以然開篇
2019-04-23
AndroidIDE
Flutter載入圖片與Glide
2020-07-14
FlutterIDE
圖片載入框架Picasso －原始碼分析
2019-03-04
框架原始碼
圖片載入框架Picasso原始碼分析
2019-01-21
框架原始碼
Android圖片載入框架Picasso原始碼分析（基於Picasso 2.71828）
2019-02-28
Android框架原始碼
這是一份全面 & 詳細的Android多執行緒知識總結指南
2019-06-26
Android執行緒
載入本地圖片模糊，Glide載入網路圖片卻很清晰
2018-04-01
地圖IDE
Android主流三方庫原始碼分析（三、深入理解Glide原始碼）
2020-01-17
Android原始碼IDE
Glide原始碼分析
2018-05-14
IDE原始碼
Android圖片快取框架Glide
2018-05-24
Android快取框架IDE
Android圖片載入框架Fresco使用詳解
2019-04-04
Android框架
這是一份全面 & 詳細的Google序列化神器protocolBuffer 學習指南
2019-03-04
GoProtocol
Android RxJava：這是一份全面的操作符使用匯總（含詳細例項講解）
2018-05-31
AndroidRxJava
Android 動畫：這是一份詳細 & 清晰的動畫學習指南
2018-05-03
Android動畫
影片直播原始碼，載入gif圖片
2023-10-20
原始碼
Android 圖片載入框架
2019-05-05
Android框架
Glide 使用必須知道的基礎屬性——Google推薦的圖片載入庫
2018-11-30
IDEGo
要優雅！Android中這樣載入大圖片和長圖片
2019-12-27
Android
提供一個Glide靈活載入圓角圖片的方法
2018-07-02
IDE
Android 高效安全載入圖片
2019-02-22
Android
Glide的load()過程原始碼分析
2018-09-28
IDE原始碼
計算機網路：這是一份全面& 詳細 HTTP協議學習攻略
2019-03-25
計算機網路HTTP協議
Android常用圖片載入庫介紹及對比
2019-03-29
Android
Android 圖片載入快取問題：為什麼你的Glide快取沒有起作用？
2019-02-28
Android快取IDE
視訊直播app原始碼，Android RecyclerView 列表載入圖片寬高適配
2022-06-01
APP原始碼AndroidView
小說APP原始碼的圖片載入方式，懶載入和預載入的實現
2021-12-01
APP原始碼
解耦圖片載入庫
2019-02-25
解耦
Glide 4.9 原始碼分析（一） —— 一次完整載入流程
2019-04-04
IDE原始碼
Android偽圖片載入進度效果
2018-08-23
Android
Android 基礎之圖片載入(二)
2019-02-18
Android
好嗨詳細的vuex原始碼分析之API 是如何實現
2018-10-22
Vue原始碼API
深入探索Glide圖片載入框架：做了哪些優化?如何管理生命週期?怎麼做大圖載入?
2021-06-08
IDE框架優化