精华内容
下载资源
问答
  • 2022-01-03 13:53:26
    //CameraView.java
    public int mCameraId = DEFAULT_CAMERA_ID;
     @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
       super.surfaceChanged(holder, format, w, h);
       tryInit(holder, w, h);
    }
    public void tryInit(SurfaceHolder holder ,int w, int h){
       if(!checkHasPermission(CAMERA)) {
           uiObserver.onPermissionDeny();
           return false;
       }
       uiObserver.onPermissionGranted();
       mAspectRatio = w / h;
       CameraManager.of().initCamera(holder, mAspectRatio, mCameraId)
    }
    
    //CameraManager.java
    public static final int MSG_INIT_CAMERA = 0;
    public void initCamera(SurfaceHolder holder, float aspectRatio, int cameraId,){
    	getCameraHandler()
    	.sendMessage(handler.obtainMessage(MSG_INIT_CAMERA, cameraId, aspectRatio));
    }
    
    ...
    
    public void handleMessage(Message msg){
    	switch (msg.what) {
    		case MSG_INIT_CAMERA:
    			camera.initCamera((SurfaceHolder)msg.obj[0], (float)msg.obj[1],(int)msg.obj[2]);
                break;
            ...
    	}
    }
    
    //Camera1Impl.java
    public void initCamera(SurfaceHolder holder, int cameraId, float aspectRatio){
    	this.mHolder = holder;
    	this.mCameraId = cameraId;
    	this.mAspectRatio = aspectRatio;
    	synchronized(lock){
    		try{
    			if(acquireLock(timeout = 2000)){
    				Log.i(TAG, "initCamera超时")
    			}
    			openCamera(cameraId);
    			applyDefaultParameters();
    			startPreview();
    			releaseLock();
    			Log.i(TAG, "initCamera succ")
    			retryCount = 0;
    		}catch(Exception e){
    			releaseLock();
    			Log.e(TAG, "initCamera exception info = "+e.getInfo();
    			if(retryCount > DEFAULT_RETRY_COUNT){
    				getCameraHandler().postDelay(()->{
    					retryCount++;
    					initCamera(holder, cameraId, aspectRatio);
    				},20);
    			}
    		}
    	}
    }
    
    public void openCamera(int cameraId){
    	int count = 0;
    		// @return total number of accessible camera devices, 
    		//or 0 if there are no cameras or an error was encountered enumerating them.
    	try{
    		count = Camera.getNumberOfCameras();
    	}catch(Exception e){
    		count = -1;
    	}
    	if(count == 0){
    		Toast("清检查设备前后置摄像头")
    		//释放锁
    		releaseLock();
    		return;
    	}
    	if(count == -1){
    		releaseLock();
    		if(retryCount> DEFAULT_RETRY_COUNT){
    			getCameraHandle().postDelay(()->{
    				openCamera(cameraId);
    				retryCount++;
    			},20);
    		}
    		return;
    	}
    	retryCount= 0;
    	if(mCamera!=null){
    		//releaseCamera释放camera,并set null to mCamera。
    		releaseCamera();
    	}
    	mCamera = Camera.open(cameraId);
    	if(mCamera == null){
    		Toast("打开摄像头失败");
    		releaseLock();
    		return;
    	}
    	mCameraId = cameraId;
    	Camera.CameraInfo info = new Camera.CameraInfo();
    	try{
    		Camera.getCameraInfo(mCameraId,info)
    	}catch(Exception e){
    		Log.e(TAG,"exception info = "+ e.getInfo());
    	}
    	
    	mCanDisableSound = info.canDisableShutterSound;
    	if(mCanDisableSound){
    		try {
    			// 关闭快门声
    	       mCamera.enableShutterSound(false);  
    	   	}catch (Exception e){
    	    }
    	}else{
    		//TODO 需要做额外的关闭声音容错处理
    	}
    }
    
    private void applyDefaultParameters(){
    	//1.apply方向
    	applyDefaultOrientation();
    	//2.apply previewSize
    	applyDefaultPreviewSize();
    	//3.apply pictureSize
    	applyDefaultPictureSize();
    	//4.apply focus mode
    	applyDefaultFocusMode();
    	//5.apply flash mode
    	applyDefaultFlashMode();
    }
    private int applyDefaultOrientation() {
     	int displayOrientation;
     	 //1.问题机型兼容逻辑处理
     	if(CameraCompat.Camera1.isOrientationExcepDevice(Build.Model)){
     	 	displayOrientation = CameraCompat.Camera1.getOrientationForExcepDevices();
     	}else{	
     	//2.逻辑计算
    	    int rotation = activity.getWindowManager().getDefaultDisplay()
    	            .getRotation();
    	    int degrees = 0;
    	    switch (rotation) {
    	        case Surface.ROTATION_0: degrees = 0; break;
    	        case Surface.ROTATION_90: degrees = 90; break;
    	        case Surface.ROTATION_180: degrees = 180; break;
    	        case Surface.ROTATION_270: degrees = 270; break;
    	    }
    
    //mOrientation为 CameraInfo里 orientation字段,在openCamera阶段保存为变量即可
    	    if (mFacing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
    	        displayOrientation = (mOrientation + degrees) % 360;
    	        displayOrientation = (360 - displayOrientation) % 360;  
    	        // compensate the mirror
    	    } else {  // back-facing
    	        displayOrientation = (mOrientation - degrees + 360) % 360;
    	    }
    	}
        try{
        //3.非致命异常 try-catch
       		camera.setDisplayOrientation(displayOrientation);
        }catch(Exception e){
       		Log.e(TAG, "setDisplayOrientation exception info = "+e.getInfo());
        }
    }
    
    public void applyDefaultPreviewSize(){
        if (mShowingPreview) {
            mCamera.stopPreview();
        }
    	Camera.Parameters params = null;
    	try{
    		//mCamera.getParameters();需要try-catch住,不是致命bug
    		params = mCamera.getParameters();
    	}catch(Exception e){
    		...
    	}
    	if(params == null){
    		//不设置 return
    		return;
    	}
    	List<Size> previewSize = null;
    	try{
    		//可参看源码,内部没有异常try-catch。可能会抛异常,也可能返回为null;
    		previewSize = params.getSupportedPreviewSizes();
    	}catch(Exception e){
    		...
    	}
    	if(previewSize == null || previewSize.size() == 0){
    		return;
    	}
    	float min = Integer.MAX_VALUE;
    	Size selectSize = null;
    	for(Size s : previewSize){
    		float ar = AspectRatio.cal(s);
    		if(ar - mAspectRatio < min){
    			selectPreviewSize = s;
    			min = Math.min(min,Math.abs(mAspectRatio - ar));
    		}
    	}
    	if(selectPreviewSize == null){
    		return;
    	}
    	try{
    		params.setPreviewSize(selectSize.getWidth(),selectSize.getHeight());
    	}catch(Exception e){
    		...
    	}
    }
    
    public void applyDefaultPictureSize(){
        if (mShowingPreview) {
            mCamera.stopPreview();
        }
    	Camera.Parameters params = null;
    	try{
    		//mCamera.getParameters();需要try-catch住,不是致命bug
    		params = mCamera.getParameters();
    	}catch(Exception e){
    		...
    	}
    	if(params == null){
    		//不设置 return
    		return;
    	}
    	List<Size> pictureSize = null;
    	try{
    		//可参看源码,内部没有异常try-catch。可能会抛异常,也可能返回为null;
    		pictureSize = params.getSupportedPictureSizes();
    	}catch(Exception e){
    		...
    	}
    	if(pictureSize == null || pictureSize.size() == 0){
    		return;
    	}
    	float min = Integer.MAX_VALUE;
    	Size selectSize = null;
    	for(Size s : pictureSize){
    		float ar = AspectRatio.cal(s);
    		if(ar - mAspectRatio < min){
    			selectPictureSize = s;
    			min = Math.min(min,Math.abs(mAspectRatio - ar));
    		}
    	}
    	if(selectPictureSize == null){
    		return;
    	}
    	try{
    		params.setPictureSize(selectSize.getWidth(),selectSize.getHeight());
    	}catch(Exception e){
    		...
    	}
    }
    
    public boolean applyDefaultFocusMode(){
    	if(!isCameraOpened()){
    		return false;
    	}
    	try{
    	    final List<String> modes = mCameraParameters.getSupportedFocusModes();
    	    if(modes == null || modes.size() == 0){
    	    	return false;
    	    }
    	    if (isCurVideoTab()
    	    && modes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
    	        mCameraParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
    	    } else if (modes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
    	        mCameraParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
    	    }else if (modes.contains(Camera.Parameters.FOCUS_MODE_FIXED)) {
    	        mCameraParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_FIXED);
    	    } else if (modes.contains(Camera.Parameters.FOCUS_MODE_INFINITY)) {
    	        mCameraParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_INFINITY);
    	    } else {
    	        mCameraParameters.setFocusMode(modes.get(0));
    	    }
    	}catch(Exception e){
    		...
    	}
    }
    
    private static final SparseArrayCompat<String> FLASH_MODES = new SparseArrayCompat<>();
    
    static {
        FLASH_MODES.put(Constants.FLASH_OFF, Camera.Parameters.FLASH_MODE_OFF);
        FLASH_MODES.put(Constants.FLASH_ON, Camera.Parameters.FLASH_MODE_ON);
        FLASH_MODES.put(Constants.FLASH_TORCH, Camera.Parameters.FLASH_MODE_TORCH);
        FLASH_MODES.put(Constants.FLASH_AUTO, Camera.Parameters.FLASH_MODE_AUTO);
        FLASH_MODES.put(Constants.FLASH_RED_EYE, Camera.Parameters.FLASH_MODE_RED_EYE);
    }
    
    private boolean applyDefaultFlashMode(int flash) {
        if (isCameraOpened()) {
            List<String> modes = mCameraParameters.getSupportedFlashModes();
            String mode = FLASH_MODES.get(flash);
            if (modes != null && modes.contains(mode)) {
                mCameraParameters.setFlashMode(mode);
                mFlash = flash;
                return true;
            }
            String currentMode = FLASH_MODES.get(mFlash);
            if (modes == null || !modes.contains(currentMode)) {
                mCameraParameters.setFlashMode(Camera.Parameters.FLASH_MODE_OFF);
                mFlash = Constants.FLASH_OFF;
                return true;
            }
            return false;
        } else {
            mFlash = flash;
            return false;
        }
    }
    
    public void startPreview(){
    	//这里兜底再做一次权限检查防止无权限出错
    	if(CheckHasPermission(CAMERA_PERMISSION)){
    		Toast("无相机权限")
    		return;
    	}
    	if(isPreviewing){
    		Toast("重复初始化")
    		return;
    	}
    	if(mCamera == null){
    		//这里因为openCamera底层是异步的在极端情况下,mCamera会由于时许问题在此位null
    		return;
    	}
    	try{
    		//mCamera.startPreview() 经常会抛异常错误信息位startPreview fail. 该异常一部分通常与自动对焦有关系,所以这里try-catch cancelAutoFocus.
    		//cancelAutoFocus
    		mCamera.cancelAutoFocus();
    	}catch(Exception e){
    		
    	}
    	synchronize(Lock){
    		if(acquireLock(timeot = 2000)){
    			Log.w("timeout");
    		}
    		mCamera.setPreviewDisplay(mSurfaceHolder);
    		//previewCallBack监听回调,通知UI层。
    		mCamera.setPreviewCallBack(new PreviewCallback(){
    			void onPreviewFrame(byte[] data, Camera camera){
    				releaseLock();
    				if(isPreviewing) return;
    				isPreviewing = true;
    				CameraManager.of().onCameraPreviewed();=
    			}
    		})
    		try{
    			mCamera.startPreview();
    		}catch(Exception e){
    			Log.e(TAG, "exp info = "+e.getInfos());
    			//重试逻辑
    			retryStartPreview();
    		}
    	}
    }
    
    public void releaseCamera(){
    	if(mCamera == null) return;
    	synchronized(Lock){
    		try{
    			if(acquireLock(timeout = 2000)){
    				Log.e(TAG, "timeout")
    			}
    			mCamera.stopPreview();
    			mCamera.release();
    			mCamera = null;
    			releaseLock();
    		}catch(Exception e){
    			...
    		}
    	}
    }
    
    更多相关内容
  • Android Framework提供Camera API来实现拍照与录制视频的功能,目前Android有三类API, Camera 此类是用于控制设备相机的旧版 API,现已弃用,在Android5.0以下使用 Camera2 此软件包是用于控制设备相机的主要 ...

    基础知识

    Android Framework提供Camera API来实现拍照与录制视频的功能,目前Android有三类API,

    • Camera
      此类是用于控制设备相机的旧版 API,现已弃用,在Android5.0以下使用
    • Camera2
      此软件包是用于控制设备相机的主要 API,Android5.0以上使用
    • CameraX
      基于Camera 2 API封装,简化了开发流程,并增加生命周期控制

    相关开发类

    • android.hardware.camera2
      控制相机的核心API,使用它可以实现拍照和录制视频的功能。
    • Camera
      此类是用于控制设备相机的旧版 API,现已弃用。
    • SurfaceView
      此类用于向用户呈现实时相机预览。
    • TextureView
      也是用于实时相机预览,Android4.0之后引入
    • MediaRecorder
      用于录制视频
    • Intent
      MediaStore.ACTION_IMAGE_CAPTURE 或 MediaStore.ACTION_VIDEO_CAPTURE 的 Intent 操作类型可用于捕获图像或视频,而无需直接使用 Camera 对象。

    术语

    1. ISO(感光度)
      CMOS(或胶卷)对光线的敏感程度,用ISO100的胶卷,相机2秒可以正确曝光的话,同样光线条件下用ISO200的胶卷只需要1秒即可,用ISO400则只要0.5秒。
      常见的标准:ISO100,ISO200,ISO400
    2. 曝光时间
      曝光时间是为了将光投射到相机感光片上,相机快门所要打开至关闭的时间
    3. 光圈
      用来控制光线透过镜头,进入相机内感光面光量的装置
    4. 焦距
      指的是平行的光线穿过镜片后,所汇集的焦点至镜片间之距离。
      数值越小,代表可以拍摄的角度越广,数值越大,代表可以拍摄的角度越小
    5. 景深
      拍摄时,当镜头聚集于某个被摄体时,这个被摄体就能在相机上结成清晰影像。使被摄体产生较为清晰影像的纵深的范围叫景深
    6. 测光
      测光模式:中央平均测光(average metering)、中央局部测光、点测光(spot metering)、多点测光、评价测光
    7. 自动曝光(Auto Exposure)
      相机根据光线条件自动来调整曝光时间等来确定曝光量
    8. 对焦
      对焦模式:自动对焦 AE(Auto Focus)、手动对焦 MF(Manual Focus)
      自动对焦分为对比度对焦(contrast)、相位对焦(PDAF: Phase Detection Auto Focus)和混合对焦(hybrid)
    9. 闪光灯(Flashlight)
      通过闪光灯打闪照亮物体来达到拍出清晰图片的目的
    10. ScreenFlash
      通过屏幕打闪,照亮周围物体,拍出高清图片
    11. 高动态范围图像(HDR)
      HDR全称是High-Dynamic Range,即高动态范围图像技术。在拍照过程中开启HDR,可以让原先的暗场景变得更明亮更通透。
    12. 零延时拍照(ZSD)
      为了减少拍照延时,让拍照&回显瞬间完成的一种技术
    13. 连拍(ContinuousShot)
      通过节约数据传输时间来捕捉摄影时机
    14. 预览大小(PreviewSize)
      相机预览图片的大小
    15. 拍照大小(PictureSize)
      拍照生成图片的大小
    16. 自动白平衡(Auto white balance)
      AWB(Auto white balance),自动白平衡是相机的默认设置,相机中有一结构复杂的矩形图,它可决定画面中的白平衡基准点,以此来达到白平衡调校
    17. 对比度
      图像最亮和最暗之间的区域之间的比率,比值越大,从黑到白的渐变层次就越多,从而色彩表现越丰富
    18. 饱和度
      指色彩的鲜艳程度
    19. 锐度
      是反映图像平面清晰度和图像边缘锐利程度的一个指标

    相机功能

    Android 支持多种相机功能,您可使用相机应用控制这些功能,如图片格式、闪光模式、对焦设置等等。
    通过Camera.Parameters可以设置大部分的功能,下面介绍几个重要功能:

    • 区域测光和对焦
    • 人脸检测
    • 延时视频

    区域测光和对焦

    从 Android 4.0(API 级别 14)开始,通过Camera.Parameters来确定对焦或亮度设置的区域,然后进行拍照或者录像

    人脸检测

    这个和真正的人脸识别是不一样的 ,这里仅仅是检测人脸。
    通过照片分析,检测照片中是否包含人脸,使用人脸识别技术来识别人脸并计算照片设置

    延时视频

    延时视频功能允许用户将间隔几秒钟或几分钟拍摄的图片串联起来,创建视频剪辑。使用MediaRecorder录制时间流逝片段的图像。

    其他重要功能API:

    功能API

    Camera1使用

    流程:

    1. 检测设备摄像头,打开相机
    2. 创建预览画面,显示实时预览画面
    3. 设置相机参数,进行拍照监听
    4. 监听中,保存图片资源或者直接操作原始数据
    5. 释放相机资源

    权限声明

    <uses-feature
            android:name="android.hardware.camera"
            android:required="true" />
    
    <uses-permission android:name="android.permission.CAMERA" />
    

    相机必须声明CAMERA权限,在Android6.0上,你还需要在代码中动态申请权限

    ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA},
                        REQUEST_CAMERA_PERMISSION);
    

    开发流程

    下图是一个开发流程的导览:

    打开相机

    Camera.open()
    

    该方法的系统源码实现

    public static Camera open() {
        int numberOfCameras = getNumberOfCameras();
        CameraInfo cameraInfo = new CameraInfo();
        for (int i = 0; i < numberOfCameras; i++) {
            getCameraInfo(i, cameraInfo);
            if (cameraInfo.facing == CameraInfo.CAMERA_FACING_BACK) {
                return new Camera(i);
            }
        }
        return null;
    }
    

    这里会检查可用的摄像头,默认使用的CameraInfo.CAMERA_FACING_BACK后置摄像头

    创建预览画面

    这里使用的是SurfaceView

    private SurfaceView mSurfaceView;
    private SurfaceHolder mSurfaceHolder;
    ...
    mSurfaceHolder = mSurfaceView.getHolder();
    mSurfaceHolder.addCallback(new SurfaceHolder.Callback() {
        @Override
        public void surfaceCreated(SurfaceHolder holder) {
            ...
            startPreview();
        }
    
        @Override
        public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
    
        }
    
        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {
            releaseCamera();
        }
    });
    ...
    private void startPreview() {
        try {
            //设置实时预览
            mCamera.setPreviewDisplay(mSurfaceHolder);
            //Orientation
            setCameraDisplayOrientation();
            //开始预览
            mCamera.startPreview();
    
            startFaceDetect();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    

    设置预览的时候,可以设置setPreviewCallback监听预览数据的回调

    void onPreviewFrame(byte[] data, Camera camera);
    

    设置相机参数

    设置相机参数后,需要重新启动预览,这边在初始化的时候,已经设置好了。

    private void initParameters(final Camera camera) {
        mParameters = camera.getParameters();
        mParameters.setPreviewFormat(ImageFormat.NV21); //default
    
        if (isSupportFocus(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
            mParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
        } else if (isSupportFocus(Camera.Parameters.FOCUS_MODE_AUTO)) {
            mParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
        }
    
        //设置预览图片大小
        setPreviewSize();
        //设置图片大小
        setPictureSize();
    
        camera.setParameters(mParameters);
    }
    

    Camera.Parameters可以设置的参数非常多,这里就介绍几个比较常用的

     

    Camera.Parameters

    1.setFocusMode

    设置对焦模式

    • FOCUS_MODE_AUTO:自动对焦
    • FOCUS_MODE_INFINITY:无穷远
    • FOCUS_MODE_MACRO:微距
    • FOCUS_MODE_FIXED:固定焦距
    • FOCUS_MODE_EDOF:景深扩展
    • FOCUS_MODE_CONTINUOUS_PICTURE:持续对焦(针对照片)
    • FOCUS_MODE_CONTINUOUS_VIDEO:(针对视频)

    2.setPreviewSize

    设置预览图片大小

    3.setPreviewFormat

    支持的格式:

    • ImageFormat.NV16
    • ImageFormat.NV21
    • ImageFormat.YUY2
    • ImageFormat.YV12
    • ImgaeFormat.RGB_565
    • ImageFormat.JPEG
      如果不设置,默认返回NV21的数据

    4.setPictureSize

    设置保存图片的大小

    5.setPictureFormat

    设置保存图片的格式,格式和setPreviewFormat一样

    6.setDisplayOrientation

    设置相机预览画面旋转的角度,degress取值0,90,180,270

    7.setPreviewDisplay

    设置实时预览SurfaceHolder

    8.setPreviewCallback

    监听相机预览数据回调

    9.setParameters

    设置相机的Parameters
    其他一些设置,大家可以查看Android文档进行相应的设置

    设置方向

    设置相机的预览方向,orientation比较详细的介绍

    private void setCameraDisplayOrientation() {
        Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
        Camera.getCameraInfo(mCameraId, cameraInfo);
        int rotation = getWindowManager().getDefaultDisplay().getRotation();  //自然方向
        int degrees = 0;
        switch (rotation) {
            case Surface.ROTATION_0:
                degrees = 0;
                break;
            case Surface.ROTATION_90:
                degrees = 90;
                break;
            case Surface.ROTATION_180:
                degrees = 180;
                break;
            case Surface.ROTATION_270:
                degrees = 270;
                break;
        }
    
        int result;
        //cameraInfo.orientation 图像传感方向
        if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
            result = (cameraInfo.orientation + degrees) % 360;
            result = (360 - result) % 360;
        } else {
            result = (cameraInfo.orientation - degrees + 360) % 360;
        }
    
        mOrientation = result;
        //相机预览方向
        mCamera.setDisplayOrientation(result);
    }
    

    拍照

    private void takePicture() {
        if (null != mCamera) {
            mCamera.takePicture(new Camera.ShutterCallback() {
                @Override
                public void onShutter() {
    
                }
            }, new Camera.PictureCallback() {
                @Override
                public void onPictureTaken(byte[] data, Camera camera) {
                    //base data
                }
            }, new Camera.PictureCallback() {
                @Override
                public void onPictureTaken(final byte[] data, Camera camera) {
                    mCamera.startPreview();
                    //save data
                }
            });
        }
    }
    

    takePicture的源码实现:

    public final void takePicture(ShutterCallback shutter, PictureCallback raw,
                PictureCallback jpeg) {
            takePicture(shutter, raw, null, jpeg);
        }
    
    • shutter(ShutterCallback):快门按下后的回调
    • raw(PictureCallback):raw图像数据
    • jpeg(PictureCallback):jpeg图像生成以后的回调

    释放相机资源

    在使用完成后,onPause或者onDestory中进行相机资源的释放

    private void releaseCamera() {
        if (null != mCamera) {
            mCamera.stopPreview();
            mCamera.stopFaceDetection();
            mCamera.setPreviewCallback(null);
            mCamera.release();
            mCamera = null;
        }
    }
    
    • stopPreview:停止预览
    • release:释放资源

    Camera2使用

    设计框架

    来自官网的模型图,展示了相关的工作流程

    重新设计 Android Camera API 的目的在于大幅提高应用对于 Android 设备上的相机子系统的控制能力,同时重新组织 API,提高其效率和可维护性。
    在CaptureRequest中设置不同的Surface用于接收不同的图片数据,最后从不同的Surface中获取到图片数据和包含拍照相关信息的CaptureResult。

    优点

    通过设计框架的改造和优化,Camera2具备了以下优点:

    • 改进了新硬件的性能。Supported Hardware Level的概念,不同厂商对Camera2的支持程度不同,从低到高有LEGACY、LIMITED、FULL 和 LEVEL_3四个级别
    • 以更快的间隔拍摄图像
    • 显示来自多个摄像机的预览
    • 直接应用效果和滤镜

    开发流程

    框架上的变化,对整个使用流程变化也非常大,首先了解一些主要的开发类

    CameraManager

    相机系统服务,用于管理和连接相机设备

    CameraDevice

    相机设备类,和Camera1中的Camera同级

    CameraCharacteristics

    主要用于获取相机信息,内部携带大量的相机信息,包含摄像头的正反(LENS_FACING)、AE模式、AF模式等,和Camera1中的Camera.Parameters类似

    CaptureRequest

    相机捕获图像的设置请求,包含传感器,镜头,闪光灯等

    CaptureRequest.Builder

    CaptureRequest的构造器,使用Builder模式,设置更加方便

    CameraCaptureSession

    请求抓取相机图像帧的会话,会话的建立主要会建立起一个通道。一个CameraDevice一次只能开启一个CameraCaptureSession。
    源端是相机,另一端是 Target,Target可以是Preview,也可以是ImageReader。

    ImageReader

    用于从相机打开的通道中读取需要的格式的原始图像数据,可以设置多个ImageReader。

    流程

     Camera2开发流程

    获取CameraManager

    CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
    

    获取相机信息

    for (String cameraId : cameraManager.getCameraIdList()) {
        CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
    
        Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
        if (null != facing && facing == CameraCharacteristics.LENS_FACING_FRONT) {
            continue;
        }
        ....
    }
    

    这里默认选择前置摄像头,并获取相关相机信息。

    初始化ImageReader

    mImageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(), ImageFormat.JPEG, 2);
    mImageReader.setOnImageAvailableListener(new ImageReader.OnImageAvailableListener() {
        @Override
        public void onImageAvailable(ImageReader reader) {
            Log.d("DEBUG", "##### onImageAvailable: " + mFile.getPath());
            mBackgroundHandler.post(new ImageSaver(reader.acquireNextImage(), mFile));
        }
    }, mBackgroundHandler);
    

    ImageReader是获取图像数据的重要途径,通过它可以获取到不同格式的图像数据,例如JPEG、YUV、RAW等。通过ImageReader.newInstance(int width, int height, int format, int maxImages)创建ImageReader对象,有4个参数:

    • width:图像数据的宽度
    • height:图像数据的高度
    • format:图像数据的格式,例如ImageFormat.JPEGImageFormat.YUV_420_888
    • maxImages:最大Image个数,Image对象池的大小,指定了能从ImageReader获取Image对象的最大值,过多获取缓冲区可能导致OOM,所以最好按照最少的需要去设置这个值

    ImageReader其他相关的方法和回调:

    • ImageReader.OnImageAvailableListener:有新图像数据的回调
    • acquireLatestImage():从ImageReader的队列里面,获取最新的Image,删除旧的,如果没有可用的Image,返回null
    • acquireNextImage():获取下一个最新的可用Image,没有则返回null
    • close():释放与此ImageReader关联的所有资源
    • getSurface():获取为当前ImageReader生成Image的Surface

    打开相机设备

    try {
        if (!mCameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
            throw new RuntimeException("Time out waiting to lock camera opening.");
        }
    
        cameraManager.openCamera(mCameraId, mStateCallback, mBackgroundHandler);
    } catch (Exception e) {
        e.printStackTrace();
    }
    

    cameraManager.openCamera(@NonNull String cameraId,@NonNull final CameraDevice.StateCallback callback, @Nullable Handler handler)的三个参数:

    • cameraId:摄像头的唯一标识
    • callback:设备连接状态变化的回调
    • handler:回调执行的Handler对象,传入null则使用当前的主线程Handler

    其中callback回调:

    private final CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() {
        @Override
        public void onOpened(@NonNull CameraDevice camera) {
            mCameraOpenCloseLock.release();
            mCameraDevice = camera;
            createCameraPreviewSession();
        }
    
        @Override
        public void onDisconnected(@NonNull CameraDevice camera) {
            mCameraOpenCloseLock.release();
            camera.close();
            mCameraDevice = null;
        }
    
        @Override
        public void onError(@NonNull CameraDevice camera, int error) {
            mCameraOpenCloseLock.release();
            camera.close();
            mCameraDevice = null;
        }
    
        @Override
        public void onClosed(@NonNull CameraDevice camera) {
            super.onClosed(camera);
        }
    };
    
    • onOpened:表示相机打开成功,可以真正开始使用相机,创建Capture会话
    • onDisconnected:当相机断开连接时回调该方法,需要进行释放相机的操作
    • onError:当相机打开失败时,需要进行释放相机的操作
    • onClosed:调用Camera.close()后的回调方法

    创建Capture会话

    在CameraDevice.StateCallback的onOpened回调中执行:

    private void createCameraPreviewSession() {
        SurfaceTexture texture = mTextureView.getSurfaceTexture();
        assert texture != null;
        texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
        Surface surface = new Surface(texture);
    
        try {
            mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            mPreviewRequestBuilder.addTarget(surface);
    
            // Here, we create a CameraCaptureSession for camera preview.
            mCameraDevice.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()),
                    new CameraCaptureSession.StateCallback() {
    
                        @Override
                        public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
                            // The camera is already closed
                            if (null == mCameraDevice) {
                                return;
                            }
    
                            // When the session is ready, we start displaying the preview.
                            mCaptureSession = cameraCaptureSession;
                            try {
                                // Auto focus should be continuous for camera preview.
                                mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
                                        CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
                                // Flash is automatically enabled when necessary.
                                setAutoFlash(mPreviewRequestBuilder);
    
                                // Finally, we start displaying the camera preview.
                                mPreviewRequest = mPreviewRequestBuilder.build();
                                mCaptureSession.setRepeatingRequest(mPreviewRequest,
                                        mCaptureCallback, mBackgroundHandler);
                            } catch (CameraAccessException e) {
                                e.printStackTrace();
                            }
                        }
    
                        @Override
                        public void onConfigureFailed(
                                @NonNull CameraCaptureSession cameraCaptureSession) {
                            Toast.makeText(Camera2Activity.this, "configureFailed", Toast.LENGTH_SHORT).show();
                        }
                    }, null
            );
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }
    

    这段的代码核心方法是mCameraDevice.createCaptureSession()创建Capture会话,它接受了三个参数:

    • outputs:用于接受图像数据的surface集合,这里传入的是一个preview的surface
    • callback:用于监听 Session 状态的CameraCaptureSession.StateCallback对象
    • handler:用于执行CameraCaptureSession.StateCallback的Handler对象,传入null则使用当前的主线程Handler

    创建CaptureRequest

    CaptureRequest是向CameraCaptureSession提交Capture请求时的信息载体,其内部包括了本次Capture的参数配置和接收图像数据的Surface。

    mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
    mPreviewRequestBuilder.addTarget(surface);
    

    通过CameraDevice.createCaptureRequest()创建CaptureRequest.Builder对象,传入一个templateType参数,templateType用于指定使用何种模板创建CaptureRequest.Builder对象,templateType的取值:

    • TEMPLATE_PREVIEW:预览模式
    • TEMPLATE_STILL_CAPTURE:拍照模式
    • TEMPLATE_RECORD:视频录制模式
    • TEMPLATE_VIDEO_SNAPSHOT:视频截图模式
    • TEMPLATE_MANUAL:手动配置参数模式

    除了模式的配置,CaptureRequest还可以配置很多其他信息,例如图像格式、图像分辨率、传感器控制、闪光灯控制、3A(自动对焦-AF、自动曝光-AE和自动白平衡-AWB)控制等。在createCaptureSession的回调中可以进行设置

    // Auto focus should be continuous for camera preview.
    mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
            CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
    // Flash is automatically enabled when necessary.
    setAutoFlash(mPreviewRequestBuilder);
    
    // Finally, we start displaying the camera preview.
    mPreviewRequest = mPreviewRequestBuilder.build();
    

    代码中设置了AF为设置未图片模式下的连续对焦,并设置自动闪光灯。最后通过build()方法生成CaptureRequest对象。

    预览

    Camera2中,通过连续重复的Capture实现预览功能,每次Capture会把预览画面显示到对应的Surface上。连续重复的Capture操作通过mCaptureSession.setRepeatingRequest(mPreviewRequest,mCaptureCallback, mBackgroundHandler)实现,该方法有三个参数:

    • request:CaptureRequest对象
    • listener:监听Capture 状态的回调
    • handler:用于执行CameraCaptureSession.CaptureCallback的Handler对象,传入null则使用当前的主线程Handler

    停止预览使用mCaptureSession.stopRepeating()方法。

    拍照

    设置上面的request,session后,就可以真正的开始拍照操作

    mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, mBackgroundHandler);
    

    该方法也有三个参数,和mCaptureSession.setRepeatingRequest一样:

    • request:CaptureRequest对象
    • listener:监听Capture 状态的回调
    • handler:用于执行CameraCaptureSession.CaptureCallback的Handler对象,传入null则使用当前的主线程Handler

    这里设置了mCaptureCallback:

    private CameraCaptureSession.CaptureCallback mCaptureCallback = new CameraCaptureSession.CaptureCallback() {
        @Override
        public void onCaptureProgressed(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull CaptureResult partialResult) {
            process(partialResult);
        }
    
        @Override
        public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
            process(result);
        }
    
        private void process(CaptureResult result) {
            switch (mState) {
                case STATE_PREVIEW: {
                    // We have nothing to do when the camera preview is working normally.
                    break;
                }
                case STATE_WAITING_LOCK: {
                    Integer afState = result.get(CaptureResult.CONTROL_AF_STATE);
                    Log.d("DEBUG", "##### process STATE_WAITING_LOCK: " + afState);
                    if (afState == null) {
                        captureStillPicture();
                    } else if (CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED == afState ||
                            CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED == afState) {
                        // CONTROL_AE_STATE can be null on some devices
                        Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                        if (aeState == null ||
                                aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED) {
                            mState = STATE_PICTURE_TAKEN;
                            captureStillPicture();
                        } else {
                            runPrecaptureSequence();
                        }
                    }
                    break;
                }
                case STATE_WAITING_PRECAPTURE: {
                    // CONTROL_AE_STATE can be null on some devices
                    Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                    if (aeState == null ||
                            aeState == CaptureResult.CONTROL_AE_STATE_PRECAPTURE ||
                            aeState == CaptureRequest.CONTROL_AE_STATE_FLASH_REQUIRED) {
                        mState = STATE_WAITING_NON_PRECAPTURE;
                    }
                    break;
                }
                case STATE_WAITING_NON_PRECAPTURE: {
                    // CONTROL_AE_STATE can be null on some devices
                    Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                    if (aeState == null || aeState != CaptureResult.CONTROL_AE_STATE_PRECAPTURE) {
                        mState = STATE_PICTURE_TAKEN;
                        captureStillPicture();
                    }
                    break;
                }
            }
        }
    };
    

    通过设置mState来区分当前状态,是在预览还是拍照

    关闭相机

    退到后台或者当前页面被关闭的时候,已经不需要使用相机了,需要进行相机关闭操作,释放资源,

    private void closeCamera() {
        try {
            mCameraOpenCloseLock.acquire();
            if (null != mCaptureSession) {
                mCaptureSession.close();
                mCaptureSession = null;
            }
            if (null != mCameraDevice) {
                mCameraDevice.close();
                mCameraDevice = null;
            }
            if (null != mImageReader) {
                mImageReader.close();
                mImageReader = null;
            }
        } catch (InterruptedException e) {
            throw new RuntimeException("Interrupted while trying to lock camera closing.", e);
        } finally {
            mCameraOpenCloseLock.release();
        }
    }
    

    先后对CaptureSession,CameraDevice,ImageReader进行close操作,释放资源。
    这里仅仅对Camera2基本使用流程做了介绍,一些更高级的用法需要大家自行去实践。在Camera1中需要对画面进行方向矫正,而Camera2是否需要呢,关于相机Orientation相关的知识,通过后面的章节再进行介绍。

    CameraView

    CameraView的目的就是帮助开发者能够快速集成Camera1和Camera2的特性,可以用下面这张表来说明:

    开发流程

    CameraView定义

    xml中定义

    <com.google.android.cameraview.CameraView
        android:id="@+id/camera"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:keepScreenOn="true"
        android:adjustViewBounds="true"
        app:autoFocus="true"
        app:aspectRatio="4:3"
        app:facing="back"
        app:flash="auto"/>
    

    xml中可以配置:

    • autoFocus:是否自动对焦
    • aspectRatio:预览画面比例
    • facing:前后摄像头
    • flash:闪光灯模式

    增加生命周期

    @Override
    protected void onResume() {
        super.onResume();
        mCameraView.start();
    }
    
    @Override
    protected void onPause() {
        mCameraView.stop();
        super.onPause();
    }
    

    这样声明后,就可以完成预览的工作了

    相机状态回调

    在xml声明CameraView后,增加回调

    if (mCameraView != null) {
        mCameraView.addCallback(mCallback);
    }
    ...
    private CameraView.Callback mCallback
                = new CameraView.Callback() {
    
        @Override
        public void onCameraOpened(CameraView cameraView) {
            Log.d(TAG, "onCameraOpened");
        }
    
        @Override
        public void onCameraClosed(CameraView cameraView) {
            Log.d(TAG, "onCameraClosed");
        }
    
        @Override
        public void onPictureTaken(CameraView cameraView, final byte[] data) {
            Log.d(TAG, "onPictureTaken " + data.length);
            Toast.makeText(cameraView.getContext(), R.string.picture_taken, Toast.LENGTH_SHORT)
                    .show();
            getBackgroundHandler().post(new Runnable() {
                @Override
                public void run() {
                    File file = new File(getExternalFilesDir(Environment.DIRECTORY_PICTURES),
                            "picture.jpg");
                    Log.d(TAG, "onPictureTaken file path: " + file.getPath());
                    OutputStream os = null;
                    try {
                        os = new FileOutputStream(file);
                        os.write(data);
                        os.close();
                    } catch (IOException e) {
                        Log.w(TAG, "Cannot write to " + file, e);
                    } finally {
                        if (os != null) {
                            try {
                                os.close();
                            } catch (IOException e) {
                                // Ignore
                            }
                        }
                    }
                }
            });
        }
    
    };
    

    有三个回调方法,相机打开,相机关闭,和拍照。

    拍照

    mCameraView.takePicture();
    

    就是这么简单,点击后拍照,然后回调中处理图像数据

    CameraX

    CameraX 是一个 Jetpack 支持库,目的是简化Camera的开发工作,它是基于Camera2 API的基础,向后兼容至 Android 5.0(API 级别 21)。
    它有以下几个特性:

    • 易用性,只需要几行代码就可以实现预览和拍照
    • 保持设备的一致性,在不同相机设备上,对宽高比、屏幕方向、旋转、预览大小和高分辨率图片大小,做到都可以正常使用
    • 相机特性的扩展,增加人像、HDR、夜间模式和美颜等功能

    开发流程

    库引用

    目前CameraX最新版本是1.0.0-alpha06,在app的build.gradle引用:

    dependencies {
        // CameraX core library.
        def camerax_version = "1.0.0-alpha06"
        implementation "androidx.camera:camera-core:${camerax_version}"
        // If you want to use Camera2 extensions.
        implementation "androidx.camera:camera-camera2:${camerax_version}"
    
        def camerax_view_version = "1.0.0-alpha03"
        def camerax_ext_version = "1.0.0-alpha03"
        //other
        // If you to use the Camera View class
        implementation "androidx.camera:camera-view:$camerax_view_version"
        // If you to use Camera Extensions
        implementation "androidx.camera:camera-extensions:$camerax_ext_version"
    }
    

    因为CameraX是一个 Jetpack 支持库,相机的打开和释放都是使用了Jetpack的Lifecycle来进行处理。

    预览

    预览参数设置,使用PreviewConfig.Builder()实现:

    PreviewConfig config = new PreviewConfig.Builder()
                    .setLensFacing(CameraX.LensFacing.BACK)
                    .setTargetRotation(mTextureView.getDisplay().getRotation())
                    .setTargetResolution(new Size(640, 480))
                    .build();
    
    Preview preview = new Preview(config);
    preview.setOnPreviewOutputUpdateListener(new Preview.OnPreviewOutputUpdateListener() {
        @Override
        public void onUpdated(@NonNull Preview.PreviewOutput output) {
            if (mTextureView.getParent() instanceof ViewGroup) {
                ViewGroup viewGroup = (ViewGroup) mTextureView.getParent();
                viewGroup.removeView(mTextureView);
                viewGroup.addView(mTextureView, 0);
    
                mTextureView.setSurfaceTexture(output.getSurfaceTexture());
                updateTransform();
            }
        }
    });
    
    //lifecycle
    CameraX.bindToLifecycle(this, preview);
    

    PreivewConfig.Builder可以设置的属性很多,这里只设置了摄像头、旋转方向、预览分辨率,还有很多其他方法,大家可以自行试验。
    在preview回调监听中,把output的SurfaceTexture设置到mTextureView中,实现图像预览,最后增加Lifecycle的绑定。

    拍照

    ImageCaptureConfig captureConfig = new ImageCaptureConfig.Builder()
            .setTargetAspectRatio(AspectRatio.RATIO_16_9)
            .setCaptureMode(ImageCapture.CaptureMode.MIN_LATENCY)
            .setTargetRotation(getWindowManager().getDefaultDisplay().getRotation())
            .build();
    
    ImageCapture imageCapture = new ImageCapture(captureConfig);
    mTakePicture.setOnClickListener((view) -> {
        final File file = new File(getExternalMediaDirs()[0], System.currentTimeMillis() + ".jpg");
        Log.d("DEBUG", "##### file path: " + file.getPath());
        imageCapture.takePicture(file, ContextCompat.getMainExecutor(getApplicationContext()), new ImageCapture.OnImageSavedListener() {
            @Override
            public void onImageSaved(@NonNull File file) {
                Log.d("DEBUG", "##### onImageSaved: " + file.getPath());
            }
    
            @Override
            public void onError(@NonNull ImageCapture.ImageCaptureError imageCaptureError, @NonNull String message, @Nullable Throwable cause) {
                Log.d("DEBUG", "##### onError: " + message);
            }
        });
    });
    
    CameraX.bindToLifecycle(this, preview, imageCapture);
    

    拍照的参数通过ImageCaptureConfig.Builder设置,这里只设置了图片宽高比、拍摄模式和旋转方向,还有很多其他方法,大家可以自行试验。
    真正调用拍照的方法:

    • takePicture(OnImageCapturedListener):此方法为拍摄的图片提供内存缓冲区。
    • takePicture(File, OnImageSavedListener):此方法将拍摄的图片保存到提供的文件位置。
    • takePicture(File, OnImageSavedListener, Metadata):此方法可用于指定要嵌入已保存文件的 Exif 中的元数据。

    例子调用的是takePicture(File, OnImageSavedListener),直接存为文件。最后再增加Lifecycle的绑定。

    图片分析

    ImageAnalysisConfig analysisConfig = new ImageAnalysisConfig.Builder()
            .setImageReaderMode(ImageAnalysis.ImageReaderMode.ACQUIRE_LATEST_IMAGE)
            .build();
    
    ImageAnalysis imageAnalysis = new ImageAnalysis(analysisConfig);
    imageAnalysis.setAnalyzer(ContextCompat.getMainExecutor(getApplicationContext()),
            new LuminosityAnalyzer());
    
    CameraX.bindToLifecycle(this, preview, imageCapture, imageAnalysis);
    
    ...
    private class LuminosityAnalyzer implements ImageAnalysis.Analyzer {
        private long lastAnalyzedTimestamp = 0L;
    
        @Override
        public void analyze(ImageProxy image, int rotationDegrees) {
            final Image img = image.getImage();
            if (img != null) {
                Log.d("DEBUG", img.getWidth() + "," + img.getHeight());
            }
        }
    }
    

    图片分析,不是必要的步骤,但是ImageAnalysis,可以对每帧图像进行分析。
    设置参数通过ImageAnalysisConfig.Builder(),这里只设置了ImageReaderMode,它有两种模式:

    • 阻止模式(ImageReaderMode.ACQUIRE_NEXT_IMAGE):就是Camera2中的acquireNextImage(),获取下一个最新的可用Image
    • 非阻止模式(ImageReaderMode.ACQUIRE_LATEST_IMAGE):Camera2中的acquireLatestImage(),获得图像队列中最新的图片,并且会清空队列,删除已有的旧的图像

    最后还是增加Lifecycle的绑定。CameraX的使用也非常简单,把Camera2中复杂的API封装到统一的config中,只需要几行代码,就实现需要的功能。

     

     

     

    展开全文
  • 对焦功能标准化流程一、摘要二、对焦功能流程2.1 功能分类2.1.1 对焦模式2.1.2 对焦功能2.2 对焦工作流程2.2.1 Part1: `【1、2、3】`2.2.2 Part2:`【5、6、7】`2.2.3 Part3:`...Camera1 对焦(一) UI坐标系和相机坐

    一、摘要

    本篇文章围绕实际相机功能的对焦场景阐述如何开发好一个功能完善的相机对焦功能。

    相关文章:

    1. Camera1 对焦(一) UI坐标系和相机坐标系
    2. Camera1 对焦(二) 对焦区域计算的几种方式(Touch to Focus)
    3. Camera1 Parameters参数详解(二)—— 3A算法 (对焦、曝光、白平衡)
    4. Android AF Work Flow安卓自动对焦工作流程

    二、对焦功能流程

    2.1 功能分类

    2.1.1 对焦模式

    对焦模式
    FOCUS_MODE_AUTO
    FOCUS_MODE_INFINITY
    FOCUS_MODE_MACRO
    FOCUS_MODE_FIXED
    FOCUS_MODE_EDOF
    FOCUS_MODE_CONTINUOUS_VIDEO
    FOCUS_MODE_CONTINUOUS_PICTURE

    具体细节可参考Camera1 Parameters参数详解(二)—— 3A算法 (对焦、曝光、白平衡)【二.AF】

    2.1.2 对焦功能

    1. 连续对焦:用于相机移动预览画面,对应对焦模式为continuous
    2. 单次对焦:touch focus,点击对焦

    2.2 对焦工作流程

    在这里插入图片描述

    2.2.1 Part1: 【1、2、3】

    1. 进入相机首先设置模式为连续对焦,拍照和视频对应不同的连续对焦

    2.2.2 Part2:【5、6、7】

    1. 单次对焦分为2种,一种为自己触发一次中心对焦。另外一种为根据onTouchEvent获取点击位置Touch Focus。
    2. 自己触发一次中心对焦即坐标点为(mPreviewUIWidth/2f,mPreviewUIHeight/2f),Touch Focus即(touchX, touchY)
    3. 判断AUTO模式,判断maxMeterAreaNum、maxFocusAreaNum等
    4. 具体代码可参考Camera1 对焦(二) 对焦区域计算的几种方式(Touch to Focus)

    2.2.3 Part3:【8、9】

    part2之后即锁定了对焦区域为Part2设置的rect。此时需要监听手机是否移动,如果不监听手机是否做移动就会出现对焦区域锁定在点击区域,移到别的场景就会出现不对焦的情况。

    1. 监听手机传感器,根据阀值判断手机是否移动相关距离
    2. 如果移动则切换到连续对焦
    3. 这里需要延后一定时间如3000ms后开始检测移动,否则当点击固定区域对焦后手抖就会立马失焦

    2.3 相关代码

    2.3.1 设置连续对焦模式代码:

    private void setAutoFocus(Camera camera) {
    	if (camera is null) {
    	   return;
    	}
    	try {
    	   Camera.Parameters params = mCamera1Config.getCameraParameter(camera);
    	   if (params == null) {
    	       return;
    	   }
    	   List<String> modes = params.getSupportedFocusModes();
    	   if (modes is null) {
    	       return;
    	   }
    	   if (isVideo && modes.contains(FOCUS_MODE_CONTINUOUS_VIDEO)) {
    	       params.setFocusMode(FOCUS_MODE_CONTINUOUS_VIDEO);
    	   } else if (modes.contains(FOCUS_MODE_CONTINUOUS_PICTURE)) {
    	       params.setFocusMode(FOCUS_MODE_CONTINUOUS_PICTURE);
    	   } else if (modes.contains(FOCUS_MODE_FIXED)) {
    	       params.setFocusMode(FOCUS_MODE_FIXED);
    	   } else if (modes.contains(FOCUS_MODE_INFINITY)) {
    	       params.setFocusMode(FOCUS_MODE_INFINITY);
    	   } else {
    	       params.setFocusMode(modes.get(0));
    	   }
    	   camera.setParameters(params);
    	} catch (Exception e) {
    		...
    	}
    }
    

    2.3.2 touch Focus相关代码

    传送门 => Camera1 对焦(二) 对焦区域计算的几种方式(Touch to Focus)

    2.3.3 监听传感器移动

    public class PhoneMovementDetector implements SensorEventListener {
        protected final String TAG = getClass().getSimpleName();
        private SensorManager sensorManager;
        private Sensor accelerometer;
        private Listener listener;
        private Semaphore lock = new Semaphore(1);
        
        private static PhoneMovementDetector mInstance = new PhoneMovementDetector();
    
        private void init() {
            sensorManager = (SensorManager) AppContexts.sContext.getSystemService(Context.SENSOR_SERVICE);
            accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION);
        }
    
        public PhoneMovementDetector start(Listener listener) {
            this.listener = listener;
            sensorManager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_NORMAL);
            return this;
        }
    
        public PhoneMovementDetector stop() {
            sensorManager.unregisterListener(this);
            this.listener = null;
            return this;
        }
    
        private long lastTime = 0;
        @Override
        public void onSensorChanged(SensorEvent event) {
            if (event.sensor.getType() == Sensor.TYPE_LINEAR_ACCELERATION) {
                try {
                    float x = event.values[0];
                    float y = event.values[1];
                    float z = event.values[2];
                    float diff = x * x + y * y + z * z;
                    listener.onMotionDetected(diff);
                } catch (Exception e) {
                } finally {
                }
            }
        }
        
        public interface Listener {
            void onMotionDetected(float acceleration);
        }
    }
    

    综上,Android Camera里对焦功能开发基于上述流程即可。

    展开全文
  • Camera1 在 API 21 的时候已经被弃用了,虽然现在google 都推荐 使用 Camerax 来实现相机的一些功能,但这不妨碍我们学习 Camera1 和 Camera2,对此有基础了解,为后续学习 Camera2 和 Camerax 做铺垫 在这篇文章中...

    音视频 系列文章
    Android 音视频开发(一) – 使用AudioRecord 录制PCM(录音);AudioTrack播放音频
    Android 音视频开发(二) – Camera1 实现预览、拍照功能
    Android 音视频开发(三) – Camera2 实现预览、拍照功能
    Android 音视频开发(四) – CameraX 实现预览、拍照功能
    Android 音视频开发(五) – 使用 MediaExtractor 分离音视频,并使用 MediaMuxer合成新视频(音视频同步)
    音视频工程

    Camera1 在 API 21 的时候已经被弃用了,虽然现在google 都推荐 使用 Camerax 来实现相机的一些功能,但这不妨碍我们学习 Camera1 和 Camera2,对此有基础了解,为后续学习 Camera2 和 Camerax 做铺垫

    在这篇文章中,你将了解到:

    1. 实现相机的开启与预览
    2. 相机预览方向的矫正
    3. 实现拍照功能,并矫正拍照图片

    效果如下:
    在这里插入图片描述

    一. 相机的开启与预览

    首先,先申请权限:

     <uses-permission android:name="android.permission.CAMERA" />
     <!-- 支持相机才能运行 -->
     <uses-feature
         android:name="android.hardware.camera"
         android:required="true" />
    

    1.1. 获取相机个数

    一般手机中,都有前置摄像头和后置摄像头,我们可以根据 Camera 的 getNumberOfCameras() 方法,来获取这些信息。比如:

     //获取相机个数
     int numberOfCameras = Camera.getNumberOfCameras();
     for (int i = 0; i < numberOfCameras; i++) {
         Camera.CameraInfo info = new Camera.CameraInfo();
         //获取相机信息
         Camera.getCameraInfo(i, info);
         //前置摄像头
         if (Camera.CameraInfo.CAMERA_FACING_FRONT == info.facing) {
             mFrontCameraId = i;
             mFrontCameraInfo = info;
         } else if (Camera.CameraInfo.CAMERA_FACING_BACK == info.facing) {
             mBackCameraId = i;
             mBackCameraInfo = info;
         }
     }
    

    可以看到,通过 Camera.getCameraInfo(i, info) 就可以拿到当前的 CameraInfo 的信息,里面有个参数我们需要注意一下,就是 facing,它表示当前摄像机面对的方向,理解为前置和后置,然后我们把这些信息也保存起来。

    1.2 打开摄像头

    接着,我们可以使用 Camera.open(cameraid) 去打开摄像头

     //根据 cameraId 打开不同摄像头
     mCamera = Camera.open(cameraId);
    

    打开我们的摄像头之后,可以对它进行一些配置,比如设置预览方向等,这个话题我们等到下面出现了再说。

    1.3 配置摄像头属性

    在开启相机预览之前,我们需要对相机进行一些参数配置,比如聚焦,预览尺寸等;这里我使用的是 SurfaceView,所以等SurfaceView 创建好之后,可以对它进行一些参数的设置:

      @Override
      public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
          startPreview(width, height);
      }
    
    # startPreview
    private void startPreview(int width, int height) {
    	//配置camera参数
        initPreviewParams(width, height);
        //设置预览 SurfaceHolder
        Camera camera = mCamera;
        if (camera != null) {
            try {
                camera.setPreviewDisplay(mSurfaceView.getHolder());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //开始显示
        camera.startPreview();
    }
    

    在Camra 中,我们可以通过 camera.getParameters() 拿到相机默认的参数,如果要配置自己的参数,可以使用 camera.setParameters(parameters) 去设置,不过这个比较比较好使,所以相机的配置开启这些,可以使用 HandlerThread 去开启,这里就不增加多余代码了。
    initPreviewParams 的完整代码如下:

        private void initPreviewParams(int shortSize, int longSize) {
            Camera camera = mCamera;
            if (camera != null) {
                Camera.Parameters parameters = camera.getParameters();
                //获取手机支持的尺寸
                List<Camera.Size> sizes = parameters.getSupportedPreviewSizes();
                Camera.Size bestSize = getBestSize(shortSize, longSize, sizes);
                //设置预览大小
                parameters.setPreviewSize(bestSize.width, bestSize.height);
                //设置图片大小,拍照
                parameters.setPictureSize(bestSize.width, bestSize.height);
                //设置格式,所有的相机都支持 NV21格式
                parameters.setPreviewFormat(ImageFormat.NV21);
                //设置聚焦
                parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
    
                camera.setParameters(parameters);
            }
        }
    

    1.3.1 相机预览大小

    首先,应该根据自己UI的大小去设置相机预览的大小,如果你的控件为 200x200,但相机的数据为 1920x1080 ,这样填充过去,画面肯定是会被拉伸的。
    所以,可以通过

    List<Camera.Size> sizes = parameters.getSupportedPreviewSizes()
    

    拿到手机相机支持的所有尺寸;所以,我们需要找到比例相同,或者近似的大小,跟UI配合,这样画面才不会拉伸,注意相机的 width > height,所以获取一个最佳的预览尺寸可以这样写:

    /**
      * 获取预览最后尺寸
      */
     private Camera.Size getBestSize(int shortSize, int longSize, List<Camera.Size> sizes) {
         Camera.Size bestSize = null;
         float uiRatio = (float) longSize / shortSize;
         float minRatio = uiRatio;
         for (Camera.Size previewSize : sizes) {
             float cameraRatio = (float) previewSize.width / previewSize.height;
    
             //如果找不到比例相同的,找一个最近的,防止预览变形
             float offset = Math.abs(cameraRatio - minRatio);
             if (offset < minRatio) {
                 minRatio = offset;
                 bestSize = previewSize;
             }
             //比例相同
             if (uiRatio == cameraRatio) {
                 bestSize = previewSize;
                 break;
             }
    
         }
         return bestSize;
     }
    

    当 UI 的比例跟相机支持的比例相同,直接返回,否则则找近似的。

    接着调用

    效果如下:

    在这里插入图片描述
    咦,发现预览的方向是反的;这个时候就需要使用 setDisplayOrientation() 去设置预览方向了

    二. 调整预览方向

    首先,在调整预览方向钱,我们需要先了解一些知识。

    • 屏幕坐标: Android 坐标系中,在 (0,0) 坐标那,向右为 x 轴,向下为 y 轴。
    • 自然方向: 设置的自然方向,比如手机默认就是竖直是自然方向,平板的话,横向就是自然方向
    • 图片传感器方向: 手机的图片数据都来自摄像头硬件传感器,这个传感器有个默认的方向,一般是手机是横向的,这就跟手机的自然方向成 90° 关系了。

    所以,我们要做的就是,就是把传感器拿到的图片,进行一个角度的变化,使图像能跟自然方向一致:
    图片来源

    在这里插入图片描述
    所以,我们的方向调整可以这样写:

        private void adjustCameraOrientation(Camera.CameraInfo info) {
            //判断当前的横竖屏
            int rotation = getWindowManager().getDefaultDisplay().getRotation();
    
            int degress = 0;
            //获取手机的方向
            switch (rotation) {
                case Surface.ROTATION_0:
                    degress = 0;
                    break;
                case Surface.ROTATION_90:
                    degress = 90;
                    break;
                case Surface.ROTATION_180:
                    degress = 180;
                    break;
                case Surface.ROTATION_270:
                    degress = 270;
                    break;
            }
            int result = 0;
            //后置摄像头
            if (info.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
                result = (info.orientation - degress + 360) % 360;
            } else if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
                //先镜像
                result = (info.orientation + degress) % 360;
                result = (360 - result) % 360;
            }
            mCamera.setDisplayOrientation(result);
    
        }
    

    最后再看一下:
    在这里插入图片描述

    三. 切换摄像头

    现在用到的都是后置摄像头,切换也比较简单,首先先释放相机支援,然后再从配置参数,预览再来一遍即可:

      //关闭摄像头
      closeCamera();
      
      mCameraID = mCameraID == mFrontCameraId ? mBackCameraId : mFrontCameraId;
      //打开相机
      openCamera(mCameraID);
      //开启预览
      startPreview(mSurfaceView.getWidth(), mSurfaceView.getHeight());
    
    #closeCamera
     private void closeCamera() {
         //停止预览
         mCamera.stopPreview();
         mCamera.release();
         mCamera = null;
     }
    

    四. 拍照及调整图片方向

    Camera 的拍照也比较简单,使用 takePicture(ShutterCallback shutter, PictureCallback raw, PictureCallback jpeg) 方法即可,它的三个参数如下:

    • ShutterCallback :拍照瞬间调用,如果空回调,则由声音,传 null ,则没效果
    • PictureCallback :图片的原始数据,即没处理过的
    • PictureCallback : 图片的 JPEG 数据

    拿到 byte 数据后,转换成bitmap即可,如下:

    Camera camera = mCamera;
    camera.takePicture(new Camera.ShutterCallback() {
        @Override
        public void onShutter() {
            
        }
    }, null, new Camera.PictureCallback() {
        @Override
        public void onPictureTaken(byte[] data, Camera camera) {
            new SavePicAsyncTask(data).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
        }
    });
    

    这里的图片保存,用一个 AsyncTask 来保存:

        /**
         * 保存图片
         */
        class SavePicAsyncTask extends AsyncTask<Void, Void, File> {
    
            byte[] data;
            File file;
    
            public SavePicAsyncTask(byte[] data) {
                this.data = data;
                File dir = new File(Constants.PATH);
                if (!dir.exists()) {
                    dir.mkdirs();
                }
                String name = "test.jpg";
                file = new File(dir, name);
            }
    
            @Override
            protected File doInBackground(Void... voids) {
                Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
                if (bitmap == null) {
                    return null;
                }
                FileOutputStream fos = null;
                try {
                    fos = new FileOutputStream(file);
                    //保存之前先调整方向
                    Camera.CameraInfo info = mCameraID == mFrontCameraId ? mFrontCameraInfo : mBackCameraInfo;
                    if (info.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
                        bitmap = BitmapUtils.rotate(bitmap, 90);
                    } else {
                        bitmap = BitmapUtils.rotate(bitmap, 270);
                    }
                    bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);
    
    
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } finally {
                    CloseUtils.close(fos);
                }
                return file;
            }
    
            @Override
            protected void onPostExecute(File file) {
                super.onPostExecute(file);
                if (file != null) {
                    Toast.makeText(Camera1Activity.this, "图片保存成功", Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(Camera1Activity.this, "图片保存失败", Toast.LENGTH_SHORT).show();
                }
            }
        }
    #BitmapUtils#rotate
    
        public static Bitmap rotate(Bitmap bitmap,float degress){
            Matrix matrix = new Matrix();
            matrix.postRotate(degress);
            return Bitmap.createBitmap(bitmap,0,0,bitmap.getWidth(),bitmap.getHeight(),matrix,true);
        }
    

    当拿到 byte[] 数据时,使用 BitmapFactory.decodeByteArray 解析 bitmap ,但此时的图片也是不对的,需要对它进行一个旋转,如上所示,这样,我们的拍照就也完成了。

    参考:
    https://developer.android.google.cn/reference/android/hardware/Camera?hl=en#takePicture(android.hardware.Camera.ShutterCallback,%20android.hardware.Camera.PictureCallback,%20android.hardware.Camera.PictureCallback,%20android.hardware.Camera.PictureCallback)

    https://www.jianshu.com/p/f8d0d1467584

    展开全文
  • 【Android Camera1】Android Camera1综述

    千次阅读 2021-12-20 21:01:03
    Camera1综述,介绍Camera1文章中最好,最值得收藏的干货
  • Android 摄像头Camera1、Camera2

    千次阅读 2021-11-02 09:29:41
    Camera1是以前的前后摄像头 Camera2是现在多摄像头的管理框架 摄像头在Android开发预览时,旋转好了角度,是surfaceview旋转了角度,摄像头保存数据时,并没有旋转,所以数据 里面,还是横着的,需要被旋转 ...
  • Android Camera1参数设置

    千次阅读 2018-11-24 12:46:16
    谷歌推荐开发者不使用Camera1 API,使用Camera2作为相机开发的接口。但是我在一些老的项目中遇到Camera1,且还需在其基础上进行扩展。  出于好奇心,且抱着一种学习的态度,我还是总结了一些Camera1的知识。  本文...
  • Camera1、Camera2 API的使用

    千次阅读 2019-09-05 15:28:22
    Camera1 使用流程: 检查相机权限(android.permission.CAMERA) Camera.getNumberOfCameras():获取相机硬件数量; Camera.getCameraInfo():获取指定相机信息; Camera.open():打开指定相机; camera.get...
  • android camera1 碰到的奇葩问题

    千次阅读 2022-01-13 08:55:38
    android camera1 碰到的奇葩问题 1. xiaomi 手机快门声音禁用 使用camera.enableShutterSound(false)或是使用反射将enableShutterSound设置为false,拍照时快门依然有声音,最后是调用camera.takePicture方法时,将...
  • Camera1 调用摄像机预览+获取每一帧

    千次阅读 2019-04-29 14:09:30
    使用camera1调试相机预览+获取每一帧数据, https://www.jianshu.com/p/3440d82545f6 https://www.jianshu.com/p/705d4792e836 主要学习代码,在这里 MainActivity public class MainActivity extends ...
  • API1的方法较少、命名规则等都比较简单,如果是针对目前市面上的手机,API1是足够而且使用起来非常方便,尤其是它的setParameter方法,相较于API2的要自己去填key和value来说,它不仅很容易能找到相机支持的(使用...
  • camera1 实时预览取帧

    千次阅读 2017-12-15 15:08:29
    安卓相机5.0以后加入了camera2类,但低版本还是用之前的camera1,所以直接选择camera1来开发! 直奔主题,在开发中遇到的坑! 1,安卓提供了camera.setPreviewCallbac这个回调写出这个回调后,在onPreviewFrame...
  • 以本文记录下学习sdm660 camera模块的总结: ... (一)目录 一. android camera系统架构图 ...(1)Bn Bp对象的理解 (2)回调函数的注册,监听 (3)aidl—ICameraService,hidl--ICameraDevice 三. takepic...
  • Camera API1和API2对比

    千次阅读 2019-05-06 16:26:26
    Android 5.0对拍照API进行了全新的设计,新增了全新设计的Camera v2 API,这些API不仅大幅提高了Android系统拍照的功能,还能...Camera api1调用流程比较直观,也利于理解一些,应用程序实例化camera这一个类就可以...
  • Camera2详解

    千次阅读 2021-04-08 21:06:23
    从Android 5.0开始,Google 引入了一套全新的相机框架 Camera2(android.hardware.camera2)并且废弃了旧的相机框架 Camera1(android.hardware.Camera) 不了解的同学,可能会有疑问,为啥要废弃Camera1接口?基本...
  • Camera2】Android Camera2 综述

    千次阅读 2021-12-25 14:52:17
    Camera2综述。 介绍Camera2文章里最好的文章和干货。
  • Android Camera简单整理(一)-Camera Android架构(基于Q)

    万次阅读 多人点赞 2020-04-12 19:39:23
    一.Android Camera架构简述 先盗用谷歌的一张图,该图表示的即是Camera Hal之上的App层,framework层组件结构
  • camera 3A 算法

    2018-07-27 12:54:55
    camera 3Acamera 3Acamera 3Acamera 3Acamera 3Acamera 3A
  • 需求:最近在做一个 Camera 相关的项目,最简单粗暴的一个目的就是使用 C++ 开发。也就是说,作为 System/Framework 层,我们需要把 Android 的 Camera 系统封装出一套 C++ 接口,以供 SDK/Application 调用,使得 ...
  • 1 camera基本代码架构 高通平台对于camera的代码组织,大体上还是遵循Android的框架:即上层应用和HAL层交互,高通平台在HAL层里面实现自己的一套管理策略;在kernel中实现sensor的底层驱动。但是,对于最核心的...
  • 深入理解Android Camera

    千次阅读 2022-03-31 19:03:44
    文章目录深入理解Android Camera前言一、Camera框架1. 架构(旧版)1.1 简介1.2 底层用HAL V11.3 底层用HAL V3二、API和Hal特殊组合1. API1 + HAL32. API2 + HAL 1)总结 前言 提示:这里可以添加本文要记录的大概...
  • Camera(7) MTK camera打开流程介绍

    千次阅读 2020-05-22 00:16:08
    文章目录一、整体介绍1、MiddleWare(MW)层介绍2、Pipeline介绍二、Camera Open流程 一、整体介绍 首先看下MTKcam的整体框架图如下包含了很多的内容,其中camera的打开流程也贯穿在其中,从Camera APK 一层层的系统...
  • android camera hal3 新增vendor tag

    千次阅读 热门讨论 2020-09-07 15:55:24
    在实际使用的过程中,遇到了一个问题——客户app在用camera api接口调用usbcamera或virtual camera时,希望能够知道当前调用的是系统本身的mipi摄像头,还是usbcamera或virtualcamera。也就是说,客户想知道,我当前...
  • Camera2 openCamera 流程分析

    千次阅读 2022-04-01 09:47:58
    文章目录一、相机架构二、应用框架1.Camera APP2.AIDL3.原生框架4.binder IPC 接口5.相机服务6.HAL三、流程分析1.openCamera 一、相机架构 (详细资料参见:https://source.android.google.cn/devices/camera) 二...
  • Android Camera HAL3 - Multi Camera(1)

    千次阅读 2020-06-14 13:58:27
    本文介绍下 Google Android 在其文档中对于 Multi-Camera 的描述,以及 Android R 中对 Camera HAL3 的一些新增内容,Multi-Camera 从 Android 9 也就是 P 开始就已经有相关的支持描述了,只不过还是比较简单的要求...
  • camera api2打开摄像头的时序图
  • Android Camera AE和AF的设置

    千次阅读 2021-11-18 09:27:04
    ae mode = 1,代表ae为off模式,flash state = 2,代表flash处于 ready状态,表示没有打闪。 当闪光灯设置为auto时,是通过设置ae mode 控制的。flash mode = 0,代表flash为off模式; ae mode = 2,代表ae为on模式,...
  • PlayCamera_V1.0.0(SurfaceView预览Camera,拍照demo)

    千次下载 热门讨论 2014-06-23 19:26:18
    SurfaceView预览Camera,拍照demo),详见博客:http://blog.csdn.net/yanzi1225627/article/details/33028041
  • Camera客观测试标准

    2019-02-01 10:31:55
    camera客观测试标准,包含各项测试指标和测试方法(MTF、Lens shading、SNR、AWB、Step等)
  • Android Camera旋转角度总结

    万次阅读 2019-08-18 23:56:53
    开发过Android自定义相机的朋友们估计都被相机的各种乱七八糟的旋转角度适配坑过,本文将对Camera的各种角度进行解析。 一、适配目标 根据相机旋转角度以及屏幕显示旋转角度选择相机预览数据显示到View上的预览数据...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 266,309
精华内容 106,523
关键字:

Camera1