Android 拍照后图片处理

最新推荐文章于 2024-04-14 23:28:53 发布
最新推荐文章于 2024-04-14 23:28:53 发布
阅读量482 收藏
点赞数
分类专栏： Android 文章标签： android 安卓
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongxingxxx/article/details/112222018
版权

安卓拍照或选择的图片自动旋转处理

在安卓开发中，经常使用相机或是选择照片的功能，但是在部分手机上拍照或选择图片后，发现图片被自动旋转了。那我们怎么处理呢？相信这个不难，很多人都能轻易想到。下面是如果是H5调用原生相机获取照片，需要原生将图片存储后继续返回Uri路径。

处理步骤如下:

  1. 根据拍照或选择照片的Uri获取图片Path 
  2. 根据图片Path获取其EXIF信息，包括图片旋转的角度
  3. 将URI转换成Bitmap对象
  4. 对Bitmap对象做旋转处理
  5. 将旋转的Bitmap存储，然后获取存储后的Uri

1、根据Uri获取图片绝对路径

    /**
     * 根据Uri返回文件绝对路径
     * 兼容了file:///开头的 和 content://开头的情况
     * @param context
     * @param uri
     * @return
     */
    public static String getRealFilePathFromUri(final Context context, final Uri uri) {
        if (null == uri) {
            return null;
        }
        final String scheme = uri.getScheme();
        String data = null;
        if (scheme == null) {
            data = uri.getPath();
        } else if (ContentResolver.SCHEME_FILE.equalsIgnoreCase(scheme)) {
            data = uri.getPath();
        } else if (ContentResolver.SCHEME_CONTENT.equalsIgnoreCase(scheme)) {
            Cursor cursor = context.getContentResolver().query(uri, new String[]{MediaStore.Images.ImageColumns.DATA}, null, null, null);
            if (null != cursor) {
                if (cursor.moveToFirst()) {
                    int index = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
                    if (index > -1) {
                        data = cursor.getString(index);
                    }
                }
                cursor.close();
            }
        }
        return data;
    }

2、根据图片Path获取其EXIF信息，包括图片旋转的角度

     /**
     * 读取图片的旋转的角度
     *
     * @param path
     *            图片绝对路径
     * @return 图片的旋转角度
     */
    private int getBitmapDegree(String path) {
        int degree = 0;//被旋转的角度
        try {
            // 从指定路径下读取图片，并获取其EXIF信息
            ExifInterface exifInterface = new ExifInterface(path);
            // 获取图片的旋转信息
            int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_NORMAL);
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    degree = 90;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    degree = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    degree = 270;
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return degree;
    }

3、将URI转换成Bitmap对象

a) 获取图片的宽高

public static int[] getImageWidthHeight(Context context, Uri uri) {
        BitmapFactory.Options options = new BitmapFactory.Options();
        //最关键在此，把options.inJustDecodeBounds = true;
        //这里再decodeFile()，返回的bitmap为空，但此时调用options.outHeight时，已经包含了图片的高了

        options.inJustDecodeBounds = true;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            try {
                ParcelFileDescriptor parcelFileDescriptor = context.getContentResolver().openFileDescriptor(uri, "r");
                FileDescriptor fileDescriptor = parcelFileDescriptor.getFileDescriptor();
                Bitmap bitmap = BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options);
                parcelFileDescriptor.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            Bitmap bitmap = BitmapFactory.decodeFile(FileUtil.getRealFilePathFromUri(context, uri), options); // 此时返回的bitmap为null
        }
        //options.outHeight为原始图片的高
        return new int[]{options.outWidth, options.outHeight};
    }

b)获取Bitmap图片

     /**
     * 图片等比例压缩
     *
     * @param uri
     * @param reqWidth  期望的宽
     * @param reqHeight 期望的高
     * @return
     */
    public static Bitmap decodeSampledBitmap(Context context, Uri uri, int reqWidth,
                                             int reqHeight) {

        // First decode with inJustDecodeBounds=true to check dimensions
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        options.inPreferredConfig = Bitmap.Config.RGB_565;
        //bitmap is null
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            try {
                ParcelFileDescriptor parcelFileDescriptor = context.getContentResolver().openFileDescriptor(uri, "r");
                FileDescriptor fileDescriptor = parcelFileDescriptor.getFileDescriptor();
                Bitmap bitmap = BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options);

                // Calculate inSampleSize
                int inSampleSize = calculateInSampleSize(options, reqWidth,
                        reqHeight);
                Log.i(TAG, "decodeSampledBitmap: inSampleSize = " + inSampleSize);
                options.inSampleSize = inSampleSize;

                // Decode bitmap with inSampleSize set
                options.inJustDecodeBounds = false;
                return BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        } else {
            Bitmap bitmap = BitmapFactory.decodeFile(FileUtil.getRealFilePathFromUri(context, uri), options);
            // Calculate inSampleSize
            int inSampleSize = calculateInSampleSize(options, reqWidth,
                    reqHeight);
            Log.i(TAG, "decodeSampledBitmap: inSampleSize = " + inSampleSize);
            options.inSampleSize = inSampleSize;
            // Decode bitmap with inSampleSize set
            options.inJustDecodeBounds = false;
            return BitmapFactory.decodeFile(FileUtil.getRealFilePathFromUri(context, uri), options);
        }
        return null;
    }

4 、对Bitmap对象做旋转处理

    /**
     * 将图片按照某个角度进行旋转
     * @param bm 需要旋转的图片
     * @param degree 旋转角度
     * @return 旋转后的图片
     */
    private Bitmap rotateBitmapByDegree(Bitmap bm, int degree) {
        Bitmap returnBm = null;

        // 根据旋转角度，生成旋转矩阵
        Matrix matrix = new Matrix();
        matrix.postRotate(degree);
        try {
            // 将原始图片按照旋转矩阵进行旋转，并得到新的图片
            returnBm = Bitmap.createBitmap(bm, 0, 0, bm.getWidth(), bm.getHeight(), matrix, true);
        } catch (OutOfMemoryError e) {
        }
        if (returnBm == null) {
            returnBm = bm;
        }
        if (bm != returnBm) {
            bm.recycle();
        }
        return returnBm;
    }

5、将旋转的Bitmap存储，然后获取存储后的Uri

private Uri saveBitmapToFile(Uri singleUri,Bitmap bitmap){

        try {
            String path = singleUri.toString();
            String fileName = path.substring(singleUri.toString().lastIndexOf("/"))+".JPEG";
            File filesDir = context.getExternalFilesDir(Environment.DIRECTORY_DCIM);
            File file = new File(filesDir,fileName);
            FileOutputStream fos = new FileOutputStream(file);
            bitmap.compress(Bitmap.CompressFormat.JPEG,100,fos);
            fos.flush();
            fos.close();
            return Uri.fromFile(file);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }

将图片角度测量和旋转转图片已经储封装工具类如下：

package com.bobfintech.module_webview.util;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Matrix;
import android.net.Uri;
import android.os.Environment;
import android.text.TextUtils;

import androidx.appcompat.app.AppCompatActivity;
import androidx.exifinterface.media.ExifInterface;

import com.bobfintech.by_base.utils.BitmapUtil;
import com.bobfintech.by_base.utils.FileUtil;
import com.bobfintech.by_lib.utils.LogUtils;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * author ： wdx
 * time    ： 2021/1/4
 * 计算图片角度
 **/
public class BitmapDegreeHandle {
    private static BitmapDegreeHandle instance;
    private Context context;
    private BitmapHandlerListener mListener;
    private Thread mHandleThead;

    private BitmapDegreeHandle(Context context){
        this.context = context;
    }

    public static BitmapDegreeHandle init(Context context){

        if (instance == null){
            synchronized (BitmapDegreeHandle.class){
                if (instance == null){
                    instance = new BitmapDegreeHandle(context);
                }
            }
        }
        return instance;
    }
    public BitmapDegreeHandle build(BitmapHandlerListener handle){
        this.mListener = handle;
        return instance;
    }
    public void handle(final Uri[]uris){
        mHandleThead = new Thread(new Runnable() {
            @Override
            public void run() {
                instance.unifyAllUriHandle(uris);
            }
        });
        mHandleThead.start();
    }
    /**
     * 读取图片的旋转的角度
     *
     * @param path
     *            图片绝对路径
     * @return 图片的旋转角度
     */
    private int getBitmapDegree(String path) {
        int degree = 0;//被旋转的角度
        try {
            // 从指定路径下读取图片，并获取其EXIF信息
            ExifInterface exifInterface = new ExifInterface(path);
            // 获取图片的旋转信息
            int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_NORMAL);
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    degree = 90;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    degree = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    degree = 270;
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return degree;
    }
    /**
     * 将图片按照某个角度进行旋转
     * @param bm 需要旋转的图片
     * @param degree 旋转角度
     * @return 旋转后的图片
     */
    private Bitmap rotateBitmapByDegree(Bitmap bm, int degree) {
        Bitmap returnBm = null;

        // 根据旋转角度，生成旋转矩阵
        Matrix matrix = new Matrix();
        matrix.postRotate(degree);
        try {
            // 将原始图片按照旋转矩阵进行旋转，并得到新的图片
            returnBm = Bitmap.createBitmap(bm, 0, 0, bm.getWidth(), bm.getHeight(), matrix, true);
        } catch (OutOfMemoryError e) {
        }
        if (returnBm == null) {
            returnBm = bm;
        }
        if (bm != returnBm) {
            bm.recycle();
        }
        return returnBm;
    }

    private Uri saveBitmapToFile(Uri singleUri,Bitmap bitmap){

        try {
            String path = singleUri.toString();
            String fileName = path.substring(singleUri.toString().lastIndexOf("/"))+".JPEG";
            File filesDir = context.getExternalFilesDir(Environment.DIRECTORY_DCIM);
            File file = new File(filesDir,fileName);
            FileOutputStream fos = new FileOutputStream(file);
            bitmap.compress(Bitmap.CompressFormat.JPEG,100,fos);
            fos.flush();
            fos.close();
            return Uri.fromFile(file);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }

    private Uri singleUriHandle(Uri singleUri){
        String path = FileUtil.getRealFilePathFromUri(context, singleUri);
        LogUtils.i("evan", "*********path*******  " + path);
        if (TextUtils.isEmpty(path)) {
            return singleUri;
        }
        int degree = getBitmapDegree(path);
        LogUtils.i("evan", "*********degree*******  " + degree);
        if (degree ==0){
            return singleUri;
        }

        int[] imageWidthHeight = BitmapUtil.getImageWidthHeight(context, singleUri);
        int w = imageWidthHeight[0];
        int h = imageWidthHeight[1];

        Bitmap bitmap = BitmapUtil.decodeSampledBitmap(context, singleUri,  w, h);

        if (bitmap == null) {
            return singleUri;
        }
        Bitmap resutBitmap = rotateBitmapByDegree(bitmap, degree);

        Uri resultUri = saveBitmapToFile(singleUri, resutBitmap);
        LogUtils.i("evan", "*********resultUri*******  " + resultUri);
        if (resultUri == null){
            return singleUri;
        }
        return resultUri;
    }

    private void unifyAllUriHandle(final Uri[] results ){
        final Uri[] mUri = new Uri[results.length];
        try {
            for(int i=0;i<mUri.length;i++){
                Uri uri = singleUriHandle(results[i]);
                mUri[i] = uri;
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            ((AppCompatActivity)context).runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    mListener.onSuccess(mUri);
                }
            });
            if (mHandleThead !=null){
                mHandleThead =null;
            }
        }

    }

    public interface BitmapHandlerListener{
        void onSuccess(Uri[]results);
    }
}

在打开相机或打开相册获取Uri后调用如下：

 Uri[] results = pathList.toArray(new Uri[pathList.size()]);
 BitmapDegreeHandle.init(this).build(new BitmapDegreeHandle.BitmapHandlerListener() {
      @Override
      public void onSuccess(Uri[] results) {
         if (!isFinishing()){
            uploadMessage.onReceiveValue(results);
         }
         uploadMessage = null;
     }
 }).handle(results);

 

FlyingWDX
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android序列化之Parcel
wenhonglian的博客
06-27 2765
Android操作系统的底层数据传输形式是简单的字节序列形式进行传递。用通俗的话说就是系统不认识对象，只认识字节序列。而我们为了达到通信或者存储的目的，需要先将数据序列化传递，要使用时再进行反序列化还原。我们知道Android系统是基于Linux系统实现的，而Linux有进程隔离的机制。而进程如果传递复杂数据类型那传递的是对象的引用，本质上就是一个内存地址。但是传递内存地址的方式在跨进程中明显不行，由于Linux采用了虚拟内存机制，两个进程都有自己独立的内存地址空间，所以把A进程中某个对象的内存地址传递给B
android跨进程传输大文件,android - 使用ParcelFileDescriptor.createPipe（）将InputStream传输到另一个服务（跨进程边界），并使用“EBADF（错...
weixin_30845365的博客
05-26 1600
我想通过使用ParcelFileDescriptor.createPipe() ，一个流到流的复制线程和一个ParcelFileDescriptor，将一个Android服务中的InputStream从一个Android服务“发送”到另一个服务，这个服务代表管道的读取端，通过Binder IPC提供给其他服务。发送代码(流程A)我想将一个给定的InputStream发送到接收服务：public s...
Android ParcelFileDescriptor实现进程间通信
最新发布
Dream It Possible
04-14 1463
来建立一个pipe通信通道，ParcelFileDescriptor数组第一个元素是read端，第二个元素是write端，通过write端的AutoCloseOutputStream和read端的AutoCloseInputStream，我们就可以实现进程见的数据流传输了。两端业务层都把Uri对应的ParcelFileDescriptor发送给通信层，发送端通信层从AutoCloseInputStream中取数据发送，接收端通信层获取到数据后，写入到AutoCloseOutputStream中。
Android 使用AIDL传输超大型文件
linkwj的博客
04-06 2754
我们先不细究，为什么要用AIDL传递大文件，单纯从技术的角度考虑能不能实现。众所周知，AIDL是一种基于Binder实现的跨进程调用方案，Binder 对传输数据大小有限制，传输超过 1M 的文件就会报 android.os.TransactionTooLargeException 异常。
Android中将Bitmap转换成byte[]数组及ParcelFileDescriptor
Blue_Tong的博客
06-27 3497
Android中将Bitmap转换成byte[]数组及ParcelFileDescriptor
Android 图像处理
精彩生活，不惧挑战
03-21 1122
本文是我在看过eclipse_xu大神的课程之后做的一些笔记，希望可以很好的掌握Android图片处理的相关知识。
Android拍照与相册图片裁剪
09-29
在Android应用开发中，"Android拍照与相册图片裁剪"是一个常见的功能需求，涉及到用户交互和权限管理等多个方面。以下将详细阐述实现这一功能的关键知识点： 1. **请求相机权限**：在Android 6.0（API级别23）及...
Android拍照或从图库选择图片并裁剪
01-04
今天看《第一行代码》上面关于拍照和从相册选取图片那一部分，发现始终出不来效果，所以搜索其他资料学习一下相关知识，写一个简单的Demo。  一、 拍照选择图片 1、使用隐式Intent启动相机 //构建隐式Intent ...
Android拍照裁剪图片
01-20
在用户拍摄照片后，系统会返回结果，我们需要在`onActivityResult()`方法中处理这个结果，然后启动裁剪操作： ```java @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) ...
Android实现拍照截取和相册图片截取
01-20
总结来说，实现Android拍照截取和相册图片截取的功能，主要涉及到Intent的使用、文件管理、权限控制、裁剪操作以及回调处理。这些步骤都需要结合实际应用环境进行调整，以满足特定需求和兼容不同设备。在开发过程中...
Android拍照+图片处理（修正版）
10-14
本文将详细解析"Android拍照+图片处理（修正版）"这一主题，涵盖拍照、从相册选取图片以及后续的图片处理技术，如旋转、裁剪、倒影、黑白效果等。 首先，让我们从拍照开始。在Android中，我们可以利用`Intent`来...
【转】深入理解Camera-基础知识点
程序员Android
09-21 3015
和你一起终身学习，这里是程序员 Android 本篇文章主要介绍 Android 开发中的部分知识点，通过阅读本篇文章，您将收获以下内容: 一、简介 二、基本硬件结构 三、手机相机简介 一、简介 相机的硬件层，作为整个框架的最底层，通过硬件模块接收来自客观世界的真实光影效果，将其转换为计算机所熟知的数字信号，并按照一定的数据格式向上源源不断提供成稳定并成像效果优秀的图像数据，整个部分复杂且高效，可以说是，一个优秀的硬件基础，就好比为整个相机框架的地基，拥有一个好的地基，便使得建造一座摩天大厦成为可能，接
Android中的Parcel是什么
Skypine_Lee的专栏
04-11 1017
http://blog.csdn.net/nkmnkm/article/details/6451699 Parcel，翻译过来是“打包”的意思。打包干什么呢？是为了序列化。     如果要在进程之间传递一个整数，很简单，直接传就是行了；如果要传一个字符串，就稍微复杂了点：需先分配一块可以容纳字符串的内存，然后将字符串复制到内存中，再传递（新手可能问：为啥不直接把字符串的引用传过去呢？学过C/C
文件的基本操作
KuQI滴滴滴的博客
09-23 360
文件的创建和打开 f=open('date.txt','w') #创建一个文件并且打开 f=open('date.txt') #打开date.txt文件 文件的写入和读取 f.write('hello wolrd!') #写入信息 f.read() #读取信息存到暂存区 文件的关闭 f.close() #关闭当前文件 ...
androidq获取文件正式路径_AndroidQ 沙箱适配多媒体文件(小结)
weixin_39719727的博客
12-19 183
综述所有内容的访问变化见下图：外部媒体文件的扫描，读取和写入最容易被踩坑的应该是，对外部媒体文件，照片，视频，图片的读取或写入。扫描首先是扫描。扫描依然是使用 query MediaStore 的方式。一句话介绍 MediaStore，MediaStore 就是Android系统中的一个多媒体数据库。代码如下图所示，以搜索本地视频为例子：protected List doInBackground(...
mediapipe学习-手势识别android（3）
yunteng521的博客
08-07 2931
mediapipe学习-手势识别android（3）
android uri parcel,Android ParcelFileDescriptor实现进程间通信
weixin_32661831的博客
05-28 1072
需求一个通信通道，实现跨进程的的Socket网络通信。具体的通信通道的图如下。需求分析我们需要一个进程一直做通信通道的事情，业务进程把数据通过进程间通信交给通信进程。通信进程通过Socket通道将数据发给网络另外一端的通信进程。接收端的通信进程把数据再交给业务进程。android进程间通信基本方式android进程间通信是使用Binder来传数据，而Binder传输的数据，有一个最为基本的要求，就...
Android 点击空白区域，隐藏软键盘
dongxingxxx的博客
08-15 1714
点击使用EditText组件的时候，会弹出软键盘。然后我们输入操作，但我们输入完成之后点击空白区域，键盘并没有收起，我们必须点击软键盘自带收起才能关闭键盘，这对用户来说，可能体验不是太好，因此，在输入时需要软键盘，弹出软键盘，当不需要时，点击空白区域，就让软键盘收起，代码如下： 首先我们封装一个工具类：KeyboardUtils ， public class KeyboardUtils { ...
Android Studio 拍照后imageview显示图片
04-24
4. 在Activity中添加拍照的处理逻辑，使用Intent来调用系统自带的相机应用，拍完照后将照片保存到指定路径，并显示在ImageView上： ``` private File photoFile = null; private String currentPhotoPath = null; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值