Android high-efficiency loading large map, multi-graph solution, effectively avoid program Oom

Load large images efficiently

We often use a lot of pictures when we write the Android program, different pictures will always have different shapes, different sizes, but in most cases, these images will be larger than the size of our program. For example, the pictures in the system pictures are mostly taken from the mobile phone camera, the resolution of these images is much higher than the resolution of our phone screen. As you should know, we write applications that have a certain memory limit, and programs that consume too much memory are prone to oom (OutOfMemory) exceptions. We can see how much memory is available for each application using the code below.

int maxmemory = (int) (Runtime.getruntime (). MaxMemory ()/ 1024);

LOG.D ("TAG", "Max memory is" + MaxMemory + "KB");

Therefore, when displaying high-resolution images, it is best to compress the images first. The compressed picture size should be similar to the size of the control used to show it, and displaying a large picture on a small imageview will not have any visual benefit, but it will take up quite a lot of our valuable memory and may have a negative impact on performance. Let's take a look at how to properly compress a large picture so that it can be displayed at the best size while preventing Oom from appearing.

The

Bitmapfactory class provides multiple parsing methods (Decodebytearray, DecodeFile, Decoderesource, etc.) for creating bitmap objects, and we should choose the appropriate method based on the source of the image. For example, the image on the SD card can use the DecodeFile method, the picture on the network can use the Decodestream method, the picture in the resource file can use the Decoderesource method. These methods attempt to allocate memory for the bitmap already built, which can easily cause oom to appear. For this reason each parsing method provides an optional bitmapfactory.options parameter that sets the Injustdecodebounds property of this parameter to true to prevent the parsing method from allocating memory for bitmap, and the return value is no longer a bitmap object, but a null 。 Although bitmap is null, Bitmapfactory.options's outwidth, Outheight, and Outmimetype properties are assigned values. This technique allows us to get the image's long and wide values and MIME types before loading the image, thus compressing the image as appropriate. As shown in the following code:

1. Bitmapfactory.options Options = new Bitmapfactory.options ();
2. Options.injustdecodebounds = true;
3. Bitmapfactory.decoderesource (Getresources (), r.id.myimage, options);
4. int imageheight = Options.outheight;
5. int imagewidth = Options.outwidth;
6. String imageType = Options.outmimetype;

To avoid oom anomalies, it's a good idea to check the size of each picture, unless you trust the source of the image so that it doesn't go beyond your program's available memory.

Now that the size of the picture is known, we can decide whether to load the entire picture into memory or load a compressed version of the image into memory. Here are a few things we need to consider:

• Estimate the memory required to load the entire picture.
• How much memory you are willing to provide in order to load this picture.
• The actual size of the control used to show this picture.
• The screen size and resolution of the current device.

For example, your imageview is only 128*96 pixels in size, just to show a thumbnail, it is obviously not worthwhile to load a picture of 1024x768 pixel completely into memory.

So how do we compress the image? This can be achieved by setting the value of Insamplesize in Bitmapfactory.options. For example, we have a picture of 2048*1536 pixels, set the value of Insamplesize to 4, you can compress this image into 512*384 pixels. Originally loading this image needs to occupy 13M of memory, compression will only need to occupy 0.75M (assuming that the image is the argb_8888 type, that is, each pixel occupies 4 bytes). The following method calculates the appropriate insamplesize value according to the width and height of the incoming:

2. Public static int calculateinsamplesize (bitmapfactory.options Options,
4. int reqwidth, int reqheight) {
6. //height and width of the source picture
8. final int height = options.outheight;
10. final int width = options.outwidth;
12. int insamplesize = 1;
14. if (height > Reqheight | | width > reqwidth) {
16. //Calculate the ratio of the actual width to the target width and height
18. final int heightratio = Math.Round ((float) height/(float) reqheight);
20. final int widthRatio = Math.Round ((float) width/(float) reqwidth);
22. //Select width and high school minimum ratio as the value of the insamplesize, which guarantees the width and height of the final image
24. //must be greater than or equal to the width and height of the target.
26. Insamplesize = HeightRatio < WidthRatio? Heightratio:widthratio;
28. }
30. return insamplesize;
32. }

Using this method, you first set the Injustdecodebounds property of the Bitmapfactory.options to true to parse the picture once. The bitmapfactory.options is then passed along with the desired width and height to the Calculateinsamplesize method, and the appropriate insamplesize value can be obtained. Then parse the picture again, use the newly obtained Insamplesize value, and set the Injustdecodebounds to False, you can get the compressed picture.

2. Public static Bitmap Decodesampledbitmapfromresource (Resources res, int resId,
4. int reqwidth, int reqheight) {
6. ///First resolution set Injustdecodebounds to True to get the picture size
8. final Bitmapfactory.options Options = new Bitmapfactory.options ();
10. Options.injustdecodebounds = true;
12. Bitmapfactory.decoderesource (res, resId, options);
14. //Call the method defined above to calculate the Insamplesize value
16. Options.insamplesize = calculateinsamplesize (options, Reqwidth, reqheight);
18. //Use the obtained Insamplesize value to parse the picture again
20. Options.injustdecodebounds = false;
22. return Bitmapfactory.decoderesource (res, resId, options);
24. }

The following code is very simple to compress any picture into a 100*100 thumbnail and show it on the ImageView.

1. Mimageview.setimagebitmap (
2. Decodesampledbitmapfromresource (Getresources (), R.id.myimage, 100));

Using Picture caching technology

Loading a picture in your application's UI interface is a simple matter, but when you need to load a lot of pictures on the interface, things get complicated. In many cases (such as using widgets such as ListView, GridView, or Viewpager), images displayed on the screen can be continuously increased through events such as sliding screens, eventually resulting in oom.

In order to ensure that the memory usage is always maintained in a reasonable range, the image removed from the screen is usually recycled. The garbage collector will also assume that you no longer have a reference to these pictures to perform GC operations on them. Using this approach to solve the problem is very good, but in order to allow the program to run quickly, in the interface to quickly load the picture, you have to consider that some pictures are recycled, the user then re-slide it into the screen this situation. It is a performance bottleneck to reload the images that have just been loaded, and you need to find a way to avoid the situation.

This time, the use of memory caching technology can be a good solution to this problem, it allows the component to quickly reload and process the picture. Let's take a look at how memory caching technology can be used to cache images so that your application will be able to improve responsiveness and fluency when loading many images.

Memory caching technology provides quick access to images that consume valuable memory from applications. The most core of these classes is LRUCache (this class is provided in the ANDROID-SUPPORT-V4 package). This class is ideal for caching images, and its main algorithm is to store recently used objects in linkedhashmap with strong references, and to remove the least recently used objects from memory before the cached value reaches a predetermined value.

In the past, we often used an implementation of a very popular memory caching technique, either soft or weak (SoftReference or weakreference). However, this is no longer recommended because, starting with Android 2.3 (API Level 9), the garbage collector is more inclined to reclaim objects holding soft or weak references, which makes soft and weak references less reliable. In addition, in Android 3.0 (API level 11), image data is stored in local memory, so it cannot be released in a predictable way, which poses a potential risk of memory overflow and crash of the application.

To be able to choose a suitable cache size for LRUCache, there are several factors that should be taken into account, such as:

• How much memory can your device allocate for each application?
• How many pictures can be displayed on the device screen at a time? How many images need to be preloaded, as it is possible to be displayed on the screen soon?
• What is the screen size and resolution of your device? An ultra-high-resolution device, such as a Galaxy nexus, requires more cache space than a lower-resolution device, such as a Nexus S, when holding the same number of images.
• The size and size of the picture, and how much memory space each image occupies.
• How often are the images accessed? Will there be some images that are more frequently accessed than other images? If so, you might want to have some images reside in memory, or use multiple LRUCache objects to distinguish different groups of pictures.
• Can you maintain a good balance between quantity and quality? In some cases, it is more effective to store multiple low-pixel images, while loads in the background to load high-resolution images.

And not a specified cache size can satisfy all applications, which is up to you. You should analyze the usage of the program's memory and then work out a suitable solution. A cache space that is too small can cause images to be released and reloaded frequently, which does not benefit. A cache space that is too large can still cause java.lang.OutOfMemory exceptions.

Here is an example of using LruCache to cache a picture:

2. Private lrucache<string, bitmap> Mmemorycache;
6. @Override
8. protected void OnCreate (Bundle savedinstancestate) {
10. //Gets the maximum amount of available memory, using memory exceeding this value can cause a OutOfMemory exception.
12. //LRUCache pass through the constructor function to the cache value, in kilobytes.
14. int maxmemory = (int) (Runtime.getruntime (). MaxMemory ()/ 1024);
16. //Use 1/8 of the maximum available memory value as the size of the cache.
18. int cacheSize = maxmemory/ 8;
20. Mmemorycache = new lrucache<string, bitmap> (cacheSize) {
22. @Override
24. protected int sizeOf (String key, Bitmap Bitmap) {
26. //Override this method to measure the size of each picture, returning the number of pictures by default.
28. return Bitmap.getbytecount ()/ 1024;
30. }
32. };
34. }
38. Public void Addbitmaptomemorycache (String key, Bitmap Bitmap) {
40. if (getbitmapfrommemcache (key) = = null) {
42. Mmemorycache.put (key, bitmap);
44. }
46. }
50. Public Bitmap Getbitmapfrommemcache (String key) {
52. return Mmemorycache.get (key);
54. }

In this example, one-eighth of the memory allocated by the system to the application is used as the cache size. This will probably have 4 megabytes (32/8) of cache space in the high-profile handsets. A full-screen GridView is populated with 4 800x480 resolution images, which will probably take up 1.5 megabytes of space (800*480*4). Therefore, this cache size can store 2.5 pages of pictures.
When a picture is loaded into the ImageView, it is first checked in the LruCache cache. If the corresponding key value is found, the ImageView is updated immediately, otherwise a background thread is opened to load the image.

2. Public void LoadBitmap (int resId, ImageView ImageView) {
4. final String ImageKey = string.valueof (resId);
6. final Bitmap Bitmap = Getbitmapfrommemcache (ImageKey);
8. if (bitmap! = null) {
10. Imageview.setimagebitmap (bitmap);
12. } Else {
14. Imageview.setimageresource (R.drawable.image_placeholder);
16. Bitmapworkertask task = new Bitmapworkertask (ImageView);
18. Task.execute (RESID);
20. }
22. }

Bitmapworkertask also puts the key-value pairs of the newly loaded pictures into the cache.

2. Class Bitmapworkertask extends Asynctask<integer, Void, bitmap> {
4. //load the picture in the background.
6. @Override
8. protected Bitmap doinbackground (Integer ... params) {
10. final Bitmap Bitmap = Decodesampledbitmapfromresource (
12. Getresources (), params[0], 100);
14. Addbitmaptomemorycache (string.valueof (params[0]), bitmap);
16. return bitmap;
18. }
20. }

Master the above two methods, whether it is to load large images in the program, or to load a large number of pictures, do not worry about oom problem! But just a theoretical introduction does not know that we can not fully understand, in the following article I will demonstrate how to use the flexible application of the above techniques in the actual program to avoid the program Oom

Android high-efficiency loading large map, multi-graph solution, effectively avoid program Oom