文档开发者中心
我的

Android P Camera初始化流程

在Android O版本之前,Camera HAL服务的初始化是耦合在CameraService服务当中的。在O版本中,Android引入HIDL机制,将Service层与HAL层进行了解耦。

因此,Android P版本的Camera初始化分为两部分:

  • CameraService服务初始化

  • Camera HAL服务初始化

CameraService服务初始化

Android服务的启动信息在.rc文件中进行描述,CameraService的启动描述文件是cameraserver.rc(我知道名字不一致,本文以架构中的名字为准,不要在意这些细节)。

/* /frameworks/av/camera/cameraserver */service cameraserver /system/bin/cameraserver    class main
    user cameraserver
    group audio camera input drmrpc
    ioprio rt 4
    writepid /dev/cpuset/camera-daemon/tasks /dev/stune/top-app/tasks

Android启动的时候会收集此cameraserver.rc文件,然后启动对应的服务。

/* frameworks/av/camera/cameraserver/main_cameraserver.cpp */int main(int argc __unused, char** argv __unused)
{
    signal(SIGPIPE, SIG_IGN);

    hardware::configureRpcThreadpool(3, /*willjoin*/ false);

    sp<ProcessState> proc(ProcessState::self());
    sp<IServiceManager> sm = defaultServiceManager();
    ALOGI('ServiceManager: %p', sm.get());    /* 这里初始化CameraService */
    CameraService::instantiate(); 
    ProcessState::self()->startThreadPool();
    IPCThreadState::self()->joinThreadPool();
}

CameraService继承BinderService,因此调用的是BinderService的instantiate方法,而在instantiate中,直接调用publish方法。

/* frameworks/native/libs/binder/include/binder/BinderService.h */static void instantiate() { publish(); }static status_t publish(bool allowIsolated = false, int dumpFlags = IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT) {
    sp<IServiceManager> sm(defaultServiceManager());    /* 添加CameraService服务 */
    return sm->addService(String16(SERVICE::getServiceName()), new SERVICE(), allowIsolated, dumpFlags);
}

其中的SERVICE是模板参数,即CameraService。

CameraService继承自IBinder,因此在构造CameraService的时候,会首先调用OnFirstRef方法。

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

    BnCameraService::onFirstRef();

    BatteryNotifier& notifier(BatteryNotifier::getInstance());
    notifier.noteResetCamera();
    notifier.noteResetFlashlight();

    status_t res = INVALID_OPERATION;    /* 枚举注册CameraProvider */
    res = enumerateProviders();    if (res == OK) {
        mInitialized = true;
    }

    CameraService::pingCameraServiceProxy();

    mUidPolicy = new UidPolicy(this);
    mUidPolicy->registerSelf();
}

可以看到,在OnFirstRef方法中,会调用enumerateProviders来初始化并注册CameraProvider。

/* frameworks/av/services/camera/libcameraservice/CameraService.cpp */status_t CameraService::enumerateProviders() {
    status_t res;
    std::vector<std::string> deviceIds;
    {
        Mutex::Autolock l(mServiceLock);        if (nullptr == mCameraProviderManager.get()) {            /* 构造并初始化CameraProviderManager */
            mCameraProviderManager = new CameraProviderManager();
            res = mCameraProviderManager->initialize(this);            if (res != OK) {
                ALOGE('%s: Unable to initialize camera provider manager: %s (%d)',
                        __FUNCTION__, strerror(-res), res);                return res;
            }
        }

    ...略    return OK;
}

CameraProviderManager用来管理所有可用的CameraProvider,而CameraProvider对应的就是Camera HAL。下面我们看一下CameraProviderManager的initialize方法。

/* frameworks/av/services/camera/libcameraservice/common/CameraProviderManager.h *//**
 * Initialize the manager and give it a status listener; optionally accepts a service
 * interaction proxy.
 *
 * The default proxy communicates via the hardware service manager; alternate proxies can be
 * used for testing. The lifetime of the proxy must exceed the lifetime of the manager.
 */status_t initialize(wp<StatusListener> listener,
            ServiceInteractionProxy *proxy = &sHardwareServiceInteractionProxy);

在CameraProviderManager.h文件中已经对proxy赋了默认值,这个是CameraService与Camera HAL通信的核心。

/* 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;
    }
    mListener = listener;
    mServiceProxy = proxy;    bool success = mServiceProxy->registerForNotifications(this);    if (!success) {
        ALOGE('%s: Unable to register with hardware service manager for notifications about camera providers', __FUNCTION__);        return INVALID_OPERATION;
    }

    addProviderLocked(kLegacyProviderName, /*expected*/ false);
    addProviderLocked(kExternalProviderName, /*expected*/ false);    return OK;
}

在initialize方法中可以看到,CameraProviderManager将自己注册到了mServiceProxy中,也就是sHardwareServiceInteractionProxy,后续会在CameraService和Camera HAL的连接建立中详细介绍。

在方法的最后,调用了addProviderLocked方法来注册对应的Provider。

/* frameworks/av/services/camera/libcameraservice/common/CameraProviderManager.cpp */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;
        }
    }    /* 根据Provider名字,获取对应的HAL层CameraProvider接口 */
    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;
        }
    }    /* 构造CameraProvider信息,并初始化 */
    sp<ProviderInfo> providerInfo = new ProviderInfo(newProvider, interface, this);
    status_t res = providerInfo->initialize();    if (res != OK) {        return res;
    }    /* 将Provicer信息进行统一管理 */
    mProviders.push_back(providerInfo);    return OK;
}

addProviderLocked方法中,首先通过入参newProvider从mServiceProxy中获取对应的ICameraProvider接口。然后构造ProviderInfo时将ICameraProvider接口传入,并调用initialize进行初始化。最后将ProviderInfo放到mProviders中统一管理。

下面详细看一下ProviderInfo的初始化。

/* frameworks/av/services/camera/libcameraservice/common/CameraProviderManager.cpp */status_t CameraProviderManager::ProviderInfo::initialize() {
    status_t res = parseProviderName(mProviderName, &mType, &mId);
    ...略
    hardware::Return<Status> status = mInterface->setCallback(this);
    ...略
    hardware::Return<bool> linked = mInterface->linkToDeath(this, /*cookie*/ mId);
    ...略    /* 通过ICameraProvider获取相机ID列表 */
    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]);
            }
        } });
    ...略    /* 将相机信息转换为设备信息 */
    for (auto& device : devices) {
        std::string id;
        status_t res = addDevice(device,
                hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT, &id);        if (res != OK) {
            ALOGE('%s: Unable to enumerate camera device '%s': %s (%d)',
                    __FUNCTION__, device.c_str(), strerror(-res), res);            continue;
        }
    }
    ...略
    mInitialized = true;    return OK;
}

接下来看一下addDevice方法是如何将HAL层返回的相机信息转换为Service层的设备信息的。

/* frameworks/av/services/camera/libcameraservice/common/CameraProviderManager.cpp */status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,
        CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {
    uint16_t major, minor;
    std::string type, id;

    status_t res = parseDeviceName(name, &major, &minor, &type, &id);
    ...略    /* 根据相机HAL版本,初始化对应的设备信息 */
    std::unique_ptr<DeviceInfo> deviceInfo;    switch (major) {        case 1:
            deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, mProviderTagid,
                    id, minor);            break;        case 3:
            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;
    }
    ...略    return OK;
}

initializeDeviceInfo是个模板方法,其中会调用HAL层ICameraDevice接口获取相机设备的资源成本信息(CameraRsourceCost),然后构造模板参数中的DeviceInfo,并将ICameraDevice和CameraRsourceCost传入构造函数中。

CameraRsourceCost包含了资源消耗指数和冲突相机ID。这里不详细介绍了,可以参考types.hal中的CameraResourceCost描述。

我们以DeviceInfo3为例,看一下DeviceInfo的构造。

CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,        const metadata_vendor_id_t tagId, const std::string &id,
        uint16_t minorVersion,        const CameraResourceCost& resourceCost,
        sp<InterfaceT> interface) :
        DeviceInfo(name, tagId, id, hardware::hidl_version{3, minorVersion},
                   resourceCost),
        mInterface(interface) {    // Get camera characteristics and initialize flash unit availability
    Status status;
    hardware::Return<void> ret;    /* 通过ICameraDevice接口获取相机特性信息 */
    ret = mInterface->getCameraCharacteristics([&status, this](Status s,
                    device::V3_2::CameraMetadata metadata) {
                status = s;                if (s == Status::OK) {
                    camera_metadata_t *buffer =                            reinterpret_cast<camera_metadata_t*>(metadata.data());
                    size_t expectedSize = metadata.size();                    int res = validate_camera_metadata_structure(buffer, &expectedSize);                    if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
                        set_camera_metadata_vendor_id(buffer, mProviderTagid);
                        mCameraCharacteristics = buffer;
                    } else {
                        ALOGE('%s: Malformed camera metadata received from HAL', __FUNCTION__);
                        status = Status::INTERNAL_ERROR;
                    }
                }
            });
    ...略
    camera_metadata_entry flashAvailable =
            mCameraCharacteristics.find(ANDROID_FLASH_INFO_AVAILABLE);    if (flashAvailable.count == 1 &&
            flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) {
        mHasFlashUnit = true;
    } else {
        mHasFlashUnit = false;
    }
}

可以看到,在构造DeviceInfo3的时候,会获取相机的特性信息,并转换为CameraMetadata,具体结构在camera_metadata.c中定义。

至此,CameraService服务的初始化已完成。

Camera HAL服务初始化

与CameraService服务的初始化类似,Camera HAL服务的启动描述文件是android.hardware.camera.provider@2.4-service.rc。

/* hardware/interfaces/camera/provider/2.4/default/android.hardware.camera.provider@2.4-service.rc */service vendor.camera-provider-2-4 /vendor/bin/hw/android.hardware.camera.provider@2.4-service    class hal
    user cameraserver
    group audio camera input drmrpc
    ioprio rt 4
    capabilities SYS_NICE
    writepid /dev/cpuset/camera-daemon/tasks /dev/stune/top-app/tasks

对应的main方法在service.cpp文件中。

/* hardware/interfaces/camera/provider/2.4/default/service.cpp */int main()
{
    ALOGI('Camera provider Service is starting.');    // The camera HAL may communicate to other vendor components via
    // /dev/vndbinder
    android::ProcessState::initWithDriver('/dev/vndbinder');    return defaultPassthroughServiceImplementation<ICameraProvider>('legacy/0', /*maxThreads*/ 6);
}

可以看到在main函数中调用了ICameraProvider接口的实现,也就是CameraProvider的构造函数。同时,Camera HAL层的初始化逻辑,主要集中在CameraProvider中。我们来看一下它的构造函数。

/* hardware/interfaces/camera/provider/2.4/default/CameraProvider.cpp */CameraProvider::CameraProvider() :
        camera_module_callbacks_t({sCameraDeviceStatusChange,
                                   sTorchModeStatusChange}) {
    mInitFailed = initialize();
}

从CameraProvider的头文件可以看到,它继承自ICameraProvider和camera_module_callbacks_t,后者是一个回调。可以看到在构造函数中,设置了两个回调函数,然后调用了initialize方法来进行初始化。

bool CameraProvider::initialize() {    /* 获取camera_module_t结构体 */
    camera_module_t *rawModule;    int err = hw_get_module(CAMERA_HARDWARE_MODULE_ID,
            (const hw_module_t **)&rawModule);
    ...略
    mModule = new CameraModule(rawModule);
    err = mModule->init();
    ...略
    err = mModule->setCallbacks(this);
    ...略
    mPreferredHal3MinorVersion =
        property_get_int32('ro.vendor.camera.wrapper.hal3TrebleMinorVersion', 3);
    ALOGV('Preferred HAL 3 minor version is %d', mPreferredHal3MinorVersion);    switch(mPreferredHal3MinorVersion) {        case 2:        case 3:            // OK
            break;        default:
            ...略
            mPreferredHal3MinorVersion = 3;
    }

    mNumberOfLegacyCameras = mModule->getNumberOfCameras();    for (int i = 0; i < mNumberOfLegacyCameras; i++) {        struct camera_info info;        auto rc = mModule->getCameraInfo(i, &info);
        ...略        char cameraId[kMaxCameraIdLen];        snprintf(cameraId, sizeof(cameraId), '%d', i);
        std::string cameraIdStr(cameraId);
        mCameraStatusMap[cameraIdStr] = CAMERA_DEVICE_STATUS_PRESENT;

        addDeviceNames(i);
    }    return false; // mInitFailed}

在initialize方法中,首先会加载动态库,获取对应的camera_module_t结构体。然后通过camera_module_t去构造CameraModule。

本质上CameraModule是camera_module_t的一个包装,后面调用的init、setCallbacks、getCameraInfo实际上都是在调用camera_module_t提供的方法。

而camera_module_t结构体是贯穿在Camera HAL层的一个核心结构体,在camera_common.h文件中有具体的介绍,这里不再赘述。

不同的平台和芯片,会实现对应的camera_module_t结构体。高通平台在Android的源码中提供了默认实现,如下。

/* hardware/qcom/camera/QCamera2/QCamera2Hal.cpp */camera_module_t HAL_MODULE_INFO_SYM = {
    .common                 = camera_common,
    .get_number_of_cameras  = qcamera::QCamera2Factory::get_number_of_cameras,
    .get_camera_info        = qcamera::QCamera2Factory::get_camera_info,
    .set_callbacks          = qcamera::QCamera2Factory::set_callbacks,
    .get_vendor_tag_ops     = qcamera::QCamera3VendorTags::get_vendor_tag_ops,
    .open_legacy            = NULL,
    .set_torch_mode         = qcamera::QCamera2Factory::set_torch_mode,
    .init                   = NULL,
    .reserved               = {0}
};

通过此结构体的映射关系,CameraProvider就可以直接调用到Camera HAL层的实现了。

至此,Camera HAL服务的初始化已完成。

下图以高通平台为例绘制,可以参考。

CameraService与Camera HAL的连接建立

在CameraService启动的时候,会与Camera HAL建立连接,在这里单独进行解释,便于理解。

大家可以看到,在Camera HAL启动的main方法最后一行,有一个参数是legacy/0。

int main()
{
    android::ProcessState::initWithDriver('/dev/vndbinder');    /* 注意第一个参数 */
    return defaultPassthroughServiceImplementation<ICameraProvider>('legacy/0', /*maxThreads*/ 6);
}

而在CameraService启动的过程中,会初始化CameraProviderManager,其中在initialize方法中,最后有两行代码。

    /* frameworks/av/services/camera/libcameraservice/common/CameraProviderManager.cpp */
    status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener, ServiceInteractionProxy* proxy) {
        ...略        /* 注意这两行代码 */
        addProviderLocked(kLegacyProviderName, /*expected*/ false);
        addProviderLocked(kExternalProviderName, /*expected*/ false);        return OK;
    }

其中的kLegacyProviderName就是legacy/0。

const std::string kLegacyProviderName('legacy/0');const std::string kExternalProviderName('external/0');

那external/0对应的是什么呢?其实在Camera HAL启动的时候,还有一个external服务,在android.hardware.camera.provider@2.4-external-service.rc文件中定义。对应的main方法如下:

int main()
{
    android::ProcessState::initWithDriver('/dev/vndbinder');    /* 注意第一个参数 */
    return defaultPassthroughServiceImplementation<ICameraProvider>('external/0', /*maxThreads*/ 6);
}

接下来我们详细看一下addProviderLocked方法。

/* frameworks/av/services/camera/libcameraservice/common/CameraProviderManager.cpp */status_t CameraProviderManager::addProviderLocked(const std::string& newProvider, bool expected) {
    ...略    /* 根据Provider名字,获取对应的HAL层CameraProvider接口 */
    sp<provider::V2_4::ICameraProvider> interface;
    interface = mServiceProxy->getService(newProvider);
    ...略    return OK;
}

这里的newProvider就是上面传入的legacy/0和external/0,mServiceProxy是在CameraProviderManager::initialize方法中的第二个参数,在CameraProviderManager头文件中已经赋默认值,为HardwareServiceInteractionProxy。

/* frameworks/av/services/camera/libcameraservice/common/CameraProviderManager.h */static HardwareServiceInteractionProxy sHardwareServiceInteractionProxy;

status_t initialize(wp<StatusListener> listener,
        ServiceInteractionProxy *proxy = &sHardwareServiceInteractionProxy);

下面看一下HardwareServiceInteractionProxy的定义。

struct HardwareServiceInteractionProxy : public ServiceInteractionProxy {    virtual bool registerForNotifications(            const std::string &serviceName,            const sp<hidl::manager::V1_0::IServiceNotification>
            &notification) override {        return hardware::camera::provider::V2_4::ICameraProvider::registerForNotifications(
                serviceName, notification);
    }    virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService(            const std::string &serviceName) override {        /* 直接调用HAL层,根据serviceName获取对应的服务 */
        return hardware::camera::provider::V2_4::ICameraProvider::getService(serviceName);
    }
};

可以看到,通过getService方法可以获取到HAL层的ICameraProvider服务,也就是CameraProvider。

这样,CameraService和Camera HAL之间就建立了连接。


By HW ZCX

点赞
收藏
回复
分享
举报
浏览3305 编辑于2020-07-31 07:30未知归属地
全部评论
最多点赞
最新发布
最早发布
暂无评论
暂无评论
写回答
新增插入模板功能
一键使用模板,快速填写内容,轻松发帖~
知道了
  • 为了保障您的信息安全,请勿上传您的敏感个人信息(如您的密码等信息)和您的敏感资产信息(如关键源代码、签名私钥、调试安装包、业务日志等信息),且您需自行承担由此产生的信息泄露等安全风险。
  • 如您发布的内容为转载内容,请注明内容来源。

我要发帖子

目录 收起
CameraService服务初始化
Camera HAL服务初始化
CameraService与Camera HAL的连接建立
了解社区公约,与您携手共创和谐专业的开发者社区。