Android-Universal-Image-Loader开源项目的简要说明及使用实例

本文转载于：http://www.cnblogs.com/hsx514/p/3460179.html

一.核心类的说明及相关参数的说明

ImageLoaderConfiguration

1.作用：为ImageLoader提供下载配置

2.构造方法：

/**
     * ImageLoaderConfiguration 创建的两种方式。
     */
    // 创建默认的ImageLoaderConfiguration
    ImageLoaderConfiguration configuration_0 = ImageLoaderConfiguration
            .createDefault(this);
 
    // 使用DisplayImageOptions.Builder()创建DisplayImageOptions
    ImageLoaderConfiguration configuration_1 = new ImageLoaderConfiguration.Builder(
            this).threadPriority(Thread.NORM_PRIORITY - 2)
            .denyCacheImageMultipleSizesInMemory()
            .discCacheFileNameGenerator(new Md5FileNameGenerator())
            .tasksProcessingOrder(QueueProcessingType.LIFO).enableLogging()
            .build();

3.常用方法：

/**
 *当同一个Uri获取不同大小的图片，缓存到内存时，只缓存一个。默认会缓存多个不同的大小的相同图片
 */
 denyCacheImageMultipleSizesInMemory()

/**
     * 设置本地图片缓存
     * @param discCache
     */
    discCache(DiscCacheAware discCache)
              

    DiscCacheAware 类型（在com.nostra13.universalimageloader.cache.disc.impl包下能找到如下的类）：
        FileCountLimitedDiscCache(File cacheDir, int maxFileCount):设置缓存路径和缓存文件的数量，超过数量后，old将被删除
        FileCountLimitedDiscCache(File cacheDir,FileNameGenerator fileNameGenerator,int maxFileCount):第二个参数是通过图片的url生成的唯一文件名。
        LimitedAgeDiscCache(File cacheDir, FileNameGenerator fileNameGenerator, long maxAge) :第二个参数同上
        LimitedAgeDiscCache(File cacheDir, long maxAge):maxAge为定义的时间，超过时间后，图片将被删除
        TotalSizeLimitedDiscCache(File cacheDir, FileNameGenerator fileNameGenerator, int maxCacheSize) :第二个参数同上
        TotalSizeLimitedDiscCache(File cacheDir, int maxCacheSize) :定义缓存的大小，如超过了，就会删除old图片。
        UnlimitedDiscCache(File cacheDir) ：缓存没有限制
        UnlimitedDiscCache(File cacheDir, FileNameGenerator fileNameGenerator)：第二个参数同上

/**
     * 设置图片保存到本地的参数
     * @param maxImageWidthForDiscCache 保存的最大宽度
     * @param maxImageHeightForDiscCache 保存的最大高度
     * @param compressFormat    保存的压缩格式
     * @param compressQuality 提示压缩的程度，有0-100.想png这种图片无损耗，就不必设置了
     */
    discCacheExtraOptions(int maxImageWidthForDiscCache,
            int maxImageHeightForDiscCache,
            android.graphics.Bitmap.CompressFormat compressFormat,
            int compressQuality)

/**
     * 设置缓存文件的数量
    * @param maxFileCount 数量
     */
    discCacheFileCount(int maxFileCount)

/**
       * 设置缓存的大小
       * @param maxCacheSize 大小
      */
        discCacheSize(int maxCacheSize)

/**
     * 设置缓存文件的名字
     * @param fileNameGenerator
     */
    discCacheFileNameGenerator(FileNameGenerator fileNameGenerator)
             fileNameGenerator：
                      HashCodeFileNameGenerator() ：通过HashCode将url生成文件的唯一名字
                      Md5FileNameGenerator()：通过Md5将url生产文件的唯一名字

/**
  * 启动Log信息记录，用于查看异常信息
  */
    enableLogging()

/**
     * 设置缓存信息
     * @param maxImageWidthForMemoryCache 缓存图片的最大宽度，默认为手机的屏幕宽度
     * @param maxImageHeightForMemoryCache 缓存图片的最大高度，默认为手机的屏幕宽度
     */
    memoryCacheExtraOptions(int maxImageWidthForMemoryCache, int maxImageHeightForMemoryCache)

/**
     * 添加个线程池，进行下载
     * @param executor 线程池
     * 如果进行了这个设置，那么threadPoolSize(int)，threadPriority(int)，tasksProcessingOrder(QueueProcessingType)
     * 将不会起作用
     */
     taskExecutor(Executor executor)

/**
       * 设置用于显示图片的线程池大小
      * @param threadPoolSize
       */
      threadPoolSize(int threadPoolSize)

/**
      * 设置线程的优先级
      * @param threadPriority
       */
      threadPriority(int threadPriority)

/**
      * 设置图片下载和显示的工作队列排序
       * @param tasksProcessingType
       */
      tasksProcessingOrder(QueueProcessingType tasksProcessingType)

/**
      * 下载缓存图片
    * @param executorForCachedImages
    */
     taskExecutorForCachedImages(Executor executorForCachedImages)

DisplayImageOptions

1.作用：用于设置图片显示的类。

2.构造方法：

/**
         * DisplayImageOptions 创建的两种方式。
         */
        // 创建默认的DisplayImageOptions
        DisplayImageOptions option_0 = DisplayImageOptions.createSimple();
 
        // 使用DisplayImageOptions.Builder()创建DisplayImageOptions
        DisplayImageOptions option_1 = new DisplayImageOptions.Builder()
                .showStubImage(R.drawable.ic_launcher)
                .showImageOnFail(R.drawable.ic_error)
                .showImageForEmptyUri(R.drawable.ic_empty).cacheInMemory()
                .cacheOnDisc().displayer(new RoundedBitmapDisplayer(20))
                .build();

3.常用方法：

//设置图片在下载期间显示的图片
    showStubImage(R.drawable.ic_launcher)
 
    //设置图片Uri为空或是错误的时候显示的图片
    showImageForEmptyUri(R.drawable.ic_empty)
 
    //设置图片加载/解码过程中错误时候显示的图片
    showImageOnFail(R.drawable.ic_error)
 
    //设置图片在下载前是否重置，复位
    resetViewBeforeLoading()
 
    //设置下载的图片是否缓存在内存中
    cacheInMemory()
 
    //设置下载的图片是否缓存在SD卡中
    cacheOnDisc()
 
    //设置图片的解码类型
    bitmapConfig(Bitmap.Config.RGB_565)
 
    //设置图片的解码配置
    decodingOptions(android.graphics.BitmapFactory.Options decodingOptions)
 
    //设置图片下载前的延迟
    delayBeforeLoading(int delayInMillis) 
 
    //设置额外的内容给ImageDownloader
    extraForDownloader(Object extra)
 
    //设置图片加入缓存前，对bitmap进行设置
    preProcessor(BitmapProcessor preProcessor)
 
    //设置显示前的图片，显示后这个图片一直保留在缓存中
    postProcessor(BitmapProcessor postProcessor) 
 
    //设置图片以如何的编码方式显示
    imageScaleType(ImageScaleType imageScaleType)

/**
     * 设置图片的显示方式
     * @param displayer
     */
    displayer(BitmapDisplayer displayer)
        displayer：
              RoundedBitmapDisplayer（int roundPixels）设置圆角图片
              FakeBitmapDisplayer（）这个类什么都没做
              FadeInBitmapDisplayer（int durationMillis）设置图片渐显的时间
　　　　　　　SimpleBitmapDisplayer()正常显示一张图片

/**
 * 图片的缩放方式
 * @param imageScaleType
 */
    imageScaleType(ImageScaleType imageScaleType)
         imageScaleType:
                 EXACTLY :图像将完全按比例缩小的目标大小
                   EXACTLY_STRETCHED:图片会缩放到目标大小完全
                   IN_SAMPLE_INT:图像将被二次采样的整数倍
                   IN_SAMPLE_POWER_OF_2:图片将降低2倍，直到下一减少步骤，使图像更小的目标大小
                   NONE:图片不会调整

二.简要使用的示例

MyApplication

package com.ryantang.rtimageloader;
 
import android.app.Application;
 
import com.nostra13.universalimageloader.cache.disc.naming.Md5FileNameGenerator;
import com.nostra13.universalimageloader.core.ImageLoader;
import com.nostra13.universalimageloader.core.ImageLoaderConfiguration;
import com.nostra13.universalimageloader.core.assist.QueueProcessingType;
/**
 * 初始化ImageLoaderConfiguration
 *
 * @author hsx
 * @time 2013-12-5下午05:38:43
 */
public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
 
        // This configuration tuning is custom. You can tune every option, you may tune some of them,
        // or you can create default configuration by
        //  ImageLoaderConfiguration.createDefault(this);
        // method.
        ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(getApplicationContext())
                .threadPriority(Thread.NORM_PRIORITY - 2)//设置线程的优先级
                .denyCacheImageMultipleSizesInMemory()//当同一个Uri获取不同大小的图片，缓存到内存时，只缓存一个。默认会缓存多个不同的大小的相同图片
                .discCacheFileNameGenerator(new Md5FileNameGenerator())//设置缓存文件的名字
                .discCacheFileCount(60)//缓存文件的最大个数
                .tasksProcessingOrder(QueueProcessingType.LIFO)// 设置图片下载和显示的工作队列排序
                .enableLogging() //是否打印日志用于检查错误
                .build();
 
        //Initialize ImageLoader with configuration
        ImageLoader.getInstance().init(config);
    }
}

AnimateFirstDisplayListener

package com.ryantang.rtimageloader.listener;
 
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
 
import android.graphics.Bitmap;
import android.view.View;
import android.widget.ImageView;
 
import com.nostra13.universalimageloader.core.assist.SimpleImageLoadingListener;
import com.nostra13.universalimageloader.core.display.FadeInBitmapDisplayer;
 
public class AnimateFirstDisplayListener extends SimpleImageLoadingListener {
 
    public static  List<String> displayedImages = Collections.synchronizedList(new LinkedList<String>());
 
    @Override
    public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {
        if (loadedImage != null) {
            ImageView imageView = (ImageView) view;
            boolean firstDisplay = !displayedImages.contains(imageUri);
            if (firstDisplay) {
                FadeInBitmapDisplayer.animate(imageView, 500);
                displayedImages.add(imageUri);
            }
        }
    }
}

ItemAdapter

package com.ryantang.rtimageloader.adapter;
 
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.TextView;
import com.nostra13.universalimageloader.core.DisplayImageOptions;
import com.nostra13.universalimageloader.core.ImageLoader;
import com.nostra13.universalimageloader.core.assist.ImageLoadingListener;
import com.nostra13.universalimageloader.core.display.RoundedBitmapDisplayer;
import com.ryantang.rtimageloader.R;
import com.ryantang.rtimageloader.listener.AnimateFirstDisplayListener;
 
public class ItemAdapter extends BaseAdapter {
    DisplayImageOptions options;
 
    private ImageLoadingListener animateFirstListener = new AnimateFirstDisplayListener();
 
    String[] imageUrls;
    Context context;
 
    public ItemAdapter(String[] imageUrls, Context context) {
        super();
        this.imageUrls = imageUrls;
        this.context = context;
        options = new DisplayImageOptions.Builder()
        .showStubImage(R.drawable.ic_launcher)//设置图片在下载期间显示的图片
        .showImageForEmptyUri(R.drawable.ic_launcher)//设置图片Uri为空或是错误的时候显示的图片
         .showImageOnFail(R.drawable.ic_launcher)//设置图片加载/解码过程中错误时候显示的图片
         .cacheInMemory(true)//是否緩存都內存中
         .cacheOnDisc(true)//是否緩存到sd卡上
         .displayer(new RoundedBitmapDisplayer(20))
                .build();
    }
 
    private class ViewHolder {
        public TextView text;
        public ImageView image;
    }
 
    @Override
    public int getCount() {
        return imageUrls.length;
    }
 
    @Override
    public Object getItem(int position) {
        return position;
    }
 
    @Override
    public long getItemId(int position) {
        return position;
    }
 
    @Override
    public View getView(final int position, View convertView, ViewGroup parent) {
        final ViewHolder holder;
        if (convertView == null) {
            LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
            convertView = inflater.inflate(R.layout.item_list_image, parent, false);
            holder = new ViewHolder();
            holder.text = (TextView) convertView.findViewById(R.id.text);
            holder.image = (ImageView) convertView.findViewById(R.id.image);
            convertView.setTag(holder);
        } else {
            holder = (ViewHolder) convertView.getTag();
        }
 
        holder.text.setText("Item " + (position + 1));
        // ImageLoader
        ImageLoader imageLoader = ImageLoader.getInstance();
        imageLoader.displayImage(imageUrls[position], holder.image, options, animateFirstListener);
 
        return convertView;
    }
}