PS：小项目总算是做完了...历经20多天...素材，设计，以及实现全由自己完成...心力憔悴啊...该写写博客记录一下学习到的东西了...
学习内容：
1.使用BitmapFactory.Options实现图片资源的加载...防止OOM的产生...
我们在设计和制作app的时候,有时我们需要去动态的加载图片资源数据,图片的大小将决定读取图片资源所耗费物理内存...Android对内存的要求是非常苛刻的...如果图片的资源过大，那么就会出现OOM，也就是所说的内存溢出...这样程序就不得不被终止掉...因此我们需要避免这种情况的发生...这里我们需要使用到BitmapFactory.Options...
BitmapFactory.Options其实是一个辅助类，这个类提供了创建Bitmap类的接口,真正完成图像处理的类其实是Bitmap，但是由于这个类的构造函数是私有的，因此是无法在其他的类外进行实例化对象的，因此BitmapFactory.Options充当了这个辅助类，对外暴露接口，这样，我们就可以真正的调用Bitmap中的方法了...
BitmapFactory.Options通过decodeFile()的方法去获取图片资源的位置.那么获取到了资源位置后，我们就可以对图片进行解码操作，因为我们都知道，想要获取到一个图片，首先要从图片的码流开始，对码流进行解析才会得到相应的图片...那么这个解码的过程就是使用decodeStream()方法进行解码，解码也是可以限制的...BitmapFactory.Options这个类的Options其实就是对解码进行一个限制...
那么再说一下Options，Options有几个属性，第一个inJustDecodeBounds（这是一个布尔值，true和false两个属性），inJustDecodeBounds=true的时候，那么代表对现在的这张图片进行非完全解码，其实说白了就是不给这个图片资源分配任何的内存，只是获取这个图片的基本信息（比如说:长度和宽度）,不分配内存的原因想必大家都知道了，就是防止图片过大的问题，如果图片过大，那么我们获取到图片长度和宽度后，需要对图片进行一个压缩的操作，那么这个压缩就涉及第二个参数，inSampleSize(int 类型，可以是任意值)...这个值的获取取决于我们压缩操作的方式，这个压缩方式是需要我们自己去实现的，最后通过压缩的方式去获取inSampleSize的值，通过这个值指定图片缩放的大小...最后将inJustDecodeBounds=false这样就可以得到缩放后的图片了...如果图片满足正常的范围之内，那么就直接进行显示就可以了...没必要再进行压缩操作...
还是来一段代码，来方便大家的理解...
private Bitmap decodeFile(File f){
try {
//解码图像大小,对图片进行缩放...防止图片过大导致内存溢出...
BitmapFactory.Options o = new BitmapFactory.Options();//实例化一个对象...
o.inJustDecodeBounds = true;//这个就是Options的第一个属性,设置为true的时候，不会完全的对图片进行解码操作,不会为其分配内存，只是获取图片的基本信息...
BitmapFactory.decodeStream(new FileInputStream(f),null,o); //以码流的形式进行解码....
/*
* 下面也就是对图片进行的一个压缩的操作...如果图片过大，最后会根据指定的数值进行缩放...
* 找到正确的刻度值，它应该是2的幂.
* 这里我指定了图片的长度和宽度为70个像素...
*
* */
final int REQUIRED_SIZE=70;
int width_tmp=o.outWidth, height_tmp=o.outHeight;
int scale=1;
while(true){
if(width_tmp/2<REQUIRED_SIZE || height_tmp/2<REQUIRED_SIZE)
break;
width_tmp/=2;
height_tmp/=2;
scale*=2;
}
BitmapFactory.Options o2 = new BitmapFactory.Options(); //这里定义了一个新的对象...获取的还是同一张图片...
o2.inSampleSize=scale; //对这张图片设置一个缩放值...inJustDecodeBounds不需要进行设置...
return BitmapFactory.decodeStream(new FileInputStream(f), null, o2); //这样通过这个方法就可以产生一个小的图片资源了...
} catch (Exception e) {}
return null;
}
这里只是粘贴了缩放过程的一个代码，通过这段代码，我们就可以实现大图片缩放为小型图片，防止OOM的发生...这只是一个小的函数，最后我会给出一个源码提供给大家去下载，方便大家去学习...这里还需要说明一些问题...就是这个inSampleSize值的设置.这个值如果设置为2，那么图片就缩放4倍...如果为3，那么缩放的程度就为9倍...以此类推...
还有这个decodeStream()方法只是一个把数据封装成流的形式对码流进行一个数据传递...真正完成图片绘制的是其内部过程...我们还是来看一下源代码，方便大家的理解...
/*
*这是源码的实现过程,说实话,我也看不懂所有的东西...因为自己也是个小菜鸟...
*不过我们可以分析一下...
*/
public static Bitmap decodeStream(InputStream is, Rect outPadding, Options opts) {
// we don't throw in this case, thus allowing the caller to only check
// the cache, and not force the image to be decoded.
if (is == null) {
return null;
} // we need mark/reset to work properly if (!is.markSupported()) {
is = new BufferedInputStream(is, DECODE_BUFFER_SIZE);
} // so we can call reset() if a given codec gives up after reading up to
// this many bytes. FIXME: need to find out from the codecs what this
// value should be.
is.mark(1024); Bitmap bm;
boolean finish = true;
/*
*我们来看下面这个函数...
*/
if (is instanceof AssetManager.AssetInputStream) {//这块是一个判断的过程，判断的东西就是，我们这个图片资源到底来自于什么地方，如果满足这个if条件，那么这个图片资源属于drawable文件下的资源...
final int asset = ((AssetManager.AssetInputStream) is).getAssetInt();
/*
*这里就是设置缩放的一个过程，其中包含一些参数的设置...
*比如说缩放的参数，以及目标面积的大小设定...
*/
if (opts == null || (opts.inScaled && opts.inBitmap == null)) {
float scale = 1.0f;
int targetDensity = 0;
if (opts != null) {
final int density = opts.inDensity;
targetDensity = opts.inTargetDensity;
if (density != 0 && targetDensity != 0) {
scale = targetDensity / (float) density;
}
}
/*
*下面这个函数的源码，我也看不到了...应该就是一个解码的操作过程...
*/
bm = nativeDecodeAsset(asset, outPadding, opts, true, scale);
if (bm != null && targetDensity != 0) bm.setDensity(targetDensity); finish = false;
} else {
/*
*这块就是直接解码操作，这个else满足的条件是图片资源满足指定的大小，因此我们不需要传递scale参数了...也就是代表不用进行缩放...
*/
bm = nativeDecodeAsset(asset, outPadding, opts);
}
} else { //这里满足的条件想必大家知道，就是图片资源可能来自于其他地方...
// pass some temp storage down to the native code. 1024 is made up,
// but should be large enough to avoid too many small calls back
// into is.read(...) This number is not related to the value passed
// to mark(...) above.
/*
*通过byte流的形式对图片进行获取,这个也很好理解，如果想获取图片资源，那么必须要经过流的形式，对资源数据进行封装...然后获取...
*上面之所以不用流的形式，是因为drawable中的资源有特定的获取方式...
*/
byte [] tempStorage = null;
if (opts != null) tempStorage = opts.inTempStorage;
if (tempStorage == null) tempStorage = new byte[16 * 1024]; /*
*还是同理，设置参数....
*/
if (opts == null || (opts.inScaled && opts.inBitmap == null)) {
float scale = 1.0f;
int targetDensity = 0;
if (opts != null) {
final int density = opts.inDensity;
targetDensity = opts.inTargetDensity;
if (density != 0 && targetDensity != 0) {
scale = targetDensity / (float) density;
}
} bm = nativeDecodeStream(is, tempStorage, outPadding, opts, true, scale);
if (bm != null && targetDensity != 0) bm.setDensity(targetDensity); finish = false;
} else {
bm = nativeDecodeStream(is, tempStorage, outPadding, opts);
}
} if (bm == null && opts != null && opts.inBitmap != null) {
throw new IllegalArgumentException("Problem decoding into existing bitmap");
}
//这个方法，将会被最终调用..也就是下面的方法...
return finish ? finishDecode(bm, outPadding, opts) : bm;
}
/*
*这个方法是当完成解码操作后需要调用的方法...
*/
private static Bitmap finishDecode(Bitmap bm, Rect outPadding, Options opts) {
if (bm == null || opts == null) {
return bm;
} final int density = opts.inDensity;
if (density == 0) {
return bm;
} bm.setDensity(density);
final int targetDensity = opts.inTargetDensity;
if (targetDensity == 0 || density == targetDensity || density == opts.inScreenDensity) {
return bm;
}
byte[] np = bm.getNinePatchChunk();
int[] lb = bm.getLayoutBounds();
final boolean isNinePatch = np != null && NinePatch.isNinePatchChunk(np);
/*
*这个函数重要部分就是下面，我们可以看到，通过对参数的一些设定..最后会调用 Bitmap.createScaledBitmap方法...
*/
if (opts.inScaled || isNinePatch) {
float scale = targetDensity / (float) density;
if (scale != 1.0f) {
final Bitmap oldBitmap = bm;
bm = Bitmap.createScaledBitmap(oldBitmap,
Math.max(1, (int) (bm.getWidth() * scale + 0.5f)),
Math.max(1, (int) (bm.getHeight() * scale + 0.5f)), true);
if (bm != oldBitmap) oldBitmap.recycle(); if (isNinePatch) {
np = nativeScaleNinePatch(np, scale, outPadding);
bm.setNinePatchChunk(np);
}
if (lb != null) {
int[] newLb = new int[lb.length];
for (int i=0; i<lb.length; i++) {
newLb[i] = (int)((lb[i]*scale)+.5f);
}
bm.setLayoutBounds(newLb);
}
} bm.setDensity(targetDensity);
} return bm;
}
我们可以不完全弄懂这个源码到底是怎么回事，但是我们通过源码可以知道其中到底是以怎样的过程进行实现的，这才是看源码的目的...如果还是有更深入研究的读者...那么您可以完全弄懂...这里我们可以看到最后的调用时Bitmap.createScaledBitmap方法，接着Bitmap.createScaledBitmap方法将调用Bitmap createBitmap...这个方法才是最终实现把图片显示在画布上的一个最终函数，这个函数通过使用Canvas最后在画布上将图片描画出来...这是这个函数的源码，我就不进行解释了，其实这个源码比上面那个更简单，容易理解，其实就是根据这些参数把图片展示出来，比如说获取图片的高度和宽度，缩放的大小，图片的编码格式,最后通过调用Paint画笔，结合Canvas,这里我们能够发现，最后画出来的画布是一个矩形，那么画出来的图片必然也是一个矩形..最后把画出来的图片进行返回..最后就显示在画布之上了...
public static Bitmap createBitmap(Bitmap source, int x, int y, int width, int height,
Matrix m, boolean filter) { checkXYSign(x, y);
checkWidthHeight(width, height);
if (x + width > source.getWidth()) {
throw new IllegalArgumentException("x + width must be <= bitmap.width()");
}
if (y + height > source.getHeight()) {
throw new IllegalArgumentException("y + height must be <= bitmap.height()");
} // check if we can just return our argument unchanged
if (!source.isMutable() && x == 0 && y == 0 && width == source.getWidth() &&
height == source.getHeight() && (m == null || m.isIdentity())) {
return source;
} int neww = width;
int newh = height;
Canvas canvas = new Canvas();
Bitmap bitmap;
Paint paint; Rect srcR = new Rect(x, y, x + width, y + height);
RectF dstR = new RectF(0, 0, width, height); Config newConfig = Config.ARGB_8888;
final Config config = source.getConfig();
// GIF files generate null configs, assume ARGB_8888
if (config != null) {
switch (config) {
case RGB_565:
newConfig = Config.RGB_565;
break;
case ALPHA_8:
newConfig = Config.ALPHA_8;
break;
//noinspection deprecation
case ARGB_4444:
case ARGB_8888:
default:
newConfig = Config.ARGB_8888;
break;
}
} if (m == null || m.isIdentity()) {
bitmap = createBitmap(neww, newh, newConfig, source.hasAlpha());
paint = null; // not needed
} else {
final boolean transformed = !m.rectStaysRect(); RectF deviceR = new RectF();
m.mapRect(deviceR, dstR); neww = Math.round(deviceR.width());
newh = Math.round(deviceR.height()); bitmap = createBitmap(neww, newh, transformed ? Config.ARGB_8888 : newConfig,
transformed || source.hasAlpha()); canvas.translate(-deviceR.left, -deviceR.top);
canvas.concat(m); paint = new Paint();
paint.setFilterBitmap(filter);
if (transformed) {
paint.setAntiAlias(true);
}
} // The new bitmap was created from a known bitmap source so assume that
// they use the same density
bitmap.mDensity = source.mDensity; canvas.setBitmap(bitmap);
canvas.drawBitmap(source, srcR, dstR, paint);
canvas.setBitmap(null); return bitmap;
}
这样就实现了通过对图片大小的缩放，避免OOM的发生...最后放上面一个源码....提供大家下载....只不过这个源码是通过从服务器上下载图片，通过解析XML文件，然后对数据进行获取..然后对图片进行缩放，最后以ListView的形式进行显示...图片的缩放只隶属于一个小的模块....
源码位置：http://files.cnblogs.com/files/RGogoing/daimarufeng.zip