CameraService启动流程-获取ICameraProvider服务代理对象BpHwCameraProvider并由此获取所有相机设备代理对象BpHwCameraDevice的流程

本文分析下CameraService获取ICameraProvider代理对象BpHwCameraProvider的流程，以方便后边分析CameraService与ICameraProvider的通讯方式及探究下其他进程是否也可以获取ICameraProvider，直接与ICameraProvider通讯（即直接和HAL通讯）

cameraService启动时，调用的方法第一个方法：

//frameworks\av\services\camera\libcameraservice\CameraService.cpp
void CameraService::onFirstRef()
{
    
    
    ALOGI("CameraService process starting");

    BnCameraService::onFirstRef();

    // Update battery life tracking if service is restarting
    BatteryNotifier& notifier(BatteryNotifier::getInstance());
    notifier.noteResetCamera();
    notifier.noteResetFlashlight();

    status_t res = INVALID_OPERATION;
    //和ICameraProvider通讯获取设备上所有的机器
    res = enumerateProviders();
    if (res == OK) {
    
    
        mInitialized = true;
    }

    CameraService::pingCameraServiceProxy();
}

enumerateProviders()函数会与ICameraProvider通讯已获取所有的相机设备

status_t CameraService::enumerateProviders() {
    
    
    status_t res;
    Mutex::Autolock l(mServiceLock);

    if (nullptr == mCameraProviderManager.get()) {
    
    
        mCameraProviderManager = new CameraProviderManager();
        //initialize会与ICameraProvider通讯，获取所有相机设备
        res = mCameraProviderManager->initialize(this);
    }

    mNumberOfCameras = mCameraProviderManager->getCameraCount();
    mNumberOfNormalCameras =
            mCameraProviderManager->getAPI1CompatibleCameraCount();

    // Setup vendor tags before we call get_camera_info the first time
    // because HAL might need to setup static vendor keys in get_camera_info
    // TODO: maybe put this into CameraProviderManager::initialize()?
    mCameraProviderManager->setUpVendorTags();

    ...
}

enumerateProviders()函数首先创建了CameraProviderManager对象，然后调用其初始话函数initialize,
initialize有两个形参：

//frameworks\av\services\camera\libcameraservice\common\CameraProviderManager.h
  //proxy 默认值&sHardwareServiceInteractionProxy
    status_t initialize(wp<StatusListener> listener,
            ServiceInteractionProxy *proxy = &sHardwareServiceInteractionProxy);

initialize函数的第二个形参存在默认值 &sHardwareServiceInteractionProxy，CameraService就是使用了该默认值，下边分析下sHardwareServiceInteractionProxy：
其类图：

其实现代码：

//frameworks\av\services\camera\libcameraservice\common\CameraProviderManager.h
    struct HardwareServiceInteractionProxy : public ServiceInteractionProxy {
    
    
        virtual bool registerForNotifications(
                const std::string &serviceName,
                const sp<hidl::manager::V1_0::IServiceNotification>
                &notification) override {
    
    
       //是通过hardware::camera::provider::V2_4::ICameraProvider的静态方法registerForNotifications
       //注册Notifications的
            return hardware::camera::provider::V2_4::ICameraProvider::registerForNotifications(
                    serviceName, notification);
        }
        virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService(
                const std::string &serviceName) override {
    
    
             //是通过hardware::camera::provider::V2_4::ICameraProvider的静态方法getService
             //以Transport::HWBINDER方式获取ICameraProvider代理对象BpHwCameraProvider
            return hardware::camera::provider::V2_4::ICameraProvider::getService(serviceName);
        }
    }

接续分析下mCameraProviderManager->initialize(this)

//frameworks\av\services\camera\libcameraservice\common\CameraProviderManager.cpp
status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
        ServiceInteractionProxy* proxy) {
    
    
    std::lock_guard<std::mutex> lock(mInterfaceMutex);
    if (proxy == nullptr) {
    
    
        ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__);
        return BAD_VALUE;
    }
    //是CameraService对象指针
    mListener = listener;
    //mServiceProxy 就是&sHardwareServiceInteractionProxy静态变量
    mServiceProxy = proxy;
     ...
    // See if there's a passthrough HAL, but let's not complain if there's not
    //addProviderLocked首先获取ICameraProvider服务，然后开始遍历所有相机设备，kLegacyProviderName为"legacy/0"
    addProviderLocked(kLegacyProviderName, /*expected*/ false);

    return OK;
}

继续分析下addProviderLocked

//frameworks\av\services\camera\libcameraservice\common\CameraProviderManager.cpp
//newProvider为"legacy/0";expected为false
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;
        }
    }
    //通过sHardwareServiceInteractionProxy对象获取ICameraProvider服务代理BpHwCameraProvider
    //实际是执行的是hardware::camera::provider::V2_4::ICameraProvider::getService("legacy/0")
    sp<provider::V2_4::ICameraProvider> interface;
    interface = mServiceProxy->getService(newProvider);

   ...
    //封装上一步获取的ICameraProvider代理对象BpHwCameraProvider为interface为ProviderInfo对象
    //newProvider为"legacy/0"；interface为BpHwCameraProvider代理对象；this为CameraProviderManager对象
    sp<ProviderInfo> providerInfo =
            new ProviderInfo(newProvider, interface/*provider::V2_4::ICameraProvider*/, this);
     //调用ProviderInfo的initialize方法
    status_t res = providerInfo->initialize();
    if (res != OK) {
    
    
        return res;
    }

    mProviders.push_back(providerInfo);

    return OK;
}

首先接着分析下getService

//out\soong\.intermediates\hardware\interfaces\camera\provider\2.4\[email protected]_genc++\gen\android\hardware\camera\provider\2.4\CameraProviderAll.cpp
// static
//getStub的默认值是false
::android::sp<ICameraProvider> ICameraProvider::getService(const std::string &serviceName, const bool getStub) {
    
    
    using ::android::hardware::defaultServiceManager;
    using ::android::hardware::details::waitForHwService;
    using ::android::hardware::getPassthroughServiceManager;
    using ::android::hardware::Return;
    using ::android::sp;
    using Transport = ::android::hidl::manager::V1_0::IServiceManager::Transport;

    sp<ICameraProvider> iface = nullptr;
   //获取hwservicemanager代理对象BpHwServiceManager
    const sp<::android::hidl::manager::V1_0::IServiceManager> sm = defaultServiceManager();
    if (sm == nullptr) {
    
    
        ALOGE("getService: defaultServiceManager() is null");
        return nullptr;
    }
   //获取Transport属性
   //CameraProvider的transport属性为Transport::HWBINDER
   //属性定义在device\qcom\projectName\manifest.xml
    Return<Transport> transportRet = sm->getTransport(ICameraProvider::descriptor, serviceName);

    if (!transportRet.isOk()) {
    
    
        ALOGE("getService: defaultServiceManager()->getTransport returns %s", transportRet.description().c_str());
        return nullptr;
    }
    //通过上一步分析可知vintfHwbinder为true、vintfPassthru为false
    Transport transport = transportRet;
    const bool vintfHwbinder = (transport == Transport::HWBINDER);
    const bool vintfPassthru = (transport == Transport::PASSTHROUGH);

...
//getStub为false，vintfHwbinder为true，满足该条件
    for (int tries = 0; !getStub && (vintfHwbinder || (vintfLegacy && tries == 0)); tries++) {
    
    
        if (tries > 1) {
    
    
            ALOGI("getService: Will do try %d for %s/%s in 1s...", tries, ICameraProvider::descriptor, serviceName.c_str());
            sleep(1);
        }
        if (vintfHwbinder && tries > 0) {
    
    
            waitForHwService(ICameraProvider::descriptor, serviceName);
        }
        //通过BpHwServiceManager代理对象sm的get方法获取CameraProvider代理对象BpHwCameraProvider
        //ICameraProvider::descriptor为[email protected]::ICameraProvider
        //serviceName为legacy/0
        Return<sp<::android::hidl::base::V1_0::IBase>> ret = 
                sm->get(ICameraProvider::descriptor, serviceName);
        if (!ret.isOk()) {
    
    
            ALOGE("ICameraProvider: defaultServiceManager()->get returns %s", ret.description().c_str());
            break;
        }
        sp<::android::hidl::base::V1_0::IBase> base = ret;
        if (base == nullptr) {
    
    
            if (tries > 0) {
    
    
                ALOGW("ICameraProvider: found null hwbinder interface");
            }continue;
        }
        //通过ICameraProvider::castFrom将base转换为BpHwCameraProvider,稍后重点分析下
        Return<sp<ICameraProvider>> castRet = ICameraProvider::castFrom(base, true /* emitError */);
        ...
        iface = castRet;
        if (iface == nullptr) {
    
    
            ALOGW("ICameraProvider: received incompatible service; bug in hwservicemanager?");
            break;
        }
        return iface;
    }
...
}

接着分析下ICameraProvider::castFrom

//out\soong\.intermediates\hardware\interfaces\camera\provider\2.4\[email protected]_genc++\gen\android\hardware\camera\provider\2.4\CameraProviderAll.cpp
// static 
::android::hardware::Return<::android::sp<ICameraProvider>> ICameraProvider::castFrom(const ::android::sp<::android::hidl::base::V1_0::IBase>& parent, bool emitError) {
    
    
    return ::android::hardware::details::castInterface<ICameraProvider, ::android::hidl::base::V1_0::IBase, BpHwCameraProvider>(
            parent, "[email protected]::ICameraProvider", emitError);
}

接着分析下castInterface

//system\libhidl\transport\include\hidl\HidlTransportSupport.h
//IChild为ICameraProvider；IParent为IBase；BpChild为BpHwCameraProvider
//parent为BpHwServiceManager::get方法获的IBase代理对象BpHwBase
//childIndicator为[email protected]::ICameraProvider
//emitError为true
template <typename IChild, typename IParent, typename BpChild>
Return<sp<IChild>> castInterface(sp<IParent> parent, const char* childIndicator, bool emitError) {
    
    
    if (parent.get() == nullptr) {
    
    
        // casts always succeed with nullptrs.
        return nullptr;
    }
    //判断是否可以转换
    Return<bool> canCastRet = details::canCastInterface(parent.get(), childIndicator, emitError);
    if (!canCastRet.isOk()) {
    
    
        // call fails, propagate the error if emitError
        return emitError
                ? details::StatusOf<bool, sp<IChild>>(canCastRet)
                : Return<sp<IChild>>(sp<IChild>(nullptr));
    }

    if (!canCastRet) {
    
    
        return sp<IChild>(nullptr); // cast failed.
    }
    //该处parent->isRemote()为true
    //将parent封装为BpHwCameraProvider对象
    // TODO b/32001926 Needs to be fixed for socket mode.
    if (parent->isRemote()) {
    
    
        // binderized mode. Got BpChild. grab the remote and wrap it.
        return sp<IChild>(new BpChild(toBinder<IParent>(parent)));
    }
    // Passthrough mode. Got BnChild and BsChild.
    return sp<IChild>(static_cast<IChild *>(parent.get()));
}

通过上边的分析，可以知道CameraService调用ICameraProvider::getService("legacy/0")
最终获得是ICameraProvider代理对象BpHwCameraProvider

接着继续分析下ProviderInfo::initialize()

//frameworks\av\services\camera\libcameraservice\common\CameraProviderManager.cpp
status_t CameraProviderManager::ProviderInfo::initialize() {
    
    
    status_t res = parseProviderName(mProviderName, &mType, &mId);

    ALOGI("Connecting to new camera provider: %s, isRemote? %d",
            mProviderName.c_str(), mInterface->isRemote());
    //mInterface是上一步通过mServiceProxy->getService(newProvider)
    //获取的provider::V2_4::ICameraProvider代理对象BpHwCameraProvider
    hardware::Return<Status> status = mInterface->setCallback(this);

    ...
    hardware::Return<bool> linked = mInterface->linkToDeath(this, /*cookie*/ mId);

    //获取所有相机设备的idStatus和cameraDeviceNames（即camera ID??待确定），
    //然后赋值给status和devices
    // Get initial list of camera devices, 
    //if any
    std::vector<std::string> devices;
    hardware::Return<void> ret = mInterface->getCameraIdList([&status, &devices](
            Status idStatus,
            const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
    
    
        status = idStatus;
        if (status == Status::OK) {
    
    
            for (size_t i = 0; i < cameraDeviceNames.size(); i++) {
    
    
                devices.push_back(cameraDeviceNames[i]);
            }
        } });

    ...
    sp<StatusListener> listener = mManager->getStatusListener();
    //遍历上一步获取的设备
    for (auto& device : devices) {
    
    
        std::string id;
        status_t res = addDevice(device,
                hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT, &id);
    }
    ...
    return OK;
}

继续分析下addDevice

status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,
        CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {
    
    

    ALOGI("Enumerating new camera device: %s", name.c_str());

    uint16_t major, minor;
    std::string type, id;
    //根据获取的cameraDeviceNames，解析出其major，minor，type，id四个变量
    status_t res = parseDeviceName(name, &major, &minor, &type, &id);
    ....

    std::unique_ptr<DeviceInfo> deviceInfo;
    //sdm845 的major 为3（待确定？？）
    switch (major) {
    
    
        case 1:
            deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, mProviderTagid,
                    id, minor);
            break;
        case 3:
            //根据上一步获取的name，id等信息，创建DeviceInfo对象指针
            deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, mProviderTagid,
                    id, minor);
            break;
        default:
            ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
                    name.c_str(), major);
            return BAD_VALUE;
    }
    if (deviceInfo == nullptr) return BAD_VALUE;
    deviceInfo->mStatus = initialStatus;

    mDevices.push_back(std::move(deviceInfo));
    //如果所有的都成功，在返回解析出的id作为camera ID使用
    if (parsedId != nullptr) {
    
    
        *parsedId = id;
    }
    return OK;
}

先分析下deviceInfo，它其实是父类
定义如下：

        // Basic device information, common to all camera devices
        struct DeviceInfo {
    
    
            const std::string mName;  // Full instance name
            const std::string mId;    // ID section of full name
            const hardware::hidl_version mVersion;
            const metadata_vendor_id_t mProviderTagid;

            const hardware::camera::common::V1_0::CameraResourceCost mResourceCost;

            hardware::camera::common::V1_0::CameraDeviceStatus mStatus;

            bool hasFlashUnit() const {
    
     return mHasFlashUnit; }
            virtual status_t setTorchMode(bool enabled) = 0;
            virtual status_t getCameraInfo(hardware::CameraInfo *info) const = 0;
            virtual bool isAPI1Compatible() const = 0;
            virtual status_t getCameraCharacteristics(CameraMetadata *characteristics) const {
    
    
                (void) characteristics;
                return INVALID_OPERATION;
            }

            DeviceInfo(const std::string& name, const metadata_vendor_id_t tagId,
                    const std::string &id, const hardware::hidl_version& version,
                    const hardware::camera::common::V1_0::CameraResourceCost& resourceCost) :
                    mName(name), mId(id), mVersion(version), mProviderTagid(tagId),
                    mResourceCost(resourceCost),
                    mStatus(hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT),
                    mHasFlashUnit(false) {
    
    }
            virtual ~DeviceInfo();
        protected:
            bool mHasFlashUnit;

            template<class InterfaceT>
            static status_t setTorchMode(InterfaceT& interface, bool enabled);
        }

其两个子类DeviceInfo1 和DeviceInfo3
DeviceInfo1 定义如下：

        // HALv1-specific camera fields, including the actual device interface
        struct DeviceInfo1 : public DeviceInfo {
    
    
            //类型定义InterfaceT为hardware::camera::device::V1_0::ICameraDevice，之后会用到
            typedef hardware::camera::device::V1_0::ICameraDevice InterfaceT;
            const sp<InterfaceT> mInterface;

            virtual status_t setTorchMode(bool enabled) override;
            virtual status_t getCameraInfo(hardware::CameraInfo *info) const override;
            //In case of Device1Info assume that we are always API1 compatible
            virtual bool isAPI1Compatible() const override {
    
     return true; }
            DeviceInfo1(const std::string& name, const metadata_vendor_id_t tagId,
                    const std::string &id, uint16_t minorVersion,
                    const hardware::camera::common::V1_0::CameraResourceCost& resourceCost,
                    sp<InterfaceT> interface);
            virtual ~DeviceInfo1();
        private:
            CameraParameters2 mDefaultParameters;
        }

DeviceInfo3 定义如下：

        struct DeviceInfo3 : public DeviceInfo {
    
    
        //类型定义InterfaceT 为hardware::camera::device::V3_2::ICameraDevice，之后会用到
            typedef hardware::camera::device::V3_2::ICameraDevice InterfaceT;
            const sp<InterfaceT> mInterface;

            virtual status_t setTorchMode(bool enabled) override;
            virtual status_t getCameraInfo(hardware::CameraInfo *info) const override;
            virtual bool isAPI1Compatible() const override;
            virtual status_t getCameraCharacteristics(
                    CameraMetadata *characteristics) const override;

            DeviceInfo3(const std::string& name, const metadata_vendor_id_t tagId,
                    const std::string &id, uint16_t minorVersion,
                    const hardware::camera::common::V1_0::CameraResourceCost& resourceCost,
                    sp<InterfaceT> interface);
            virtual ~DeviceInfo3();
        private:
            CameraMetadata mCameraCharacteristics;
        }

接着继续这只分析下initializeDeviceInfo

//是一个模板函数，上一步调用传入的类型参数是DeviceInfo3
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;
    //获取ICameraDevice对象（auto 的类型是device::V3_2::ICameraDevice）
    // DeviceInfoT::InterfaceT的类型是hardware::camera::device::V3_2::ICameraDevice
    auto cameraInterface = getDeviceInterface<typename DeviceInfoT::InterfaceT>(name);
    if (cameraInterface == nullptr) return nullptr;
    //通过上一步获取的device::V3_2::ICameraDevice的代理对象
    //获取getResourceCost
    CameraResourceCost resourceCost;
    cameraInterface->getResourceCost([&status, &resourceCost](
        Status s, CameraResourceCost cost) {
    
    
                status = s;
                resourceCost = cost;
            });

    //根据获得name，id，device::V3_2::ICameraDevice代理对象cameraInterface，
    //封装为一个DeviceInfo3对象
    return std::unique_ptr<DeviceInfo>(
        new DeviceInfoT(name, tagId, id, minorVersion, resourceCost,
                cameraInterface));
}

接着分析下 auto cameraInterface = getDeviceInterface<typename DeviceInfoT::InterfaceT>(name);
根据上一步分析，调用的模板函数的具体化如下

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;
     //mInterface是上一步通过mServiceProxy->getService(newProvider)
    //获取的provider::V2_4::ICameraProvider代理对象BpHwCameraProvider
    // getCameraDeviceInterface_V3_x获取的是device::V3_2::ICameraDevice代理对象BpHwCameraDevice
    ret = mInterface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
        Status s, sp<device::V3_2::ICameraDevice> interface) {
    
    
                status = s;
                cameraInterface = interface;
            });
....
返回获取的device::V3_2::ICameraDevice代理对象BpHwCameraDevice
    return cameraInterface;
}

至此分析完成了cameraservice获取ICameraProvider服务代理对象BpHwCameraProvider并由此获取所有相机设备ICameraDevice代理对象BpHwCameraDevice流程。