上面这张图比较清楚的表现了camera provider进程在camera架构中位置,作为承上启下的部分,和cameraserver进程和底层的驱动交互,camera provider进程非常重要,camera HAL层几乎全部运行在camera provider进程中完成。
首先看下camera provider所在源码中的位置:hardware/interfaces/camera/provider/
可以看出来在hardware/interfaces/camera/provider/2.4/default/ 下面有几个rc文件,Android初始化就是执行这些rc文件,这里执行的是android.hardware.camera.provider@2.4-service.rc文件,看看其中的执行代码。
1 service vendor.camera-provider-2-4 /vendor/bin/hw/android.hardware.camera.provider@2.4-service 2 class hal 3 user cameraserver 4 group audio camera input drmrpc 5 ioprio rt 4 6 capabilities SYS_NICE 7 writepid /dev/cpuset/camera-daemon/tasks /dev/stune/top-app/tasks
第一行就看到了启动一个 /vendor/bin/hw/android.hardware.camera.provider@2.4-service 进程。
Cameraserver 执行文件对应的源码为:frameworksavcameracameraservermain_cameraserver.cpp
1 service cameraserver /system/bin/cameraserver 2 class main 3 user cameraserver 4 group audio camera input drmrpc 5 ioprio rt 4 6 writepid /dev/cpuset/camera-daemon/tasks /dev/stune/top-app/tasks 7 rlimit rtprio 10 10
接下来看具体的流程:
cameraserver 与 provider 这两个进程启动、初始化的调用逻辑
总体逻辑顺序:
provider 进程启动,注册;
cameraserver 进程启动,注册,初始化;
cameraserver 获取远端 provider(此时实例化 CameraProvider 并初始化)。
上图中,实线箭头是调用关系。左边是 cameraserver 进程中的动作,右边则是 provider 进程中的动作,它们之间通过 ICameraProvider 联系在了一起,而这个东西与 HIDL 相关,我们可以不用关心它的实现方式。
由图可见:
cameraserver 一侧,Cameraservice 类依旧是主体。它通过 CameraProviderManager 来管理对 CameraProvider 的操作。此处初始化的最终目的是连接上 CameraProvider。
provider 一侧,最终主体是 CameraProvider。初始化最终目的是得到一个 mModule,通过它可以直接与 HAL 接口定义层进行交互。
至此,我们就能对 Android O 上的 Camera 服务启动流程有一个大致的了解。但由于我个人功力尚浅,目前只能理解到这个地步,还无法轻易抽象出更容易理解的框架,所以图片中的流程还是比较凌乱的,可能需要对照相应代码才能理解
CameraProvider 的启动与注册
这个服务进程的启动很简单,主要动作是注册该 CameraProvider,以便 CameraServer 启动时能找到它。需要注意的是,此时 CameraProvider 还未实例化与初始化。
Service.cpp
文件位置:hardwareinterfacescameraprovider2.4default
看代码:
第 6 行:与 /dev/vndbinder 进行某种关联,注释表明 Camera HAL 可能会通过它与其它 vendor 组件进行通信。
第 7 行:创建默认为直通模式(passthrough)的 CameraProvider 服务实现。
1 int main() 2 { 3 ALOGI("Camera provider Service is starting."); 4 // The camera HAL may communicate to other vendor components via 5 // /dev/vndbinder 6 android::ProcessState::initWithDriver("/dev/vndbinder"); 7 return defaultPassthroughServiceImplementation<ICameraProvider>("legacy/0", /*maxThreads*/ 6); 8 }
LegacySupport.h
文件路径:systemlibhidl ransportincludehidl
该函数做了这些事:第 5 行:配置 RPC 线程池(当前设置最大线程为 6)。
第 6 行:将 Interface(即 CameraProvider)以入参 legacy/0 为名注册到相应的管理服务中。
第 12 行:连接到线程池。
1 template<class Interface> 2 __attribute__((warn_unused_result)) 3 status_t defaultPassthroughServiceImplementation(std::string name, 4 size_t maxThreads = 1) { 5 configureRpcThreadpool(maxThreads, true); 6 status_t result = registerPassthroughServiceImplementation<Interface>(name); 7 8 if (result != OK) { 9 return result; 10 } 11 12 joinRpcThreadpool(); 13 return 0; 14 }
registerPassthroughServiceImplementation 的模板在 LegacySupport.h 接下来就是hidl 相关的实现
1 template<class Interface> 2 __attribute__((warn_unused_result)) 3 status_t registerPassthroughServiceImplementation( 4 std::string name = "default") { 5 sp<Interface> service = Interface::getService(name, true /* getStub */); //从当前进程空间中拿到IComposer接口类对象 6 7 if (service == nullptr) { 8 ALOGE("Could not get passthrough implementation for %s/%s.", 9 Interface::descriptor, name.c_str()); 10 return EXIT_FAILURE; 11 } 12 13 LOG_FATAL_IF(service->isRemote(), "Implementation of %s/%s is remote!", 14 Interface::descriptor, name.c_str()); 15 16 status_t status = service->registerAsService(name);//将IComposer注册到hwservicemanager中 17 18 if (status == OK) { 19 ALOGI("Registration complete for %s/%s.", 20 Interface::descriptor, name.c_str()); 21 } else { 22 ALOGE("Could not register service %s/%s (%d).", 23 Interface::descriptor, name.c_str(), status); 24 } 25 26 return status; 27 }
这里可以看一下 google 关于注册服务 registerAsService 的描述: https://source.android.google.cn/devices/architecture/hidl/services
HIDL 接口服务器(实现接口的对象)可注册为已命名的服务。注册的名称不需要与接口或软件包名称相关。如果没有指定名称,则使用名称“默认”;这应该用于不需要注册同一接口的两个实现的 HAL。例如,在每个接口中定义的服务注册的 C++ 调用是:
status_t status = myFoo->registerAsService(); status_t anotherStatus = anotherFoo->registerAsService("another_foo_service"); // if needed
HIDL 接口的版本包含在接口本身中。版本自动与服务注册关联,并可通过每个 HIDL 接口上的方法调用 (android::hardware::IInterface::getInterfaceVersion()
) 进行检索。服务器对象不需要注册,并可通过 HIDL 方法参数传递到其他进程,相应的接收进程会向服务器发送 HIDL 方法调用。
CameraService 的启动与初始化
一般来说应该是 Provider 服务先启动,然后 Cameraserver 再启动,并 ”连接“ 到 Provider。
前面已经分析了 Provider 的启动,现在就来看看 Cameraserver 的启动流程。
main_cameraserver.cpp
文件位置:frameworksavcameracameraserver
- 关于线程池配置的部分就忽略吧,主要关注第 11 行,在该进程中实例化了 CameraService。
- 实例化只有简单的一行代码,但实例化的过程并不那么简单。这个 instantiate() 接口并不是定义在 CameraService 类中的,而是定义在 BinderService 类里(而 CameraService 继承了它)。在此处,它的作用是创建一个 CameraService(通过 new 的方式),并将其加入到 ServiceManager 中(注意,在这一过程中,CameraService 被强指针引用了)。
1 int main(int argc __unused, char** argv __unused) 2 { 3 signal(SIGPIPE, SIG_IGN); 4 5 // Set 3 threads for HIDL calls 6 hardware::configureRpcThreadpool(3, /*willjoin*/ false); 7 8 sp<ProcessState> proc(ProcessState::self()); 9 sp<IServiceManager> sm = defaultServiceManager(); 10 ALOGI("ServiceManager: %p", sm.get()); 11 CameraService::instantiate(); 12 ProcessState::self()->startThreadPool(); 13 IPCThreadState::self()->joinThreadPool(); 14 }
CameraService.cpp
文件位置:frameworksavservicescameralibcameraservice
由于首次被强指针引用时,就会调用 onFirstRef() 函数执行初始化之类的业务逻辑,所以现在就看看 CameraService 在此处实现了什么逻辑。
onFirstRef
- 根据 12~ 17 行可以知道,初始化的主要逻辑实现应该在 enumerateProviders() 函数中。
- 而最后在 19 行调用一个 ping 函数,可能是在尝试连接到服务代理吧,不管它。
1 void CameraService::onFirstRef() 2 { 3 ALOGI("CameraService process starting"); 4 5 BnCameraService::onFirstRef(); 6 7 // Update battery life tracking if service is restarting 8 BatteryNotifier& notifier(BatteryNotifier::getInstance()); 9 notifier.noteResetCamera(); 10 notifier.noteResetFlashlight(); 11 12 status_t res = INVALID_OPERATION; 13 14 res = enumerateProviders(); 15 if (res == OK) { 16 mInitialized = true; 17 } 18 19 CameraService::pingCameraServiceProxy(); 20 }
enumerateProviders
- 函数内容略多,所以只截取需要重点关注的部分。
- 首先将 CameraProviderManager 实例化(第 2 行),然后调用 initialize() 接口将其初始化(第 3 行),传入的参数是 this 指针,指向当前 CameraService 实例的地址。
1 if (nullptr == mCameraProviderManager.get()) { 2 mCameraProviderManager = new CameraProviderManager(); 3 res = mCameraProviderManager->initialize(this); 4 if (res != OK) { 5 ALOGE("%s: Unable to initialize camera provider manager: %s (%d)", 6 __FUNCTION__, strerror(-res), res); 7 return res; 8 } 9 }
CameraProviderManager.cpp
文件位置:frameworksavservicescameralibcameraservicecommon
initialize
在分析具体实现之前,可以先看看它在头文件中的声明:
- 用于初始化管理器,并给它设置一个状态监听(即 CameraService 实例)。选择性地接受一个与服务交互的代理。
- 默认的代理通过 Hardware 服务管理器进行通信。备用的代理可以用来进行测试。代理的生命周期必须要超过管理器的生命周期。
- 注意到在 enumerateProviders 中调用该接口时,只有一个入参,说明当前用的是默认代理。
1 /** 2 * Initialize the manager and give it a status listener; optionally accepts a service 3 * interaction proxy. 4 * 5 * The default proxy communicates via the hardware service manager; alternate proxies can be 6 * used for testing. The lifetime of the proxy must exceed the lifetime of the manager. 7 */ 8 status_t initialize(wp<StatusListener> listener, 9 ServiceInteractionProxy *proxy = &sHardwareServiceInteractionProxy);
接下来看看具体实现的逻辑:
- 第 11~19 行:通过服务代理作出一个注册动作。根据注释,注册会触发一个给所有已知 Provider 进行通知的动作。
- 第 22 行:这是我们主要关注的函数。注释翻译过来是这样,看看这是否为一个直通的 HAL,如果不是也没关系。注意传入的参数 kLegacyProviderName,在文件开头有它的定义,即为字符串 legacy/0。
1 status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener, 2 ServiceInteractionProxy* proxy) { 3 std::lock_guard<std::mutex> lock(mInterfaceMutex); 4 if (proxy == nullptr) { 5 ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__); 6 return BAD_VALUE; 7 } 8 mListener = listener; 9 mServiceProxy = proxy; 10 11 // Registering will trigger notifications for all already-known providers 12 bool success = mServiceProxy->registerForNotifications( 13 /* instance name, empty means no filter */ "", 14 this); 15 if (!success) { 16 ALOGE("%s: Unable to register with hardware service manager for notifications " 17 "about camera providers", __FUNCTION__); 18 return INVALID_OPERATION; 19 } 20 21 // See if there's a passthrough HAL, but let's not complain if there's not 22 addProviderLocked(kLegacyProviderName, /*expected*/ false); 23 24 return OK; 25 }
上面是CameraProviderManager的初始化过程,CameraProviderManager就是管理camera Service与camera provider之间通信的工程管理类,两个参数,其中第二个参数就是远程代理类。这个参数已经是默认赋值了。不信可以看下CameraProviderManager::initialize的定义。
1 status_t initialize(wp<StatusListener> listener, 2 ServiceInteractionProxy *proxy = &sHardwareServiceInteractionProxy);
这是定义,默认值就是 ----> sHardwareServiceInteractionProxy,这个sHardwareServiceInteractionProxy是 ----> HardwareServiceInteractionProxy 的实例,可以看出在HardwareServiceInteractionProxy定义中,已经直接调用了ICameraProvider--->getService(...)了。
1 // Standard use case - call into the normal generated static methods which invoke 2 // the real hardware service manager 3 struct HardwareServiceInteractionProxy : public ServiceInteractionProxy { 4 virtual bool registerForNotifications( 5 const std::string &serviceName, 6 const sp<hidl::manager::V1_0::IServiceNotification> 7 ¬ification) override { 8 return hardware::camera::provider::V2_4::ICameraProvider::registerForNotifications( 9 serviceName, notification); 10 } 11 virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService( 12 const std::string &serviceName) override { 13 return hardware::camera::provider::V2_4::ICameraProvider::getService(serviceName); 14 } 15 };
addProviderLocked
这个函数主要作用是将找到的这个 Provider 通过 ProviderInfo 记录下来并初始化。这儿就实现了camera service与camera provider的桥接了。
- 第 2~8 行:检查已知的 Provider 中是否已有名为 legacy/0 的。
- 第 10~21 行:根据 legacy/0 从服务代理处获取 CameraProvider 接口,这里需要特别注意,因为此处真正地初始化了对应的 CameraProvider(怎么就在这初始化了?下一节继续分析)。
- 第 23~28 行:通过 ProviderInfo 来保存当前 Provider 相关信息。
- 第 30 行:记录当前 Provider。
1 status_t CameraProviderManager::addProviderLocked(const std::string& newProvider, bool expected) { 2 for (const auto& providerInfo : mProviders) { 3 if (providerInfo->mProviderName == newProvider) { 4 ALOGW("%s: Camera provider HAL with name '%s' already registered", __FUNCTION__, 5 newProvider.c_str()); 6 return ALREADY_EXISTS; 7 } 8 } 9 10 sp<provider::V2_4::ICameraProvider> interface; 11 interface = mServiceProxy->getService(newProvider); 12 13 if (interface == nullptr) { 14 if (expected) { 15 ALOGE("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__, 16 newProvider.c_str()); 17 return BAD_VALUE; 18 } else { 19 return OK; 20 } 21 } 22 23 sp<ProviderInfo> providerInfo = 24 new ProviderInfo(newProvider, interface, this); 25 status_t res = providerInfo->initialize(); 26 if (res != OK) { 27 return res; 28 } 29 30 mProviders.push_back(providerInfo); 31 32 return OK; 33 }
这里可以看一下 google 关于注册服务 getService 的描述: https://source.android.google.cn/devices/architecture/hidl/services
发现服务
客户端代码按名称和版本请求给定的接口,并对所需的 HAL 类调用 getService:
1 // C++ 2 sp<V1_1::IFooService> service = V1_1::IFooService::getService(); 3 sp<V1_1::IFooService> alternateService = V1_1::IFooService::getService("another_foo_service"); 4 // Java 5 V1_1.IFooService service = V1_1.IFooService.getService(true /* retry */); 6 V1_1.IFooService alternateService = V1_1.IFooService.getService("another", true /* retry */);
每个版本的 HIDL 接口都会被视为单独的接口。因此,IFooService 版本 1.1 和 IFooService 版本 2.2 都可以注册为“foo_service”,在任一接口上调用 getService("foo_service") 都会获得相应接口的已注册服务。因此,在大多数情况下,注册或发现服务均无需提供名称参数(也就是说名称为“默认”)。
供应商接口对象还会影响所返回接口的传输方法。对于软件包 android.hardware.foo@1.0 中的接口 IFoo,IFoo::getService 返回的接口始终使用设备清单中针对 android.hardware.foo 声明的传输方法(如果相应条目存在的话);如果该传输方法不存在,则返回 nullptr。
在某些情况下,即使没有获得相关服务,也可能需要立即继续。例如,当客户端希望自行管理服务通知或者在需要获得所有 hwservice 并检索它们的诊断程序(如 atrace)中时,可能会发生这种情况。在这种情况下,可以使用其他 API,如 C++ 中的 tryGetService 或 Java 中的 getService("instance-name", false)。Java 中提供的旧版 API getService 也必须与服务通知一起使用。使用此 API 不会避免以下竞态条件:当客户端使用某个非重试 API 请求服务器后,该服务器对自身进行了注册。
CameraProviderManager中提供了一个ProviderInfo来保存Camera provider信息,方便管理camera service调用 camera provider,下面分析一下ProviderInfo是怎么样的?方便我们接下来从这个为切入掉分析camera provider里面代码。
1 struct ProviderInfo : 2 virtual public hardware::camera::provider::V2_4::ICameraProviderCallback, 3 virtual public hardware::hidl_death_recipient 4 { 5 const std::string mProviderName; 6 const sp<hardware::camera::provider::V2_4::ICameraProvider> mInterface; 7 8 ProviderInfo(const std::string &providerName, 9 sp<hardware::camera::provider::V2_4::ICameraProvider>& interface, 10 CameraProviderManager *manager); 11 12 13 status_t initialize(); 14 status_t addDevice(const std::string& name, 15 hardware::camera::common::V1_0::CameraDeviceStatus initialStatus = 16 hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT, 17 /*out*/ std::string *parsedId = nullptr); 18 19 20 // ICameraProviderCallbacks interface - these lock the parent mInterfaceMutex 21 virtual hardware::Return<void> cameraDeviceStatusChange( 22 const hardware::hidl_string& cameraDeviceName, 23 hardware::camera::common::V1_0::CameraDeviceStatus newStatus) override; 24 virtual hardware::Return<void> torchModeStatusChange( 25 const hardware::hidl_string& cameraDeviceName, 26 hardware::camera::common::V1_0::TorchModeStatus newStatus) override; 27 28 29 // hidl_death_recipient interface - this locks the parent mInterfaceMutex 30 virtual void serviceDied(uint64_t cookie, const wp<hidl::base::V1_0::IBase>& who) override; 31 32 33 //...... 34 };
ProviderInfo继承了 hardware::camera::provider::V2_4::ICameraProviderCallback 与 hardware::hidl_death_recipient,其中ProviderInfo 第 2个参数就是camera service与cameraprovider通信的IPC接口,保证两层可以顺利通信。
ICameraProviderCallback 是 camera provider的 回调接口,也是可以IPC间通信的,hardware::hidl_death_recipient 是hal层的死亡回调接口,方便在底层死亡的时候通知上层。
initialize() ----> initialize 函数的主要作用是初始化camera provider,并且IPC调用到camera provider 获取camera device信息,然后调用 addDevice接口将获取的camera device保存在内存中。
addDevice ----> 将底层获取的camera device信息保存在camera service中,防止多次跨进程调用。
cameraDeviceStatusChange 与 torchModeStatusChange 都是 ICameraProviderCallback 的回调函数,当camera provider发生变化的时候需要通知上层这些变化。
serviceDied 是 hardware::hidl_death_recipient 的回调函数,当底层发生问题的时候会通知上层变化。
我们在camera service中就是使用 ProviderInfo 来和底层的camera provider通信,保存camera device顺利运行。
CameraProvider 的初始化
在 CameraService 的初始化过程中,CameraProvider 才开始进行初始化,只不过这个初始化是通过服务代理进行远端调用而进行的。
在 CameraProviderManager::addProviderLocked 函数的实现逻辑中,调用了 ICameraProvider::getService 接口,该接口最终会调用到一个名为 HIDL_FETCH_ICameraProvider 的函数。
CameraProvider.cpp
文件位置:hardwareinterfacescameraprovider2.4default
HIDL_FETCH_ICameraProvider
若传入的参数是 legacy/0,则创建一个 CameraProvider 实例(构造函数中调用了它自身的初始化函数)并返回相应指针给函数调用者。
1 ICameraProvider* HIDL_FETCH_ICameraProvider(const char* name) { 2 if (strcmp(name, kLegacyProviderName) != 0) { 3 return nullptr; 4 } 5 CameraProvider* provider = new CameraProvider(); 6 if (provider == nullptr) { 7 ALOGE("%s: cannot allocate camera provider!", __FUNCTION__); 8 return nullptr; 9 } 10 if (provider->isInitFailed()) { 11 ALOGE("%s: camera provider init failed!", __FUNCTION__); 12 delete provider; 13 return nullptr; 14 } 15 return provider; 16 }
initialize
整个函数实现比较冗长,只贴出我们需要关注的部分分析。
- 第 1~7 行:需要注意 rawModule 这个指针指向的结构,通过 hw_get_module 函数获取到它的实例(从相应的 Camera HAL 动态库中加载得到)。实际上这个结构就是连接到 HAL 层的关键点,通过它就可以调用到 HAL 中的一些函数。
- (关于 hw_get_module,我以前分析过 Android N 上相关的逻辑,在 O 上其实没有很大改动,如果要详细了解可以去看看那篇文章)
- 第 9~15 行:基于 rawModule 创建 CameraModule 实例并初始化。之后都是通过 mModule 来对 HAL 进行操作的。(其实 CameraModule 是对于 camera_module_t 的一层封装,诸如 init、open 这样的操作,实际上都是通过调用 camera_module_t 结构中函数指针指向的 HAL 层的具体实现函数来完成的)
- 执行完这个函数,CameraProvider 也就随之初始化完成了。
1 camera_module_t *rawModule; 2 int err = hw_get_module(CAMERA_HARDWARE_MODULE_ID, 3 (const hw_module_t **)&rawModule); 4 if (err < 0) { 5 ALOGE("Could not load camera HAL module: %d (%s)", err, strerror(-err)); 6 return true; 7 } 8 9 mModule = new CameraModule(rawModule); 10 err = mModule->init(); 11 if (err != OK) { 12 ALOGE("Could not initialize camera HAL module: %d (%s)", err, strerror(-err)); 13 mModule.clear(); 14 return true; 15 } 16 ALOGI("Loaded "%s" camera module", mModule->getModuleName());
期间使用了camera_module_t这个结构体。可以看下 CameraModule::init函数。
1 int CameraModule::init() { 2 ATRACE_CALL(); 3 int res = OK; 4 if (getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_4 && 5 mModule->init != NULL) { 6 ATRACE_BEGIN("camera_module->init"); 7 res = mModule->init(); 8 ATRACE_END(); 9 } 10 mCameraInfoMap.setCapacity(getNumberOfCameras()); 11 return res; 12 }
这儿调用的mModule->init(); 这个mModule就是camera_module_t结构体对象
1 typedef struct camera_module { 2 hw_module_t common; 3 int (*get_number_of_cameras)(void); 4 int (*get_camera_info)(int camera_id, struct camera_info *info); 5 int (*set_callbacks)(const camera_module_callbacks_t *callbacks); 6 void (*get_vendor_tag_ops)(vendor_tag_ops_t* ops); 7 int (*open_legacy)(const struct hw_module_t* module, const char* id, 8 uint32_t halVersion, struct hw_device_t** device); 9 int (*set_torch_mode)(const char* camera_id, bool enabled); 10 int (*init)(); 11 void* reserved[5]; 12 } camera_module_t;
结构体中有一些函数指针,我们现在需要搞清楚这些函数指针被映射到什么地方了? camx 和 mm-camera 是一样的实现 类似于:(关于qcom的code只是copy了其他博文上的code)
1 camera_module_t HAL_MODULE_INFO_SYM __attribute__ ((visibility("default"))) = { 2 .common = { 3 .tag = HARDWARE_MODULE_TAG, 4 .module_api_version = CAMERA_MODULE_API_VERSION_2_2, 5 .hal_api_version = HARDWARE_HAL_API_VERSION, 6 .id = CAMERA_HARDWARE_MODULE_ID, 7 .name = "Default Camera HAL", 8 .author = "The Android Open Source Project", 9 .methods = &gCameraModuleMethods, 10 .dso = NULL, 11 .reserved = {0}, 12 }, 13 .get_number_of_cameras = get_number_of_cameras, 14 .get_camera_info = get_camera_info, 15 .set_callbacks = set_callbacks, 16 .get_vendor_tag_ops = get_vendor_tag_ops, 17 .open_legacy = NULL, 18 .set_torch_mode = NULL, 19 .init = NULL, 20 .reserved = {0}, 21 };
1 static hw_module_t camera_common = { 2 .tag = HARDWARE_MODULE_TAG, 3 .module_api_version = CAMERA_MODULE_API_VERSION_2_4, 4 .hal_api_version = HARDWARE_HAL_API_VERSION, 5 .id = CAMERA_HARDWARE_MODULE_ID, 6 .name = "QCamera Module", 7 .author = "Qualcomm Innovation Center Inc", 8 .methods = &qcamera::QCamera2Factory::mModuleMethods, 9 .dso = NULL, 10 .reserved = {0} 11 }; 12 13 camera_module_t HAL_MODULE_INFO_SYM = { 14 .common = camera_common, 15 .get_number_of_cameras = qcamera::QCamera2Factory::get_number_of_cameras, 16 .get_camera_info = qcamera::QCamera2Factory::get_camera_info, 17 .set_callbacks = qcamera::QCamera2Factory::set_callbacks, 18 .get_vendor_tag_ops = qcamera::QCamera3VendorTags::get_vendor_tag_ops, 19 .open_legacy = NULL, 20 .set_torch_mode = qcamera::QCamera2Factory::set_torch_mode, 21 .init = NULL, 22 .reserved = {0} 23 };
小结
在 Android O 之前,Service 与 HAL 的耦合比较严重,而现在 Google 通过 HIDL 这个进程通信机制将他们分隔成两个进程,这使得 Service 与 HAL 之间的通路建立过程变得复杂了一些。
本文对 Android O 上,这两个进程的启动与初始化流程进行了简单的分析。总体来说是如下逻辑顺序:
- android.hardware.camera.provider@2.4-service 进程启动,仅注册 Provider;
- cameraserver 进程启动,实例化 CameraService,并注册到 ServiceManager 中;
- 由于强指针首次引用,CameraService::onFirstRef() 被调用,相当于进行初始化;
- 在 CameraService 初始化过程中,通过 CameraProviderManager 来获取已注册的 Provider,并实例化、初始化 CameraProvider;
- CameraProvider 初始化过程中,从动态库中加载了 HAL 层的关键结构,并将其封装到 CameraModule 中;
- 将获取到的 CameraProvider 保存在 ProviderInfo 中,以便后续的使用。
这其实就相当于 Android N 之前,整个 cameraserver 的启动流程。殊途同归,最后都是通过 CameraModule 及其内部的 camera_module_t 连接到 Camera HAL。