在UI上显示Bitmap

编写:kesenhoo - 原文:http://developer.android.com/training/displaying-bitmaps/display-bitmap.html

这一课会演示如何运用前面几节课的内容，使用后台线程与缓存机制将图片加载到ViewPager与GridView控件，并且学习处理并发与配置改变问题。

实现加载图片到ViewPager

Swipe View Pattern是一个使用滑动来切换显示不同详情页面的设计模型。（关于这种效果请先参看Android Design: Swipe Views）。我们可以通过PagerAdapter与ViewPager控件来实现这个效果。 不过，一个更加合适的Adapter是PagerAdapter的一个子类，叫做FragmentStatePagerAdapter：它可以在某个ViewPager中的子视图切换出屏幕时自动销毁与保存Fragments的状态。这样能够保持更少的内存消耗。

Note: 如果只有为数不多的图片并且确保不会超出程序内存限制，那么使用PagerAdapter或 FragmentPagerAdapter会更加合适。

下面是一个使用ViewPager与ImageView作为子视图的示例。主Activity包含有ViewPager和Adapter。

  1. public class ImageDetailActivity extends FragmentActivity {
  2.     public static final String EXTRA_IMAGE = "extra_image";
  4.     private ImagePagerAdapter mAdapter;
  5.     private ViewPager mPager;
  7.     // A static dataset to back the ViewPager adapter
  8.     public final static Integer[] imageResIds = new Integer[] {
  9.             R.drawable.sample_image_1, R.drawable.sample_image_2, R.drawable.sample_image_3,
  10.             R.drawable.sample_image_4, R.drawable.sample_image_5, R.drawable.sample_image_6,
  11.             R.drawable.sample_image_7, R.drawable.sample_image_8, R.drawable.sample_image_9};
  13.     @Override
  14.     public void onCreate(Bundle savedInstanceState) {
  15.         super.onCreate(savedInstanceState);
  16.         setContentView(R.layout.image_detail_pager); // Contains just a ViewPager
  18.         mAdapter = new ImagePagerAdapter(getSupportFragmentManager(), imageResIds.length);
  19.         mPager = (ViewPager) findViewById(R.id.pager);
  20.         mPager.setAdapter(mAdapter);
  21.     }
  23.     public static class ImagePagerAdapter extends FragmentStatePagerAdapter {
  24.         private final int mSize;
  26.         public ImagePagerAdapter(FragmentManager fm, int size) {
  27.             super(fm);
  28.             mSize = size;
  29.         }
  31.         @Override
  32.         public int getCount() {
  33.             return mSize;
  34.         }
  36.         @Override
  37.         public Fragment getItem(int position) {
  38.             return ImageDetailFragment.newInstance(position);
  39.         }
  40.     }
  41. }

Fragment里面包含了ImageView控件:

  1. public class ImageDetailFragment extends Fragment {
  2.     private static final String IMAGE_DATA_EXTRA = "resId";
  3.     private int mImageNum;
  4.     private ImageView mImageView;
  6.     static ImageDetailFragment newInstance(int imageNum) {
  7.         final ImageDetailFragment f = new ImageDetailFragment();
  8.         final Bundle args = new Bundle();
  9.         args.putInt(IMAGE_DATA_EXTRA, imageNum);
  10.         f.setArguments(args);
  11.         return f;
  12.     }
  14.     // Empty constructor, required as per Fragment docs
  15.     public ImageDetailFragment() {}
  17.     @Override
  18.     public void onCreate(Bundle savedInstanceState) {
  19.         super.onCreate(savedInstanceState);
  20.         mImageNum = getArguments() != null ? getArguments().getInt(IMAGE_DATA_EXTRA) : -1;
  21.     }
  23.     @Override
  24.     public View onCreateView(LayoutInflater inflater, ViewGroup container,
  25.             Bundle savedInstanceState) {
  26.         // image_detail_fragment.xml contains just an ImageView
  27.         final View v = inflater.inflate(R.layout.image_detail_fragment, container, false);
  28.         mImageView = (ImageView) v.findViewById(R.id.imageView);
  29.         return v;
  30.     }
  32.     @Override
  33.     public void onActivityCreated(Bundle savedInstanceState) {
  34.         super.onActivityCreated(savedInstanceState);
  35.         final int resId = ImageDetailActivity.imageResIds[mImageNum];
  36.         mImageView.setImageResource(resId); // Load image into ImageView
  37.     }
  38. }

希望你有发现上面示例存在的问题：在UI线程中读取图片可能会导致应用无响应。因此使用在第二课中学习的AsyncTask会更好。

  1. public class ImageDetailActivity extends FragmentActivity {
  2.     ...
  4.     public void loadBitmap(int resId, ImageView imageView) {
  5.         mImageView.setImageResource(R.drawable.image_placeholder);
  6.         BitmapWorkerTask task = new BitmapWorkerTask(mImageView);
  7.         task.execute(resId);
  8.     }
  10.     ... // include BitmapWorkerTask class
  11. }
  13. public class ImageDetailFragment extends Fragment {
  14.     ...
  16.     @Override
  17.     public void onActivityCreated(Bundle savedInstanceState) {
  18.         super.onActivityCreated(savedInstanceState);
  19.         if (ImageDetailActivity.class.isInstance(getActivity())) {
  20.             final int resId = ImageDetailActivity.imageResIds[mImageNum];
  21.             // Call out to ImageDetailActivity to load the bitmap in a background thread
  22.             ((ImageDetailActivity) getActivity()).loadBitmap(resId, mImageView);
  23.         }
  24.     }
  25. }

在BitmapWorkerTask中做一些例如重设图片大小，从网络拉取图片的任务，可以确保不会阻塞UI线程。如果后台线程不仅仅是一个简单的加载操作，增加一个内存缓存或者磁盘缓存会比较好（请参考第三课：缓存Bitmap），下面是一些为了内存缓存而附加的内容：

  1. public class ImageDetailActivity extends FragmentActivity {
  2.     ...
  3.     private LruCache mMemoryCache;
  5.     @Override
  6.     public void onCreate(Bundle savedInstanceState) {
  7.         ...
  8.         // initialize LruCache as per Use a Memory Cache section
  9.     }
  11.     public void loadBitmap(int resId, ImageView imageView) {
  12.         final String imageKey = String.valueOf(resId);
  14.         final Bitmap bitmap = mMemoryCache.get(imageKey);
  15.         if (bitmap != null) {
  16.             mImageView.setImageBitmap(bitmap);
  17.         } else {
  18.             mImageView.setImageResource(R.drawable.image_placeholder);
  19.             BitmapWorkerTask task = new BitmapWorkerTask(mImageView);
  20.             task.execute(resId);
  21.         }
  22.     }
  24.     ... // include updated BitmapWorkerTask from Use a Memory Cache section
  25. }

把前面学习到的所有技巧合并起来，我们将得到一个响应性良好的ViewPager实现：它拥有最小的加载延迟，同时可以根据实际需求执行不同的后台处理任务。

实现加载图片到GridView

Grid List Building Block是一种有效显示大量图片的方式。它能够一次显示许多图片，同时即将被显示的图片会处于准备显示的状态。如果我们想要实现这种效果，必须确保UI是流畅的，能够控制内存使用，并且正确处理并发问题（因为GridView会循环使用子视图)。

下面是一个典型的使用场景，在Fragment里面内置GridView，其中GridView的子视图是ImageView：

  1. public class ImageGridFragment extends Fragment implements AdapterView.OnItemClickListener {
  2.     private ImageAdapter mAdapter;
  4.     // A static dataset to back the GridView adapter
  5.     public final static Integer[] imageResIds = new Integer[] {
  6.             R.drawable.sample_image_1, R.drawable.sample_image_2, R.drawable.sample_image_3,
  7.             R.drawable.sample_image_4, R.drawable.sample_image_5, R.drawable.sample_image_6,
  8.             R.drawable.sample_image_7, R.drawable.sample_image_8, R.drawable.sample_image_9};
  10.     // Empty constructor as per Fragment docs
  11.     public ImageGridFragment() {}
  13.     @Override
  14.     public void onCreate(Bundle savedInstanceState) {
  15.         super.onCreate(savedInstanceState);
  16.         mAdapter = new ImageAdapter(getActivity());
  17.     }
  19.     @Override
  20.     public View onCreateView(
  21.             LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
  22.         final View v = inflater.inflate(R.layout.image_grid_fragment, container, false);
  23.         final GridView mGridView = (GridView) v.findViewById(R.id.gridView);
  24.         mGridView.setAdapter(mAdapter);
  25.         mGridView.setOnItemClickListener(this);
  26.         return v;
  27.     }
  29.     @Override
  30.     public void onItemClick(AdapterView parent, View v, int position, long id) {
  31.         final Intent i = new Intent(getActivity(), ImageDetailActivity.class);
  32.         i.putExtra(ImageDetailActivity.EXTRA_IMAGE, position);
  33.         startActivity(i);
  34.     }
  36.     private class ImageAdapter extends BaseAdapter {
  37.         private final Context mContext;
  39.         public ImageAdapter(Context context) {
  40.             super();
  41.             mContext = context;
  42.         }
  44.         @Override
  45.         public int getCount() {
  46.             return imageResIds.length;
  47.         }
  49.         @Override
  50.         public Object getItem(int position) {
  51.             return imageResIds[position];
  52.         }
  54.         @Override
  55.         public long getItemId(int position) {
  56.             return position;
  57.         }
  59.         @Override
  60.         public View getView(int position, View convertView, ViewGroup container) {
  61.             ImageView imageView;
  62.             if (convertView == null) { // if it's not recycled, initialize some attributes
  63.                 imageView = new ImageView(mContext);
  64.                 imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);
  65.                 imageView.setLayoutParams(new GridView.LayoutParams(
  66.                         LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
  67.             } else {
  68.                 imageView = (ImageView) convertView;
  69.             }
  70.         //请注意下面的代码
  71.         imageView.setImageResource(imageResIds[position]); // Load image into ImageView
  72.         return imageView;
  73.     }
  74. }

这里同样有一个问题，上面的代码实现中，犯了把图片加载放在UI线程进行处理的错误。如果只是加载一些很小的图片，或者是经过Android系统缩放并缓存过的图片，上面的代码在运行时不会有太大问题，但是如果加载的图片稍微复杂耗时一点，这都会导致你的UI卡顿甚至应用无响应。

与前面加载图片到ViewPager一样，如果setImageResource的操作会比较耗时，也有可能会阻塞UI线程。不过我们可以使用类似前面异步处理图片与增加缓存的方法来解决这个问题。然而，我们还需要考虑GridView的循环机制所带来的并发问题。为了处理这个问题，可以参考前面的课程 。下面是一个更新过后的解决方案：

  1. public class ImageGridFragment extends Fragment implements AdapterView.OnItemClickListener {
  2.     ...
  4.     private class ImageAdapter extends BaseAdapter {
  5.         ...
  7.         @Override
  8.         public View getView(int position, View convertView, ViewGroup container) {
  9.             ...
  10.             loadBitmap(imageResIds[position], imageView)
  11.             return imageView;
  12.         }
  13.     }
  15.     public void loadBitmap(int resId, ImageView imageView) {
  16.         if (cancelPotentialWork(resId, imageView)) {
  17.             final BitmapWorkerTask task = new BitmapWorkerTask(imageView);
  18.             final AsyncDrawable asyncDrawable =
  19.                     new AsyncDrawable(getResources(), mPlaceHolderBitmap, task);
  20.             imageView.setImageDrawable(asyncDrawable);
  21.             task.execute(resId);
  22.         }
  23.     }
  25.     static class AsyncDrawable extends BitmapDrawable {
  26.         private final WeakReference bitmapWorkerTaskReference;
  28.         public AsyncDrawable(Resources res, Bitmap bitmap,
  29.                 BitmapWorkerTask bitmapWorkerTask) {
  30.             super(res, bitmap);
  31.             bitmapWorkerTaskReference =
  32.                 new WeakReference(bitmapWorkerTask);
  33.         }
  35.         public BitmapWorkerTask getBitmapWorkerTask() {
  36.             return bitmapWorkerTaskReference.get();
  37.         }
  38.     }
  40.     public static boolean cancelPotentialWork(int data, ImageView imageView) {
  41.         final BitmapWorkerTask bitmapWorkerTask = getBitmapWorkerTask(imageView);
  43.         if (bitmapWorkerTask != null) {
  44.             final int bitmapData = bitmapWorkerTask.data;
  45.             if (bitmapData != data) {
  46.                 // Cancel previous task
  47.                 bitmapWorkerTask.cancel(true);
  48.             } else {
  49.                 // The same work is already in progress
  50.                 return false;
  51.             }
  52.         }
  53.         // No task associated with the ImageView, or an existing task was cancelled
  54.         return true;
  55.     }
  57.     private static BitmapWorkerTask getBitmapWorkerTask(ImageView imageView) {
  58.        if (imageView != null) {
  59.            final Drawable drawable = imageView.getDrawable();
  60.            if (drawable instanceof AsyncDrawable) {
  61.                final AsyncDrawable asyncDrawable = (AsyncDrawable) drawable;
  62.                return asyncDrawable.getBitmapWorkerTask();
  63.            }
  64.         }
  65.         return null;
  66.     }
  68.     ... // include updated BitmapWorkerTask class

Note:对于ListView同样可以套用上面的方法。

上面的方法提供了足够的弹性，使得我们可以做从网络下载图片，并对大尺寸大的数码照片做缩放等操作而不至于阻塞UI线程。