Android Camera SurfaceView 预览拍照

最新推荐文章于 2024-05-08 17:28:07 发布
最新推荐文章于 2024-05-08 17:28:07 发布
阅读量1.5k 收藏 9
点赞数
原文链接：https://www.jianshu.com/p/9e0f3fc5a3b4
版权

本文已获得作者授权，本文作者：cain_huang

Android使用 Camera API + SurfaceView 方式进行预览拍照。

SurfaceView 的创建以及回调

创建一个SurfaceView，并实现SurfaceHolder的回调。

由于Camera在SurfaceView中是通过SurfaceHolder 使得Surfaceview能够预览Camera返回的数据，因此我们需要实现SurfaceHolder 的回调，实现代码如下：

public class CameraSurfaceView extends SurfaceView implements SurfaceHolder.Callback {

    private static final String TAG = CameraSurfaceView.class.getSimpleName();

    private SurfaceHolder mSurfaceHolder;

    public CameraSurfaceView(Context context) {
        super(context);
        init();
    }

    public CameraSurfaceView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public CameraSurfaceView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private void init() {
        mSurfaceHolder = getHolder();
        mSurfaceHolder.addCallback(this);
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        CameraUtils.openFrontalCamera(CameraUtils.DESIRED_PREVIEW_FPS);
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        CameraUtils.startPreviewDisplay(holder);
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        CameraUtils.releaseCamera();
    }
}

Camera 操作的辅助类

CameraUtils 辅助类主要是Camera API 的一些操作，比如打开相机、开始预览、停止预览、切换相机、设置预览参数等操作，具体实现如下：

public class CameraUtils {

    // 相机默认宽高，相机的宽度和高度跟屏幕坐标不一样，手机屏幕的宽度和高度是反过来的。
    public static final int DEFAULT_WIDTH = 1280;
    public static final int DEFAULT_HEIGHT = 720;
    public static final int DESIRED_PREVIEW_FPS = 30;

    private static int mCameraID = Camera.CameraInfo.CAMERA_FACING_FRONT;
    private static Camera mCamera;
    private static int mCameraPreviewFps;
    private static int mOrientation = 0;

    /**
     * 打开相机，默认打开前置相机
     * @param expectFps
     */
    public static void openFrontalCamera(int expectFps) {
        if (mCamera != null) {
            throw new RuntimeException("camera already initialized!");
        }
        Camera.CameraInfo info = new Camera.CameraInfo();
        int numCameras = Camera.getNumberOfCameras();
        for (int i = 0; i < numCameras; i++) {
            Camera.getCameraInfo(i, info);
            if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
                mCamera = Camera.open(i);
                mCameraID = info.facing;
                break;
            }
        }
        // 如果没有前置摄像头，则打开默认的后置摄像头
        if (mCamera == null) {
            mCamera = Camera.open();
            mCameraID = Camera.CameraInfo.CAMERA_FACING_BACK;
        }
        // 没有摄像头时，抛出异常
        if (mCamera == null) {
            throw new RuntimeException("Unable to open camera");
        }

        Camera.Parameters parameters = mCamera.getParameters();
        mCameraPreviewFps = CameraUtils.chooseFixedPreviewFps(parameters, expectFps * 1000);
        parameters.setRecordingHint(true);
        mCamera.setParameters(parameters);
        setPreviewSize(mCamera, CameraUtils.DEFAULT_WIDTH, CameraUtils.DEFAULT_HEIGHT);
        setPictureSize(mCamera, CameraUtils.DEFAULT_WIDTH, CameraUtils.DEFAULT_HEIGHT);
        mCamera.setDisplayOrientation(mOrientation);
    }

    /**
     * 根据ID打开相机
     * @param cameraID
     * @param expectFps
     */
    public static void openCamera(int cameraID, int expectFps) {
        if (mCamera != null) {
            throw new RuntimeException("camera already initialized!");
        }
        mCamera = Camera.open(cameraID);
        if (mCamera == null) {
            throw new RuntimeException("Unable to open camera");
        }
        mCameraID = cameraID;
        Camera.Parameters parameters = mCamera.getParameters();
        mCameraPreviewFps = CameraUtils.chooseFixedPreviewFps(parameters, expectFps * 1000);
        parameters.setRecordingHint(true);
        mCamera.setParameters(parameters);
        setPreviewSize(mCamera, CameraUtils.DEFAULT_WIDTH, CameraUtils.DEFAULT_HEIGHT);
        setPictureSize(mCamera, CameraUtils.DEFAULT_WIDTH, CameraUtils.DEFAULT_HEIGHT);
        mCamera.setDisplayOrientation(mOrientation);
    }

    /**
     * 开始预览
     * @param holder
     */
    public static void startPreviewDisplay(SurfaceHolder holder) {
        if (mCamera == null) {
            throw new IllegalStateException("Camera must be set when start preview");
        }
        try {
            mCamera.setPreviewDisplay(holder);
            mCamera.startPreview();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 切换相机
     * @param cameraID
     */
    public static void switchCamera(int cameraID, SurfaceHolder holder) {
        if (mCameraID == cameraID) {
            return;
        }
        mCameraID = cameraID;
        // 释放原来的相机
        releaseCamera();
        // 打开相机
        openCamera(cameraID, CameraUtils.DESIRED_PREVIEW_FPS);
        // 打开预览
        startPreviewDisplay(holder);
    }

    /**
     * 释放相机
     */
    public static void releaseCamera() {
        if (mCamera != null) {
            mCamera.stopPreview();
            mCamera.release();
            mCamera = null;
        }
    }

    /**
     * 开始预览
     */
    public static void startPreview() {
        if (mCamera != null) {
            mCamera.startPreview();
        }
    }

    /**
     * 停止预览
     */
    public static void stopPreview() {
        if (mCamera != null) {
            mCamera.stopPreview();
        }
    }

    /**
     * 拍照
     */
    public static void takePicture(Camera.ShutterCallback shutterCallback,
                                   Camera.PictureCallback rawCallback,
                                   Camera.PictureCallback pictureCallback) {
        if (mCamera != null) {
            mCamera.takePicture(shutterCallback, rawCallback, pictureCallback);
        }
    }

    /**
     * 设置预览大小
     * @param camera
     * @param expectWidth
     * @param expectHeight
     */
    public static void setPreviewSize(Camera camera, int expectWidth, int expectHeight) {
        Camera.Parameters parameters = camera.getParameters();
        Camera.Size size = calculatePerfectSize(parameters.getSupportedPreviewSizes(),
                expectWidth, expectHeight);
        parameters.setPreviewSize(size.width, size.height);
        camera.setParameters(parameters);
    }

    /**
     * 获取预览大小
     * @return
     */
    public static Camera.Size getPreviewSize() {
        if (mCamera != null) {
            return mCamera.getParameters().getPreviewSize();
        }
        return null;
    }

    /**
     * 设置拍摄的照片大小
     * @param camera
     * @param expectWidth
     * @param expectHeight
     */
    public static void setPictureSize(Camera camera, int expectWidth, int expectHeight) {
        Camera.Parameters parameters = camera.getParameters();
        Camera.Size size = calculatePerfectSize(parameters.getSupportedPictureSizes(),
                expectWidth, expectHeight);
        parameters.setPictureSize(size.width, size.height);
        camera.setParameters(parameters);
    }

    /**
     * 获取照片大小
     * @return
     */
    public static Camera.Size getPictureSize() {
        if (mCamera != null) {
            return mCamera.getParameters().getPictureSize();
        }
        return null;
    }

    /**
     * 计算最完美的Size
     * @param sizes
     * @param expectWidth
     * @param expectHeight
     * @return
     */
    public static Camera.Size calculatePerfectSize(List<Camera.Size> sizes, int expectWidth,
                                                   int expectHeight) {
        sortList(sizes); // 根据宽度进行排序
        Camera.Size result = sizes.get(0);
        boolean widthOrHeight = false; // 判断存在宽或高相等的Size
        // 辗转计算宽高最接近的值
        for (Camera.Size size: sizes) {
            // 如果宽高相等，则直接返回
            if (size.width == expectWidth && size.height == expectHeight) {
                result = size;
                break;
            }
            // 仅仅是宽度相等，计算高度最接近的size
            if (size.width == expectWidth) {
                widthOrHeight = true;
                if (Math.abs(result.height - expectHeight)
                        > Math.abs(size.height - expectHeight)) {
                    result = size;
                }
            }
            // 高度相等，则计算宽度最接近的Size
            else if (size.height == expectHeight) {
                widthOrHeight = true;
                if (Math.abs(result.width - expectWidth)
                        > Math.abs(size.width - expectWidth)) {
                    result = size;
                }
            }
            // 如果之前的查找不存在宽或高相等的情况，则计算宽度和高度都最接近的期望值的Size
            else if (!widthOrHeight) {
                if (Math.abs(result.width - expectWidth)
                        > Math.abs(size.width - expectWidth)
                        && Math.abs(result.height - expectHeight)
                        > Math.abs(size.height - expectHeight)) {
                    result = size;
                }
            }
        }
        return result;
    }

    /**
     * 排序
     * @param list
     */
    private static void sortList(List<Camera.Size> list) {
        Collections.sort(list, new Comparator<Camera.Size>() {
            @Override
            public int compare(Camera.Size pre, Camera.Size after) {
                if (pre.width > after.width) {
                    return 1;
                } else if (pre.width < after.width) {
                    return -1;
                }
                return 0;
            }
        });
    }

    /**
     * 选择合适的FPS
     * @param parameters
     * @param expectedThoudandFps 期望的FPS
     * @return
     */
    public static int chooseFixedPreviewFps(Camera.Parameters parameters, int expectedThoudandFps) {
        List<int[]> supportedFps = parameters.getSupportedPreviewFpsRange();
        for (int[] entry : supportedFps) {
            if (entry[0] == entry[1] && entry[0] == expectedThoudandFps) {
                parameters.setPreviewFpsRange(entry[0], entry[1]);
                return entry[0];
            }
        }
        int[] temp = new int[2];
        int guess;
        parameters.getPreviewFpsRange(temp);
        if (temp[0] == temp[1]) {
            guess = temp[0];
        } else {
            guess = temp[1] / 2;
        }
        return guess;
    }

    /**
     * 设置预览角度，setDisplayOrientation本身只能改变预览的角度
     * previewFrameCallback以及拍摄出来的照片是不会发生改变的，拍摄出来的照片角度依旧不正常的
     * 拍摄的照片需要自行处理
     * 这里Nexus5X的相机简直没法吐槽，后置摄像头倒置了，切换摄像头之后就出现问题了。
     * @param activity
     */
    public static int calculateCameraPreviewOrientation(Activity activity) {
        Camera.CameraInfo info = new Camera.CameraInfo();
        Camera.getCameraInfo(mCameraID, info);
        int rotation = activity.getWindowManager().getDefaultDisplay()
                .getRotation();
        int degrees = 0;
        switch (rotation) {
            case Surface.ROTATION_0:
                degrees = 0;
                break;
            case Surface.ROTATION_90:
                degrees = 90;
                break;
            case Surface.ROTATION_180:
                degrees = 180;
                break;
            case Surface.ROTATION_270:
                degrees = 270;
                break;
        }

        int result;
        if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
            result = (info.orientation + degrees) % 360;
            result = (360 - result) % 360;
        } else {
            result = (info.orientation - degrees + 360) % 360;
        }
        mOrientation = result;
        return result;
    }


    /**
     * 获取当前的Camera ID
     * @return
     */
    public static int getCameraID() {
        return mCameraID;
    }

    /**
     * 获取当前预览的角度
     * @return
     */
    public static int getPreviewOrientation() {
        return mOrientation;
    }

    /**
     * 获取FPS（千秒值）
     * @return
     */
    public static int getCameraPreviewThousandFps() {
        return mCameraPreviewFps;
    }
}

权限申请

在Activity中使用CameraSurfaceview，有Android6.0动态权限申请问题，需要我们判断相机和存储权限是否申请了：

public class CameraSurfaceViewActivity extends AppCompatActivity implements View.OnClickListener {

    private static final int REQUEST_CAMERA = 0x01;

    private CameraSurfaceView mCameraSurfaceView;
    private Button mBtnTake;
    private Button mBtnSwitch;

    private int mOrientation;

    // CameraSurfaceView 容器包装类
    private FrameLayout mAspectLayout;
    private boolean mCameraRequested;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
        setContentView(R.layout.activity_camera_surface);
        // Android 6.0相机动态权限检查
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA)
                == PackageManager.PERMISSION_GRANTED) {
            initView();
        } else {
            ActivityCompat.requestPermissions(this,
                    new String[]{
                            Manifest.permission.CAMERA,
                            Manifest.permission.WRITE_EXTERNAL_STORAGE
                    }, REQUEST_CAMERA);
        }
    }

    /**
     * 初始化View
     */
    private void initView() {
        mAspectLayout = (FrameLayout) findViewById(R.id.layout_aspect);;
        mCameraSurfaceView = new CameraSurfaceView(this);
        mAspectLayout.addView(mCameraSurfaceView);
        mOrientation = CameraUtils.calculateCameraPreviewOrientation(CameraSurfaceViewActivity.this);
        mBtnTake = (Button) findViewById(R.id.btn_take);
        mBtnTake.setOnClickListener(this);
        mBtnSwitch = (Button) findViewById(R.id.btn_switch);
        mBtnSwitch.setOnClickListener(this);
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            // 相机权限
            case REQUEST_CAMERA:
                if (grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    mCameraRequested = true;
                    initView();
                }
                break;
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (mCameraRequested) {
            CameraUtils.startPreview();
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        CameraUtils.stopPreview();
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_take:
                takePicture();
                break;

            case R.id.btn_switch:
                switchCamera();
                break;
        }
    }

    /**
     * 拍照
     */
    private void takePicture() {
        CameraUtils.takePicture(new Camera.ShutterCallback() {
            @Override
            public void onShutter() {

            }
        }, null, new Camera.PictureCallback() {
            @Override
            public void onPictureTaken(byte[] data, Camera camera) {
                CameraUtils.startPreview();
                Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
                if (bitmap != null) {
                    bitmap = ImageUtils.getRotatedBitmap(bitmap, mOrientation);
                    String path = Environment.getExternalStorageDirectory() + "/DCIM/Camera/"
                            + System.currentTimeMillis() + ".jpg";
                    try {
                        FileOutputStream fout = new FileOutputStream(path);
                        BufferedOutputStream bos = new BufferedOutputStream(fout);
                        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bos);
                        bos.flush();
                        bos.close();
                        fout.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                CameraUtils.startPreview();
            }
        });
    }


    /**
     * 切换相机
     */
    private void switchCamera() {
        if (mCameraSurfaceView != null) {
            CameraUtils.switchCamera(1 - CameraUtils.getCameraID(), mCameraSurfaceView.getHolder());
            // 切换相机后需要重新计算旋转角度
            mOrientation = CameraUtils.calculateCameraPreviewOrientation(CameraSurfaceViewActivity.this);
        }
    }

}

由于用到了相机和存储权限，我们需要在manifest中注册相机和存储权限，这里要说明的是，manifest用use-permission只是声明了需要使用哪些权限，而我们实际项目中在使用到这两项权限时，需要你检查权限是否已经被授权，如果没授权，则需要请求授权：

<!-- 存储权限 -->
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <!-- 相机权限 -->
    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <uses-permission android:name="android.permission.FLASHLIGHT" />

图像处理的辅助类

另外，ImageUtils类的实现如下：

public class ImageUtils {

    /**
     * 旋转图片
     * @param bitmap
     * @param rotation
     * @Return
     */
    public static Bitmap getRotatedBitmap(Bitmap bitmap, int rotation) {
        Matrix matrix = new Matrix();
        matrix.postRotate(rotation);
        return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(),
                bitmap.getHeight(), matrix, false);
    }

    /**
     * 镜像翻转图片
     * @param bitmap
     * @Return
     */
    public static Bitmap getFlipBitmap(Bitmap bitmap) {
        Matrix matrix = new Matrix();
        matrix.setScale(-1, 1);
        matrix.postTranslate(bitmap.getWidth(), 0);
        return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(),
                bitmap.getHeight(), matrix, false);
    }
}

layout如下：

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.cgfay.camerasample.CameraSurfaceViewActivity">

    <FrameLayout
        android:id="@+id/layout_aspect"
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

    </FrameLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        android:layout_gravity="bottom"
        android:gravity="center">
        <Button
            android:id="@+id/btn_take"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="拍照" />

        <Button
            android:id="@+id/btn_switch"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="切换相机" />
    </LinearLayout>

</FrameLayout>

至此，通过SurfaceView + Camera API 预览拍照功能已经实现。

备注

Camera API 在打开相机是在哪个线程，那么onPreviewFrame回调执行就在哪个线程。

因此，如果要通过onPreviewFrame回调使用预览数据，则可以通过HandlerThread 异步调用Camera进行操作。样会阻塞Camera，无法获取新的Frame，导致帧率下降。

关注微信公众号【纸上浅谈】，阅读更多音视频、Camera、OpenGL、NDK 开发相关文章~~~

640?wx_fmt=gif

音视频开发进阶
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android Camera 预览镜像（使用 surfaceView 实现）
mbrose的博客
05-02 1万+
该方法是从opencv的java接口中学得 不知道为什么，最后显示出来的效果基本不能用（卡顿） 效果如下： 主要思想： 将Camera.PreviewCallback获得的 实时数据byte[] 数组，显示到Surfaceview上（双缓冲，子线程画图），这样就可以在即将预览的数据做镜像处理； 问题描述： 一般情况下 我们会直接使用 camera.setPreviewDisp...
Surfaceview调用Camera实现拍照
未来~超越自己
08-22 7462
一、Surfaceview的使用        surfaceView的使用主要有三步：继承SurfaceView；获取SurfaceViewHolder；应用Holder更新展示内容。Surfaceview的应用有常用类型及数据展示的Demo。        拍照功能实现思路： 1，依据布局，获取Surfaceview对象； 2，获取Holder对象并设置属性； 3，绑定Surface
CameraSurfaceView——Android Camera使用详解
u012874222的博客
04-22 6182
本篇文章将围绕自定义控件——CameraSurfaceView来阐述Android Camera（非Camera2，因为Camera2只适应5.0+的安卓系统，而目前5.0以下还是大部分，所以当前的主流还是Camera）的使用详解，首先先介绍下CameraSurfaceView，这是一个集拍照，录像，闪光灯，摄像头切换，前后台切换，自适应横竖屏于一体的SurfaceView，而我们平常使用Came
Android利用SurfaceView显示Camera图像爬坑记（二）
Misdirection_XG的博客
04-18 419
前一章《[Android利用SurfaceView显示Camera图像爬坑记（一）我们已经实现了利用SurfaceView将Camera中的实时帧图像显示出来了，我们做这个的主要目录是想把每一帧的数据取出后通过OpenCV图像处理后，再实时显示出处理后的图像。要实现这个情况，我们首先要把Camera的实时数据存成Bitbmp的图像然后通过自己的处理显示出来，接下来我们就看看怎么样把Camera的实时图像都通过Bitbmp的方式显示出来。
安卓surfaceview的使用方式
最新发布
Makenna's World
05-08 1792
surfaceview内部机制和外部层次结构在安卓开发中，我们经常会遇到一些需要高性能、高帧率、高画质的应用场景，例如视频播放、游戏开发、相机预览等。这些场景中，我们需要直接操作图像数据，并且实时地显示到屏幕上。view组件是在主线程中进行绘制的，如果绘制过程耗时过长或者频繁刷新，可能会导致主线程阻塞，影响用户交互和界面响应。view组件在绘制时没有使用双缓冲机制，也就是说每次绘制都是直接在屏幕上进行的，这可能会导致绘制过程中出现闪烁或者撕裂的现象。
Android Camera2使用SurfaceView进行简单预览和绘制
wulileaf的博客
03-22 4636
最近项目上需要在相机上做些开发，之前对这块不是很了解，就学习下，这里使用的Camera2进行开发测试调试的手机是vivo Y9s(Andrioid9.0) 下面是主要流程步骤 检测是否有相机设备 检测相关相机权限 开启线程打开相机(>=21和<21) 预览过程 简单绘制 其中预览过程最为复杂或者需要下功夫去了解下的。 // 检测手机是否有摄像头 presenceCamera = checkCameraHardware(Camera.this);
自定义Camera系列之：SurfaceView + Camera
热门推荐
阿飞的博客
12-25 1万+
一、前言 之前一直想把 Camera 系列的写一下，拖了很久，现在慢慢填坑吧。 首先介绍 SurfaceView + Camera 的组合。虽然从 Android 5.0 后推荐使用 Camera2 了，不过某些旧工程或者需要适配低版本的场景还是用得着旧的 Camer API 的。 为什么选择 SurfaceView ？ SurfaceView 在自己独立的线程中绘制，不会影响到主线程，内部使用双...
android自定义拍照界面SurfaceView+Camera
qq_28653073的博客
05-04 1379
前言： 在android开发中intent启动系统默认相机就能解决打不分的需求。但是对于一些有特殊要求的app，我们就需要自己实现一个拍照页面了。 其中重要知识点： SurfaceView：用来显示拍照前预览的图像，使用方法让Activity继承SurfaceHolder.Callback接口，并实现他的三个方法（surfaceCreated，surfaceCreated和surfaceDe...
android camera mirror 使用SurfaceView自定义相机视频实现预览时左右镜像，实现镜子效果
02-07
android camera mirror 前置后置相机视频预览时左右镜像，实现镜子效果 基于以下网址实现的android studio项目源代码包，可以直接打开使用 https://blog.csdn.net/mbrose/article/details/80167781 代码做了一...
Android圆形相机预览窗口，圆形SurfaceView
03-24
SurfaceView是Android系统提供的一种用于显示多媒体数据（如视频或相机预览）的视图组件。它拥有自己的Surface，可以直接与硬件进行交互，从而提供流畅的动画和低延迟的视频播放。SurfaceView通常用于处理高性能的...
Android 无预览拍照功能
08-28
在 Android 中实现无预览拍照功能需要使用 Camera 类和 SurfaceView 类。Camera 类提供了拍照的相关方法，而 SurfaceView 类提供了预览拍照的界面。为了实现无预览拍照功能，我们需要在后台创建一个 SurfaceView ...
surfaceView +camera2 实现拍照功能
03-15
最近公司有眼镜个人脸识别产品，需要安卓开发，网上找了找代码实现基于surfaceView +camera2 拍照功能
android camera2实现实时预览和拍照
03-07
本文将深入探讨如何使用`Android Studio`和`Camera2` API来实现实时预览以及拍照功能，并将照片以`.fpg`格式保存到手机中。 首先，我们需要在`build.gradle`文件中添加必要的依赖项，确保项目可以使用`Camera2` API...
Android+Camera+SurfaceView自定义相机系列（一）
hequnwang10的博客
01-02 1850
本文主要介绍如何使用camera+surfaceview来自定义相机，我们使用自定义相机进行拍照、扫描二维码等等。Camera是属于硬件部分，在开发中会经常遇到如何使用相机。在上一篇文章中介绍了如何动态的申请权限，使用相机是需要动态申请权限的。 根据官方文档介绍在拍摄照片时，用户通常要先看到拍摄目标的预览效果，然后再按下快门。为此，您可以使用SurfaceView绘制摄像头传感器需要...
Camera+SurfaceView拍照和视频录制
搬砖路上的博客
11-18 1120
1、拍照 和 视频录制效果 获取相机实例 /** * 获取相机实例 */ camera = Camera.open(); 获取相机参数和配置参数 Camera.Parameters params = camera.getParameters(); /**获取所有支持预览的分辨率*/ List<Camera.Size> supp.
android-使用Camera+SurfaceView打开摄像头(一)
九千行代码的博客
04-01 317
使用Camera+SurfaceView打开摄像头
Android 使用SurfaceView加载相机预览界面
Smile乾的博客
06-17 2125
使用SurfaceView加载相机预览界面 1，添加相机权限 <uses-permission android:name="android.permission.CAMERA" /> 2，页面布局，因为我项目需要的是一个扫描页面，所以我在底布局下填充了一个SurfaceView <SurfaceView android:id="@+id/mSurfaceView" android:layout_width="match_parent"
android-使用Camera2+SurfaceView打开摄像头(二)
九千行代码的博客
04-01 989
使用Camera2打开相机,所有逻辑封装在CameraView自定义控件,使用方式直接调用即可。过时的Camera打开相机可以参考文章(android-使用Camera+SurfaceView打开摄像头(一))
Android Camera+SurfaceView实现自定义拍照
u012964281的专栏
11-15 7909
对Activity强制横屏，保证预览方向正确。使用OrientationEventListener监听设备方向，判断竖拍时，旋转照片后再保存，保证竖拍时预览图片和保存后的图片方向一致。       运行效果：                       代码： TestCameraActivity.java package com.example.testcamera;
Android camera api 预览
04-01
Android相机API预览是一种将相机捕捉的内容显示在屏幕上的功能。它允许开发人员通过Android设备的相机硬件获取视频数据，并将其实时显示在应用程序的屏幕上。相机预览是实时的，因此用户可以在拍照或录像前查看他们所拍摄的内容。在Android中，相机预览由CameraPreview类处理。该类使用SurfaceView来显示相机捕获的视频数据。开发人员可以通过这个类来实现自定义的相机预览功能，以满足应用程序的需求。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值