3. Android框架和工具之 xUtils（BitmapUtils）

1. BitmapUtils 作用：

• 加载bitmap的时候无需考虑bitmap加载过程中出现的oom和android容器快速滑动时候出现的图片错位等现象；
• 支持加载网络图片和本地图片；
• 内存管理使用lru算法，更好的管理bitmap内存；
• 可配置线程加载线程数量，缓存大小，缓存路径，加载显示动画等...

 

2. BitmapUtils 全面注释：

/**
 * 加载图片工具类
 * @author afu
 *
 */
public class BitmapUtils implements TaskHandler {

    /**
     * 判断任务是否暂停
     */
    private boolean pauseTask = false;
    /**
     * 是否取消所有任务
     */
    private boolean cancelAllTask = false;
    private final Object pauseTaskLock = new Object();

    /**
     * Android上下文
     */
    private Context context;
    private BitmapGlobalConfig globalConfig;
    private BitmapDisplayConfig defaultDisplayConfig;

    /////////////////////////////////////////////// create ///////////////////////////////////////////////////
    /**
     * 
     * @param context 上下文
     */
    public BitmapUtils(Context context) {
        this(context, null);
    }

    /**
     * 
     * @param context 上下文
     * @param diskCachePath 磁盘高速缓存路径
     */
    public BitmapUtils(Context context, String diskCachePath) {
        if (context == null) {
            throw new IllegalArgumentException("context may not be null");
        }

        this.context = context.getApplicationContext();
        globalConfig = BitmapGlobalConfig.getInstance(this.context, diskCachePath);
        defaultDisplayConfig = new BitmapDisplayConfig();
    }

    /**
     * 
     * @param context 上下文
     * @param diskCachePath 磁盘高速缓存路径
     * @param memoryCacheSize 内存缓存空间大小
     */
    public BitmapUtils(Context context, String diskCachePath, int memoryCacheSize) {
        this(context, diskCachePath);
        globalConfig.setMemoryCacheSize(memoryCacheSize);
    }

    /**
     * 
     * @param context 上下文
     * @param diskCachePath 磁盘高速缓存路径
     * @param memoryCacheSize 内存缓存空间大小
     * @param diskCacheSize 磁盘高速缓存空间大小
     */
    public BitmapUtils(Context context, String diskCachePath, int memoryCacheSize, int diskCacheSize) {
        this(context, diskCachePath);
        globalConfig.setMemoryCacheSize(memoryCacheSize);
        globalConfig.setDiskCacheSize(diskCacheSize);
    }

    /**
     * 
     * @param context 上下文
     * @param diskCachePath 磁盘高速缓存路径
     * @param memoryCachePercent 内存缓存百分比
     */
    public BitmapUtils(Context context, String diskCachePath, float memoryCachePercent) {
        this(context, diskCachePath);
        globalConfig.setMemCacheSizePercent(memoryCachePercent);
    }

    /**
     * 
     * @param context 上下文
     * @param diskCachePath  磁盘高速缓存路径
     * @param memoryCachePercent 内存缓存百分比
     * @param diskCacheSize 磁盘缓存空间大小
     */
    public BitmapUtils(Context context, String diskCachePath, float memoryCachePercent, int diskCacheSize) {
        this(context, diskCachePath);
        globalConfig.setMemCacheSizePercent(memoryCachePercent);
        globalConfig.setDiskCacheSize(diskCacheSize);
    }

    //////////////////////////////////////// config  配置////////////////////////////////////////////////////////////////////

    /**
     * 配置默认加载drawable类型资源图片
     * @param drawable
     * @return
     */
    public BitmapUtils configDefaultLoadingImage(Drawable drawable) {
        defaultDisplayConfig.setLoadingDrawable(drawable);
        return this;
    }

    /**
     * 配置默认加载资源id类型资源图片
     * @param resId
     * @return
     */
    public BitmapUtils configDefaultLoadingImage(int resId) {
        defaultDisplayConfig.setLoadingDrawable(context.getResources().getDrawable(resId));
        return this;
    }

    /**
     * 配置默认加载图片
     * @param bitmap bitmap类中的资源图片
     * @return
     */
    public BitmapUtils configDefaultLoadingImage(Bitmap bitmap) {
        defaultDisplayConfig.setLoadingDrawable(new BitmapDrawable(context.getResources(), bitmap));
        return this;
    }

    /**
     * 设置默认加载失败的图片
     * @param drawable drawable类型的资源图片
     * @return
     */
    public BitmapUtils configDefaultLoadFailedImage(Drawable drawable) {
        defaultDisplayConfig.setLoadFailedDrawable(drawable);
        return this;
    }

    /**
     * 配置默认加载失败图片，加载id类型资源图片
     * @param resId
     * @return
     */
    public BitmapUtils configDefaultLoadFailedImage(int resId) {
        defaultDisplayConfig.setLoadFailedDrawable(context.getResources().getDrawable(resId));
        return this;
    }

    /**
     * 配置默认加载失败图片，加载Bitmap类型资源图片
     * @param bitmap
     * @return
     */
    public BitmapUtils configDefaultLoadFailedImage(Bitmap bitmap) {
        defaultDisplayConfig.setLoadFailedDrawable(new BitmapDrawable(context.getResources(), bitmap));
        return this;
    }

    /**
     * 配置默认图片最大宽和高
     * @param maxWidth 最大宽
     * @param maxHeight 最大高
     * @return
     */
    public BitmapUtils configDefaultBitmapMaxSize(int maxWidth, int maxHeight) {
        defaultDisplayConfig.setBitmapMaxSize(new BitmapSize(maxWidth, maxHeight));
        return this;
    }

    /**
     * 配置默认位图最大图片参数
     * @param maxSize 最大图片参数类
     * @return
     */
    public BitmapUtils configDefaultBitmapMaxSize(BitmapSize maxSize) {
        defaultDisplayConfig.setBitmapMaxSize(maxSize);
        return this;
    }

    /**
     * 配置默认图片加载动画
     * @param animation 动画
     * @return
     */
    public BitmapUtils configDefaultImageLoadAnimation(Animation animation) {
        defaultDisplayConfig.setAnimation(animation);
        return this;
    }

    /**
     * 配置默认自动旋转动画
     * @param autoRotation
     * @return
     */
    public BitmapUtils configDefaultAutoRotation(boolean autoRotation) {
        defaultDisplayConfig.setAutoRotation(autoRotation);
        return this;
    }

    /**
     * 配置默认是否显示原始图片
     * @param showOriginal true:显示原始图片，false：将会对图片压缩处理
     * @return
     */
    public BitmapUtils configDefaultShowOriginal(boolean showOriginal) {
        defaultDisplayConfig.setShowOriginal(showOriginal);
        return this;
    }

    /**
     * 配置默认图片配置，传入Bitmap.Config类型
     * @param config
     * @return
     */
    public BitmapUtils configDefaultBitmapConfig(Bitmap.Config config) {
        defaultDisplayConfig.setBitmapConfig(config);
        return this;
    }

    /**
     * 配置默认显示配置
     * @param displayConfig
     * @return
     */
    public BitmapUtils configDefaultDisplayConfig(BitmapDisplayConfig displayConfig) {
        defaultDisplayConfig = displayConfig;
        return this;
    }

    /**
     * 配置下载参数
     * @param downloader
     * @return
     */
    public BitmapUtils configDownloader(Downloader downloader) {
        globalConfig.setDownloader(downloader);
        return this;
    }

    /**
     * 配置默认缓存失效
     * @param defaultExpiry
     * @return
     */
    public BitmapUtils configDefaultCacheExpiry(long defaultExpiry) {
        globalConfig.setDefaultCacheExpiry(defaultExpiry);
        return this;
    }

    /**
     * 配置默认链接时间超时时间
     * @param connectTimeout  毫秒单位
     * @return
     */
    public BitmapUtils configDefaultConnectTimeout(int connectTimeout) {
        globalConfig.setDefaultConnectTimeout(connectTimeout);
        return this;
    }

    /**
     * 配置默认读取超时时间
     * @param readTimeout 毫秒
     * @return
     */
    public BitmapUtils configDefaultReadTimeout(int readTimeout) {
        globalConfig.setDefaultReadTimeout(readTimeout);
        return this;
    }

    /**
     * 配置线程池多少
     * @param threadPoolSize 线程池数
     * 此参数没有设置，默认是设置5个核心线程池
     * @return
     */
    public BitmapUtils configThreadPoolSize(int threadPoolSize) {
        globalConfig.setThreadPoolSize(threadPoolSize);
        return this;
    }

    /**
     * 配置内存缓存是否启用，默认是启用的
     * @param enabled
     * @return
     */
    public BitmapUtils configMemoryCacheEnabled(boolean enabled) {
        globalConfig.setMemoryCacheEnabled(enabled);
        return this;
    }

    /**
     * 配置磁盘缓存功能，默认是启用的
     * @param enabled
     * @return
     */
    public BitmapUtils configDiskCacheEnabled(boolean enabled) {
        globalConfig.setDiskCacheEnabled(enabled);
        return this;
    }

    /**
     * 配置原始磁盘缓存文件名称
     * @param fileNameGenerator
     * @return
     */
    public BitmapUtils configDiskCacheFileNameGenerator(FileNameGenerator fileNameGenerator) {
        globalConfig.setFileNameGenerator(fileNameGenerator);
        return this;
    }

    /**
     * 配置位图缓存监听
     * @param listener
     * @return
     */
    public BitmapUtils configBitmapCacheListener(BitmapCacheListener listener) {
        globalConfig.setBitmapCacheListener(listener);
        return this;
    }

    ////////////////////////// display  显示////////////////////////////////////

    /**
     * 根据图片路径，显示到具体的View上
     * @param container 要把图片显示到的View
     * @param uri 图片路径
     */
    public <T extends View> void display(T container, String uri) {
        display(container, uri, null, null);
    }

    /**
     * 根据图片路径，显示到具体的View上
     * @param container 要把图片显示到的View
     * @param uri 图片路径
     * @param displayConfig
     */
    public <T extends View> void display(T container, String uri, BitmapDisplayConfig displayConfig) {
        display(container, uri, displayConfig, null);
    }

    /**
     * 根据图片路径，显示到具体的View上
     * @param container 要把图片显示到的View
     * @param uri 图片路径
     * @param callBack 加载过程回调各种状态
     */
    public <T extends View> void display(T container, String uri, BitmapLoadCallBack<T> callBack) {
        display(container, uri, null, callBack);
    }

    /**
     * 根据图片路径，显示到具体的View上
     * @param container 要把图片显示到的View
     * @param uri 图片路径
     * @param displayConfig 位图显示配置
     * @param callBack
     */
    public <T extends View> void display(T container, String uri, BitmapDisplayConfig displayConfig, BitmapLoadCallBack<T> callBack) {
        if (container == null) {
            return;
        }

        if (callBack == null) {
            callBack = new DefaultBitmapLoadCallBack<T>();
        }

        if (displayConfig == null || displayConfig == defaultDisplayConfig) {
            displayConfig = defaultDisplayConfig.cloneNew();
        }

        // Optimize Max Size
        BitmapSize size = displayConfig.getBitmapMaxSize();
        displayConfig.setBitmapMaxSize(BitmapCommonUtils.optimizeMaxSizeByView(container, size.getWidth(), size.getHeight()));

        container.clearAnimation();

        if (TextUtils.isEmpty(uri)) {
            callBack.onLoadFailed(container, uri, displayConfig.getLoadFailedDrawable());
            return;
        }

        // start loading
        callBack.onPreLoad(container, uri, displayConfig);

        // find bitmap from mem cache.
        Bitmap bitmap = globalConfig.getBitmapCache().getBitmapFromMemCache(uri, displayConfig);

        if (bitmap != null) {
            callBack.onLoadStarted(container, uri, displayConfig);
            callBack.onLoadCompleted(
                    container,
                    uri,
                    bitmap,
                    displayConfig,
                    BitmapLoadFrom.MEMORY_CACHE);
        } else if (!bitmapLoadTaskExist(container, uri, callBack)) {

            final BitmapLoadTask<T> loadTask = new BitmapLoadTask<T>(container, uri, displayConfig, callBack);

            // get executor
            PriorityExecutor executor = globalConfig.getBitmapLoadExecutor();
            File diskCacheFile = this.getBitmapFileFromDiskCache(uri);
            boolean diskCacheExist = diskCacheFile != null && diskCacheFile.exists();
            if (diskCacheExist && executor.isBusy()) {
                executor = globalConfig.getDiskCacheExecutor();
            }
            // set loading image
            Drawable loadingDrawable = displayConfig.getLoadingDrawable();
            callBack.setDrawable(container, new AsyncDrawable<T>(loadingDrawable, loadTask));

            loadTask.setPriority(displayConfig.getPriority());
            loadTask.executeOnExecutor(executor);
        }
    }

    /////////////////////////////////////////////// cache  缓存相关/////////////////////////////////////////////////////////////////

    /**
     * 清除内存和磁盘缓存
     */
    public void clearCache() {
        globalConfig.clearCache();
    }

    /**
     * 清除内存缓存
     */
    public void clearMemoryCache() {
        globalConfig.clearMemoryCache();
    }

    /**
     * 清除磁盘缓存
     */
    public void clearDiskCache() {
        globalConfig.clearDiskCache();
    }

    /**
     * 根据uri清除内存缓存和磁盘缓存
     * @param uri
     */
    public void clearCache(String uri) {
        globalConfig.clearCache(uri);
    }

    /**
     * 根据uri清除内存缓存
     * @param uri
     */
    public void clearMemoryCache(String uri) {
        globalConfig.clearMemoryCache(uri);
    }

    /**
     * 根据uri清除磁盘缓存
     * @param uri
     */
    public void clearDiskCache(String uri) {
        globalConfig.clearDiskCache(uri);
    }

    /**
     * 刷新缓存
     */
    public void flushCache() {
        globalConfig.flushCache();
    }

    /**
     * 关闭缓存
     */
    public void closeCache() {
        globalConfig.closeCache();
    }

    /**
     * 根据uri从磁盘缓存得到位图文件
     * @param uri
     * @return
     */
    public File getBitmapFileFromDiskCache(String uri) {
        return globalConfig.getBitmapCache().getBitmapFileFromDiskCache(uri);
    }

    /**
     * 根据uri和位图显示配置从磁盘缓存得到位图文件
     * @param uri
     * @param config
     * @return
     */
    public Bitmap getBitmapFromMemCache(String uri, BitmapDisplayConfig config) {
        if (config == null) {
            config = defaultDisplayConfig;
        }
        return globalConfig.getBitmapCache().getBitmapFromMemCache(uri, config);
    }

    ////////////////////////////////////////// tasks  任务//////////////////////////////////////////////////////////////////////

    /**
     * 支持暂停
     */
    @Override
    public boolean supportPause() {
        return true;
    }

    /**
     * 支持重新开始
     */
    @Override
    public boolean supportResume() {
        return true;
    }

    /**
     * 支持取消
     */
    @Override
    public boolean supportCancel() {
        return true;
    }

    /**
     * 暂停
     */
    @Override
    public void pause() {
        pauseTask = true;
        flushCache();
    }

    /**
     * 刷新
     */
    @Override
    public void resume() {
        pauseTask = false;
        synchronized (pauseTaskLock) {
            pauseTaskLock.notifyAll();
        }
    }

    /**
     * 取消
     */
    @Override
    public void cancel() {
        pauseTask = true;
        cancelAllTask = true;
        synchronized (pauseTaskLock) {
            pauseTaskLock.notifyAll();
        }
    }

    /**
     * 是否暂停
     */
    @Override
    public boolean isPaused() {
        return pauseTask;
    }

    /**
     * 是否是取消了
     */
    @Override
    public boolean isCancelled() {
        return cancelAllTask;
    }

    ////////////////////////////////////////////////下面这些方法是否没有提供给开发者使用的///////////////////////////////////////////////////////////////

    @SuppressWarnings("unchecked")
    private static <T extends View> BitmapLoadTask<T> getBitmapTaskFromContainer(T container, BitmapLoadCallBack<T> callBack) {
        if (container != null) {
            final Drawable drawable = callBack.getDrawable(container);
            if (drawable instanceof AsyncDrawable) {
                final AsyncDrawable<T> asyncDrawable = (AsyncDrawable<T>) drawable;
                return asyncDrawable.getBitmapWorkerTask();
            }
        }
        return null;
    }

    private static <T extends View> boolean bitmapLoadTaskExist(T container, String uri, BitmapLoadCallBack<T> callBack) {
        final BitmapLoadTask<T> oldLoadTask = getBitmapTaskFromContainer(container, callBack);

        if (oldLoadTask != null) {
            final String oldUrl = oldLoadTask.uri;
            if (TextUtils.isEmpty(oldUrl) || !oldUrl.equals(uri)) {
                oldLoadTask.cancel(true);
            } else {
                return true;
            }
        }
        return false;
    }

    public class BitmapLoadTask<T extends View> extends PriorityAsyncTask<Object, Object, Bitmap> {
        private final String uri;
        private final WeakReference<T> containerReference;
        private final BitmapLoadCallBack<T> callBack;
        private final BitmapDisplayConfig displayConfig;

        private BitmapLoadFrom from = BitmapLoadFrom.DISK_CACHE;

        public BitmapLoadTask(T container, String uri, BitmapDisplayConfig config, BitmapLoadCallBack<T> callBack) {
            if (container == null || uri == null || config == null || callBack == null) {
                throw new IllegalArgumentException("args may not be null");
            }

            this.containerReference = new WeakReference<T>(container);
            this.callBack = callBack;
            this.uri = uri;
            this.displayConfig = config;
        }

        @Override
        protected Bitmap doInBackground(Object... params) {

            synchronized (pauseTaskLock) {
                while (pauseTask && !this.isCancelled()) {
                    try {
                        pauseTaskLock.wait();
                        if (cancelAllTask) {
                            return null;
                        }
                    } catch (Throwable e) {
                    }
                }
            }

            Bitmap bitmap = null;

            // get cache from disk cache
            if (!this.isCancelled() && this.getTargetContainer() != null) {
                this.publishProgress(PROGRESS_LOAD_STARTED);
                bitmap = globalConfig.getBitmapCache().getBitmapFromDiskCache(uri, displayConfig);
            }

            // download image
            if (bitmap == null && !this.isCancelled() && this.getTargetContainer() != null) {
                bitmap = globalConfig.getBitmapCache().downloadBitmap(uri, displayConfig, this);
                from = BitmapLoadFrom.URI;
            }

            return bitmap;
        }

        public void updateProgress(long total, long current) {
            this.publishProgress(PROGRESS_LOADING, total, current);
        }

        private static final int PROGRESS_LOAD_STARTED = 0;
        private static final int PROGRESS_LOADING = 1;

        @Override
        protected void onProgressUpdate(Object... values) {
            if (values == null || values.length == 0) return;

            final T container = this.getTargetContainer();
            if (container == null) return;

            switch ((Integer) values[0]) {
                case PROGRESS_LOAD_STARTED:
                    callBack.onLoadStarted(container, uri, displayConfig);
                    break;
                case PROGRESS_LOADING:
                    if (values.length != 3) return;
                    callBack.onLoading(container, uri, displayConfig, (Long) values[1], (Long) values[2]);
                    break;
                default:
                    break;
            }
        }

        @Override
        protected void onPostExecute(Bitmap bitmap) {
            final T container = this.getTargetContainer();
            if (container != null) {
                if (bitmap != null) {
                    callBack.onLoadCompleted(
                            container,
                            this.uri,
                            bitmap,
                            displayConfig,
                            from);
                } else {
                    callBack.onLoadFailed(
                            container,
                            this.uri,
                            displayConfig.getLoadFailedDrawable());
                }
            }
        }

        @Override
        protected void onCancelled(Bitmap bitmap) {
            synchronized (pauseTaskLock) {
                pauseTaskLock.notifyAll();
            }
        }

        public T getTargetContainer() {
            final T container = containerReference.get();
            final BitmapLoadTask<T> bitmapWorkerTask = getBitmapTaskFromContainer(container, callBack);

            if (this == bitmapWorkerTask) {
                return container;
            }

            return null;
        }
    }
}

3. BitmapUtils使用：

（1）新建一个Android工程，如下：

（2）首先我们来到主布局文件，如下：

activity_main.xml：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.himi.bitmaputils.MainActivity" >

    <ListView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/lv" />

</LinearLayout>

item.xml：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:orientation="horizontal" >
    <ImageView 
        android:src="@drawable/ic_launcher"
        android:layout_width="50dp"
        android:layout_height="50dp"
        android:layout_margin="10dp"
        android:id="@+id/iv"/>
        
    <TextView 
        android:text="默认"
        android:id="@+id/tv"
        android:textSize="15sp"
        android:layout_marginTop="25dp"
        android:layout_marginLeft="80dp"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>
    
    

</LinearLayout>

（3）这里上面我们使用到了ListView，那么就需要使用Adapter，这里我们需要自定义Adapter，如下：

 在新建的包"com.himi.bitmaputils.adapter"下，新建一个MyAdapter，如下：

package com.himi.bitmaputils.adapter;


import com.himi.bitmaputils.R;
import com.lidroid.xutils.BitmapUtils;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.drawable.AnimationDrawable;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.TextView;

public class MyAdapter extends BaseAdapter {
    
    public String[] Txt =  {
            "Angelababy",
            "刘德华",
            "张国荣",
            "朱珠"
            
        };
    
    public String[] Urls = {
            "http://49.123.72.28:8080/imgs/Angelababy.jpg",
            "http://49.123.72.28:8080/imgs/liudehua.jpg",
            "http://49.123.72.28:8080/imgs/zhangguorong.jpg",
            "http://49.123.72.28:8080/imgs/zhuzhu.jpg"
    };
    private Context context;
    
    private ViewHolder holder;
    
    public MyAdapter(Context context) {
        this.context = context;
    }

    @Override
    public int getCount() {
        // TODO Auto-generated method stub
        return Txt.length;
    }

    @Override
    public Object getItem(int position) {
        // TODO Auto-generated method stub
        return Txt[position];
    }

    @Override
    public long getItemId(int position) {
        // TODO Auto-generated method stub
        return position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        if(convertView ==null) {
            convertView = View.inflate(context, R.layout.item, null);
            
            holder = new ViewHolder();
            holder.iv = (ImageView) convertView.findViewById(R.id.iv);
            holder.tv = (TextView) convertView.findViewById(R.id.tv);
            
            convertView.setTag(holder);
            
            
        } else {
            holder = (ViewHolder) convertView.getTag();
        }
        /**
         * 加载assets中的图片(路径以assets开头)
         * 完整路径是：assets/img01.jpg
         */
        /*BitmapUtils util = new BitmapUtils(context);
        util.display(holder.iv, "assets/img0"+(position+1)+".jpg");
        
        holder.tv.setText(Txt[position]);*/
        
        
        /**
         *  加载本地图片(路径以/开头， 绝对路径)
         *    bitmapUtils.display(testImageView, "/sdcard/test.jpg");
         *  同上
         */
        
        
        /**
         * 加载网络图片
         */
        BitmapUtils util = new BitmapUtils(context,"/data/data/files/imgs");
        AnimationDrawable animation;
        
        holder.iv.setBackgroundResource(R.drawable.git);
        animation = (AnimationDrawable) holder.iv.getBackground();
        
        //设置加载图片过程中的动画gif
        util.configDefaultLoadingImage(animation);
        //设置加载失败默认图片
        util.configDefaultLoadFailedImage(R.drawable.failed);
        //配置图片参数
        util.configDefaultBitmapConfig(Bitmap.Config.RGB_565);
        //加载特定网络路径的图片
        util.display(holder.iv, Urls[position]);
        
        holder.tv.setText(Txt[position]);
        
        return convertView;
    }
    
    class ViewHolder {
        ImageView iv;
        TextView tv;
    }
    
    

}

　　1）上面加载本地图片、assets目录图片比较简单，这里就不详细说明，上面有使用基本代码

　　2）加载网络图片：

首先我们在Android工程中，添加网络权限；

 <uses-permission android:name="android.permission.INTERNET"/>

接下来我们来模拟网络环境，我们开启Apache服务器，如下：

在相应apache服务器文件存放目录下，存放图片文件，如下：

同时上面配置了正在加载ing网络图片时候，加载中图片，使用到了Gif显示，关于Gif显示，可以参考如下笔记：

Android（java）学习笔记207：开源项目使用之gif view

或者

Android（java）学习笔记198：Android下的帧动画（Drawable Animation）

（4）来到MainActivity，如下：

package com.himi.bitmaputils;

import com.himi.bitmaputils.adapter.MyAdapter;

import android.app.Activity;
import android.os.Bundle;
import android.widget.ListView;

public class MainActivity extends Activity {
    
    private ListView lv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        lv = (ListView) findViewById(R.id.lv);
        MyAdapter adapter = new MyAdapter(this);
        
        lv.setAdapter(adapter);
        
    }

    
}

（5）布署程序到模拟器上：

• 正常情况下，如下：

• 这里为了模拟场景，删除Apache服务器端liudehua.jpg图片资源，退出程序，重新继续运行，如下：

说明上面BitmapUtils内部自带了缓冲机制。

• 这时候，卸载程序，重新安装，再次运行如下：