camera2 demo

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "ssss";

    private Context mContext;
    private HandlerThread mHandlerThread;
    private Handler mHandler;

    private CameraManager mCameraManager;
    private CameraDevice mCameraDevice;
    private String mCameraId;
    private CameraCaptureSession mCameraCaptureSession;

    private ImageReader mImageReader;
    private SurfaceHolder mSurfaceHolder;
    private SurfaceView mSurface;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getSupportActionBar().hide();
        mContext = this;

        mHandlerThread = new HandlerThread(TAG);
        mHandlerThread.start();
        mHandler = new Handler(mHandlerThread.getLooper(), new Handler.Callback() {
            @Override
            public boolean handleMessage(Message msg) {
                Log.d(TAG, "handleMessage()..." + msg);
                return false;
            }
        });

        mImageReader = ImageReader.newInstance(1280, 720, ImageFormat.YUV_420_888, 3);
        mImageReader.setOnImageAvailableListener(mImageAvailableListener, mHandler);

        mSurface = findViewById(R.id.surface_unlock);
        ViewGroup.LayoutParams lp = mSurface.getLayoutParams();
        lp.height = 720;
        lp.width = 1280;
        mSurface.setLayoutParams(lp);
        SurfaceHolder surfaceHolder = mSurface.getHolder();
        surfaceHolder.setKeepScreenOn(true);
        surfaceHolder.addCallback(new SurfaceHolder.Callback() {
            @Override
            public void surfaceCreated(SurfaceHolder holder) {
                Log.d(TAG, "surfaceCreated()...holder:" + holder);
                mSurfaceHolder = holder;
                initcamera();
            }

            @Override
            public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
                Log.d(TAG, "surfaceChanged()..."+width+" "+height);
            }

            @Override
            public void surfaceDestroyed(SurfaceHolder holder) {
                Log.d(TAG, "surfaceDestroyed()...");
            }
        });
    }

    void initcamera() {
        Log.d(TAG, "initcamera()...");
         mCameraManager = (CameraManager) mContext.getSystemService(Activity.CAMERA_SERVICE);
        if (!checkNotNull(mCameraManager)) {
            Log.d(TAG, "mCameraManager is null...");
            return;
        }

        mCameraId = selectBackOrFrontCamera();
        if (!checkNotNull(mCameraId)) {
            Log.e(TAG, "Camera id is invalid, return!");
        return;
        }

        Log.e(TAG, "mCameraId:"+mCameraId);

        try {
            mCameraManager.openCamera(mCameraId, mCameraStateCallback, mHandler);
        } catch (CameraAccessException e) {
            Log.e(TAG, "Failed to open Camera");
            e.printStackTrace();
        } catch (SecurityException e) {
            Log.e(TAG, "Failed to open Camera");
            e.printStackTrace();
        }
    }

    private ImageReader.OnImageAvailableListener mImageAvailableListener = new ImageReader.OnImageAvailableListener() {
        @Override
        public void onImageAvailable(ImageReader reader) {
            Image image = reader.acquireNextImage();
            byte[] yuvData = new byte[image.getHeight() * image.getWidth() * 3 / 2];;

            image.close();
        }
    };

    private void handleStartPreview() {
        Log.d(TAG, "handleStartPreview()...");
        if (!checkNotNull(mCameraDevice)) {
            Log.e(TAG, "Invalid Camera device");
            return;
        }

        List<Surface> surfaces = new ArrayList<>();
        surfaces.add(mImageReader.getSurface());
        surfaces.add(mSurfaceHolder.getSurface());

        try {
            final CaptureRequest.Builder builder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            builder.addTarget(mImageReader.getSurface());
            builder.addTarget(mSurfaceHolder.getSurface());

            mCameraDevice.createCaptureSession(surfaces, new CameraCaptureSession.StateCallback() {
                @Override
                public void onConfigured(@NonNull CameraCaptureSession session) {
                    if (!checkNotNull(mCameraDevice)) {
                        return;
                    }
                    try {
                        builder.set(CaptureRequest.CONTROL_AF_MODE,
                                CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);

                        mCameraCaptureSession = session;

                        session.setRepeatingRequest(builder.build(),null, mHandler);
                    } catch (CameraAccessException e) {
                        e.printStackTrace();
                    }
                }

                @Override
                public void onConfigureFailed(@NonNull CameraCaptureSession session) {
                    Log.e(TAG, "on configure failed");
                }
            }, mHandler);

        } catch (Exception e) {
            e.printStackTrace();
            Log.e(TAG, "Failed to start preview!");
        }
    }

    private boolean checkNotNull(Object object) {
        return (null != object);
    }

    private String selectBackOrFrontCamera() {
        Log.d(TAG, "selectBackOrFrontCamera()...");
        String cameraId = null;
        try {
            String[] idList = mCameraManager.getCameraIdList();
            for (String id : idList) {
                CameraCharacteristics characteristics = mCameraManager.getCameraCharacteristics(id);

                Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
                if (facing != null) {
                    if (CameraCharacteristics.LENS_FACING_BACK == facing) {
                        cameraId = id;
                    }
                }
                Log.d(TAG, "Camera Id:" + cameraId);
            }
        } catch (CameraAccessException e) {
            Log.e(TAG, "Invalid Camera Id");
        }
        return cameraId;
    }

    private final CameraDevice.StateCallback mCameraStateCallback = new CameraDevice.StateCallback() {
        @Override
        public void onOpened(@NonNull CameraDevice cameraDevice) {
            Log.d(TAG, "onOpened()...");
            mCameraDevice = cameraDevice;
            handleStartPreview();
        }

        @Override
        public void onDisconnected(@NonNull CameraDevice cameraDevice) {
            Log.d(TAG, "onDisconnected()...");
            mCameraDevice.close();
            mCameraDevice = null;
        }

        @Override
        public void onError(@NonNull CameraDevice cameraDevice, int errorCode) {
            Log.d(TAG, "onError()...code:" + errorCode);
            mCameraDevice.close();
            mCameraDevice = null;
        }
    };

}