Camera2 TextureView

深藏阁楼爱情的钟 2023-05-22 06:34 19阅读 0赞

MSCameraTextureViewManager.java

import android.Manifest;
    import android.app.Activity;
    import android.content.Context;
    import android.content.pm.PackageManager;
    import android.content.res.Configuration;
    import android.graphics.ImageFormat;
    import android.graphics.Matrix;
    import android.graphics.RectF;
    import android.graphics.SurfaceTexture;
    import android.hardware.camera2.CameraAccessException;
    import android.hardware.camera2.CameraCaptureSession;
    import android.hardware.camera2.CameraCharacteristics;
    import android.hardware.camera2.CameraDevice;
    import android.hardware.camera2.CameraManager;
    import android.hardware.camera2.CaptureRequest;
    import android.hardware.camera2.CaptureResult;
    import android.hardware.camera2.TotalCaptureResult;
    import android.hardware.camera2.params.MeteringRectangle;
    import android.hardware.camera2.params.StreamConfigurationMap;
    import android.media.Image;
    import android.media.ImageReader;
    import android.os.Environment;
    import android.support.annotation.NonNull;
    import android.support.v4.app.ActivityCompat;
    import android.util.Log;
    import android.util.Size;
    import android.view.Surface;
    import android.view.TextureView;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.ByteBuffer;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    public class MSCameraTextureViewManager { 
        private Size mPreviewSize;
        private AutoFitTextureView mAutoFitTextureView;
        private Activity mContext;
        public final static String CAMERA_FRONT = "1";
        public final static String CAMERA_BACK = "0";
        private String mCameraId = "0";
        private boolean mIsFaceAi;
        private CameraDevice mCameraDevice;
        private static final String TAG = "FaceCameraManager";
        private static final String TAG_PREVIEW = "预览";
        private CaptureRequest mPreviewRequest;
        private Surface mPreviewSurface;
        private CaptureRequest.Builder mPreviewRequestBuilder;
        private ImageReader mImageReader;
        private CameraCaptureSession mCaptureSession;
    
        //类初始化时，不初始化这个对象(延时加载，真正用的时候再创建)
        private static MSCameraTextureViewManager instance;
    
        //构造器私有化
        private MSCameraTextureViewManager() { 
        }
    
        //方法同步，调用效率低
        public static synchronized MSCameraTextureViewManager getInstance() { 
            if (instance == null) { 
                instance = new MSCameraTextureViewManager();
            }
            return instance;
        }
    
    
        public void initCamera(Activity context, AutoFitTextureView autoFitTextureView, boolean isFaceAi) { 
            this.mAutoFitTextureView = autoFitTextureView;
            this.mContext = context;
            this.mIsFaceAi = isFaceAi;
            if (isFaceAi) { 
                mCameraId = CAMERA_FRONT;
            } else { 
                mCameraId = CAMERA_BACK;
            }
            setListener();
        }
    
        private void setListener() { 
            mAutoFitTextureView.setSurfaceTextureListener(textureListener);
    
        }
    
        public void closeCamera() { 
            if (null != mCaptureSession) { 
                mCaptureSession.close();
                mCaptureSession = null;
            }
            if (null != mCameraDevice) { 
                mCameraDevice.close();
                mCameraDevice = null;
            }
            if (null != mImageReader) { 
                mImageReader.close();
                mImageReader = null;
            }
        }
    
        public void switchCamera() { 
            if (mCameraId.equals(CAMERA_FRONT)) { 
                mCameraId = CAMERA_BACK;
                closeCamera();
                reopenCamera();
    
            } else if (mCameraId.equals(CAMERA_BACK)) { 
                mCameraId = CAMERA_FRONT;
                closeCamera();
                reopenCamera();
            }
        }
    
        public void reopenCamera() { 
            if (mAutoFitTextureView.isAvailable()) { 
                openCamera();
            } else { 
                mAutoFitTextureView.setSurfaceTextureListener(textureListener);
            }
        }
    
        // Surface状态回调
        TextureView.SurfaceTextureListener textureListener = new TextureView.SurfaceTextureListener() { 
            @Override
            public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) { 
                setupCamera(width, height);
                configureTransform(width, height);
                openCamera();
            }
    
            @Override
            public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) { 
                configureTransform(width, height);
            }
    
            @Override
            public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) { 
                return false;
            }
    
            @Override
            public void onSurfaceTextureUpdated(SurfaceTexture surface) { 
    
            }
        };
    
        private void openCamera() { 
            //获取摄像头的管理者CameraManager
            CameraManager manager = (CameraManager) mContext.getSystemService(Context.CAMERA_SERVICE);
            //检查权限
            try { 
                if (ActivityCompat.checkSelfPermission(mContext, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) { 
                    return;
                }
                //打开相机，第一个参数指示打开哪个摄像头，第二个参数stateCallback为相机的状态回调接口，第三个参数用来确定Callback在哪个线程执行，为null的话就在当前线程执行
                manager.openCamera(mCameraId, stateCallback, null);
            } catch (CameraAccessException e) { 
                e.printStackTrace();
            }
        }
    
        private void configureTransform(int viewWidth, int viewHeight) { 
            if (null == mAutoFitTextureView || null == mPreviewSize) { 
                return;
            }
            int rotation = mContext.getWindowManager().getDefaultDisplay().getRotation();
            Matrix matrix = new Matrix();
            RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
            RectF bufferRect = new RectF(0, 0, mPreviewSize.getHeight(), mPreviewSize.getWidth());
            float centerX = viewRect.centerX();
            float centerY = viewRect.centerY();
            if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) { 
                bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
                matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
                float scale = Math.max(
                        (float) viewHeight / mPreviewSize.getHeight(),
                        (float) viewWidth / mPreviewSize.getWidth());
                matrix.postScale(scale, scale, centerX, centerY);
                matrix.postRotate(90 * (rotation - 2), centerX, centerY);
            } else if (Surface.ROTATION_180 == rotation) { 
                matrix.postRotate(180, centerX, centerY);
            }
            mAutoFitTextureView.setTransform(matrix);
        }
    
        // 摄像头状态回调
        private final CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() { 
            @Override
            public void onOpened(CameraDevice camera) { 
                mCameraDevice = camera;
                //开启预览
                startPreview();
            }
    
    
            @Override
            public void onDisconnected(@NonNull CameraDevice camera) { 
                Log.i(TAG, "CameraDevice Disconnected");
            }
    
            @Override
            public void onError(@NonNull CameraDevice camera, int error) { 
                Log.e(TAG, "CameraDevice Error");
            }
        };
    
        private void startPreview() { 
            setupImageReader();
            SurfaceTexture mSurfaceTexture = mAutoFitTextureView.getSurfaceTexture();
            //设置TextureView的缓冲区大小
            mSurfaceTexture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
            //获取Surface显示预览数据
            mPreviewSurface = new Surface(mSurfaceTexture);
            try { 
                getPreviewRequestBuilder();
                //创建相机捕获会话，第一个参数是捕获数据的输出Surface列表，第二个参数是CameraCaptureSession的状态回调接口，当它创建好后会回调onConfigured方法，第三个参数用来确定Callback在哪个线程执行，为null的话就在当前线程执行
                mCameraDevice.createCaptureSession(Arrays.asList(mPreviewSurface, mImageReader.getSurface()), new CameraCaptureSession.StateCallback() { 
                    @Override
                    public void onConfigured(CameraCaptureSession session) { 
                        mCaptureSession = session;
                        repeatPreview();
                    }
    
                    @Override
                    public void onConfigureFailed(CameraCaptureSession session) { 
    
                    }
                }, null);
            } catch (CameraAccessException e) { 
                e.printStackTrace();
            }
        }
    
        private void setupImageReader() { 
            //前三个参数分别是需要的尺寸和格式，最后一个参数代表每次最多获取几帧数据
            mImageReader = ImageReader.newInstance(mPreviewSize.getWidth(), mPreviewSize.getHeight(), ImageFormat.JPEG, 1);
            //监听ImageReader的事件，当有图像流数据可用时会回调onImageAvailable方法，它的参数就是预览帧数据，可以对这帧数据进行处理
            mImageReader.setOnImageAvailableListener(new ImageReader.OnImageAvailableListener() { 
                @Override
                public void onImageAvailable(ImageReader reader) { 
                    Log.i(TAG, "Image Available!");
                    Image image = reader.acquireLatestImage();
                    // 开启线程异步保存图片
                    new Thread(new ImageSaver(image)).start();
                }
            }, null);
        }
    
        private void repeatPreview() { 
            mPreviewRequestBuilder.setTag(TAG_PREVIEW);
            mPreviewRequest = mPreviewRequestBuilder.build();
            //设置反复捕获数据的请求，这样预览界面就会一直有数据显示
            try { 
                mCaptureSession.setRepeatingRequest(mPreviewRequest, mPreviewCaptureCallback, null);
            } catch (CameraAccessException e) { 
                e.printStackTrace();
            }
        }
    
        private CameraCaptureSession.CaptureCallback mPreviewCaptureCallback = new CameraCaptureSession.CaptureCallback() { 
            @Override
            public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) { 
    
            }
    
            @Override
            public void onCaptureProgressed(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull CaptureResult partialResult) { 
    
            }
        };
    
    
        // 创建预览请求的Builder（TEMPLATE_PREVIEW表示预览请求）
        private void getPreviewRequestBuilder() { 
            try { 
                mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            } catch (CameraAccessException e) { 
                e.printStackTrace();
            }
            //设置预览的显示界面
            mPreviewRequestBuilder.addTarget(mPreviewSurface);
            MeteringRectangle[] meteringRectangles = mPreviewRequestBuilder.get(CaptureRequest.CONTROL_AF_REGIONS);
            if (meteringRectangles != null && meteringRectangles.length > 0) { 
                Log.d(TAG, "PreviewRequestBuilder: AF_REGIONS=" + meteringRectangles[0].getRect().toString());
            }
            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_MODE, CaptureRequest.CONTROL_MODE_AUTO);
            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CaptureRequest.CONTROL_AF_TRIGGER_IDLE);
        }
    
    
        private void setupCamera(int width, int height) { 
            // 获取摄像头的管理者CameraManager
            CameraManager manager = (CameraManager) mContext.getSystemService(Context.CAMERA_SERVICE);
            try { 
                String[] cameraIdList = manager.getCameraIdList();
                if (cameraIdList == null || cameraIdList.length == 0) return;
                CameraCharacteristics characteristics = manager.getCameraCharacteristics(mCameraId);
                StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
                mPreviewSize = getOptimalSize(map.getOutputSizes(SurfaceTexture.class), width, height);
                int orientation = mContext.getResources().getConfiguration().orientation;
                if (orientation == Configuration.ORIENTATION_LANDSCAPE) { 
                    mAutoFitTextureView.setAspectRatio(mPreviewSize.getWidth(), mPreviewSize.getHeight());
                } else { 
                    mAutoFitTextureView.setAspectRatio(mPreviewSize.getHeight(), mPreviewSize.getWidth());
                }
            } catch (CameraAccessException e) { 
                e.printStackTrace();
            }
        }
    
        // 选择sizeMap中大于并且最接近width和height的size
        private Size getOptimalSize(Size[] sizeMap, int width, int height) { 
            List<Size> sizeList = new ArrayList<>();
            for (Size option : sizeMap) { 
                if (width > height) { 
                    if (option.getWidth() > width && option.getHeight() > height) { 
                        sizeList.add(option);
                    }
                } else { 
                    if (option.getWidth() > height && option.getHeight() > width) { 
                        sizeList.add(option);
                    }
                }
            }
            if (sizeList.size() > 0) { 
                return Collections.min(sizeList, new Comparator<Size>() { 
                    @Override
                    public int compare(Size lhs, Size rhs) { 
                        return Long.signum(lhs.getWidth() * lhs.getHeight() - rhs.getWidth() * rhs.getHeight());
                    }
                });
            }
            return sizeMap[0];
        }
    
        public static class ImageSaver implements Runnable { 
            private Image mImage;
    
            public ImageSaver(Image image) { 
                mImage = image;
            }
    
            @Override
            public void run() { 
                ByteBuffer buffer = mImage.getPlanes()[0].getBuffer();
                byte[] data = new byte[buffer.remaining()];
                buffer.get(data);
                File imageFile = new File(Environment.getExternalStorageDirectory() + "/DCIM/myPicture.jpg");
                FileOutputStream fos = null;
                try { 
                    fos = new FileOutputStream(imageFile);
                    fos.write(data, 0, data.length);
                } catch (IOException e) { 
                    e.printStackTrace();
                } finally { 
                    if (fos != null) { 
                        try { 
                            fos.close();
                        } catch (IOException e) { 
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    
    
    }

AutoFitTextureView.java

import android.content.Context;
    import android.util.AttributeSet;
    import android.view.TextureView;
    
    public class AutoFitTextureView extends TextureView { 
    
        private int mRatioWidth = 0;
        private int mRatioHeight = 0;
    
        public AutoFitTextureView(Context context) { 
            this(context, null);
        }
    
        public AutoFitTextureView(Context context, AttributeSet attrs) { 
            this(context, attrs, 0);
        }
    
        public AutoFitTextureView(Context context, AttributeSet attrs, int defStyle) { 
            super(context, attrs, defStyle);
        }
    
        /** * Sets the aspect ratio for this view. The size of the view will be measured based on the ratio * calculated from the parameters. Note that the actual sizes of parameters don't matter, that * is, calling setAspectRatio(2, 3) and setAspectRatio(4, 6) make the same result. * * @param width Relative horizontal size * @param height Relative vertical size */
        public void setAspectRatio(int width, int height) { 
            if (width < 0 || height < 0) { 
                throw new IllegalArgumentException("Size cannot be negative.");
            }
            mRatioWidth = width;
            mRatioHeight = height;
            requestLayout();
        }
    
        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            int width = MeasureSpec.getSize(widthMeasureSpec);
            int height = MeasureSpec.getSize(heightMeasureSpec);
            if (0 == mRatioWidth || 0 == mRatioHeight) { 
                setMeasuredDimension(width, height);
            } else { 
                if (width < height * mRatioWidth / mRatioHeight) { 
                    setMeasuredDimension(width, width * mRatioHeight / mRatioWidth);
                } else { 
                    setMeasuredDimension(height * mRatioWidth / mRatioHeight, height);
                }
            }
        }
    
    }