最新版本的Camera2 API的常见依赖项应该怎么写入Manifest文件

以下是最新版本的Camera2 API的常见依赖项在Manifest文件中的写法：

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

这些依赖项要求设备支持Camera2 API的全功能级别（android.hardware.camera2.full），自动对焦功能（android.hardware.camera.autofocus），并且需要相机权限（android.permission.CAMERA）。请注意，在使用Camera2 API时，还需要在代码中进行适当的检查和错误处理，以确保应用程序在不支持Camera2 API或没有相机权限的设备上能够正常运行。

相关问题

如何使用Android的camera2 API 实现一个实时二维码扫码功能？

要实现实时二维码扫描功能，可以使用 Android 的 camera2 API 和 Google 的 ZXing 库。

首先，在 AndroidManifest.xml 文件中添加相机和网络权限：

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

然后，在 build.gradle 文件中添加 ZXing 库的依赖项：

implementation 'com.google.zxing:core:3.4.0'
implementation 'com.journeyapps:zxing-android-embedded:3.6.0'

接下来，在布局文件中添加一个 TextureView 组件用于预览相机图像，并在代码中实例化 CameraManager 和 TextureView：

<TextureView
    android:id="@+id/textureView"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

private CameraManager cameraManager;
private TextureView textureView;

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

    cameraManager = (CameraManager) getSystemService(CAMERA_SERVICE);
    textureView = findViewById(R.id.textureView);
}

然后，实现 TextureView.SurfaceTextureListener 接口，以在 TextureView 就绪时打开相机，开始预览图像：

private String cameraId;
private CameraDevice cameraDevice;
private Size previewSize;
private CaptureRequest.Builder captureRequestBuilder;
private CameraCaptureSession cameraCaptureSession;
private ImageReader imageReader;

private final TextureView.SurfaceTextureListener surfaceTextureListener = new TextureView.SurfaceTextureListener() {
    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int width, int height) {
        openCamera();
    }

    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture, int width, int height) {
        configureTransform(width, height);
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surfaceTexture) {
        return false;
    }

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surfaceTexture) {

    }
};

在 openCamera() 方法中，获取可用的相机列表并选择一个相机，设置预览尺寸和输出格式，然后打开相机：

private void openCamera() {
    try {
        CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
        StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
        assert map != null;
        previewSize = getPreferredPreviewSize(map.getOutputSizes(SurfaceTexture.class), textureView.getWidth(), textureView.getHeight());
        imageReader = ImageReader.newInstance(previewSize.getWidth(), previewSize.getHeight(), ImageFormat.YUV_420_888, 2);
        imageReader.setOnImageAvailableListener(imageReaderListener, backgroundHandler);

        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            return;
        }
        cameraManager.openCamera(cameraId, stateCallback, backgroundHandler);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

在 stateCallback 中处理相机设备的状态，如果打开成功，创建一个 CaptureRequest.Builder 对象，用于构建捕获请求：

private final CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
    @Override
    public void onOpened(CameraDevice camera) {
        cameraDevice = camera;
        createPreviewSession();
    }

    @Override
    public void onDisconnected(CameraDevice camera) {
        cameraDevice.close();
        cameraDevice = null;
    }

    @Override
    public void onError(CameraDevice camera, int error) {
        cameraDevice.close();
        cameraDevice = null;
    }
};

private void createPreviewSession() {
    try {
        SurfaceTexture surfaceTexture = textureView.getSurfaceTexture();
        assert surfaceTexture != null;
        surfaceTexture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());
        Surface previewSurface = new Surface(surfaceTexture);
        Surface imageReaderSurface = imageReader.getSurface();
        captureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        captureRequestBuilder.addTarget(previewSurface);
        captureRequestBuilder.addTarget(imageReaderSurface);
        cameraDevice.createCaptureSession(Arrays.asList(previewSurface, imageReaderSurface),
                new CameraCaptureSession.StateCallback() {
                    @Override
                    public void onConfigured(CameraCaptureSession session) {
                        cameraCaptureSession = session;
                        updatePreview();
                    }

                    @Override
                    public void onConfigureFailed(CameraCaptureSession session) {

                    }
                }, backgroundHandler);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

在 updatePreview() 方法中，设置捕获请求的参数并开始预览：

private void updatePreview() {
    try {
        captureRequestBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
        cameraCaptureSession.setRepeatingRequest(captureRequestBuilder.build(), null, backgroundHandler);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

最后，在 imageReaderListener 中处理相机输出的图像数据，解码二维码并将结果显示在界面上：

private final ImageReader.OnImageAvailableListener imageReaderListener = new ImageReader.OnImageAvailableListener() {
    @Override
    public void onImageAvailable(ImageReader reader) {
        Image image = reader.acquireLatestImage();
        ByteBuffer buffer = image.getPlanes()[0].getBuffer();
        byte[] data = new byte[buffer.remaining()];
        buffer.get(data);
        image.close();

        try {
            PlanarYUVLuminanceSource source = new PlanarYUVLuminanceSource(data, previewSize.getWidth(), previewSize.getHeight(), 0, 0, previewSize.getWidth(), previewSize.getHeight(), false);
            BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));
            Result result = new MultiFormatReader().decode(bitmap);
            runOnUiThread(() -> textView.setText(result.getText()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
};

完整的代码示例可以参考 https://github.com/edwardw1987/Camera2QRCodeScanner 。注意，在实际开发中，可能需要进行更多的错误处理和性能优化。

写一个android使用camera2demo

### 回答1：

我可以给你一个Android使用Camera2Demo的示例代码：import android.Manifest;
import android.app.Activity;
import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.ImageFormat;
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.params.StreamConfigurationMap;
import android.media.ImageReader;
import android.os.Build;
import android.os.Handler;
import android.os.HandlerThread;
import android.support.annotation.NonNull;
import android.support.annotation.RequiresApi;
import android.support.v4.app.ActivityCompat;
import android.util.Size;
import android.util.SparseIntArray;
import android.view.Surface;
import android.view.TextureView;
import android.widget.Toast;@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
public class Camera2Demo {
private TextureView textureView;
private Context context;
private Size previewSize;
private Handler backgroundHandler;
private HandlerThread backgroundThread;
private ImageReader imageReader;
private CaptureRequest.Builder previewRequestBuilder;
private CameraDevice cameraDevice;
private CameraCaptureSession captureSession;
private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
static {
ORIENTATIONS.append(Surface.ROTATION_0, 0);
ORIENTATIONS.append(Surface.ROTATION_90, 90);
ORIENTATIONS.append(Surface.ROTATION_180, 180);
ORIENTATIONS.append(Surface.ROTATION_270, 270);
} public Camera2Demo(TextureView textureView, Context context) {
this.textureView = textureView;
this.context = context;
} public void openCamera() {
CameraManager cameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
try {
String cameraID = cameraManager.getCameraIdList()[0];
CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraID);
StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
previewSize = map.getOutputSizes(SurfaceTexture.class)[0];
// 权限检查
if (ActivityCompat.checkSelfPermission(context, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
return;
}
cameraManager.openCamera(cameraID, stateCallBack, backgroundHandler);
} catch (CameraAccessException e) {
e.printStackTrace();
}
} private CameraDevice.StateCallback stateCallBack = new CameraDevice.StateCallback() {
@Override
public void onOpened(@NonNull CameraDevice camera) {
cameraDevice = camera;
startPreview();
} @Override
public void onDisconnected(@NonNull CameraDevice camera) {
camera.close();
cameraDevice = null;
} @Override
public void onError(@NonNull CameraDevice camera, int error) {
Toast.makeText(context, "摄像头开启失败", Toast.LENGTH_SHORT).show();
}
}; private void startPreview() {
SurfaceTexture surfaceTexture = textureView.getSurfaceTexture();
surfaceTexture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());
Surface previewSurface = new Surface(surfaceTexture);
try {
previewRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
previewRequestBuilder.addTarget(previewSurface);
cameraDevice.createCaptureSession(Arrays.asList(previewSurface, imageReader.getSurface()),
new CameraCaptureSession.StateCallback() {
@Override
public void onConfigured(@NonNull CameraCaptureSession session) {
captureSession = session;
try {
captureSession.setRepeatingRequest(previewRequestBuilder.build(), null, backgroundHandler);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
@Override
public void onConfigureFailed(@NonNull CameraCaptureSession session) {
}
}, backgroundHandler);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
}

### 回答2：
在Android上使用摄像头可以通过Camera2 API来实现，以下是一个简单的Camera2的Demo实现：

首先，需要在AndroidManifest.xml文件中添加相应的权限，包括摄像头访问权限和存储权限。

然后，在布局文件中添加一个TextureView用于实时预览，例如：

<TextureView
    android:id="@+id/textureView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
/>

接下来，创建一个Camera2Helper类来辅助操作摄像头。在该类中，首先获取到CameraManager实例，然后通过CameraManager的getCameraIdList()方法获取所有可用的摄像头ID。

选择一个摄像头后，可以通过CameraCharacteristics类获取到该摄像头的特性，例如摄像头方向、支持的输出格式等。

在Camera2Helper类中，还需要创建一个CameraDevice.StateCallback回调对象，用于监听摄像头设备的连接状态。在连接成功后，可以通过CameraDevice.createCaptureSession()方法创建一个会话用于预览或拍照。

在该会话中，可以通过CameraCaptureSession.CaptureCallback回调对象监听预览数据或拍照数据的生成。

最后，在Activity中创建一个Camera2Helper对象，并在合适的生命周期方法中调用该对象的连接摄像头、开启预览、拍照等方法即可完成Camera2的使用。

以上是一个简单的Camera2的Demo实现，用于在Android上使用摄像头进行实时预览和拍照操作。当然，实际的Camera2应用还可以根据需求进行更加复杂的功能扩展和优化。

### 回答3：
为了编写一个Android使用Camera2 API的Demo，你需要遵循以下步骤：

1. 在Android Studio中创建一个新的Android项目。
2. 在app级别的build.gradle文件中，确保已添加以下依赖项：'android.hardware.camera2'。
3. 在布局文件中添加一个包含SurfaceView的View元素，这将用于预览相机图像。
4. 在MainActivity.java或您选择的活动类中，创建一个CameraManager对象。
5. 使用CameraManager对象获取后置相机ID。
6. 创建一个CameraDevice.StateCallback对象，以便在相机已打开或关闭时执行相应操作。
7. 使用CameraManager对象打开相机，并在成功打开时执行回调操作。
8. 在CameraDevice.StateCallback对象的回调方法中，创建一个CameraCaptureSession.StateCallback对象。
9. 获取SurfaceTexture对象，它将用于渲染预览图像。
10. 使用SurfaceTexture对象创建一个输入Surface，并将其添加到输出目标中。
11. 创建一个相机预览请求构建器，并将Surface添加为预览目标。
12. 使用CameraCaptureSession对象开始预览。
13. 在必要时，可以设置相机捕获的其他配置，例如闪光灯、对焦模式等。
14. 当您想要拍照时，创建一个相机捕获请求构建器，并将Surface添加为捕获目标。
15. 使用CameraCaptureSession对象捕获图像。
16. 在不再需要预览或拍照时，务必释放相关资源，如CameraCaptureSession、CameraDevice等。

通过遵循以上步骤，您就可以编写一个简单的Android Camera2 API Demo，该应用程序可以显示相机预览，并能够拍照。您还可以根据需要添加其他功能，例如手电筒控制、相机参数调整等。记得在完成时对代码进行测试和调试，以确保一切正常工作。祝您编写成功！