Android camera: 从camera service 调用到camera HAL(HIDL)

sp<hardware::camera::provider::V2_4::ICameraProvider> mInterface

CameraProviderManager::initialize -> addProviderLocked

status_t CameraProviderManager::addProviderLocked(const std::string& newProvider, bool expected) {

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


    sp<ProviderInfo> providerInfo =
            new ProviderInfo(newProvider, interface, this);
    status_t res = providerInfo->initialize();

    return OK;
}

CameraProviderManager::ProviderInfo::ProviderInfo(
        const std::string &providerName,
        sp<provider::V2_4::ICameraProvider>& interface,
        CameraProviderManager *manager) :
        mProviderName(providerName),
        mInterface(interface),/*这里对mInterface进行赋值*/
        mProviderTagid(generateVendorTagId(providerName)),
        mUniqueDeviceCount(0),
        mManager(manager) {
    (void) mManager;
}

mInterface代表访问ICameraProvider.hal的接口，例如通过

mInterface->setCallback(this);设置IProviderCallbak.

deviceInfo3->mInterface访问　ICameraDevice.hal

通过provider　service的getCameraDeviceInterface_V3_x获得访问ICameraDevice.hal的接口

template<class DeviceInfoT>
std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
    CameraProviderManager::ProviderInfo::initializeDeviceInfo(
        const std::string &name, const metadata_vendor_id_t tagId,
        const std::string &id, uint16_t minorVersion) const {
    Status status;

    auto cameraInterface =
            getDeviceInterface<typename DeviceInfoT::InterfaceT>(name);


    CameraResourceCost resourceCost;
    cameraInterface->getResourceCost([&status, &resourceCost](
        Status s, CameraResourceCost cost) {
                status = s;
                resourceCost = cost;
            });

    return std::unique_ptr<DeviceInfo>(
        new DeviceInfoT(name, tagId, id, minorVersion, resourceCost,
                cameraInterface));
}

template<>
sp<device::V3_2::ICameraDevice>
CameraProviderManager::ProviderInfo::getDeviceInterface
        <device::V3_2::ICameraDevice>(const std::string &name) const {
    Status status;
    sp<device::V3_2::ICameraDevice> cameraInterface;
    hardware::Return<void> ret;
    ret = mInterface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
        Status s, sp<device::V3_2::ICameraDevice> interface) {
                status = s;
                cameraInterface = interface;
            });
    return cameraInterface;
}

mHidlSession:调用ICameraDeviceSession.hidl接口

sp<hardware::camera::device::V3_2::ICameraDeviceSession> mHidlSession;

Camera3Device::HalInterface::HalInterface(
            sp<ICameraDeviceSession> &session,
            std::shared_ptr<RequestMetadataQueue> queue) :
        mHal3Device(nullptr),
        mHidlSession(session),
        mRequestMetadataQueue(queue) {}