Android BitmapUtil Bitmap读取、保存、下载、效果处理

最新推荐文章于 2020-03-26 20:23:22 发布
最新推荐文章于 2020-03-26 20:23:22 发布
阅读量817 收藏 2
点赞数
文章标签： android Bitmap读取 Bitmap下载 Bitmap保存 Bitmap效果处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaxl/article/details/72458331
版权

Android BitmapUtil 工具类整理，包含的功能：

  • 读取 Bitmap：
    从Sdcard读取图片、从Assets中去取图片；
  • 保存 Bitmap：
    将View截图为Sdcard的一张图片；
    将Bitmap保存为Sdcard的一张图片；
  • 下载 Bitmap：
    根据URL地址，从网络侧下载Bitmap；
  • 处理 Bitmap：
    Bitmap宽高更改、Bitmap等比缩放、Bitmap增加圆角、Bitmap镜像；
public class BitmapUtil {
    private static final String TAG = "BitmapUtil";

    // ############################################################

    /**
     * 根据路径，以流的形式，在sdcard中读取图片
     *
     * @param filePath
     * @return
     */
    public static Bitmap getBmpFromSdcard(String filePath) {
        if (TextUtils.isEmpty(filePath)) {
            return null;
        }

        Bitmap bitmap = null;
        try {
            bitmap = BitmapFactory.decodeFile(filePath);
        } catch (OutOfMemoryError e) {
            if (bitmap != null) {
                if (!bitmap.isRecycled()) {
                    bitmap.recycle();
                }
                bitmap = null;
            }
        } catch (Exception e) {
            if (bitmap != null) {
                if (!bitmap.isRecycled()) {
                    bitmap.recycle();
                }
                bitmap = null;
            }
        }
        return bitmap;
    }


    /**
     * 根据文件名,从Assets中取图片
     *
     * @param context
     * @param fileName 例如:game_bg.png
     * @return
     */
    public static Bitmap getBmpFromAssets(Context context, String fileName) {
        Bitmap bmp = null;
        if (TextUtils.isEmpty(fileName)) {
            return null;
        }
        AssetManager asm = context.getAssets();
        if (asm == null) {
            return bmp;
        }
        InputStream is = null;
        try {
            is = asm.open(fileName);
            bmp = BitmapFactory.decodeStream(is);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return bmp;
    }

    // ############################################################

    /**
     * 将当前的View 截图保存为sdcard的一张 PNG 图片
     */
    public static void saveViewToSdcard(View view, String pngFilePath) {
        FileOutputStream out = null;
        try {
            File file = new File(pngFilePath);
            if (file.exists()) {
                file.delete();
            }
            file.createNewFile();
            //
            out = new FileOutputStream(file);
            view.setDrawingCacheEnabled(true);
            view.buildDrawingCache();
            //
            Bitmap bitmap = view.getDrawingCache();
            bitmap.compress(Bitmap.CompressFormat.PNG, 100, out);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            view.destroyDrawingCache();
            if (null != out) {
                try {
                    out.close();
                } catch (Exception e) {
                }
            }
        }
    }


    /**
     * 将图片存入Sdcard中指定路径
     *
     * @param bitmap
     * @param pngFilePath
     * @return
     */
    public static boolean saveBmpToSdcard(Bitmap bitmap, String pngFilePath) {
        if (bitmap == null || TextUtils.isEmpty(pngFilePath)) {
            return false;
        }
        File file = null;
        FileOutputStream fos = null;
        try {
            file = new File(pngFilePath);
            if (file.exists()) {
                file.delete();
            }
            //
            fos = new FileOutputStream(file);
            bitmap.compress(Bitmap.CompressFormat.PNG, 100, fos);
            fos.flush();
            return true;
        } catch (Exception e) {
            //
        } finally {
            if (null != fos) {
                try {
                    fos.close();
                } catch (Exception e) {
                }
            }
        }
        return false;
    }


    // ############################################################


    /**
     * 更改bitmap的宽,高
     *
     * @param bmp
     * @param targetWidth
     * @param targetHeight
     * @return
     */
    public static Bitmap resizeBmp(Bitmap bmp, int targetWidth,
                                   int targetHeight) {

        if (bmp == null || bmp.isRecycled()) {
            return null;
        }
        Bitmap bmResult = null;
        try {
            // 原始图片宽度
            float width = bmp.getWidth();
            // 原始图片高度
            float height = bmp.getHeight();

            Matrix m1 = new Matrix();
            // 这里指的是目标区域（不是目标图片）
            m1.postScale(targetWidth / width, targetHeight / height);
            // 声明位图
            bmResult = Bitmap.createBitmap(bmp, 0, 0, (int) width,
                    (int) height, m1, true);

        } catch (Exception e) {
            if (bmResult != null) {
                if (!bmResult.isRecycled()) {
                    bmResult.recycle();
                    bmResult = null;
                }
            }
            bmResult = bmp;
        }
        return bmResult;
    }

    /**
     * 按某个比例缩放图片
     *
     * @param bmp
     * @param ratio
     * @return
     */
    public static Bitmap resizeBmp(Bitmap bmp, float ratio) {

        if (bmp == null || bmp.isRecycled()) {
            return null;
        }
        Bitmap bmResult = null;

        try {
            // 图片宽度
            float width = bmp.getWidth();
            // 图片高度
            float height = bmp.getHeight();

            Matrix m1 = new Matrix();
            m1.postScale(ratio, ratio);
            // 声明位图
            bmResult = Bitmap.createBitmap(bmp, 0, 0, (int) width,
                    (int) height, m1, true);

        } catch (Exception e) {
            if (bmResult != null) {
                if (!bmResult.isRecycled()) {
                    bmResult.recycle();
                    bmResult = null;
                }
            }
            bmResult = bmp;
        }

        return bmResult;
    }

    /**
     * 处理头像（填充圆角）
     *
     * @param bitmap
     * @param roundPx
     * @return
     */
    public static Bitmap getCornerBmp(Bitmap bitmap, float roundPx) {
        if (bitmap == null) {
            return null;
        }
        Bitmap output = null;

        try {
            output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(),
                    Config.ARGB_8888);
            Canvas canvas = new Canvas(output);
            final Rect rect = new Rect(0, 0, bitmap.getWidth(),
                    bitmap.getHeight());
            final RectF rectF = new RectF(rect);

            final Paint paint = new Paint();
            paint.setAntiAlias(true);
            canvas.drawARGB(0, 0, 0, 0);
            canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
            paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
            canvas.drawBitmap(bitmap, rect, rect, paint);

            return output;
        } catch (OutOfMemoryError e) {
            if (output != null) {
                if (!output.isRecycled()) {
                    output.recycle();
                    output = null;
                }
            }
            output = bitmap;
            //
            e.printStackTrace();

        }
        return null;
    }

    // ############################################################

    /**
     * 根据URL下载图片
     *
     * @param imageUrl       网络url地址
     * @param connectTimeout 链接超时
     * @param readTimeout    读取超时
     * @return
     */
    public static Bitmap downloadImg(String imageUrl, int connectTimeout,
                                     int readTimeout) {
        if (TextUtils.isEmpty(imageUrl)) {
            return null;
        }
        URL url = null;
        HttpURLConnection conn = null;
        InputStream is = null;
        Bitmap bitmap = null;
        try {

            url = new URL(imageUrl);
            conn = (HttpURLConnection) url.openConnection();
            //
            conn.setConnectTimeout(connectTimeout);
            //
            conn.setReadTimeout(readTimeout);
            conn.setDoInput(true);
            //
            conn.connect();
            is = conn.getInputStream();
            //
            bitmap = BitmapFactory.decodeStream(is);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (OutOfMemoryError e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (conn != null) {
                conn.disconnect();
                conn = null;
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    is = null;
                }
            }
        }
        return bitmap;
    }

    // ############################################################

    /**
     * 镜像效果mirror
     *
     * @param originalBmp
     * @return
     */
    public static Bitmap getMirrorBmp(Bitmap originalBmp) {
        if (originalBmp == null) {
            return null;
        }

        Bitmap bitmapWithReflection = null;
        try {

            final int reflectionGap = 2;
            int width = originalBmp.getWidth();
            int height = originalBmp.getHeight();

            Matrix matrix = new Matrix();

            matrix.preScale(1, -1);

            Bitmap reflectionImage = Bitmap.createBitmap(originalBmp, 0,
                    height / 2, width, height / 2, matrix, false);

            bitmapWithReflection = Bitmap.createBitmap(width,
                    (height + height / 6), Config.ARGB_8888);

            Canvas canvas = new Canvas(bitmapWithReflection);

            canvas.drawBitmap(originalBmp, 0, 0, null);

            canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);

            Paint paint = new Paint();

            LinearGradient shader = new LinearGradient(0, height, 0,
                    bitmapWithReflection.getHeight() + reflectionGap + 20,
                    0xffffffff, 0x00ffffff, TileMode.MIRROR);

            paint.setShader(shader);
            paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));

            canvas.drawRect(0, height, width, bitmapWithReflection.getHeight()
                    + reflectionGap, paint);
        } catch (OutOfMemoryError e) {
            if (bitmapWithReflection != null) {
                if (!bitmapWithReflection.isRecycled()) {
                    bitmapWithReflection.recycle();
                    bitmapWithReflection = null;
                }
            }
            bitmapWithReflection = originalBmp;
            //
            e.printStackTrace();

        }
        return bitmapWithReflection;
    }

    /**
     * Mosaic a bitmap
     *
     * @param srcBitmap
     * @param radius    The pixel number of a block. such as width/16
     * @param dstBitmap the width and height must be the same of srcBitmap
     * @return
     */
    public static boolean mirrorBmp(final Bitmap srcBitmap, final int radius, Bitmap dstBitmap) {
        try {
            Log.d(TAG, "mosaic srcBitmap = " + srcBitmap + ", radius = " + radius + ", dstBitmap = " + dstBitmap);
            int w = srcBitmap.getWidth();
            int h = srcBitmap.getHeight();
            int[] srcData = new int[w * h];
            int[] dstData = new int[w * h];
            int midRadius = radius >> 1;
            int srcX, srcY;

            Log.d(TAG, "mosaic:w= " + w + ",h=" + h);
            long startTime = System.currentTimeMillis();
            srcBitmap.getPixels(srcData, 0, w, 0, 0, w, h);

            for (int j = 0; j < h; j++) {
                for (int i = 0; i < w; i++) {
                    srcX = i - i % radius + midRadius;
                    srcY = j - j % radius + midRadius;
                    if (srcX >= w) {
                        srcX = w - 1;
                    }
                    if (srcY >= h) {
                        srcY = h - 1;
                    }
                    dstData[j * w + i] = srcData[srcY * w + srcX];
                }
            }
            Log.d(TAG, "exe time = " + (System.currentTimeMillis() - startTime));
            dstBitmap.setPixels(dstData, 0, w, 0, 0, w, h);
            Log.d(TAG, "setPixels time = " + (System.currentTimeMillis() - startTime));

        } catch (ArrayIndexOutOfBoundsException e) {
            Log.e(TAG, "ArrayIndexOutOfBoundsException = " + e);
            return false;
        } catch (IllegalStateException e) {
            Log.e(TAG, "IllegalStateException = " + e);
            return false;
        } catch (Exception e) {
            Log.e(TAG, "Exception = " + e);
            return false;
        }

        return true;
    }


    /**
     * Mosaic2 a bitmap. The time cost is 9 times against as mosaic(...),
     * but the memory is half of it
     *
     * @param srcBitmap
     * @param radius    The pixel number of a block. such as width/16
     * @param dstBitmap the width and height must be the same of srcBitmap
     * @return
     */
    public static boolean mirrorBmp2(final Bitmap srcBitmap, final int radius, Bitmap dstBitmap) {
        try {
            Log.d(TAG, "mosaic srcBitmap = " + srcBitmap + ", radius = " + radius + ", dstBitmap = " + dstBitmap);
            int w = srcBitmap.getWidth();
            int h = srcBitmap.getHeight();
            int srcData = 0;
            int midRadius = radius >> 1;
            int srcX, srcY;

            Log.d(TAG, "mosaic:w= " + w + ",h=" + h);
            long startTime = System.currentTimeMillis();
            for (int j = 0; j < h; j++) {
                for (int i = 0; i < w; i++) {
                    srcX = i - i % radius + midRadius;
                    srcY = j - j % radius + midRadius;
                    if (srcX >= w) {
                        srcX = w - 1;
                    }
                    if (srcY >= h) {
                        srcY = h - 1;
                    }
                    srcData = srcBitmap.getPixel(srcX, srcY);
                    dstBitmap.setPixel(i, j, srcData);
                }
            }
            Log.d(TAG, "exe time = " + (System.currentTimeMillis() - startTime));
        } catch (ArrayIndexOutOfBoundsException e) {
            // TODO: handle exception
            Log.e(TAG, "ArrayIndexOutOfBoundsException = " + e);
            return false;
        } catch (IllegalStateException e) {
            Log.e(TAG, "IllegalStateException = " + e);
            return false;
        } catch (Exception e) {
            Log.e(TAG, "Exception = " + e);
            return false;
        }

        return true;
    }
    // ############################################################

    /**
     * 设置 ImageView 图标颜色
     */
    public void setImageViewColorFilter(ImageView view, int color) {
        if (view == null)
            return;
        view.setColorFilter(view.getContext().getResources().getColor(color));
    }

    /**
     * 获取 指定颜色 的图标
     *
     * @param context
     * @param resID
     * @return
     */
    public Drawable getThemeDrawableColorFilter(Context context, int resID, int color) {
        Drawable drawable = null;
        try {
            drawable = context.getResources().getDrawable(resID);
            drawable.setColorFilter(context.getResources().getColor(color), PorterDuff.Mode.SRC_ATOP);
        } catch (Exception | OutOfMemoryError error) {
            error.printStackTrace();
        }
        if (drawable == null) {
            return new ColorDrawable(Color.TRANSPARENT);
        } else {
            return drawable;
        }
    }
}
bjxiaxueliang
关注
专栏目录
Android 图片处理BitmapUtils
mr_zdd的专栏
11-19 260
publicclassBitmapUtils{ /** *加载本地图片 * *@paramurl *@return */ publicstaticBitmapgetLoacalBitmap(Stringurl){ try{ FileInputStreamfis=newFileInputStream(url); returnBitmapFactory.decodeStrea...
Android 玩转图片（读取图片转化Bitmap，保存本地，采样压缩）
Mr_ChenXu的博客
01-19 2951
1、权限 uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/> uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" /> 2、将图片转化为Bitmap 第一种：返回项目Resources中图片
Android Bitmap网络图片下载
11-17
这是一个用于Android网络图片下载及其处理的示例源代码，非常适合Android初级开发人员使用，尤其是对下载图片的缩放等进行了详细的示范，希望大家学以致用！
图片下载工具类：BitmapUtil
flying_vip_521的专栏
06-12 3746
转载请注明出处 package com.net.util; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.net.HttpURLConnection; import java.net.Malform
Android教程示例BitmapFun分析
hello_tree的专栏
02-21 992
转载自：http://blog.csdn.net/xu_fu/article/details/8269865 Google为Android开发提供了一个培训教程，在加载图片一节中提供了示例程序BitmapFun，实现了图片下载、缓存、解析加载的功能，具体分析如下： 1、程序介绍      程序整体结构如上图所示，应用启动后进入ImageGridActivity，首
Android glide4.5 网络图片下载为bitmap并保存相册
迎风致万里的博客
11-29 6400
bulide.glide中依赖： implementation 'com.github.bumptech.glide:glide:4.5.0' annotationProcessor 'com.github.bumptech.glide:compiler:4.5.0' 代码中使用，注释已经写的很详细 var bitmap: Bitmap? = null var s...
android高效加载Bitmap
11-03
归纳总结： 1. 从缓存中读取图片：先从内存缓存中读取。 若是从内存中读取到的Bitmap为空，则在磁盘缓存中读取。 若是从磁盘中读取到的Bitmap为空，则从起始资源中读取 2.开启工作线程，执行从起始资源中读取bitmap的任务 3.计算合适比例，读取适屏的bitmap 4.检查ImageView与任务线程的一致性 5.最后Hanlder更新UI
Android中Bitmap内存优化
weixin_43901866的博客
03-26 457
Android开发中，Bitmap是经常会遇到的对象，特别是在列表图片展示、大图显示等界面。而Bitmap实实在在是内存使用的“大客户”。如何更好的使用Bitmap，减少其对App内存的使用，是Android优化方面不可回避的问题。因此，本文从常规的Bitmap使用，到Bitmap内存计算进行了介绍，最后分析了Bitmap的源码和其内存模型在不同版本上的变化。 Bitmap的使用 一般来说，一个对...
Android代码-android-utils
08-07
Bitmap 工具类主要包括获取 Bitmap 和对 Bitmap 的操作 CipherUtils 加密与解密的工具类 Colors 常用颜色色值工具类 CommonUtil 一些通用的方法 ChannelUtil 为打包而生的渠道工具类 极速打包传送门 ...
Android util code
最新发布
09-21
BitmapUtil 提供了 `compressBitmap(Bitmap bitmap, int width, int height)` 方法，可以根据指定尺寸压缩位图，避免内存溢出问题。 3. **NetworkUtil**：网络模块中，`isNetworkAvailable(Context context)` 方法...
Android 实现将Bitmap 保存到本地
08-19
主要介绍了Android 实现将Bitmap 保存到本地，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
BitmapUtil
08-28
bitmap 缓存工具类，实现缓存sd卡以及内存功能，
Android读取本地或网络图片并转换为Bitmap
09-01
主要为大家详细介绍了Android读取本地或网络图片，并转换为Bitmap，感兴趣的小伙伴们可以参考一下
BitmapUtils
06-26
图片压缩，本地保存
BitmapUtilDemo:BitmapUtil【缩放bitmap以及将bitmap保存成图片到SD卡中】
05-14
BitmapUtilDemo
网络图片转bitmap,并设置相应参数
安卓加油
11-07 1742
参考文章:http://blog.csdn.net/appandroid/article/details/11213973 通常我们项目中用到网络图片达不到我们的既定要求时,我们想到的是将图片转成我们可以操作的对象进行处理, 那么这个流程是怎样的呢? 例如 我们想获取一个网络图片的宽和高,那么就需要 先将网络图片利用BitmapFactory.decodeFile(Sting fi
BitmapUtil【缩放bitmap以及将bitmap保存成图片到SD卡中】
weixin_34355881的博客
10-07 146
版权声明：本文为HaiyuKing原创文章，转载请注明出处！ 前言 用于缩放bitmap以及将bitmap保存成图片到SD卡中 效果图 代码分析 bitmapZoomByHeight(Bitmap srcBitmap, float newHeight)： 根据指定的高度进行缩放（src是bitmap） bitmapZoomByHeight(Drawable drawable, fl...
Android--Bitmap高效加载
gs344937933的专栏
05-10 391
基本概念 代码实战 Android缓存 LruCache使用 代码实现： DiskLreCache使用 代码实战 ...
Android开发：BitmapUtil图片处理全解析与实例
本文档详细介绍了Android开发中的一个强大工具类——BitmapUtil，它专门用于优化图片处理操作。BitmapUtil整合了常见的图片加载、转换、缩放以及内存计算功能，为开发者提供了一站式的解决方案，避免因图片处理导致...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

bjxiaxueliang

您的鼓励是我创作的最大动力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值