在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>
¬ification) 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





































苏公安网备 32011402010933号