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

時間 2019-11-06

標籤 android 這是一份全面詳細圖片加載 glide 源碼分析欄目 Android 简体版

原文原文鏈接

前言

Glide，該功能很是強大 Android 圖片加載開源框架相信你們並不陌生 android
正因爲他的功能強大，因此它的源碼很是複雜，這致使不少人望而卻步git
本人嘗試將 Glide 的功能進行分解，並單獨針對每一個功能進行源碼分析，從而下降Glide源碼的複雜度。github

接下來，我將推出一系列關於 Glide的功能源碼分析，有興趣能夠繼續關注緩存

今天，我將主要源碼分析Glide的基礎功能：圖片加載 ，但願大家會喜歡。

因爲文章較長，但願讀者先收藏 & 預留足夠時間進行查看。bash

1. 簡介

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

注：從上面可看出，Glide不只解決了圖片異步加載的問題，還解決了Android加載圖片時的一些常見問題，功能十分強大。服務器

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

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

3. 具體使用

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

4. 源碼分析

在進行源碼分析前，有幾點須要特別說明：app

本次源碼分析是基於 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() 並 傳入圖片，因而就實現了圖片顯示。

}
複製代碼