SoFunction
Updated on 2025-03-11

Analysis of Android Glide usage methods and principles

Principle analysis

Glide's principles are complex and efficient. It is first loaded based on the given image URL or resource ID, and supports a variety of data sources, including network requests, local files, ContentProvider, etc. Glide improves loading speed through a cache mechanism, and also stores compressed images on disk, saving memory and traffic.

Glide designed aRequestBuilderThe mode allows us to configure image loading parameters through chain call methods. This design makes the code more concise and easy to read.

In addition, Glide supports image transformation and loading animations, and can apply various transformation effects, such as circular pictures, rounded corner pictures and grayscale pictures, and can also add animation effects to the image loading process to improve user experience.

Use posture

Here are some optimized Glide usage poses to help you use this library more fully:

Add dependencies

First, add Glide's dependencies to the project:

implementation ':glide:4.12.0'
kapt ':compiler:4.12.0'

Loading pictures

Loading images using Glide is very simple, with just a few lines of code:

(context)
     .load(url)
     .into(imageView)

Herecontextis a context object,urlIt is the URL of the image.imageViewis the ImageView that displays the image.

Set placeholders and error pictures

You can useplaceholder()Methods to set the placeholder picture displayed during loading, and useerror()Method Settings the picture displayed when loading fails:

(context)
     .load(url)
     .placeholder()
     .error()
     .into(imageView)

Set thumbnails

Glide supports setting thumbnails to improve loading speed. passthumbnail()Method to set the URL or resource ID of the thumbnail:

(context)
     .load(url)
     .thumbnail(0.1f)
     .into(imageView)

Picture transformation

You can usetransform()Method adds transformation effect to the image. For example, usecircleCrop()Methods can cut the picture into a circle.roundedCorners()Methods can change the corners of the picture into rounded corners:

(context)
     .load(url)
     .transform(CircleCrop())
     .into(imageView)

Loading animation

passanimate()Method, you can add animation effects to the image loading process. For example, usecrossFade()Method to add fade effect:

(context)
     .load(url)
     .animate(.fade_in)
     .into(imageView)

Image compression

Glide calculates the actual size of the image based on the size of the target ImageView and the ScaleType and compresses it.

When loading the image, you need to specify the width and height of the target ImageView and the ScaleType. Glide will determine how the image is compressed based on this information.

If the width and height ratio of the target ImageView is inconsistent with the image's ratio, Glide will calculate the scaling ratio based on ScaleType, and then compress the image proportionally to suit the ImageView size.

If the aspect ratio of the target ImageView is consistent with the ratio of the image, Glide will directly load the original image without compression.

In this way, Glide automatically compresses images according to the target ImageView to improve loading speed and save memory.

In addition, Glide also supports custom image compression strategies. We can achieveTransformationInterface to define its own compression algorithm.

Custom image compression strategy

Custom image compression strategy is implementedTransformationInterface implementation. This interface containstransform()Method where custom compression operations can be defined.

Here is an example showing how to implement a custom image compression strategy:

class CustomTransformation : Transformation<Bitmap> {
    override fun transform(
        context: Context,
        resource: Resource<Bitmap>,
        outWidth: Int,
        outHeight: Int
    ): Resource<Bitmap> {
        val originalBitmap = ()
        // Custom compression algorithm        val compressedBitmap = customCompress(originalBitmap)
        return BitmapResource(compressedBitmap, (context).bitmapPool)
    }
    override fun getId(): String {
        return "customTransformation" // Returns a unique identifier for cache    }
    private fun customCompress(bitmap: Bitmap): Bitmap {
        // Custom compression algorithm implementation        // ...
        return compressedBitmap
    }
}

When using a custom image compression strategy, it can be applied in a chain call in Glide:

(context)
     .load(url)
     .transform(CustomTransformation())
     .into(imageView)

By implementingTransformationInterface, you can formulate different compression algorithms according to your needs to meet specific image compression needs.

Image cache

Glide uses a double cache policy to manage image cache. It caches uncompressed original images in memory, improving loading speed, and also stores compressed images on disk, saving memory and traffic.

Glide's caching mechanism is very smart. It generates a unique cache key based on the image's URL or resource ID to ensure that different images are not confused. In addition, Glide supports custom cache size and expiration period

, to meet different needs.

Glide's caching mechanism is one of the keys to its excellent performance. Through the combination of memory cache and disk cache, it can efficiently manage loaded image data, thereby increasing the speed of subsequent loading.

Memory cache

Glide uses memory cache to store recently used image data for quick access. Memory cache is based on the LRU (Least Recently Used, least recently used) algorithm, retaining the recently loaded image data. When the application needs to access these images again, it can be provided directly, thus avoiding frequent network requests and disk reads.

Disk Cache

Disk cache is divided into active resource cache and inactive resource cache.

  • Active Resources Cache:This is a small, writable disk cache that stores the image data currently in use. It helps to reduce repeated disk reads of frequently loaded pictures.

  • Inactive Resources Cache:This is a larger, read-only disk cache for long-term storage of loaded image data. When the active resource cache is full, Glide moves images that are no longer active from the active cache to the unactive resource cache to make room for new images to use.

Cache Policy

Glide allows developers to set different cache policies according to their needs. For example:

  • : Caches both in memory and disk.
  • : No disk cache is used.
  • : Only caches raw data.
  • : Only the converted resources are cached.
  • : Automatically select cache policy based on the image data source.

Clear cache

If the image changes or needs to be freed up, the Glide cache can be manually cleared. Use the following code to clear the disk cache:

(context).clearDiskCache()

Clearing the memory cache can be used:

(context).clearMemory()

To sum up, Glide's caching mechanism efficiently improves image loading performance through the combination of memory and disk cache. This mechanism allows the same image to load faster, saves user traffic, and displays images normally when offline or when the network is unstable.

in conclusion

Android Glide is a powerful and flexible picture loading library. By gaining insight into its working principles and application methods, you can use this excellent library more freely to improve the application's image loading experience.

This is the article about the analysis of Android Glide usage methods and principles. For more information about Android Glide usage, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!