小编有话说
在图片加载库烂大街的今天，选择一个适合自己使用的图片加载库已经成为了每一个Android开发者的必经之路。现在市面上知名的图片加载库有UIL,Picasso,Volley ImageLoader,以及我们今天的主角。它们各有千秋，不能评定谁一定比谁好，只能说哪一个更适合你。我的理解下面我来谈一下个人对这些图片加载库的理解，如有错误，还望指教。Universal Image Loader：一个强大的图片加载库，包含各种各样的配置，最老牌，使用也最广泛。Picasso: Square出品，必属精品。和OkHttp搭配起来更配呦！Volley ImageLoader：Google官方出品，可惜不能加载本地图片~Fresco：Facebook出的，天生骄傲！不是一般的强大。Glide：Google推荐的图片加载库，专注于流畅的滚动。更多详情请看stackoverflow上。初试Glide下面进入今天的主题，相信之前很多同学都看到过介绍Glide的文章,中文版在。文中从各个方面介绍和比较了Glide与Picasso，总体来说二者极为相似，有着近乎相同的API的使用风格。但Glide在缓存策略和加载GIF方面略胜一筹。最后作者也极力推荐了这个库。而且据说在Google新出的Photos应用中，到处可见Glide的踪迹。看到这里，你是不是已经迫不及待的想试一试这个库呢？就在你下定决心尝试一记的时候，你又听说Yelp app(据说是美国的大众点评)也在使用这个吊炸天的库。你的心中激动万分，发四一定要使用这个库。说干就干，打开Android Studio，在builde.gradle里面添加上compile 'com.github.bumptech.glide:glide:3.6.1'然后全局搜索图片加载的地方，全部换成了下面的代码：Glide.with(mContext)
.load(url)
.placeholder(R.drawable.loading_spinner)
.crossFade()
.into(myImageView);在经过漫长的编译过程之后，再次打开APP，看到有着渐现效果的图片呈现在你的面前，你不禁叫道：“wocao,真TM帅！为什么我以前没有发现呢？”。不过在你使用了几天之后你会发现一些问题：为什么 有的图片第一次加载的时候只显示占位图，第二次才显示正常的图片呢？为什么 我总会得到类似You cannot start a load for a destroyed activity这样的异常呢？为什么 我不能给加载的图片setTag()呢？为什么？为什么？这么NB的库竟然会有这么多的问题。没错，这就是我今天要讲的重点。怎么避免上面的问题发生。一些解决方案1.如果你刚好使用了这个圆形或者其他的一些自定义的圆形Imageview，而你又刚好设置了占位的话，那么，你就会遇到第一个问题。如何解决呢？方案一: 不设置占位；方案二：使用Glide的Transformation API自定义圆形Bitmap的转换。这里是一个已有的；方案三：使用下面的代码加载图片：Glide.with(mContext)
.load(url)
.placeholder(R.drawable.loading_spinner)
.into(new SimpleTarget&Bitmap&(width, height) {
public void onResourceReady(Bitmap bitmap, GlideAnimation anim) {
// setImageBitmap(bitmap) on CircleImageView
};2.至于第二个问题，请记住一句话：不要再非主线程里面使用Glide加载图片，如果真的使用了，请把context参数换成getApplicationContext。更多的细节请参考。3.为什么不能设置Tag，是因为你使用的姿势不对哦。如何为ImageView设置Tag呢？且听我细细道来。方案一：使用setTag(int,object)方法设置tag,具体用法如下：Java代码是酱紫的：Glide.with(context).load(urls.get(i).getUrl()).fitCenter().into(imageViewHolder.image);
imageViewHolder.image.setTag(R.id.image_tag, i);
imageViewHolder.image.setOnClickListener(new View.OnClickListener() {
int position = (int) v.getTag(R.id.image_tag);
Toast.makeText(context, urls.get(position).getWho(), Toast.LENGTH_SHORT).show();
});同时在values文件夹下新建ids.xml，添加&item name=&image_tag& type=&id&/&大功告成!方案二：从Glide的3.6.0之后，新添加了全局设置的方法。具体方法如下：先实现GlideMoudle接口，全局设置ViewTaget的tagId:public class MyGlideMoudle implements GlideModule{
public void applyOptions(Context context, GlideBuilder builder) {
ViewTarget.setTagId(R.id.glide_tag_id);
public void registerComponents(Context context, Glide glide) {
}}同样，也需要在ids.xml下添加id&item name=&glide_tag_id& type=&id&/&最后在AndroidManifest.xml文件里面添加&meta-data
android:name=&com.yourpackagename.MyGlideMoudle&
android:value=&GlideModule& /&又可以愉快的玩耍了，嘻嘻`(∩_∩)′。方案三：写一个继承自ImageViewTaget的类，复写它的get/setRequest方法。Glide.with(context).load(urls.get(i).getUrl()).fitCenter().into(new ImageViewTarget&GlideDrawable&(imageViewHolder.image) {
protected void setResource(GlideDrawable resource) {
imageViewHolder.image.setImageDrawable(resource);
public void setRequest(Request request) {
imageViewHolder.image.setTag(i);
imageViewHolder.image.setTag(R.id.glide_tag_id,request);
public Request getRequest() {
return (Request) imageViewHolder.image.getTag(R.id.glide_tag_id);
imageViewHolder.image.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
int position = (int) v.getTag();
Toast.makeText(context, urls.get(position).getWho(), Toast.LENGTH_SHORT).show();
});一些使用技巧1.Glide.with(context).resumeRequests()和 Glide.with(context).pauseRequests()当列表在滑动的时候，调用pauseRequests()取消请求，滑动停止时，调用resumeRequests()恢复请求。这样是不是会好些呢？2.Glide.clear()当你想清除掉所有的图片加载请求时，这个方法可以帮助到你。3.ListPreloader如果你想让列表预加载的话，不妨试一下ListPreloader这个类。一些基于Glide的优秀库1.一个基于Glide的transformation库，拥有裁剪，着色，模糊，滤镜等多种转换效果，赞的不行不行的~~2.一个可以在Glide加载时很方便使用Palette的库。以下文章点击文字直接进入：Android开发者(apkbus)
　文章为作者独立观点，不代表大不六文章网立场
apkbus分享互联网世界所有有价值的消息热门文章2.【自组 徒步】观晨雾，游古村，进银楼精华二日游最新文章apkbus分享互联网世界所有有价值的消息&&&&违法和不良信息举报电话：183-
举报邮箱：Copyright(C)2017 大不六文章网Glide使用中的踩坑和填坑 - 推酷
Glide使用中的踩坑和填坑
在使用Glide的过程中，遇到不少问题，如下：
加载本地国际化图片资源时出现错乱。
加载Gif图时显示奇慢。
Glide加载图片的ImageView不能设置tag。
使用CircleImageView时图片显示不正常。
本文，对遇到的这些问题进行了分析和总结。
是Google的一个图片加载的优秀开源库。其几大特点：
通过with()参数传入Activity/Fragment，实现图片加载和Activity/Fragment的生命周期联动，即onPause即停止加载，onResume继续下载。
专门针对列表加载进行了优化，不用担心复用convertView引起图片错位问题的出现。
支持gif图，支持gif图，不用再额外添加gif的支持库。
图片质量。图片质量参数默认采用2bytes/pixel的Bitmap.Config.RGB_565，如果对图片质量要求高，可通过自定义GlideModule来实现4bytes/pixel高质量的ARGB_8888。
智能的内存开销优化。Glide每次加载都会自动计算出ImageView的大小和所需要的显示尺寸，而不是将全尺寸的图片加载至内存，优化内存占用。
智能的磁盘缓存，加载显示快。Picasso每次加载都是全尺寸的图片，所有在列表快速滑动时，加载速度会较慢；但是Glide可以设置磁盘缓存策略DiskCacheStrategy.ALL，即缓存全尺寸又缓存其他尺寸，使得列表中快速回滚时图片可以迅速加载显示。
可以直接加载本地资源图片，比直接设置src更省内存。
链式调用，简单到没有学习成本。
库体积小啊。
为啥不用其他的图片加载开源库呢？
Fresco. 很牛逼，加载据说是最快的，但是体积太大。
Picasso. 内存占用大，加载较慢。
UImageLoader. 配置参数多多。
但是…..他们都不支持Gif啊，还是选我大Glide吧，而且Glide在绝大多数应用场景中已经够用和优秀。
下面就说说在项目实际使用中遇到的一些坑，和对应的解决方案，正文开始。
踩坑与填坑
Glide加载本地国际化图片资源时出现错乱
为了批量加载大图片避免oom，采用Glide加载本地图片资源，但是在切换应用语言时，对应的国际化的图片资源却没自动切换。纳尼？莫非Glide不支持国际化资源加载，不可能啊，在不同语言下刚安装第一进入时加载都是正确的呀！哪个地方出问题了呢？
经过分析测试，把问题定位在磁盘缓存上。Glide在不设置DiskCacheStrategy时默认采用DiskCacheStrategy.RESULT的缓存策略，即存储此次加载的结果，那么，在切换语言时，再次加载图片时，默认是从缓存中读取的，而不是新的资源路径，那么就会造成这次加载的和上次加载的一样，结果就是，切换了语言环境，但是图片资源无变化。
只需修改其磁盘缓存策略即可，不做磁盘缓存，即设置磁盘缓存策略为NONE，代码实现为：
Glide.with(context).*.*.diskCacheStrategy(DiskCacheStrategy.NONE).into(imageView);
建议：使用Glide加载本地图片时最好将磁盘缓存策略设置为NONE，首先，既然是本地资源，根本无需再做本地缓存了，其次避免出现类似国际化资源出现的问题。
Glide加载Gif图片时显示奇慢
在利用Glide加载Gif图片时，采用和加载.png/.jpg一样的调用方式时，发现Gif图的加载速度超级慢啊，而应用中Gif图有时会有连续的好几张，这时就一直loading，真烦人。
在搜索后，准备到Glide下提个issue，发现已经有人提过，而且作者也给出了
，加载Gif时除了调用asGif()方法外，还需特别设置缓存策略(又是缓存策略的问题，可见这块是个烦人的点啊)，需要将缓存策略设置为SOURCE或者NONE，即设置为缓存原图资源或者不做缓存。猜想是，在做ALL或者RESULT的缓存策略时，需要转换处理Gif图，造成较耗资源，显示缓慢。
解决方案：
三点：asGIf(), DiskCacheStrategy.SOURCE/NONE, dontAnimate(), dontAnimate()为个人建议，实测中发现去掉动画会显示更快。
在实际项目中可以这样写：
if(picUrl.endsWith(&.gif&)){
Glide.with(resultFragment)
.load(picUrl)
.override(width,height)
.placeholder(placeholderImg)
.error(errorImg)
.dontAnimate()
.centerCrop()
.diskCacheStrategy(DiskCacheStrategy.SOURCE)// DiskCacheStrategy.NONE
.into(ivPic);
Glide.with(resultFragment)
.load(picUrl)
.override(width,height)
.placeholder(placeholderImg)
.error(errorImg)
.crossFade()
.centerCrop()
.into(ivPic);
Glide加载的ImageView设置tag就报错
利用Glide加载图片的ImageView，在给其设置tag时会出现报错：Java.lang.IllegalArgumentException: You must not call setTag() on a view Glide is targeting。这是因为Glide为了防止在列表中出现的错乱情况，默认给Glide加载的对象(ImageView)设置了tag，就像我们早期使用图片加载时自己手动做的tag处理防止图片加载错位。
解决方案：
以下三种方案，参考自博文
最简单方便，使用setTag(int,object)方法设置tag。
(1) 先实现GlideMoudle接口，全局设置ViewTaget的tagId
public class MyGlideMoudle implements GlideModule{
public void applyOptions(Context context, GlideBuilder builder) {
ViewTarget.setTagId(R.id.glide_tag_id);
public void registerComponents(Context context, Glide glide) {
(2) 在ids.xml下添加id
&item name=&glide_tag_id& type=&id&/&
(3) 在AndroidManifest.xml文件里面添加
&meta-data
android:name=&com.yourpackagename.MyGlideMoudle&
android:value=&GlideModule& /&
写一个继承自ImageViewTaget的类，复写它的get/setRequest方法。具体实现参考
,再次不再贴出。
使用CircleImageView加载图片时显示不正常
在使用CircleImageView实现圆形头像时，如果Glide设置了placeHolder，加载时会出现加载不出图片的情况。
CircleImageView引起的与占位图和显示动画的冲突问题。
解决方案：
方案一： 不设置placeholder占位图。
方案二： 使用Glide的Transformation自己设置圆形图片，具体参考这个
方案三： 去掉Glide加载的默认动画，即调用dontAnimate()方法。
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致Android加载上百张图片做动画出现OOM(内存溢出)解决方案
帧动画一开始我的想法是直接用帧动画来做，可是我太天真了，当帧数放到 50 几张的时候，已经在有些机器上奔溃了！所以这个方案否决！GIF动图虽然可以显示，但是已经卡的我，已经不想看了，直接放弃视频在这里，我突然想到我可以直接把他做成一个小视频啊，而且可以极限压缩视频。最终，视频大小被压缩到 500K 左右。此时已经基本可以满足需求了，但是我们有好多类似的动画，要求在每个动画切换的时候要有衔接感，不能有突兀的感觉，所有在这里视频就不能很好的完成任务了，所有再次放弃，已经泪牛满面了！！！！SurfaceView + BitmapRegionDecoder +缓存首先回答一下：为什么会想到这个解决方案？
首先在做帧动画的时候，大约每帧之间的时间差值是 40ms 可以说速度非常快了，在如此快速的图片切换上，自然而然的想到来了使用SurfaceView。
现在再来说说为什么想到要使用这个类 BitmapRegionDecoder .这个也是从我司游戏开发人员那儿得到的经验？他们在做游戏的时候，游戏中的切图都是放在一张大图上的，然后在根据对应的 xml,json 文件，获取相应的图片，接着再来切图。对此，我想能不能把所有的动图都放到同一张的图片上呢，之后在根据对应的描述文件，裁剪出我想要的图片呢！所以就用到了 BitmapRegionDecoder. 它的作用是：于显示图片的某一块矩形区域！之后，我在找设计人员商量一一下，把图片在尽量的压缩。之后从美工那儿获取的信息是这样的：
json格式的描述文件：{"frames": [{
"filename": "kidbot-正常闭眼0000",
"frame": {"x":0,"y":0,"w":360,"h":300},
"rotated": false,
"trimmed": false,
"spriteSourceSize": {"x":0,"y":0,"w":360,"h":300},
"sourceSize": {"w":360,"h":300}}.....}png图片：
接下来就好做了，解析 json 格式的文件，裁剪图片。
最后说一下为什么使用缓存，其实很简单，因为切换的频率实在太高了，没有必要每次都从图片中裁剪，这里就把裁剪出来的 bitmap 缓存起来在用。从而介绍内存开销！最后给出代码：
public class AnimView extends SurfaceView implements SurfaceHolder.Callback {
private BitmapRegionDecoder bitmapRegionD
private SurfaceHolder mH
private boolean isrunning =
private AnimT
private Paint mP
private int WIDTH = 0;
private int HEIGHT = 0;
private int state = -1;
private boolean isstart =
private boolean isblinkfirst =
private int rate = 40;
private int index = 0;
private Handler handler = new Handler() {
public void handleMessage(android.os.Message msg) {
isblinkfirst =
private SparseArray&WeakReference&Bitmap&& weakB
private SparseArray&WeakReference&Bitmap&& cweakB
private BitmapFactory.O
public AnimView(Context context) {
super(context);
public AnimView(Context context, AttributeSet attrs) {
super(context, attrs);
public AnimView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
@SuppressLint("NewApi")
private void init() {
weakBitmaps = new SparseArray&WeakReference&Bitmap&&();
cweakBitmaps = new SparseArray&WeakReference&Bitmap&&();
mHolder = getHolder();
mHolder.addCallback(this);
mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
setState(FaceBean.BLINK);
mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
matrix = new Matrix();
float[] values = { -1f, 0.0f, 0.0f, 0.0f, 1f, 0.0f, 0.0f, 0.0f, 1.0f };
matrix.setValues(values);
WindowManager manger = (WindowManager) getContext().getSystemService(
Context.WINDOW_SERVICE);
DisplayMetrics displayMetrics = new DisplayMetrics();
manger.getDefaultDisplay().getMetrics(displayMetrics);
WIDTH = displayMetrics.widthPixels / 2;
HEIGHT = displayMetrics.heightPixels / 2;
rand = new Random();
options = new Options();
options.inPreferredConfig = Bitmap.Config.RGB_565;
public void surfaceCreated(SurfaceHolder holder) {
handler.sendEmptyMessageDelayed(0, 1000 * (4 + rand.nextInt(4)));
thread = new AnimThread();
thread.start();
public void surfaceChanged(SurfaceHolder holder, int format, int width,
int height) {
public void surfaceDestroyed(SurfaceHolder holder) {
if (thread != null) {
thread.stopThread();
public class AnimThread extends Thread {
public void run() {
super.run();
SurfaceHolder holder = mH
while (isrunning) {
Canvas canvas = holder.lockCanvas();
if (canvas == null)
synchronized (AnimThread.class) {
AnimBean.F
switch (state) {
case FaceBean.BLINK:
frames = KidbotRobotApplication.animBlink.getFrames()
.get(index);
if (frames.getFrame().getW() &= 0) {
Rect rect = new Rect(frames.getFrame().getX(),
frames.getFrame().getY(), frames.getFrame()
+ frames.getSourceSize().getW(),
frames.getFrame().getY()
+ frames.getSourceSize().getH());
WeakReference&Bitmap& weakBitmap = weakBitmaps
.get(index);
Bitmap map =
if (weakBitmap == null) {
map = bitmapRegionDecoder.decodeRegion(rect,
weakBitmaps.put(index,
new WeakReference&Bitmap&(map));
map=weakBitmap.get();
if (map == null) {
map = bitmapRegionDecoder.decodeRegion(
rect, options);
weakBitmaps.put(index,
new WeakReference&Bitmap&(map));
if (map == null) {
holder.unlockCanvasAndPost(canvas);
mPaint.setXfermode(new PorterDuffXfermode(
Mode.CLEAR));
canvas.drawPaint(mPaint);
mPaint.setXfermode(new PorterDuffXfermode(Mode.SRC));
canvas.drawBitmap(map,
(int) (WIDTH - (map.getWidth() * 1) - 150),
(int) (HEIGHT - (map.getHeight() / 2)),
canvas.drawBitmap(map, (int) (WIDTH + 150),
(int) (HEIGHT - (map.getHeight() / 2)),
if (index == 0) {
if (map.isRecycled()) {
map.recycle();
if (!isstart) {
if (index & KidbotRobotApplication.animBlink
.getFrames().size()) {
if (index == KidbotRobotApplication.animBlink
.getFrames().size()) {
if (rand.nextInt(10) &= 2) {
index = 1;
if (index & 0) {
if (index == 0) {
if (!isblinkfirst) {
index = 0;
if (index == KidbotRobotApplication.animBlink
.getFrames().size() - 1) {
isblinkfirst =
index = 0;
handler.sendEmptyMessageDelayed(0,
1000 * (4 + rand.nextInt(4)));
case FaceBean.ANGRY:
frames = KidbotRobotApplication.animAngry.getFrames()
.get(index);
if (frames.getFrame().getW() &= 0) {
Rect rect = new Rect(frames.getFrame().getX(),
frames.getFrame().getY(), frames.getFrame()
.getX() + frames.getFrame().getW(),
frames.getFrame().getH()
+ frames.getFrame().getX());
WeakReference&Bitmap& weakBitmap = weakBitmaps
.get(index);
Bitmap map =
if (weakBitmap == null) {
map = bitmapRegionDecoder.decodeRegion(rect,
weakBitmaps.put(index,
new WeakReference&Bitmap&(map));
map=weakBitmap.get();
if (map == null) {
map = bitmapRegionDecoder.decodeRegion(
rect, options);
weakBitmaps.put(index,
new WeakReference&Bitmap&(map));
if (map == null) {
holder.unlockCanvasAndPost(canvas);
mPaint.setXfermode(new PorterDuffXfermode(
Mode.CLEAR));
canvas.drawPaint(mPaint);
mPaint.setXfermode(new PorterDuffXfermode(Mode.SRC));
Bitmap dstbmp =
weakBitmap=cweakBitmaps.get(index);
if(weakBitmap==null){
dstbmp = Bitmap.createBitmap(map, 0, 0,
map.getWidth(), map.getHeight(),
matrix, true);
cweakBitmaps.put(index,
new WeakReference&Bitmap&(dstbmp));
dstbmp=weakBitmap.get();
if(dstbmp==null){
dstbmp = Bitmap.createBitmap(map, 0, 0,
map.getWidth(), map.getHeight(),
matrix, true);
cweakBitmaps.put(index,
new WeakReference&Bitmap&(dstbmp));
canvas.drawBitmap(
frames.getSpriteSourceSize().getX()
+ (int) (WIDTH
- (map.getWidth() * 1) - 150),
frames.getSpriteSourceSize().getY()
+ (int) (HEIGHT - (map.getHeight() / 2)),
canvas.drawBitmap(dstbmp, frames
.getSpriteSourceSize().getX()
+ (int) (WIDTH + 150), frames
.getSpriteSourceSize().getY()
+ (int) (HEIGHT - (map.getHeight() / 2)),
if (dstbmp.isRecycled()) {
dstbmp.recycle();
if (map.isRecycled()) {
map.recycle();
if (!isstart) {
if (index & KidbotRobotApplication.animAngry
.getFrames().size()) {
if (index == KidbotRobotApplication.animAngry
.getFrames().size()) {
if (index & 0) {
if (index == 0) {
case FaceBean.HAPPY:
frames = KidbotRobotApplication.animHappy.getFrames()
.get(index);
if (frames.getFrame().getW() &= 0) {
Rect rect = new Rect(frames.getFrame().getX(),
frames.getFrame().getY(), frames.getFrame()
+ frames.getSourceSize().getW(),
frames.getFrame().getY()
+ frames.getSourceSize().getH());
WeakReference&Bitmap& weakBitmap = weakBitmaps
.get(index);
Bitmap map =
if (weakBitmap == null) {
map = bitmapRegionDecoder.decodeRegion(rect,
weakBitmaps.put(index,
new WeakReference&Bitmap&(map));
map=weakBitmap.get();
if (map == null) {
map = bitmapRegionDecoder.decodeRegion(
rect, options);
weakBitmaps.put(index,
new WeakReference&Bitmap&(map));
if (map == null) {
holder.unlockCanvasAndPost(canvas);
mPaint.setXfermode(new PorterDuffXfermode(
Mode.CLEAR));
canvas.drawPaint(mPaint);
mPaint.setXfermode(new PorterDuffXfermode(Mode.SRC));
Bitmap dstbmp =
weakBitmap=cweakBitmaps.get(index);
if(weakBitmap==null){
dstbmp = Bitmap.createBitmap(map, 0, 0,
map.getWidth(), map.getHeight(),
matrix, true);
cweakBitmaps.put(index,
new WeakReference&Bitmap&(dstbmp));
dstbmp=weakBitmap.get();
if(dstbmp==null){
dstbmp = Bitmap.createBitmap(map, 0, 0,
map.getWidth(), map.getHeight(),
matrix, true);
cweakBitmaps.put(index,
new WeakReference&Bitmap&(dstbmp));
canvas.drawBitmap(
frames.getSpriteSourceSize().getX()
+ (int) (WIDTH
- (map.getWidth() * 1) - 150),
frames.getSpriteSourceSize().getY()
+ (int) (HEIGHT - (map.getHeight() / 2)),
canvas.drawBitmap(dstbmp, frames
.getSpriteSourceSize().getX()
+ (int) (WIDTH + 150), frames
.getSpriteSourceSize().getY()
+ (int) (HEIGHT - (map.getHeight() / 2)),
// if (dstbmp.isRecycled()) {
// dstbmp.recycle();
// if (map.isRecycled()) {
// map.recycle();
if (!isstart) {
if (index & KidbotRobotApplication.animHappy
.getFrames().size()) {
if (index == KidbotRobotApplication.animHappy
.getFrames().size()) {
if (index & 0) {
if (index == 0) {
case FaceBean.RESOLVE:
case FaceBean.RISUS:
case FaceBean.SEERIGHT:
case FaceBean.SAD:
frames = KidbotRobotApplication.animSad.getFrames()
.get(index);
if (frames.getFrame().getW() &= 0) {
Rect rect = new Rect(frames.getFrame().getX(),
frames.getFrame().getY(), frames.getFrame()
+ frames.getSourceSize().getW(),
frames.getFrame().getY()
+ frames.getSourceSize().getH());
WeakReference&Bitmap& weakBitmap = weakBitmaps
.get(index);
Bitmap map =
if (weakBitmap == null) {
map = bitmapRegionDecoder.decodeRegion(rect,
weakBitmaps.put(index,
new WeakReference&Bitmap&(map));
map=weakBitmap.get();
if (map == null) {
map = bitmapRegionDecoder.decodeRegion(
rect, options);
weakBitmaps.put(index,
new WeakReference&Bitmap&(map));
if (map == null) {
holder.unlockCanvasAndPost(canvas);
mPaint.setXfermode(new PorterDuffXfermode(
Mode.CLEAR));
canvas.drawPaint(mPaint);
mPaint.setXfermode(new PorterDuffXfermode(Mode.SRC));
Bitmap dstbmp =
weakBitmap=cweakBitmaps.get(index);
if(weakBitmap==null){
dstbmp = Bitmap.createBitmap(map, 0, 0,
map.getWidth(), map.getHeight(),
matrix, true);
cweakBitmaps.put(index,
new WeakReference&Bitmap&(dstbmp));
dstbmp=weakBitmap.get();
if(dstbmp==null){
dstbmp = Bitmap.createBitmap(map, 0, 0,
map.getWidth(), map.getHeight(),
matrix, true);
cweakBitmaps.put(index,
new WeakReference&Bitmap&(dstbmp));
canvas.drawBitmap(
frames.getSpriteSourceSize().getX()
+ (int) (WIDTH
- (map.getWidth() * 1) - 150),
frames.getSpriteSourceSize().getY()
+ (int) (HEIGHT - (map.getHeight() / 2)),
canvas.drawBitmap(dstbmp, frames
.getSpriteSourceSize().getX()
+ (int) (WIDTH + 150), frames
.getSpriteSourceSize().getY()
+ (int) (HEIGHT - (map.getHeight() / 2)),
if (dstbmp.isRecycled()) {
dstbmp.recycle();
if (map.isRecycled()) {
map.recycle();
if (!isstart) {
if (index & KidbotRobotApplication.animSad
.getFrames().size()) {
if (index == KidbotRobotApplication.animSad
.getFrames().size()) {
if (index & 0) {
if (index == 0) {
holder.unlockCanvasAndPost(canvas);
Thread.sleep(rate);
} catch (InterruptedException e) {
e.printStackTrace();
public void stopThread() {
isrunning =
} catch (InterruptedException e) {
e.printStackTrace();
public synchronized void setRate(int rate) {
this.rate =
public int getState() {
return this.
public synchronized void setState(int state) {
// if (FaceBean.BLINK == this.state) {
// while ((index != KidbotRobotApplication.animBlink.getFrames()
// .size() - 1)) {
cweakBitmaps.clear();
weakBitmaps.clear();
this.state =
this.index = 0;
switch (state) {
case FaceBean.BLINK:
bitmapRegionDecoder = BitmapRegionDecoder.newInstance(
getContext().getAssets().open("kidbot_blink.png"),
} catch (IOException e) {
e.printStackTrace();
case FaceBean.ANGRY:
bitmapRegionDecoder = BitmapRegionDecoder.newInstance(
getContext().getAssets().open("kidbot_angry.png"),
} catch (IOException e) {
e.printStackTrace();
case FaceBean.HAPPY:
bitmapRegionDecoder = BitmapRegionDecoder.newInstance(
getContext().getAssets().open("kidbot_happy.png"),
} catch (IOException e) {
e.printStackTrace();
case FaceBean.RESOLVE:
bitmapRegionDecoder = BitmapRegionDecoder.newInstance(
getContext().getAssets().open("kidbot_blink.png"),
} catch (IOException e) {
e.printStackTrace();
case FaceBean.RISUS:
bitmapRegionDecoder = BitmapRegionDecoder.newInstance(
getContext().getAssets().open("kidbot_blink.png"),
} catch (IOException e) {
e.printStackTrace();
case FaceBean.SEERIGHT:
case FaceBean.SAD:
bitmapRegionDecoder = BitmapRegionDecoder.newInstance(
getContext().getAssets().open("kidbot_sad.png"), false);
} catch (IOException e) {
e.printStackTrace();
public synchronized void setRunning(boolean isrunning) {
this.isrunning =
public synchronized void addIndex() {
this.index++;
Android高效加载大图、多图解决方案，有效避免程序OOM比如说系统图片库里展示的图片大都是用手机摄像头拍出来的，这些图片的分辨率会比我们手机屏幕的分辨率高得多。大家应该知道，我们编写的应用程序都是有一定内存限制的，程序占用了过高的内存就容易出现OOM(OutOfMemory)异常。我们可以通过下面的代码看出每个应用程序最高可用内存是多少。
int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
Log.d("TAG", "Max memory is " + maxMemory + "KB");
因此在展示高分辨率图片的时候，最好先将图片进行压缩。压缩后的图片大小应该和用来展示它的控件大小相近，在一个很小的ImageView上显示一张超大的图片不会带来任何视觉上的好处，但却会占用我们相当多宝贵的内存，而且在性能上还可能会带来负面影响。下面我们就来看一看，如何对一张大图片进行适当的压缩，让它能够以最佳大小显示的同时，还能防止OOM的出现。BitmapFactory这个类提供了多个解析方法(decodeByteArray, decodeFile, decodeResource等)用于创建Bitmap对象，我们应该根据图片的来源选择合适的方法。比如SD卡中的图片可以使用decodeFile方法，网络上的图片可以使用decodeStream方法，资源文件中的图片可以使用decodeResource方法。这些方法会尝试为已经构建的bitmap分配内存，这时就会很容易导致OOM出现。为此每一种解析方法都提供了一个可选的BitmapFactory.Options参数，将这个参数的inJustDecodeBounds属性设置为true就可以让解析方法禁止为bitmap分配内存，返回值也不再是一个Bitmap对象，而是null。虽然Bitmap是null了，但是BitmapFactory.Options的outWidth、outHeight和outMimeType属性都会被赋值。这个技巧让我们可以在加载图片之前就获取到图片的长宽值和MIME类型，从而根据情况对图片进行压缩。如下代码所示：
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds =
BitmapFactory.decodeResource(getResources(), R.id.myimage, options);
int imageHeight = options.outH
int imageWidth = options.outW
String imageType = options.outMimeT
为了避免OOM异常，最好在解析每张图片的时候都先检查一下图片的大小，除非你非常信任图片的来源，保证这些图片都不会超出你程序的可用内存。现在图片的大小已经知道了，我们就可以决定是把整张图片加载到内存中还是加载一个压缩版的图片到内存中。以下几个因素是我们需要考虑的：预估一下加载整张图片所需占用的内存。为了加载这一张图片你所愿意提供多少内存。用于展示这张图片的控件的实际大小。当前设备的屏幕尺寸和分辨率。比如，你的ImageView只有128*96像素的大小，只是为了显示一张缩略图，这时候把一张像素的图片完全加载到内存中显然是不值得的。那我们怎样才能对图片进行压缩呢？通过设置BitmapFactory.Options中inSampleSize的值就可以实现。比如我们有一张像素的图片，将inSampleSize的值设置为4，就可以把这张图片压缩成512*384像素。原本加载这张图片需要占用13M的内存，压缩后就只需要占用0.75M了(假设图片是ARGB_8888类型，即每个像素点占用4个字节)。下面的方法可以根据传入的宽和高，出合适的inSampleSize值：
public static int calculateInSampleSize(BitmapFactory.Options options,
int reqWidth, int reqHeight) {
// 源图片的高度和宽度
final int height = options.outH
final int width = options.outW
int inSampleSize = 1;
if (height & reqHeight || width & reqWidth) {
// 计算出实际宽高和目标宽高的比率
final int heightRatio = Math.round((float) height / (float) reqHeight);
final int widthRatio = Math.round((float) width / (float) reqWidth);
// 选择宽和高中最小的比率作为inSampleSize的值，这样可以保证最终图片的宽和高
// 一定都会大于等于目标的宽和高。
inSampleSize = heightRatio & widthRatio ? heightRatio : widthR
return inSampleS
使用这个方法，首先你要将BitmapFactory.Options的inJustDecodeBounds属性设置为true，解析一次图片。然后将BitmapFactory.Options连同期望的宽度和高度一起传递到到calculateInSampleSize方法中，就可以得到合适的inSampleSize值了。之后再解析一次图片，使用新获取到的inSampleSize值，并把inJustDecodeBounds设置为false，就可以得到压缩后的图片了。
public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId,
int reqWidth, int reqHeight) {
// 第一次解析将inJustDecodeBounds设置为true，来获取图片大小
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds =
BitmapFactory.decodeResource(res, resId, options);
// 调用上面定义的方法计算inSampleSize值
options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
// 使用获取到的inSampleSize值再次解析图片
options.inJustDecodeBounds =
return BitmapFactory.decodeResource(res, resId, options);
下面的代码非常简单地将任意一张图片压缩成100*100的缩略图，并在ImageView上展示。
mImageView.setImageBitmap(
decodeSampledBitmapFromResource(getResources(), R.id.myimage, 100, 100));
使用图片缓存技术在你应用程序的UI界面加载一张图片是一件很简单的事情，但是当你需要在界面上加载一大堆图片的时候，情况就变得复杂起来。在很多情况下，（比如使用ListView, GridView 或者 ViewPager 这样的组件），屏幕上显示的图片可以通过滑动屏幕等事件不断地增加，最终导致OOM。为了保证内存的使用始终维持在一个合理的范围，通常会把被移除屏幕的图片进行回收处理。此时垃圾回收器也会认为你不再持有这些图片的引用，从而对这些图片进行GC操作。用这种思路来解决问题是非常好的，可是为了能让程序快速运行，在界面上迅速地加载图片，你又必须要考虑到某些图片被回收之后，用户又将它重新滑入屏幕这种情况。这时重新去加载一遍刚刚加载过的图片无疑是性能的瓶颈，你需要想办法去避免这个情况的发生。这个时候，使用内存缓存技术可以很好的解决这个问题，它可以让组件快速地重新加载和处理图片。下面我们就来看一看如何使用内存缓存技术来对图片进行缓存，从而让你的应用程序在加载很多图片的时候可以提高响应速度和流畅性。内存缓存技术对那些大量占用应用程序宝贵内存的图片提供了快速访问的方法。其中最核心的类是LruCache (此类在android-support-v4的包中提供) 。这个类非常适合用来缓存图片，它的主要算法原理是把最近使用的对象用强引用存储在 LinkedHashMap 中，并且把最近最少使用的对象在缓存值达到预设定值之前从内存中移除。在过去，我们经常会使用一种非常流行的内存缓存技术的实现，即软引用或弱引用 (SoftReference or WeakReference)。但是现在已经不再推荐使用这种方式了，因为从 Android 2.3 (API Level 9)开始，垃圾回收器会更倾向于回收持有软引用或弱引用的对象，这让软引用和弱引用变得不再可靠。另外，Android 3.0 (API Level 11)中，图片的数据会存储在本地的内存当中，因而无法用一种可预见的方式将其释放，这就有潜在的风险造成应用程序的内存溢出并崩溃。为了能够选择一个合适的缓存大小给LruCache, 有以下多个因素应该放入考虑范围内，例如：你的设备可以为每个应用程序分配多大的内存？设备屏幕上一次最多能显示多少张图片？有多少图片需要进行预加载，因为有可能很快也会显示在屏幕上？你的设备的屏幕大小和分辨率分别是多少？一个超高分辨率的设备（例如 Galaxy Nexus) 比起一个较低分辨率的设备（例如 Nexus S），在持有相同数量图片的时候，需要更大的缓存空间。图片的尺寸和大小，还有每张图片会占据多少内存空间。图片被访问的频率有多高？会不会有一些图片的访问频率比其它图片要高？如果有的话，你也许应该让一些图片常驻在内存当中，或者使用多个LruCache 对象来区分不同组的图片。你能维持好数量和质量之间的平衡吗？有些时候，存储多个低像素的图片，而在后台去开线程加载高像素的图片会更加的有效。并没有一个指定的缓存大小可以满足所有的应用程序，这是由你决定的。你应该去分析程序内存的使用情况，然后制定出一个合适的解决方案。一个太小的缓存空间，有可能造成图片频繁地被释放和重新加载，这并没有好处。而一个太大的缓存空间，则有可能还是会引起 java.lang.OutOfMemory 的异常。下面是一个使用 LruCache 来缓存图片的例子：
private LruCache&String, Bitmap& mMemoryC
protected void onCreate(Bundle savedInstanceState) {
// 获取到可用内存的最大值，使用内存超出这个值会引起OutOfMemory异常。
// LruCache通过构造函数传入缓存值，以KB为单位。
int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
// 使用最大可用内存值的1/8作为缓存的大小。
int cacheSize = maxMemory / 8;
mMemoryCache = new LruCache&String, Bitmap&(cacheSize) {
protected int sizeOf(String key, Bitmap bitmap) {
// 重写此方法来衡量每张图片的大小，默认返回图片数量。
return bitmap.getByteCount() / 1024;
public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
if (getBitmapFromMemCache(key) == null) {
mMemoryCache.put(key, bitmap);
public Bitmap getBitmapFromMemCache(String key) {
return mMemoryCache.get(key);
在这个例子当中，使用了系统分配给应用程序的八分之一内存来作为缓存大小。在中高配置的手机当中，这大概会有4兆(32/8)的缓存空间。一个全屏幕的 GridView 使用4张 800x480分辨率的图片来填充，则大概会占用1.5兆的空间(800*480*4)。因此，这个缓存大小可以存储2.5页的图片。当向 ImageView 中加载一张图片时,首先会在 LruCache 的缓存中进行检查。如果找到了相应的键值，则会立刻更新ImageView ，否则开启一个后台线程来加载这张图片。
public void loadBitmap(int resId, ImageView imageView) {
final String imageKey = String.valueOf(resId);
final Bitmap bitmap = getBitmapFromMemCache(imageKey);
if (bitmap != null) {
imageView.setImageBitmap(bitmap);
imageView.setImageResource(R.drawable.image_placeholder);
BitmapWorkerTask task = new BitmapWorkerTask(imageView);
task.execute(resId);
BitmapWorkerTask 还要把新加载的图片的键值对放到缓存中。
class BitmapWorkerTask extends AsyncTask&Integer, Void, Bitmap& {
// 在后台加载图片。
protected Bitmap doInBackground(Integer... params) {
final Bitmap bitmap = decodeSampledBitmapFromResource(
getResources(), params[0], 100, 100);
addBitmapToMemoryCache(String.valueOf(params[0]), bitmap);
掌握了以上两种方法，不管是要在程序中加载超大图片，还是要加载大量图片，都不用担心OOM的问题了!不过仅仅是理论地介绍不知道大家能不能完全理解，在后面的中我会演示如何在实际程序中灵活运用上述技巧来避免程序OOM，敬请期待。