Bitmap(四)

最新推荐文章于 2024-11-03 16:35:57 发布
最新推荐文章于 2024-11-03 16:35:57 发布
阅读量78 收藏
点赞数
文章标签： 移动开发 java ui
原文链接：http://www.cnblogs.com/fishbone-lsy/p/4541773.html
版权

　　Bitmap(一)　　http://www.cnblogs.com/fishbone-lsy/p/4486571.html

　　Bitmap(二) 　  http://www.cnblogs.com/fishbone-lsy/p/4496166.html

　　Bitmap(三) 　  http://www.cnblogs.com/fishbone-lsy/p/4526922.html

　　在Bitmap(一)中介绍了，Bitmap如何通过BitmapFactory获得图片资源。在Bitmap(二)中，介绍了将Bitmap进行预加载，缩放，再载入ImageView。Bitmap(三)中，介绍了通过异步任务加载图片，并使用弱引用封装ImageView。

　　上面三节在加载单张图片时，已经满足基本要求了。但是，在多个图片的ListView中，那个方法就不适用了。

　　上一节最后的代码是这样的

        LoadImageTask task = new LoadImageTask(imageView1 , 100 , 100);
        task.execute(R.drawable.images);

　　如果我将上面一段代码放在自定义Adapter里面的getView中，每一个Item都会开启一个新的线程。由于Item在getView中会以viewHolder的形式重用，当用户疯狂地上下滑动ListView时，就会产生N个LoadImageTask在为同一个ImageView工作。这显然是非常不科学的。

　　我们希望，每个ImageView只有一个属于自己的线程，如果这个ImageView被重用有了新的任务，那么它前面未加载完成的任务也应该中止掉。因此在这一节中，我们试图将ImageView和LoadImageTask绑定起来，顺便给它一个defaultBitmap用作加载过程中的显示图片。它的最终形式应该是这个样子

 public void loadBitmap(int resId, ImageView imageView , int defaultResId , int reqWidth , int reqHeight)

　　使用它时，应该只需要这样子

loadBitmap(R.drawable.images2 , imageView1 , R.drawable.images , 100 , 100);

 

　　好了，开始说怎么做。第一步，就如上面所说，我们要绑定ImageView和LoadImageTask，顺便加上defaultBitmap。所以首先使用了BitmapDrawable：

    /**
     * 将Bitmap的加载task封装进BitmapDrawable中,设置默认图，并在加载完新图后换掉
     */
    private class AsyncDrawable extends BitmapDrawable{
        private final WeakReference<LoadImageTask> bitmapWorkTask ;
        public AsyncDrawable(Resources resources, Bitmap bitmap, LoadImageTask bitmapWorkTask){
            super(resources,bitmap);
            this.bitmapWorkTask = new WeakReference<LoadImageTask>(bitmapWorkTask);
        }
        public LoadImageTask getLoadImageTask(){
            return bitmapWorkTask.get();
        }
    }

 

在上面的代码中，通过一个弱引用，将LoadImageTask和Bitmap绑定了起来。

　　然后，将封装了Bitmap和LoadImageTask的AsyncDrawable，通过imageView.setImageDrawable(asyncDrawable);直接赋给ImageView，最后再开始加载异步任务。

    /**
     * 加载图片
     * @param resId
     * @param imageView
     * @param defaultResId
     * @param reqWidth
     * @param reqHeight
     */
    public void loadBitmap(int resId, ImageView imageView , int defaultResId , int reqWidth , int reqHeight) {
        //判断任务是否正在进行
        if (cancelPotentialWork(resId, imageView)) {
            final LoadImageTask task = new LoadImageTask(imageView , reqWidth , reqHeight );
            AsyncDrawable asyncDrawable = null;
            try{
                asyncDrawable = new AsyncDrawable(getResources(), BitmapFactory.decodeResource(getResources() , defaultResId), task);
            }catch (Exception ex){
                asyncDrawable = new AsyncDrawable(getResources(), BitmapFactory.decodeResource(getResources() , R.mipmap.ic_launcher) , task);
            }
            imageView.setImageDrawable(asyncDrawable);
            task.execute(resId);
        }
    }

　　　这样，每次赋给ImageView的不仅仅是一张图片，而是一张默认图片、一张目标图片和一个加载目标图片的异步任务。当我们要在ImageView上开一个新任务时，可以在新开任务前判断，我要开始的任务的目标是不是和正在进行的任务目标一致，如果一致就不要新开任务了。

　　那么如何进行这样的判断呢？

　　首先，我们需要一个方法，能取出ImageView中的LoadImageTask，原理是取出ImageView中的Drawable，然后判断它是不是AsyncDrawable，进而取出它的LoadImageTask。

    /**
     * 获得视图当前任务
     * @param imageView
     * @return
     */
    private LoadImageTask getLoadImageTask(ImageView imageView){
        if(imageView != null ){
            final Drawable drawable = imageView.getDrawable();
            if(drawable instanceof AsyncDrawable){
                final AsyncDrawable asyncDrawable = (AsyncDrawable) drawable;
                return asyncDrawable.getLoadImageTask();
            }
        }
        return null;
    }

　

　　然后，我们需要给异步任务类加入能够取出它当前正在进行的任务的目标的方法

    /**
     * 异步加载图像的任务类
     */
    private class LoadImageTask extends AsyncTask<Integer , Void , Bitmap>{
        private final  WeakReference imageViewReference;
        private final int mReqWidth , mReqHeight;
        private int data = 0;
        public LoadImageTask(ImageView imageView , int reqWidth , int reqHeight){
            imageViewReference = new WeakReference<ImageView>(imageView);
            mReqWidth = reqWidth;
            mReqHeight = reqHeight;
        }
        @Override
        protected Bitmap doInBackground(Integer... params) {
            data = params[0];
            return decodeSampledBitmapFromResource(getResources() , params[0],mReqWidth , mReqHeight);
        }
        @Override
        protected void onPostExecute(Bitmap bitmap) {
            //因为目标切换等原因中止了任务
            if (isCancelled()) {
                bitmap = null;
            }
            if(bitmap!=null && imageViewReference !=null){
                final ImageView imageView = (ImageView) imageViewReference.get();
                if(imageView != null){

                    final LoadImageTask loadImageTask = getLoadImageTask(imageView);
                    if (this == loadImageTask){
                        imageView.setImageBitmap(bitmap);
                    }
                }
            }
        }
        public int getData() {
            return data;
        }
    }

值得一提的是，所谓的中止异步任务，并不是说能够在异步任务外的UI线程中，中止它。我们所能做的，只能是将异步任务中的cancel标志位设为true，真正中止它的，只能是在异步任务内，通过检测isCancelled来决定它是否要使自己无效。

　　最后，是判断目标任务与正在进行中的任务是否一致的方法：

    /**
     * 通过判断任务中的数据，任务是否已经开始，或者任务目标与当前需求目标不同。
     * @param res
     * @param imageView
     * bitmapData为正在进行中的任务的目标resId
     * @return false:目标任务与正在进行的任务相同
     */
    private boolean cancelPotentialWork(int res , ImageView imageView){
        final LoadImageTask loadImageTask = getLoadImageTask(imageView);
        if (loadImageTask!=null){
            final int bitmapData = loadImageTask.getData();
            // If bitmapData is not yet set or it differs from the new data
            if (bitmapData == 0  ||  bitmapData != res ){
                loadImageTask.cancel(true);
            }
            else{
                return false;
            }
        }
        return true;
    }

该方法只有在没有进行中的任务，或者目标任务与正在进行中的任务不同时，才会返回true。然后结合loadBitmap方法，只有在返回true时，才会加载图片，开启新任务。

　　

　　虽然过程比较繁琐，但是用起来，就简单了！

    public void createImage(View view){
        loadBitmap(R.drawable.images2 , imageView1 , R.drawable.images , 30 , 30);
    }

　　Done

 

最后附上一套稍微完整一点的代码

import android.app.Activity;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.AsyncTask;
import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.ImageView;

import java.lang.ref.WeakReference;


public class MainActivity extends Activity {
    private ImageView imageView1,imageView2;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        imageView1 = (ImageView) findViewById(R.id.image1);
    }

    /**
     * 计算图象的缩放比例
     * @param options   图像的参数设置接口
     * @param reqWidth  要求的宽
     * @param reqHeight 要求的高
     * @return  缩放比例,系数越大缩小的越多
     */
    private 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;

        if (height > reqHeight || width > reqWidth) {

            final int halfHeight = height / 2;
            final int halfWidth = width / 2;

            // Calculate the largest inSampleSize value that is a power of 2 and keeps both
            // height and width larger than the requested height and width.
            while ((halfHeight / inSampleSize) > reqHeight
                    && (halfWidth / inSampleSize) > reqWidth) {
                inSampleSize *= 2;
            }
        }
        return inSampleSize;
    }

    /**
     * 压缩图片
     * @param res           系统资源
     * @param resId         压缩前的资源ID
     * @param reqWidth      要求的宽
     * @param reqHeight     要求的高
     * @return  压缩后的Bitmap图
     */
    private Bitmap decodeSampledBitmapFromResource(Resources res, int resId,
                                                         int reqWidth, int reqHeight) {

        // First decode with inJustDecodeBounds=true to check dimensions
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeResource(res, resId, options);

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

        // Decode bitmap with inSampleSize set
        options.inJustDecodeBounds = false;
        return BitmapFactory.decodeResource(res, resId, options);
    }

    /**
     * 异步加载图像的任务类
     */
    private class LoadImageTask extends AsyncTask<Integer , Void , Bitmap>{
        private final  WeakReference imageViewReference;
        private final int mReqWidth , mReqHeight;
        private int data = 0;
        public LoadImageTask(ImageView imageView , int reqWidth , int reqHeight){
            imageViewReference = new WeakReference<ImageView>(imageView);
            mReqWidth = reqWidth;
            mReqHeight = reqHeight;
        }
        @Override
        protected Bitmap doInBackground(Integer... params) {
            data = params[0];
            return decodeSampledBitmapFromResource(getResources() , params[0],mReqWidth , mReqHeight);
        }
        @Override
        protected void onPostExecute(Bitmap bitmap) {
            //因为目标切换等原因中止了任务
            if (isCancelled()) {
                bitmap = null;
            }
            if(bitmap!=null && imageViewReference !=null){
                final ImageView imageView = (ImageView) imageViewReference.get();
                if(imageView != null){

                    final LoadImageTask loadImageTask = getLoadImageTask(imageView);
                    if (this == loadImageTask){
                        imageView.setImageBitmap(bitmap);
                    }

                }
            }
        }
        public int getData() {
            return data;
        }
    }

    /**
     * 将Bitmap的加载task封装进BitmapDrawable中,设置默认图，并在加载完新图后换掉
     */
    private class AsyncDrawable extends BitmapDrawable{
        private final WeakReference<LoadImageTask> bitmapWorkTask ;
        public AsyncDrawable(Resources resources, Bitmap bitmap, LoadImageTask bitmapWorkTask){
            super(resources,bitmap);
            this.bitmapWorkTask = new WeakReference<LoadImageTask>(bitmapWorkTask);
        }
        public LoadImageTask getLoadImageTask(){
            return bitmapWorkTask.get();
        }
    }

    /**
     * 加载图片
     * @param resId
     * @param imageView
     * @param defaultResId
     * @param reqWidth
     * @param reqHeight
     */
    public void loadBitmap(int resId, ImageView imageView , int defaultResId , int reqWidth , int reqHeight) {
        //判断任务是否正在进行
        if (cancelPotentialWork(resId, imageView)) {
            final LoadImageTask task = new LoadImageTask(imageView , reqWidth , reqHeight );
            AsyncDrawable asyncDrawable = null;
            try{
                asyncDrawable = new AsyncDrawable(getResources(), BitmapFactory.decodeResource(getResources() , defaultResId), task);
            }catch (Exception ex){
                asyncDrawable = new AsyncDrawable(getResources(), BitmapFactory.decodeResource(getResources() , R.mipmap.ic_launcher) , task);
            }
            imageView.setImageDrawable(asyncDrawable);
            task.execute(resId);
        }
    }

    /**
     * 通过判断任务中的数据，任务是否已经开始，或者任务目标与当前需求目标不同。
     * @param res
     * @param imageView
     * bitmapData为正在进行中的任务的目标resId
     * @return false:目标任务与正在进行的任务相同
     */
    private  boolean cancelPotentialWork(int res , ImageView imageView){
        final LoadImageTask loadImageTask = getLoadImageTask(imageView);
        if (loadImageTask!=null){
            final int bitmapData = loadImageTask.getData();
            // If bitmapData is not yet set or it differs from the new data
            if (bitmapData == 0  ||  bitmapData != res ){
                loadImageTask.cancel(true);
            }
            else{
                return false;
            }
        }
        return true;
    }

    /**
     * 获得视图当前任务
     * @param imageView
     * @return
     */
    private  LoadImageTask getLoadImageTask(ImageView imageView){
        if(imageView != null ){
            final Drawable drawable = imageView.getDrawable();
            if(drawable instanceof AsyncDrawable){
                final AsyncDrawable asyncDrawable = (AsyncDrawable) drawable;
                return asyncDrawable.getLoadImageTask();
            }
        }
        return null;
    }


    public void createImage(View view){
        loadBitmap(R.drawable.images2 , imageView1 , R.drawable.images , 30 , 30);
    }
}

 

转载于:https://www.cnblogs.com/fishbone-lsy/p/4541773.html

dingyi4799
关注
Bitmap详解
joye123的博客
01-28 2397
Bitmap详解 我们都知道，在显示图片时，可以图片文件解析为Bitmap，然后交给ImageView控件去展示。 所以，Bitmap就代表了一张解码后的，用于显示到屏幕上的图片数据。 这里需要注意的是，一张图片文件(无论从网络下载，还是从磁盘读取)是怎么显示到屏幕上的。 图像的拍摄 相机种类分为两大类：老式的胶片相机和新式的数码相机，他们的成像方式有很大的区别。 胶片相机通过镜头将光线投影到胶片上，所以感光元件是胶片，胶片上有无数的银盐颗粒，越是专业的胶片颗粒越多，通过银盐颗粒的感光物理属性，将图像记录下
android bitmap裁剪圆形,android 利用Bitmap获取圆角矩形、圆形图片详解
weixin_34229578的博客
05-28 1040
1.在很多时候，我们要显示图片资源，需要将他的资源显示为圆角的；示例源码如下：publicstaticBitmapgetRoundedCornerBitmap(Bitmapbitmap,floatroundPx){Bitmapoutput=Bitmap.createBitmap(bitmap.getWidth(),bitmap.getHeight(),Config.ARGB_8...
Android Bitmap四个角不等的圆角切割
啥都靠学
08-17 1046
1. 问题背景 设计的需要是这样的：需要上边两个角圆角，下边两个角是直角，同时这张图是Url Glide加载进来的。OK，目标明确，做起来也不是很难了。 2. 解决方案 首先加载 Url 图片进来 Glide.with(this).load(url).into(new CustomTarget<Drawable>() { @Override public void onResourceReady(@NonNull Drawable resource, @Nullable Transit
android 分别修改bitmap四个角圆角大小
zhuxingchong的博客
08-05 576
int radious = 32; Paint paint = new Paint(); // lefttop,lefttop,righttop,righttop,leftbottom,leftbottom,rightbottom,rightbottom float[] radiusArray = { radious, radious, radious, radious, radious, radious, radious, radious }; private..
Android—Bitmap解析与应用
ListerCi的博客
03-16 872
项目地址 https://github.com/ListerChen/BitmapProject 一、Bitmap基本介绍 Bitmap也称为位图，是图片在内存中的表现形式，任何图片(JPEG, PNG, WEBP…)加载到内存后都是一个Bitmap对象。Bitmap实际是像素点的集合，假设它的宽高为width和height，那么该Bitmap就包含width*height个像素，它在内存中占用的内存就是(width*height*单个像素内存)。 为了减小图片在磁盘上所占的空间，将Bitmap保存到磁盘上
Bitmap四种属性
热门推荐
rabbit_in_android的博客
11-21 1万+
我们知道Android系统分配给每个应用程序的内存是有限的，Bitmap作为消耗内存大户，我们对Bitmap的管理稍有不当就可能引发OutOfMemoryError，而Bitmap对象在不同的Android版本中存在一些差异，今天就给大家介绍下这些差异，并提供一些在使用Bitmap的需要注意的地方。 在Android2.3.3(API 10)及之前的版本中，Bitmap对象与其像素数据是分开
Bitmap使用优化
汉堡怪兽
03-14 567
BItmap使用优化可以从三个方面进行：内存压缩、对象复用、内存磁盘缓存 一. BItmap内存压缩 当我们读取一个Bitmap图片的时候，有一点一定要注意，就是千万不要去加载不需要的分辨率。在一个很小的ImageView上显示一张高分辨率的图片不会带来任何视觉上的好处，但却会占用我们相当多宝贵的内存。需要仅记的一点是，将一张图片解析成一个Bitmap对象时所占用的内存并不是这个图片在硬盘中的大小（那是各种压缩格式压缩后的大小），可能一张图片只有100k你觉得它并不大，但是读取到内存当中是按照像素点来算的
Android Bitmap详解
假装你是大灰狼的专栏
03-01 5801
一、Bitmap： Bitmap是Android系统中的图像处理的最重要类之一。用它可以获取图像文件信息，进行图像剪切、旋转、缩放等操作，并可以指定格式保存图像文件。 常用方法： public void recycle() 　// 回收位图占用的内存空间，把位图标记为Dead public fina...
bitMap浅析
b779789251的博客
03-30 1749
基本思想： 所谓的BitMap就是用一个bit位来标记某个元素所对应的value，而key即是该元素，由于BitMap使用了bit位来存储数据，因此可以大大节省存储空间。 举例： 　　这此我用一个简单的例子来详细介绍BitMap算法的原理。假设我们要对0-7内的5个元素(4,7,2,5,3)进行排序(这里假设元素没有重复)。我们可以使用BitMap算法达到排序目的。要表示8个数...
Bitmap相关知识点
qq_40959750的博客
04-26 413
Bitmap 应该是很多应用中最占据内存空间的一类资源了，Bitmap 也是导致应用 OOM 的常见原因之一。例如，Pixel 手机的相机拍摄的照片最大可达 4048 * 3036 像素（1200 万像素），如果使用的位图配置为 ARGB_8888（Android 2.3 及更高版本的默认设置），将单张照片加载到内存大约需要 48MB 内存（4048 * 3036 * 4 字节），如此庞大的内存需求可能会立即耗尽应用的所有可用内存。 全文可以概括为以下几个问题： Bitmap 所占内存大小的计算公式？ B
Android canvas drawBitmap方法详解及实例
08-31
如果你想只绘制Bitmap的一部分，比如红色线条划分的四个部分中的第二个部分，你可以调整`src`矩形的坐标。假设第二个部分的左上角坐标是(x1, y1)，右下角是(x2, y2)，则可以这样设置`src`： ```java Rect srcRect =...
Android开发实现去除bitmap无用白色边框的方法示例
08-28
具体来说，方法首先将bitmap的上、左、右、下四个方向的白色边框高度计算出来，然后将这些边框去除，以获得处理后的bitmap。 通过使用这个工具类，可以轻松地去除bitmap的无用白色边框，从而提高图像的显示效果。 ...
Android实现将View保存成Bitmap的方法
01-20
在示例代码中，使用了`Bitmap.Config.ARGB_8888`，这是一种32位的颜色格式，每个像素包含alpha、red、green和blue四个通道，占用4个字节。 ```java Bitmap bitmap = Bitmap.createBitmap(view.getWidth(), view....
android Bitmap圆角与倒影的具体实现代码
01-20
为了将Bitmap的四个角变成圆形，我们可以使用`getRoundedCornerBitmap()`方法。这个方法接受一个原始Bitmap和圆角半径`roundPx`作为参数。首先，它创建一个新的Bitmap`output`，与原始Bitmap具有相同的尺寸和ARGB_...
Flutter动画容器
Python私教
10-29 953
现在，让我们来定义 StatefulWidget 的状态。您将在这里存储随时间变化的属性。在本例中，我们将使用一个简单的布尔变量来切换容器的大小。
Android 自定义背景渐变色
Makenna's World
10-30 421
在上述代码中，我们通过setOrientation方法设置了渐变方向为从左到右。在上述代码中，我们设置了四种颜色进行渐变，即从红色到黄色再到绿色最后到蓝色。上述示例中我们只是使用了两种颜色进行渐变，而实际上，我们可以使用更多的颜色来实现更丰富的渐变效果。除了基本的渐变色效果，我们还可以实现一些高级的渐变效果，比如圆角渐变、渐变边框等。GradientDrawable.Orientation.TL_BR：从左上到右下。GradientDrawable.Orientation.BL_TR：从左下到右上。
Android 13 解决 Settings 首页矢量图修改颜色不生效
人生只是一种体验，不必用来演绎完美。
10-30 285
从Android 12 开始, 推出了Material You 设计，并在 Android 13 中得到了改进。导致了修改svg颜色不生效的问题。
Flutter&鸿蒙next 封装 Dio 网络请求详解：登录身份验证与免登录缓存
小淼淼的博客
10-30 2486
在现代应用中，处理用户身份验证和缓存是非常重要的。Dio 是一个强大的 Dart HTTP 客户端，支持多种功能，例如请求拦截、响应拦截等。本文将详细讲解如何在 Flutter 中使用 Dio 封装网络请求，并实现登录身份验证及免登录缓存功能。
Android13开发IPV4地址固定
最新发布
柴三少_
11-03 74
找到configureIPV4这个方法。
解决Android中Bitmap导致的内存溢出问题
这里的`computeInitialSampleSize()`方法首先计算出一个初步的`sampleSize`，然后根据是否小于等于8来决定是否需要对结果进行四舍五入。如果小于等于8，则每次乘以2直到大于或等于初始值；否则，将结果调整为最接近...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值