Camera1实现预览并自动获取图片(再次封装)

最新推荐文章于 2024-04-24 15:17:23 发布
最新推荐文章于 2024-04-24 15:17:23 发布
阅读量404 收藏 1
点赞数 1
分类专栏： camera1 文章标签： android bitmap 移动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qmdluck/article/details/105727226
版权

清单文件中添加权限：

<uses-permission android:name="android.permission.CAMERA" />
<uses-feature android:name="android.hardware.camera" />
<uses-feature android:name="android.hardware.camera.autofocus" />
<!-- 闪光灯权限 -->
<uses-permission android:name="android.permission.FLASHLIGHT" />

Camera1的封装：

 


import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.ImageFormat;
import android.graphics.Matrix;
import android.graphics.Rect;
import android.graphics.YuvImage;
import android.hardware.Camera;
import android.os.AsyncTask;
import android.os.Handler;
import android.os.Message;
import android.util.AttributeSet;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

import com.bhyf.bhyfsdk.config.ImageInfo;
import com.bhyf.bhyfsdk.config.ImageStack;

import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class CameraSurfaceView extends SurfaceView implements SurfaceHolder.Callback, Camera.PreviewCallback {
    private final static String TAG = "CameraSurfaceView";
    private SurfaceHolder surfaceHolder;
    private int mCameraIndex = 0;
    private Camera mCamera;
    private int mRotatePre = 0;
    private int mRotatePic = 0;
    private int mWidth = 0;
    private int mHeight = 0;

    private onPreviewChangedListener mOnPreviewChangedListener = null;
    private ImageStack imgStack = null;

    public static final int DEFAULT_CAMERA_IMAGE_WIDTH = 320;
    public static final int DEFAULT_CAMERA_IMAGE_HEIGHT = 240;
    public static final int DEFAULT_CAMERA_IMAGE_ROTATE = 90;
    public static final int DEFAULT_CAMERA_PRE_ROTATE = 90;

    public CameraSurfaceView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    /**
     * 打开 cameraId = 1 的摄像头
     * 预览画面默认是横屏的，需要旋转90度
     */
    public void openCamera() {

        openCamera(1, DEFAULT_CAMERA_PRE_ROTATE, 
                DEFAULT_CAMERA_IMAGE_ROTATE,DEFAULT_CAMERA_IMAGE_WIDTH, DEFAULT_CAMERA_IMAGE_HEIGHT);

    }

    /**
     * 打开摄像头
     *
     * @param cameraId          摄像头序号
     * @param rotatePre         预览画面旋转角度
     * @param rotatePic         获取到的图片旋转角度
     * @param cameraImageWidth  图像preview宽度
     * @param cameraImageHeight 图像preview高度
     */
    public void openCamera(int cameraId, int rotatePre, int rotatePic,  int cameraImageWidth, int cameraImageHeight) {

        log("开始 打开摄像头--------");

        int mNumberOfCameras = Camera.getNumberOfCameras();
        log(" mNumberOfCameras:  " + mNumberOfCameras);

        if (mNumberOfCameras > cameraId) {
            initCameraView(cameraId, rotatePre, rotatePic,cameraImageWidth, cameraImageHeight);
        }
    }


    /**
     * @param cameraIndex 摄像头序号
     * @param rotatePre   预览画面旋转角度
     * @param rotatePic   获取到的图片旋转角度
     * @param width       图像preview宽度
     * @param height      图像preview高度
     */
    private void initCameraView(int cameraIndex, int rotatePre, int rotatePic, int width, int height) {
        log(String.format("CameraView initCameraView() cameraIndex:%d rotate:%d width:%d height:%d", cameraIndex, rotatePre, width, height));
        surfaceHolder = this.getHolder();
        surfaceHolder.addCallback(this);
        mCameraIndex = cameraIndex;
        mRotatePre = rotatePre;
        mRotatePic = rotatePic;
        mWidth = width;
        mHeight = height;
        imgStack = new ImageStack(mWidth, mHeight);
    }


    /**
     * 初始化SurfaceView时调用一次，另外更改surface或者onpause->onresume时调用
     */
    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        log("CameraView surfaceChanged()");
        if (mCamera != null) {
            Camera.Parameters parameters = mCamera.getParameters();
            // 选择合适的图片尺寸，必须是手机支持的尺寸
            /*
            List<Camera.Size> sizeList = parameters.getSupportedPictureSizes();
            // 如果sizeList只有一个我们也没有必要做什么了，因为就他一个别无选择
            if (sizeList.size() > 1) {
            	int w = 0;
            	int h = 0;
                for (int j = 0; j < sizeList.size(); j++) {
                    Camera.Size size = sizeList.get(j);
                    w = size.width;
                    h = size.height;
                    log("w:" + w + " h:" + h);
                }
            }
            */
            //设置照片的大小
            log("setPictureSize mWidth:" + mWidth + " mHeight:" + mHeight);
            parameters.setPreviewSize(mWidth, mHeight);
            parameters.setPictureSize(mWidth, mHeight);
            parameters.setPreviewFpsRange(10, 20);
            try {
                mCamera.setParameters(parameters);
            } catch (RuntimeException ex) {
                ex.printStackTrace();
            }
            try {
                mCamera.setPreviewDisplay(holder);
                mCamera.setPreviewCallback(this);
            } catch (IOException e) {
                e.printStackTrace();
            }
            //调用相机预览功能
            mCamera.startPreview();
        }
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        log("CameraView surfaceCreated()");
        if (null == mCamera) {
            //Camera.open()方法说明：2.3以后支持多摄像头，所以开启前可以通过getNumberOfCameras先获取摄像头数目，
            // 再通过 getCameraInfo得到需要开启的摄像头id，然后传入Open函数开启摄像头，
            // 假如摄像头开启成功则返回一个Camera对象
            try {
                mCamera = Camera.open(mCameraIndex);
                //预览画面默认是横屏的，需要旋转90度
                mCamera.setDisplayOrientation(mRotatePre);
            } catch (Exception e) {
            }
        }
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        log("CameraView surfaceDestroyed()");
        if (null != mCamera) {
            try {
                mCamera.setPreviewDisplay(null);
                mCamera.setPreviewCallback(null);
            } catch (IOException e) {
                e.printStackTrace();
            }
            //停止预览
            mCamera.stopPreview();
            //释放相机资源
            mCamera.release();
            mCamera = null;
        }
    }

    @Override
    public void onPreviewFrame(byte[] data, Camera camera) {
        boolean isPreview = false;
        if (data != null) {
            isPreview = true;
            if (imgStack != null) {
                //log("imgStack.pushImageInfo() mCameraIndex:" + mCameraIndex);
                imgStack.pushImageInfo(data, System.currentTimeMillis());
            }
        }

        onPreviewChanged(isPreview);

    }

    public void setOnPreviewChangedListener(onPreviewChangedListener mPreviewChangedListener) {
        this.mOnPreviewChangedListener = mPreviewChangedListener;
    }

    public interface onPreviewChangedListener {
        void onPreviewChanged(Bitmap bitmap);
    }

    private void log(String msg) {
        Log.d(TAG, msg);
    }

    private static boolean isDisplay = false;

    public void cameraResume() {
        // TODO Auto-generated method stub
        isDisplay = true;
        if (faceDetectTask != null) {
            faceDetectTask.setStop(false);
        }

    }

    public void cameraPause() {
        // TODO Auto-generated method stub
        isDisplay = false;
        if (faceDetectTask != null) {
            faceDetectTask.setStop(true);
        }

    }


    public void cameraDestory() {
        // TODO Auto-generated method stub
        if (faceDetectTask != null) {
            faceDetectTask.setStop(true);
            faceDetectTask.cancel(true);
            faceDetectTask = null;
        }
    }


    public void onPreviewChanged(boolean isPreview) {
        if (isDisplay && isPreview && !isRunning) {
            log("====onPreviewChanged() isPreview:" + isPreview);
            startRecognizeUser();
        }
    }


    private boolean isRunning = false;
    private FaceDetectTask faceDetectTask;

    public void startRecognizeUser() {
        log("startRecognizeUser isRunning: " + isRunning);
        if (!isRunning) {
            isRunning = true;
            log("startRecognizeUser isRunning: " + isRunning);

            if (imgStack != null) {
                // 清空缓存记录
                imgStack.clearAll();
            }

            if (faceDetectTask != null) {
                faceDetectTask.setStop(true);
                faceDetectTask = null;
            }
            faceDetectTask = new FaceDetectTask();
            faceDetectTask.setStop(false);
            faceDetectTask.execute();
        }
    }

    /**
     * 定义一个类，让其继承AsyncTask这个类
     */
    class FaceDetectTask extends AsyncTask<Void, Rect, Void> {

        private boolean isStop = false;

        public void setStop(boolean isStop) {
            this.isStop = isStop;
        }

        @Override
        protected Void doInBackground(Void... voids) {

            ImageInfo imgInfo = null;

            while (!isStop && isRunning) {

                if (imgStack != null)
                    imgInfo = imgStack.pullImageInfo();

                if (!isStop && isRunning && imgInfo != null && imgInfo.isNew()) {

                    Log.d(TAG,"doInBackground imgInfo.isNew(): " + imgInfo.isNew());
                    byte[] data = imgInfo.getData();

                    Log.d(TAG, data.toString());

                    Bitmap bitmapCamera = null;

                    if (null != data) {
                        //获取图片
                        ByteArrayOutputStream baos;
                        byte[] rawImage;
                        BitmapFactory.Options newOpts = new BitmapFactory.Options();
                        newOpts.inJustDecodeBounds = true;
                        YuvImage yuvimage = new YuvImage(
                                data,
                                ImageFormat.NV21,
                                mWidth,
                                mHeight,
                                null);
                        baos = new ByteArrayOutputStream();
                        yuvimage.compressToJpeg(new Rect(0, 0, mWidth, mHeight), 100, baos);// 80--JPG图片的质量[0-100],100最高
                        rawImage = baos.toByteArray();
                        //将rawImage转换成bitmap
                        BitmapFactory.Options options = new BitmapFactory.Options();
                        options.inPreferredConfig = Bitmap.Config.RGB_565;
                        //获取到图片
                        Bitmap bitmap = BitmapFactory.decodeByteArray(rawImage, 0, rawImage.length, options);

                        //摄像头拍出来的图片，默认是横着的，所以需要对图片进行旋转
                        if (bitmap != null) {
                            Matrix matrix = new Matrix();
                            matrix.postRotate((float) mRotatePic);
                            bitmapCamera = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, false);
                        }

                        Log.d(TAG, "dealData 获取到的图片 bitmapCamera --> " + bitmapCamera);

                    }

                    if (bitmapCamera != null) {
                        // TODO 获取到图片
                        Message message = Message.obtain();
                        message.what = 12341;
                        message.obj = bitmapCamera;
                        handler.sendMessage(message);
                        
                    }
                }
            }

            return null;
        }

    }
    
    

    Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {

            if (msg.what == 12341) {

                Bitmap bitmap = (Bitmap) msg.obj;

                if (mOnPreviewChangedListener != null) {
                    
                    mOnPreviewChangedListener.onPreviewChanged(bitmap);
                }
            }
        }
    };

}

 

Activity代码：

 

import android.app.Activity;
import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.widget.ImageView;
import android.widget.Toast;

import com.bhyf.bhyf_demo.R;
import com.bhyf.bhyf_demo.view.CameraSurfaceView;


/**
 * 获取相机图片
 */
public class Camera2Activity extends Activity implements CameraSurfaceView.onPreviewChangedListener {



    private CameraSurfaceView surfaceView;
    private ImageView image;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_camera2);


        surfaceView = (CameraSurfaceView) findViewById(R.id.surfaceView);
        surfaceView.setOnPreviewChangedListener(this);

        image = findViewById(R.id.image);

        if (!checkedHardware(this)) {
            Toast.makeText(this, "no camera", Toast.LENGTH_LONG).show();
        }else {
            surfaceView.openCamera();
        }
    }
    

    @Override
    protected void onResume() {
        // TODO Auto-generated method stub
        super.onResume();
        surfaceView.cameraResume();

    }


    @Override
    protected void onPause() {
        // TODO Auto-generated method stub
        super.onPause();
        surfaceView.cameraPause();

    }


    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub

        surfaceView.cameraDestory();

        super.onDestroy();
    }


    @SuppressWarnings("unused")
    private boolean checkedHardware(Context context) {
        if (context.getPackageManager().hasSystemFeature(
                PackageManager.FEATURE_CAMERA)) {
            return true;
        }
        return false;
    }


    @Override
    public void onPreviewChanged(Bitmap bitmap) {
        image.setImageBitmap(bitmap);
    }
}

 

 

布局文件：

 

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:background="#fff"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <RelativeLayout
        android:id="@+id/layout"
        android:layout_below="@+id/tv_face"
        android:layout_centerInParent="true"
        android:layout_marginTop="30dp"
        android:layout_width="420dp"
        android:layout_height="540dp">

        <com.kris.kris_demo.view.CameraSurfaceView
            android:id="@+id/surfaceView"
            android:layout_width="match_parent"
            android:layout_height="match_parent"/>


    </RelativeLayout>

    <ImageView
        android:id="@+id/image"
        android:layout_width="400dp"
        android:layout_height="400dp"/>



</RelativeLayout>
qmdluck
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android Camera自动拍照、自动对焦并获取指定大小图片
01-03
1.首先android6.0以上版本要动态申请相机和文件读写权限 2.废话不啰嗦，上代码： /** * 摄像头画面采集界面 */ public class DistinguishActivity extends BaseActivity implements SurfaceHolder.Callback, ...
Android Camera获取预览流
曹太强的专栏
03-25 5151
camera获取预览流的方法有两种： 方法1 直接显示setPreviewDisplay，方法2 使用previewCallback 第一种 1 需要一个surfaceview 2在权限允许和surfaceview onCreate 成功后，打开camera，并且把surfaceview的holder设置在camera的setDisplayPreview上。 3 为Camera设置一些C...
摄像头图像质量常用指标的测试方法
热门推荐
北络
11-28 2万+
自动曝光主要是对某可选区域内画面亮度分量（y 信号）进行评估，若y 偏小，增大曝光量，反之减少。
Android 使用Camera1实现相机预览、拍照、录像
朱豪凯的博客
09-17 5181
本文介绍在Android中，如何使用Camera1 API实现相机预览、拍照和录制视频，以及提供可以接入使用的Camera1工具类
Android Camera2 中对拍照的照片进行左右镜像
engine_men的博客
02-25 6750
Android Camera2 中对拍照的照片进行左右镜像 最近移植了android camera驱动增加了新的摄像头支持后，预览和拍照都已经可以，但发现拍照出来的照片左右镜像了，本来在hal层找到了简单方法，jpeg硬件合成可以直接有参数设置图片镜像，但修改后发现图片是镜像过来了，但是有问题(照片放大后很模糊)，应该是jpeg硬件合成进行镜像会有bug，不镜像照片是正常的。那唯有在APP应...
Camera1 调用摄像机预览+获取每一帧
果酱大师的博客
04-29 3811
使用camera1调试相机预览+获取每一帧数据， https://www.jianshu.com/p/3440d82545f6 https://www.jianshu.com/p/705d4792e836 主要学习代码，在这里 MainActivity public class MainActivity extends AppCompatActivity implements Hand...
Camera2 教程 4：通过TEXTURE OES方式实现相机预览
星空点点
03-25 196
青橙相机 GLES11Ext.GL_TEXTURE_EXTERNAL_OES的用处是什么？ 上一张实现相机预览的每一帧的输出格式是YUV的(YUV)，那么这个扩展纹理的作用就是实现YUV格式到RGB的自动转化，我们就不需要再为此写YUV转RGB的代码了 1. 创建xml和Render //xml <?xml version="1.0" encoding="utf-8"?> &...
Android camera2 实现估算眼睛到屏幕的距离 人脸识别 护眼实验室
soso密斯密斯的博客
12-21 3732
记一次不成熟功能的开发记录 主要使用的API camera2 FaceDetector 一、实现思路： 1.首先用camera2打开前置摄像头获取前置摄像头的照片 2.通过FaceDetetoc来获取人双眼的间距 3.我们知道摄像头的成像，近大远小。那么越远的距离，我们获取到眼间距的距离会越小，反之，则越大。 4.取一个已知大小（长或宽）的参照物，在已知特定距离在手机上成像的大小，通...
android camera2 应用以及实时滤镜
Lammy的专栏
12-07 7495
之前一直用android camera，但现在市面上新出的手机都是支持camera2的，项目要求也是运用camera2，于是自己学习了下，将一些知识点罗列出来，以供复习和大家参考。 一、camera2的预览流程 1、获取相机manager，获得相机ID列表（通过ID选择开启的相机） 2、获取画面传感器的面积，
2D人脸识别之Camera篇
内核工匠
01-28 5012
一、概述本文主要介绍2D人脸识别中的Camera图像采集部分，目前市面上Android阵营中大部分机型都使用的是2D人脸识别；图像采集主要是获取目标的RGB图像，2D人脸图像获取相对简单，...
剑指offer 栈的压入、弹出序列
qq_39827131的博客
05-18 185
题目描述 输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的） 代码 public boolean IsPopOrder(int[] pushA, ...
android camera2实现实时预览和拍照
03-07
使用android studio，用camera2实现拍照并能够实时预览，并将照片存到手机里，路径代码有注释。保存格式：fpg。实现全网最简便的代码。
Android Camera1 Demo - 实现预览、拍照、录制视频功能
09-15
由于工作中需要用到Camera1，所以花了两天时间研究了以下，使用Android Camera1 API实现了相机预览、拍照和录制视频的功能。 资源中有个MyCamera1Demo.apk可以直接安装运行，MyCamera1Demo.zip是Demo源码。 具体详见...
Android Camera2 Demo - 实现相机预览、拍照、录制视频功能
06-28
因为工作中要使用 Android Camera2 API 来实现相机功能，但因为Camera2比较复杂，网上资料也比较乱，有一定入门门槛，所以花了几天时间系统研究了下，这个项目就是我研究的成果。 其中包括一个自己写的Camera2的Demo...
Android实现Camera2预览和拍照效果
08-29
主要为大家详细介绍了Android开发之一个类实现Camera2预览和拍照效果，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Android --- 英文单引号用&apos；替换报错：does not contain a valid string resource
梁同学与Android
04-23 193
Android --- 英文单引号用&apos;替换报错：does not contain a valid string resource
Android 14 transtion 动画流程
u012627628的博客
04-24 913
implements Transitions.TransitionHandler 的对象都会调用到startAnimation。根据上步计算出来的sortedTargets计算要做的动画TransitionInfo。此列表在开始做动画时候会判断里面的key，value是否满足做动画的条件。将符合条件的changeInfo添加到targets 返回。计算所有的到mChanges。
安卓aab文件生成apk文件
最新发布
ma15991375491的博客
04-24 321
比如我们在手机上经常下载的的各种APP，其实一个Android应用程序的代码想要在Android设备上运行，必须先进行编译，然后被打包成为一个被Android系统所能识别的文件才可以被运行，而这种能被Android系统识别并运行的文件格式便是“APK”。一个APK文件内包含被编译的代码文件(.dex 文件)，文件资源（resources）， 原生资源文件（assets），证书（certificates），和清单文件（manifest file）严格来说，两者没有什么区别，后者是前者的一种升级版格式文件。
bugku ezbypass
m_de_g的博客
04-23 195
bugku ezbypass $++,$_++
camera1实现相机预览、拍照
11-18
camera1是一种用于实现相机预览和拍照功能的技术。它可以在手机、相机和其他设备中被使用。在手机中，用户可以通过camera1预览相机的实时画面，并且可以进行拍照操作。 camera1可以帮助用户实现多种功能，比如调整...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值