Android教程網
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> 關於Android編程 >> Universal-Image-Loader完全解析

Universal-Image-Loader完全解析

編輯:關於Android編程

  相信大家平時做Android應用的時候,多少會接觸到異步加載圖片,或者加載大量圖片的問題,而加載圖片我們常常會遇到許多的問題,比如說圖片的錯亂,OOM等問題,對於新手來說,這些問題解決起來會比較吃力,所以就有很多的開源圖片加載框架應運而生,比較著名的就是Universal-Image-Loader,相信很多朋友都聽過或者使用過這個強大的圖片加載框架,今天這篇文章就是對這個框架的基本介紹以及使用,主要是幫助那些沒有使用過這個框架的朋友們。該項目存在於Github上面https://github.com/hgl888/Android-Universal-Image-Loader,我們可以先看看這個開源庫存在哪些特征

  多線程下載圖片,圖片可以來源於網絡,文件系統,項目文件夾assets中以及drawable中等支持隨意的配置ImageLoader,例如線程池,圖片下載器,內存緩存策略,硬盤緩存策略,圖片顯示選項以及其他的一些配置支持圖片的內存緩存,文件系統緩存或者SD卡緩存支持圖片下載過程的監聽根據控件(ImageView)的大小對Bitmap進行裁剪,減少Bitmap占用過多的內存較好的控制圖片的加載過程,例如暫停圖片加載,重新開始加載圖片,一般使用在ListView,GridView中,滑動過程中暫停加載圖片,停止滑動的時候去加載圖片提供在較慢的網絡下對圖片進行加載

  當然上面列舉的特性可能不全,要想了解一些其他的特性只能通過我們的使用慢慢去發現了,接下來我們就看看這個開源庫的簡單使用吧

  新建一個Android項目,下載JAR包添加到工程libs目錄下

  新建一個MyApplication繼承Application,並在onCreate()中創建ImageLoader的配置參數,並初始化到ImageLoader中代碼如下

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  packagecom.example.uil;

  importcom.nostra13.universalimageloader.core.ImageLoader;

  importcom.nostra13.universalimageloader.core.ImageLoaderConfiguration;

  importandroid.app.Application;

  publicclassMyApplicationextendsApplication{

  @Override

  publicvoidonCreate(){

  super.onCreate();

  //創建默認的ImageLoader配置參數

  ImageLoaderConfigurationconfiguration=ImageLoaderConfiguration.createDefault(this);

  //InitializeImageLoaderwithconfiguration.

  ImageLoader.getInstance().init(configuration);

  }

  }

  ImageLoaderConfiguration是圖片加載器ImageLoader的配置參數,使用了建造者模式,這裡是直接使用了createDefault()方法創建一個默認的ImageLoaderConfiguration,當然我們還可以自己設置ImageLoaderConfiguration,設置如下

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  FilecacheDir=StorageUtils.getCacheDirectory(context);

  ImageLoaderConfigurationconfig=newImageLoaderConfiguration.Builder(context)

  .memoryCacheExtraOptions(480,800)//default=devicescreendimensions

  .diskCacheExtraOptions(480,800,CompressFormat.JPEG,75,null)

  .taskExecutor(...)

  .taskExecutorForCachedImages(...)

  .threadPoolSize(3)//default

  .threadPriority(Thread.NORM_PRIORITY-1)//default

  .tasksProcessingOrder(QueueProcessingType.FIFO)//default

  .denyCacheImageMultipleSizesInMemory()

  .memoryCache(newLruMemoryCache(2*1024*1024))

  .memoryCacheSize(2*1024*1024)

  .memoryCacheSizePercentage(13)//default

  .diskCache(newUnlimitedDiscCache(cacheDir))//default

  .diskCacheSize(50*1024*1024)

  .diskCacheFileCount(100)

  .diskCacheFileNameGenerator(newHashCodeFileNameGenerator())//default

  .imageDownloader(newBaseImageDownloader(context))//default

  .imageDecoder(newBaseImageDecoder())//default

  .defaultDisplayImageOptions(DisplayImageOptions.createSimple())//default

  .writeDebugLogs()

  .build();

  上面的這些就是所有的選項配置,我們在項目中不需要每一個都自己設置,一般使用createDefault()創建的ImageLoaderConfiguration就能使用,然後調用ImageLoader的init()方法將ImageLoaderConfiguration參數傳遞進去,ImageLoader使用單例模式。

  配置Android Manifest文件

  [html]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  ...

  ...

  接下來我們就可以來加載圖片了,首先我們定義好Activity的布局文件

  [html]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  android:layout_height="fill_parent">

  android:layout_gravity="center"

  android:id="@+id/image"

  android:src="@drawable/ic_empty"

  android:layout_width="wrap_content"

  android:layout_height="wrap_content"/>

  裡面只有一個ImageView,很簡單,接下來我們就去加載圖片,我們會發現ImageLader提供了幾個圖片加載的方法,主要是這幾個displayImage(),loadImage(),loadImageSync(),loadImageSync()方法是同步的,android4.0有個特性,網絡操作不能在主線程,所以loadImageSync()方法我們就不去使用

  .

  loadimage()加載圖片

  我們先使用ImageLoader的loadImage()方法來加載網絡圖片

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  finalImageViewmImageView=(ImageView)findViewById(R.id.image);

  StringimageUrl="http://pic36.nipic.com/20131217/6704106_233034463381_2.jpg";

  ImageLoader.getInstance().loadImage(imageUrl,newImageLoadingListener(){

  @Override

  publicvoidonLoadingStarted(StringimageUri,Viewview){

  }

  @Override

  publicvoidonLoadingFailed(StringimageUri,Viewview,

  FailReasonfailReason){

  }

  @Override

  publicvoidonLoadingComplete(StringimageUri,Viewview,BitmaploadedImage){

  mImageView.setImageBitmap(loadedImage);

  }

  @Override

  publicvoidonLoadingCancelled(StringimageUri,Viewview){

  }

  }); 傳入圖片的url和ImageLoaderListener, 在回調方法onLoadingComplete()中將loadedImage設置到ImageView上面就行了,如果你覺得傳入ImageLoaderListener太復雜了,我們可以使用SimpleImageLoadingListener類,該類提供了ImageLoaderListener接口方法的空實現,使用的是缺省適配器模式

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  finalImageViewmImageView=(ImageView)findViewById(R.id.image);

  StringimageUrl="http://pic36.nipic.com/20131217/6704106_233034463381_2.jpg";

  ImageLoader.getInstance().loadImage(imageUrl,newSimpleImageLoadingListener(){

  @Override

  publicvoidonLoadingComplete(StringimageUri,Viewview,

  BitmaploadedImage){

  super.onLoadingComplete(imageUri,view,loadedImage);

  mImageView.setImageBitmap(loadedImage);

  }

  }); 如果我們要指定圖片的大小該怎麼辦呢,這也好辦,初始化一個ImageSize對象,指定圖片的寬和高,代碼如下

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  finalImageViewmImageView=(ImageView)findViewById(R.id.image);

  StringimageUrl="http://pic36.nipic.com/20131217/6704106_233034463381_2.jpg";

  ImageSizemImageSize=newImageSize(100,100);

  ImageLoader.getInstance().loadImage(imageUrl,mImageSize,newSimpleImageLoadingListener(){

  @Override

  publicvoidonLoadingComplete(StringimageUri,Viewview,

  BitmaploadedImage){

  super.onLoadingComplete(imageUri,view,loadedImage);

  mImageView.setImageBitmap(loadedImage);

  }

  });

  上面只是很簡單的使用ImageLoader來加載網絡圖片,在實際的開發中,我們並不會這麼使用,那我們平常會怎麼使用呢?我們會用到DisplayImageOptions,他可以配置一些圖片顯示的選項,比如圖片在加載中ImageView顯示的圖片,是否需要使用內存緩存,是否需要使用文件緩存等等,可供我們選擇的配置如下

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  DisplayImageOptionsoptions=newDisplayImageOptions.Builder()

  .showImageOnLoading(R.drawable.ic_stub)//resourceordrawable

  .showImageForEmptyUri(R.drawable.ic_empty)//resourceordrawable

  .showImageOnFail(R.drawable.ic_error)//resourceordrawable

  .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(newSimpleBitmapDisplayer())//default

  .handler(newHandler())//default

  .build();

  我們將上面的代碼稍微修改下

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  finalImageViewmImageView=(ImageView)findViewById(R.id.image);

  StringimageUrl="http://pic36.nipic.com/20131217/6704106_233034463381_2.jpg";

  ImageSizemImageSize=newImageSize(100,100);

  //顯示圖片的配置

  DisplayImageOptionsoptions=newDisplayImageOptions.Builder()

  .showImageOnLoading(R.drawable.ic_stub)

  .showImageForEmptyUri(R.drawable.ic_empty)

  .showImageOnFail(R.drawable.ic_error)

  .cacheInMemory(true)

  .cacheOnDisk(true)

  .considerExifParams(true)

  .bitmapConfig(Bitmap.Config.RGB_565)

  .build();

  ImageLoader.getInstance().loadImage(imageUrl,mImageSize,options,newSimpleImageLoadingListener(){

  @Override

  publicvoidonLoadingComplete(StringimageUri,Viewview,

  BitmaploadedImage){

  super.onLoadingComplete(imageUri,view,loadedImage);

  mImageView.setImageBitmap(loadedImage);

  }

  });

  我們使用了DisplayImageOptions來配置顯示圖片的一些選項,這裡我添加了將圖片緩存到內存中已經緩存圖片到文件系統中,這樣我們就不用擔心每次都從網絡中去加載圖片了,是不是很方便呢,但是DisplayImageOptions選項中有些選項對於loadImage()方法是無效的,比如showImageOnLoading,showImageForEmptyUri等,

  displayImage()加載圖片

  接下來我們就來看看網絡圖片加載的另一個方法displayImage(),代碼如下

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  finalImageViewmImageView=(ImageView)findViewById(R.id.image);

  StringimageUrl="http://pic36.nipic.com/20131217/6704106_233034463381_2.jpg";

  //顯示圖片的配置

  DisplayImageOptionsoptions=newDisplayImageOptions.Builder()

  .showImageOnLoading(R.drawable.ic_stub)

  .showImageOnFail(R.drawable.ic_error)

  .cacheInMemory(true)

  .cacheOnDisk(true)

  .bitmapConfig(Bitmap.Config.RGB_565)

  .build();

  ImageLoader.getInstance().displayImage(imageUrl,mImageView,options);

  從上面的代碼中,我們可以看出,使用displayImage()比使用loadImage()方便很多,也不需要添加ImageLoadingListener接口,我們也不需要手動設置ImageView顯示Bitmap對象,直接將ImageView作為參數傳遞到displayImage()中就行了,圖片顯示的配置選項中,我們添加了一個圖片加載中ImageVIew上面顯示的圖片,以及圖片加載出現錯誤顯示的圖片,效果如下,剛開始顯示ic_stub圖片,如果圖片加載成功顯示圖片,加載產生錯誤顯示ic_error

  

\
\

 

  這個方法使用起來比較方便,而且使用displayImage()方法 他會根據控件的大小和imageScaleType來自動裁剪圖片,我們修改下MyApplication,開啟Log打印

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  publicclassMyApplicationextendsApplication{

  @Override

  publicvoidonCreate(){

  super.onCreate();

  //創建默認的ImageLoader配置參數

  ImageLoaderConfigurationconfiguration=newImageLoaderConfiguration.Builder(this)

  .writeDebugLogs()//打印log信息

  .build();

  //InitializeImageLoaderwithconfiguration.

  ImageLoader.getInstance().init(configuration);

  }

  }

  我們來看下圖片加載的Log信息

  

\

 

  第一條信息中,告訴我們開始加載圖片,打印出圖片的url以及圖片的最大寬度和高度,圖片的寬高默認是設備的寬高,當然如果我們很清楚圖片的大小,我們也可以去設置這個大小,在ImageLoaderConfiguration的選項中memoryCacheExtraOptions(int maxImageWidthForMemoryCache, int maxImageHeightForMemoryCache)

  第二條信息顯示我們加載的圖片來源於網絡

  第三條信息顯示圖片的原始大小為1024 x 682 經過裁剪變成了512 x 341

  第四條顯示圖片加入到了內存緩存中,我這裡沒有加入到sd卡中,所以沒有加入文件緩存的Log

  我們在加載網絡圖片的時候,經常有需要顯示圖片下載進度的需求,Universal-Image-Loader當然也提供這樣的功能,只需要在displayImage()方法中傳入ImageLoadingProgressListener接口就行了,代碼如下

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  imageLoader.displayImage(imageUrl,mImageView,options,newSimpleImageLoadingListener(),newImageLoadingProgressListener(){

  @Override

  publicvoidonProgressUpdate(StringimageUri,Viewview,intcurrent,

  inttotal){

  }

  }); 由於displayImage()方法中帶ImageLoadingProgressListener參數的方法都有帶ImageLoadingListener參數,所以我這裡直接new 一個SimpleImageLoadingListener,然後我們就可以在回調方法onProgressUpdate()得到圖片的加載進度。

  加載其他來源的圖片

  使用Universal-Image-Loader框架不僅可以加載網絡圖片,還可以加載sd卡中的圖片,Content provider等,使用也很簡單,只是將圖片的url稍加的改變下就行了,下面是加載文件系統的圖片

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  //顯示圖片的配置

  DisplayImageOptionsoptions=newDisplayImageOptions.Builder()

  .showImageOnLoading(R.drawable.ic_stub)

  .showImageOnFail(R.drawable.ic_error)

  .cacheInMemory(true)

  .cacheOnDisk(true)

  .bitmapConfig(Bitmap.Config.RGB_565)

  .build();

  finalImageViewmImageView=(ImageView)findViewById(R.id.image);

  StringimagePath="/mnt/sdcard/image.png";

  StringimageUrl=Scheme.FILE.wrap(imagePath);

  //StringimageUrl="http://img.my.csdn.net/uploads/201309/01/1378037235_7476.jpg";

  imageLoader.displayImage(imageUrl,mImageView,options); 當然還有來源於Content provider,drawable,assets中,使用的時候也很簡單,我們只需要給每個圖片來源的地方加上Scheme包裹起來(Content provider除外),然後當做圖片的url傳遞到imageLoader中,Universal-Image-Loader框架會根據不同的Scheme獲取到輸入流

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  //圖片來源於Contentprovider

  StringcontentprividerUrl="content://media/external/audio/albumart/13";

  //圖片來源於assets

  StringassetsUrl=Scheme.ASSETS.wrap("image.png");

  //圖片來源於

  StringdrawableUrl=Scheme.DRAWABLE.wrap("R.drawable.image");

  GirdView,ListView加載圖片

  相信大部分人都是使用GridView,ListView來顯示大量的圖片,而當我們快速滑動GridView,ListView,我們希望能停止圖片的加載,而在GridView,ListView停止滑動的時候加載當前界面的圖片,這個框架當然也提供這個功能,使用起來也很簡單,它提供了PauseOnScrollListener這個類來控制ListView,GridView滑動過程中停止去加載圖片,該類使用的是代理模式

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  listView.setOnScrollListener(newPauseOnScrollListener(imageLoader,pauseOnScroll,pauseOnFling));

  gridView.setOnScrollListener(newPauseOnScrollListener(imageLoader,pauseOnScroll,pauseOnFling)); 第一個參數就是我們的圖片加載對象ImageLoader, 第二個是控制是否在滑動過程中暫停加載圖片,如果需要暫停傳true就行了,第三個參數控制猛的滑動界面的時候圖片是否加載

  OutOfMemoryError

  雖然這個框架有很好的緩存機制,有效的避免了OOM的產生,一般的情況下產生OOM的概率比較小,但是並不能保證OutOfMemoryError永遠不發生,這個框架對於OutOfMemoryError做了簡單的catch,保證我們的程序遇到OOM而不被crash掉,但是如果我們使用該框架經常發生OOM,我們應該怎麼去改善呢?

  減少線程池中線程的個數,在ImageLoaderConfiguration中的(.threadPoolSize)中配置,推薦配置1-5在DisplayImageOptions選項中配置bitmapConfig為Bitmap.Config.RGB_565,因為默認是ARGB_8888, 使用RGB_565會比使用ARGB_8888少消耗2倍的內存在ImageLoaderConfiguration中配置圖片的內存緩存為memoryCache(new WeakMemoryCache()) 或者不使用內存緩存在DisplayImageOptions選項中設置.imageScaleType(ImageScaleType.IN_SAMPLE_INT)或者imageScaleType(ImageScaleType.EXACTLY)

  通過上面這些,相信大家對Universal-Image-Loader框架的使用已經非常的了解了,我們在使用該框架的時候盡量的使用displayImage()方法去加載圖片,loadImage()是將圖片對象回調到ImageLoadingListener接口的onLoadingComplete()方法中,需要我們手動去設置到ImageView上面,displayImage()方法中,對ImageView對象使用的是Weak references,方便垃圾回收器回收ImageView對象,如果我們要加載固定大小的圖片的時候,使用loadImage()方法需要傳遞一個ImageSize對象,而displayImage()方法會根據ImageView對象的測量值,或者android:layout_width and android:layout_height設定的值,或者android:maxWidth and/or android:maxHeight設定的值來裁剪圖片

  繼續為大家介紹Universal-Image-Loader這個開源的圖片加載框架,介紹的是圖片緩存策略方面的,我們一般去加載大量的圖片的時候,都會做緩存策略,緩存又分為內存緩存和硬盤緩存,使用的內存緩存是LruCache這個類,LRU是Least Recently Used 近期最少使用算法,我們可以給LruCache設定一個緩存圖片的最大值,它會自動幫我們管理好緩存的圖片總大小是否超過我們設定的值, 超過就刪除近期最少使用的圖片,而作為一個強大的圖片加載框架,Universal-Image-Loader自然也提供了多種圖片的緩存策略,下面就來詳細的介紹下

  內存緩存

  首先我們來了解下什麼是強引用和什麼是弱引用?

  強引用是指創建一個對象並把這個對象賦給一個引用變量,強引用有引用變量指向時永遠不會被垃圾回收。即使內存不足的時候寧願報OOM也不被垃圾回收器回收,我們new的對象都是強引用

  弱引用通過weakReference類來實現,它具有很強的不確定性,如果垃圾回收器掃描到有著WeakReference的對象,就會將其回收釋放內存

  現在我們來看Universal-Image-Loader有哪些內存緩存策略

  1. 只使用的是強引用緩存

  LruMemoryCache(這個類就是這個開源框架默認的內存緩存類,緩存的是bitmap的強引用,下面我會從源碼上面分析這個類)

  2.使用強引用和弱引用相結合的緩存有

  UsingFreqLimitedMemoryCache(如果緩存的圖片總量超過限定值,先刪除使用頻率最小的bitmap)LRULimitedMemoryCache(這個也是使用的lru算法,和LruMemoryCache不同的是,他緩存的是bitmap的弱引用)FIFOLimitedMemoryCache(先進先出的緩存策略,當超過設定值,先刪除最先加入緩存的bitmap)LargestLimitedMemoryCache(當超過緩存限定值,先刪除最大的bitmap對象)LimitedAgeMemoryCache(當 bitmap加入緩存中的時間超過我們設定的值,將其刪除)

  3.只使用弱引用緩存

  WeakMemoryCache(這個類緩存bitmap的總大小沒有限制,唯一不足的地方就是不穩定,緩存的圖片容易被回收掉)

  上面介紹了Universal-Image-Loader所提供的所有的內存緩存的類,當然我們也可以使用我們自己寫的內存緩存類,我們還要看看要怎麼將這些內存緩存加入到我們的項目中,我們只需要配置ImageLoaderConfiguration.memoryCache(...),如下

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  ImageLoaderConfigurationconfiguration=newImageLoaderConfiguration.Builder(this)

  .memoryCache(newWeakMemoryCache())

  .build();

  下面我們來分析LruMemoryCache這個類的源代碼

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  packagecom.nostra13.universalimageloader.cache.memory.impl;

  importandroid.graphics.Bitmap;

  importcom.nostra13.universalimageloader.cache.memory.MemoryCacheAware;

  importjava.util.Collection;

  importjava.util.HashSet;

  importjava.util.LinkedHashMap;

  importjava.util.Map;

  /**

  *AcachethatholdsstrongreferencestoalimitednumberofBitmaps.EachtimeaBitmapisaccessed,itismovedto

  *theheadofaqueue.WhenaBitmapisaddedtoafullcache,theBitmapattheendofthatqueueisevictedandmay

  *becomeeligibleforgarbagecollection.

  *

  *NOTE:ThiscacheusesonlystrongreferencesforstoredBitmaps.

  *

  *@authorSergeyTarasevich(nostra13[at]gmail[dot]com)

  *@since1.8.1

  */

  publicclassLruMemoryCacheimplementsMemoryCacheAware{

  privatefinalLinkedHashMapmap;

  privatefinalintmaxSize;

  /**Sizeofthiscacheinbytes*/

  privateintsize;

  /**@parammaxSizeMaximumsumofthesizesoftheBitmapsinthiscache*/

  publicLruMemoryCache(intmaxSize){

  if(maxSize<=0){

  thrownewIllegalArgumentException("maxSize<=0");

  }

  this.maxSize=maxSize;

  this.map=newLinkedHashMap(0,0.75f,true);

  }

  /**

  *ReturnstheBitmapfor{@codekey}ifitexistsinthecache.IfaBitmapwasreturned,itismovedtothehead

  *ofthequeue.ThisreturnsnullifaBitmapisnotcached.

  */

  @Override

  publicfinalBitmapget(Stringkey){

  if(key==null){

  thrownewNullPointerException("key==null");

  }

  synchronized(this){

  returnmap.get(key);

  }

  }

  /**Caches{@codeBitmap}for{@codekey}.TheBitmapismovedtotheheadofthequeue.*/

  @Override

  publicfinalbooleanput(Stringkey,Bitmapvalue){

  if(key==null||value==null){

  thrownewNullPointerException("key==null||value==null");

  }

  synchronized(this){

  size+=sizeOf(key,value);

  Bitmapprevious=map.put(key,value);

  if(previous!=null){

  size-=sizeOf(key,previous);

  }

  }

  trimToSize(maxSize);

  returntrue;

  }

  /**

  *Removetheeldestentriesuntilthetotalofremainingentriesisatorbelowtherequestedsize.

  *

  *@parammaxSizethemaximumsizeofthecachebeforereturning.Maybe-1toevicteven0-sizedelements.

  */

  privatevoidtrimToSize(intmaxSize){

  while(true){

  Stringkey;

  Bitmapvalue;

  synchronized(this){

  if(size<0||(map.isEmpty()&&size!=0)){

  thrownewIllegalStateException(getClass().getName()+".sizeOf()isreportinginconsistentresults!");

  }

  if(size<=maxSize||map.isEmpty()){

  break;

  }

  Map.EntrytoEvict=map.entrySet().iterator().next();

  if(toEvict==null){

  break;

  }

  key=toEvict.getKey();

  value=toEvict.getValue();

  map.remove(key);

  size-=sizeOf(key,value);

  }

  }

  }

  /**Removestheentryfor{@codekey}ifitexists.*/

  @Override

  publicfinalvoidremove(Stringkey){

  if(key==null){

  thrownewNullPointerException("key==null");

  }

  synchronized(this){

  Bitmapprevious=map.remove(key);

  if(previous!=null){

  size-=sizeOf(key,previous);

  }

  }

  }

  @Override

  publicCollectionkeys(){

  synchronized(this){

  returnnewHashSet(map.keySet());

  }

  }

  @Override

  publicvoidclear(){

  trimToSize(-1);//-1willevict0-sizedelements

  }

  /**

  *Returnsthesize{@codeBitmap}inbytes.

  *

  *Anentry'ssizemustnotchangewhileitisinthecache.

  */

  privateintsizeOf(Stringkey,Bitmapvalue){

  returnvalue.getRowBytes()*value.getHeight();

  }

  @Override

  publicsynchronizedfinalStringtoString(){

  returnString.format("LruCache[maxSize=%d]",maxSize);

  }

  } 我們可以看到這個類中維護的是一個LinkedHashMap,在LruMemoryCache構造函數中我們可以看到,我們為其設置了一個緩存圖片的最大值maxSize,並實例化LinkedHashMap, 而從LinkedHashMap構造函數的第三個參數為ture,表示它是按照訪問順序進行排序的,

  我們來看將bitmap加入到LruMemoryCache的方法put(String key, Bitmap value), 第61行,sizeOf()是計算每張圖片所占的byte數,size是記錄當前緩存bitmap的總大小,如果該key之前就緩存了bitmap,我們需要將之前的bitmap減掉去,接下來看trimToSize()方法,我們直接看86行,如果當前緩存的bitmap總數小於設定值maxSize,不做任何處理,如果當前緩存的bitmap總數大於maxSize,刪除LinkedHashMap中的第一個元素,size中減去該bitmap對應的byte數

  我們可以看到該緩存類比較簡單,邏輯也比較清晰,如果大家想知道其他內存緩存的邏輯,可以去分析分析其源碼,在這裡我簡單說下FIFOLimitedMemoryCache的實現邏輯,該類使用的HashMap來緩存bitmap的弱引用,然後使用LinkedList來保存成功加入到FIFOLimitedMemoryCache的bitmap的強引用,如果加入的FIFOLimitedMemoryCache的bitmap總數超過限定值,直接刪除LinkedList的第一個元素,所以就實現了先進先出的緩存策略,其他的緩存都類似,有興趣的可以去看看。

  硬盤緩存

  在新版本中,使用LruDiscCache代替LimitedAgeDiscCache,TotalSizeLimitedDiscCache,FileCountLimitedDiscCache

  下面我們就來分析分析BaseDiscCache的源碼實現

  /*******************************************************************************

  * Copyright 2011-2014 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.cache.disc.impl;

  import android.graphics.Bitmap;

  import com.nostra13.universalimageloader.cache.disc.DiskCache;

  import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator;

  import com.nostra13.universalimageloader.core.DefaultConfigurationFactory;

  import com.nostra13.universalimageloader.utils.IoUtils;

  import java.io.BufferedOutputStream;

  import java.io.File;

  import java.io.FileOutputStream;

  import java.io.IOException;

  import java.io.InputStream;

  import java.io.OutputStream;

  /**

  * Base disk cache.

  *

  * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)

  * @see FileNameGenerator

  * @since 1.0.0

  */

  public abstract class BaseDiskCache implements DiskCache {

  /** {@value */

  public static final int DEFAULT_BUFFER_SIZE = 32 * 1024; // 32 Kb

  /** {@value */

  public static final Bitmap.CompressFormat DEFAULT_COMPRESS_FORMAT = Bitmap.CompressFormat.PNG;

  /** {@value */

  public static final int DEFAULT_COMPRESS_QUALITY = 100;

  private static final String ERROR_ARG_NULL = " argument must be not null";

  private static final String TEMP_IMAGE_POSTFIX = ".tmp";

  protected final File cacheDir;

  protected final File reserveCacheDir;

  protected final FileNameGenerator fileNameGenerator;

  protected int bufferSize = DEFAULT_BUFFER_SIZE;

  protected Bitmap.CompressFormat compressFormat = DEFAULT_COMPRESS_FORMAT;

  protected int compressQuality = DEFAULT_COMPRESS_QUALITY;

  /** @param cacheDir Directory for file caching */

  public BaseDiskCache(File cacheDir) {

  this(cacheDir, null);

  }

  /**

  * @param cacheDir Directory for file caching

  * @param reserveCacheDir null-ok; Reserve directory for file caching. It's used when the primary directory isn't available.

  */

  public BaseDiskCache(File cacheDir, File reserveCacheDir) {

  this(cacheDir, reserveCacheDir, DefaultConfigurationFactory.createFileNameGenerator());

  }

  /**

  * @param cacheDir Directory for file caching

  * @param reserveCacheDir null-ok; Reserve directory for file caching. It's used when the primary directory isn't available.

  * @param fileNameGenerator {@linkplain com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator

  * Name generator} for cached files

  */

  public BaseDiskCache(File cacheDir, File reserveCacheDir, FileNameGenerator fileNameGenerator) {

  if (cacheDir == null) {

  throw new IllegalArgumentException("cacheDir" + ERROR_ARG_NULL);

  }

  if (fileNameGenerator == null) {

  throw new IllegalArgumentException("fileNameGenerator" + ERROR_ARG_NULL);

  }

  this.cacheDir = cacheDir;

  this.reserveCacheDir = reserveCacheDir;

  this.fileNameGenerator = fileNameGenerator;

  }

  @Override

  public File getDirectory() {

  return cacheDir;

  }

  @Override

  public File get(String imageUri) {

  return getFile(imageUri);

  }

  @Override

  public boolean save(String imageUri, InputStream imageStream, IoUtils.CopyListener listener) throws IOException {

  File imageFile = getFile(imageUri);

  File tmpFile = new File(imageFile.getAbsolutePath() + TEMP_IMAGE_POSTFIX);

  boolean loaded = false;

  try {

  OutputStream os = new BufferedOutputStream(new FileOutputStream(tmpFile), bufferSize);

  try {

  loaded = IoUtils.copyStream(imageStream, os, listener, bufferSize);

  } finally {

  IoUtils.closeSilently(os);

  }

  } finally {

  if (loaded && !tmpFile.renameTo(imageFile)) {

  loaded = false;

  }

  if (!loaded) {

  tmpFile.delete();

  }

  }

  return loaded;

  }

  @Override

  public boolean save(String imageUri, Bitmap bitmap) throws IOException {

  File imageFile = getFile(imageUri);

  File tmpFile = new File(imageFile.getAbsolutePath() + TEMP_IMAGE_POSTFIX);

  OutputStream os = new BufferedOutputStream(new FileOutputStream(tmpFile), bufferSize);

  boolean savedSuccessfully = false;

  try {

  savedSuccessfully = bitmap.compress(compressFormat, compressQuality, os);

  } finally {

  IoUtils.closeSilently(os);

  if (savedSuccessfully && !tmpFile.renameTo(imageFile)) {

  savedSuccessfully = false;

  }

  if (!savedSuccessfully) {

  tmpFile.delete();

  }

  }

  bitmap.recycle();

  return savedSuccessfully;

  }

  @Override

  public boolean remove(String imageUri) {

  return getFile(imageUri).delete();

  }

  @Override

  public void close() {

  // Nothing to do

  }

  @Override

  public void clear() {

  File[] files = cacheDir.listFiles();

  if (files != null) {

  for (File f : files) {

  f.delete();

  }

  }

  }

  /** Returns file object (not null) for incoming image URI. File object can reference to non-existing file. */

  protected File getFile(String imageUri) {

  String fileName = fileNameGenerator.generate(imageUri);

  File dir = cacheDir;

  if (!cacheDir.exists() && !cacheDir.mkdirs()) {

  if (reserveCacheDir != null && (reserveCacheDir.exists() || reserveCacheDir.mkdirs())) {

  dir = reserveCacheDir;

  }

  }

  return new File(dir, fileName);

  }

  public void setBufferSize(int bufferSize) {

  this.bufferSize = bufferSize;

  }

  public void setCompressFormat(Bitmap.CompressFormat compressFormat) {

  this.compressFormat = compressFormat;

  }

  public void setCompressQuality(int compressQuality) {

  this.compressQuality = compressQuality;

  }

  }

  下面主要從源碼的角度上面去解讀這個強大的圖片加載框架,

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  ImageViewmImageView=(ImageView)findViewById(R.id.image);

  StringimageUrl="http://pic36.nipic.com/20131217/6704106_233034463381_2.jpg";

  //顯示圖片的配置

  DisplayImageOptionsoptions=newDisplayImageOptions.Builder()

  .showImageOnLoading(R.drawable.ic_stub)

  .showImageOnFail(R.drawable.ic_error)

  .cacheInMemory(true)

  .cacheOnDisk(true)

  .bitmapConfig(Bitmap.Config.RGB_565)

  .build();

  ImageLoader.getInstance().displayImage(imageUrl,mImageView,options); 大部分的時候我們都是使用上面的代碼去加載圖片,我們先看下

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  publicvoiddisplayImage(Stringuri,ImageViewimageView,DisplayImageOptionsoptions){

  displayImage(uri,newImageViewAware(imageView),options,null,null);

  } 從上面的代碼中,我們可以看出,它會將ImageView轉換成ImageViewAware, ImageViewAware主要是做什麼的呢?該類主要是將ImageView進行一個包裝,將ImageView的強引用變成弱引用,當內存不足的時候,可以更好的回收ImageView對象,還有就是獲取ImageView的寬度和高度。這使得我們可以根據ImageView的寬高去對圖片進行一個裁剪,減少內存的使用。

  接下來看具體的displayImage方法啦,由於這個方法代碼量蠻多的,所以這裡我分開來讀

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  checkConfiguration();

  if(imageAware==null){

  thrownewIllegalArgumentException(ERROR_WRONG_ARGUMENTS);

  }

  if(listener==null){

  listener=emptyListener;

  }

  if(options==null){

  options=configuration.defaultDisplayImageOptions;

  }

  if(TextUtils.isEmpty(uri)){

  engine.cancelDisplayTaskFor(imageAware);

  listener.onLoadingStarted(uri,imageAware.getWrappedView());

  if(options.shouldShowImageForEmptyUri()){

  imageAware.setImageDrawable(options.getImageForEmptyUri(configuration.resources));

  }else{

  imageAware.setImageDrawable(null);

  }

  listener.onLoadingComplete(uri,imageAware.getWrappedView(),null);

  return;

  } 第1行代碼是檢查ImageLoaderConfiguration是否初始化,這個初始化是在Application中進行的

  12-21行主要是針對url為空的時候做的處理,第13行代碼中,ImageLoaderEngine中存在一個HashMap,用來記錄正在加載的任務,加載圖片的時候會將ImageView的id和圖片的url加上尺寸加入到HashMap中,加載完成之後會將其移除,然後將DisplayImageOptions的imageResForEmptyUri的圖片設置給ImageView,最後回調給ImageLoadingListener接口告訴它這次任務完成了。

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  ImageSizetargetSize=ImageSizeUtils.defineTargetSizeForView(imageAware,configuration.getMaxImageSize());

  StringmemoryCacheKey=MemoryCacheUtils.generateKey(uri,targetSize);

  engine.prepareDisplayTaskFor(imageAware,memoryCacheKey);

  listener.onLoadingStarted(uri,imageAware.getWrappedView());

  Bitmapbmp=configuration.memoryCache.get(memoryCacheKey);

  if(bmp!=null&&!bmp.isRecycled()){

  L.d(LOG_LOAD_IMAGE_FROM_MEMORY_CACHE,memoryCacheKey);

  if(options.shouldPostProcess()){

  ImageLoadingInfoimageLoadingInfo=newImageLoadingInfo(uri,imageAware,targetSize,memoryCacheKey,

  options,listener,progressListener,engine.getLockForUri(uri));

  ProcessAndDisplayImageTaskdisplayTask=newProcessAndDisplayImageTask(engine,bmp,imageLoadingInfo,

  defineHandler(options));

  if(options.isSyncLoading()){

  displayTask.run();

  }else{

  engine.submit(displayTask);

  }

  }else{

  options.getDisplayer().display(bmp,imageAware,LoadedFrom.MEMORY_CACHE);

  listener.onLoadingComplete(uri,imageAware.getWrappedView(),bmp);

  }

  } 第1行主要是將ImageView的寬高封裝成ImageSize對象,如果獲取ImageView的寬高為0,就會使用手機屏幕的寬高作為ImageView的寬高,我們在使用ListView,GridView去加載圖片的時候,第一頁獲取寬度是0,所以第一頁使用的手機的屏幕寬高,後面的獲取的都是控件本身的大小了

  第7行從內存緩存中獲取Bitmap對象,我們可以再ImageLoaderConfiguration中配置內存緩存邏輯,默認使用的是LruMemoryCache,這個類我在前面的文章中講過

  第11行中有一個判斷,我們如果在DisplayImageOptions中設置了postProcessor就進入true邏輯,不過默認postProcessor是為null的,BitmapProcessor接口主要是對Bitmap進行處理,這個框架並沒有給出相對應的實現,如果我們有自己的需求的時候可以自己實現BitmapProcessor接口(比如將圖片設置成圓形的)

  第22 -23行是將Bitmap設置到ImageView上面,這裡我們可以在DisplayImageOptions中配置顯示需求displayer,默認使用的是SimpleBitmapDisplayer,直接將Bitmap設置到ImageView上面,我們可以配置其他的顯示邏輯, 他這裡提供了FadeInBitmapDisplayer(透明度從0-1)RoundedBitmapDisplayer(4個角是圓弧)等, 然後回調到ImageLoadingListener接口

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  if(options.shouldShowImageOnLoading()){

  imageAware.setImageDrawable(options.getImageOnLoading(configuration.resources));

  }elseif(options.isResetViewBeforeLoading()){

  imageAware.setImageDrawable(null);

  }

  ImageLoadingInfoimageLoadingInfo=newImageLoadingInfo(uri,imageAware,targetSize,memoryCacheKey,

  options,listener,progressListener,engine.getLockForUri(uri));

  LoadAndDisplayImageTaskdisplayTask=newLoadAndDisplayImageTask(engine,imageLoadingInfo,

  defineHandler(options));

  if(options.isSyncLoading()){

  displayTask.run();

  }else{

  engine.submit(displayTask);

  } 這段代碼主要是Bitmap不在內存緩存,從文件中或者網絡裡面獲取bitmap對象,實例化一個LoadAndDisplayImageTask對象,LoadAndDisplayImageTask實現了Runnable,如果配置了isSyncLoading為true, 直接執行LoadAndDisplayImageTask的run方法,表示同步,默認是false,將LoadAndDisplayImageTask提交給線程池對象

  接下來我們就看LoadAndDisplayImageTask的run(), 這個類還是蠻復雜的,我們還是一段一段的分析

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  if(waitIfPaused())return;

  if(delayIfNeed())return;

  如果waitIfPaused(), delayIfNeed()返回true的話,直接從run()方法中返回了,不執行下面的邏輯, 接下來我們先看看waitIfPaused()

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  privatebooleanwaitIfPaused(){

  AtomicBooleanpause=engine.getPause();

  if(pause.get()){

  synchronized(engine.getPauseLock()){

  if(pause.get()){

  L.d(LOG_WAITING_FOR_RESUME,memoryCacheKey);

  try{

  engine.getPauseLock().wait();

  }catch(InterruptedExceptione){

  L.e(LOG_TASK_INTERRUPTED,memoryCacheKey);

  returntrue;

  }

  L.d(LOG_RESUME_AFTER_PAUSE,memoryCacheKey);

  }

  }

  }

  returnisTaskNotActual();

  }

  這個方法是干嘛用呢,主要是我們在使用ListView,GridView去加載圖片的時候,有時候為了滑動更加的流暢,我們會選擇手指在滑動或者猛地一滑動的時候不去加載圖片,所以才提出了這麼一個方法,那麼要怎麼用呢? 這裡用到了PauseOnScrollListener這個類,使用很簡單ListView.setOnScrollListener(newPauseOnScrollListener(pauseOnScroll, pauseOnFling)),pauseOnScroll控制我們緩慢滑動ListView,GridView是否停止加載圖片,pauseOnFling 控制猛的滑動ListView,GridView是否停止加載圖片

  除此之外,這個方法的返回值由isTaskNotActual()決定,我們接著看看isTaskNotActual()的源碼

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  privatebooleanisTaskNotActual(){

  returnisViewCollected()||isViewReused();

  } isViewCollected()是判斷我們ImageView是否被垃圾回收器回收了,如果回收了,LoadAndDisplayImageTask方法的run()就直接返回了,isViewReused()判斷該ImageView是否被重用,被重用run()方法也直接返回,為什麼要用isViewReused()方法呢?主要是ListView,GridView我們會復用item對象,假如我們先去加載ListView,GridView第一頁的圖片的時候,第一頁圖片還沒有全部加載完我們就快速的滾動,isViewReused()方法就會避免這些不可見的item去加載圖片,而直接加載當前界面的圖片[java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  ReentrantLockloadFromUriLock=imageLoadingInfo.loadFromUriLock;

  L.d(LOG_START_DISPLAY_IMAGE_TASK,memoryCacheKey);

  if(loadFromUriLock.isLocked()){

  L.d(LOG_WAITING_FOR_IMAGE_LOADED,memoryCacheKey);

  }

  loadFromUriLock.lock();

  Bitmapbmp;

  try{

  checkTaskNotActual();

  bmp=configuration.memoryCache.get(memoryCacheKey);

  if(bmp==null||bmp.isRecycled()){

  bmp=tryLoadBitmap();

  if(bmp==null)return;//listenercallbackalreadywasfired

  checkTaskNotActual();

  checkTaskInterrupted();

  if(options.shouldPreProcess()){

  L.d(LOG_PREPROCESS_IMAGE,memoryCacheKey);

  bmp=options.getPreProcessor().process(bmp);

  if(bmp==null){

  L.e(ERROR_PRE_PROCESSOR_NULL,memoryCacheKey);

  }

  }

  if(bmp!=null&&options.isCacheInMemory()){

  L.d(LOG_CACHE_IMAGE_IN_MEMORY,memoryCacheKey);

  configuration.memoryCache.put(memoryCacheKey,bmp);

  }

  }else{

  loadedFrom=LoadedFrom.MEMORY_CACHE;

  L.d(LOG_GET_IMAGE_FROM_MEMORY_CACHE_AFTER_WAITING,memoryCacheKey);

  }

  if(bmp!=null&&options.shouldPostProcess()){

  L.d(LOG_POSTPROCESS_IMAGE,memoryCacheKey);

  bmp=options.getPostProcessor().process(bmp);

  if(bmp==null){

  L.e(ERROR_POST_PROCESSOR_NULL,memoryCacheKey);

  }

  }

  checkTaskNotActual();

  checkTaskInterrupted();

  }catch(TaskCancelledExceptione){

  fireCancelEvent();

  return;

  }finally{

  loadFromUriLock.unlock();

  } 第1行代碼有一個loadFromUriLock,這個是一個鎖,獲取鎖的方法在ImageLoaderEngine類的getLockForUri()方法中[java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  ReentrantLockgetLockForUri(Stringuri){

  ReentrantLocklock=uriLocks.get(uri);

  if(lock==null){

  lock=newReentrantLock();

  uriLocks.put(uri,lock);

  }

  returnlock;

  } 從上面可以看出,這個鎖對象與圖片的url是相互對應的,為什麼要這麼做?也行你還有點不理解,不知道大家有沒有考慮過一個場景,假如在一個ListView中,某個item正在獲取圖片的過程中,而此時我們將這個item滾出界面之後又將其滾進來,滾進來之後如果沒有加鎖,該item又會去加載一次圖片,假設在很短的時間內滾動很頻繁,那麼就會出現多次去網絡上面請求圖片,所以這裡根據圖片的Url去對應一個ReentrantLock對象,讓具有相同Url的請求就會在第7行等待,等到這次圖片加載完成之後,ReentrantLock就被釋放,剛剛那些相同Url的請求就會繼續執行第7行下面的代碼

  來到第12行,它們會先從內存緩存中獲取一遍,如果內存緩存中沒有在去執行下面的邏輯,所以ReentrantLock的作用就是避免這種情況下重復的去從網絡上面請求圖片。

  第14行的方法tryLoadBitmap(),這個方法確實也有點長,我先告訴大家,這裡面的邏輯是先從文件緩存中獲取有沒有Bitmap對象,如果沒有在去從網絡中獲取,然後將bitmap保存在文件系統中,我們還是具體分析下

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  FileimageFile=configuration.diskCache.get(uri);

  if(imageFile!=null&&imageFile.exists()){

  L.d(LOG_LOAD_IMAGE_FROM_DISK_CACHE,memoryCacheKey);

  loadedFrom=LoadedFrom.DISC_CACHE;

  checkTaskNotActual();

  bitmap=decodeImage(Scheme.FILE.wrap(imageFile.getAbsolutePath()));

  } 先判斷文件緩存中有沒有該文件,如果有的話,直接去調用decodeImage()方法去解碼圖片,該方法裡面調用BaseImageDecoder類的decode()方法,根據ImageView的寬高,ScaleType去裁剪圖片,具體的代碼我就不介紹了,大家自己去看看,我們接下往下看tryLoadBitmap()方法

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  if(bitmap==null||bitmap.getWidth()<=0||bitmap.getHeight()<=0){

  L.d(LOG_LOAD_IMAGE_FROM_NETWORK,memoryCacheKey);

  loadedFrom=LoadedFrom.NETWORK;

  StringimageUriForDecoding=uri;

  if(options.isCacheOnDisk()&&tryCacheImageOnDisk()){

  imageFile=configuration.diskCache.get(uri);

  if(imageFile!=null){

  imageUriForDecoding=Scheme.FILE.wrap(imageFile.getAbsolutePath());

  }

  }

  checkTaskNotActual();

  bitmap=decodeImage(imageUriForDecoding);

  if(bitmap==null||bitmap.getWidth()<=0||bitmap.getHeight()<=0){

  fireFailEvent(FailType.DECODING_ERROR,null);

  }

  } 第1行表示從文件緩存中獲取的Bitmap為null,或者寬高為0,就去網絡上面獲取Bitmap,來到第6行代碼是否配置了DisplayImageOptions的isCacheOnDisk,表示是否需要將Bitmap對象保存在文件系統中,一般我們需要配置為true, 默認是false這個要注意下,然後就是執行tryCacheImageOnDisk()方法,去服務器上面拉取圖片並保存在本地文件中

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  privateBitmapdecodeImage(StringimageUri)throwsIOException{

  ViewScaleTypeviewScaleType=imageAware.getScaleType();

  ImageDecodingInfodecodingInfo=newImageDecodingInfo(memoryCacheKey,imageUri,uri,targetSize,viewScaleType,

  getDownloader(),options);

  returndecoder.decode(decodingInfo);

  }

  /**@returntrue-ifimagewasdownloadedsuccessfully;false-otherwise*/

  privatebooleantryCacheImageOnDisk()throwsTaskCancelledException{

  L.d(LOG_CACHE_IMAGE_ON_DISK,memoryCacheKey);

  booleanloaded;

  try{

  loaded=downloadImage();

  if(loaded){

  intwidth=configuration.maxImageWidthForDiskCache;

  intheight=configuration.maxImageHeightForDiskCache;

  if(width>0||height>0){

  L.d(LOG_RESIZE_CACHED_IMAGE_FILE,memoryCacheKey);

  resizeAndSaveImage(width,height);//TODO:processbooleanresult

  }

  }

  }catch(IOExceptione){

  L.e(e);

  loaded=false;

  }

  returnloaded;

  }

  privatebooleandownloadImage()throwsIOException{

  InputStreamis=getDownloader().getStream(uri,options.getExtraForDownloader());

  returnconfiguration.diskCache.save(uri,is,this);

  } 第6行的downloadImage()方法是負責下載圖片,並將其保持到文件緩存中,將下載保存Bitmap的進度回調到IoUtils.CopyListener接口的onBytesCopied(int current, int total)方法中,所以我們可以設置ImageLoadingProgressListener接口來獲取圖片下載保存的進度,這裡保存在文件系統中的圖片是原圖

  第16-17行,獲取ImageLoaderConfiguration是否設置保存在文件系統中的圖片大小,如果設置了maxImageWidthForDiskCache和maxImageHeightForDiskCache,會調用resizeAndSaveImage()方法對圖片進行裁剪然後在替換之前的原圖,保存裁剪後的圖片到文件系統的,之前有同學問過我說這個框架保存在文件系統的圖片都是原圖,怎麼才能保存縮略圖,只要在Application中實例化ImageLoaderConfiguration的時候設置maxImageWidthForDiskCache和maxImageHeightForDiskCache就行了

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  if(bmp==null)return;//listenercallbackalreadywasfired

  checkTaskNotActual();

  checkTaskInterrupted();

  if(options.shouldPreProcess()){

  L.d(LOG_PREPROCESS_IMAGE,memoryCacheKey);

  bmp=options.getPreProcessor().process(bmp);

  if(bmp==null){

  L.e(ERROR_PRE_PROCESSOR_NULL,memoryCacheKey);

  }

  }

  if(bmp!=null&&options.isCacheInMemory()){

  L.d(LOG_CACHE_IMAGE_IN_MEMORY,memoryCacheKey);

  configuration.memoryCache.put(memoryCacheKey,bmp);

  } 接下來這裡就簡單了,6-12行是否要對Bitmap進行處理,這個需要自行實現,14-17就是將圖片保存到內存緩存中去

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  DisplayBitmapTaskdisplayBitmapTask=newDisplayBitmapTask(bmp,imageLoadingInfo,engine,loadedFrom);

  runTask(displayBitmapTask,syncLoading,handler,engine); 最後這兩行代碼就是一個顯示任務,直接看DisplayBitmapTask類的run()方法

  [java]view plaincopy

  

在CODE上查看代碼片
派生到我的代碼片

 

  @Override

  publicvoidrun(){

  if(imageAware.isCollected()){

  L.d(LOG_TASK_CANCELLED_IMAGEAWARE_COLLECTED,memoryCacheKey);

  listener.onLoadingCancelled(imageUri,imageAware.getWrappedView());

  }elseif(isViewWasReused()){

  L.d(LOG_TASK_CANCELLED_IMAGEAWARE_REUSED,memoryCacheKey);

  listener.onLoadingCancelled(imageUri,imageAware.getWrappedView());

  }else{

  L.d(LOG_DISPLAY_IMAGE_IN_IMAGEAWARE,loadedFrom,memoryCacheKey);

  displayer.display(bitmap,imageAware,loadedFrom);

  engine.cancelDisplayTaskFor(imageAware);

  listener.onLoadingComplete(imageUri,imageAware.getWrappedView(),bitmap);

  }

  }

  假如ImageView被回收了或者被重用了,回調給ImageLoadingListener接口,否則就調用BitmapDisplayer去顯示Bitmap

  文章寫到這裡就已經寫完了,不知道大家對這個開源框架有沒有進一步的理解,這個開源框架設計也很靈活,用了很多的設計模式,比如建造者模式,裝飾模式,代理模式,策略模式等等,這樣方便我們去擴展,實現我們想要的功能,今天的講解就到這了,有對這個框架不明白的地方可以在下面留言,我會盡量為大家解答的。

  1. 上一頁:
  2. 下一頁:
熱門文章
閱讀排行版
Copyright © Android教程網 All Rights Reserved