下面列出了怎么用android.hardware.camera2.CameraAccessException的API类实例代码及写法,或者点击链接到github查看源代码。
private void updatePreview(final OBVideoPlayer videoPlayer)
{
if (null == cameraDevice)
{
return;
}
try
{
setUpCaptureRequestBuilder(previewBuilder);
captureSession.setRepeatingRequest(previewBuilder.build(),
new CameraCaptureSession.CaptureCallback()
{
@Override
public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result)
{
videoPlayer.invalidate();
super.onCaptureCompleted(session, request, result);
}
}
, backgroundHandler);
} catch (CameraAccessException e)
{
e.printStackTrace();
}
}
@TargetApi(21)
public static Size[] querySupportResolution(Context context, int index) {
CameraManager manager =
(CameraManager)context.getSystemService(CAMERA_SERVICE);
try {
CameraCharacteristics chars
= manager.getCameraCharacteristics(index+"");
StreamConfigurationMap configurationMap = chars.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
return configurationMap.getOutputSizes(ImageFormat.YUV_420_888);
} catch(CameraAccessException e){
e.printStackTrace();
}
return null;
}
@Override
void setFlash(int flash) {
if (mFlash == flash) {
return;
}
int saved = mFlash;
mFlash = flash;
if (mPreviewRequestBuilder != null) {
updateFlash();
if (mCaptureSession != null) {
try {
mCaptureSession.setRepeatingRequest(mPreviewRequestBuilder.build(),
mCaptureCallback, null);
} catch (CameraAccessException e) {
mFlash = saved; // Revert
}
}
}
}
/**
* 拍照
*/
@SuppressLint("NewApi")
private void takePicture() {
if (mCameraDevice == null) return;
// 创建拍照需要的CaptureRequest.Builder
final CaptureRequest.Builder captureRequestBuilder;
try {
captureRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
// 将imageReader的surface作为CaptureRequest.Builder的目标
captureRequestBuilder.addTarget(mImageReader.getSurface());
// 自动对焦
captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
// 自动曝光
captureRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
// 获取手机方向
int rotation = getWindowManager().getDefaultDisplay().getRotation();
// 根据设备方向计算设置照片的方向
captureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION, ORIENTATIONS.get(rotation));
//拍照
CaptureRequest mCaptureRequest = captureRequestBuilder.build();
mCameraCaptureSession.capture(mCaptureRequest, null, childHandler);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
private void startPreview() {
Log.d(TAG, "Starting preview.");
try {
CaptureRequest.Builder previewRequestBuilder =
cameraController
.getRequestFactory()
.makePreview(
viewfinderSurface,
cameraController.getOutputSurfaces(),
currentSensorExposureTimeNs,
currentSensorSensitivity);
captureSession.stopRepeating();
captureSession.setRepeatingRequest(
previewRequestBuilder.build(),
cameraController.getSynchronizerCaptureCallback(),
cameraHandler);
} catch (CameraAccessException e) {
Log.w(TAG, "Unable to create preview.");
}
}
/**
* 指定した条件に合う解像度を選択する
* @param manager
* @param cameraId
* @param targetFace
* @param width
* @param height
* @param degrees
* @return
* @throws CameraAccessException
*/
public static CameraConst.CameraInfo chooseOptimalSize(
@NonNull final CameraManager manager,
final String cameraId, @CameraConst.FaceType final int targetFace,
final int width, final int height, final int degrees)
throws CameraAccessException {
if (DEBUG) Log.v(TAG,
String.format("chooseOptimalSize:Size(%dx%d),targetFace=%d,degrees=%d",
width, height, targetFace, degrees));
final CameraCharacteristics characteristics
= manager.getCameraCharacteristics(cameraId);
final StreamConfigurationMap map = characteristics.get(
CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
final Size previewSize
= chooseOptimalSize(characteristics, map, width, height, degrees);
final int orientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
if (!TextUtils.isEmpty(cameraId) && (previewSize != null)) {
return new CameraConst.CameraInfo(cameraId, targetFace, orientation,
previewSize.getWidth(), previewSize.getHeight());
}
return null;
}
public void flush() throws CameraAccessException {
synchronized(mInterfaceLock) {
checkIfCameraClosedOrInError();
mDeviceExecutor.execute(mCallOnBusy);
// If already idle, just do a busy->idle transition immediately, don't actually
// flush.
if (mIdle) {
mDeviceExecutor.execute(mCallOnIdle);
return;
}
long lastFrameNumber = mRemoteDevice.flush();
if (mRepeatingRequestId != REQUEST_ID_NONE) {
checkEarlyTriggerSequenceComplete(mRepeatingRequestId, lastFrameNumber);
mRepeatingRequestId = REQUEST_ID_NONE;
}
}
}
@Override
public int captureBurst(List<CaptureRequest> requests, CaptureCallback callback,
Handler handler) throws CameraAccessException {
checkCaptureRequests(requests);
synchronized (mDeviceImpl.mInterfaceLock) {
checkNotClosed();
handler = checkHandler(handler, callback);
if (DEBUG) {
CaptureRequest[] requestArray = requests.toArray(new CaptureRequest[0]);
Log.v(TAG, mIdString + "captureBurst - requests " + Arrays.toString(requestArray) +
", callback " + callback + " handler " + handler);
}
return addPendingSequence(mDeviceImpl.captureBurst(requests,
createCaptureCallbackProxy(handler, callback), mDeviceExecutor));
}
}
@Override
public int setSingleRepeatingRequest(CaptureRequest request, Executor executor,
CaptureCallback callback) throws CameraAccessException {
if (executor == null) {
throw new IllegalArgumentException("executor must not be null");
} else if (callback == null) {
throw new IllegalArgumentException("callback must not be null");
}
checkRepeatingRequest(request);
synchronized (mDeviceImpl.mInterfaceLock) {
checkNotClosed();
executor = CameraDeviceImpl.checkExecutor(executor, callback);
if (DEBUG) {
Log.v(TAG, mIdString + "setRepeatingRequest - request " + request + ", callback " +
callback + " executor" + " " + executor);
}
return addPendingSequence(mDeviceImpl.setRepeatingRequest(request,
createCaptureCallbackProxyWithExecutor(executor, callback), mDeviceExecutor));
}
}
public Size[] getCameraResolutions(Facing facing) {
try {
CameraCharacteristics characteristics = getCharacteristicsForFacing(cameraManager, facing);
if (characteristics == null) {
return new Size[0];
}
StreamConfigurationMap streamConfigurationMap =
characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
Size[] outputSizes = streamConfigurationMap.getOutputSizes(SurfaceTexture.class);
return outputSizes != null ? outputSizes : new Size[0];
} catch (CameraAccessException | NullPointerException e) {
Log.e(TAG, "Error", e);
return new Size[0];
}
}
@Override
public void onOpened(CameraDevice camera) {
mCamera = camera;
if (mOpenCallback != null) {
try {
CameraCharacteristics props =
mCameraManager.getCameraCharacteristics(mCameraId);
CameraDeviceInfo.Characteristics characteristics =
getCameraDeviceInfo().getCharacteristics(mCameraIndex);
mCameraProxy = new AndroidCamera2ProxyImpl(AndroidCamera2AgentImpl.this,
mCameraIndex, mCamera, characteristics, props);
mPersistentSettings = new Camera2RequestSettingsSet();
mActiveArray =
props.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
mLegacyDevice =
props.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL) ==
CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY;
changeState(AndroidCamera2StateHolder.CAMERA_UNCONFIGURED);
mOpenCallback.onCameraOpened(mCameraProxy);
} catch (CameraAccessException ex) {
mOpenCallback.onDeviceOpenFailure(mCameraIndex,
generateHistoryString(mCameraIndex));
}
}
}
/**
* <p>Starts a capture session for camera preview.</p>
* <p>This rewrites {@link #mPreviewRequestBuilder}.</p>
* <p>The result will be continuously processed in {@link #mSessionCallback}.</p>
*/
void startCaptureSession() {
if (!isCameraOpened() || !mPreview.isReady() || mImageReader == null) {
return;
}
Size previewSize = chooseOptimalSize();
mPreview.setBufferSize(previewSize.getWidth(), previewSize.getHeight());
Surface surface = mPreview.getSurface();
try {
mPreviewRequestBuilder = mCamera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
mPreviewRequestBuilder.addTarget(surface);
mCamera.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()),
mSessionCallback, null);
} catch (CameraAccessException e) {
throw new RuntimeException("Failed to start camera session");
}
}
/**
* 拍照
*/
@SuppressLint("NewApi")
private void takePicture() {
if (mCameraDevice == null) return;
// 创建拍照需要的CaptureRequest.Builder
final CaptureRequest.Builder captureRequestBuilder;
try {
captureRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
// 将imageReader的surface作为CaptureRequest.Builder的目标
captureRequestBuilder.addTarget(mImageReader.getSurface());
// 自动对焦
captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
// 自动曝光
captureRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
// 获取手机方向
int rotation = getWindowManager().getDefaultDisplay().getRotation();
// 根据设备方向计算设置照片的方向
captureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION, ORIENTATIONS.get(rotation));
//拍照
CaptureRequest mCaptureRequest = captureRequestBuilder.build();
mCameraCaptureSession.capture(mCaptureRequest, null, childHandler);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
public FlashHandler(CameraManager cameraManager) {
mCameraManager = cameraManager;
try {
for (String camId : mCameraManager.getCameraIdList()) {
CameraCharacteristics characteristics = mCameraManager.getCameraCharacteristics(camId);
Boolean hasFlash = characteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE);
Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
if (facing != null && facing == CameraCharacteristics.LENS_FACING_BACK
&& Boolean.TRUE.equals(hasFlash)) {
torchId = camId;
break;
}
}
if (torchId != null) {
controller = new FlashControlThread();
controller.start();
}
} catch (CameraAccessException e) {
Log.d(TAG, "Could not create flash controller");
}
}
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
private void initCamera() {
try {
CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
String[] cameraIds = cameraManager.getCameraIdList();
if (cameraIds.length == 0) return;
String cameraId = cameraIds[0];
if (ActivityCompat.checkSelfPermission(this,
Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(this,
new String[]{Manifest.permission.CAMERA}, CAMERA_PERMISSIONS_REQUEST);
}
cameraManager.openCamera(cameraId, cameraDeviceCallback, null);
} catch (CameraAccessException e) {
Log.d(TAG, "No access to the camera.", e);
}
}
@Override
protected List<PreviewSize> getSupportedSize() {
try {
CameraCharacteristics characteristics = mCameraManager.getCameraCharacteristics(
getCurrentCameraId());
StreamConfigurationMap map =
characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
if (map == null) {
return Collections.singletonList(new PreviewSize(mPreviewWidth, mPreviewHeight));
}
Size[] supportedSize = map.getOutputSizes(SurfaceTexture.class);
if (supportedSize == null || supportedSize.length == 0) {
return Collections.singletonList(new PreviewSize(mPreviewWidth, mPreviewHeight));
}
List<PreviewSize> results = new ArrayList<>();
for (Size size : supportedSize) {
results.add(new PreviewSize(size.getWidth(), size.getHeight()));
}
return results;
} catch (CameraAccessException e) {
throw new CameraAccessError();
}
}
public void stopRepeating() throws CameraAccessException {
synchronized(mInterfaceLock) {
checkIfCameraClosedOrInError();
if (mRepeatingRequestId != REQUEST_ID_NONE) {
int requestId = mRepeatingRequestId;
mRepeatingRequestId = REQUEST_ID_NONE;
long lastFrameNumber;
try {
lastFrameNumber = mRemoteDevice.cancelRequest(requestId);
} catch (IllegalArgumentException e) {
if (DEBUG) {
Log.v(TAG, "Repeating request was already stopped for request " + requestId);
}
// Repeating request was already stopped. Nothing more to do.
return;
}
checkEarlyTriggerSequenceComplete(requestId, lastFrameNumber);
}
}
}
/**
* Unlock the focus. This method should be called when still image capture sequence is
* finished.
*/
private void unlockFocus() {
try {
state = STATE_PREVIEW;
// Send a single request to cancel any AF in progress.
setAfTriggerCancel(previewRequestBuilder);
captureSession.capture(previewRequestBuilder.build(), captureCallback, backgroundHandler);
setAfTriggerIdle(previewRequestBuilder);
// After this resume a normal preview.
captureSession.setRepeatingRequest(previewRequest, captureCallback, backgroundHandler);
} catch (CameraAccessException e) {
Log.w(TAG, e);
}
}
@Override
public void setAutoFocus(boolean autoFocus) {
if (mAutoFocus == autoFocus) {
return;
}
mAutoFocus = autoFocus;
if (mPreviewRequestBuilder != null) {
updateAutoFocus();
if (mCaptureSession != null) {
try {
mCaptureSession.setRepeatingRequest(mPreviewRequestBuilder.build(),
mCaptureCallback, null);
} catch (CameraAccessException e) {
mAutoFocus = !mAutoFocus; // Revert
}
}
}
}
@Override
public void close()
{
if (mIsClosed)
{
Log.w(TAG, "Camera is already closed.");
return;
}
try
{
mCaptureSession.stopRepeating();
} catch (CameraAccessException e)
{
Log.e(TAG, "Could not abort captures in progress.");
}
mIsClosed = true;
mCameraThread.quitSafely();
mDevice.close();
mCaptureManager.close();
mCaptureImageReader.close();
}
/**
* Lock the focus as the first step for a still image capture.
*/
private void lockFocus() {
Log.d(TAG, "lockFocus: ");
try {
// This is how to tell the camera to lock focus.
mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER,
CameraMetadata.CONTROL_AF_TRIGGER_START);
// Tell #mCaptureCallback to wait for the lock.
mState = STATE_WAITING_LOCK;
mCaptureSession.setRepeatingRequest(mPreviewRequestBuilder.build(), mCaptureCallback,
mBackgroundHandler);
} catch (CameraAccessException e) {
Log.e(TAG, "CameraAccessException: " + e);
e.printStackTrace();
}
}
/**
* Request preview capture stream with auto focus trigger cycle.
*/
private void sendAutoFocusTriggerCaptureRequest(Object tag)
{
try
{
// Step 1: Request single frame CONTROL_AF_TRIGGER_START.
CaptureRequest.Builder builder;
builder = mDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
builder.addTarget(mPreviewSurface);
builder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
mControlAFMode = CameraMetadata.CONTROL_AF_MODE_AUTO;
addBaselineCaptureKeysToRequest(builder);
builder.set(CaptureRequest.CONTROL_AF_TRIGGER, CaptureRequest.CONTROL_AF_TRIGGER_START);
builder.setTag(tag);
mCaptureSession.capture(builder.build(), mCaptureCallback, mCameraHandler);
// Step 2: Call repeatingPreview to update mControlAFMode.
repeatingPreview(tag);
resumeContinuousAFAfterDelay(FOCUS_HOLD_MILLIS);
} catch (CameraAccessException ex)
{
Log.e(TAG, "Could not execute preview request.", ex);
}
}
@SuppressWarnings("deprecation")
private void doToggleTorch(boolean switchOn) throws IOException, CameraAccessException {
if (Build.VERSION.SDK_INT >= 23) { // Android M has such an easy API! <3
doToggleTorchSdk23(switchOn);
} else {
if (mCamera == null) {
mCamera = Camera.open();
if (Build.VERSION.SDK_INT >= 11) { // honeycomb
// required for (at least) the Nexus 5
mCamera.setPreviewTexture(new SurfaceTexture(0));
}
}
final Camera.Parameters mParameters = mCamera.getParameters();
mParameters.setFlashMode(switchOn ? Camera.Parameters.FLASH_MODE_TORCH : Camera.Parameters.FLASH_MODE_OFF);
mCamera.setParameters(mParameters);
mCamera.startPreview();
callbackContext.success();
}
}
/**
* Callbacks for CameraOps
*/
@Override
public void onCameraReady() {
// Ready to send requests in, so set them up
try {
CaptureRequest.Builder previewBuilder =
mCameraOps.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
previewBuilder.addTarget(mProcessingNormalSurface);
previewBuilder.setTag(mAutoExposureTag);
mPreviewRequest = previewBuilder.build();
mHdrBuilder =
mCameraOps.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
mHdrBuilder.set(CaptureRequest.CONTROL_AE_MODE,
CaptureRequest.CONTROL_AE_MODE_OFF);
mHdrBuilder.addTarget(mProcessingHdrSurface);
switchRenderMode(0);
} catch (CameraAccessException e) {
String errorMessage = getErrorString(e);
showErrorDialog(errorMessage);
}
}
/**
* 指定された facing に対応するカメラIDを取得します.
* <p>
* facing に対応したカメラが発見できない場合には null を返却します。
* </p>
* @param cameraManager カメラマネージャ
* @param facing カメラの向き
* @return カメラID
* @throws CameraAccessException カメラの操作に失敗した場合に発生
*/
public static String getCameraId(final CameraManager cameraManager, final int facing) throws CameraAccessException {
for (String cameraId : cameraManager.getCameraIdList()) {
CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
Integer supportFacing = characteristics.get(CameraCharacteristics.LENS_FACING);
if (supportFacing != null && supportFacing == facing) {
return cameraId;
}
}
return null;
}
/**
* Initialize the camera device
*/
@SuppressLint("MissingPermission")
public void initializeCamera(Context context, int previewWidth, int previewHeight,
Handler backgroundHandler,
ImageReader.OnImageAvailableListener imageAvailableListener) {
if (initialized) {
throw new IllegalStateException(
"CameraHandler is already initialized or is initializing");
}
initialized = true;
// Discover the camera instance
CameraManager manager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
String[] camIds = null;
try {
camIds = manager.getCameraIdList();
} catch (CameraAccessException e) {
Log.w(TAG, "Cannot get the list of available cameras", e);
}
if (camIds == null || camIds.length < 1) {
Log.d(TAG, "No cameras found");
return;
}
Log.d(TAG, "Using camera id " + camIds[0]);
// Initialize the image processor
mImageReader = ImageReader.newInstance(previewWidth, previewHeight, ImageFormat.JPEG,
MAX_IMAGES);
mImageReader.setOnImageAvailableListener(imageAvailableListener, backgroundHandler);
// Open the camera resource
try {
manager.openCamera(camIds[0], mStateCallback, backgroundHandler);
} catch (CameraAccessException cae) {
Log.d(TAG, "Camera access exception", cae);
}
}
/**
* Lock the focus as the first step for a still image capture.
*/
private void lockFocus() {
try {
Log.d(TAG, "lockFocus: ");
// This is how to tell the camera to lock focus.
mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER,
CameraMetadata.CONTROL_AF_TRIGGER_START);
// Tell #mCaptureCallback to wait for the lock.
// mState = STATE_WAITING_LOCK;
mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback,
mBackgroundHandler);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
@Override
@TargetApi(Build.VERSION_CODES.M)
public boolean toggle(boolean enable) {
try {
if (mCameraID != null){
mCameraManager.setTorchMode(mCameraID, enable);
return true;
}else{
return false;
}
} catch (CameraAccessException e) {
Toast.makeText(mContext, e.getMessage(), Toast.LENGTH_SHORT).show();
return false;
}
}
void changeAutoFocus() {
requestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_VIDEO);
requestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_CANCEL);
//then we ask for a single request (not repeating!)
try {
cameraCaptureSession.setRepeatingRequest(requestBuilder.build(), null, null);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
private String selectCamera(int lenseDirection) throws CameraAccessException {
for (String id : cameraManager.getCameraIdList()) {
CameraCharacteristics info = cameraManager.getCameraCharacteristics(id);
/* discard cameras that don't face the right direction */
if (lenseDirection == info.get(CameraCharacteristics.LENS_FACING)) {
Log.d(LOG_TAG,"selectCamera() Direction the camera faces relative to device screen: " + info.get(CameraCharacteristics.LENS_FACING));
return id;
}
}
return null;
}