Android source code advanced Glide loading process and source code detailed explanation

[[421043]]

This article is reprinted from the WeChat public account "Android Development Programming", the author is Android Development Programming. Please contact the Android Development Programming public account for reprinting this article.

Preface

Glide is an open source image loading library for Android written in pure Java. It can help us download, cache, and display images in various formats, including GIF format.

Yesterday we analyzed the cache strategy mechanism of Glide from the source code;

So today we will strike while the iron is hot to analyze a wave of loading processes;

1. Common loading methods of glide

1. Load the image into imageView

 Glide. with (Context context). load (Strint url). into (ImageView imageView);

2. Load various forms of pictures into ImageView

 // Load local images
 File file = new File(getExternalCacheDir() + "/image.jpg" );
 Glide. with (this). load (file). into (imageView);
 // Load application resources
 int resource = R.drawable.image;
 Glide. with (this). load (resource). into (imageView);
 // Load binary stream
 byte[] image = getImageBytes();
 Glide. with (this). load (image). into (imageView);
 // Load the Uri object
 Uri imageUri = getImageUri();
 Glide. with (this). load (imageUri). into (imageView);

3. Loading with placeholder image

 Glide. with (this). load (url).placeholder(R.drawable.loading). into (imageView);

The purpose of the placeholder image is to display an image to the user in advance when the target image has not yet been loaded;

4. Place a placeholder when loading fails

 Glide. with (this). load (url).placeholder(R.drawable.loading).error(R.drawable.error)
 .diskCacheStrategy(DiskCacheStrategy.NONE) //Disable Glide's hard disk cache mechanism
 .into (imageView);
 //DiskCacheStrategy.NONE: means no content is cached.
 //DiskCacheStrategy.SOURCE: means only the original image is cached.
 //DiskCacheStrategy.RESULT: means only caching converted images (default option).
 //DiskCacheStrategy. ALL : Indicates that both the original images and the converted images are cached.

5. Load pictures in the specified format--specify as still pictures

 Glide.with ( this)
 .load (url)
 .asBitmap() //Only load static images. If it is a git image, only load the first frame.
     .placeholder(R.drawable.loading)
 .error(R.drawable.error)
     .diskCacheStrategy(DiskCacheStrategy.NONE)
 .into (imageView);

6. Load dynamic images

 Glide.with ( this)
 .load (url)
 .asGif()//Load a dynamic image. If the existing image is not a gif image, directly load the error placeholder image.
     .placeholder(R.drawable.loading)
 .error(R.drawable.error)
     .diskCacheStrategy(DiskCacheStrategy.NONE)
 .into (imageView);

7. Load pictures of specified size

 Glide.with ( this)
 .load (url)
     .placeholder(R.drawable.loading)
 .error(R.drawable.error)
     .diskCacheStrategy(DiskCacheStrategy.NONE)
 .override(100, 100) //Specify the image size
 .into (imageView);

8. Turn off the framework's memory cache mechanism

 Glide.with ( this)
 .load (url)
 .skipMemoryCache( true ) //When the passed parameter is false , the memory cache is turned off.
 .into (imageView);

9. Turn off the hard disk cache

 Glide.with ( this)
 .load (url)
 .diskCacheStrategy(DiskCacheStrategy.NONE) //Disable hard disk cache operation
 .into (imageView);
 //Other parameters indicate:
 //DiskCacheStrategy.NONE: means no content is cached.
 //DiskCacheStrategy.SOURCE: means only the original image is cached.
 //DiskCacheStrategy.RESULT: means only caching converted images (default option).
 //DiskCacheStrategy. ALL : Indicates that both the original images and the converted images are cached.

10. Solution when the referenced URL has a token

 public class MyGlideUrl extends GlideUrl {
 private String mUrl;
 public MyGlideUrl(String url) {
 super(url);
 mUrl = url;
 }
 @Override
 public String getCacheKey() {
 return mUrl.replace ( findTokenParam (), "" );
 }
    private String findTokenParam() {
        String tokenParam = "" ;
 int tokenKeyIndex = mUrl.indexOf( "?token=" ) >= 0 ? mUrl.indexOf( "?token=" ) : mUrl.indexOf( "&token=" );
        if (tokenKeyIndex != -1) {
 int nextAndIndex = mUrl.indexOf( "&" , tokenKeyIndex + 1);
            if (nextAndIndex != -1) {
                tokenParam = mUrl.substring (tokenKeyIndex + 1, nextAndIndex + 1);
 } else {
                tokenParam = mUrl.substring (tokenKeyIndex);
 }
 }
 return tokenParam;
 }
 }

Then load the image as follows:

 Glide.with ( this)
     . load (new MyGlideUrl(url))
 .into (imageView);

11. Use Glide to load images into different controls or load them into different usage modes

(1) Get the picture example

 //1. You can get the image instance by constructing the target yourself
 SimpleTarget<GlideDrawable> simpleTarget = new SimpleTarget<GlideDrawable>() {
 @Override
 public void onResourceReady(GlideDrawable resource, GlideAnimation glideAnimation) {
        imageView.setImageDrawable(resource);
 }
 };
 //2. Record the image instance to the specified imageview, and you can also do other things
 public void loadImage( View   view ) {
    String url = "http://cn.bing.com/az/hprichbg/rb/TOAD_ZH-CN7336795473_1920x1080.jpg" ;
 Glide.with (this)
 .load (url)
         . into (simpleTarget);
 }

(2) Load the image to any location

 /*
 * Load the image as the control background
 */
 public class MyLayout extends LinearLayout {
    private ViewTarget<MyLayout, GlideDrawable> viewTarget;
 public MyLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
        viewTarget = new ViewTarget<MyLayout, GlideDrawable>(this) {
 @Override
 public void onResourceReady(GlideDrawable resource, GlideAnimation glideAnimation) {
                MyLayout myLayout = getView();
                myLayout.setImageAsBackground(resource);
 }
 };
 }
 public ViewTarget<MyLayout, GlideDrawable> getTarget() {
 return viewTarget;
 }
 public void setImageAsBackground(GlideDrawable resource) {
        setBackground(resource);
 }
 }
 //Reference the image to the specified control as the background
 public class MainActivity extends AppCompatActivity {
 MyLayout myLayout;
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        myLayout = (MyLayout) findViewById(R.id.background);
 }
 public void loadImage( View   view ) {
        String url = "http://cn.bing.com/az/hprichbg/rb/TOAD_ZH-CN7336795473_1920x1080.jpg" ;
 Glide.with (this)
 .load (url)
             . into (myLayout.getTarget());
 }
 }

12. Glide implements preloading

 //a. Preload code
 Glide.with (this)
 .load (url)
     .diskCacheStrategy(DiskCacheStrategy.SOURCE)
 .preload();
 //preload() has two overloads
 // 1. Overload with parameters. The parameter is used to set the size of the preloaded image.
 //2. Without parameters, the loaded image is of original size;
 //b. Use preloaded images
 Glide.with (this)
 .load (url)
     .diskCacheStrategy(DiskCacheStrategy.SOURCE)
 .into (imageView);

2. Detailed explanation of Glide loading process

1. with(context)

 // Glide.java
 public   static RequestManager with (@NonNull Context context) {
 return getRetriever(context).get(context);
 }
 public   static RequestManager with (@NonNull Activity activity) {
 return getRetriever(activity).get(activity);
 }
 public   static RequestManager with (@NonNull FragmentActivity activity) {
 return getRetriever(activity).get(activity);
 }
 public   static RequestManager with (@NonNull Fragment fragment) {
 return getRetriever(fragment.getContext()).get(fragment);
 }
 public   static RequestManager with (@NonNull View   view ) {
 return getRetriever( view .getContext()).get( view );
 }

This function creates a Glide instance and initializes some basic parameters, then creates a RequestManager object and returns it. There are five scenarios in total, and here we will analyze the case where the parameter is of type Context.

 // Glide.java
 public   static RequestManager with (@NonNull Context context) {
 return getRetriever(context).get(context);
 }

It can be seen that the function first calls getRetriever(context) to obtain the RequestManagerRetriever object. Before creating the object, the Glide instance is first obtained through the get method in Glide.java (Glide is a singleton), and the configuration of AppGlideModule and AndroidManifest.xml is read at the same time.

 // Glide.java
 private static RequestManagerRetriever getRetriever(@Nullable Context context) {
 // Glide.get(context) gets the Glide instance
 return Glide.get(context).getRequestManagerRetriever();
 }
 public   static Glide get(@NonNull Context context) {
 if (glide == null ) {
 // Load AppGlideModule
      GeneratedAppGlideModule annotationGeneratedModule =
          getAnnotationGeneratedGlideModules(context.getApplicationContext());
      synchronized (Glide.class) {
 if (glide == null ) {
 // Load Mainfest configuration and register module callback
 // This step executes the Glide.build() method to construct a Glide instance. The build method will be discussed below.
          checkAndInitializeGlide(context, annotationGeneratedModule);
 }
 }
 }
 return glide;
 }

After obtaining the Glide instance, the getRequestManagerRetriever method is called to return the RequestManagerRetriever object that has been initialized in the previous step.

 // Glide.java
 public RequestManagerRetriever getRequestManagerRetriever() {
 return requestManagerRetriever;
 }

Next, let's take a look at how RequestManagerRetriever is initialized and what it does during the initialization process. First, paste the source code to see the specific implementation of the Glide.build method (this method is called in the checkAndInitializeGlide() function above):

 // GlideBuilder.java
 Glide build(@NonNull Context context) {
 // Allocate thread pool and configure cache strategy
      sourceExecutor = GlideExecutor.newSourceExecutor();
      diskCacheExecutor = GlideExecutor.newDiskCacheExecutor();
      animationExecutor = GlideExecutor.newAnimationExecutor();
      memorySizeCalculator = new MemorySizeCalculator.Builder(context).build();
 //Monitor network changes
      connectivityMonitorFactory = new DefaultConnectivityMonitorFactory();
 int   size = memorySizeCalculator.getBitmapPoolSize();
 if ( size > 0 ) {
        bitmapPool = new LruBitmapPool( size );
 } else {
        bitmapPool = new BitmapPoolAdapter();
 }
      arrayPool = new LruArrayPool(memorySizeCalculator.getArrayPoolSizeInBytes());
      memoryCache = new LruResourceCache(memorySizeCalculator.getMemoryCacheSize());
      diskCacheFactory = new InternalCacheDiskCacheFactory(context);
 // The engine is responsible for executing the loading task
 if (engine == null ) {
 engine =
 new Engine(
 memoryCache,
              diskCacheFactory,
              diskCacheExecutor,
 sourceExecutor,
              GlideExecutor.newUnlimitedSourceExecutor(),
              animationExecutor,
              isActiveResourceRetentionAllowed);
 }
    if (defaultRequestListeners == null ) {
      defaultRequestListeners = Collections.emptyList();
 } else {
      defaultRequestListeners = Collections.unmodifiableList(defaultRequestListeners);
 }
    RequestManagerRetriever requestManagerRetriever =
        new RequestManagerRetriever(requestManagerFactory);
 return new Glide(
 context,
 engine,
 memoryCache,
 bitmapPool,
 arrayPool,
        requestManagerRetriever,
        connectivityMonitorFactory,
 logLevel,
        defaultRequestOptionsFactory,
        defaultTransitionOptions,
        defaultRequestListeners,
        isLoggingRequestOriginsEnabled,
        isImageDecoderEnabledForBitmaps);
 }

• When executing the Glide.get() method, resource loading, cache thread pool, and cache strategy have been allocated. The engine here is responsible for loading and decoding resources. ConnectivityMonitor registers a network status listener. When the network is disconnected, it suspends requesting network resources and continues requesting resources after reconnection.
• RequestManagerRetriever is originally constructed by the RequestManagerFactory factory class. Enter the RequestManagerFactory.java class and you can see that the get method obtains the corresponding RequestManager object;
• From here we can see that in either case, when the App enters the background, the page will become invisible. At this time, RequestManager is bound to ApplicationContext, which is consistent with the life cycle of App. Therefore, the callback function related to the life cycle is also implemented in the RequestManager.java class;

 // RequestManagerRetriever.java
 // get has several overloaded methods, here we only select the context parameter for analysis
 public RequestManager get(@NonNull Context context) {
    if (Util.isOnMainThread() && !(context instanceof Application)) {
      if (context instanceof FragmentActivity) {
 return get((FragmentActivity) context);
      } else if (context instanceof Activity) {
 return get((Activity) context);
      } else if (context instanceof ContextWrapper
          && ((ContextWrapper) context).getBaseContext().getApplicationContext() != null ) {
 return get(((ContextWrapper) context).getBaseContext());
 }
 }
 return getApplicationManager(context);
 }

After executing Glide.with(context), we get a corresponding RequestManager object, and then execute the next task load(url);

2. load(url)

After getting the RequestManager, call the load method to start the next step. Let's first look at the implementation of the load method.

 // RequestManager.java
 public RequestBuilder<Drawable> load (@Nullable Bitmap bitmap) {
 return asDrawable(). load (bitmap);
 }
 public RequestBuilder<Drawable> load (@Nullable Drawable drawable) {
 return asDrawable(). load (drawable);
 }
 public RequestBuilder<Drawable> load (@Nullable String string) {
 return asDrawable(). load (string);
 }
 public RequestBuilder<Drawable> load (@Nullable Uri uri) {
 return asDrawable(). load (uri);
 }
 public RequestBuilder<Drawable> load (@Nullable File file) {
 return asDrawable(). load (file);
 }
 public RequestBuilder<Drawable> load (@RawRes @DrawableRes @Nullable Integer resourceId) {
 return asDrawable(). load (resourceId);
 }
 public RequestBuilder<Drawable> load (@Nullable URL url) {
 return asDrawable(). load (url);
 }
 public RequestBuilder<Drawable> load (@Nullable byte[] model) {
 return asDrawable(). load (model);
 }
 public RequestBuilder<Drawable> load (@Nullable Object model) {
 return asDrawable(). load (model);
 }

• load() also has multiple overloaded functions. The parameters passed in can be image objects Bitmap, Drawable, local resource Uri, online resource path Url, file object File, assets resource id. Here we only look at the case where the parameter is Url;
• asDrawable().load(url) returns a RequestBuilder object. First, let’s see what the asDrawable method does;

 // RequestManager.java
 public RequestBuilder<Drawable> asDrawable() {
 return   as (Drawable.class);
 }
 public <ResourceType> RequestBuilder<ResourceType> as (@NonNull Class<ResourceType> resourceClass) {
 return new RequestBuilder<>(glide, this, resourceClass, context);
 }

The asDrawable method creates a RequestBuilder object and then calls the load method in RequestBuilder.java;

 // RequestBuilder.java
 // The String type URL passed in will be used as the cache key  
 public RequestBuilder<TranscodeType> load (@Nullable String string) {
 return loadGeneric(string);
 }
 // This returns itself
  private RequestBuilder<TranscodeType> loadGeneric(@Nullable Object model) {
 this.model = model;
 isModelSet = true ;
 return this;
 }

The main job of the load function is to construct a corresponding RequestBuilder object based on the resource type passed in. Now all preparations are ready, and the next step is the most important step - loading and displaying files. Let's see how the into(view) method completes these tasks;

3. into(view)

What we get is the corresponding type RequestBuilder instance, so let's look at the specific implementation of the into method in this class. The into method also has two overloaded functions: into(@NonNull Y target) and into(@NonNull ImageView) (these two functions will eventually go to the same function). When calling the into method, the parameter we pass in is of type ImageView;

 // RequestBuilder.java
 public ViewTarget<ImageView, TranscodeType> into (@NonNull ImageView view ) {
 Util.assertMainThread();
    BaseRequestOptions<?> requestOptions = this;
 // View 's scale type.
 // Process image scaling and initialize the corresponding requestOptions object according to the scaling type
 ......
 return   into (
        glideContext.buildImageViewTarget( view , transcodeClass),
        /*targetListener=*/ null ,
 requestOptions,
 Executors.mainThreadExecutor() // handler running on the main thread
 );
 }

• The above code snippet first processes the image scaling type (cropping, alignment, etc.), and puts the generated related parameters into the requestOptions object, and then passes it as a parameter to the private method into of the RequestBuilder.java class. The four parameters defined in this method are: viewTarget, target callback listener, request parameters, and callback function of the main thread;
• Obviously, the external ImageView object is finally converted into a ViewTarget object, and the conversion function is glideContext.buildImageViewTarget(view, transcodeClass);

 // GlideContext.java
 public <X> ViewTarget<ImageView, X> buildImageViewTarget(@NonNull ImageView imageView, @NonNull Class<X> transcodeClass) {
 return imageViewTargetFactory.buildTarget(imageView, transcodeClass);
 }

ViewTarget is generated by the ImageViewTargetFactory factory method. Next, let’s see how the buildTarget method generates a ViewTarget object.

 // imageViewTargetFactory.java
 public class ImageViewTargetFactory {
 public <Z> ViewTarget<ImageView, Z> buildTarget(@NonNull ImageView view , @NonNull Class<Z> clazz) {
    if (Bitmap.class.equals(clazz)) {
 return (ViewTarget<ImageView, Z>) new BitmapImageViewTarget( view );
    } else if (Drawable.class.isAssignableFrom(clazz)) {
 return (ViewTarget<ImageView, Z>) new DrawableImageViewTarget( view );
 } else {
      throw new IllegalArgumentException( "Unhandled class: " + clazz + ", try .as(Class).transcode(ResourceTranscoder)" );
 }
 }
 }

You can see that no matter what type of parameter is passed in, it will eventually be converted into two types of ViewTarget: BitmapImageViewTarget; DrawableImageViewTarget; the choice here depends on whether the asBitmap(), asGif(), and asDrawable() functions are called. The default is Bitmap type, so the default returned here is BitmapImageViewTarget;

 // BitmapImageViewTarget.java
 public class BitmapImageViewTarget extends ImageViewTarget<Bitmap> {
 public BitmapImageViewTarget(ImageView view ) {
 super( view );
 }
 @Override
  protected void setResource(Bitmap resource) {
 view .setImageBitmap(resource); // Display the image
 }
 }

Now that ViewTarget has been created, let's go back to the private into method of RequestBuilder.java

 // RequestBuilder.java`
 private <Y extends Target<TranscodeType>> Y into (
 @NonNull Y target,
      @Nullable RequestListener<TranscodeType> targetListener,
      BaseRequestOptions<?> options,
      Executor callbackExecutor) {
 // Note 1: Create request
    Request request = buildRequest(target, targetListener, options, callbackExecutor);
 // Get the previous request object
    Request previous = target.getRequest();
 // Same as the previous request AND the previous request has completed
    if (request.isEquivalentTo(previous)&& !isSkipMemoryCacheWithCompletePreviousRequest(options, previous)) {
 // The previous request has completed, so restart it
      if (!Preconditions.checkNotNull(previous).isRunning()) {
 previous.begin ();
 }
 return target;
 }
 // If it is different from the previous request, clear the previous one and add the new request
    requestManager.clear(target);
    target.setRequest(request);
    requestManager.track(target, request);
 return target;
 }

Following the code order, let's see what this method does at each step:

• First, execute the buildRequest method to create a new Request request req1;
• Get the ongoing Request req2 on the current ViewTarget;
• Determine whether the newly created request req1 is the same as the existing request req2. If they are the same, determine whether to skip the cache of the request req2. If both conditions are met, start executing the begin() method to request resources and stop executing further. If neither condition is met, continue to step 4.
• Set the latest request req1 to ViewTarget, and then execute the track method to track req1.
• Executing the into(view) method first gets the Request request, and then starts executing the Request. If it is a reused Request, directly execute begin(), otherwise execute track(target, request), but eventually still execute begin();

 // RequestManager.java
 synchronized void track(@NonNull Target<?> target, @NonNull Request request) {
 //Binding with lifecycle
    targetTracker.track(target);
 // Start request
    requestTracker.runRequest(request);
 }
 // RequestTracker.java
 public void runRequest(@NonNull Request request) {
 requests.add (request);
 if (!isPaused) {
 request.begin (); // Start loading immediately
 } else {
 //Prevents any bitmaps from previous requests from being loaded, releases any resources owned by this request, displays the current placeholder (if one was provided), and marks the request as canceled.
      // request.java(Interface)
 request.clear();
 pendingRequests.add (request); // Join the queue and wait for execution
 }
 }

• The source code of the track method first executes targetTracker.track(target) to listen to the ViewTarget's request, and then runRequest starts to execute. Since the request is ultimately started through the begin() method, let's first look at the specific implementation of the begin() method;
• The Request class is of interface type, and begin() is its abstract method. So if we want to figure out the specific implementation of begin(), we must first find the implementation class of Request and start with the buildRequest(xx) method. Also, post the source code first:

 // RequestBuilder.java
 private Request buildRequest(
      Target<TranscodeType> target,
      @Nullable RequestListener<TranscodeType> targetListener,
      BaseRequestOptions<?> requestOptions,
      Executor callbackExecutor) {
 return buildRequestRecursive(
        /*requestLock=*/ new Object(),
 target,
 targetListener,
        /*parentCoordinator=*/ null ,
 transitionOptions,
        requestOptions.getPriority(),
        requestOptions.getOverrideWidth(),
        requestOptions.getOverrideHeight(),
 requestOptions,
 callbackExecutor);
 }
 private Request buildRequestRecursive(
 Object requestLock,
      Target<TranscodeType> target,
      @Nullable RequestListener<TranscodeType> targetListener,
      @Nullable RequestCoordinator parentCoordinator,
      TransitionOptions<?, ? super TranscodeType> transitionOptions,
 Priority priority,
 int overrideWidth,
 int overrideHeight,
      BaseRequestOptions<?> requestOptions,
      Executor callbackExecutor) {
    // Build the ErrorRequestCoordinator first if necessary so we can update parentCoordinator.
    ErrorRequestCoordinator errorRequestCoordinator = null ;
 // Request error
    if (errorBuilder != null ) {
      errorRequestCoordinator = new ErrorRequestCoordinator(requestLock, parentCoordinator);
      parentCoordinator = errorRequestCoordinator;
 }
 // It is not possible to confirm which of the completion request and the thumbnail request is completed first, so when the thumbnail is completed after the completion request, the thumbnail will no longer be displayed
 Request mainRequest =
        buildThumbnailRequestRecursive(
 requestLock,
 target,
 targetListener,
            parentCoordinator,
            transitionOptions,
 priority,
 overrideWidth,
 overrideHeight,
 requestOptions,
            callbackExecutor);
 // The request is successful, and the thumbnail Request is returned directly
    if (errorRequestCoordinator == null ) {
 return mainRequest;
 }
 // ...
 Request errorRequest =
        errorBuilder.buildRequestRecursive(
 requestLock,
 target,
 targetListener,
            errorRequestCoordinator,
            errorBuilder.transitionOptions,
            errorBuilder.getPriority(),
            errorOverrideWidth,
            errorOverrideHeight,
 errorBuilder,
            callbackExecutor);
 // Return thumbnail requests and error requests at the same time
    errorRequestCoordinator.setRequests(mainRequest, errorRequest);
 return errorRequestCoordinator;
 }

Obviously, the mainRequest in the code is the Request we are looking for, which is returned by the buildThumbnailRequestRecursive method. Going deep into it, we find that the Request is actually generated by the SingleRequest.obtain method, which means that the Request we finally get is actually an instance of the SingleRequest class. The process here is relatively simple, so I won't post the code. Let's go directly to the SingleRequest class to see how the begin method is implemented;

 // SingleRequest.java
 public void begin () {
      if (status == Status.COMPLETE) {
 // The resource has been downloaded, call back directly
 // Execute the animation
        onResourceReady(resource, DataSource.MEMORY_CACHE);
 return ;
 }
 // Calculate the size
      if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
        onSizeReady(overrideWidth, overrideHeight);
 } else {
 target.getSize(this);
 }
      if ((status == Status.RUNNING || status == Status.WAITING_FOR_SIZE)
          && canNotifyStatusChanged()) {
 // Start loading
 // Set the position
        target.onLoadStarted(getPlaceholderDrawable());
 }
 }

After entering the begin method, first determine if the resource has been loaded, then directly call back onResourceReady to display the image and cache it. Otherwise, measure the image size and then start loading the image (execute the loading task in onSizeReady()) and display the placeholder image at the same time:

① overrideWith, overrideHeight are set by override(width, height):

Glide.with(mContext).load(url).override(75, 75).into(imageView);

②The placeholder image is set by the user calling placeholder(resId):

Glide.with(mContext).load(url).placeholder(resId).into(imageView);

Next, let's look at how onSizeReady() loads the image after measuring the image size:

 // SingleRequest.java
 @Override
 public void onSizeReady( int width, int height) {
      if (status != Status.WAITING_FOR_SIZE) {
 return ;
 }
      status = Status.RUNNING;
 // Get the image size
 float sizeMultiplier = requestOptions.getSizeMultiplier();
      this.width = maybeApplySizeMultiplier(width, sizeMultiplier);
      this.height = maybeApplySizeMultiplier(height, sizeMultiplier);
 // Start loading the task
 loadStatus =
 engine.load (
 glideContext,
 model,
              requestOptions.getSignature(),
 this.width,
 this.height,
              requestOptions.getResourceClass(),
 transcodeClass,
 priority,
              requestOptions.getDiskCacheStrategy(),
              requestOptions.getTransformations(),
              requestOptions.isTransformationRequired(),
              requestOptions.isScaleOnlyOrNoTransform(),
              requestOptions.getOptions(),
              requestOptions.isMemoryCacheable(),
              requestOptions.getUseUnlimitedSourceGeneratorsPool(),
              requestOptions.getUseAnimationPool(),
              requestOptions.getOnlyRetrieveFromCache(),
 this,
              callbackExecutor);
 }

• It can be seen that the actual download task is implemented in the load method of the Engine class, which also involves the image caching logic;
• Finally, through the Handler mechanism, Glide switches from the worker thread to the main thread, and finally displays the Drawable object on the ImageView;

Summarize

The entire business process of Glide initialization, displaying placeholder images, and picture covers has been completed;

You can learn the design patterns in Glide: singleton pattern, factory method, strategy pattern, etc., and find your own shortcomings;

Glide's image cache can be found in the previous article