Android openCamera流程

最新推荐文章于 2024-05-16 07:16:14 发布
最新推荐文章于 2024-05-16 07:16:14 发布
阅读量7.4k 收藏 46
点赞数 7
分类专栏： camera Android 文章标签： android camera frameworks
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41944449/article/details/99684653
版权

从 Application 连接到 CameraService，这涉及到 Android 架构中的三个层次：APP 层，frameworks 层，Runtime 层。 其中，APP 层直接调用 frameworks 层所封装的方法，而 frameworks 层需要通过 Binder 远程调用 Runtime 中 CameraService 的函数。

下面以 android P 开始跟踪代码。

从APP到CameraService

这部分主要的调用逻辑如下图所示（图片来源 StoneDemo CSDN博客）。
图片来源 StoneDemo CSDN博客

APP

在应用中使用camera，将需要创建 CameraManager 对象实例，而后通过 CameraManager::openCamera() 打开camera设备。

openCamera(String cameraId, final CameraDevice.StateCallback callback, Handler handler)

其中：

  • cameraId 是需要打开的camera设备
  • callback 是camera设备状态的回调
  • handler 是回调函数需要使用的 Handler

frameworks

CameraManager

文件路径：android/frameworks/base/core/java/android/hardware/camera2/CameraManager.java

通过 CameraManager::openCamera() 方法可以知道，最终也将是调用 openCameraDeviceUserAsync(cameraId, callback, executor, clientUid) 方法，其中 clientUid 为 USE_CALLING_UID。

    private CameraDevice openCameraDeviceUserAsync(String cameraId,
            CameraDevice.StateCallback callback, Executor executor, final int uid)
            throws CameraAccessException {
        CameraCharacteristics characteristics = getCameraCharacteristics(cameraId);
        CameraDevice device = null;

        synchronized (mLock) {

            ICameraDeviceUser cameraUser = null;

            /* 实例化CameraDeviceImpl，该对象的构造函数将保存参数信息 */
            android.hardware.camera2.impl.CameraDeviceImpl deviceImpl =
                    new android.hardware.camera2.impl.CameraDeviceImpl(
                        cameraId,
                        callback,
                        executor,
                        characteristics,
                        mContext.getApplicationInfo().targetSdkVersion);

            /* CameraDeviceImpl 对象包含的 CameraDeviceCallbacks 实例，
             * 每个 CameraDeviceImpl 都将创建一个 CameraDeviceCallbacks,
             * 这是提供给远端连接到 CameraDeviceImpl 的接口
             */
            ICameraDeviceCallbacks callbacks = deviceImpl.getCallbacks();

            try {
                /* 根据 API1/API2 进行不同的区分，以API2进行跟踪 */
                if (supportsCamera2ApiLocked(cameraId)) {
                    // Use cameraservice's cameradeviceclient implementation for HAL3.2+ devices
                    /* 通过同一文件的 CameraManagerGlobal 类方法获得CameraService代理。
                     * 实际上是通过ServiceManager获得"media.camera" 的
                     * CameraService Binder代理，然后转变为ICameraService
                     */
                    ICameraService cameraService = CameraManagerGlobal.get().getCameraService();
                    if (cameraService == null) {
                        throw new ServiceSpecificException(
                            ICameraService.ERROR_DISCONNECTED,
                            "Camera service is currently unavailable");
                    }
                    /* 通过 ICameraService::connectDevice() 连接设备，
                     * 返回的 cameraUser 实际上指向的是远端 CameraDeviceClient
                     * 的本地接口
                     */
                    cameraUser = cameraService.connectDevice(callbacks, cameraId,
                            mContext.getOpPackageName(), uid);
                } else {
                    // Use legacy camera implementation for HAL1 devices
                    ...
                }
            } catch (ServiceSpecificException e) {
                ...
            }

            // TODO: factor out callback to be non-nested, then move setter to constructor
            // For now, calling setRemoteDevice will fire initial
            // onOpened/onUnconfigured callbacks.
            // This function call may post onDisconnected and throw CAMERA_DISCONNECTED if
            // cameraUser dies during setup.
            /* 将 CameraDeviceClient 设置到 CameraDeviceImpl 中进行管理 */
            deviceImpl.setRemoteDevice(cameraUser);
            device = deviceImpl;
        }

        return device;
    }
CameraDeviceImpl

文件路径：android/frameworks/base/core/java/android/hardware/camera2/impl/CameraDeviceImpl.java

    /**
     * Set remote device, which triggers initial onOpened/onUnconfigured callbacks
     *
     * <p>This function may post onDisconnected and throw CAMERA_DISCONNECTED if remoteDevice dies
     * during setup.</p>
     *
     */
    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();
            ...

            /* 将会触发 onOpened 和 onUnconfigured 这两个回调，
             * 这两个回调是在创建 CameraDeviceImpl 实例对象时传递
             * 进来的callback，而该callback只是APP在调用 openCamera()
             * 时传递进来的，应用一般实现为开启预览等操作
             */
            mDeviceExecutor.execute(mCallOnOpened);
            mDeviceExecutor.execute(mCallOnUnconfigured);
        }
    }
CameraService

文件路径：android/frameworks/av/services/camera/libcameraservice/CameraService.cpp

在调用 cameraService.connectDevice(callbacks, cameraId, mContext.getOpPackageName(), uid) 时，最终将会调用到 CameraService.cpp 中的 connectDevice() 函数。而在 connectDevice() 函数中，connectHelper() 才是真正的逻辑实现，此时设定的模板类型是 <hardware::camera2::ICameraDeviceCallbacks,CameraDeviceClient>。

Status CameraService::connectDevice(
        const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb,
        const String16& cameraId,
        const String16& clientPackageName,
        int clientUid,
        /*out*/
        sp<hardware::camera2::ICameraDeviceUser>* device) {

    ATRACE_CALL();
    Status ret = Status::ok();
    String8 id = String8(cameraId);
    sp<CameraDeviceClient> client = nullptr;
    ret = connectHelper<hardware::camera2::ICameraDeviceCallbacks,CameraDeviceClient>(cameraCb, id,
            /*api1CameraId*/-1,
            CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName,
            clientUid, USE_CALLING_PID, API_2,
            /*legacyMode*/ false, /*shimUpdateOnly*/ false,
            /*out*/client);

    ...

    *device = client;
    return ret;
}

template<class CALLBACK, class CLIENT>
Status CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,
        int api1CameraId, int halVersion, const String16& clientPackageName, int clientUid,
        int clientPid, apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly,
        /*out*/sp<CLIENT>& device) {
    binder::Status ret = binder::Status::ok();

    String8 clientName8(clientPackageName);

    ...

    sp<CLIENT> client = nullptr;
    {
        ...

        sp<BasicClient> tmp = nullptr;
        /* makeClient() 将会根据API版本以及HAL版本选择生成具体的 Client 实例 */
        if(!(ret = makeClient(this, cameraCb, clientPackageName,
                cameraId, api1CameraId, facing,
                clientPid, clientUid, getpid(), legacyMode,
                halVersion, deviceVersion, effectiveApiLevel,
                /*out*/&tmp)).isOk()) {
            return ret;
        }
        client = static_cast<CLIENT*>(tmp.get());

        ...

        /* client 进行初始化工作
         * 注意这里的参数，mCameraProviderManager 是 CameraService 运行起来时，
         * 第一次强指针引用从而调用 onFirstRef() 函数创建的 CameraProviderManager
         * 实例对象，它保存了 CameraProvider 信息，待会再详细分析
         */    
        err = client->initialize(mCameraProviderManager, mMonitorTags);
        ...
    } // lock is destroyed, allow further connect calls

    // Important: release the mutex here so the client can call back into the service from its
    // destructor (can be at the end of the call)
    device = client;
    return ret;
}

Status CameraService::makeClient(const sp<CameraService>& cameraService,
        const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId,
        int api1CameraId, int facing, int clientPid, uid_t clientUid, int servicePid,
        bool legacyMode, int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
        /*out*/sp<BasicClient>* client) {

    if (halVersion < 0 || halVersion == deviceVersion) {
        // Default path: HAL version is unspecified by caller, create CameraClient
        // based on device version reported by the HAL.
        switch(deviceVersion) {
          /* CAMERA_DEVICE_API_VERSION_1_0 只能使用 API1 */
          case CAMERA_DEVICE_API_VERSION_1_0:
            ...
            break;
          case CAMERA_DEVICE_API_VERSION_3_0:
          case CAMERA_DEVICE_API_VERSION_3_1:
          case CAMERA_DEVICE_API_VERSION_3_2:
          case CAMERA_DEVICE_API_VERSION_3_3:
          case CAMERA_DEVICE_API_VERSION_3_4:
            if (effectiveApiLevel == API_1) { // Camera1 API route
                sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
                *client = new Camera2Client(cameraService, tmp, packageName,
                        cameraId, api1CameraId,
                        facing, clientPid, clientUid,
                        servicePid, legacyMode);
            } else { // Camera2 API route
                sp<hardware::camera2::ICameraDeviceCallbacks> tmp =
                        static_cast<hardware::camera2::ICameraDeviceCallbacks*>(cameraCb.get());
                /* API2 HAL3 将会通过 CameraDeviceClient() 创建 client，
                 * 这一 client 最终返回到 CameraDeviceImpl 实例，被保存在 mRemoteDevice
                 */
                *client = new CameraDeviceClient(cameraService, tmp, packageName, cameraId,
                        facing, clientPid, clientUid, servicePid);
            }
            break;
          default:
            // Should not be reachable
            ...
        }
    } else {
        // A particular HAL version is requested by caller. Create CameraClient
        // based on the requested HAL version.
        ...
    }
    return Status::ok();
}

至此，打开相机流程中，从 App 到 CameraService 的调用逻辑基本上就算走完了。

简图总结

根据上面的流程追踪，我们可以描绘一个比较简单直观的连路框架图，如下（图片来源 StoneDemo CSDN博客）。
其中黑色虚线表示下行（控制）路线，红色虚线表明上行（状态、数据）路线。
图片来源 StoneDemo CSDN博客

从CameraService到CameraProvider

由于 Android O 中加入了 Treble 机制，它带来的一个巨大变化就是将原本的 CameraServer 进程分隔成 CameraServer 与 Provider service 两个进程，它们之间通过 HIDL（一个类似 Binder 的机制）进行通信。
在这种情况下，CameraServer 一端主体为 CameraService，它将会寻找现存的 Provider service，将其加入到内部的 CameraProviderManager 中进行管理，相关操作都是通过远端调用进行的。
而 Provider service 一端的主体为 CameraProvider，它在初始化时就已经连接到 libhardware 的 Camera HAL 实现层，并以 CameraModule 来进行管理。这两个进程的启动以及初始化在系统启动时就已经进行，所以当相机应用运行时，它们的初始化工作已经完成。

CS

CameraDeviceClient

文件路径：android/frameworks/av/services/camera/libcameraservice/api2/CameraDeviceClient.cpp

Camera2ClientBase 的设置模板为 CameraService::BasicClient 。

// Interface used by CameraService

CameraDeviceClient::CameraDeviceClient(const sp<CameraService>& cameraService,
        const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback,
        const String16& clientPackageName,
        const String8& cameraId,
        int cameraFacing,
        int clientPid,
        uid_t clientUid,
        int servicePid) :
    /* 通过构造函数初始化 Camera2ClientBase，在它的
     * 构造函数中，将会创建一个 Camera3Device 实例对象
     */
    Camera2ClientBase(cameraService, remoteCallback, clientPackageName,
                cameraId, /*API1 camera ID*/ -1,
                cameraFacing, clientPid, clientUid, servicePid),
    mInputStream(),
    mStreamingRequestId(REQUEST_ID_NONE),
    mRequestIdCounter(0) {

    ATRACE_CALL();
    ALOGI("CameraDeviceClient %s: Opened", cameraId.string());
}
client->initialize()

回到 CameraService::connectHelper() 函数，在调用 makeClient() 函数之后，将得到相应的client，接着，在 CameraService::connectHelper() 函数进行 client->initialize(mCameraProviderManager, mMonitorTags)，mCameraProviderManager 为 CameraService 保存 CameraProvider 信息的成员变量。

// Camera2ClientBase 的设置模板为 CameraService::BasicClient 
template<typename TProviderPtr>
status_t CameraDeviceClient::initializeImpl(TProviderPtr providerPtr, const String8& monitorTags) {
    ATRACE_CALL();
    status_t res;

    res = Camera2ClientBase::initialize(providerPtr, monitorTags);
    if (res != OK) {
        return res;
    }

    String8 threadName;
    /* 创建 FrameProcessorBase 实例对象，它将负责帧处理 */
    mFrameProcessor = new FrameProcessorBase(mDevice);
    threadName = String8::format("CDU-%s-FrameProc", mCameraIdStr.string());
    /* 创建线程进行获取图像数据 */
    mFrameProcessor->run(threadName.string());

	/* 将 CameraDeviceClient 注册登记到 FrameProcessorBase
	 * 的 mRangeListeners，当帧处理完成时，将会通过它来回调通知APP */
    mFrameProcessor->registerListener(FRAME_PROCESSOR_LISTENER_MIN_ID,
                                      FRAME_PROCESSOR_LISTENER_MAX_ID,
                                      /*listener*/this,
                                      /*sendPartials*/true);
    ...

    return OK;
}

template <typename TClientBase>
template <typename TProviderPtr>
status_t Camera2ClientBase<TClientBase>::initializeImpl(TProviderPtr providerPtr,
        const String8& monitorTags) {
    ...

    // Verify ops permissions
    /* 将调用到 CameraService::BasicClient::startCameraOps() 函数 */
    res = TClientBase::startCameraOps();
    ...

    /* 将调用 Camera3Device::initialize() 函数 */
    res = mDevice->initialize(providerPtr, monitorTags);
    ...

    return OK;
}


TClientBase::startCameraOps()
        |
        |
        |
       \|/
status_t CameraService::BasicClient::startCameraOps() {
    ...
    // Transition device state to OPEN
    /* 这里，将会通过Binder代理，将设备状态更新到远端，这个时候，
     * CameraProvider 管理的device 状态将更新，设备进入 OPEN 状态
     */
    sCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_OPEN,
            mCameraIdStr, mCameraFacing, mClientPackageName, apiLevel);

    return OK;
}


res = mDevice->initialize(providerPtr, monitorTags)
        |
        |
        |
       \|/
status_t Camera3Device::initialize(sp<CameraProviderManager> manager, const String8& monitorTags) {
    ...

    sp<ICameraDeviceSession> session;
    ATRACE_BEGIN("CameraHal::openSession");
    /* 从 CameraProviderManager 的 mProviders 查找对应 id 的 mDevices，
     * 而后调用相对应的 deviceInfo3->mInterface->open()，其中，mInterface
     * 是在CameraProvider adddevice 时，通过DeviceInfo3的构造函数传递进来的，
     * mInterface 最终为
     * android::hardware::camera::device::V3_4::implementation::CameraDevice
     */
    status_t res = manager->openSession(mId.string(), this,
            /*out*/ &session);
    ATRACE_END();
    ...

    /* 获取请求队列 */
    std::shared_ptr<RequestMetadataQueue> queue;
    auto requestQueueRet = session->getCaptureRequestMetadataQueue(
        [&queue](const auto& descriptor) {
            queue = std::make_shared<RequestMetadataQueue>(descriptor);
            if (!queue->isValid() || queue->availableToWrite() <= 0) {
                ALOGE("HAL returns empty request metadata fmq, not use it");
                queue = nullptr;
                // don't use the queue onwards.
            }
        });
    ...

	/* 获取请求结果返回队列 */
    std::unique_ptr<ResultMetadataQueue>& resQueue = mResultMetadataQueue;
    auto resultQueueRet = session->getCaptureResultMetadataQueue(
        [&resQueue](const auto& descriptor) {
            resQueue = std::make_unique<ResultMetadataQueue>(descriptor);
            if (!resQueue->isValid() || resQueue->availableToWrite() <= 0) {
                ALOGE("HAL returns empty result metadata fmq, not use it");
                resQueue = nullptr;
                // Don't use the resQueue onwards.
            }
        });
    ....

    /* 运行相应的队列线程 */
    return initializeCommonLocked();
}

status_t Camera3Device::initializeCommonLocked() {
    /** Start up status tracker thread */
    mStatusTracker = new StatusTracker(this);
    status_t res = mStatusTracker->run(String8::format("C3Dev-%s-Status", mId.string()).string());

	/** Register in-flight map to the status tracker */
    mInFlightStatusId = mStatusTracker->addComponent();
    
    /** Start up request queue thread */
    mRequestThread = new RequestThread(this, mStatusTracker, mInterface, sessionParamKeys);
    res = mRequestThread->run(String8::format("C3Dev-%s-ReqQueue", mId.string()).string());
    
    mPreparerThread = new PreparerThread();
    ...
}

CameraProviderService

CameraDevice

文件路径：android/hardware/interfaces/camera/device/3.4/default/CameraDevice.cpp

CameraDevice 实例对象在初始化 CameraProviderService 之后就存在了，前面说到通过 CameraProviderManager 中的 deviceInfo 接口，调用远端 CameraDevice 实例的 open() 函数。（3.4版本的open函数，将会调用到3.2版本的open函数）

Return<void> CameraDevice::open(const sp<ICameraDeviceCallback>& callback, open_cb _hidl_cb)  {
    Status status = initStatus();
    sp<CameraDeviceSession> session = nullptr;

    ...

    if (status != Status::OK) {
        ...
    } else {
        ...

        /** Open HAL device */
        status_t res;
        camera3_device_t *device;

        ATRACE_BEGIN("camera3->open");
        /* 调用HAL层的 open() 函数 */
        res = mModule->open(mCameraId.c_str(),
                reinterpret_cast<hw_device_t**>(&device));
        ...

        struct camera_info info;
        res = mModule->getCameraInfo(mCameraIdInt, &info);
        ...

        /* 创建session实例对象 */
        session = createSession(
                device, info.static_camera_characteristics, callback);
        ...
        mSession = session;

        ...
        mLock.unlock();
    }
    _hidl_cb(status, session->getInterface());
    return Void();
}

sp<CameraDeviceSession> CameraDevice::createSession(camera3_device_t* device,
        const camera_metadata_t* deviceInfo,
        const sp<ICameraDeviceCallback>& callback) {
    return new CameraDeviceSession(device, deviceInfo, callback);
}

至此，Android open camera的流程操作到相应SOC厂商的camera HAL层，各个平台将会有一些差异，就不再详细的分析。

参考的结构图如下：
在这里插入图片描述
由于自身能力有限，对这一方面的理解还不够透彻，所以很多地方没有说清楚，后续理解了再详细更新，也欢迎各路大佬指点迷津，感谢！

参考文章

在了解学习android camera的过程中，参考了网上很多的优秀文章，感谢！

StoneDemo [Android O] HAL3 之 Open Camera2 流程（一）—— 从 App 到 CameraService

StoneDemo [Android O] HAL3 之 Open Camera2 流程（二）—— 从 CameraService 到 HAL Service

StoneDemo [Android O] HAL3 之 Open Camera2 流程（三，完结）—— 从 HAL Service 到 Camera HAL

chengwei_peng
关注
  • 7
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Camera2完整流程分析一】从Log角度跟踪分析原生Camera2摄像机Open（打开）流程分析
jiangchaobing_2017的博客
04-19 97
cameraUser这个就是service返回的CameraDeviceClient，而deviceImpl就是new android.hardware.camera2.impl.CameraDeviceImpl了，接着看setRemoteDevice里面的调用。然后直接找到android.camera2的进程，并且点击这个进程的标签就可以把这个信息移动到最上面，这样好跟踪查看，然后鼠标点击activitystart进行选中，在按shift+m就可以框选这个接口。设备open的调用也就从这里开始实现。
Android Camera open流程
To be geek
04-02 4276
首先，Package层的Camera.java会调用Framework层的Camera.java的open函数，传入camera id。这个函数是个static函数，它只是new了一个Camera对象并返回。在Camera的构造函数中，最主要的就是调用JNI层的native_setup函数，传入两个参数：对象自身的weak引用，以及camera id。使用weak reference的目的是不
Android Camera2 openCamera流程详解(1)
weixin_41678668的博客
05-19 1517
本文用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 流程学习记录（二）—— Camera Open 调用流程
weixin_34348174的博客
08-23 2384
简介 这一章里，我们将 Camera.java 中的 open() 方法作为切入点。作为打开摄像头的方法，无论哪种 Camera 应用都需要调用到它。 从 Camera.open() 被调用开始，这一指令是如何通过 Framework 层走到 C/C++ 层，又是如何进入 HAL 层从而使得指令能够到达设备端。 通过追踪源码，我们可以比较清晰地了解...
2024年安卓最新Camera Request 流程源码分析，2024年最新整理出Android逆向系列学习进阶视频
最新发布
2401_84544531的博客
05-16 1092
总而言之，成功是留给准备好的人的。无论是参加什么面试，都要做好充足的准备，注意好面试的礼仪和穿着，向面试官表现出自己的热忱与真诚就好。即使最后没有过关，也要做好经验的总结，为下一次面试做好充足准备。这里我为大家准备了一些我在面试后整理的面试专题资料，除了面试题，还总结出了互联网公司Android程序员面试涉及到的绝大部分面试题及答案，并整理做成了文档，以及系统的进阶学习视频资料分享给大家，希望能帮助到你面试前的复习，且找到一个好的工作，也节省大家在网上搜索资料的时间来学习。
Android camera open 流程
你好呀，信田君！
06-21 2561
从 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 8.0系统源码分析--openCamera（HAL）启动过程源码分析
红旺永福
05-13 7976
     前面我们详细分析了从应用层调用CameraManager的openCamera的方法来打开相机的逻辑，上次的分析我们来到了CameraServer进程当中，但是还没有真正看到open操作设备节点来实现真正打开的逻辑，遗留的问题也就是从frameworks\av\services\camera\libcameraservice\device3\Camera3Device.cpp文件中的st...
Open Camera:适用于Android的相机应用。-开源
05-10
Open Camera是适用于Android（TM）手机和平板电脑的开源相机应用程序。 *在Google Play上获取：https://play.google.com/store/apps/details?id=net.sourceforge.opencamera *在F-Droid上获取：https://f-droid.org/zh/包/net.sourceforge.opencamera/ *或您可以直接下载APK /源代码，请参见上面的“文件”。 Open Camera是完全免费的，但是如果您希望通过支持我来表示感谢，请访问：https://opencamera.org.uk/info.html#supportme。 Android，Google Play和Google Play徽标是Google LLC的商标。
Camera2 openCamera 流程分析
ltc_666的博客
04-01 5646
文章目录一、相机架构二、应用框架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
camera 之 openCamera
android
08-30 4472
openCameraopenCamera() 方法参数解析openCamera() 代码跟踪 openCamera() 方法参数解析 1、 打开 camera我们可以直接调用系统service，获得CameraManager，然后调用openCamera(); CameraManager cameraManager = (CameraManager) mContext.getSystemService(Context.CAMERA_SERVICE); cameraManager.openCamera(mC
Android 13 openCamera流程详解
weixin_41678668的博客
07-18 988
Android从5.0开始已经引入了Camera API2，所以我们后面的流程都是Camera API2调用流程。
Andriod Camera之Open Camera
wk314061331的博客
07-19 1325
Hal层必须要去实作这些Interface，这部分是由各个厂商（比如MTK、高通）的去实作的，因此不同厂商的平台在这部分是会有差异的，这里就不细讲了。这个callback参数是一个回调对象，用来接收这个CameraDevice的状态变化情况的，这个回调对象里有提供几个回调函数（onOpened()、onClosed()、onError()、onDisconnected()），APP必须要去实作这些方法，以便于底层的CameraDevice切到对应的状态后，APP能够做出对应的反应。...
Android Camera 调用流程
执迷不悔的专栏
11-21 1495
Android中Camera的调用流程可分为以下几个层次： Package->Framework->JNI->Camera(cpp)--(binder)-->CameraService->Camera HAL->Camera Driver 以拍照流程为例： 1. 各个参数设置完成，对焦完成后，位于Package的Camera.java会调用Framework中Camera.java的ta
Android Camera2架构-OpenCamera2流程android.hardware.camera2.CameraManager(1)
01-03
关于打开相机的openCamera流程参考： Android P Camera2架构-OpenCamera2流程Frameworks层到HAL层(1) 简单介绍新架构右半部分android.hardware.camera2.CameraManager CameraManager的继承关系： 源码路径： ...
Android相机Camera使用源码
05-04
以上就是Android相机使用的核心流程。在实际开发中，还需要考虑用户界面的交互设计、权限管理、相机旋转等问题，确保应用在各种设备和场景下都能稳定运行。同时，随着Android版本的更新，相机API也有所变化，如从...
Android原生Camera2完成预览和拍照
01-25
这通常涉及到调用`CameraManager.getCameraIdList()`来获取设备ID列表，然后使用`CameraManager.openCamera()`打开特定的设备。 2. 创建Surface：为了显示预览，我们需要创建一个Surface对象，如SurfaceView或...
android Camera2 架构
07-09
2. 打开相机设备：通过SystemServiceManager获取ICameraService的stub，调用openCamera方法打开相机，返回CameraDevice对象。 3. 调整相机参数：创建CaptureRequest.Builder，设置CaptureRequest.Key类型的参数，...
android 原生人脸识别Camera和Camera2的示例
05-06
1. **获取Camera实例**：调用`Camera.open()`方法打开设备上的摄像头。 2. **设置预览回调**：使用`setPreviewCallback()`设置一个回调函数，该函数会在摄像头预览帧更新时被调用。 3. **开启人脸检测**：调用`...
Camera2 OpenCamera流程
程序员Android
10-29 1253
和你一起终身学习，这里是程序员Android经典好文推荐，通过阅读本文，您将收获以下知识点:1.1、APP层传递摄像头id来打开摄像头这里的callback是回调给APP的摄像头打开的结果handler这里主要是设置上面的回调所在的线程。该参数可以为空，为空framework会内部创建一个当前线程的Handler。openCamera(@NonNull String cameraId, @NonN...
open camera 流程
06-06
打开相机的流程可以分为以下几个步骤： 1. 检查设备是否有相机：使用相机之前，需要检查设备是否有相机。可以通过检查设备上是否安装了相机应用程序或使用系统服务来完成此操作。 2. 请求权限：如果设备具有相机，则需要请求相机权限。在 Android 中，可以使用运行时权限来请求相机权限。 3. 创建相机实例：创建相机实例是使用相机的第一步。可以使用 Camera2 API 或旧版 Camera API 来创建相机实例。 4. 配置相机：配置相机可以设置相机的各种参数，例如曝光时间、焦距等。可以使用相机参数对象来配置相机。 5. 预览相机：预览相机是使用相机的关键步骤，可以使用 SurfaceView、TextureView 或 SurfaceTexture 来预览相机。 6. 拍照：拍照是使用相机的另一个重要步骤。可以使用 Camera2 API 或旧版 Camera API 来拍照。 7. 释放相机：使用完相机后，需要释放相机资源，以便其他应用可以使用相机。 以上是打开相机的基本流程。需要注意的是，相机的使用可能因设备和 Android 版本而异，因此在使用相机之前需要仔细阅读相关文档和示例代码。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

chengwei_peng

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

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

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

打赏作者

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

抵扣说明：

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

余额充值