Displaying Bitmaps in Your UI[在UI上呈现Bitmap]

最新推荐文章于 2023-04-23 00:19:25 发布

lzhang616

最新推荐文章于 2023-04-23 00:19:25 发布

阅读量659

点赞数

分类专栏： android 文章标签： android Cache Bitmap

android 专栏收录该内容

55 篇文章 0 订阅

订阅专栏

Displaying Bitmaps in Your UI [在UI上呈现Bitmap]

这一课会演示如何运用前面三节课的内容，使用后台线程与Cache机制来加载图片到 ViewPager 与 GridView 组件，并且学习处理并发与配置改变问题。
[并发问题的处理确实需要好好考虑，大多数App都没有仔细考虑到这个问题，会导致浪费更多的资源，效率不够]。

Load Bitmaps into a ViewPager Implementation [实现加载图片到ViewPager]

swipe view pattern 是一个用来切换显示不同详情界面的很好的方法。[关于这种效果请先参看Android Design: Swipe Views ，这是一个很好的设计，在很多App里面都可以看到这种设计，例如网易阅读，在阅读文章时可以左右滑动来切换文章，在Google Reader里面文章的切换也是这样，不过最终网易还是做的稍微好些，因为GReader对手势的判断有点过了，一不小心左右碰到就可能文章被切换掉，这点让我很苦恼，而网易阅读避免了这样的问题，需要用户动作稍大才会出现切换的效果] .
你可以通过 PagerAdapter 与 ViewPager 组件来实现这个效果. 然而，一个更加合适的Adapter是PagerAdapter 的子类 FragmentStatePagerAdapter：它可以在某个ViewPager中的子视图切换出屏幕时自动销毁与保存 Fragments 的状态。这样能够保持消耗更少的内存。
- Note: 如果你只有为数不多的图片并且确保不会超出程序内存限制，那么使用 PagerAdapter 或 FragmentPagerAdapter 会更加合适。
下面是一个使用ViewPager与ImageView作为子视图的示例。

 
   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);  
         }  
     }  
 }  
 
 

Fragment 里面包含了ImageView 的子组件:

 
    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 Thread中读取图片可能会导致程序ANR。使用在Lesson 2中学习的 AsyncTask 会比较好。

 
   public class ImageDetailActivity extends FragmentActivity {  
     ...  
   
     public void loadBitmap(int resId, ImageView imageView) {  
         mImageView.setImageResource(R.drawable.image_placeholder);  
         BitmapWorkerTask task = new BitmapWorkerTask(mImageView);  
         task.execute(resId);  
     }  
   
     ... // include BitmapWorkerTask class  
 }  
   
 public class ImageDetailFragment extends Fragment {  
     ...  
   
     @Override  
     public void onActivityCreated(Bundle savedInstanceState) {  
         super.onActivityCreated(savedInstanceState);  
         if (ImageDetailActivity.class.isInstance(getActivity())) {  
             final int resId = ImageDetailActivity.imageResIds[mImageNum];  
             // Call out to ImageDetailActivity to load the bitmap in a background thread  
             ((ImageDetailActivity) getActivity()).loadBitmap(resId, mImageView);  
         }  
     }  
 }  
 
 

在 BitmapWorkerTask 中做一些例如resizing or fetching images from the network，不会卡到UI Thread。如果后台线程不仅仅是做个简单的直接加载动作，增加一个内存Cache或者磁盘Cache会比较好[参考Lesson 3] ,下面是一些为了内存Cache而附加的内容:

 
   public class ImageDetailActivity extends FragmentActivity {  
     ...  
     private LruCache mMemoryCache;  
   
     @Override  
     public void onCreate(Bundle savedInstanceState) {  
         ...  
         // initialize LruCache as per Use a Memory Cache section  
     }  
   
     public void loadBitmap(int resId, ImageView imageView) {  
         final String imageKey = String.valueOf(resId);  
   
         final Bitmap bitmap = mMemoryCache.get(imageKey);  
         if (bitmap != null) {  
             mImageView.setImageBitmap(bitmap);  
         } else {  
             mImageView.setImageResource(R.drawable.image_placeholder);  
             BitmapWorkerTask task = new BitmapWorkerTask(mImageView);  
             task.execute(resId);  
         }  
     }  
   
     ... // include updated BitmapWorkerTask from Use a Memory Cache section  
 }  
 
 

Load Bitmaps into a GridView Implementation [实现加载图片到GridView]

grid list building block 是一种有效显示大量图片的方式。这样能够一次显示许多图片，而且那些即将被显示的图片也处于准备显示状态。如果你想要实现这种效果，你必须确保UI是流畅的，能够控制内存使用，并且正确的处理并发问题（因为 GridView 会循环使用子视图)。
下面是一个在Fragment里面内置了ImageView作为GridView子视图的示例：

 
   public class ImageGridFragment extends Fragment implements AdapterView.OnItemClickListener {  
     private ImageAdapter mAdapter;  
   
     // A static dataset to back the GridView 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};  
   
     // Empty constructor as per Fragment docs  
     public ImageGridFragment() {}  
   
     @Override  
     public void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         mAdapter = new ImageAdapter(getActivity());  
     }  
   
     @Override  
     public View onCreateView(  
             LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {  
         final View v = inflater.inflate(R.layout.image_grid_fragment, container, false);  
         final GridView mGridView = (GridView) v.findViewById(R.id.gridView);  
         mGridView.setAdapter(mAdapter);  
         mGridView.setOnItemClickListener(this);  
         return v;  
     }  
   
     @Override  
     public void onItemClick(AdapterView parent, View v, int position, long id) {  
         final Intent i = new Intent(getActivity(), ImageDetailActivity.class);  
         i.putExtra(ImageDetailActivity.EXTRA_IMAGE, position);  
         startActivity(i);  
     }  
   
     private class ImageAdapter extends BaseAdapter {  
         private final Context mContext;  
   
         public ImageAdapter(Context context) {  
             super();  
             mContext = context;  
         }  
   
         @Override  
         public int getCount() {  
             return imageResIds.length;  
         }  
   
         @Override  
         public Object getItem(int position) {  
             return imageResIds[position];  
         }  
   
         @Override  
         public long getItemId(int position) {  
             return position;  
         }  
   
         @Override  
         public View getView(int position, View convertView, ViewGroup container) {  
             ImageView imageView;  
             if (convertView == null) { // if it's not recycled, initialize some attributes  
                 imageView = new ImageView(mContext);  
                 imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);  
                 imageView.setLayoutParams(new GridView.LayoutParams(  
                         LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));  
             } else {  
                 imageView = (ImageView) convertView;  
             }  
 
 

 
           //请注意下面的代码  
         imageView.setImageResource(imageResIds[position]); // Load image into ImageView  
         return imageView;  
     }  
 }  
 
 

与前面加载到图片到ViewPager一样，如果setImageResource的操作会比较耗时，有可能会卡到UI Thread。
可以使用类似前面异步处理图片与增加缓存的方法来解决那个问题。然而，我们还需要考虑GridView的循环机制所带来的并发问题。为了处理这个问题，请参考前面Lesson 2: Processing Bitmaps Off the UI Thread 。下面是一个更新的解决方案：

 
   public class ImageGridFragment extends Fragment implements AdapterView.OnItemClickListener {  
     ...  
   
     private class ImageAdapter extends BaseAdapter {  
         ...  
   
         @Override  
         public View getView(int position, View convertView, ViewGroup container) {  
             ...  
             loadBitmap(imageResIds[position], imageView)  
             return imageView;  
         }  
     }  
   
     public void loadBitmap(int resId, ImageView imageView) {  
         if (cancelPotentialWork(resId, imageView)) {  
             final BitmapWorkerTask task = new BitmapWorkerTask(imageView);  
             final AsyncDrawable asyncDrawable =  
                     new AsyncDrawable(getResources(), mPlaceHolderBitmap, task);  
             imageView.setImageDrawable(asyncDrawable);  
             task.execute(resId);  
         }  
     }  
   
     static class AsyncDrawable extends BitmapDrawable {  
         private final WeakReference bitmapWorkerTaskReference;  
   
         public AsyncDrawable(Resources res, Bitmap bitmap,  
                 BitmapWorkerTask bitmapWorkerTask) {  
             super(res, bitmap);  
             bitmapWorkerTaskReference =  
                 new WeakReference(bitmapWorkerTask);  
         }  
   
         public BitmapWorkerTask getBitmapWorkerTask() {  
             return bitmapWorkerTaskReference.get();  
         }  
     }  
   
     public static boolean cancelPotentialWork(int data, ImageView imageView) {  
         final BitmapWorkerTask bitmapWorkerTask = getBitmapWorkerTask(imageView);  
   
         if (bitmapWorkerTask != null) {  
             final int bitmapData = bitmapWorkerTask.data;  
             if (bitmapData != data) {  
                 // Cancel previous task  
                 bitmapWorkerTask.cancel(true);  
             } else {  
                 // The same work is already in progress  
                 return false;  
             }  
         }  
         // No task associated with the ImageView, or an existing task was cancelled  
         return true;  
     }  
   
     private static BitmapWorkerTask getBitmapWorkerTask(ImageView imageView) {  
        if (imageView != null) {  
            final Drawable drawable = imageView.getDrawable();  
            if (drawable instanceof AsyncDrawable) {  
                final AsyncDrawable asyncDrawable = (AsyncDrawable) drawable;  
                return asyncDrawable.getBitmapWorkerTask();  
            }  
         }  
         return null;  
     }  
   
     ... // include updated BitmapWorkerTask class  
 
 