类结构图：
启动流程时序图：
1. 程序入口
frameworks\av\camera\cameraserver\main_cameraserver.cpp
int main(int argc __unused, char** argv __unused)
{
signal(SIGPIPE, SIG_IGN);
// Set 5 threads for HIDL calls. Now cameraserver will serve HIDL calls in
// addition to consuming them from the Camera HAL as well.
hardware::configureRpcThreadpool(5, /*willjoin*/ false);
sp<ProcessState> proc(ProcessState::self());
sp<IServiceManager> sm = defaultServiceManager(); // 获取Service_Manager服务句柄
ALOGI("ServiceManager: %p", sm.get());
CameraService::instantiate();//camera 服务
ALOGI("ServiceManager: %p done instantiate", sm.get());
ProcessState::self()->startThreadPool(); // 为进程开启缓存池，用来处理到来的调用请求的消息，包括请求和远端响应的消息。
IPCThreadState::self()->joinThreadPool(); // 将进程加入缓存池。
}2. 开始ICameraService服务端Binder的创建和注册流程
class CameraService :
public BinderService<CameraService>, //模板类 主要封装了将Binder添加到ServiceManager进程中
public virtual ::android::hardware::BnCameraService, //ICameraService的服务需要继承BnCameraService(native binder的写法)
public virtual IBinder::DeathRecipient, //Binder死亡监听，监听客户端进程的死亡情况
public virtual CameraProviderManager::StatusListener
//CameraService::instantiate() 调用这里的instantiate()主要是向ServiceManager注册了ICameraService的服务端binder
template<typename SERVICE>
class BinderService
{
public:
static status_t publish(bool allowIsolated = false,
int dumpFlags = IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT) {
sp<IServiceManager> sm(defaultServiceManager());
//这里就是向ServiceManager进程注册binder, binder名称是“media.camera”
return sm->addService(String16(SERVICE::getServiceName()), new SERVICE(), allowIsolated,
dumpFlags);
}
static void publishAndJoinThreadPool(
bool allowIsolated = false,
int dumpFlags = IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT) {
publish(allowIsolated, dumpFlags);
joinThreadPool();
}
static void instantiate() { publish(); }
static status_t shutdown() { return NO_ERROR; }
private:
static void joinThreadPool() {
sp<ProcessState> ps(ProcessState::self());
ps->startThreadPool();
ps->giveThreadPoolName();
IPCThreadState::self()->joinThreadPool();
}
};上面的new SERVICE()让程序流程来到了CameraService()构造函数里面，CameraService继承了BnCameraservice(这个是AIDL--cpp生成的代码)，所以CameraService.cpp是ICameraService.adil的IPC机制的服务端。
3. CameraService的构造函数
CameraService::CameraService() :
mEventLog(DEFAULT_EVENT_LOG_LENGTH), //初始化用来打印Log的Buffer的长度-100
mNumberOfCameras(0), //初始化Camera的数据为0
mNumberOfCamerasWithoutSystemCamera(0), // ？
mSoundRef(0), mInitialized(false), //标识CameraService是否被初始化了
mAudioRestriction(hardware::camera2::ICameraDeviceUser::AUDIO_RESTRICTION_NONE) {
ALOGI("CameraService started (pid=%d)", getpid());
mServiceLockWrapper = std::make_shared<WaitableMutexWrapper>(&mServiceLock);
}构造函数执行完成之后，ServiceManager里面也注册了该服务的binder。然后因为CameraService继承了RefBase, 访函数在强引用sp新增引用计数时调用(即当有sp包装的类初始化时调用，在CameraService.h中有"sp<CameraSerive> mCamerService"定义)，因此CameraService对象在第一次被创建时会调用到onFirstRef()函数：
4. CameraService的onFirstRef()
void CameraService::onFirstRef()
{
ALOGI("CameraService process starting");
BnCameraService::onFirstRef(); //调用它父类的onFirstRef()函数
// Update battery life tracking if service is restarting
BatteryNotifier& notifier(BatteryNotifier::getInstance());
notifier.noteResetCamera();
notifier.noteResetFlashlight();
status_t res = INVALID_OPERATION;
//获取CameraProvider信息
res = enumerateProviders();
if (res == OK) {
mInitialized = true;
}5. CameraService::enumerateProviders()
status_t CameraService::enumerateProviders() {
status_t res;
std::vector<std::string> deviceIds;
{
Mutex::Autolock l(mServiceLock);
// 这里就是对mCameraProviderManager创建然后调用它的初始化函数
if (nullptr == mCameraProviderManager.get()) {
// 创建一个CameraProviderManager对象之后调用initilalize(), 其实就是将CameraService设置为CameraProviderManager的监听者
mCameraProviderManager = new CameraProviderManager();
res = mCameraProviderManager->initialize(this); // 传入参数指向当前CameraService实例地址
if (res != OK) {
ALOGE("%s: Unable to initialize camera provider manager: %s (%d)",
__FUNCTION__, strerror(-res), res);
return res;
}
}
// 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();
// 创建flshlight对象
if (nullptr == mFlashlight.get()) {
mFlashlight = new CameraFlashlight(mCameraProviderManager, this);
}
res = mFlashlight->findFlashUnits();
if (res != OK) {
ALOGE("Failed to enumerate flash units: %s (%d)", strerror(-res), res);
}
// 获取摄像头设备ID的向量集合
deviceIds = mCameraProviderManager->getCameraDeviceIds();
}
for (auto& cameraId : deviceIds) {
String8 id8 = String8(cameraId.c_str());
if (getCameraState(id8) == nullptr) {
onDeviceStatusChanged(id8, CameraDeviceStatus::PRESENT);
}
}
return OK;
}
上面创建了一个CameraProviderManager对象将其保存在CameraService中的mCameraProviderManager。继续执行mCameraProviderManager->initialize(this)，这里的this指向就是当前的CameraService对象。因为CameraService继承了CameraProviderManager::statusListener, 可以通过StatusListener将信息从CameraProviderManager中回调给CameraService。
6. CameraProviderManager创建和初始化
struct StatusListener : virtual public RefBase {
~StatusListener() {}
virtual void onDeviceStatusChanged(const String8 &cameraId,
hardware::camera::common::V1_0::CameraDeviceStatus newStatus) = 0;
virtual void onDeviceStatusChanged(const String8 &cameraId,
const String8 &physicalCameraId,
hardware::camera::common::V1_0::CameraDeviceStatus newStatus) = 0;
virtual void onTorchStatusChanged(const String8 &cameraId,
hardware::camera::common::V1_0::TorchModeStatus newStatus) = 0;
virtual void onNewProviderRegistered() = 0;
};
// 第二个参数就是远程代理类，这个参数已经是默认赋值了，实际类HardwareServiceInteractionProxy
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; // mListener的实现是在CameraService中(类似java中的回调机制)
mServiceProxy = proxy;
mDeviceState = static_cast<hardware::hidl_bitfield<provider::V2_5::DeviceState>>(
provider::V2_5::DeviceState::NORMAL);
// Registering will trigger notifications for all already-known providers
// 这里调用到CameraProviderAll.cpp里面，然后调用到了defaultServiceManager()->registerForNOtifications(),
// 从notification是android::hidl::manager::V1_0::IServiceNOtification来看，应该是兼容老的API处理
bool success = mServiceProxy->registerForNotifications(
/* instance name, empty means no filter */ "",
this);
if (!success) {
ALOGE("%s: Unable to register with hardware service manager for notifications "
"about camera providers", __FUNCTION__);
return INVALID_OPERATION;
}
// 这里主要是和CameraProvider和ExternalCameraProvider建立联系，并把对应的代理(Interface)保存到ProviderInfo中
// 所以这里执行完后有两个ProviderInfo对象(保存在Providers中)
for (const auto& instance : mServiceProxy->listServices()) {
this->addProviderLocked(instance);
}
IPCThreadState::self()->flushCommands();
return OK;
}将传递过来的StatusListener赋值给mListener, 然后执行addProviderLocked(instance), instance分别是“legacy/0”和“external/0”与之前分析CameraProvider进程启动的时候注册的binde服务名称对应上。
7. CameraProviderManager::addProviderLocked()和CameraProvider进程建立联系
status_t CameraProviderManager::addProviderLocked(const std::string& newProvider) {
// 检查已知的Provider中是否已存在名为legacy/0和external/0的
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;
}
}
// 这里是通过服务端binder的名字来获取hal的ICameraProvider对象
// mServiceProxy就是HardwareServiceInteractionProxy
sp<provider::V2_4::ICameraProvider> interface;
interface = mServiceProxy->tryGetService(newProvider);
if (interface == nullptr) {
ALOGE("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
newProvider.c_str());
return BAD_VALUE;
}
// 通过ProviderInfo保存得到CameraHal进程的代理对象ICameraProvider
sp<ProviderInfo> providerInfo = new ProviderInfo(newProvider, this);
status_t res = providerInfo->initialize(interface, mDeviceState);
if (res != OK) {
return res;
}
mProviders.push_back(providerInfo);
return OK;
}首先通过tryGetService方法来获取ICameraProvider代理，随后实例化一个providerInfo对象，之后调用其initialize方法乾初始化，最后将ProviderInfo加入到一个内部容器中进行管理。
7.1 保存CameraProvider服务端的代理BpHwCameraProvider
前面获取到的Interface(BpHwCameraPorvider)会保存在新建的一个ProviderInfo对象中，然后调用ProviderInfo::initialize()进行一些初始化。初始化完成后，会将ProviderInfo对象存储在全局变量mProviders中。
status_t CameraProviderManager::ProviderInfo::initialize(
sp<provider::V2_4::ICameraProvider>& interface,
hardware::hidl_bitfield<provider::V2_5::DeviceState> currentDeviceState) {
status_t res = parseProviderName(mProviderName, &mType, &mId);
if (res != OK) {
ALOGE("%s: Invalid provider name, ignoring", __FUNCTION__);
return BAD_VALUE;
}
ALOGI("Connecting to new camera provider: %s, isRemote? %d",
mProviderName.c_str(), interface->isRemote());
// Determine minor version
mMinorVersion = 4;
auto cast2_6 = provider::V2_6::ICameraProvider::castFrom(interface);
sp<provider::V2_6::ICameraProvider> interface2_6 = nullptr;
if (cast2_6.isOk()) {
interface2_6 = cast2_6;
if (interface2_6 != nullptr) {
mMinorVersion = 6;
}
}
// We need to check again since cast2_6.isOk() succeeds even if the provider
// version isn't actually 2.6.
if (interface2_6 == nullptr){
auto cast2_5 =
provider::V2_5::ICameraProvider::castFrom(interface);
sp<provider::V2_5::ICameraProvider> interface2_5 = nullptr;
if (cast2_5.isOk()) {
interface2_5 = cast2_5;
if (interface != nullptr) {
mMinorVersion = 5;
}
}
}
// cameraDeviceStatusChange callbacks may be called (and causing new devices added)
// before setCallback returns
// interface是在ProviderInfo的构造函数中赋值的，也就是上面获取到BpHwCameraProvider
// ProvdierInfo实现了ICameraProviderCallback接口，所以紧接着调用了ICameraProvider的setCallback将自身注册到Camera Provider中，
// ProvdierInfo接收来自CameraProvider进程的事件回调, ProvdierInfo再通过注册的listener回调给CameraService类。
hardware::Return<Status> status = interface->setCallback(this);
if (!status.isOk()) {
ALOGE("%s: Transaction error setting up callbacks with camera provider '%s': %s",
__FUNCTION__, mProviderName.c_str(), status.description().c_str());
return DEAD_OBJECT;
}
if (status != Status::OK) {
ALOGE("%s: Unable to register callbacks with camera provider '%s'",
__FUNCTION__, mProviderName.c_str());
return mapToStatusT(status);
}
// 设置死亡监听
hardware::Return<bool> linked = interface->linkToDeath(this, /*cookie*/ mId);
if (!linked.isOk()) {
ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
__FUNCTION__, mProviderName.c_str(), linked.description().c_str());
return DEAD_OBJECT;
} else if (!linked) {
ALOGW("%s: Unable to link to provider '%s' death notifications",
__FUNCTION__, mProviderName.c_str());
}
if (!kEnableLazyHal) {
// Save HAL reference indefinitely
mSavedInterface = interface;
} else {
mActiveInterface = interface;
}
ALOGV("%s: Setting device state for %s: 0x%" PRIx64,
__FUNCTION__, mProviderName.c_str(), mDeviceState);
notifyDeviceStateChange(currentDeviceState);
res = setUpVendorTags();
if (res != OK) {
ALOGE("%s: Unable to set up vendor tags from provider '%s'",
__FUNCTION__, mProviderName.c_str());
return res;
}
// Get initial list of camera devices, if any
// 可用摄像头列表，里面存放的是CameraId
std::vector<std::string> devices;
// getCameraIdList()参数是一个回调函数，等着Provider进程回调过来数据。主要是将状态ok的摄像头的id存到devices列表里
hardware::Return<void> ret = interface->getCameraIdList([&status, this, &devices](
Status idStatus,
const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
status = idStatus;
if (status == Status::OK) {
for (auto& name : cameraDeviceNames) {
uint16_t major, minor;
std::string type, id;
status_t res = parseDeviceName(name, &major, &minor, &type, &id);
if (res != OK) {
ALOGE("%s: Error parsing deviceName: %s: %d", __FUNCTION__, name.c_str(), res);
status = Status::INTERNAL_ERROR;
} else {
devices.push_back(name);
mProviderPublicCameraIds.push_back(id);
}
}
} });
if (!ret.isOk()) {
ALOGE("%s: Transaction error in getting camera ID list from provider '%s': %s",
__FUNCTION__, mProviderName.c_str(), linked.description().c_str());
return DEAD_OBJECT;
}
if (status != Status::OK) {
ALOGE("%s: Unable to query for camera devices from provider '%s'",
__FUNCTION__, mProviderName.c_str());
return mapToStatusT(status);
}
// Get list of concurrent streaming camera device combinations
if (mMinorVersion >= 6) {
res = getConcurrentCameraIdsInternalLocked(interface2_6);
if (res != OK) {
return res;
}
}
ret = interface->isSetTorchModeSupported(
[this](auto status, bool supported) {
if (status == Status::OK) {
mSetTorchModeSupported = supported;
}
});
if (!ret.isOk()) {
ALOGE("%s: Transaction error checking torch mode support '%s': %s",
__FUNCTION__, mProviderName.c_str(), ret.description().c_str());
return DEAD_OBJECT;
}
mIsRemote = interface->isRemote();
sp<StatusListener> listener = mManager->getStatusListener();
// 遍历Provider进程给过来的摄像头设备列表
for (auto& device : devices) {
std::string id;
// 将设备名和状态(在这里初始成PRESENT)保存起来
status_t res = addDevice(device, 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;
}
}
ALOGI("Camera provider %s ready with %zu camera devices",
mProviderName.c_str(), mDevices.size());
// Process cached status callbacks
std::unique_ptr<std::vector<CameraStatusInfoT>> cachedStatus =
std::make_unique<std::vector<CameraStatusInfoT>>();
{
std::lock_guard<std::mutex> lock(mInitLock);
for (auto& statusInfo : mCachedStatus) {
std::string id, physicalId;
status_t res = OK;
if (statusInfo.isPhysicalCameraStatus) {
res = physicalCameraDeviceStatusChangeLocked(&id, &physicalId,
statusInfo.cameraId, statusInfo.physicalCameraId, statusInfo.status);
} else {
res = cameraDeviceStatusChangeLocked(&id, statusInfo.cameraId, statusInfo.status);
}
if (res == OK) {
cachedStatus->emplace_back(statusInfo.isPhysicalCameraStatus,
id.c_str(), physicalId.c_str(), statusInfo.status);
}
}
mCachedStatus.clear();
mInitialized = true;
}
// The cached status change callbacks cannot be fired directly from this
// function, due to same-thread deadlock trying to acquire mInterfaceMutex
// twice.
if (listener != nullptr) {
mInitialStatusCallbackFuture = std::async(std::launch::async,
&CameraProviderManager::ProviderInfo::notifyInitialStatusChange, this,
listener, std::move(cachedStatus));
}
return OK;
}
Interface->setCallback(this) 这个会调用到CameraProvider里面去，然后这里的this是因为ProviderInfo继承了hardware::camera::provider::V2_4::ICameraProviderCallback（这里ProviderInfo是ICameraProviderCallback的匿名Binder的服务端，实现了回调相关接口）。CameraProvider可以通过ICameraProviderCallback传递消息到CameraService进程的ProviderInfo中，ProviderInfo再通过注册的Listenter将消息回调给CameraService。Interface->getCameraIdList() 这是主动调用获取摄像头列表，这里是通过函数回调形式传递数据。得到摄像头名称的列表之后，就对这个列表进行遍历，根据摄像头的name属性获取摄像头的基本信息并保存起来。
7.2 保存ProviderInfo初始化时获取摄像头的名称信息
上面的代码会继续直到addDevice(device, common::V1_0::CameraDeviceStatus::PRESENT, &id)
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;
// 将传递过来的name(设备名)解析得到 major minor type id等值
status_t res = parseDeviceName(name, &major, &minor, &type, &id);
if (res != OK) {
return res;
}
if (type != mType) {
ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__,
type.c_str(), mType.c_str());
return BAD_VALUE;
}
// 检查摄像头设备是否已添加到ProviderInfo->mDevices中
if (mManager->isValidDeviceLocked(id, major)) {
ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__,
name.c_str(), id.c_str(), major);
return BAD_VALUE;
}
std::unique_ptr<DeviceInfo> deviceInfo;
// 这里分析的是Camera2的API, 因此是case3分支
switch (major) {
case 1:
deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, mProviderTagid,
id, minor);
break;
case 3:
// 根据上面的信息去创建一个DeviceInfo3的对象
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;
// 将传递过来的CameraDeviceStatus::PRESENT状态赋值给创建的DeviceInfo对象
deviceInfo->mStatus = initialStatus;
bool isAPI1Compatible = deviceInfo->isAPI1Compatible();
// 将创建的DeviceInfo对象保存到ProviderInfo的mDevices中
mDevices.push_back(std::move(deviceInfo));
// 将CameraId存放到UniqueCameraIds
mUniqueCameraIds.insert(id);
// 摄像头是否支持camera api1
if (isAPI1Compatible) {
// addDevice can be called more than once for the same camera id if HAL
// supports openLegacy.
if (std::find(mUniqueAPI1CompatibleCameraIds.begin(), mUniqueAPI1CompatibleCameraIds.end(),
id) == mUniqueAPI1CompatibleCameraIds.end()) {
mUniqueAPI1CompatibleCameraIds.push_back(id);
}
}
if (parsedId != nullptr) {
*parsedId = id;
}
return OK;
}根据摄像头的设备名称信息获取到摄像头的major minor type id等值后做了一些基本的校验，然后根据这些信息调用initializeDeviceInfo<DeviceInfo3>(name, mProviderTagid, id, minor) 创建一个DeviceInfo3对象。
7.2.1 CameraProviderManager::ProviderInfo::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) {
Status status;
// DeviceInfo3 中 typedef hardware::camera::device::V3_2::ICameraDevice InterfaceT;
// cameraInterface -- ICameDevice的代理和provider进程来通信 这里的模板是device::V3_2::ICameraDevice在Provider进程中的device/3.2/ICameraDevice.hal
auto cameraInterface =
startDeviceInterface<typename DeviceInfoT::InterfaceT>(name);
if (cameraInterface == nullptr) return nullptr;
CameraResourceCost resourceCost;
// 调用到provider进程中的CameraDevice，然后通过回调接收数据
cameraInterface->getResourceCost([&status, &resourceCost](
Status s, CameraResourceCost cost) {
status = s;
resourceCost = cost;
});
if (status != Status::OK) {
ALOGE("%s: Unable to obtain resource costs for camera device %s: %s", __FUNCTION__,
name.c_str(), statusToString(status));
return nullptr;
}
for (auto& conflictName : resourceCost.conflictingDevices) {
uint16_t major, minor;
std::string type, id;
status_t res = parseDeviceName(conflictName, &major, &minor, &type, &id);
if (res != OK) {
ALOGE("%s: Failed to parse conflicting device %s", __FUNCTION__, conflictName.c_str());
return nullptr;
}
conflictName = id;
}
return std::unique_ptr<DeviceInfo>(
new DeviceInfoT(name, tagId, id, minorVersion, resourceCost, this,
mProviderPublicCameraIds, cameraInterface));
}获取CameraProvider进程中的的ICameraDevice.hal的代理--cameraInterface，这里的 getDeviceInterface<typename DeviceInfoT::InterfaceT>(name)函数中的模板是hardware::camera::device::V3_2::ICameraDevice所以会调用到对应版的函数如下：
然后通过cameraInterface->getResourceCost()获取摄像头设备的一些属性信息(也就是前面CameraProvider进程中的camera_info)。
7.2.1.1 首先看看如何得到ICameraDevice的代理
ICameraDevice.hal 会生成ICameraDevice.h 文件
template<>
sp<device::V1_0::ICameraDevice>
CameraProviderManager::ProviderInfo::startDeviceInterface
<device::V1_0::ICameraDevice>(const std::string &name) {
Status status;
sp<device::V1_0::ICameraDevice> cameraInterface;
hardware::Return<void> ret;
const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
if (interface == nullptr) {
return nullptr;
}
// 这里主要是调用CameraProvider中的getCameraDeviceInterface_V1_x(name)函数，name就是前面获取到的设备名称
ret = interface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
Status s, sp<device::V1_0::ICameraDevice> interface) {
status = s;
cameraInterface = interface;
});
if (!ret.isOk()) {
ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
__FUNCTION__, name.c_str(), ret.description().c_str());
return nullptr;
}
if (status != Status::OK) {
ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
name.c_str(), statusToString(status));
return nullptr;
}
// 返回provider进程中ICameraDevice的代理
return cameraInterface;
}这个主要是用到了前面获取到的ICameraProvider的代理（Interface）之后调用其getCameraDeviceInterface_V3_x(name)函数，然后通过回调的形式收到ICameraDevice的代理（可以看出这里也使用到了匿名Binder）。
至此，CameraService进程的启动流程分析完了，大致总结启动流程：
1、创建一个CameraProviderManager对象来负责管理和provider进程的IPC.
2、在CameraProviderManager里会创建一个ProviderInfo对象来保存和provider进程通信的ICameraProvider.hal的代理。
3、通过ICameraProvider获取摄像头的数量，然后遍历摄像头个数，通过调用ICameraProvider中的getCameraDeviceInterface_V3_x()函数创建ICameraDevice的服务端实例，并将其代理作为参数来创建DeviceInfo3对象。
CameraService 1---1 CameraProviderManager 1---1 ProviderInfo 1---M DeviceInfo3
其中，ProviderInfo持有provider进程中CameraProvider的代理，DeviceInfo3持有provider进程中的CameraDevice的代理。
8725
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
