Android Camera原理之openCamera模块(二)

最新推荐文章于 2022-07-19 15:26:17 发布
最新推荐文章于 2022-07-19 15:26:17 发布
阅读量960 收藏 1
点赞数
文章标签： 移动开发
原文链接：https://my.oschina.net/u/920274/blog/3078087
版权

在上一篇文章《Android Camera原理之openCamera模块(一)》我们主要介绍了openCamera的调用流程以及camera模块涉及到的4个层次之间的调用关系，但是一些细节问题并没有阐释到，本文我们补充一下细节问题，力求丰满整个openCamera模块的知识体系。
在《Android Camera模块解析之拍照》一文中谈到了调用openCamera方法：

manager.openCamera(mCameraId, mStateCallback, mBackgroundHandler);

这个manager就是CameraManager实例，openCamera方法上一篇文章已经介绍地比较清楚了，但是第二个参数mStateCallback没有深入讲解，大家只知道是一个相机状态的回调，但是这个状态很重要。这个状态回调会告知开发者当前的camera处于什么状态，在确切获得这个状态之后，才能进行下一步的操作。例如我打开camera是成功还是失败了，如果不知道的话是不能进行下一步的操作的。

    private final CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() {

        @Override
        public void onOpened(@NonNull CameraDevice cameraDevice) {
            // This method is called when the camera is opened.  We start camera preview here.
            mCameraOpenCloseLock.release();
            mCameraDevice = cameraDevice;
            createCameraPreviewSession();
        }

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

        @Override
        public void onError(@NonNull CameraDevice cameraDevice, int error) {
            mCameraOpenCloseLock.release();
            cameraDevice.close();
            mCameraDevice = null;
            Activity activity = getActivity();
            if (null != activity) {
                activity.finish();
            }
        }

    };

本文想搞清楚的一点是：Camera状态是如何回调的？
由于上一篇openCamera的文章已经谈到了详细的调用流程，这里不会赘述了。

1.openCameraDeviceUserAsync中StateCallback

openCamera会调用到openCameraDeviceUserAsync(...)中，当然也会把它的StateCallback参数传进来，这个参数和获取到的CameraCharacteristics一起传入CameraDeviceImpl的构造函数中。

android.hardware.camera2.impl.CameraDeviceImpl deviceImpl =
                    new android.hardware.camera2.impl.CameraDeviceImpl(
                        cameraId,
                        callback,
                        executor,
                        characteristics,
                        mContext.getApplicationInfo().targetSdkVersion);

但是传入cameraService的回调参数却不是这个回调，看一下代码：

ICameraDeviceCallbacks callbacks = deviceImpl.getCallbacks();
//......
cameraUser = cameraService.connectDevice(callbacks, cameraId,
                            mContext.getOpPackageName(), uid);

这个callbacks是CameraDeviceImpl实例中的参数，那么这个callbacks和我们传入的StateCallback有什么关系了，还是要去CameraDeviceImpl看一下。

    public CameraDeviceImpl(String cameraId, StateCallback callback, Executor executor,
                        CameraCharacteristics characteristics, int appTargetSdkVersion) {
        if (cameraId == null || callback == null || executor == null || characteristics == null) {
            throw new IllegalArgumentException("Null argument given");
        }
        mCameraId = cameraId;
        mDeviceCallback = callback;
        mDeviceExecutor = executor;
        mCharacteristics = characteristics;
        mAppTargetSdkVersion = appTargetSdkVersion;

        final int MAX_TAG_LEN = 23;
        String tag = String.format("CameraDevice-JV-%s", mCameraId);
        if (tag.length() > MAX_TAG_LEN) {
            tag = tag.substring(0, MAX_TAG_LEN);
        }
        TAG = tag;

        Integer partialCount =
                mCharacteristics.get(CameraCharacteristics.REQUEST_PARTIAL_RESULT_COUNT);
        if (partialCount == null) {
            // 1 means partial result is not supported.
            mTotalPartialCount = 1;
        } else {
            mTotalPartialCount = partialCount;
        }
    }
  • 构造函数中传入的StateCallback赋给了CameraDeviceImpl中的mDeviceCallback
    private final CameraDeviceCallbacks mCallbacks = new CameraDeviceCallbacks();
    public CameraDeviceCallbacks getCallbacks() {
        return mCallbacks;
    }
    public class CameraDeviceCallbacks extends ICameraDeviceCallbacks.Stub {
    //......
    }
  • CameraDeviceCallbacks继承ICameraDeviceCallbacks.Stub，而ICameraDeviceCallbacks.Stub是可以在Binder IPC中传输的对象，很显然这个才是应用程序与CameraService通信的回调，在这个回调中的执行方法标识当前的camera的执行状态
2.CameraDeviceCallbacks回调

ICameraDeviceCallbacks.aidl自动生成的android/hardware/camera2/ICameraDeviceCallbacks.h文件

class ICameraDeviceCallbacksDefault : public ICameraDeviceCallbacks {
public:
  ::android::IBinder* onAsBinder() override;
  ::android::binder::Status onDeviceError(int32_t errorCode, const ::android::hardware::camera2::impl::CaptureResultExtras& resultExtras) override;
  ::android::binder::Status onDeviceIdle() override;
  ::android::binder::Status onCaptureStarted(const ::android::hardware::camera2::impl::CaptureResultExtras& resultExtras, int64_t timestamp) override;
  ::android::binder::Status onResultReceived(const ::android::hardware::camera2::impl::CameraMetadataNative& result, const ::android::hardware::camera2::impl::CaptureResultExtras& resultExtras, const ::std::vector<::android::hardware::camera2::impl::PhysicalCaptureResultInfo>& physicalCaptureResultInfos) override;
  ::android::binder::Status onPrepared(int32_t streamId) override;
  ::android::binder::Status onRepeatingRequestError(int64_t lastFrameNumber, int32_t repeatingRequestId) override;
  ::android::binder::Status onRequestQueueEmpty() override;

};

这个回调函数是从CameraService中调上来的。下面的回调包含了Camera执行过程中的各种状态，执行成功、执行失败、数据接收成功等等。这儿暂时不展开描述，等后面capture image的时候会详细阐释。

  • onDeviceError
  • onDeviceIdle
  • onCaptureStarted
  • onResultReceived
  • onPrepared
  • onRepeatingRequestError
  • onRequestQueueEmpty
3.StateCallback回调

StateCallback是openCamera传入的3个参数中的一个，这是一个标识当前camera连接状态的回调。

    public static abstract class StateCallback {
        public static final int ERROR_CAMERA_IN_USE = 1;
        public static final int ERROR_MAX_CAMERAS_IN_USE = 2;
        public static final int ERROR_CAMERA_DISABLED = 3;
        public static final int ERROR_CAMERA_DEVICE = 4;
        public static final int ERROR_CAMERA_SERVICE = 5;

        /** @hide */
        @Retention(RetentionPolicy.SOURCE)
        @IntDef(prefix = {"ERROR_"}, value =
            {ERROR_CAMERA_IN_USE,
             ERROR_MAX_CAMERAS_IN_USE,
             ERROR_CAMERA_DISABLED,
             ERROR_CAMERA_DEVICE,
             ERROR_CAMERA_SERVICE })
        public @interface ErrorCode {};
        public abstract void onOpened(@NonNull CameraDevice camera); // Must implement
        public void onClosed(@NonNull CameraDevice camera) {
            // Default empty implementation
        }
        public abstract void onDisconnected(@NonNull CameraDevice camera); // Must implement
        public abstract void onError(@NonNull CameraDevice camera,
                @ErrorCode int error); // Must implement
    }
  • onOpened回调：
    当前camera device已经被打开了，会触发这个回调。探明camera的状态是opened了，这是可以开始createCaptureSession开始使用camera 捕捉图片或者视频了。

触发onOpened回调的地方在setRemoteDevice(...)，这个函数在connectDevice(...)连接成功之后执行，表明当前的camera device已经连接成功了，触发camera 能够打开的回调。

    public void setRemoteDevice(ICameraDeviceUser remoteDevice) throws CameraAccessException {
        synchronized(mInterfaceLock) {
            // TODO: Move from decorator to direct binder-mediated exceptions
            // If setRemoteFailure already called, do nothing
            if (mInError) return;

            mRemoteDevice = new ICameraDeviceUserWrapper(remoteDevice);

            IBinder remoteDeviceBinder = remoteDevice.asBinder();
            // For legacy camera device, remoteDevice is in the same process, and
            // asBinder returns NULL.
            if (remoteDeviceBinder != null) {
                try {
                    remoteDeviceBinder.linkToDeath(this, /*flag*/ 0);
                } catch (RemoteException e) {
                    CameraDeviceImpl.this.mDeviceExecutor.execute(mCallOnDisconnected);

                    throw new CameraAccessException(CameraAccessException.CAMERA_DISCONNECTED,
                            "The camera device has encountered a serious error");
                }
            }

            mDeviceExecutor.execute(mCallOnOpened);
            mDeviceExecutor.execute(mCallOnUnconfigured);
        }
    }

    private final Runnable mCallOnOpened = new Runnable() {
        @Override
        public void run() {
            StateCallbackKK sessionCallback = null;
            synchronized(mInterfaceLock) {
                if (mRemoteDevice == null) return; // Camera already closed

                sessionCallback = mSessionStateCallback;
            }
            if (sessionCallback != null) {
                sessionCallback.onOpened(CameraDeviceImpl.this);
            }
            mDeviceCallback.onOpened(CameraDeviceImpl.this);
        }
    };
  • onClosed回调：
    camera device已经被关闭，这个回调被触发。一般是终端开发者closeCamera的时候会释放当前持有的camera device，这是正常的现象。
    public void close() {
        synchronized (mInterfaceLock) {
            if (mClosing.getAndSet(true)) {
                return;
            }

            if (mRemoteDevice != null) {
                mRemoteDevice.disconnect();
                mRemoteDevice.unlinkToDeath(this, /*flags*/0);
            }
            if (mRemoteDevice != null || mInError) {
                mDeviceExecutor.execute(mCallOnClosed);
            }

            mRemoteDevice = null;
        }
    }
    private final Runnable mCallOnClosed = new Runnable() {
        private boolean mClosedOnce = false;

        @Override
        public void run() {
            if (mClosedOnce) {
                throw new AssertionError("Don't post #onClosed more than once");
            }
            StateCallbackKK sessionCallback = null;
            synchronized(mInterfaceLock) {
                sessionCallback = mSessionStateCallback;
            }
            if (sessionCallback != null) {
                sessionCallback.onClosed(CameraDeviceImpl.this);
            }
            mDeviceCallback.onClosed(CameraDeviceImpl.this);
            mClosedOnce = true;
        }
    };
  • onDisconnected回调：
    camera device不再可用，打开camera device失败了，一般是因为权限或者安全策略问题导致camera device打不开。一旦连接camera device出现ERROR_CAMERA_DISCONNECTED问题了，这是函数就会被回调，表示当前camera device处于断开的状态。
  • onError回调：
    调用camera device的时候出现了严重的问题。执行CameraService-->connectDevice 出现异常了
            } catch (ServiceSpecificException e) {
                if (e.errorCode == ICameraService.ERROR_DEPRECATED_HAL) {
                    throw new AssertionError("Should've gone down the shim path");
                } else if (e.errorCode == ICameraService.ERROR_CAMERA_IN_USE ||
                        e.errorCode == ICameraService.ERROR_MAX_CAMERAS_IN_USE ||
                        e.errorCode == ICameraService.ERROR_DISABLED ||
                        e.errorCode == ICameraService.ERROR_DISCONNECTED ||
                        e.errorCode == ICameraService.ERROR_INVALID_OPERATION) {
                    // Received one of the known connection errors
                    // The remote camera device cannot be connected to, so
                    // set the local camera to the startup error state
                    deviceImpl.setRemoteFailure(e);

                    if (e.errorCode == ICameraService.ERROR_DISABLED ||
                            e.errorCode == ICameraService.ERROR_DISCONNECTED ||
                            e.errorCode == ICameraService.ERROR_CAMERA_IN_USE) {
                        // Per API docs, these failures call onError and throw
                        throwAsPublicException(e);
                    }
                } else {
                    // Unexpected failure - rethrow
                    throwAsPublicException(e);
                }
            } catch (RemoteException e) {
                // Camera service died - act as if it's a CAMERA_DISCONNECTED case
                ServiceSpecificException sse = new ServiceSpecificException(
                    ICameraService.ERROR_DISCONNECTED,
                    "Camera service is currently unavailable");
                deviceImpl.setRemoteFailure(sse);
                throwAsPublicException(sse);
            }

deviceImpl.setRemoteFailure(e);是执行onError回调的函数。

小结

Camera的知识点非常多，我们从openCamera讲起，也是希望从代码实践中真正了解camera的调用流程，由浅入深的学习camera知识。下面我们会继续讲解连接成功之后，也就是StateCallback-->onOpened回调中camera会如何操作。敬请期待，不足之处，敬请谅解。

 

转载于:https://my.oschina.net/u/920274/blog/3078087

chuotao1354
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2024年Android最全Camera功耗分析和拆解，2024年最新android 线程面试题
2401_84545618的博客
05-04 543
希望大家能有一个好心态，想进什么样的公司要想清楚，并不一定是大公司，我选的也不是特大厂。当然如果你不知道选或是没有规划，那就选大公司！希望我们能先选好想去的公司再投或内推，而不是有一个公司要我我就去！还有就是不要害怕，也不要有压力，平常心对待就行，但准备要充足。最后希望大家都能拿到一份满意的 offer！如果目前有一份工作也请好好珍惜好好努力，找工作其实挺累挺辛苦的。这里附上上述的面试题相关的几十套字节跳动，京东，小米，腾讯、头条、阿里、美团等公司19年的面试题。
opencamera-for-android：android美颜相机
02-04
开放式摄像头 opencamera是一套高性能的相机框架，基于opengles + glsurfaceview，能够实现实时滤镜，拍摄，录制短视频，美颜磨皮等功能。 效果图 已实现功能 1.拍照2.录视频3.美颜，滤镜 开发计划 1.加入CameraX Api 2.将glsurfaceview变成自定义的textureview渲染3.离线渲染4.将opengl java部分的代码变成可移植的c库，方便ios上的移植。 集成和使用 版本号 allprojects { repositories { .. . maven { url ' https://ww
Android Camera原理之openCamera模块(一)
07-23 934
我们平时开发，知道怎么调度api，怎么调起camera，怎么调用camera的实例来操作camera就可以了，但是这些调度的背后都做了什么事情，我们可能不太清楚，本文打算从openCamera这个调用谈起，展开说下camera调起之后底层是怎么工作的？ Camera操作过程中最重要的四个步骤...
Camera2 openCamera 流程分析
ltc_666的博客
04-01 5689
文章目录一、相机架构二、应用框架1.Camera APP2.AIDL3.原生框架4.binder IPC 接口5.相机服务6.HAL三、流程分析1.openCamera 一、相机架构 （详细资料参见：https://source.android.google.cn/devices/camera） 二、应用框架 1.Camera APP 应用代码位于应用框架级别，它使用 Camera 2 API 与相机硬件进行互动。在内部，此代码会调用相应的 Binder 接口，以访问与相机互动的原生代码。 2.AIDL
Andriod Camera之Open Camera
wk314061331的博客
07-19 1333
Hal层必须要去实作这些Interface，这部分是由各个厂商（比如MTK、高通）的去实作的，因此不同厂商的平台在这部分是会有差异的，这里就不细讲了。这个callback参数是一个回调对象，用来接收这个CameraDevice的状态变化情况的，这个回调对象里有提供几个回调函数（onOpened()、onClosed()、onError()、onDisconnected()），APP必须要去实作这些方法，以便于底层的CameraDevice切到对应的状态后，APP能够做出对应的反应。...
Android Camera API --openCamera
hugang的博客
10-24 2603
预览，拍照，录像的size和format选取
open camera Android 源码 适配Android Studio
06-19
文件名"opencamera"很可能是指Open Camera项目的根目录，其中包含了整个项目的源代码、资源文件、构建脚本和其他相关文件。通常，一个Android Studio项目会包含以下几个关键部分： 1. `build.gradle`：定义项目的...
OpenCamera.zipOpenCamera.zip
03-02
OpenCamera是一款开源的Android相机应用，它提供了许多高级功能，如手动对焦、曝光控制、白平衡调整等，为摄影爱好者和开发者提供了更多的拍摄自由度。这个zip文件可能包含了OpenCamera项目的源代码、构建文件以及...
opencamera
05-23
二、OpenCamera功能实现 2.1 实时预览 OpenCamera通过SurfaceView或者TextureView实现相机画面的实时预览，通过SurfaceHolder回调方法控制预览帧的更新。 2.2 图像捕获 在拍照功能中，OpenCamera利用Android的...
OpenCamera:Android相机工具
04-14
Android Camera API :right_arrow: Android后置摄像头 Android前置摄像头 Android Camera2 API :right_arrow: Android后置摄像头 Android前置摄像头 UVCCamera API :right_arrow: Android UVC相机1 Android UVC...
android的hal层下的camera的实现
07-10
- Android Camera HAL通常包含多个模块，如Camera Service、Camera Provider、Camera Client等。Camera Service是管理所有camera设备的服务，负责设备的打开、关闭、配置等操作。Camera Provider作为服务的管理者，...
Android Camera2架构-OpenCamera2流程android.hardware.camera2.CameraManager(1)
01-03
关于打开相机的openCamera流程参考： Android P Camera2架构-OpenCamera2流程Frameworks层到HAL层(1) 简单介绍新架构右半部分android.hardware.camera2.CameraManager CameraManager的继承关系： 源码路径： frameworks\base\core\java\android\hardware\camera2\CameraManager.java 谷歌原文解释： A system service manager for detecting, characterizing, and connecti
android8 Open Camera2
转载和创作优秀的博客
12-06 2037
文件CameraManager.java 入手 private CameraDevice openCameraDeviceUserAsync(String cameraId, CameraDevice.StateCallback callback, Handler handler, final int uid) throws CameraAccessException { CameraCharacteristics character...
Android 8.0系统源码分析--openCamera（HAL）启动过程源码分析（转载）
qq_42538455的博客
06-16 517
openCamera HAL
[Android P]OpenCamera详细分析(Camera2+Hal3)
u012906122的专栏
10-23 8781
因为工作涉及到Android Camera系统的问题，本文就整理了在Android P上讲解OpenCamera比较详细的文章，结合Andriod P源码，以架构图、UML顺序图、UML类图和关键代码走读的方式，从App层、Framework层、Hal层详细分析了OpenCamera的流程。如有分析的不对的地方，欢迎大家指正~ 注意：Camera系统架构采用Camera2+Hal3。 参考博客： Android Camera2+HAL3架构_既不是天才，便做那疯子！-CSDN博客 [A
Android openCamera流程
chengwei_peng
08-16 7511
了解android open camera流程是怎样的
Android camera open 流程
你好呀，信田君！
06-21 2573
从 Application 连接到 CameraService，这涉及到 Android 架构中的三个层次：App 层，Framework 层，Runtime 层。 其中，App 层直接调用 Framework 层所封装的方法，而 Framework 层需要通过 Binder 远程调用 Runtime 中 CameraService 的函数。 （https://blog.csdn.net/qq_16775897/article/details/81537710）APP： mCameraManager.o
Android Camera2 openCamera流程详解(1)
weixin_41678668的博客
05-19 1533
本文用Android 11 的代码进行梳理。 Android Camera2 open Camera的接口为CameraManager的openCamera函数，如下： frameworks/base/core/java/android/hardware/camera2/CameraManager.java 648 @RequiresPermission(android.Manifest.permission.CAMERA) 649 public void openCamera(@Non
android camera 工作原理,Android Camera原理之openCamera模块(一)
weixin_30446557的博客
05-26 550
我们平时开发，知道怎么调度api，怎么调起camera，怎么调用camera的实例来操作camera就可以了，但是这些调度的背后都做了什么事情，我们可能不太清楚，本文打算从openCamera这个调用谈起，展开说下camera调起之后底层是怎么工作的？Camera操作过程中最重要的四个步骤：CameraManager-->openCamera ---> 打开相机CameraDevi...
Android开发学习之Camera
最新发布
06-10
好的，很高兴回答你关于Android开发中的相机(Camera)学习问题。在Android开发中，相机是一个非常常见的模块，因此学习如何使用相机是非常重要的一部分。 首先，你需要在AndroidManifest.xml中声明相机权限： ```xml <uses-permission android:name="android.permission.CAMERA" /> ``` 接着，在你的Activity中，你需要获取相机的实例并启动预览： ```java private Camera mCamera; private void startCameraPreview() { try { mCamera = Camera.open(); Camera.Parameters parameters = mCamera.getParameters(); // 设置相关参数 mCamera.setParameters(parameters); // 设置预览SurfaceView mCamera.setPreviewDisplay(mSurfaceView.getHolder()); // 开启预览 mCamera.startPreview(); } catch (IOException e) { Log.e(TAG, "Error while setting camera preview", e); } } ``` 上面的代码中，我们首先获取系统相机的实例，然后获取相机参数，并设置相关参数。接着，我们将预览SurfaceView和相机绑定，最后开启预览。 当你完成相机预览后，你就可以使用相机拍照了。以下是拍照的示例代码： ```java private void takePicture() { mCamera.takePicture(null, null, new Camera.PictureCallback() { @Override public void onPictureTaken(byte[] data, Camera camera) { // 处理拍照后的数据 } }); } ``` 当你调用`takePicture()`方法时，相机会拍摄一张照片，并通过PictureCallback返回照片的数据。你可以将数据保存到文件中，或者进行进一步的处理，比如将照片显示在ImageView中。 以上就是Android开发中相机的基本使用方法。当然，相机的功能还有很多，你可以尝试更多的参数设置和拍照处理，来发掘相机的更多特性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值