Using Glide like this saves more memory!!!

  [[205671]]

1. Introduction

Glide is an image loading library officially recommended by Google. It is also very simple and convenient to use. Glide helps us complete many important but common functions, such as: image loading compression, display, memory management of loaded images, etc.

For those who are not familiar with Glide, you can refer to "A good article to help you get started with Glide"

However, when using Glide, there are some tips to optimize your memory and avoid possible OOM. For example, although Glide will optimize the size of the loaded image according to the size of the loaded control, if a full-screen large image is loaded, it will still be an operation that takes up a lot of memory space.

To learn how much memory a Bitmap takes up, refer to "Bitmap takes up more memory than you think | Beating OOM"

Some suggestions in this article come from Android TV App. However, the hardware conditions of many smart TVs and smart boxes running Android TV are actually very poor. Android TV App will use most of the pictures for beautification. Therefore, the OOM problem will be magnified in terms of picture usage. The optimization solutions introduced below will not have much impact if they are not used in an environment where the hardware conditions of Android phones are very good.

2. Start Optimization

2.1 Configure TrimMemory and LowMemory

Glide does most of the memory management for us, and in fact it supports doing better.

For an App, when the system memory environment is insufficient, some methods such as onTrimMemory() or onLowMemory() will be called back. These are to remind developers that the memory environment of the current device has changed. You should adjust your memory usage strategy to avoid being cleared by the system or OOM.

If you don't know about onTrimMemroy(), you can refer to "Android Development, Memory Management That Can't Be Skipped"

Glide also provides us with a similar method interface. Developers only need to call it. It will help us optimize the cached images internally according to different memory conditions.

Here, you mainly use Glide's trimMemory() and cleanMemroy() methods, one of which is used to trim the image memory space of Glide cache, and the other is used to clean the memory space of Glide cache.

Before using onTrimMemory(), you usually implement the ComponentCallbacks2 interface and then register it in the Application using the registerComponentCallbacks() method. Of course, if you find it troublesome, you can also override the corresponding method directly in the Application.

Knowing this, we can configure when to call Glide's corresponding method according to our needs. The configuration I recommend is:

1. When lowMemory is reached, call Glide.cleanMemroy() to clean up all memory caches.
2. When the App is replaced to the background, call Glide.cleanMemroy() to clean up all memory caches.
3. In the onTrimMemroy() callback of other situations, directly call the Glide.trimMemory() method to let Glide handle the memory situation.

Then the corresponding code is as follows:

Now that we know we need to call these two methods of Glide, we still need to understand what it does for us internally. Let's first take a look at the corresponding source code of Glide.

In these Glide methods, we can see that they all operate on memoryCache and bitmapPool objects. In fact, they are two interfaces. If special processing is done here, the operations are Glide's default implementation of them, LruResourceCache and LruBitmapPool. As can be seen from the name, they all follow the Lru algorithm.

As far as Glide is concerned, Memory Cache is used by Glide to cache image resources in memory so that they can be used immediately when needed without having to perform disk I/O operations. BitmatPool is an image reuse pool maintained by Glide. LruBitmapPool uses the Lru algorithm to retain the Bitmap of the most recently used size. This is not the focus of this article, so you can just learn about it.

In fact, the operations of clearMemory() and trimMemory() in LruResourceCache and LruBitmapPool are similar. Here we take LruBitmapPool as an example.

In LruBitmapPool, clearMemory() or trimToSize() will be called according to the callback method and parameters. In fact, the trimToSize() method is called in the end. It is used to trim the number of current cached resources.

It can be seen that according to the cropping target size, the redundant Bitmap will be recycled to the appropriate target size to achieve the purpose of clearing memory.

2.2 Configure GlideModule

GlideModule is a configuration interface provided by Glide. It will be called the first time Glide is used to perform some initial configuration of Glide.

For the specific use of GlideModule, please refer to the official documentation:

https://github.com/bumptech/glide/wiki/Configuration

GlideModule is an interface and its corresponding methods need to be implemented.

Here we only need to use the applyOptions() method, which is used to append some configurations we need based on the default configuration of Glide.

Here, we can set it according to the memory status of the current device. Use ActivityManager to obtain the memory status of the current device. If it is in lowMemory, set the DecodeFormat of the image to RGB_565. Compared with the default ARGB_8888, RGB_565 has 2 bytes less per pixel. In this way, the same image will occupy half the memory when loaded into the memory (ARGB_8888 occupies 4 bytes per pixel).

2.3 Avoid using ImageView with rounded corners

In actual projects, we often use images with rounded corners or directly circular images. Circular images are mostly used for display effects such as user avatars.

On Android, there are also a large number of open source controls similar to XxxImageView, which are used to manipulate Bitmap to achieve the effect of a rounded image, such as the popular RoundedImageView on Github.

Most of them work by receiving the Bitmap you pass, then outputting a new Bitmap of the same size as the original Bitmap, and then performing some processing on the rounded corners. This actually results in holding an extra Bitmap in the memory, and the memory occupied by a picture is doubled.

So since you have chosen to use Glide, it is recommended to use the open source library glide-transformations. Glide-transformations uses Glide's bitmapTransfrom() interface to perform some transformation operations on the loaded Bitmap.

The Github address of glide-transformations is as follows:

https://github.com/wasabeef/glide-transformations

Glide-transformations provides a series of transformation operations for loaded images, from shape transformation to color transformation, which basically meets most development needs. It also reuses Glide's BitmapPool to save memory.

For the specific usage of glide-transformations, you can view the documentation on Github. The following is a picture of its effect.

2.4 Crop your image based on memory usage

The optimization points introduced above are all recommended general practices. Basically, by using the methods introduced above, the OOM caused by images should be greatly reduced.

Next, we will introduce a solution to optimize memory usage when loading full-screen images on Android TV.

First of all, we should make it clear that the hardware environment of Android TV in China is very poor. Smart boxes that cost 200 or 300 yuan are sold everywhere. After all, they also run the Android system. If you think about it, you are using a 299 Android phone, and you will not have any expectations for it. However, Android TV is designed for TV, so in most cases, it needs to support screen sizes such as 1920 * 1280. As a result, if it loads a full-screen large picture, the memory consumed is unbearable. If the memory environment is not good, it may directly crash due to OOM.

Therefore, for this extreme situation, I thought of a way to scale down the full-screen image to be displayed according to the current memory environment, so that the image loaded into the memory is scaled down accordingly.

Here we need to use the override() API of DrawableRequestBuilder, which can accept a width and height to re-specify the size of the loaded image.

Since Glide already provides standard APIs, we also need to get the width and height of the current running device.

It is recommended to use getRealSize() to get the screen width and height, which can actually get the current screen size. Other APIs may get smaller sizes on some smart TVs and boxes because they do not calculate the height of StatusBar or NavigationBar. This is based on experience.

At the same time, we also need to use the ComponentCallbacks2 interface, which has been introduced before, so I will not repeat it here.

In it, the value of trim level is recorded to reflect the current memory level. When used, getBitmapSize() is used to trim a size that matches the current memory environment.

In this example, only TRIM_MENORY_RUNNING_LOW is processed, and it will be scaled to 0.8f times according to the screen size. If you want to do more, you can add several other levels and adjust different scaling factors.

Output both and see the difference, the same full screen image, without scaling and scaling 0.8f.

 I/cxmyDev: bgImage byteCount: 8294400
 I/cxmyDev: bgImage byteCount: 5308416

As you can see, the optimization goal is achieved. It can save about 3MB of memory space, and the image is not blurred to the point of being unreadable.

3. Summary

There is no end to optimization. Let’s stop here for today and add more if I think of anything else.

[This article is an original article by 51CTO columnist "Zhang Yang". Please contact the author through WeChat official account to obtain authorization for reprinting]

Click here to read more articles by this author