程序博客网 > 手机怎么完全清除数据

Android-Universal-Image-Loader学习笔记

来源：互联网 发布：手机怎么完全清除数据 编辑：程序博客网 时间：2024/06/05 23:53

 Android-Universal-Image-Loader是一个开源的UI组件程序，该项目的目的是提供一个可重复使用的仪器为异步图像加载，缓存和显示。

(1).使用多线程加载图片
(2).灵活配置ImageLoader的基本参数，包括线程数、缓存方式、图片显示选项等；
(3).图片异步加载缓存机制，包括内存缓存及SDCard缓存；
(4).采用监听器监听图片加载过程及相应事件的处理；
(5).配置加载的图片显示选项，比如图片的圆角处理及渐变动画。

 

常用的功能，网上都有了，现在讲一下，加载后手工

(1)圆角化等处理

Java代码  收藏代码
  1. /** 
  2.      * 加载图片 
  3.      *  
  4.      * @param uri 
  5.      * @param imageView 
  6.      * @param options 
  7.      * @param spinner   进度条，可以要可以不要 
  8.      * @param imageLoadingListener 图片加载监听器 
  9.      * @param needRoundImage 图片是否圆角化 
  10.      *  
  11.      */  
  12.     public void display(String uri , ImageView imageView , DisplayImageOptions options , final ProgressBar spinner , ImageLoadingListener imageLoadingListener , final boolean needRoundImage){  
  13.           
  14.         try {  
  15.   
  16.               
  17.               
  18.             if(options == null){  
  19.                 options = new DisplayImageOptions.Builder()  
  20. //              .showStubImage(R.drawable.default_photo_small)  
  21. //              .showImageForEmptyUri(R.drawable.default_photo_small)  
  22. //              .showImageOnFail(R.drawable.default_photo_small)  
  23.                 .resetViewBeforeLoading(true)  
  24.                 .cacheOnDisc(true)  
  25.                 .imageScaleType(ImageScaleType.EXACTLY)  
  26. //              .imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2)  
  27.                 .bitmapConfig(Bitmap.Config.RGB_565)  
  28. //              .displayer(new FadeInBitmapDisplayer(300))  
  29.                 .build();  
  30.             }  
  31.               
  32.               
  33.             if(imageLoadingListener == null){  
  34.                 imageLoadingListener = new SimpleImageLoadingListener() {  
  35.                     @Override  
  36.                     public void onLoadingStarted(String imageUri, View view) {  
  37.                         if(spinner != null){  
  38.                             spinner.setVisibility(View.VISIBLE);  
  39.                         }  
  40.                           
  41.                     }  
  42.   
  43.                     @Override  
  44.                     public void onLoadingFailed(String imageUri, View view, FailReason failReason) {  
  45.                         String message = null;  
  46.                           
  47.                         switch (failReason.getType()) {  
  48.                             case IO_ERROR:  
  49.                                 message = "Input/Output error";  
  50.                                 break;  
  51.                             case DECODING_ERROR:  
  52.                                 message = "Image can't be decoded";  
  53.                                 break;  
  54.                             case NETWORK_DENIED:  
  55.                                 message = "Downloads are denied";  
  56.                                 break;  
  57.                             case OUT_OF_MEMORY:  
  58.                                 message = "Out Of Memory error";  
  59.                                 break;  
  60.                             case UNKNOWN:  
  61.                                 message = "Unknown error";  
  62.                                 break;  
  63.                         }  
  64.                         CLog.e(TAG, imageUri+"/t加载失败!");  
  65.   
  66.                         if(spinner != null){  
  67.                             spinner.setVisibility(View.GONE);  
  68.                         }  
  69.                     }  
  70.                       
  71.   
  72.                     @Override  
  73.                     public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {  
  74.                           
  75.                         /** 
  76.                          * 圆角化处理 
  77.                          */  
  78.                         if(needRoundImage){  
  79.                             ((ImageView) view).setImageBitmap(toRoundBitmap(loadedImage));  
  80.                         }  
  81.                           
  82.                           
  83.                         if(spinner != null){  
  84.                             CLog.d(TAG, imageUri+"/t加载成功!" );  
  85.                             spinner.setVisibility(View.GONE);  
  86.                         }  
  87.                     }  
  88.                 };  
  89.             }  
  90.   
  91.             imageLoader.displayImage(uri, imageView , options , imageLoadingListener);  
  92.       
  93.         } catch (Exception e) {  
  94.             CLog.e(TAG , "exception!" , e);  
  95.         }  
  96.           
  97.     }  
  98.   
  99.   
  100.   
  101.   
  102.   
  103.     /** 
  104.      * 转换图片成圆形 
  105.      * @param bitmap 
  106.      * 传入Bitmap对象 
  107.      * @return 
  108.      */  
  109.     public Bitmap toRoundBitmap(Bitmap bitmap) {  
  110.         int width = bitmap.getWidth();  
  111.         int height = bitmap.getHeight();  
  112.         float roundPx;  
  113.         float left, top, right, bottom, dst_left, dst_top, dst_right, dst_bottom;  
  114.         if (width <= height) {  
  115.             roundPx = width / 2;  
  116.             left = 0;  
  117.             top = 0;  
  118.             right = width;  
  119.             bottom = width;  
  120.             height = width;  
  121.             dst_left = 0;  
  122.             dst_top = 0;  
  123.             dst_right = width;  
  124.             dst_bottom = width;  
  125.         } else {  
  126.             roundPx = height / 2;  
  127.             float clip = (width - height) / 2;  
  128.             left = clip;  
  129.             right = width - clip;  
  130.             top = 0;  
  131.             bottom = height;  
  132.             width = height;  
  133.             dst_left = 0;  
  134.             dst_top = 0;  
  135.             dst_right = height;  
  136.             dst_bottom = height;  
  137.         }  
  138.   
  139.         Bitmap output = Bitmap.createBitmap(width, height, Config.ARGB_8888);  
  140.         Canvas canvas = new Canvas(output);  
  141.   
  142.         final int color = 0xff424242;  
  143.         final Paint paint = new Paint();  
  144.         final Rect src = new Rect((int) left, (int) top, (int) right, (int) bottom);  
  145.         final Rect dst = new Rect((int) dst_left, (int) dst_top, (int) dst_right, (int) dst_bottom);  
  146.         final RectF rectF = new RectF(dst);  
  147.   
  148.         paint.setAntiAlias(true);// 设置画笔无锯齿  
  149.   
  150.         canvas.drawARGB(0, 0, 0, 0); // 填充整个Canvas  
  151.         paint.setColor(color);  
  152.   
  153.         // 以下有两种方法画圆,drawRounRect和drawCircle  
  154.         // canvas.drawRoundRect(rectF, roundPx, roundPx, paint);// 画圆角矩形，第一个参数为图形显示区域，第二个参数和第三个参数分别是水平圆角半径和垂直圆角半径。  
  155.         canvas.drawCircle(roundPx, roundPx, roundPx, paint);  
  156.   
  157.         paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));// 设置两张图片相交时的模式,参考http://trylovecatch.iteye.com/blog/1189452  
  158.         canvas.drawBitmap(bitmap, src, dst, paint); //以Mode.SRC_IN模式合并bitmap和已经draw了的Circle  
  159.           
  160.         return output;  
  161.     }  

 

 

(2)手工从缓存中取出bitmap

Java代码  收藏代码
  1. /** 
  2.      * 使用此加载框架的imageloader加载的图片，设置了缓存后，下次使用，手工从缓存取出来用，这时特别要注意，不能直接使用： 
  3.      * imageLoader.getMemoryCache().get(uri)来获取，因为在加载过程中，key是经过运算的，而不单单是uri,而是： 
  4.      * String memoryCacheKey = MemoryCacheUtil.generateKey(uri, targetSize); 
  5.      *  
  6.      * @return 
  7.      */  
  8.     public Bitmap getBitmapFromCache(String uri){//这里的uri一般就是图片网址  
  9.         List<String> memCacheKeyNameList = MemoryCacheUtil.findCacheKeysForImageUri(uri , imageLoader.getMemoryCache());    
  10.         if(memCacheKeyNameList != null && memCacheKeyNameList.size() > 0){  
  11.             CLog.d(TAG , "memCache size ============> " + memCacheKeyNameList.size());  
  12.             for(String each:memCacheKeyNameList){  
  13.                 CLog.d(TAG , "memCache each ============> " + each);  
  14.             }  
  15.               
  16.             return imageLoader.getMemoryCache().get(memCacheKeyNameList.get(0));  
  17.         }  
  18.           
  19.         return null;  
  20.     }  

 取出的key有可能有两个，如:

http://tizi-zujuan-thumb.oss.aliyuncs.com/qfactory_word_img/201405/ae/309e9b359d0541f87e40f0d8eCKS74F.gif

http://tizi-zujuan-thumb.oss.aliyuncs.com/qfactory_word_img/201405/ae/309e9b359d0541f87e40f0d8eCKS74F.gif_720x1280

 

 

 

 

（3）加载图片（没有imageview控件，只想加载图片的bitmap到内存中）

Java代码  收藏代码
  1. /** 
  2.      * 加载图片 
  3.      * @param uri 
  4.      * @param listener 
  5.      */  
  6.     public void loadImage(String uri , ImageLoadingListener  listener){  
  7. //      imageLoader.loadImage(uri, listener);  
  8.           
  9.         options = new DisplayImageOptions.Builder()  
  10.         .showStubImage(R.drawable.default_photo_small)  
  11.         .showImageForEmptyUri(R.drawable.default_photo_small)  
  12.         .showImageOnFail(R.drawable.default_photo_small)  
  13. //      .resetViewBeforeLoading(true)  
  14.         .cacheOnDisc(true)  
  15.         .cacheInMemory(true)  
  16.         .imageScaleType(ImageScaleType.EXACTLY)  
  17. //      .imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2)  
  18. //      .bitmapConfig(Bitmap.Config.RGB_565)  
  19. //      .displayer(new FadeInBitmapDisplayer(300))  
  20.         .resetViewBeforeLoading(true)  
  21.         .build();  
  22.       
  23.         imageLoader.loadImage(uri, options, listener);  
  24.     }  

 

加载使用示例:

Java代码  收藏代码
  1. /** 
  2.          * 网络加载图片 
  3.          * 这里需要注意的是，一个问题界面，会有多张如公式等小图，他们在加载过程中，都会到方法onLoadingStarted，但如果图多同时加载，后面几张图就可以加载不出来， 
  4.          * 会进入onLoadingCancelled方法，所以这里在onLoadingCancelled方法里再调用typesetDelegate.refresh();方法刷新一下图， 
  5.          * 图应该是下载下来了，只是不知道为什么到了onLoadingCancelled方法。 
  6.          */  
  7.         UniversalImageLoaderUtil.getInstance().loadImage(getBitmapUrl().trim(), new ImageLoadingListener() {  
  8.               
  9.             @Override  
  10.             public void onLoadingStarted(String imageUri, View view) {  
  11.                 CLog.d(TAG , "onLoadingStarted ===>" + imageUri);  
  12.             }  
  13.               
  14.             @Override  
  15.             public void onLoadingFailed(String imageUri, View view,  
  16.                     FailReason failReason) {  
  17.                 CLog.e(TAG , "onLoadingFailed ===>" + imageUri);  
  18.             }  
  19.               
  20.             @Override  
  21.             public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {  
  22.                 if(null == loadedImage){  
  23.                     return;  
  24.                 }  
  25.                   
  26.                 boolean bool = (Math.abs(loadedImage.getWidth()  
  27.                         - TiKuBitmapSpan.this.getPresetWidth()) > TYPESET_THRESHOLD)  
  28.                         || (Math.abs(loadedImage.getHeight()  
  29.                                 - TiKuBitmapSpan.this.getPresetHeight()) > TYPESET_THRESHOLD);  
  30.                   
  31.                 /** 
  32.                  * 调用refresh方法，刷新控件界面，那么又会重走该render方法，这里图片已在缓存，所以就不会再去网络加载，不会再走回这里造成死循环,一直刷新 
  33.                  */  
  34.                 typesetDelegate.refresh(bool);  
  35.                   
  36.                 CLog.d(TAG , "onLoadingComplete bool===>" + bool);  
  37.             }  
  38.               
  39.             @Override  
  40.             public void onLoadingCancelled(String imageUri, View view) {  
  41.                   
  42.   
  43.                 /** 
  44.                  * 调用refresh方法，刷新控件界面，那么又会重走该render方法，这里图片已在缓存，所以就不会再去网络加载，不会再走回这里造成死循环,一直刷新 
  45.                  */  
  46.                 typesetDelegate.refresh(true);  
  47.                   
  48.                 CLog.e(TAG , "onLoadingCancelled ===>" + imageUri);  
  49.             }  
  50.         });  

 

这里特别要注意的是，同时加载多个url的bitmap，有可能会因超时等原因(具体我也不知道什么的原因)，最后跳到监听器的onLoadingCancelled方法(此时图片也可能在后台加载了)，所以对种特殊情况也要处理。

 

 

 

 

 

完整的工具类代码:

 

Java代码  收藏代码
  1. package com.yiduoyun.tiku.util;  
  2.   
  3. import java.util.List;  
  4.   
  5. import android.content.Context;  
  6. import android.graphics.Bitmap;  
  7. import android.graphics.Bitmap.Config;  
  8. import android.graphics.Canvas;  
  9. import android.graphics.Paint;  
  10. import android.graphics.PorterDuff.Mode;  
  11. import android.graphics.PorterDuffXfermode;  
  12. import android.graphics.Rect;  
  13. import android.graphics.RectF;  
  14. import android.view.View;  
  15. import android.widget.ImageView;  
  16. import android.widget.ProgressBar;  
  17.   
  18. import com.nostra13.universalimageloader.cache.disc.naming.Md5FileNameGenerator;  
  19. import com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache;  
  20. import com.nostra13.universalimageloader.core.DisplayImageOptions;  
  21. import com.nostra13.universalimageloader.core.ImageLoader;  
  22. import com.nostra13.universalimageloader.core.ImageLoaderConfiguration;  
  23. import com.nostra13.universalimageloader.core.assist.FailReason;  
  24. import com.nostra13.universalimageloader.core.assist.ImageLoadingListener;  
  25. import com.nostra13.universalimageloader.core.assist.ImageScaleType;  
  26. import com.nostra13.universalimageloader.core.assist.MemoryCacheUtil;  
  27. import com.nostra13.universalimageloader.core.assist.QueueProcessingType;  
  28. import com.nostra13.universalimageloader.core.assist.SimpleImageLoadingListener;  
  29. import com.nostra13.universalimageloader.core.display.FadeInBitmapDisplayer;  
  30. import com.nostra13.universalimageloader.core.display.RoundedBitmapDisplayer;  
  31. import com.yiduoyun.tiku.R;  
  32.   
  33.   
  34. /** 
  35.  * 使用开源图片加载框架Universal-Image-Loader 
  36.  *  
  37.  * @author chenwenbiao 
  38.  * @date 2013-11-1 上午11:21:45 
  39.  * @version V1.0 
  40.  */  
  41. public class UniversalImageLoaderUtil {  
  42.       
  43.     private static String TAG = UniversalImageLoaderUtil.class.getName();  
  44.   
  45.     private static UniversalImageLoaderUtil universalImageLoaderUtil = null;  
  46.   
  47.     private static ImageLoader imageLoader = null;  
  48.       
  49.   
  50.     private static DisplayImageOptions options = null;  
  51. //  private static ProgressBar spinner = null;  
  52.       
  53.     /** 
  54.      * 返回图片加载工具类实例 
  55.      * @return 
  56.      */  
  57.     public static UniversalImageLoaderUtil getInstance() {  
  58.         if (universalImageLoaderUtil == null) {  
  59.             synchronized (UniversalImageLoaderUtil.class) {  
  60.                 if (universalImageLoaderUtil == null) {  
  61.                     universalImageLoaderUtil = new UniversalImageLoaderUtil();  
  62.                 }  
  63.             }  
  64.         }  
  65.         return universalImageLoaderUtil;  
  66.     }  
  67.       
  68.     /** 
  69.      * 记得使用前初始化context 
  70.      * @param aContext 
  71.      */  
  72.     public void setContext(Context aContext) {  
  73.         imageLoader = ImageLoader.getInstance();   
  74. //      imageLoader.init(ImageLoaderConfiguration.createDefault(aContext));  
  75.         ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(aContext.getApplicationContext())    
  76.         .memoryCache(new LruMemoryCache(16 * 1024 * 1024))    
  77. //        .memoryCacheSize(16 * 1024 * 1024)   
  78.         .discCacheSize(100 * 1024 * 1024)    
  79.         .denyCacheImageMultipleSizesInMemory()      
  80.         .discCacheFileNameGenerator(new Md5FileNameGenerator())      
  81.         .tasksProcessingOrder(QueueProcessingType.LIFO)      
  82. //        .discCacheFileCount(100)    
  83. //        .writeDebugLogs()  
  84.         .threadPoolSize(10)  
  85.         .build();    
  86.           
  87.           
  88.         /*File cacheDir = StorageUtils.getCacheDirectory(aContext); 
  89.         CLog.d(TAG , "cache direction =======> " + cacheDir); 
  90.         ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(aContext) 
  91.         .memoryCacheExtraOptions(480, 800) // default = device screen dimensions 
  92.         .discCacheExtraOptions(480, 800, CompressFormat.JPEG, 75, null) 
  93. //        .taskExecutor(null) 
  94. //        .taskExecutorForCachedImages(null) 
  95.         .threadPoolSize(3) // default 
  96.         .threadPriority(Thread.NORM_PRIORITY - 1) // default 
  97.         .tasksProcessingOrder(QueueProcessingType.FIFO) // default 
  98.         .denyCacheImageMultipleSizesInMemory() 
  99.         .memoryCache(new LruMemoryCache(2 * 1024 * 1024)) 
  100.         .memoryCacheSize(2 * 1024 * 1024) 
  101.         .memoryCacheSizePercentage(13) // default 
  102.         .discCache(new UnlimitedDiscCache(cacheDir)) // default 
  103.         .discCacheSize(50 * 1024 * 1024) 
  104.         .discCacheFileCount(100) 
  105.         .discCacheFileNameGenerator(new HashCodeFileNameGenerator()) // default 
  106.         .imageDownloader(new BaseImageDownloader(aContext)) // default 
  107. //        .imageDecoder(new BaseImageDecoder(true)) // default 
  108.         .defaultDisplayImageOptions(DisplayImageOptions.createSimple()) // default 
  109.         .writeDebugLogs() 
  110.         .build();*/  
  111.           
  112.       
  113.           
  114.         /*File cacheDir = StorageUtils.getCacheDirectory(aContext); 
  115.         ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(aContext) 
  116.                 //如果图片尺寸大于了这个参数，那么就会这按照这个参数对图片大小进行限制并缓存 
  117.                 .memoryCacheExtraOptions(480, 800) // default=device screen dimensions 
  118.                 .discCacheExtraOptions(480, 800, CompressFormat.JPEG, 75 , null) 
  119. //               .memoryCacheExtraOptions(40, 80) // default=device screen dimensions 
  120. //              .discCacheExtraOptions(40, 80, CompressFormat.JPEG, 75 , null) 
  121. //              .taskExecutor(AsyncTask.THREAD_POOL_EXECUTOR) 
  122. //              .taskExecutorForCachedImages(AsyncTask.THREAD_POOL_EXECUTOR) 
  123.                 .threadPoolSize(3) // default 
  124.                 .threadPriority(Thread.NORM_PRIORITY - 1) // default 
  125.                 .tasksProcessingOrder(QueueProcessingType.FIFO) // default 
  126.                 .denyCacheImageMultipleSizesInMemory() 
  127.                 .memoryCache(new LruMemoryCache(2 * 1024 * 1024)) 
  128.                 .memoryCacheSize(2 * 1024 * 1024) 
  129.                 .discCache(new UnlimitedDiscCache(cacheDir)) // default 
  130.                 .discCacheSize(50 * 1024 * 1024) 
  131.                 .discCacheFileCount(100) 
  132.                 .discCacheFileNameGenerator(new HashCodeFileNameGenerator()) // default 
  133.                 .imageDownloader(new BaseImageDownloader(aContext)) // default 
  134.                 .imageDecoder(new BaseImageDecoder(false)) // default 
  135.                 .defaultDisplayImageOptions(DisplayImageOptions.createSimple()) // default 
  136. //              .enableLogging() 
  137.                 .build(); 
  138.         */  
  139.           
  140.           
  141.           
  142.           
  143.           
  144.         try {  
  145.             imageLoader.init(config);  
  146.         } catch (Exception e) {  
  147.             CLog.e(TAG , "exception" , e);  
  148.         }  
  149.     }  
  150.       
  151.       
  152.     /** 
  153.      * 获取图片加载器实例 
  154.      * @return 
  155.      */  
  156.     public static ImageLoader getImageLoader(){  
  157.         return imageLoader;  
  158.     }  
  159.       
  160.       
  161.     /** 
  162.      * 加载图片 
  163.      *  
  164.      * @param uri 
  165.      * @param imageView 
  166.      * @param options 
  167.      * @param spinner   进度条，可以要可以不要 
  168.      * @param imageLoadingListener 图片加载监听器 
  169.      * @param needRoundImage 图片是否圆角化 
  170.      *  
  171.      */  
  172.     public void display(String uri , ImageView imageView , DisplayImageOptions options , final ProgressBar spinner , ImageLoadingListener imageLoadingListener , final boolean needRoundImage){  
  173.           
  174.         try {  
  175.   
  176.               
  177.               
  178.             if(options == null){  
  179.                 options = new DisplayImageOptions.Builder()  
  180. //              .showStubImage(R.drawable.default_photo_small)  
  181. //              .showImageForEmptyUri(R.drawable.default_photo_small)  
  182. //              .showImageOnFail(R.drawable.default_photo_small)  
  183.                 .resetViewBeforeLoading(true)  
  184.                 .cacheOnDisc(true)  
  185.                 .imageScaleType(ImageScaleType.EXACTLY)  
  186. //              .imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2)  
  187.                 .bitmapConfig(Bitmap.Config.RGB_565)  
  188. //              .displayer(new FadeInBitmapDisplayer(300))  
  189.                 .build();  
  190.             }  
  191.               
  192.               
  193.             if(imageLoadingListener == null){  
  194.                 imageLoadingListener = new SimpleImageLoadingListener() {  
  195.                     @Override  
  196.                     public void onLoadingStarted(String imageUri, View view) {  
  197.                         if(spinner != null){  
  198.                             spinner.setVisibility(View.VISIBLE);  
  199.                         }  
  200.                           
  201.                     }  
  202.   
  203.                     @Override  
  204.                     public void onLoadingFailed(String imageUri, View view, FailReason failReason) {  
  205.                         String message = null;  
  206.                           
  207.                         switch (failReason.getType()) {  
  208.                             case IO_ERROR:  
  209.                                 message = "Input/Output error";  
  210.                                 break;  
  211.                             case DECODING_ERROR:  
  212.                                 message = "Image can't be decoded";  
  213.                                 break;  
  214.                             case NETWORK_DENIED:  
  215.                                 message = "Downloads are denied";  
  216.                                 break;  
  217.                             case OUT_OF_MEMORY:  
  218.                                 message = "Out Of Memory error";  
  219.                                 break;  
  220.                             case UNKNOWN:  
  221.                                 message = "Unknown error";  
  222.                                 break;  
  223.                         }  
  224.                         CLog.e(TAG, imageUri+"/t加载失败!");  
  225.   
  226.                         if(spinner != null){  
  227.                             spinner.setVisibility(View.GONE);  
  228.                         }  
  229.                     }  
  230.                       
  231.   
  232.                     @Override  
  233.                     public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {  
  234.                           
  235.                         /** 
  236.                          * 圆角化处理 
  237.                          */  
  238.                         if(needRoundImage){  
  239.                             ((ImageView) view).setImageBitmap(toRoundBitmap(loadedImage));  
  240.                         }  
  241.                           
  242.                           
  243.                         if(spinner != null){  
  244.                             CLog.d(TAG, imageUri+"/t加载成功!" );  
  245.                             spinner.setVisibility(View.GONE);  
  246.                         }  
  247.                     }  
  248.                 };  
  249.             }  
  250.   
  251.             imageLoader.displayImage(uri, imageView , options , imageLoadingListener);  
  252.       
  253.         } catch (Exception e) {  
  254.             CLog.e(TAG , "exception!" , e);  
  255.         }  
  256.           
  257.     }  
  258.       
  259.     public void display(String uri , ImageView imageView , DisplayImageOptions options , final ProgressBar spinner , final boolean needRoundImage){  
  260.         display(uri, imageView, options, spinner, null , needRoundImage);  
  261.     }  
  262.       
  263.       
  264.     /** 
  265.      * 加载图片，并将图片圆角化 
  266.      *  
  267.      * @param uri 
  268.      * @param imageView 
  269.      * @param roundPixels 
  270.      */  
  271.     public void display(String uri , ImageView imageView , int roundPixels){  
  272.         try {  
  273.   
  274.               
  275.             if(roundPixels < 1){  
  276.                 roundPixels = 10000;//搞个巨大的数据，让它变圆  
  277.                   
  278.                   
  279.             }  
  280.               
  281.             options = new DisplayImageOptions.Builder()  
  282.                                             .showStubImage(R.drawable.default_photo_big)  
  283.                                             .showImageForEmptyUri(R.drawable.default_photo_big)  
  284.                                             .showImageOnFail(R.drawable.default_photo_big)  
  285.                                             .resetViewBeforeLoading(true)  
  286.                                             .cacheOnDisc(true)  
  287.                                             .imageScaleType(ImageScaleType.IN_SAMPLE_INT)  
  288.                                             .displayer(new RoundedBitmapDisplayer(roundPixels))  
  289.                                             .bitmapConfig(Bitmap.Config.RGB_565)  
  290.                                             .displayer(new FadeInBitmapDisplayer(300))  
  291.                                             .build();  
  292.               
  293.             imageLoader.displayImage(uri, imageView, options, new SimpleImageLoadingListener() {  
  294.                   
  295.   
  296.                   
  297.                   
  298.                   
  299.       
  300.   
  301.                 @Override  
  302.                 public void onLoadingFailed(String imageUri, View view, FailReason failReason) {  
  303.                     String message = null;  
  304.                     switch (failReason.getType()) {  
  305.                         case IO_ERROR:  
  306.                             message = "Input/Output error";  
  307.                             break;  
  308.                         case DECODING_ERROR:  
  309.                             message = "Image can't be decoded";  
  310.                             break;  
  311.                         case NETWORK_DENIED:  
  312.                             message = "Downloads are denied";  
  313.                             break;  
  314.                         case OUT_OF_MEMORY:  
  315.                             message = "Out Of Memory error";  
  316.                             break;  
  317.                         case UNKNOWN:  
  318.                             message = "Unknown error";  
  319.                             break;  
  320.                     }  
  321.                     CLog.e(TAG, "load image error! message:" + message);  
  322.   
  323.                 }  
  324.   
  325.             });  
  326.               
  327.           
  328.         } catch (Exception e) {  
  329.             CLog.e(TAG , "exception!" , e);  
  330.         }  
  331.     }  
  332.       
  333.       
  334.       
  335.       
  336.     /** 
  337.      * 转换图片成圆形 
  338.      * @param bitmap 
  339.      * 传入Bitmap对象 
  340.      * @return 
  341.      */  
  342.     public Bitmap toRoundBitmap(Bitmap bitmap) {  
  343.         int width = bitmap.getWidth();  
  344.         int height = bitmap.getHeight();  
  345.         float roundPx;  
  346.         float left, top, right, bottom, dst_left, dst_top, dst_right, dst_bottom;  
  347.         if (width <= height) {  
  348.             roundPx = width / 2;  
  349.             left = 0;  
  350.             top = 0;  
  351.             right = width;  
  352.             bottom = width;  
  353.             height = width;  
  354.             dst_left = 0;  
  355.             dst_top = 0;  
  356.             dst_right = width;  
  357.             dst_bottom = width;  
  358.         } else {  
  359.             roundPx = height / 2;  
  360.             float clip = (width - height) / 2;  
  361.             left = clip;  
  362.             right = width - clip;  
  363.             top = 0;  
  364.             bottom = height;  
  365.             width = height;  
  366.             dst_left = 0;  
  367.             dst_top = 0;  
  368.             dst_right = height;  
  369.             dst_bottom = height;  
  370.         }  
  371.   
  372.         Bitmap output = Bitmap.createBitmap(width, height, Config.ARGB_8888);  
  373.         Canvas canvas = new Canvas(output);  
  374.   
  375.         final int color = 0xff424242;  
  376.         final Paint paint = new Paint();  
  377.         final Rect src = new Rect((int) left, (int) top, (int) right, (int) bottom);  
  378.         final Rect dst = new Rect((int) dst_left, (int) dst_top, (int) dst_right, (int) dst_bottom);  
  379.         final RectF rectF = new RectF(dst);  
  380.   
  381.         paint.setAntiAlias(true);// 设置画笔无锯齿  
  382.   
  383.         canvas.drawARGB(0, 0, 0, 0); // 填充整个Canvas  
  384.         paint.setColor(color);  
  385.   
  386.         // 以下有两种方法画圆,drawRounRect和drawCircle  
  387.         // canvas.drawRoundRect(rectF, roundPx, roundPx, paint);// 画圆角矩形，第一个参数为图形显示区域，第二个参数和第三个参数分别是水平圆角半径和垂直圆角半径。  
  388.         canvas.drawCircle(roundPx, roundPx, roundPx, paint);  
  389.   
  390.         paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));// 设置两张图片相交时的模式,参考http://trylovecatch.iteye.com/blog/1189452  
  391.         canvas.drawBitmap(bitmap, src, dst, paint); //以Mode.SRC_IN模式合并bitmap和已经draw了的Circle  
  392.           
  393.         return output;  
  394.     }  
  395.       
  396.       
  397.     /** 
  398.      * 使用此加载框架的imageloader加载的图片，设置了缓存后，下次使用，手工从缓存取出来用，这时特别要注意，不能直接使用： 
  399.      * imageLoader.getMemoryCache().get(uri)来获取，因为在加载过程中，key是经过运算的，而不单单是uri,而是： 
  400.      * String memoryCacheKey = MemoryCacheUtil.generateKey(uri, targetSize); 
  401.      *  
  402.      * @return 
  403.      */  
  404.     public Bitmap getBitmapFromCache(String uri){//这里的uri一般就是图片网址  
  405.         List<String> memCacheKeyNameList = MemoryCacheUtil.findCacheKeysForImageUri(uri , imageLoader.getMemoryCache());    
  406.         if(memCacheKeyNameList != null && memCacheKeyNameList.size() > 0){  
  407.             CLog.d(TAG , "memCache size ============> " + memCacheKeyNameList.size());  
  408.             for(String each:memCacheKeyNameList){  
  409.                 CLog.d(TAG , "memCache each ============> " + each);  
  410.             }  
  411.               
  412.             return imageLoader.getMemoryCache().get(memCacheKeyNameList.get(0));  
  413.         }  
  414.           
  415.         return null;  
  416.     }  
  417.       
  418.       
  419.     /** 
  420.     * @Title: getLocalBitmapFromCache  
  421.     * @Description: 这个方法只适用于加载本地图片的情况（考虑到计算key的过程），这里的key使用的是文本，注意添加内存缓存和获取Bitmap缓存的key一定要一致 
  422.     * @author gaoshunsheng 
  423.     * @param @param uri 
  424.     * @return Bitmap 
  425.     * @throws 
  426.      */  
  427. //  public Bitmap getLocalBitmapFromCache(String text)  
  428. //  {  
  429. //      return imageLoader.getMemoryCache().get(text);  
  430. //  }  
  431. //    
  432. //  /**  
  433. //  * @Title: addBitmap2Memorycache   
  434. //  * @Description: 添加Bitmap对象到缓存中，这里一般用于本地资源图片，key为文本  
  435. //  * @author gaoshunsheng  
  436. //  * @param @param text  
  437. //  * @param @param value  
  438. //  * @return void  
  439. //  * @throws  
  440. //   */  
  441. //  public void addBitmap2Memorycache(String text, Bitmap value)  
  442. //  {  
  443. //      imageLoader.getMemoryCache().put(text, value);  
  444. //  }  
  445. //    
  446. //  /**  
  447. //  * @Title: loadImageAsync   
  448. //  * @Description: 异步加载图片，不显示在某个View上  
  449. //  * @author gaoshunsheng  
  450. //  * @param @param uri  
  451. //  * @param @param listener  
  452. //  * @return void  
  453. //  * @throws  
  454. //   */  
  455. //  public void loadImageAsync(String uri, ImageLoadingListener listener)  
  456. //  {  
  457. //      imageLoader.loadImage(uri, listener);  
  458. //  }  
  459.       
  460.     /** 
  461.      * 清除缓存 
  462.      */  
  463.     public void clearCache(){  
  464.         if(imageLoader != null){  
  465.             try {  
  466.                 imageLoader.clearMemoryCache();  
  467.                 imageLoader.clearDiscCache();  
  468.             } catch (Exception e) {  
  469.                 CLog.e(TAG , "exception" , e);  
  470.             }  
  471.         }  
  472.     }  
  473.       
  474.       
  475.       
  476.     /** 
  477.      * 加载图片 
  478.      * @param uri 
  479.      * @param listener 
  480.      */  
  481.     public void loadImage(String uri , ImageLoadingListener  listener){  
  482. //      imageLoader.loadImage(uri, listener);  
  483.           
  484.         options = new DisplayImageOptions.Builder()  
  485.         .showStubImage(R.drawable.default_photo_small)  
  486.         .showImageForEmptyUri(R.drawable.default_photo_small)  
  487.         .showImageOnFail(R.drawable.default_photo_small)  
  488. //      .resetViewBeforeLoading(true)  
  489.         .cacheOnDisc(true)  
  490.         .cacheInMemory(true)  
  491.         .imageScaleType(ImageScaleType.EXACTLY)  
  492. //      .imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2)  
  493. //      .bitmapConfig(Bitmap.Config.RGB_565)  
  494. //      .displayer(new FadeInBitmapDisplayer(300))  
  495.         .resetViewBeforeLoading(true)  
  496.         .build();  
  497.       
  498.         imageLoader.loadImage(uri, options, listener);  
  499.     }  
  500. }  

 

 

 

记得在Application类里加上初始化代码:

 

Java代码  收藏代码
  1. UniversalImageLoaderUtil.getInstance().setContext(this);  
0 0
手机怎么完全清除数据 手机怎么完全清除数据
原创粉丝点击
热门IT博客
ps4slim和ps4区别知乎ps4slim和ps4区别知乎
linux隔两行合并成一行linux隔两行合并成一行
软件人才派遣
惠惠购物助手 知乎
常州红日网络地板
网络pt老虎机赌博论坛
汕头政府网络问政平台
mac的办公软件是什么
大数据的历史
模特摩卡用什么软件
android商城项目源码
星际淘宝网 88
vb视频教程打包下载
java bigdecimal除法
淘宝网网页版登录
腾讯云域名过户
js new 关键字的作用
末世数据升级流小说
八度网络怎么样
java frame text
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 郑州到巩义火车 巩义限号2019 巩义搜门户网 巩义到郑州火车 巩义邮政编码 巩义车祸 巩义旅游攻略 巩义限行区域 巩义盘龙山景区 巩义搜招聘 巩义搜房屋信息 巩义康百万庄园门票 巩义温泉酒店 巩义信息网 巩义房产信息网 巩义怎么样 巩义县 巩义是哪里 巩义论坛 巩义市住房公积金查询 郑州市巩义市 郑州巩义市 巩义在线招聘信息 巩义招聘小车司机 巩义信息网招聘信息 巩义求职招聘 巩义二手 巩义公交 巩义相亲网 巩义租房信息 巩义招聘信息巩义搜 巩义搜信息网招聘 巩义搜房产买卖 巩义搜二手房 巩义搜房屋出租 巩义搜信息网招聘求职 巩义搜招聘求职信息 巩义市招聘 在巩义市区找工作 巩国兰 巩义2018年要拆的村

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里