使用 Android Jetpack CameraX 库，需要在 AndroidManifest.xml 配置如下的权限

```

uses-feature android:name="android.hardware.camera.any"

uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"

uses-permission android:name="android.permission.CAMERA"

uses-permission android:name="android.permission.RECORD_AUDIO"

uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"

```

<uses-feature android:name="android.hardware.camera.any" />

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

<uses-permission android:name="android.permission.CAMERA" />

<uses-permission android:name="android.permission.RECORD_AUDIO" />

<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

if (PermissionUtil.allPermissionsGranted(this)) {

CLog.i(TAG,"All permissions granted");

}else {

ActivityCompat.requestPermissions(this,PermissionUtil.PERMISSION_GROUP,PERMISSION_REQUEST_CODE);

}

public static final String[]PERMISSION_GROUP = {

Manifest.permission.ACCESS_COARSE_LOCATION,

Manifest.permission.WRITE_EXTERNAL_STORAGE,

Manifest.permission.CAMERA,

Manifest.permission.RECORD_AUDIO,

};

public static boolean allPermissionsGranted(Context context) {

if (Build.VERSION.SDK_INT >=Build.VERSION_CODES.M) {

CLog.i(TAG,"API level above M need request permission");

ListunGrantedList =new ArrayList<>();

for (String permission :PERMISSION_GROUP) {

int permissionResult =ContextCompat.checkSelfPermission(context,permission);

if (permissionResult !=PackageManager.PERMISSION_GRANTED) {

CLog.i(TAG,permission +" need grant");

unGrantedList.add(permission);

}

}

return unGrantedList.size() ==0;

}else {

return true;

}

}

@Override

public void onRequestPermissionsResult(int requestCode,@NonNull String[] permissions,@NonNull int[] grantResults) {

super.onRequestPermissionsResult(requestCode, permissions, grantResults);

CLog.i(TAG,"onRequestPermissionsResult");

int index =0;

ListrequestList =new ArrayList<>();// 允许询问列表，再次申请

    ListbannedList =new ArrayList<>();// 禁止列表

    for (String permission : permissions) {

int grantResult = grantResults[index];

if (grantResult ==PackageManager.PERMISSION_GRANTED) {

CLog.i(TAG,"onRequestPermissionsResult, " +permission +" granted success");

}else {

// 查询是否允许重新申请该权限

            boolean rationalResult =ActivityCompat.shouldShowRequestPermissionRationale(this,permission);

CLog.i(TAG,"shouldShowRequestPermissionRationale " +rationalResult);

if (rationalResult) {// 允许重新申请

                requestList.add(permission);

}else {// 禁止重新申请

                bannedList.add(permission);

}

}

if (bannedList.size() >0) {// 优先对禁止列表进行判断

            // 告知该权限作用，需要手动授予

            showFinishedDialog();

}else if (requestList.size() >0) {

// 告知权限作用，并重新申请

            showTipDialog(requestList);

}else {

// 授权成功

            Toast.makeText(this,"授权成功",Toast.LENGTH_LONG).show();

}

index++;

}

}

private void showFinishedDialog() {

AlertDialog dialog =new AlertDialog.Builder(this)

.setTitle("警告")

.setMessage("请前往设置中打开相关权限，否则功能无法正常运行！")

.setPositiveButton("确定", (dialog1, which) -> {

// 一般情况下如果用户不授权的话，功能是无法运行的，做退出处理

            finish();

})

.create();

dialog.show();

}

public void showTipDialog(List pmList){

AlertDialog dialog =new AlertDialog.Builder(this)

.setTitle("提示")

.setMessage("【"+pmList.toString()+"】权限为应用必要权限，请授权")

.setPositiveButton("确定",new DialogInterface.OnClickListener() {

@Override

            public void onClick(DialogInterface dialog,int which) {

String[]sList=pmList.toArray(new String[0]);

//重新申请该权限

                ActivityCompat.requestPermissions(MainActivity.this,sList,10000);

}

})

.create();

dialog.show();

}

------------------------------------------------------动态申请权限------------------------------------------------------

------------------------------------------------------使用 CameraX 预览进行图片分析，存为文件------------------------------------------------------

<?xml version="1.0" encoding="utf-8"?>

    xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:app="http://schemas.android.com/apk/res-auto"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    tools:context=".MainActivity">

        android:id="@+id/viewFinder"

        android:layout_width="match_parent"

        android:layout_height="match_parent" />

        android:id="@+id/image_capture_button"

        android:layout_width="110dp"

        android:layout_height="110dp"

        android:layout_marginBottom="50dp"

        android:layout_marginEnd="50dp"

        android:elevation="2dp"

        android:text="@string/take_photo"

        app:layout_constraintBottom_toBottomOf="parent"

        app:layout_constraintLeft_toLeftOf="parent"

        app:layout_constraintEnd_toStartOf="@id/vertical_centerline" />

        android:id="@+id/video_capture_button"

        android:layout_width="110dp"

        android:layout_height="110dp"

        android:layout_marginBottom="50dp"

        android:layout_marginStart="50dp"

        android:elevation="2dp"

        android:text="@string/start_capture"

        app:layout_constraintBottom_toBottomOf="parent"

        app:layout_constraintStart_toEndOf="@id/vertical_centerline" />

        android:id="@+id/vertical_centerline"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:orientation="vertical"

        app:layout_constraintGuide_percent=".50" />

package com.self.program.coreserviceapplication;

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.os.Build;

import android.os.Bundle;

import android.os.Environment;

import android.os.Handler;

import android.os.HandlerThread;

import android.os.Looper;

import android.os.Message;

import android.util.Log;

import android.util.Size;

import android.view.Surface;

import android.view.WindowManager;

import androidx.annotation.NonNull;

import androidx.annotation.Nullable;

import androidx.annotation.RequiresApi;

import androidx.appcompat.app.AppCompatActivity;

import androidx.camera.core.AspectRatio;

import androidx.camera.core.Camera;

import androidx.camera.core.CameraInfo;

import androidx.camera.core.CameraSelector;

import androidx.camera.core.CameraState;

import androidx.camera.core.ImageAnalysis;

import androidx.camera.core.ImageProxy;

import androidx.camera.core.Preview;

import androidx.camera.lifecycle.ProcessCameraProvider;

import androidx.camera.view.PreviewView;

import androidx.core.content.ContextCompat;

import androidx.lifecycle.Observer;

import com.google.common.util.concurrent.ListenableFuture;

import com.self.program.coreserviceapplication.utils.CLog;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.nio.ByteBuffer;

import java.util.UUID;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class CameraXActivity extends AppCompatActivity {

private static final String TAG ="CameraXActivity";

private static final String SD_CARD_PATH =Environment.getExternalStorageDirectory().getAbsolutePath();

private static final String RELATIVE_PATH ="/identity/pic";

private PreviewView mPreviewView;

ListenableFuturemCameraProviderFuture;

private ExecutorService mCameraExecutor;

private WindowManager mWindowManager;

private long mLastCaptureTime =0;

private static final int CAPTURE_INTERVAL =3000;

private HandlerThread mHandlerThread;

private Handler mPreviewHandler;

@Override

    protected void onCreate(@Nullable Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

CLog.i(TAG,"onCreate");

setContentView(R.layout.camerax_layout);

mWindowManager = getWindowManager();

mHandlerThread =new HandlerThread("PreviewImageCapture");

mHandlerThread.start();

mPreviewHandler =new Handler(mHandlerThread.getLooper());

mPreviewView = findViewById(R.id.viewFinder);

mCameraExecutor =Executors.newSingleThreadExecutor();

startCamera();

}

@Override

    protected void onDestroy() {

super.onDestroy();

mCameraExecutor.shutdown();

}

private void startCamera() {

mCameraProviderFuture =ProcessCameraProvider.getInstance(this);

mCameraProviderFuture.addListener(() -> {

try {

ProcessCameraProvider cameraProvider =mCameraProviderFuture.get();

if (Build.VERSION.SDK_INT >=Build.VERSION_CODES.R) {

Rect metrics =mWindowManager.getCurrentWindowMetrics().getBounds();

CLog.i(TAG,"startCamera1 screen metrics : " +metrics.width() +"x" +metrics.height());

}

Preview preview =new Preview.Builder()

//                        .setTargetAspectRatio(aspectRatio2)

//                        .setTargetRotation(Surface.ROTATION_90)

//                        .setTargetResolution(new Size(720, 1280))

                        .build();

//                ImageCapture imageCapture = new ImageCapture.Builder().build();

                CameraSelector cameraSelector =CameraSelector.DEFAULT_BACK_CAMERA;

ImageAnalysis imageAnalysis =new ImageAnalysis.Builder()

.setTargetResolution(new Size(1080,1920))

.setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)

.build();

imageAnalysis.setAnalyzer(mCameraExecutor, imageProxy -> {

long currentTime =System.currentTimeMillis();

if (currentTime -mLastCaptureTime >CAPTURE_INTERVAL) {

CLog.i(TAG,"imageProxy call : " + imageProxy);

int degree = imageProxy.getImageInfo().getRotationDegrees();

CLog.i(TAG,"imageProxy degree : " +degree);

ImageProxy.PlaneProxy[]planes = imageProxy.getPlanes();

CLog.i(TAG,"imageProxy planes : " +planes.length);

//cameraX 获取yuv

                        ByteBuffer yBuffer =planes[0].getBuffer();

ByteBuffer uBuffer =planes[1].getBuffer();

ByteBuffer vBuffer =planes[2].getBuffer();

int ySize =yBuffer.remaining();

int uSize =uBuffer.remaining();

int vSize =vBuffer.remaining();

byte[]nv21 =new byte[ySize +uSize +vSize];

yBuffer.get(nv21,0,ySize);

vBuffer.get(nv21,ySize,vSize);

uBuffer.get(nv21,ySize +vSize,uSize);

// 开始时间

                        long START =System.currentTimeMillis();

// 获取yuvImage

                        YuvImage yuvImage =new YuvImage(nv21,ImageFormat.NV21, imageProxy.getWidth(), imageProxy.getHeight(),null);

// 输出流

                        ByteArrayOutputStream out =new ByteArrayOutputStream();

// 压缩写⼊out

                        yuvImage.compressToJpeg(new Rect(0,0,yuvImage.getWidth(),yuvImage.getHeight()),50,out);

// 转数组

                        byte[]imageBytes =out.toByteArray();

// 生成bitmap

                        Bitmap bitmap =BitmapFactory.decodeByteArray(imageBytes,0,imageBytes.length);

CLog.i(TAG,"imageProxy bitmap : " +bitmap);

Bitmap rotateBitmap = rotateBitmap(bitmap,90);

CLog.i(TAG,"imageProxy rotateBitmap : " +rotateBitmap);

mPreviewHandler.post(() -> {

CLog.i(TAG,"save rotateBitmap : " +rotateBitmap);

saveBitmapToFile(rotateBitmap);

});

mLastCaptureTime =currentTime;

}

imageProxy.close();

});

cameraProvider.unbindAll();

Camera camera =cameraProvider.bindToLifecycle(this,

cameraSelector,

imageAnalysis,

preview);

preview.setSurfaceProvider(mPreviewView.getSurfaceProvider());

observeCameraState(camera.getCameraInfo());

}catch (Exception e) {

CLog.e(TAG,"startCamera " +Log.getStackTraceString(e));

}

},ContextCompat.getMainExecutor(this));

}

private void saveBitmapToFile(Bitmap rotateBitmap) {

//

        String savePath =SD_CARD_PATH +RELATIVE_PATH;

CLog.i(TAG,"saveBitmapToFile savePath : " +savePath);

File picFile;

try {

picFile =new File(savePath + generateFileName());

if (!picFile.exists()) {

picFile.getParentFile().mkdirs();

picFile.createNewFile();

}

FileOutputStream fileOutputStream =new FileOutputStream(picFile);

rotateBitmap.compress(Bitmap.CompressFormat.JPEG,100,fileOutputStream);

fileOutputStream.flush();

fileOutputStream.close();

}catch (Exception e) {

CLog.e(TAG,"saveBitmapToFile : " +Log.getStackTraceString(e));

}

}

private String generateFileName() {

return UUID.randomUUID().toString() +".jpg";

}

private Bitmap rotateBitmap(Bitmap origin,float alpha) {

if (origin ==null) {

return null;

}

int width = origin.getWidth();

int height = origin.getHeight();

Matrix matrix =new Matrix();

matrix.setRotate(alpha);

Bitmap newBitmap =Bitmap.createBitmap(origin,0,0,width,height,matrix,false);

if (newBitmap.equals(origin)) {

return newBitmap;

}

origin.recycle();

return newBitmap;

}

private void observeCameraState(CameraInfo cameraInfo) {

cameraInfo.getCameraState().observe(this, cameraState -> {

CLog.i(TAG,"observeCameraState cameraState : " + cameraState);

CameraState.Type stateType = cameraState.getType();

if (stateType ==CameraState.Type.PENDING_OPEN) {

CLog.i(TAG,"observeCameraState cameraState PENDING_OPEN");

}else if (stateType ==CameraState.Type.OPENING) {

CLog.i(TAG,"observeCameraState cameraState OPENING");

}else if (stateType ==CameraState.Type.OPEN) {

CLog.i(TAG,"observeCameraState cameraState OPEN");

}else if (stateType ==CameraState.Type.CLOSING) {

CLog.i(TAG,"observeCameraState cameraState CLOSING");

}else if (stateType ==CameraState.Type.CLOSED) {

CLog.i(TAG,"observeCameraState cameraState CLOSED");

}

CameraState.StateError stateError = cameraState.getError();

CLog.i(TAG,"observeCameraState stateError : " +stateError);

});

}

------------------------------------------------------使用 CameraX 预览进行图片分析，存为文件------------------------------------------------------