高效显示图片（四、五）

原文连接：http://developer.android.com/training/displaying-bitmaps/manage-memory.html

图片内存管理

除了缓存图片，你还可以做一些其他的事情来方便垃圾回收和再利用图片。推荐的策略取决
于设备的Android版本。
在Android 2.2和之前的Android版本中，当垃圾回收发生时，你的应用程序被停止。这将导致
程序滞后，可能会降低性能。Android 2.3增加了并发的垃圾回收，这意味着当一个图片的不
在被引用了，它所占用的内存会被立即回收。
在Android 2.3.3和较低的版本中，对于一个图片的像素数据被存储在本地内存中。而bitmap
对象本身被存储在Dalvik虚拟机的堆中。在本地内存中的像素数据不会以一种可预见的方式
被释放，可能会使得应用程序超过它的内存限制而导致崩溃。而到了Android 3.0，图片的像
素数据也被存储在Dalvik虚拟机的堆中。

在Android 2.3.3和低版本的系统中管理内存

在Android 2.3.3和低版本的系统中，推荐使用recycle（）。如果你在app中显示了大量的bitmap
数据，你有可能会导致内存溢出错误。recycle方法使得应用程序尽快回收内存。

下面的代理使用引用计数器来跟踪，一个图片当前被显示或在缓存中。当满足下面的条件时，
bitmap将会被回收。
1.对于mDisplayRefCount和mCacheRefCount的引用数都为0.
2.bitmap不为null，且没有被回收。

private int mCacheRefCount = 0 ;
private int mDisplayRefCount = 0 ;
...
// Notify the drawable that the displayed state has changed.
// Keep a count to determine when the drawable is no longer displayed.
public void setIsDisplayed( boolean isDisplayed) {
   synchronized ( this ) {
        if (isDisplayed) {
            mDisplayRefCount++;
            mHasBeenDisplayed = true ;
        } else {
            mDisplayRefCount--;
        }
   }
   // Check to see if recycle() can be called.
   checkState();
}

// Notify the drawable that the cache state has changed.
// Keep a count to determine when the drawable is no longer being cached.
public void setIsCached( boolean isCached) {
   synchronized ( this ) {
        if (isCached) {
            mCacheRefCount++;
        } else {
            mCacheRefCount--;
        }
   }
   // Check to see if recycle() can be called.
   checkState();
}

private synchronized void checkState() {
   // If the drawable cache and display ref counts = 0, and this drawable
   // has been displayed, then recycle.
   if (mCacheRefCount <= 0 && mDisplayRefCount <= 0 && mHasBeenDisplayed
            && hasValidBitmap()) {
        getBitmap().recycle();
   }
}

private synchronized boolean hasValidBitmap() {
   Bitmap bitmap = getBitmap();
   return bitmap != null && !bitmap.isRecycled();
}

在Android 3.0之后的系统中管理内存

Android 3.0引入了BitmapFactory.Options.inBitmap域。如果这个选项被设置，解码方法在加
载内容时将试图重用一个存在的bitmap。这意味着bitmap的内存被重用，使得改善了性能，
消除了内存分配和回收。下面是使用inBitmap时需注意的事项：

1.重用的bitmap必须与源内容的大小相同，而且是JPEG和PNG的格式。
2.重用的bitmap将覆盖设置的inPreferredConfig。
3.你应该总是使用由decode方法返回的bitmap，因为你不能确定重用的bitmap是否能工作。

HashSet<SoftReference<Bitmap>> mReusableBitmaps;
private LruCache<String, BitmapDrawable> mMemoryCache;

// If you're running on Honeycomb or newer, create
// a HashSet of references to reusable bitmaps.
if (Utils.hasHoneycomb()) {
   mReusableBitmaps = new HashSet<SoftReference<Bitmap>>();
}

mMemoryCache = new LruCache<String, BitmapDrawable>(mCacheParams.memCacheSize) {

   // Notify the removed entry that is no longer being cached.
   @Override
   protected void entryRemoved( boolean evicted, String key,
            BitmapDrawable oldValue, BitmapDrawable newValue) {
        if (RecyclingBitmapDrawable. class .isInstance(oldValue)) {
            // The removed entry is a recycling drawable, so notify it
            // that it has been removed from the memory cache.
            ((RecyclingBitmapDrawable) oldValue).setIsCached( false );
        } else {
            // The removed entry is a standard BitmapDrawable.
            if (Utils.hasHoneycomb()) {
               // We're running on Honeycomb or later, so add the bitmap
               // to a SoftReference set for possible use with inBitmap later.
               mReusableBitmaps.add
                        ( new SoftReference<Bitmap>(oldValue.getBitmap()));
            }
        }
   }
....
}

使用一个存在的bitmap

public static Bitmap decodeSampledBitmapFromFile(String filename,
        int reqWidth, int reqHeight, ImageCache cache) {

   final BitmapFactory.Options options = new BitmapFactory.Options();
   ...
   BitmapFactory.decodeFile(filename, options);
   ...

   // If we're running on Honeycomb or newer, try to use inBitmap.
   if (Utils.hasHoneycomb()) {
        addInBitmapOptions(options, cache);
   }
   ...
   return BitmapFactory.decodeFile(filename, options);
}

private static void addInBitmapOptions(BitmapFactory.Options options,
        ImageCache cache) {
   // inBitmap only works with mutable bitmaps, so force the decoder to
   // return mutable bitmaps.
   options.inMutable = true ;

   if (cache != null ) {
        // Try to find a bitmap to use for inBitmap.
        Bitmap inBitmap = cache.getBitmapFromReusableSet(options);

        if (inBitmap != null ) {
            // If a suitable bitmap has been found, set it as the value of
            // inBitmap.
            options.inBitmap = inBitmap;
        }
   }
}

// This method iterates through the reusable bitmaps, looking for one
// to use for inBitmap:
protected Bitmap getBitmapFromReusableSet(BitmapFactory.Options options) {
        Bitmap bitmap = null ;

   if (mReusableBitmaps != null && !mReusableBitmaps.isEmpty()) {
        final Iterator<SoftReference<Bitmap>> iterator
               = mReusableBitmaps.iterator();
        Bitmap item;

        while (iterator.hasNext()) {
            item = iterator.next().get();

            if ( null != item && item.isMutable()) {
               // Check to see it the item can be used for inBitmap.
               if (canUseForInBitmap(item, options)) {
                    bitmap = item;

                    // Remove from reusable set so it can't be used again.
                    iterator.remove();
                    break ;
               }
            } else {
               // Remove from the set if the reference has been cleared.
               iterator.remove();
            }
        }
   }
   return bitmap;
}

private static boolean canUseForInBitmap(
        Bitmap candidate, BitmapFactory.Options targetOptions) {
   int width = targetOptions.outWidth / targetOptions.inSampleSize;
   int height = targetOptions.outHeight / targetOptions.inSampleSize;

   // Returns true if "candidate" can be used for inBitmap re-use with
   // "targetOptions".
   return candidate.getWidth() == width && candidate.getHeight() == height;
}

在UI中显示Bitmap

将Bitmap加载到ViewPager实现

一个交换的视图模式是浏览一个图片库详细信息视图很好的一个方式。你可以使用由PagerAdapter
和ViewPager来实现这种模式。然而，一个更合适的适配器是FragmentStatePagerAdapter，它
能自动销毁和保存在ViewPager中Fragments的状态。

public class ImageDetailActivity extends FragmentActivity {
   public static final String EXTRA_IMAGE = "extra_image" ;

   private ImagePagerAdapter mAdapter;
   private ViewPager mPager;

   // A static dataset to back the ViewPager adapter
   public final static Integer[] imageResIds = new Integer[] {
            R.drawable.sample_image_1, R.drawable.sample_image_2, R.drawable.sample_image_3,
            R.drawable.sample_image_4, R.drawable.sample_image_5, R.drawable.sample_image_6,
            R.drawable.sample_image_7, R.drawable.sample_image_8, R.drawable.sample_image_9};

   @Override
   public void onCreate(Bundle savedInstanceState) {
        super .onCreate(savedInstanceState);
        setContentView(R.layout.image_detail_pager); // Contains just a ViewPager

        mAdapter = new ImagePagerAdapter(getSupportFragmentManager(), imageResIds.length);
        mPager = (ViewPager) findViewById(R.id.pager);
        mPager.setAdapter(mAdapter);
   }

   public static class ImagePagerAdapter extends FragmentStatePagerAdapter {
        private final int mSize;

        public ImagePagerAdapter(FragmentManager fm, int size) {
            super (fm);
            mSize = size;
        }

        @Override
        public int getCount() {
            return mSize;
        }

        @Override
        public Fragment getItem( int position) {
            return ImageDetailFragment.newInstance(position);
        }
   }
}

下面是一个持有ImageView的详细Fragment的实现。这似乎是一个完全合理的做法，但你能
看到这种实现的缺点吗？如何进行改善？

public class ImageDetailFragment extends Fragment {
   private static final String IMAGE_DATA_EXTRA = "resId" ;
   private int mImageNum;
   private ImageView mImageView;

   static ImageDetailFragment newInstance( int imageNum) {
        final ImageDetailFragment f = new ImageDetailFragment();
        final Bundle args = new Bundle();
        args.putInt(IMAGE_DATA_EXTRA, imageNum);
        f.setArguments(args);
        return f;
   }

   // Empty constructor, required as per Fragment docs
   public ImageDetailFragment() {}

   @Override
   public void onCreate(Bundle savedInstanceState) {
        super .onCreate(savedInstanceState);
        mImageNum = getArguments() != null ? getArguments().getInt(IMAGE_DATA_EXTRA) : - 1 ;
   }

   @Override
   public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        // image_detail_fragment.xml contains just an ImageView
        final View v = inflater.inflate(R.layout.image_detail_fragment, container, false );
        mImageView = (ImageView) v.findViewById(R.id.imageView);
        return v;
   }

   @Override
   public void onActivityCreated(Bundle savedInstanceState) {
        super .onActivityCreated(savedInstanceState);
        final int resId = ImageDetailActivity.imageResIds[mImageNum];
        mImageView.setImageResource(resId); // Load image into ImageView
   }
}

问题是：图片在UI线程中被读取。使用一个AsyncTask。

?

代码片段，双击复制