當前位置：首頁 > 运维知识 > Android >内容正文

Android

Android之Universal-Image-loader

發布時間：2023/12/4 Android 36 豆豆

生活随笔收集整理的這篇文章主要介紹了 Android之Universal-Image-loader 小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

一、介紹

?Android-Universal-Image-Loader是一個開源的UI組件程序，該項目的目的是提供一個可重復使用的儀器為異步圖像加載，緩存和顯示。所以，如果你的程序里需要這個功能的話，那么不妨試試它。因為已經封裝好了一些類和方法。我們可以直接拿來用了。而不用重復去寫了。其實，寫一個這方面的程序還是比較麻煩的，要考慮多線程緩存，內存溢出等很多方面。

二、具體使用

一個好的類庫的重要特征就是可配置性強。我們先簡單使用Android-Universal-Image-Loader，一般情況下使用默認配置就可以了。

下面的實例利用Android-Universal-Image-Loader將網絡圖片加載到圖片墻中。

public class BaseActivity extends Activity {ImageLoader imageLoader;@Overrideprotected void onCreate(Bundle savedInstanceState) {// Create global configuration and initialize ImageLoader with this configurationImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(getApplicationContext()).build();ImageLoader.getInstance().init(config);super.onCreate(savedInstanceState);} } public class MainActivity extends BaseActivity {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);ImageLoader imageLoader = ImageLoader.getInstance();GridView gridView = (GridView) this.findViewById(R.id.grdvImageWall);gridView.setAdapter(new PhotoWallAdapter(Constants.IMAGES));}static class ViewHolder {ImageView imageView;ProgressBar progressBar;}public class PhotoWallAdapter extends BaseAdapter {String[] imageUrls;ImageLoader imageLoad;DisplayImageOptions options;LinearLayout gridViewItem;public PhotoWallAdapter(String[] imageUrls) {assert imageUrls != null;this.imageUrls = imageUrls;options = new DisplayImageOptions.Builder().showImageOnLoading(R.drawable.ic_stub) // resource or// drawable.showImageForEmptyUri(R.drawable.ic_empty) // resource or// drawable.showImageOnFail(R.drawable.ic_error) // resource or// drawable.resetViewBeforeLoading(false) // default.delayBeforeLoading(1000).cacheInMemory(false) // default.cacheOnDisk(false) // default.considerExifParams(false) // default.imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2) // default.bitmapConfig(Bitmap.Config.ARGB_8888) // default.displayer(new SimpleBitmapDisplayer()) // default.handler(new Handler()) // default.build();this.imageLoad = ImageLoader.getInstance();}@Overridepublic int getCount() {return this.imageUrls.length;}@Overridepublic Object getItem(int position) {if (position <= 0 || position >= this.imageUrls.length) {throw new IllegalArgumentException("position<=0||position>=this.imageUrls.length");}return this.imageUrls[position];}@Overridepublic long getItemId(int position) {return position;}@Overridepublic View getView(int position, View convertView, ViewGroup parent) {// 判斷這個image是否已經在緩存當中，如果沒有就下載final ViewHolder holder;if (convertView == null) {holder = new ViewHolder();gridViewItem = (LinearLayout) getLayoutInflater().inflate(R.layout.image_wall_item, null);holder.imageView = (ImageView) gridViewItem.findViewById(R.id.item_image);holder.progressBar = (ProgressBar) gridViewItem.findViewById(R.id.item_process);gridViewItem.setTag(holder);convertView = gridViewItem;} else {holder = (ViewHolder) gridViewItem.getTag();}this.imageLoad.displayImage(this.imageUrls[position],holder.imageView, options,new SimpleImageLoadingListener() {@Overridepublic void onLoadingStarted(String imageUri, View view) {holder.progressBar.setProgress(0);holder.progressBar.setVisibility(View.VISIBLE);}@Overridepublic void onLoadingFailed(String imageUri, View view,FailReason failReason) {holder.progressBar.setVisibility(View.GONE);}@Overridepublic void onLoadingComplete(String imageUri,View view, Bitmap loadedImage) {holder.progressBar.setVisibility(View.GONE);}}, new ImageLoadingProgressListener() {@Overridepublic void onProgressUpdate(String imageUri,View view, int current, int total) {holder.progressBar.setProgress(Math.round(100.0f* current / total));}}); // 通過URL判斷圖片是否已經下載return convertView;}} }

里面主要的對象都用? ? ? ??突出顯示了。

三者的關系

ImageLoaderConfiguration是針對圖片緩存的全局配置，主要有線程類、緩存大小、磁盤大小、圖片下載與解析、日志方面的配置。

ImageLoader是具體下載圖片，緩存圖片，顯示圖片的具體執行類，它有兩個具體的方法displayImage(...)、loadImage(...)，但是其實最終他們的實現都是displayImage(...)。

DisplayImageOptions用于指導每一個Imageloader根據網絡圖片的狀態（空白、下載錯誤、正在下載）顯示對應的圖片，是否將緩存加載到磁盤上，下載完后對圖片進行怎么樣的處理。

從三者的協作關系上看，他們有點像廚房規定、廚師、客戶個人口味之間的關系。ImageLoaderConfiguration就像是廚房里面的規定，每一個廚師要怎么著裝，要怎么保持廚房的干凈，這是針對每一個廚師都適用的規定，而且不允許個性化改變。ImageLoader就像是具體做菜的廚師，負責具體菜譜的制作。DisplayImageOptions就像每個客戶的偏好，根據客戶是重口味還是清淡，每一個imageLoader根據DisplayImageOptions的要求具體執行。

ImageLoaderConfiguration

在上面的示例代碼中，我們使用ImageLoaderConfiguration的默認配置，下面給出ImageLoaderConfiguration比較詳盡的配置，從下面的配置中，可以看出ImageLoaderConfiguration的配置主要是全局性的配置，主要有線程類、緩存大小、磁盤大小、圖片下載與解析、日志方面的配置。

ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(context).memoryCacheExtraOptions(480, 800) // default = device screen dimensions.diskCacheExtraOptions(480, 800, null).taskExecutor(...).taskExecutorForCachedImages(...).threadPoolSize(3) // default.threadPriority(Thread.NORM_PRIORITY - 1) // default.tasksProcessingOrder(QueueProcessingType.FIFO) // default.denyCacheImageMultipleSizesInMemory().memoryCache(new LruMemoryCache(2 * 1024 * 1024)).memoryCacheSize(2 * 1024 * 1024).memoryCacheSizePercentage(13) // default.diskCache(new UnlimitedDiscCache(cacheDir)) // default.diskCacheSize(50 * 1024 * 1024).diskCacheFileCount(100).diskCacheFileNameGenerator(new HashCodeFileNameGenerator()) // default.imageDownloader(new BaseImageDownloader(context)) // default.imageDecoder(new BaseImageDecoder()) // default.defaultDisplayImageOptions(DisplayImageOptions.createSimple()) // default.writeDebugLogs().build(); ImageLoaderConfiguration 的主要職責就是記錄相關的配置，它的內部其實就是一些字段的集合（如下面的源代碼）。它有一個builder的內部類，這個類中的字段跟ImageLoaderConfiguration中的字段完全一致，它有一些默認值，通過修改builder可以配置ImageLoaderConfiguration。

/******************************************************************************** Copyright 2011-2013 Sergey Tarasevich** Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at** http://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*******************************************************************************/ package com.nostra13.universalimageloader.core;import android.content.Context; import android.content.res.Resources; import android.util.DisplayMetrics; import com.nostra13.universalimageloader.cache.disc.DiskCache; import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator; import com.nostra13.universalimageloader.cache.memory.MemoryCache; import com.nostra13.universalimageloader.cache.memory.impl.FuzzyKeyMemoryCache; import com.nostra13.universalimageloader.core.assist.FlushedInputStream; import com.nostra13.universalimageloader.core.assist.ImageSize; import com.nostra13.universalimageloader.core.assist.QueueProcessingType; import com.nostra13.universalimageloader.core.decode.ImageDecoder; import com.nostra13.universalimageloader.core.download.ImageDownloader; import com.nostra13.universalimageloader.core.process.BitmapProcessor; import com.nostra13.universalimageloader.utils.L; import com.nostra13.universalimageloader.utils.MemoryCacheUtils;import java.io.IOException; import java.io.InputStream; import java.util.concurrent.Executor;/*** Presents configuration for {@link ImageLoader}** @author Sergey Tarasevich (nostra13[at]gmail[dot]com)* @see ImageLoader* @see MemoryCache* @see DiskCache* @see DisplayImageOptions* @see ImageDownloader* @see FileNameGenerator* @since 1.0.0*/ public final class ImageLoaderConfiguration {final Resources resources;final int maxImageWidthForMemoryCache;final int maxImageHeightForMemoryCache;final int maxImageWidthForDiskCache;final int maxImageHeightForDiskCache;final BitmapProcessor processorForDiskCache;final Executor taskExecutor;final Executor taskExecutorForCachedImages;final boolean customExecutor;final boolean customExecutorForCachedImages;final int threadPoolSize;final int threadPriority;final QueueProcessingType tasksProcessingType;final MemoryCache memoryCache;final DiskCache diskCache;final ImageDownloader downloader;final ImageDecoder decoder;final DisplayImageOptions defaultDisplayImageOptions;final ImageDownloader networkDeniedDownloader;final ImageDownloader slowNetworkDownloader;private ImageLoaderConfiguration(final Builder builder) {resources = builder.context.getResources();maxImageWidthForMemoryCache = builder.maxImageWidthForMemoryCache;maxImageHeightForMemoryCache = builder.maxImageHeightForMemoryCache;maxImageWidthForDiskCache = builder.maxImageWidthForDiskCache;maxImageHeightForDiskCache = builder.maxImageHeightForDiskCache;processorForDiskCache = builder.processorForDiskCache;taskExecutor = builder.taskExecutor;taskExecutorForCachedImages = builder.taskExecutorForCachedImages;threadPoolSize = builder.threadPoolSize;threadPriority = builder.threadPriority;tasksProcessingType = builder.tasksProcessingType;diskCache = builder.diskCache;memoryCache = builder.memoryCache;defaultDisplayImageOptions = builder.defaultDisplayImageOptions;downloader = builder.downloader;decoder = builder.decoder;customExecutor = builder.customExecutor;customExecutorForCachedImages = builder.customExecutorForCachedImages;networkDeniedDownloader = new NetworkDeniedImageDownloader(downloader);slowNetworkDownloader = new SlowNetworkImageDownloader(downloader);L.writeDebugLogs(builder.writeLogs);}/*** Creates default configuration for {@link ImageLoader} * Default values:* <ul>* <li>maxImageWidthForMemoryCache = device's screen width</li>* <li>maxImageHeightForMemoryCache = device's screen height</li>* <li>maxImageWidthForDikcCache = unlimited</li>* <li>maxImageHeightForDiskCache = unlimited</li>* <li>threadPoolSize = {@link Builder#DEFAULT_THREAD_POOL_SIZE this}</li>* <li>threadPriority = {@link Builder#DEFAULT_THREAD_PRIORITY this}</li>* <li>allow to cache different sizes of image in memory</li>* <li>memoryCache = {@link DefaultConfigurationFactory#createMemoryCache(int)}</li>* <li>diskCache = {@link com.nostra13.universalimageloader.cache.disc.impl.UnlimitedDiscCache}</li>* <li>imageDownloader = {@link DefaultConfigurationFactory#createImageDownloader(Context)}</li>* <li>imageDecoder = {@link DefaultConfigurationFactory#createImageDecoder(boolean)}</li>* <li>diskCacheFileNameGenerator = {@link DefaultConfigurationFactory#createFileNameGenerator()}</li>* <li>defaultDisplayImageOptions = {@link DisplayImageOptions#createSimple() Simple options}</li>* <li>tasksProcessingOrder = {@link QueueProcessingType#FIFO}</li>* <li>detailed logging disabled</li>* </ul>*/public static ImageLoaderConfiguration createDefault(Context context) {return new Builder(context).build();}ImageSize getMaxImageSize() {DisplayMetrics displayMetrics = resources.getDisplayMetrics();int width = maxImageWidthForMemoryCache;if (width <= 0) {width = displayMetrics.widthPixels;}int height = maxImageHeightForMemoryCache;if (height <= 0) {height = displayMetrics.heightPixels;}return new ImageSize(width, height);}/*** Builder for {@link ImageLoaderConfiguration}** @author Sergey Tarasevich (nostra13[at]gmail[dot]com)*/public static class Builder {private static final String WARNING_OVERLAP_DISK_CACHE_PARAMS = "diskCache(), diskCacheSize() and diskCacheFileCount calls overlap each other";private static final String WARNING_OVERLAP_DISK_CACHE_NAME_GENERATOR = "diskCache() and diskCacheFileNameGenerator() calls overlap each other";private static final String WARNING_OVERLAP_MEMORY_CACHE = "memoryCache() and memoryCacheSize() calls overlap each other";private static final String WARNING_OVERLAP_EXECUTOR = "threadPoolSize(), threadPriority() and tasksProcessingOrder() calls "+ "can overlap taskExecutor() and taskExecutorForCachedImages() calls.";/** {@value} */public static final int DEFAULT_THREAD_POOL_SIZE = 3;/** {@value} */public static final int DEFAULT_THREAD_PRIORITY = Thread.NORM_PRIORITY - 1;/** {@value} */public static final QueueProcessingType DEFAULT_TASK_PROCESSING_TYPE = QueueProcessingType.FIFO;private Context context;private int maxImageWidthForMemoryCache = 0;private int maxImageHeightForMemoryCache = 0;private int maxImageWidthForDiskCache = 0;private int maxImageHeightForDiskCache = 0;private BitmapProcessor processorForDiskCache = null;private Executor taskExecutor = null;private Executor taskExecutorForCachedImages = null;private boolean customExecutor = false;private boolean customExecutorForCachedImages = false;private int threadPoolSize = DEFAULT_THREAD_POOL_SIZE;private int threadPriority = DEFAULT_THREAD_PRIORITY;private boolean denyCacheImageMultipleSizesInMemory = false;private QueueProcessingType tasksProcessingType = DEFAULT_TASK_PROCESSING_TYPE;private int memoryCacheSize = 0;private long diskCacheSize = 0;private int diskCacheFileCount = 0;private MemoryCache memoryCache = null;private DiskCache diskCache = null;private FileNameGenerator diskCacheFileNameGenerator = null;private ImageDownloader downloader = null;private ImageDecoder decoder;private DisplayImageOptions defaultDisplayImageOptions = null;private boolean writeLogs = false;public Builder(Context context) {this.context = context.getApplicationContext();}/*** Sets options for memory cache** @param maxImageWidthForMemoryCache Maximum image width which will be used for memory saving during decoding* an image to {@link android.graphics.Bitmap Bitmap}. Default value - device's screen width* @param maxImageHeightForMemoryCache Maximum image height which will be used for memory saving during decoding* an image to {@link android.graphics.Bitmap Bitmap}. Default value - device's screen height*/public Builder memoryCacheExtraOptions(int maxImageWidthForMemoryCache, int maxImageHeightForMemoryCache) {this.maxImageWidthForMemoryCache = maxImageWidthForMemoryCache;this.maxImageHeightForMemoryCache = maxImageHeightForMemoryCache;return this;}/*** @deprecated Use* {@link #diskCacheExtraOptions(int, int, com.nostra13.universalimageloader.core.process.BitmapProcessor)}* instead*/@Deprecatedpublic Builder discCacheExtraOptions(int maxImageWidthForDiskCache, int maxImageHeightForDiskCache,BitmapProcessor processorForDiskCache) {return diskCacheExtraOptions(maxImageWidthForDiskCache, maxImageHeightForDiskCache, processorForDiskCache);}/*** Sets options for resizing/compressing of downloaded images before saving to disk cache. * NOTE: Use this option only when you have appropriate needs. It can make ImageLoader slower.** @param maxImageWidthForDiskCache Maximum width of downloaded images for saving at disk cache* @param maxImageHeightForDiskCache Maximum height of downloaded images for saving at disk cache* @param processorForDiskCache null-ok; {@linkplain BitmapProcessor Bitmap processor} which process images before saving them in disc cache*/public Builder diskCacheExtraOptions(int maxImageWidthForDiskCache, int maxImageHeightForDiskCache,BitmapProcessor processorForDiskCache) {this.maxImageWidthForDiskCache = maxImageWidthForDiskCache;this.maxImageHeightForDiskCache = maxImageHeightForDiskCache;this.processorForDiskCache = processorForDiskCache;return this;}/*** Sets custom {@linkplain Executor executor} for tasks of loading and displaying images. * * NOTE: If you set custom executor then following configuration options will not be considered for this* executor:* <ul>* <li>{@link #threadPoolSize(int)}</li>* <li>{@link #threadPriority(int)}</li>* <li>{@link #tasksProcessingOrder(QueueProcessingType)}</li>* </ul>** @see #taskExecutorForCachedImages(Executor)*/public Builder taskExecutor(Executor executor) {if (threadPoolSize != DEFAULT_THREAD_POOL_SIZE || threadPriority != DEFAULT_THREAD_PRIORITY || tasksProcessingType != DEFAULT_TASK_PROCESSING_TYPE) {L.w(WARNING_OVERLAP_EXECUTOR);}this.taskExecutor = executor;return this;}/*** Sets custom {@linkplain Executor executor} for tasks of displaying cached on disk images (these tasks* are executed quickly so UIL prefer to use separate executor for them). * * If you set the same executor for {@linkplain #taskExecutor(Executor) general tasks} and* tasks about cached images (this method) then these tasks will be in the* same thread pool. So short-lived tasks can wait a long time for their turn. * * NOTE: If you set custom executor then following configuration options will not be considered for this* executor:* <ul>* <li>{@link #threadPoolSize(int)}</li>* <li>{@link #threadPriority(int)}</li>* <li>{@link #tasksProcessingOrder(QueueProcessingType)}</li>* </ul>** @see #taskExecutor(Executor)*/public Builder taskExecutorForCachedImages(Executor executorForCachedImages) {if (threadPoolSize != DEFAULT_THREAD_POOL_SIZE || threadPriority != DEFAULT_THREAD_PRIORITY || tasksProcessingType != DEFAULT_TASK_PROCESSING_TYPE) {L.w(WARNING_OVERLAP_EXECUTOR);}this.taskExecutorForCachedImages = executorForCachedImages;return this;}/*** Sets thread pool size for image display tasks. * Default value - {@link #DEFAULT_THREAD_POOL_SIZE this}*/public Builder threadPoolSize(int threadPoolSize) {if (taskExecutor != null || taskExecutorForCachedImages != null) {L.w(WARNING_OVERLAP_EXECUTOR);}this.threadPoolSize = threadPoolSize;return this;}/*** Sets the priority for image loading threads. Should be NOT greater than {@link Thread#MAX_PRIORITY} or* less than {@link Thread#MIN_PRIORITY} * Default value - {@link #DEFAULT_THREAD_PRIORITY this}*/public Builder threadPriority(int threadPriority) {if (taskExecutor != null || taskExecutorForCachedImages != null) {L.w(WARNING_OVERLAP_EXECUTOR);}if (threadPriority < Thread.MIN_PRIORITY) {this.threadPriority = Thread.MIN_PRIORITY;} else {if (threadPriority > Thread.MAX_PRIORITY) {this.threadPriority = Thread.MAX_PRIORITY;} else {this.threadPriority = threadPriority;}}return this;}/*** When you display an image in a small {@link android.widget.ImageView ImageView} and later you try to display* this image (from identical URI) in a larger {@link android.widget.ImageView ImageView} so decoded image of* bigger size will be cached in memory as a previous decoded image of smaller size. * So the default behavior is to allow to cache multiple sizes of one image in memory. You can* deny it by calling this method: so when some image will be cached in memory then previous* cached size of this image (if it exists) will be removed from memory cache before.*/public Builder denyCacheImageMultipleSizesInMemory() {this.denyCacheImageMultipleSizesInMemory = true;return this;}/*** Sets type of queue processing for tasks for loading and displaying images. * Default value - {@link QueueProcessingType#FIFO}*/public Builder tasksProcessingOrder(QueueProcessingType tasksProcessingType) {if (taskExecutor != null || taskExecutorForCachedImages != null) {L.w(WARNING_OVERLAP_EXECUTOR);}this.tasksProcessingType = tasksProcessingType;return this;}/*** Sets maximum memory cache size for {@link android.graphics.Bitmap bitmaps} (in bytes). * Default value - 1/8 of available app memory. * NOTE: If you use this method then* {@link com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache LruMemoryCache} will be used as* memory cache. You can use {@link #memoryCache(MemoryCache)} method to set your own implementation of* {@link MemoryCache}.*/public Builder memoryCacheSize(int memoryCacheSize) {if (memoryCacheSize <= 0) throw new IllegalArgumentException("memoryCacheSize must be a positive number");if (memoryCache != null) {L.w(WARNING_OVERLAP_MEMORY_CACHE);}this.memoryCacheSize = memoryCacheSize;return this;}/*** Sets maximum memory cache size (in percent of available app memory) for {@link android.graphics.Bitmap* bitmaps}. * Default value - 1/8 of available app memory. * NOTE: If you use this method then* {@link com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache LruMemoryCache} will be used as* memory cache. You can use {@link #memoryCache(MemoryCache)} method to set your own implementation of* {@link MemoryCache}.*/public Builder memoryCacheSizePercentage(int availableMemoryPercent) {if (availableMemoryPercent <= 0 || availableMemoryPercent >= 100) {throw new IllegalArgumentException("availableMemoryPercent must be in range (0 < % < 100)");}if (memoryCache != null) {L.w(WARNING_OVERLAP_MEMORY_CACHE);}long availableMemory = Runtime.getRuntime().maxMemory();memoryCacheSize = (int) (availableMemory * (availableMemoryPercent / 100f));return this;}/*** Sets memory cache for {@link android.graphics.Bitmap bitmaps}. * Default value - {@link com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache LruMemoryCache}* with limited memory cache size (size = 1/8 of available app memory) * * NOTE: If you set custom memory cache then following configuration option will not be considered:* <ul>* <li>{@link #memoryCacheSize(int)}</li>* </ul>*/public Builder memoryCache(MemoryCache memoryCache) {if (memoryCacheSize != 0) {L.w(WARNING_OVERLAP_MEMORY_CACHE);}this.memoryCache = memoryCache;return this;}/** @deprecated Use {@link #diskCacheSize(int)} instead */@Deprecatedpublic Builder discCacheSize(int maxCacheSize) {return diskCacheSize(maxCacheSize);}/*** Sets maximum disk cache size for images (in bytes). * By default: disk cache is unlimited. * NOTE: If you use this method then* {@link com.nostra13.universalimageloader.cache.disc.impl.ext.LruDiscCache LruDiscCache}* will be used as disk cache. You can use {@link #diskCache(DiskCache)} method for introduction your own* implementation of {@link DiskCache}*/public Builder diskCacheSize(int maxCacheSize) {if (maxCacheSize <= 0) throw new IllegalArgumentException("maxCacheSize must be a positive number");if (diskCache != null) {L.w(WARNING_OVERLAP_DISK_CACHE_PARAMS);}this.diskCacheSize = maxCacheSize;return this;}/** @deprecated Use {@link #diskCacheFileCount(int)} instead */@Deprecatedpublic Builder discCacheFileCount(int maxFileCount) {return diskCacheFileCount(maxFileCount);}/*** Sets maximum file count in disk cache directory. * By default: disk cache is unlimited. * NOTE: If you use this method then* {@link com.nostra13.universalimageloader.cache.disc.impl.ext.LruDiscCache LruDiscCache}* will be used as disk cache. You can use {@link #diskCache(DiskCache)} method for introduction your own* implementation of {@link DiskCache}*/public Builder diskCacheFileCount(int maxFileCount) {if (maxFileCount <= 0) throw new IllegalArgumentException("maxFileCount must be a positive number");if (diskCache != null) {L.w(WARNING_OVERLAP_DISK_CACHE_PARAMS);}this.diskCacheFileCount = maxFileCount;return this;}/** @deprecated Use {@link #diskCacheFileNameGenerator(com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator)} */@Deprecatedpublic Builder discCacheFileNameGenerator(FileNameGenerator fileNameGenerator) {return diskCacheFileNameGenerator(fileNameGenerator);}/*** Sets name generator for files cached in disk cache. * Default value -* {@link com.nostra13.universalimageloader.core.DefaultConfigurationFactory#createFileNameGenerator()* DefaultConfigurationFactory.createFileNameGenerator()}*/public Builder diskCacheFileNameGenerator(FileNameGenerator fileNameGenerator) {if (diskCache != null) {L.w(WARNING_OVERLAP_DISK_CACHE_NAME_GENERATOR);}this.diskCacheFileNameGenerator = fileNameGenerator;return this;}/** @deprecated Use {@link #diskCache(com.nostra13.universalimageloader.cache.disc.DiskCache)} */@Deprecatedpublic Builder discCache(DiskCache diskCache) {return diskCache(diskCache);}/*** Sets disk cache for images. * Default value - {@link com.nostra13.universalimageloader.cache.disc.impl.UnlimitedDiscCache* BaseDiscCache}. Cache directory is defined by* {@link com.nostra13.universalimageloader.utils.StorageUtils#getCacheDirectory(Context)* StorageUtils.getCacheDirectory(Context)}. * * NOTE: If you set custom disk cache then following configuration option will not be considered:* <ul>* <li>{@link #diskCacheSize(int)}</li>* <li>{@link #diskCacheFileCount(int)}</li>* <li>{@link #diskCacheFileNameGenerator(FileNameGenerator)}</li>* </ul>*/public Builder diskCache(DiskCache diskCache) {if (diskCacheSize > 0 || diskCacheFileCount > 0) {L.w(WARNING_OVERLAP_DISK_CACHE_PARAMS);}if (diskCacheFileNameGenerator != null) {L.w(WARNING_OVERLAP_DISK_CACHE_NAME_GENERATOR);}this.diskCache = diskCache;return this;}/*** Sets utility which will be responsible for downloading of image. * Default value -* {@link com.nostra13.universalimageloader.core.DefaultConfigurationFactory#createImageDownloader(Context)* DefaultConfigurationFactory.createImageDownloader()}*/public Builder imageDownloader(ImageDownloader imageDownloader) {this.downloader = imageDownloader;return this;}/*** Sets utility which will be responsible for decoding of image stream. * Default value -* {@link com.nostra13.universalimageloader.core.DefaultConfigurationFactory#createImageDecoder(boolean)* DefaultConfigurationFactory.createImageDecoder()}*/public Builder imageDecoder(ImageDecoder imageDecoder) {this.decoder = imageDecoder;return this;}/*** Sets default {@linkplain DisplayImageOptions display image options} for image displaying. These options will* be used for every {@linkplain ImageLoader#displayImage(String, android.widget.ImageView) image display call}* without passing custom {@linkplain DisplayImageOptions options} * Default value - {@link DisplayImageOptions#createSimple() Simple options}*/public Builder defaultDisplayImageOptions(DisplayImageOptions defaultDisplayImageOptions) {this.defaultDisplayImageOptions = defaultDisplayImageOptions;return this;}/*** Enables detail logging of {@link ImageLoader} work. To prevent detail logs don't call this method.* Consider {@link com.nostra13.universalimageloader.utils.L#disableLogging()} to disable* ImageLoader logging completely (even error logs)*/public Builder writeDebugLogs() {this.writeLogs = true;return this;}/** Builds configured {@link ImageLoaderConfiguration} object */public ImageLoaderConfiguration build() {initEmptyFieldsWithDefaultValues();return new ImageLoaderConfiguration(this);}private void initEmptyFieldsWithDefaultValues() {if (taskExecutor == null) {taskExecutor = DefaultConfigurationFactory.createExecutor(threadPoolSize, threadPriority, tasksProcessingType);} else {customExecutor = true;}if (taskExecutorForCachedImages == null) {taskExecutorForCachedImages = DefaultConfigurationFactory.createExecutor(threadPoolSize, threadPriority, tasksProcessingType);} else {customExecutorForCachedImages = true;}if (diskCache == null) {if (diskCacheFileNameGenerator == null) {diskCacheFileNameGenerator = DefaultConfigurationFactory.createFileNameGenerator();}diskCache = DefaultConfigurationFactory.createDiskCache(context, diskCacheFileNameGenerator, diskCacheSize, diskCacheFileCount);}if (memoryCache == null) {memoryCache = DefaultConfigurationFactory.createMemoryCache(memoryCacheSize);}if (denyCacheImageMultipleSizesInMemory) {memoryCache = new FuzzyKeyMemoryCache(memoryCache, MemoryCacheUtils.createFuzzyKeyComparator());}if (downloader == null) {downloader = DefaultConfigurationFactory.createImageDownloader(context);}if (decoder == null) {decoder = DefaultConfigurationFactory.createImageDecoder(writeLogs);}if (defaultDisplayImageOptions == null) {defaultDisplayImageOptions = DisplayImageOptions.createSimple();}}}/*** Decorator. Prevents downloads from network (throws {@link IllegalStateException exception}). * In most cases this downloader shouldn't be used directly.** @author Sergey Tarasevich (nostra13[at]gmail[dot]com)* @since 1.8.0*/private static class NetworkDeniedImageDownloader implements ImageDownloader {private final ImageDownloader wrappedDownloader;public NetworkDeniedImageDownloader(ImageDownloader wrappedDownloader) {this.wrappedDownloader = wrappedDownloader;}@Overridepublic InputStream getStream(String imageUri, Object extra) throws IOException {switch (Scheme.ofUri(imageUri)) {case HTTP:case HTTPS:throw new IllegalStateException();default:return wrappedDownloader.getStream(imageUri, extra);}}}/*** Decorator. Handles <a href="http://code.google.com/p/android/issues/detail?id=6066">this problem</a> on slow networks* using {@link com.nostra13.universalimageloader.core.assist.FlushedInputStream}.** @author Sergey Tarasevich (nostra13[at]gmail[dot]com)* @since 1.8.1*/private static class SlowNetworkImageDownloader implements ImageDownloader {private final ImageDownloader wrappedDownloader;public SlowNetworkImageDownloader(ImageDownloader wrappedDownloader) {this.wrappedDownloader = wrappedDownloader;}@Overridepublic InputStream getStream(String imageUri, Object extra) throws IOException {InputStream imageStream = wrappedDownloader.getStream(imageUri, extra);switch (Scheme.ofUri(imageUri)) {case HTTP:case HTTPS:return new FlushedInputStream(imageStream);default:return imageStream;}}} }

Display Options

每一個ImageLoader.displayImage(...)都可以使用Display Options。

DisplayImageOptions options = new DisplayImageOptions.Builder().showImageOnLoading(R.drawable.ic_stub) // resource or drawable.showImageForEmptyUri(R.drawable.ic_empty) // resource or drawable.showImageOnFail(R.drawable.ic_error) // resource or drawable.resetViewBeforeLoading(false) // default.delayBeforeLoading(1000).cacheInMemory(false) // default.cacheOnDisk(false) // default.preProcessor(...).postProcessor(...).extraForDownloader(...).considerExifParams(false) // default.imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2) // default.bitmapConfig(Bitmap.Config.ARGB_8888) // default.decodingOptions(...).displayer(new SimpleBitmapDisplayer()) // default.handler(new Handler()) // default.build(); Display Options 的主要職責就是記錄相關的配置，它的內部其實就是一些字段的集合（如下面的源代碼）。它有一個builder的內部類，這個類中的字段跟DisplayOption中的字段完全一致，它有一些默認值，通過修改builder可以配置DisplayOptions。

public final class DisplayImageOptions {private final int imageResOnLoading;private final int imageResForEmptyUri;private final int imageResOnFail;private final Drawable imageOnLoading;private final Drawable imageForEmptyUri;private final Drawable imageOnFail;private final boolean resetViewBeforeLoading;private final boolean cacheInMemory;private final boolean cacheOnDisk;private final ImageScaleType imageScaleType;private final Options decodingOptions;private final int delayBeforeLoading;private final boolean considerExifParams;private final Object extraForDownloader;private final BitmapProcessor preProcessor;private final BitmapProcessor postProcessor;private final BitmapDisplayer displayer;private final Handler handler;private final boolean isSyncLoading;private DisplayImageOptions(Builder builder) {imageResOnLoading = builder.imageResOnLoading;imageResForEmptyUri = builder.imageResForEmptyUri;imageResOnFail = builder.imageResOnFail;imageOnLoading = builder.imageOnLoading;imageForEmptyUri = builder.imageForEmptyUri;imageOnFail = builder.imageOnFail;resetViewBeforeLoading = builder.resetViewBeforeLoading;cacheInMemory = builder.cacheInMemory;cacheOnDisk = builder.cacheOnDisk;imageScaleType = builder.imageScaleType;decodingOptions = builder.decodingOptions;delayBeforeLoading = builder.delayBeforeLoading;considerExifParams = builder.considerExifParams;extraForDownloader = builder.extraForDownloader;preProcessor = builder.preProcessor;postProcessor = builder.postProcessor;displayer = builder.displayer;handler = builder.handler;isSyncLoading = builder.isSyncLoading;}public boolean shouldShowImageOnLoading() {return imageOnLoading != null || imageResOnLoading != 0;}public boolean shouldShowImageForEmptyUri() {return imageForEmptyUri != null || imageResForEmptyUri != 0;}public boolean shouldShowImageOnFail() {return imageOnFail != null || imageResOnFail != 0;}public boolean shouldPreProcess() {return preProcessor != null;}public boolean shouldPostProcess() {return postProcessor != null;}public boolean shouldDelayBeforeLoading() {return delayBeforeLoading > 0;}public Drawable getImageOnLoading(Resources res) {return imageResOnLoading != 0 ? res.getDrawable(imageResOnLoading) : imageOnLoading;}public Drawable getImageForEmptyUri(Resources res) {return imageResForEmptyUri != 0 ? res.getDrawable(imageResForEmptyUri) : imageForEmptyUri;}public Drawable getImageOnFail(Resources res) {return imageResOnFail != 0 ? res.getDrawable(imageResOnFail) : imageOnFail;}public boolean isResetViewBeforeLoading() {return resetViewBeforeLoading;}public boolean isCacheInMemory() {return cacheInMemory;}public boolean isCacheOnDisk() {return cacheOnDisk;}public ImageScaleType getImageScaleType() {return imageScaleType;}public Options getDecodingOptions() {return decodingOptions;}public int getDelayBeforeLoading() {return delayBeforeLoading;}public boolean isConsiderExifParams() {return considerExifParams;}public Object getExtraForDownloader() {return extraForDownloader;}public BitmapProcessor getPreProcessor() {return preProcessor;}public BitmapProcessor getPostProcessor() {return postProcessor;}public BitmapDisplayer getDisplayer() {return displayer;}public Handler getHandler() {return handler;}boolean isSyncLoading() {return isSyncLoading;}/*** Builder for {@link DisplayImageOptions}** @author Sergey Tarasevich (nostra13[at]gmail[dot]com)*/public static class Builder {private int imageResOnLoading = 0;private int imageResForEmptyUri = 0;private int imageResOnFail = 0;private Drawable imageOnLoading = null;private Drawable imageForEmptyUri = null;private Drawable imageOnFail = null;private boolean resetViewBeforeLoading = false;private boolean cacheInMemory = false;private boolean cacheOnDisk = false;private ImageScaleType imageScaleType = ImageScaleType.IN_SAMPLE_POWER_OF_2;private Options decodingOptions = new Options();private int delayBeforeLoading = 0;private boolean considerExifParams = false;private Object extraForDownloader = null;private BitmapProcessor preProcessor = null;private BitmapProcessor postProcessor = null;private BitmapDisplayer displayer = DefaultConfigurationFactory.createBitmapDisplayer();private Handler handler = null;private boolean isSyncLoading = false;public Builder() {decodingOptions.inPurgeable = true;decodingOptions.inInputShareable = true;}/*** Stub image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} during image loading** @param imageRes Stub image resource* @deprecated Use {@link #showImageOnLoading(int)} instead*/@Deprecatedpublic Builder showStubImage(int imageRes) {imageResOnLoading = imageRes;return this;}/*** Incoming image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} during image loading** @param imageRes Image resource*/public Builder showImageOnLoading(int imageRes) {imageResOnLoading = imageRes;return this;}/*** Incoming drawable will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} during image loading.* This option will be ignored if {@link DisplayImageOptions.Builder#showImageOnLoading(int)} is set.*/public Builder showImageOnLoading(Drawable drawable) {imageOnLoading = drawable;return this;}/*** Incoming image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} if empty URI (null or empty* string) will be passed to ImageLoader.displayImage(...) method.** @param imageRes Image resource*/public Builder showImageForEmptyUri(int imageRes) {imageResForEmptyUri = imageRes;return this;}/*** Incoming drawable will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} if empty URI (null or empty* string) will be passed to ImageLoader.displayImage(...) method.* This option will be ignored if {@link DisplayImageOptions.Builder#showImageForEmptyUri(int)} is set.*/public Builder showImageForEmptyUri(Drawable drawable) {imageForEmptyUri = drawable;return this;}/*** Incoming image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} if some error occurs during* requested image loading/decoding.** @param imageRes Image resource*/public Builder showImageOnFail(int imageRes) {imageResOnFail = imageRes;return this;}/*** Incoming drawable will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} if some error occurs during* requested image loading/decoding.* This option will be ignored if {@link DisplayImageOptions.Builder#showImageOnFail(int)} is set.*/public Builder showImageOnFail(Drawable drawable) {imageOnFail = drawable;return this;}/*** {@link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} will be reset (set null) before image loading start** @deprecated Use {@link #resetViewBeforeLoading(boolean) resetViewBeforeLoading(true)} instead*/public Builder resetViewBeforeLoading() {resetViewBeforeLoading = true;return this;}/*** Sets whether {@link com.nostra13.universalimageloader.core.imageaware.ImageAware* image aware view} will be reset (set null) before image loading start*/public Builder resetViewBeforeLoading(boolean resetViewBeforeLoading) {this.resetViewBeforeLoading = resetViewBeforeLoading;return this;}/*** Loaded image will be cached in memory** @deprecated Use {@link #cacheInMemory(boolean) cacheInMemory(true)} instead*/@Deprecatedpublic Builder cacheInMemory() {cacheInMemory = true;return this;}/** Sets whether loaded image will be cached in memory */public Builder cacheInMemory(boolean cacheInMemory) {this.cacheInMemory = cacheInMemory;return this;}/*** Loaded image will be cached on disk** @deprecated Use {@link #cacheOnDisk(boolean) cacheOnDisk(true)} instead*/@Deprecatedpublic Builder cacheOnDisc() {return cacheOnDisk(true);}/*** Sets whether loaded image will be cached on disk** @deprecated Use {@link #cacheOnDisk(boolean)} instead*/@Deprecatedpublic Builder cacheOnDisc(boolean cacheOnDisk) {return cacheOnDisk(cacheOnDisk);}/** Sets whether loaded image will be cached on disk */public Builder cacheOnDisk(boolean cacheOnDisk) {this.cacheOnDisk = cacheOnDisk;return this;}/*** Sets {@linkplain ImageScaleType scale type} for decoding image. This parameter is used while define scale* size for decoding image to Bitmap. Default value - {@link ImageScaleType#IN_SAMPLE_POWER_OF_2}*/public Builder imageScaleType(ImageScaleType imageScaleType) {this.imageScaleType = imageScaleType;return this;}/** Sets {@link Bitmap.Config bitmap config} for image decoding. Default value - {@link Bitmap.Config#ARGB_8888} */public Builder bitmapConfig(Bitmap.Config bitmapConfig) {if (bitmapConfig == null) throw new IllegalArgumentException("bitmapConfig can't be null");decodingOptions.inPreferredConfig = bitmapConfig;return this;}/*** Sets options for image decoding. * NOTE: {@link Options#inSampleSize} of incoming options will NOT be considered. Library* calculate the most appropriate sample size itself according yo {@link #imageScaleType(ImageScaleType)}* options. * NOTE: This option overlaps {@link #bitmapConfig(android.graphics.Bitmap.Config) bitmapConfig()}* option.*/public Builder decodingOptions(Options decodingOptions) {if (decodingOptions == null) throw new IllegalArgumentException("decodingOptions can't be null");this.decodingOptions = decodingOptions;return this;}/** Sets delay time before starting loading task. Default - no delay. */public Builder delayBeforeLoading(int delayInMillis) {this.delayBeforeLoading = delayInMillis;return this;}/** Sets auxiliary object which will be passed to {@link ImageDownloader#getStream(String, Object)} */public Builder extraForDownloader(Object extra) {this.extraForDownloader = extra;return this;}/** Sets whether ImageLoader will consider EXIF parameters of JPEG image (rotate, flip) */public Builder considerExifParams(boolean considerExifParams) {this.considerExifParams = considerExifParams;return this;}/*** Sets bitmap processor which will be process bitmaps before they will be cached in memory. So memory cache* will contain bitmap processed by incoming preProcessor. * Image will be pre-processed even if caching in memory is disabled.*/public Builder preProcessor(BitmapProcessor preProcessor) {this.preProcessor = preProcessor;return this;}/*** Sets bitmap processor which will be process bitmaps before they will be displayed in* {@link com.nostra13.universalimageloader.core.imageaware.ImageAware image aware view} but* after they'll have been saved in memory cache.*/public Builder postProcessor(BitmapProcessor postProcessor) {this.postProcessor = postProcessor;return this;}/*** Sets custom {@link BitmapDisplayer displayer} for image loading task. Default value -* {@link DefaultConfigurationFactory#createBitmapDisplayer()}*/public Builder displayer(BitmapDisplayer displayer) {if (displayer == null) throw new IllegalArgumentException("displayer can't be null");this.displayer = displayer;return this;}Builder syncLoading(boolean isSyncLoading) {this.isSyncLoading = isSyncLoading;return this;}/*** Sets custom {@linkplain Handler handler} for displaying images and firing {@linkplain ImageLoadingListener* listener} events.*/public Builder handler(Handler handler) {this.handler = handler;return this;}/** Sets all options equal to incoming options */public Builder cloneFrom(DisplayImageOptions options) {imageResOnLoading = options.imageResOnLoading;imageResForEmptyUri = options.imageResForEmptyUri;imageResOnFail = options.imageResOnFail;imageOnLoading = options.imageOnLoading;imageForEmptyUri = options.imageForEmptyUri;imageOnFail = options.imageOnFail;resetViewBeforeLoading = options.resetViewBeforeLoading;cacheInMemory = options.cacheInMemory;cacheOnDisk = options.cacheOnDisk;imageScaleType = options.imageScaleType;decodingOptions = options.decodingOptions;delayBeforeLoading = options.delayBeforeLoading;considerExifParams = options.considerExifParams;extraForDownloader = options.extraForDownloader;preProcessor = options.preProcessor;postProcessor = options.postProcessor;displayer = options.displayer;handler = options.handler;isSyncLoading = options.isSyncLoading;return this;}/** Builds configured {@link DisplayImageOptions} object */public DisplayImageOptions build() {return new DisplayImageOptions(this);}}/*** Creates options appropriate for single displaying:* <ul>* <li>View will not be reset before loading</li>* <li>Loaded image will not be cached in memory</li>* <li>Loaded image will not be cached on disk</li>* <li>{@link ImageScaleType#IN_SAMPLE_POWER_OF_2} decoding type will be used</li>* <li>{@link Bitmap.Config#ARGB_8888} bitmap config will be used for image decoding</li>* <li>{@link SimpleBitmapDisplayer} will be used for image displaying</li>* </ul>* * These option are appropriate for simple single-use image (from drawables or from Internet) displaying.*/public static DisplayImageOptions createSimple() {return new Builder().build();} }

參考鏈接

http://blog.csdn.net/wangjinyu501/article/details/8091623

https://github.com/nostra13/Android-Universal-Image-Loader

http://www.intexsoft.com/blog/item/74-universal-image-loader-part-3.html

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的Android之Universal-Image-loader的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：工厂模式（简单工厂、工厂方法、抽象工厂）
下一篇： Android之React native