Android 8.0系统源码分析--openCamera（HAL）启动过程源码分析

     前面我们详细分析了从应用层调用CameraManager的openCamera的方法来打开相机的逻辑，上次的分析我们来到了CameraServer进程当中，但是还没有真正看到open操作设备节点来实现真正打开的逻辑，遗留的问题也就是从frameworks\av\services\camera\libcameraservice\device3\Camera3Device.cpp文件中的status_t Camera3Device::initialize(sp<CameraProviderManager> manager)方法的status_t res = manager->openSession(mId.string(), this, /*out*/ &session);这句代码进去后进行的处理。

     我们知道，Android的内核是Linux内核，Linux上所有的设备都被抽象成文件节点，对设备的操作都变成了对文件节点的操作，非常方便，我们openCamera的逻辑最终肯定也是通过open系统函数来打开camera的文件节点，而open系统调用的处理就是对应的camera驱动了。

     好，我们回到正文，status_t res = manager->openSession(mId.string(), this, /*out*/ &session);这句逻辑中的manager是一个sp<CameraProviderManager>对象，那我们就来看一下frameworks\av\services\camera\libcameraservice\common\CameraProviderManager.cpp文件中的openSession方法的实现，源码如下：

status_t CameraProviderManager::openSession(const std::string &id,
        const sp<hardware::camera::device::V3_2::ICameraDeviceCallback>& callback,
        /*out*/
        sp<hardware::camera::device::V3_2::ICameraDeviceSession> *session) {

    std::lock_guard<std::mutex> lock(mInterfaceMutex);

    auto deviceInfo = findDeviceInfoLocked(id,
            /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
    if (deviceInfo == nullptr) return NAME_NOT_FOUND;

    auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);

    Status status;
    hardware::Return<void> ret;
    ret = deviceInfo3->mInterface->open(callback, [&status, &session]
            (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
                status = s;
                if (status == Status::OK) {
                    *session = cameraSession;
                }
            });
    if (!ret.isOk()) {
        ALOGE("%s: Transaction error opening a session for camera device %s: %s",
                __FUNCTION__, id.c_str(), ret.description().c_str());
        return DEAD_OBJECT;
    }
    return mapToStatusT(status);
}

     该方法中根据传入的最小和最大版本号调用findDeviceInfoLocked方法获取到一个DeviceInfo对象，其中的逻辑比较简单，源码如下：

CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(
        const std::string& id,
        hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const {
    for (auto& provider : mProviders) {
        for (auto& deviceInfo : provider->mDevices) {
            if (deviceInfo->mId == id &&
                    minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {
                return deviceInfo.get();
            }
        }
    }
    return nullptr;
}

     可以看到，该方法的逻辑就是对成员变量mProviders进行遍历，判断每个DeviceInfo的id值、最小版本、最大版本号是否符合传入的最小和最大版本，符合的话，就返回该对象，那我们就要问一下了，mProviders中的值是什么时候添加的呢？我们大概追究一下，它是在CameraService进行启动时，初始化CameraProviderManager对象的逻辑中，通过addProviderLocked方法生成具体的DeviceInfo对象，添加到mProviders成员变量中的。addProviderLocked方法的源码如下：

status_t CameraProviderManager::addProviderLocked(const std::string& newProvider, bool expected) {
    for (const auto& providerInfo : mProviders) {
        if (providerInfo->mProviderName == newProvider) {
            ALOGW("%s: Camera provider HAL with name '%s' already registered", __FUNCTION__,
                    newProvider.c_str());
            return ALREADY_EXISTS;
        }
    }

    sp<provider::V2_4::ICameraProvider> interface;
    interface = mServiceProxy->getService(newProvider);

    if (interface == nullptr) {
        if (expected) {
            ALOGE("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
                    newProvider.c_str());
            return BAD_VALUE;
        } else {
            return OK;
        }
    }

    sp<ProviderInfo> providerInfo =
            new ProviderInfo(newProvider, interface, this);
    status_t res = providerInfo->initialize();
    if (res != OK) {
        return res;
    }

    mProviders.push_back(providerInfo);

    return OK;
}

     这个方法中有一个非常重要的对象，就是interface = mServiceProxy->getService(newProvider)逻辑返回的interface，它又是一个binder对象，获取camera属性、数量等实质性的方法都是通过它来完成的，获取成功后，以它为参数构造一个ProviderInfo对象，最后添加到mProviders成员变量当中。

     好了，我们回到openSession方法当中，找到deviceInfo对象之后，然后调用deviceInfo3->mInterface->open，而它的成员变量mInterface就是在前面我们说构造ProviderInfo时获取到的binder对象了，它实际上是hardware\interfaces\camera\device\3.2\default\CameraDevice.cpp对象了，来到这里，我们就进入了CameraDaemon进程当中，两个进程的通信是通过HIDL，其实还是binder进程间通信机制，只是它是用来提供给HAL层服务的，所以和AIDL类似，取了个HIDL的名字。这里需要说一下，为是什么是3.2下面的这个类呢？因为我们在调用openSession方法时，传入的第二个参数const sp<hardware::camera::device::V3_2::ICameraDeviceCallback>& callback和第三个参数sp<hardware::camera::device::V3_2::ICameraDeviceSession> *session就可以非常明显的看出来，当前调用的版本是V3_2。接下来，我们就来看一下CameraDevice.cpp类的open方法的实现，源码如下：

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

    if (callback == nullptr) {
        ALOGE("%s: cannot open camera %s. callback is null!",
                __FUNCTION__, mCameraId.c_str());
        _hidl_cb(Status::ILLEGAL_ARGUMENT, session);
        return Void();
    }

    if (status != Status::OK) {
        // Provider will never pass initFailed device to client, so
        // this must be a disconnected camera
        ALOGE("%s: cannot open camera %s. camera is disconnected!",
                __FUNCTION__, mCameraId.c_str());
        _hidl_cb(Status::CAMERA_DISCONNECTED, session);
        return Void();
    } else {
        mLock.lock();

        ALOGV("%s: Initializing device for camera %d", __FUNCTION__, mCameraIdInt);
        session = mSession.promote();
        if (session != nullptr && !session->isClosed()) {
            ALOGE("%s: cannot open an already opened camera!", __FUNCTION__);
            mLock.unlock();
            _hidl_cb(Status::CAMERA_IN_USE, nullptr);
            return Void();
        }

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

        ATRACE_BEGIN("camera3->open");
        res = mModule->open(mCameraId.c_str(),
                reinterpret_cast<hw_device_t**>(&device));
        ATRACE_END();

        if (res != OK) {
            ALOGE("%s: cannot open camera %s!", __FUNCTION__, mCameraId.c_str());
            mLock.unlock();
            _hidl_cb(getHidlStatus(res), nullptr);
            return Void();
        }

        /** Cross-check device version */
        if (device->common.version < CAMERA_DEVICE_API_VERSION_3_2) {
            ALOGE("%s: Could not open camera: "
                    "Camera device should be at least %x, reports %x instead",