BitmapFactory解析与Bitmap的内存优化

转自：http://www.tuicool.com/articles/3eMNr2n

1、BitmapFactory解析Bitmap的原理

BitmapFactory提供的解析Bitmap的静态工厂方法有以下五种：

Bitmap decodeFile(...)
Bitmap decodeResource(...)
Bitmap decodeByteArray(...)
Bitmap decodeStream(...)
Bitmap decodeFileDescriptor(...)

其中常用的三个：decodeFile、decodeResource、decodeStream。decodeFile和decodeResource其实最终都是调用decodeStream方法来解析Bitmap，decodeStream的内部则是调用两个native方法解析Bitmap的：

nativeDecodeAsset()
nativeDecodeStream()

这两个native方法只是对应decodeFile和decodeResource、decodeStream来解析的，像decodeByteArray、decodeFileDescriptor也有专门的native方法负责解析Bitmap。

接下来就是看看这两个方法在解析Bitmap时究竟有什么区别decodeFile、decodeResource，查看后发现它们调用路径如下：

decodeFile->decodeStreamdecodeResource->decodeResourceStream->decodeStream

decodeResource在解析时多调用了一个 decodeResourceStream 方法，而这个decodeResourceStream方法代码如下：

public static Bitmap decodeResourceStream(Resources res, TypedValue value,
            InputStream is, Rect pad, Options opts) {
if (opts == null) {
            opts = new Options();
        }
if (opts.inDensity == 0 && value != null) {
            final int density = value.density;
if (density == TypedValue.DENSITY_DEFAULT) {
                opts.inDensity = DisplayMetrics.DENSITY_DEFAULT;
            } else if (density != TypedValue.DENSITY_NONE) {
                opts.inDensity = density;
            }
        }
if (opts.inTargetDensity == 0 && res != null) {
            opts.inTargetDensity = res.getDisplayMetrics().densityDpi;
        }
return decodeStream(is, pad, opts);
    }

它主要是对Options进行处理了，在得到 opts.inDensity 属性的前提下，如果我们没有对该属性设定值，那么将opts.inDensity = DisplayMetrics.DENSITY_DEFAULT;赋定这个默认的Density值，这个默认值为160，为标准的dpi比例，即在Density=160的设备上1dp=1px，这个方法中还有这么一行

opts.inTargetDensity = res.getDisplayMetrics().densityDpi;

对 opts.inTargetDensity 进行了赋值，该值为当前设备的densityDpi值，所以说在decodeResourceStream方法中主要做了两件事：

1、对opts.inDensity赋值，没有则赋默认值1602、对opts.inTargetDensity赋值，没有则赋当前设备的densityDpi值

之后重点来了，之后参数将传入decodeStream方法，该方法中在调用native方法进行解析Bitmap后会调用这个方法setDensityFromOptions(bm, opts); ：

private static void setDensityFromOptions(Bitmap outputBitmap, Options opts) {
if (outputBitmap == null || opts == null) return;
final int density = opts.inDensity;
if (density != 0) {
            outputBitmap.setDensity(density);
final int targetDensity = opts.inTargetDensity;
if (targetDensity == 0 || density == targetDensity || density == opts.inScreenDensity) {
return;
            }
byte[] np = outputBitmap.getNinePatchChunk();
final boolean isNinePatch = np != null && NinePatch.isNinePatchChunk(np);
if (opts.inScaled || isNinePatch) {
                outputBitmap.setDensity(targetDensity);
            }
        } else if (opts.inBitmap != null) {
// bitmap was reused, ensure density is reset
            outputBitmap.setDensity(Bitmap.getDefaultDensity());
        }
    }

该方法主要就是把刚刚赋值过的两个属性inDensity和inTargetDensity给Bitmap进行赋值，不过并不是直接赋给Bitmap就完了，中间有个判断，当inDensity的值与inTargetDensity或与设备的屏幕Density不相等时，则将应用inTargetDensity的值，如果相等则应用inDensity的值。

所以总结来说， setDensityFromOptions 方法就是把 inTargetDensity 的值赋给Bitmap，不过前提是opts.inScaled = true；

进过上面的分析，可以得出这样一个结论：

在不配置Options的情况下：

1、decodeFile、decodeStream在解析时不会对Bitmap进行一系列的屏幕适配，解析出来的将是原始大小的图

2、decodeResource在解析时会对Bitmap根据当前设备屏幕像素密度densityDpi的值进行缩放适配操作，使得解析出来的Bitmap与当前设备的分辨率匹配，达到一个最佳的显示效果，并且Bitmap的大小将比原始的大

1.1、关于Density、分辨率、-hdpi等res目录之间的关系

DensityDpi	分辨率	res	Density
160dpi	320×533	mdpi	1
240dpi	480×800	hdpi	1.5
320dpi	720×1280	xhdpi	2
480dpi	1080×1920	xxhdpi	3
560dpi	1440×2560	xxxhdpi	3.5

dp与px的换算公式为：

px = dp * Density

1.2、DisplayMetrics::densityDpi与density的区别

getResources().getDisplayMetrics().densityDpi——表示屏幕的像素密度

getResources().getDisplayMetrics().density——1dp等于多少个像素(px)

举个栗子：在屏幕密度为160的设备下，1dp=1px。在屏幕密度为320的设备下，1dp=2px。所以这就为什么在安卓中布局建议使用dp为单位，因为可以根据当前设备的屏幕密度动态的调整进行适配

2、Bitmap的优化策略

2.1、BitmapFactory.Options的属性解析

BitmapFactory.Options中有以下属性：

inBitmap——在解析Bitmap时重用该Bitmap，不过必须等大的Bitmap而且inMutable须为true
inMutable——配置Bitmap是否可以更改，比如：在Bitmap上隔几个像素加一条线段
inJustDecodeBounds——为true仅返回Bitmap的宽高等属性
inSampleSize——须>=1,表示Bitmap的压缩比例，如：inSampleSize=4，将返回一个是原始图的1/16大小的Bitmap
inPreferredConfig——Bitmap.Config.ARGB_8888等
inDither——是否抖动，默认为false
inPremultiplied——默认为true，一般不改变它的值
inDensity——Bitmap的像素密度
inTargetDensity——Bitmap最终的像素密度
inScreenDensity——当前屏幕的像素密度
inScaled——是否支持缩放，默认为true，当设置了这个，Bitmap将会以inTargetDensity的值进行缩放
inPurgeable——当存储Pixel的内存空间在系统内存不足时是否可以被回收
inInputShareable——inPurgeable为true情况下才生效，是否可以共享一个InputStream
inPreferQualityOverSpeed——为true则优先保证Bitmap质量其次是解码速度
outWidth——返回的Bitmap的宽
outHeight——返回的Bitmap的高
inTempStorage——解码时的临时空间，建议16*1024

2.2、优化策略

1、BitmapConfig的配置

2、使用decodeFile、decodeResource、decodeStream进行解析Bitmap时，配置inDensity和inTargetDensity，两者应该相等,值可以等于屏幕像素密度*0.75f

3、使用inJustDecodeBounds预判断Bitmap的大小及使用inSampleSize进行压缩

4、对Density>240的设备进行Bitmap的适配（缩放Density）

5、2.3版本inNativeAlloc的使用

6、4.4以下版本inPurgeable、inInputShareable的使用

7、Bitmap的回收

针对上面方案，把Bitmap解码的代码封装成了一个工具类，如下：

1. package com.myframe.utils;
3. import android.content.Context;
4. import android.graphics.Bitmap;
5. import android.graphics.BitmapFactory;
6. import android.os.Build;
7. import android.util.TypedValue;
9. import java.io.FileInputStream;
10. import java.io.FileNotFoundException;
11. import java.io.IOException;
12. import java.io.InputStream;
13. import java.lang.reflect.Field;
15. /**
16. * Bitmap解码转换工具
17. */
18. public class BitmapDecodeUtil {
19. private static final int DEFAULT_DENSITY = 240;
20. private static final float SCALE_FACTOR = 0.75f;
21. private static final Bitmap.Config DEFAULT_BITMAP_CONFIG = Bitmap.Config.RGB_565;
23. /**
24. * 获取优化的BitmapFactory.Options
25. * @param context
26. * @return
27. */
28. private static BitmapFactory.Options getBitmapOptions(Context context) {
29. BitmapFactory.Options options = new BitmapFactory.Options();
30. options.inScaled = true;
31. options.inPreferredConfig = DEFAULT_BITMAP_CONFIG;
32. options.inPurgeable = true;
33. options.inInputShareable = true;
34. options.inJustDecodeBounds = false;
35. if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.GINGERBREAD_MR1) {
36. Field field = null;
37. try {
38. field = BitmapFactory.Options.class.getDeclaredField("inNativeAlloc");
39. field.setAccessible(true);
40. field.setBoolean(options, true);
41. } catch (NoSuchFieldException e) {
42. e.printStackTrace();
43. } catch (IllegalAccessException e) {
44. e.printStackTrace();
45. }
46. }
47. int displayDensityDpi = context.getResources().getDisplayMetrics().densityDpi;
48. float displayDensity = context.getResources().getDisplayMetrics().density;
49. if (displayDensityDpi > DEFAULT_DENSITY && displayDensity > 1.5f) {
50. int density = (int) (displayDensityDpi * SCALE_FACTOR);
51. options.inDensity = density;
52. options.inTargetDensity = density;
53. }
54. return options;
55. }
57. /**
58. * 通过资源ID解码Bitmap
59. * @param context
60. * @param resId
61. * @return
62. */
63. public static Bitmap decodeBitmap(Context context, int resId) {
64. checkParam(context);
65. return BitmapFactory.decodeResource(context.getResources(), resId, getBitmapOptions(context));
66. }
68. /**
69. * 通过资源路径解码Bitmap
70. * @param context
71. * @param pathName
72. * @return
73. */
74. public static Bitmap decodeBitmap(Context context, String pathName) {
75. checkParam(context);
76. return BitmapFactory.decodeFile(pathName, getBitmapOptions(context));
77. }
79. /**
80. * 通过资源输入流解码Bitmap
81. * @param context
82. * @param is
83. * @return
84. */
85. public static Bitmap decodeBitmap(Context context, InputStream is) {
86. checkParam(context);
87. checkParam(is);
88. return BitmapFactory.decodeStream(is, null, getBitmapOptions(context));
89. }
91. /**
92. * 通过资源ID获取压缩Bitmap
93. * @param context
94. * @param resId
95. * @param maxWidth
96. * @param maxHeight
97. * @return
98. */
99. public static Bitmap compressBitmap(Context context, int resId, int maxWidth, int maxHeight) {
100. checkParam(context);
101. final TypedValue value = new TypedValue();
102. InputStream is = null;
103. try {
104. is = context.getResources().openRawResource(resId, value);
105. return compressBitmap(context, is, maxWidth, maxHeight);
106. } catch (Exception e) {
107. e.printStackTrace();
108. } finally {
109. if (is != null) {
110. try {
111. is.close();
112. } catch (IOException e) {
113. e.printStackTrace();
114. }
115. }
116. }
117. return null;
118. }
120. /**
121. * 通过资源路径获取压缩Bitmap
122. * @param context
123. * @param pathName
124. * @param maxWidth
125. * @param maxHeight
126. * @return
127. */
128. public static Bitmap compressBitmap(Context context, String pathName, int maxWidth, int maxHeight) {
129. checkParam(context);
130. InputStream is = null;
131. try {
132. is = new FileInputStream(pathName);
133. return compressBitmap(context, is, maxWidth, maxHeight);
134. } catch (FileNotFoundException e) {
135. e.printStackTrace();
136. } finally {
137. if (is != null) {
138. try {
139. is.close();
140. } catch (IOException e) {
141. e.printStackTrace();
142. }
143. }
144. }
145. return null;
146. }
148. /**
149. * 通过资源流获取压缩Bitmap
150. * @param context
151. * @param is
152. * @param maxWidth
153. * @param maxHeight
154. * @return
155. */
156. public static Bitmap compressBitmap(Context context, InputStream is, int maxWidth, int maxHeight) {
157. checkParam(context);
158. checkParam(is);
159. BitmapFactory.Options opt = new BitmapFactory.Options();
160. opt.inJustDecodeBounds = true;
161. BitmapFactory.decodeStream(is, null, opt);
162. int height = opt.outHeight;
163. int width = opt.outWidth;
164. int sampleSize = computeSampleSize(width, height, maxWidth, maxHeight);
165. BitmapFactory.Options options = getBitmapOptions(context);
166. options.inSampleSize = sampleSize;
167. return BitmapFactory.decodeStream(is, null, options);
168. }
170. /**
171. * 计算SampleSize
172. * @param width
173. * @param height
174. * @param maxWidth
175. * @param maxHeight
176. * @return
177. */
178. private static int computeSampleSize(int width, int height, int maxWidth, int maxHeight) {
179. int inSampleSize = 1;
180. if (height > maxHeight || width > maxWidth) {
181. final int heightRate = Math.round((float) height / (float) maxHeight);
182. final int widthRate = Math.round((float) width / (float) maxWidth);
183. inSampleSize = heightRate < widthRate ? heightRate : widthRate;
184. }
185. if (inSampleSize % 2 != 0) {
186. inSampleSize -= 1;
187. }
188. return inSampleSize <= 1 ? 1 : inSampleSize;
189. }
191. /**
192. * 检查对象是否为空
193. * @param param
194. */
195. private static void checkParam(Object param) {
196. if (param == null)
197. throw new NullPointerException();
198. }
199. }

主要有两类方法：

一、decodeBitmap:对Bitmap不压缩，但是会根据屏幕的密度合适的进行缩放压缩

二、compressBimtap:对Bitmap进行超过最大宽高的压缩，同时也会根据屏幕的密度合适的进行缩放压缩。

3、Bitmap优化前后性能对比

针对上面方案，做一下性能对比,图片大小为3.26M,分辨率为2048*2048有两台设备：

3.1、density为320的设备

3.2、density为560的设备

可以看到，都是加载同一图片，在高屏幕像素密度的设备下所需要的内存需要很大、载入内存中的Bitmap的宽高也因设备的屏幕像素密度也改变，正如上面分析的一样，使用decodeResource会自动适配当前设备的分辨率达到一个最佳效果，而只有这个方法会自动适配其它方法将不会，依次思路，我们在封装的工具类中在每一个方法都加入了依屏幕像素密度来自动适配，而在实际中并不需要那么高清的图片，所以我们可以根据设备的density来进行缩放，比如：在400>=density>240的情况下x0.8,在density>400的情况下x0.7，这样Bitmap所占用的内存将减少非常多，可以对面上面两个图片中bitmap和decodeBitmap两个值的大小，decodeBitmap只是对density进行了一定的缩放，而占用内存却减少非常多，而且显示效果也和原先的并无区别。之后对比我们进行了inSampleSize压缩的图片，进行压缩后的效果也看不出太大区别，而占用内存也减少了很多。

4、Bitmap的回收

4.1、Android 2.3.3(API 10)及以下的系统

在2.3以下的系统中，Bitmap的像素数据是存储在native中，Bitmap对象是存储在java堆中的，所以在回收Bitmap时，需要回收两个部分的空间：native和java堆。即先调用recycle()释放native中Bitmap的像素数据，再对Bitmap对象置null，保证GC对Bitmap对象的回收

4.2、Android 3.0(API 11)及以上的系统

在3.0以上的系统中，Bitmap的像素数据和对象本身都是存储在java堆中的，无需主动调用recycle()，只需将对象置null，由GC自动管理