메모리에 캐시하는 방법 메모리와 디스크 캐시 모두에 비트 맵을 저장 하시겠습니까?

Question

현재 사용자의 기기 카메라 또는 갤러리에서 사진을 찍거나 가져온 직후에 다음 StoreImage 방법을 구현하는 가장 좋은 방법은 무엇입니까?

• 가 어떻게이 DiscCache 내부의 메모리에 현재 비트 맵을 저장할 수 있습니다

  #region IImageManager 
  
  // Stores the given bitmap inside both memory and disc caches... 
  public override void StoreImage (object rawImage, string key, bool toDisc) 
  { 
      // Given key examples: 
      // local_photo_66831.jpg 
      // local_thumbnail_photo_66831.jpg 
  
      string uri = MakeUri (key); 
  
      // Returned uri examples: 
      // file:///storage/sdcard0/Android/data/com.xxx.xxx/cache/local_photo_66831.jpg 
      // file:///storage/sdcard0/Android/data/com.xxx.xxx/cache/local_thumbnail_photo_66831.jpg 
  
      ImageLoader.Instance.MemoryCache.Put (uri, (Bitmap)rawImage); 
  
      if (toDisc) 
       ImageLoader.Instance.DiscCache.Put (uri, <File>); 
  } 
  

  질문 (Android Universal Image Loader 사용)?

• LoadImage 메서드를 사용하여 파일을로드하는 대신 프로그래밍 방식으로 파일을 DiscCache에 추가해도 괜찮습니까?
• 그것은 단순한 문자열 * 작업을 가능 키 * 대신 항상 '(키) ImageLoader.Instance.MemoryCache.Get'와 같은 통화를 사용하여 접근 한 후 지역 * URI *의 작성 및의이야?

나는 포트에 다음 아이폰 OS를 시도하고있다 - SDWebImage 구현을 비슷한 안드로이드 - UIL 버전 : 사전에

public override void StoreImage (object rawImage, string key, bool toDisk) 
{ 
    SDWebImageManager.SharedManager.ImageCache.StoreImage ((UIImage)rawImage, key, toDisk); 
} 

감사합니다.

Answer 1

아래 이미지를 다운로드 한 후 캐시 메모리와 디스크 메모리를 디스크에 이미지 저장소에 유지 관리하는 imageLoader 클래스.

public class MyImageLoader { 

private static final int DISK_CACHE_SIZE = 1024 * 1024 * 10; // 10MB 
private static final String DISK_CACHE_SUBDIR = "ImageCache"; 
private DiskLruImageCache mDiskLruImageCache; 
private ExecutorService executorService; 
private LruCache<String, Bitmap> mMemoryCache; 
private Map<ImageView, String> imageViews = Collections.synchronizedMap(new WeakHashMap<ImageView, String>()); 
private int byteCounts; 
private int requiredHeight = 100, requiredWidth = 100; // setting default height & width as 100 
private final int default_icon = R.drawable.no_image_friend; 
CommonMethod mCommonMethod; 

public MyImageLoader(Context context) { 

    executorService = Executors.newFixedThreadPool(2); 
    final int memClass = ((ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE)).getMemoryClass(); 
    // Use 1/8th of the available memory for this memory cache. 
    final int cacheSize = 1024 * 1024 * memClass/8; 

    mCommonMethod = new CommonMethod(context); 
    mDiskLruImageCache = new DiskLruImageCache(context, DISK_CACHE_SUBDIR, DISK_CACHE_SIZE, CompressFormat.PNG, 70); 

    mMemoryCache = new LruCache<String, Bitmap>(cacheSize) { 

     @Override 
     protected int sizeOf(String key, Bitmap bitmap) { 
      byteCounts = bitmap.getRowBytes() * bitmap.getHeight(); 
      return byteCounts; 
     } 
    }; 
} 

public void ExecuteLoading(String urlString, ImageView mImageView) { 

    imageViews.put(mImageView, urlString); 
    Bitmap bitmap = getBitmapFromMemCache(urlString); 

    if (bitmap != null){ 
     mImageView.setImageBitmap(bitmap); 
    } 
    else { 
     executorService.submit(new LoadImages(urlString, mImageView)); 
     mImageView.setImageResource(default_icon); 
    } 
} 

boolean ImageViewReused(String urlString, ImageView mImageView){ 
    String tag=imageViews.get(mImageView); 
    if(tag==null || !tag.equals(urlString)) 
     return true; 
    return false; 
} 

class LoadImages implements Runnable { 
    String urlString; 
    ImageView mImageView; 
    DisplayImages images; 

    public LoadImages(String urlString, ImageView mImageView) { 
     this.urlString = urlString; 
     this.mImageView = mImageView; 
    } 

    public void run() { 

     if(!ImageViewReused(urlString, mImageView)){ 
      Bitmap bitmap = DownloadFromUrl(urlString); 

      Bitmap mBitmapMask = mCommonMethod.makeMaskImageCrop(bitmap, R.drawable.image_thumb_mask, R.drawable.image_thumb); 

      //TODO to mask image then bitmap pass 
      addBitmapToDiskCache(urlString, mBitmapMask); 

      DisplayImages images = new DisplayImages(urlString, mImageView, mBitmapMask); 
      ((Activity) mImageView.getContext()).runOnUiThread(images); 
     } 
    } 
} 

class DisplayImages implements Runnable { 
    Bitmap bitmap; 
    String urlString; 
    ImageView mImageView; 

    public DisplayImages(String urlString, ImageView mImageView, Bitmap bitmap) { 
     this.urlString = urlString; 
     this.mImageView = mImageView; 
     this.bitmap = bitmap; 
    } 

    public void run() { 

     if(!ImageViewReused(urlString, mImageView)){ 
      if (bitmap != null) 
       mImageView.setImageBitmap(bitmap); 
      else 
       mImageView.setImageResource(default_icon); 
     } 
    } 
} 

private Bitmap DownloadFromUrl(String urlString) { 
    return decodeBitmapFromStream(urlString, getReqiredWidth(), getRequiredHeight()); 
} 

private void addBitmapToMemoryCache(String key, Bitmap bitmap) { 
    synchronized (mMemoryCache) { 
     if (mMemoryCache.get(key) == null) { 
      mMemoryCache.put(key, bitmap); 
     } 
    } 
} 
private Bitmap getBitmapFromMemCache(String key) { 
    Bitmap bitmap = mMemoryCache.get(key); 
    if(bitmap == null){ 
     bitmap = getBitmapFromDiskCache(key); 
    } 
    return bitmap; 
} 

private void addBitmapToDiskCache(String key, Bitmap bitmap) { 
    synchronized (mDiskLruImageCache) { 
     if (!mDiskLruImageCache.containsKey(String.valueOf(key.hashCode()))) { 
      mDiskLruImageCache.put(String.valueOf(key.hashCode()), bitmap); 
      addBitmapToMemoryCache(key, bitmap); 
     } 
    } 
} 

private Bitmap getBitmapFromDiskCache(String key) { 
    return mDiskLruImageCache.getBitmap(String.valueOf(key.hashCode())); 
} 


private static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) { 
    // Raw height and width of image 
    final int height = options.outHeight; 
    final int width = options.outWidth; 
    int inSampleSize = 1; 

    inSampleSize = Math.min(width/reqWidth, height/reqHeight); 

    return inSampleSize; 
} 

private static Bitmap decodeBitmapFromStream(String urlString, int reqWidth, int reqHeight) { 

    URL url = null; 
    InputStream is = null; 
    try { 
     url = new URL(urlString); 
     is = (InputStream) url.getContent(); 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 

    // First decode with inJustDecodeBounds=true to check dimensions 
    final BitmapFactory.Options options = new BitmapFactory.Options(); 
    options.inJustDecodeBounds = true; 
    BitmapFactory.decodeStream(is, null, options); 

    // Calculate inSampleSize 
    options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight); 

    // As InputStream can be used only once we have to regenerate it again. 
    try { 
     is = (InputStream) url.getContent(); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
    // Decode bitmap with inSampleSize set 
    options.inJustDecodeBounds = false; 
    return BitmapFactory.decodeStream(is, null, options); 
} 

public int getRequiredHeight() { 
    return requiredHeight; 
} 

public void setRequiredHeight(int longest, int requiredHeight) { 
    this.requiredHeight = requiredHeight > longest ? longest : requiredHeight; 
} 

public int getReqiredWidth() { 
    return requiredWidth; 
} 

public void setReqiredWidth(int longest, int requiredWidth) { 
    this.requiredWidth = requiredWidth > longest ? longest : requiredWidth; 
} 

public void clearCacheMemory() { 
    if(mMemoryCache.size() > 0){ 
     mMemoryCache.evictAll(); 
    } 
} 

public void clearDiskMemory() { 
    mDiskLruImageCache.clearCache(); 
} 
} 

는