使用Android 使用 camera2打开并预览

最新推荐文章于 2024-05-04 22:15:39 发布
最新推荐文章于 2024-05-04 22:15:39 发布
阅读量506 收藏
点赞数
文章标签： android java 开发语言 android-studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28884137/article/details/129130060
版权

Android camer打开预览工具类
 public class CameraUtil {
    private static final String TAG = "CameraUtil";
    private static final int REQUEST_CAMERA_PERMISSION = 1;
    private static final String FRAGMENT_DIALOG = "dialog";
    private static final int DEFAULT_ORIENTATIONS = 90;
    private static final int INVERSE_ORIENTATIONS = 270;
    private static final int SENSOR_ORIENTATION_DEFAULT_DEGREES = 90;
    private static final int SENSOR_ORIENTATION_INVERSE_DEGREES = 270;
    private static final SparseIntArray DEFAULT_ORIENTATIONS_MAP = new SparseIntArray();
    private static final SparseIntArray INVERSE_ORIENTATIONS_MAP = new SparseIntArray();

    static {
        DEFAULT_ORIENTATIONS_MAP.append(Surface.ROTATION_0, 90);
        DEFAULT_ORIENTATIONS_MAP.append(Surface.ROTATION_90, 0);
        DEFAULT_ORIENTATIONS_MAP.append(Surface.ROTATION_180, 270);
        DEFAULT_ORIENTATIONS_MAP.append(Surface.ROTATION_270, 180);
    }

    static {
        INVERSE_ORIENTATIONS_MAP.append(Surface.ROTATION_0, 270);
        INVERSE_ORIENTATIONS_MAP.append(Surface.ROTATION_90, 180);
        INVERSE_ORIENTATIONS_MAP.append(Surface.ROTATION_180, 90);
        INVERSE_ORIENTATIONS_MAP.append(Surface.ROTATION_270, 0);
    }

    private static CameraUtil cameraUtil;
    private CameraManager cameraManager;
    private CameraDevice cameraDevice;
    private CameraCaptureSession cameraCaptureSession;
    private CaptureRequest.Builder previewRequestBuilder;
    private CaptureRequest previewRequest;
    private ImageReader imageReader;
    private File file;
    private HandlerThread backgroundThread;
    private Handler backgroundHandler;
    private int rotation;
    private Semaphore cameraOpenCloseLock = new Semaphore(1);
    private boolean flashSupported;
    private int sensorOrientation;
    private Size previewSize;
    private Activity activity;
    private TextureView textureView;
    private SurfaceTexture surfaceTexture;
    private Surface surface;
    private CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
        @Override
        public void onOpened(@NonNull CameraDevice camera) {
            cameraOpenCloseLock.release();
            cameraDevice = camera;
            createCameraPreviewSession();
        }

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

        @Override
        public void onError(@NonNull CameraDevice camera, int error) {
            cameraOpenCloseLock.release();
            camera.close();
            cameraDevice = null;
            activity.finish();
        }
    };
    private CameraCaptureSession.CaptureCallback captureCallback = new CameraCaptureSession.CaptureCallback() {
        private void process(CaptureResult result) {
            switch (state) {
                case STATE_PREVIEW: {
                    break;
                }
                case STATE_WAITING_LOCK: {
                    Integer afState = result.get(CaptureResult.CONTROL_AF_STATE);
                    if (afState == null) {
                        captureStillPicture();
                    } else if (CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED == afState ||
                            CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED == afState) {
                        Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                        if (aeState == null ||
                                aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED) {
                            state = STATE_PICTURE_TAKEN;
                            captureStillPicture();
                        } else {
                            runPrecaptureSequence();
                        }
                    }
                    break;
                }
                case STATE_WAITING_PRECAPTURE: {
                    Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                    if (aeState == null ||
                            aeState == CaptureResult.CONTROL_AE_STATE_PRECAPTURE ||
                            aeState == CaptureRequest.CONTROL_AE_STATE_FLASH_REQUIRED) {
                        state = STATE_WAITING_NON_PRECAPTURE;
                    }
                    break;
                }
                case STATE_WAITING_NON_PRECAPTURE: {
                    Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                    if (aeState == null || aeState != CaptureResult.CONTROL_AE_STATE_PRECAPTURE) {
                        state = STATE_PICTURE_TAKEN;
                        captureStillPicture();
                    }
                    break;
                }
            }
        }

        @Override
        public void onCaptureProgressed(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull CaptureResult partialResult) {
            process(partialResult);
        }

        @Override
        public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
            process(result);
        }
    };
    private ImageReader.OnImageAvailableListener onImageAvailableListener = new ImageReader.OnImageAvailableListener() {
        @Override
        public void onImageAvailable(ImageReader reader) {
            backgroundHandler.post(new ImageSaver(reader.acquireNextImage(), file));
        }
    };
    private TextureView.SurfaceTextureListener surfaceTextureListener = new TextureView.SurfaceTextureListener() {
        @Override
        public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
            openCamera(width, height);
        }

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

        @Override
        public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
            return true;
        }

        @Override
        public void onSurfaceTextureUpdated(SurfaceTexture surface) {

        }
    };
    private CameraCaptureSession.StateCallback sessionStateCallback = new CameraCaptureSession.StateCallback() {
        @Override
        public void onConfigured(@NonNull CameraCaptureSession session) {
            if (null == cameraDevice) {
                return;
            }
            cameraCaptureSession = session;
            try {
                previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
                setAutoFlash(previewRequestBuilder);
                previewRequest = previewRequestBuilder.build();
                cameraCaptureSession.setRepeatingRequest(previewRequest, captureCallback, backgroundHandler);
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onConfigureFailed(@NonNull CameraCaptureSession session) {
            showToast("Failed");
        }
    };

    private CameraUtil(Activity activity, TextureView textureView) {
        this.activity = activity;
        this.textureView = textureView;
    }

    public static CameraUtil getInstance(Activity activity, TextureView textureView) {
        if (cameraUtil == null) {
            cameraUtil = new CameraUtil(activity, textureView);
        }
        return cameraUtil;
    }

    public void onResume() {
        startBackgroundThread();
        if (textureView.isAvailable()) {
            openCamera(textureView.getWidth(), textureView.getHeight());
        } else {
            textureView.setSurfaceTextureListener(surfaceTextureListener);
        }
    }

    public void onPause() {
        closeCamera();
        stopBackgroundThread();
    }

    private void setAutoFlash(CaptureRequest.Builder requestBuilder) {
        if (flashSupported) {
            requestBuilder.set(CaptureRequest.CONTROL_AE_MODE,
                    CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
        }
    }

    private void showToast(final String text) {
        final Activity activity = this.activity;
        if (activity != null) {
            activity.runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(activity, text, Toast.LENGTH_SHORT).show();
                }
            });
        }
    }

    private void startBackgroundThread() {
        backgroundThread = new HandlerThread("CameraBackground");
        backgroundThread.start();
        backgroundHandler = new Handler(backgroundThread.getLooper());
    }

    private void stopBackgroundThread() {
        backgroundThread.quitSafely();
        try {
            backgroundThread.join();
            backgroundThread = null;
            backgroundHandler = null;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void closeCamera() {
        try {
            cameraOpenCloseLock.acquire();
            if (null != cameraCaptureSession) {
                cameraCaptureSession.close();
                cameraCaptureSession = null;
            }
            if (null != cameraDevice) {
                cameraDevice.close();
                cameraDevice = null;
            }
            if (null != imageReader) {
                imageReader.close();
                imageReader = null;
            }
        } catch (InterruptedException e) {
            throw new RuntimeException("Interrupted while trying to lock camera closing.", e);
        } finally {
            cameraOpenCloseLock.release();
        }
    }

    private void openCamera(int width, int height) {
        if (ContextCompat.checkSelfPermission(activity, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            requestCameraPermission();
            return;
        }
        setUpCameraOutputs(width, height);
        configureTransform(width, height);
        Activity activity = this.activity;
        CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
        try {
            if (!cameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
                throw new RuntimeException("Time out waiting to lock camera opening.");
            }
            manager.openCamera(cameraId, stateCallback, backgroundHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            throw new RuntimeException("Interrupted while trying to lock camera opening.", e);
        }
    }

    private void requestCameraPermission() {
        if (FragmentCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)) {
            new ConfirmationDialog().show(activity.getFragmentManager(), FRAGMENT_DIALOG);
        } else {
            FragmentCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA},
                    REQUEST_CAMERA_PERMISSION);
        }
    }

    private void setUpCameraOutputs(int width, int height) {
        Activity activity = this.activity;
        CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
        try {
            for (String cameraId : manager.getCameraIdList()) {
                CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);
                Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
                if (facing != null && facing == CameraCharacteristics.LENS_FACING_FRONT) {
                    continue;
                }
                StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
                if (map == null) {
                    continue;
                }
                Size largest = Collections.max(Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)), new CompareSizesByArea());
                imageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(), ImageFormat.JPEG, 2);
                imageReader.setOnImageAvailableListener(onImageAvailableListener, backgroundHandler);
                int displayRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
                sensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
                boolean swappedDimensions = false;
                switch (displayRotation) {
                    case Surface.ROTATION_0:
                    case Surface.ROTATION_180:
                        if (sensorOrientation == 90 || sensorOrientation == 270) {
                            swappedDimensions = true;
                        }
                        break;
                    case Surface.ROTATION_90:
                    case Surface.ROTATION_270:
                        if (sensorOrientation == 0 || sensorOrientation == 180) {
                            swappedDimensions = true;
                        }
                        break;
                    default:
                        Log.e(TAG, "Display rotation is invalid: " + displayRotation);
                }
                Point displaySize = new Point();
                activity.getWindowManager().getDefaultDisplay().getSize(displaySize);
                int rotatedPreviewWidth = width;
                int rotatedPreviewHeight = height;
                int maxPreviewWidth = displaySize.x;
                int maxPreviewHeight = displaySize.y;
                if (swappedDimensions) {
                    rotatedPreviewWidth = height;
                    rotatedPreviewHeight = width;
                    maxPreviewWidth = displaySize.y;
                    maxPreviewHeight = displaySize.x;
                }
                if (maxPreviewWidth > MAX_PREVIEW_WIDTH) {
                    maxPreviewWidth = MAX_PREVIEW_WIDTH;
                }
                if (maxPreviewHeight > MAX_PREVIEW_HEIGHT) {
                    maxPreviewHeight = MAX_PREVIEW_HEIGHT;
                }
                previewSize = chooseOptimalSize(map.getOutputSizes(SurfaceTexture.class),
                        rotatedPreviewWidth, rotatedPreviewHeight, maxPreviewWidth,
                        maxPreviewHeight, largest);
                int orientation = activity.getResources().getConfiguration().orientation;
                if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
                    textureView.setAspectRatio(previewSize.getWidth(), previewSize.getHeight());
                } else {
                    textureView.setAspectRatio(previewSize.getHeight(), previewSize.getWidth());
                }
                Boolean available = characteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE);
                flashSupported = available == null ? false : available;
                this.cameraId = cameraId;
                return;
            }
        } catch (CameraAccessException e) {
            e.printStackTrace();
        } catch (NullPointerException e) {
            ErrorDialog.newInstance(activity.getString(R.string.camera_error)).show(activity.getFragmentManager(), FRAGMENT_DIALOG);
        }
    }

    private void configureTransform(int viewWidth, int viewHeight) {
        Activity activity = this.activity;
        if (null == textureView || null == previewSize || null == activity) {
            return;
        }
        int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
        Matrix matrix = new Matrix();
        RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
        RectF bufferRect = new RectF(0, 0, previewSize.getHeight(), previewSize.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 / previewSize.getHeight(),
                    (float) viewWidth / previewSize.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);
        }
        textureView.setTransform(matrix);
    }

    private void createCameraPreviewSession() {
        try {
            surfaceTexture = textureView.getSurfaceTexture();
            surfaceTexture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());
            surface = new Surface(surfaceTexture);
            previewRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            previewRequestBuilder.addTarget(surface);
            cameraDevice.createCaptureSession(Arrays.asList(surface, imageReader.getSurface()), sessionStateCallback, null);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private void takePicture() {
        lockFocus();
    }

    private void lockFocus() {
        try {
            previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_START);
            state = STATE_WAITING_LOCK;
            cameraCaptureSession.capture(previewRequestBuilder.build(), captureCallback, backgroundHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private void runPrecaptureSequence() {
        try {
            previewRequestBuilder.set(CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER,
                    CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_START);
            state = STATE_WAITING_PRECAPTURE;
            cameraCaptureSession.capture(previewRequestBuilder.build(), captureCallback,
                    backgroundHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private void captureStillPicture() {
        try {
            if (null == cameraDevice) {
                return;
            }
            final CaptureRequest.Builder captureBuilder =
                    cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
            captureBuilder.addTarget(imageReader.getSurface());
            captureBuilder.set(CaptureRequest.CONTROL_AF_MODE,
                    CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
            setAutoFlash(captureBuilder);
            int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
            captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, getOrientation(rotation));
            CameraCaptureSession.CaptureCallback CaptureCallback
                    = new CameraCaptureSession.CaptureCallback() {
                @Override
                public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
                    unlockFocus();
                }
            };
            cameraCaptureSession.stopRepeating();
            cameraCaptureSession.abortCaptures();
            cameraCaptureSession.capture(captureBuilder.build(), CaptureCallback, null);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private int getOrientation(int rotation) {
        return (ORIENTATIONS.get(rotation) + sensorOrientation + 270) % 360;
    }

    private void unlockFocus() {
        try {
            previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER,
                    CameraMetadata.CONTROL_AF_TRIGGER_CANCEL);
            setAutoFlash(previewRequestBuilder);
            cameraCaptureSession.capture(previewRequestBuilder.build(), captureCallback,
                    backgroundHandler);
            state = STATE_PREVIEW;
            cameraCaptureSession.setRepeatingRequest(previewRequest, captureCallback,
                    backgroundHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private static class ImageSaver implements Runnable {
        private final Image mImage;
        private final File mFile;

        ImageSaver(Image image, File file) {
            mImage = image;
            mFile = file;
        }

        @Override
        public void run() {
            ByteBuffer buffer = mImage.getPlanes()[0].getBuffer();
            byte[] bytes = new byte[buffer.remaining()];
            buffer.get(bytes);
            FileOutputStream output = null;
            try {
                output = new FileOutputStream(mFile);
                output.write(bytes);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                mImage.close();
                if (null != output) {
                    try {
                        output.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    private static class CompareSizesByArea implements Comparator<Size> {
        @Override
        public int compare(Size lhs, Size rhs) {
            return Long.signum((long) lhs.getWidth() * lhs.getHeight() -
                    (long) rhs.getWidth() * rhs.getHeight());
        }
    }

    private static Size chooseOptimalSize(Size[] choices, int textureViewWidth,
                                          int textureViewHeight, int maxWidth, int maxHeight, Size aspectRatio) {
        List<Size> bigEnough = new ArrayList<>();
        List<Size> notBigEnough = new ArrayList<>();
        int w = aspectRatio.getWidth();
        int h = aspectRatio.getHeight();
        for (Size option : choices) {
            if (option.getWidth() <= maxWidth && option.getHeight() <= maxHeight &&
                    option.getHeight() == option.getWidth() * h / w) {
                if (option.getWidth() >= textureViewWidth &&
                        option.getHeight() >= textureViewHeight) {
                    bigEnough.add(option);
                } else {
                    notBigEnough.add(option);
                }
            }
        }
        if (bigEnough.size() > 0) {
            return Collections.min(bigEnough, new CompareSizesByArea());
        } else if (notBigEnough.size() > 0) {
            return Collections.max(notBigEnough, new CompareSizesByArea());
        } else {
            Log.e(TAG, "Couldn't find any suitable preview size");
            return choices[0];
        }
    }

    public static class ErrorDialog extends DialogFragment {
        private static final String ARG_MESSAGE = "message";

        public static ErrorDialog newInstance(String message) {
            ErrorDialog dialog = new ErrorDialog();
            Bundle args = new Bundle();
            args.putString(ARG_MESSAGE, message);
            dialog.setArguments(args);
            return dialog;
        }

        @NonNull
        @Override
        public Dialog onCreateDialog(Bundle savedInstanceState) {
            final Activity activity = getActivity();
            return new AlertDialog.Builder(activity)
                    .setMessage(getArguments().getString(ARG_MESSAGE))
                    .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialogInterface, int i) {
                            activity.finish();
                        }
                    })
                    .create();
        }
    }

    public static class ConfirmationDialog extends DialogFragment {
        @NonNull
        @Override
        public Dialog onCreateDialog(Bundle savedInstanceState) {
            final Fragment parent = getParentFragment();
            return new AlertDialog.Builder(getActivity())
                    .setMessage(R.string.request_permission)
                    .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            FragmentCompat.requestPermissions(parent,
                                    new String[]{Manifest.permission.CAMERA},
                                    REQUEST_CAMERA_PERMISSION);
                        }
                    })
                    .setNegativeButton(android.R.string.cancel,
                            new DialogInterface.OnClickListener() {
                                @Override
                                public void onClick(DialogInterface dialog, int which) {
                                    Activity activity = parent.getActivity();
                                    if (activity != null) {
                                        activity.finish();
                                    }
                                }
                            })
                    .create();
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        if (requestCode == REQUEST_CAMERA_PERMISSION) {
            if (grantResults.length != 1 || grantResults[0] != PackageManager.PERMISSION_GRANTED) {
                ErrorDialog.newInstance(activity.getString(R.string.request_permission))
                        .show(activity.getFragmentManager(), FRAGMENT_DIALOG);
            }
        } else {
            super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        }
    }

    private static final int STATE_PREVIEW = 0;
    private static final int STATE_WAITING_LOCK = 1;
    private static final int STATE_WAITING_PRECAPTURE = 2;
    private static final int STATE_WAITING_NON_PRECAPTURE = 3;
    private static final int STATE_PICTURE_TAKEN = 4;
    private int state = STATE_PREVIEW;
    private String cameraId;
    private static final int MAX_PREVIEW_WIDTH = 1920;
    private static final int MAX_PREVIEW_HEIGHT = 1080;
    private static final SparseIntArray ORIENTATIONS = new SparseIntArray();

    static {
        ORIENTATIONS.append(Surface.ROTATION_0, 90);
        ORIENTATIONS.append(Surface.ROTATION_90, 0);
        ORIENTATIONS.append(Surface.ROTATION_180, 270);
        ORIENTATIONS.append(Surface.ROTATION_270, 180);
    }
}

qq_28884137
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Android实现Camera2预览和拍照效果
08-29
下面将详细介绍 Android 中使用 Camera2 API 实现预览和拍照效果的知识点。 一、获取可用摄像机列表 使用 getCameraIdList 方法可以获取所有可用摄像机的列表。然后，可以使用 getCameraCharacteristics 方法找到...
Android Camera2 实现预览功能
08-26
相机预览功能是 Android 应用程序中非常重要的一部分，通过使用 Camera2 API，可以实现高质量的相机预览。下面将通过源码来讲解如何使用 Camera2 来实现相机的预览功能。 首先，需要在 AndroidManifest.xml 文件中...
Android Camera2 Demo - 实现相机预览、拍照、录制视频功能
06-28
因为工作中要使用 Android Camera2 API 来实现相机功能，但因为Camera2比较复杂，网上资料也比较乱，有一定入门门槛，所以花了几天时间系统研究了下，这个项目就是我研究的成果。 其中包括一个自己写的Camera2的Demo，支持预览、拍照和视频录制，以及若干个网上找的，具有参考价值的Camera2 Demo。 具体看我的博客 : https://blog.csdn.net/EthanCo/article/details/131371887 https://blog.csdn.net/EthanCo/article/details/131414981 https://blog.csdn.net/EthanCo/article/details/131418829
Android Camera开发入门
08-01
Android Camera开发入门：目录 第一篇: 前景  一、Android Camera开发前景；      1）camera相关应用的领域      2）相关岗位介绍；      3）市场招聘介绍；      4）发展前景介绍；  二、学习这门课的重要性；      1）适合的人群；      2）熟悉和了解Android Camera 应用开发流程的重要性 第二篇: 开发环境安装  一、jdk、sdk的配置；  二、android studio的安装介绍；  三、adb命令的使用； 第三篇: Camera 常用api和最新框架介绍  一、android camera api介绍      1）camera1、camera2 区别；      2）camera 1、camera2 常用api介绍；      3）android camerax；  二、android camera最新框架介绍 第四篇：Camera api1实现预览、拍照、录像功能  一、预览  二、拍照  三、录像  四、获取实时预览流 第五篇: Camera2相机 打开功能实现第六篇: Camera2相机 预览功能实现  1）surfaceview、textureview 第七篇: Camera2相机 拍照功能实现 1）单拍； 第八篇:Camera2相机 录像功能实现1）正常录像 第九篇:Camera2预览方向、拍照方向设置     1) 预览变形问题如何处理？ 第十篇:YUV流处理  1）如何获取实时预览流？  2)  思考：双码流方案如何实现？一边本地录像，一边后台推流 第十一篇:dumpsys media.camera 第十二篇：Camera2 Zoom变焦第十三篇：人脸识别（android 原生 & 三方人脸识别算法）第十四篇：Uvc UsbCamera第十五篇：Android Camera2拍摄RAW图第十六篇: Android Camera2同时打开前后摄 并 录像第十七篇: Android Camera2 视频慢动作  附：1）提供android开发相关资源      软件工具、Android相关学习书籍、学习相关网站博客等链接2）提供课程讲解中设计到的App 源码    * Camera API1使用源码    * Camera API2使用源码    * 调用三方算法人脸识别源码    *  录像慢动作源码    * Uvc UsbCamera相关源码3）课件
Android相机预览设置适配及显示方式
最新发布
2401_83704036的博客
05-04 618
答应大伙的备战金三银四，大厂面试真题来啦！这份资料我从春招开始，就会将各博客、论坛。网站上等优质的Android开发中高级面试题收集起来，然后全网寻找最优的解答方案。每一道面试题都是百分百的大厂面经真题+最优解答。包知识脉络 + 诸多细节。节省大家在网上搜索资料的时间来学习，也可以分享给身边好友一起学习。《960全网最全Android开发笔记》《379页Android开发面试宝典》包含了腾讯、百度、小米、阿里、乐视、美团、58、猎豹、360、新浪、搜狐等一线互联网公司面试被问到的题目。
十分钟实现 Android Camera2 相机预览
朱豪凯的博客
06-28 6564
因为工作中要使用Android Camera2 API，但因为Camera2比较复杂，网上资料也比较乱，有一定入门门槛，所以花了几天时间系统研究了下，并在CSDN上记录了下，希望能帮助到更多的小伙伴。
使用Camera2实现预览功能
weixin_44752167的博客
08-29 7580
Camera2原生相机开发，预览功能
Android Camera2预览流程
weixin_43757005的博客
06-25 2238
Android Camere2预览流程
Android原生Camera2完成预览和拍照
01-25
本文将深入探讨如何使用Camera2 API来实现预览和拍照功能。 一、Camera2 API概述 Camera2 API是Android Lollipop（API级别21）引入的，旨在提供对相机硬件更直接和全面的访问。它包含了一系列类和接口，如...
Android Studio Camera2的录像功能
04-17
Android Studio提供了强大的集成开发环境，而Camera2 API则是Android系统提供给开发者用于访问和控制摄像头的高级接口。本篇将详细介绍如何利用MediaRecorder和Camera2框架来实现一个基本的录像功能。 1. **Camera2...
android 原生人脸识别Camera和Camera2的示例
05-06
本文将详细讲解如何利用Android原生的`Camera`和`Camera2` API来实现这一功能。 首先，我们从`Camera` API开始。`Camera` API是Android早期版本提供的人脸检测接口，通过`FaceDetector`类来实现。以下是一些关键...
Android Camera2 教程 · 第三章 · 预览
liuqinhou的博客
08-15 3344
相机
Android Camera开发入门 第七篇: Camera2相机 预览功能实现
欢迎关注，期待一起见证彼此的成长~
09-01 887
显示需要借助surface，一般采用surfaceview或者textureview； 相关重要流程： 1、自定义TextureView 2、Activity OnResume的时候，判断mTextureView 当前状态。如果是available状态，则直接打开camera，否则设置surfaceTexture监听 3、surfaceTexture监听中，SurfaceTextureAvailable的时候，去执行opencamera的操作 4、设置surface target 5、 创建会话中，
Android Camera2(1)-Camera2在textureView中的预览和拍照
Jwfaikeyan的博客
07-16 3151
在布局文件加入TextureView控件，然后实现监听事件。然后在OnResume()方法设置监听SurfaceTexture的事件。当SurfaceTexture准备好会回调SurfaceTextureListener的onSurfaceTextureAvailable()方法。//当SurefaceTexture可用的时候，设置相机参数并打开相机 setupCamera(width , height);} };
Android Camera2-预览、拍照、录像流程
xiaowang_lj的博客
07-20 1484
重复模式（Repeating）：指的是不断重复执行指定的 Capture 操作，当有其他模式的 Capture 提交时会暂停该模式，转而执行其他被模式的 Capture，当其他模式的 Capture 执行完毕后又会自动恢复继续执行该模式的 Capture，例如显示预览画面就是不断 Capture 获取每一帧画面。在 Camera2 上，你可以在规定的曝光时长范围内配置拍照的曝光时间，从而实现拍摄长曝光图片，你甚至可以延长每一帧预览画面的曝光时间让整个预览画面在暗环境下也能保证一定的亮度。
01.输入一个链表，反转链表后，输出新链表的表头
奋斗吧010
09-16 420
public class Tesss { public static class ListNode { int val; ListNode next = null; public ListNode(int val) { this.val = val; } } public static void main(String[] args) { ListNode listNode
Android 使用Camera2 实现拍照录像的功能
热门推荐
baipenggui_bo
05-22 1万+
职场小白迷上优美句子: 还是电影 《无问西东》中的台词，这句有点感人： 沈光耀的妈妈对沈光耀说："当初你离家千里，来到这个地方读书，你父亲和我都没有反对过，因为，是我们想你，能享受到人生的乐趣，比如读万卷书行万里路，比如同你喜欢的女孩子结婚生子。注意不是给我增添子孙，而是你自己，能够享受为人父母的乐趣，你一生所要追求的功名利禄，没有什么是你的祖上没经历过的，那些只不过是人生的幻光。我怕，你还...
Android Camera2精简预览和录像
wolf0706的专栏
02-16 863
Android精简使用Camera2预览和录像
android 使用 camera2 完成预览和拍照
06-26
### 回答1： 使用 camera2 API 可以更加灵活、可定制和高效地完成 Android 相机应用开发，其相比 camera1 API 的性能有大幅提升。 在使用 camera2 API 完成预览和拍照前，需要进行以下几个步骤： 1. 获取 CameraManager 对象，查找可用的摄像头列表，并选择需要打开的摄像头。 2. 创建 CameraCaptureSession 对象，用于处理相机触发器的请求，并连接 CameraDevice 和 Surface。 3. 匹配预览和图片输出的 Surface，设置相应的尺寸和格式。 4. 创建 CaptureRequest 对象，设置相应的参数，如自动对焦模式、曝光模式等。 5. 使用 CameraCaptureSession 进行预览或拍照。 在预览时，可以使用 TextureView 或 SurfaceView 进行实时数据渲染，比如显示相机预览画面、拍照后处理和显示等，同时可以通过设置监听器动态获取相机输出的图像流数据。 在拍照时，需要创建 ImageReader 对象，设置输出数据的格式和尺寸，同时需要建立对应的 Surface，将其传入 CaptureRequest.Builder，设置请求类型并发起拍照请求。通过设置 ImageReader 的 OnImageAvailableListener 接口，即可接收到图片数据，并进行后续处理和保存。 以上是使用 camera2 API 完成预览和拍照的基本流程，实际开发中需要根据具体需求进行优化和调整。 ### 回答2： Android Camera2 API 是 Android 系统中相机功能的一种全新的 API，使用 Camera2 可以更灵活地操作相机设备并获得更高质量的照片。 使用 Camera2 实现预览非常简单，我们只需要实现一个 CameraDevice.StateCallback 接口实现类和一个 SurfaceView 主界面。在 StateCallback 的 onOpened 回调中获得 CameraDevice 的实例，然后通过 ImageReader 创建 SurfaceHolder，最后将 SurfaceHolder 通过 CameraDevice.createCaptureSession 接口跟 CameraDevice 进行绑定即可实现预览。 拍照的实现过程与预览类似，首先获得 CameraDevice 实例，然后创建一个 CaptureRequest.Builder 对象，将拍照设置参数通过 CaptureRequest.Builder.set 方法设置到 CaptureRequest.Builder 对象中，最后通过 CameraCaptureSession.capture 接口启动拍照操作即可。 当然，在使用 Camera2 API 进行操作相机时，还需要注意一些其他问题，比如不同的相机设备有不同的特性，需要针对不同的设备进行优化和适配，还需要保证应用的流畅性和稳定性，以达到更好的用户体验。 总之，使用 Camera2 API 实现预览和拍照是 Android 开发的一个重要技能，需要开发者深入了解该 API 的机制和使用方式，才能更好地实现优秀的相机应用。 ### 回答3： Android中的camera2是一种相机应用程序接口（API），旨在提高相机应用程序的功能和性能。相较于早期版本的camera API，camera2 API提供了更多的控制选项，允许开发者定制相机应用程序的功能，从而实现更好的用户体验。 使用camera2 API实现预览和拍照需要以下步骤： 1. 获取CameraManager对象。使用该对象可以获取系统中可用的相机列表，并在需要的时候打开指定相机。 2. 打开指定相机。调用CameraManager.openCamera()方法打开相机。 3. 创建CaptureSession。CaptureSession是与相机关联的一组输出Surface的集合。 4. 创建CaptureRequest。CaptureRequest是一个指定相机操作和设置的重要对象，可以通过它来设置各种模式、参数和目标Surface。 5. 创建Preview Request。处理预览界面。 6. 启动相机预览。启动前，可以使用CaptureRequest.Builder设置其他预览参数。 7. 拍照。当用户点击拍照按钮时，调用CaptureSession.capture()方法，即可拍照并接收回调。 8. 关闭相机。释放所有占用的资源，以便其他应用程序可以使用相机。 总之，在使用camera2 API实现预览和拍照时，需要使用许多类和方法。但只要开发者掌握了API中的基本概念和流程，就可以自由地使用该API，设计新型的相机应用程序，提供更好的功能和性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

qq_28884137

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值