Android Camera HIDL交互分析

最新推荐文章于 2023-02-27 10:02:10 发布

welljrj

最新推荐文章于 2023-02-27 10:02:10 发布

阅读量2.7k

点赞数 1

分类专栏： android_framwork

本文链接：https://blog.csdn.net/welljrj/article/details/106927861

版权

android_framwork 专栏收录该内容

4 篇文章 7 订阅

订阅专栏

Android Camera HIDL交互分析

1.1 java 层openCamera逻辑

APP层调用CameraManager中的openCamera打开camera。

APP-->openCamera

|---> openCameraForUid

|--->openCameraDeviceUserAsync

① 首先通过cameraService = CameraManagerGlobal.get().getCameraService(); 获取binder 与C++ 层cameraService的ICameraService服务接口，

② 然后通过binder 通信机制，使用cameraService.connectDevice调用cameraService的C++层的connectDevice函数

源码位置： framework/base/core/java/android/hardware/camera2/

1. C++层逻辑

① cameraservice服务启动

Android在启动的时， init进程解析cameraserver.rc后会启动cameraserver native服务进程

frameworks/av/camera/cameraserver/cameraserver.rc

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
rlimit rtprio 10 10

cameraserver main函数如下：

frameworks/av/camera/cameraserver/main_cameraserver.cpp

#define LOG_TAG "cameraserver"
//#define LOG_NDEBUG 0
#include "CameraService.h"
#include <hidl/HidlTransportSupport.h>
using namespace android;
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();
ALOGI("ServiceManager: %p", sm.get());
CameraService::instantiate();
ProcessState::self()->startThreadPool();
IPCThreadState::self()->joinThreadPool();
}

CameraService::instantiate()就进入了libcameraservice中CameraService类然后初始化service后。Java层可以通过service manager获取到，然后又回到JAVA层的connectDevice了。

② connectDevice逻辑分析

connectDevice逻辑简化如下：

CameraService：：connectDevice

|--->connectHelper

|---> CameraDeviceClient

|---> Camera2ClientBase

|---> Camera3Device::initialize

|---> CameraProviderManager->openSession

源码位置：framework/av/services/camera/libcameraservice

openSession 中通过获取HIDL获取HAL层服务。具体流程如下：

status_t CameraProviderManager::openSession(const std::string &id,
const sp<device::V3_2::ICameraDeviceCallback>& callback,
/*out*/
sp<device::V3_2::ICameraDeviceSession> *session) {
auto deviceInfo = findDeviceInfoLocked(id,
/*minVersion*/ {3,0}, /*maxVersion*/ {4,0}); // 第一步
if (deviceInfo == nullptr) return NAME_NOT_FOUND;
auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);
const sp<provider::V2_4::ICameraProvider> provider =
deviceInfo->mParentProvider->startProviderInterface();// 第二步
...
...
...
auto interface = deviceInfo3->startDeviceInterface<
CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>(); // 第三步
ret = interface->open(callback, [&status, &session]
(Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
status = s;
if (status == Status::OK) {
*session = cameraSession;
}
}); //第四部
...
...
...
return mapToStatusT(status);
}

上述代码为了方便阅读，已经简化。主要流程如下：

第一步：通过版本号，找到deviceInfo

第二步：通过HIDL 中的 provider::V2_4::ICameraProvider获取android.hardware.camera.provider@2.4指针

第三步：通过HIDL 中的device::V3_2::ICameraDevice 获取android.hardware.camera.device hidl指针

第四部：调用HAL层中device::V3_2::ICameraDevice 中的 open。传递参数很重要：

device::V3_2::ICameraDeviceCallback callback 这个参数是framework给HAL层回调的
device::V3_2::ICameraDeviceSession>& cameraSession，这个cameraSession由HAL赋值后传给framework

上述四个步骤使我们明白： framework层是如何通过HIDL与HAL建立交互的，使用的HIDL接口

如下（其他版本号先不做分析）：

android.hardware.camera.provider@2.4
android.hardware.camera.device@3.2包含ICameraDeviceSession
android.hardware.camera.common@1.0

源码目录如下：

hardware/interfaces/camera
├── common
│ └── 1.0
├── device
│ ├── 1.0
│ ├── 3.2
│ ├── 3.3
│ ├── 3.4
│ └── 3.5
├── metadata
│ ├── 3.2
│ ├── 3.3
│ └── 3.4
└── provider
├── 2.4
└── 2.5

上述以数字为名的目录代表版本号。可以通过manifest.xml确定。其他可以分析函数CameraProviderManager::openSession。首先分析android.hardware.camera.provider

1. android.hardware.camera.provider的创建过程

android.hardware.camera.provider对应的interface是ICameraProvider。

调用时序图如下：

① CameraServicer 新建后，会调用onFirstRef。这个属于android强弱指针中的内容，这里不分析。

② 接着调用enumerateProviders，然后构造CameraProviderManager调用其中的initialize。

③ initialize的第二个参数，就是一个已经固定好的static结构体变量sHardwareServiceInteractionProxy。里面包含两个静态方法registerForNotifications和getService

结构体HardwareServiceInteractionProxy源码如下：

// Standard use case - call into the normal generated static methods which invoke
// the real hardware service manager
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 {
return hardware::camera::provider::V2_4::ICameraProvider::getService(serviceName);
}
};

④ 然后又在initialize通过mServiceProxy->registerForNotifications调用上述静态方法registerForNotifications

⑤ 一步一步调用到真正的硬件管理服务android::hidl::manager::V1_0::IServiceManager，调用ICameraProvider的函数实现在hidl-gen C++目录中：

out/soong/.intermediates/hardware/interfaces/camera/provider/2.4/android.hardware.camera.provider@2.4_genc++/gen/android/hardware/camera/provider/2.4/CameraProviderAll.cpp

源码如下：

::android::sp<ICameraProvider> ICameraProvider::getService(const std::string &serviceName, const bool getStub) {
return ::android::hardware::details::getServiceInternal<BpHwCameraProvider>(serviceName, true, getStub);
}
bool ICameraProvider::registerForNotifications(
const std::string &serviceName,
const ::android::sp<::android::hidl::manager::V1_0::IServiceNotification> ¬ification) {
const ::android::sp<::android::hidl::manager::V1_0::IServiceManager> sm
= ::android::hardware::defaultServiceManager();
if (sm == nullptr) {
return false;
}
::android::hardware::Return<bool> success =
sm->registerForNotifications("android.hardware.camera.provider@2.4::ICameraProvider",
serviceName, notification);
return success.isOk() && success;
}

之后要获取ICameraProvider的interface，就保存到CameraProviderManager中的mProviders中了，为一个vector变量，可以保存多个ProviderInfo信息。

另外还有两个HIDL：

android.hardware.camera.device@3.2
android.hardware.camera.common@1.0

不同的是android.hardware.camera.provider@2.4不但是个共享库，还是个进程。而上述两个只是共享库。

另外要说明点是cameraserver只与android.hardware.camera.provider@2.4服务直接通过HIDL建立连接。其他的关于camera HIDL源码中的类都需要通过android.hardware.camera.provider@2.4。这样provider提供者名副其实。下面我们再来分析另外两个。

1. android.hardware.camera.device分析

目录如下：

/hardware/interfaces/camera/device/3.2
├── Android.bp
├── default
│ ├── Android.bp
│ ├── CameraDevice_3_2.h
│ ├── CameraDevice.cpp
│ ├── CameraDeviceSession.cpp
│ ├── CameraDeviceSession.h
│ ├── convert.cpp
│ ├── include
│ │ └── convert.h
│ └── OWNERS
├── ICameraDeviceCallback.hal
├── ICameraDevice.hal
├── ICameraDeviceSession.hal
└── types.hal

1. 1. CameraDevice类

CameraDevice估计是分析aosp Camera最容易混淆的。我先来看下涉及到cameradevice的源码文件。

① framework目下的：

frameworks/av/services/camera/libcameraservice/hidl/HidlCameraDeviceUser.cpp
frameworks/av/services/camera/libcameraservice/hidl/AidlCameraDeviceCallbacks.cpp
frameworks/av/services/camera/libcameraservice/device3/Camera3Device.cpp
frameworks/av/services/camera/libcameraservice/api2/CameraDeviceClient.cpp
frameworks/av/services/camera/libcameraservice/common/CameraDeviceBase.cpp
frameworks/av/camera/aidl/android/hardware/camera2/ICameraDeviceCallbacks.aidl
frameworks/av/camera/aidl/android/hardware/camera2/ICameraDeviceUser.aidl
frameworks/ex/camera2/portability/src/com/android/ex/camera2/portability/CameraDeviceInfo.java
frameworks/base/services/usb/java/com/android/server/usb/UsbCameraDeviceManagerObserver.java
frameworks/base/core/java/android/hardware/camera2/CameraDevice.java
frameworks/base/core/java/android/hardware/camera2/legacy/LegacyCameraDevice.java
frameworks/base/core/java/android/hardware/camera2/legacy/CameraDeviceUserShim.java
frameworks/base/core/java/android/hardware/camera2/legacy/CameraDeviceState.java
frameworks/base/core/java/android/hardware/camera2/impl/ICameraDeviceUserWrapper.java
frameworks/base/core/java/android/hardware/camera2/impl/CameraDeviceImpl.java
frameworks/base/core/jni/android_hardware_camera2_legacy_LegacyCameraDevice.cpp

② hardware目录下的：

hardware/interfaces/camera/device/3.2/default/CameraDeviceSession.cpp
hardware/interfaces/camera/device/3.2/default/CameraDevice.cpp
hardware/interfaces/camera/device/3.2/ICameraDeviceSession.hal
hardware/interfaces/camera/device/3.2/ICameraDeviceCallback.hal
hardware/interfaces/camera/device/3.2/ICameraDevice.hal
hardware/aw/camera/auto_1_0/V4L2CameraDevice2.cpp
hardware/aw/camera/1_0/V4L2CameraDevice2.cpp

这么多相关文件，在学习CameraDevice时候，必须分析它是那个模块的，被谁调用。例如我们现在分析的CameraDevice是HIDL模块的类。它会被native CameraService中的CameraProviderManager调用，构造流程如下：

template<>
sp<device::V3_2::ICameraDevice>
CameraProviderManager::ProviderInfo::startDeviceInterface
<device::V3_2::ICameraDevice>(const std::string &name) {
...
...
...
const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
...
...
...
ret = interface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
Status s, sp<device::V3_2::ICameraDevice> interface) {
status = s;
cameraInterface = interface;
});
...
...
return cameraInterface;
}

通过调用android.hardware.camera.provider中 ICameraProvider的getCameraDeviceInterface_V3_x获取 CameraDevice。

Return<void> LegacyCameraProviderImpl_2_4::getCameraDeviceInterface_V3_x(
const hidl_string& cameraDeviceName,
ICameraProvider::getCameraDeviceInterface_V3_x_cb _hidl_cb) {
...
...
...
sp<android::hardware::camera::device::V3_2::implementation::CameraDevice> deviceImpl;
...
...
...
deviceImpl = new android::hardware::camera::device::V3_2::implementation::CameraDevice(
mModule, cameraId, mCameraDeviceNames);
...
...
...
_hidl_cb (Status::OK, deviceImpl->getInterface());
return Void();
}

① 第11行中构建camera::device::V3_2::implementation::CameraDevice。

② 第16行中通过 _hidl_cb函数返回接口。

通过分析CameraProviderManager.c 中调用到ICameraDevice中的函数，ICameraDevice主要功能是初始化，获取底层camera信息。

如以下函数：

open
getResourceCost
dumpState
isStreamCombinationSupported

其中open是最重要的函数,我们来分析它的源码：

Return<void> CameraDevice::open(const sp<ICameraDeviceCallback>& callback,
ICameraDevice::open_cb _hidl_cb) {
Status status = initStatus();
sp<CameraDeviceSession> session = nullptr;
...
...
...
res = mModule->open(mCameraId.c_str(),
reinterpret_cast<hw_device_t**>(&device));
...
...
...
session = createSession(
device, info.static_camera_characteristics, callback);
...
...
_hidl_cb(status, session->getInterface());
return Void();
}

源码位于：

interfaces/camera/device/3.2/default/CameraDevice.cpp

① 第8行中，调用CameraModule类型的mModule中的open，CameraModule 主要在legacy模式中用于封装camera_module_t，这样就直接调用vendor底层的函数，这里不展开。

② 第14行中，调用createSession设置好framework层传过来的callback。返回session接口。

③ 第12行中，通过 _hidl_cb函数返回接口ICameraDeviceSession接口。

我们再来分析下createSession。它构建了CameraDeviceSession。

1. 1. CameraDeviceSession

CameraDeviceSession的构建源码如下：

sp<CameraDeviceSession> CameraDevice::createSession(camera3_device_t* device,
const camera_metadata_t* deviceInfo,
const sp<ICameraDeviceCallback>& callback) {
return new CameraDeviceSession(device, deviceInfo, callback);
}

CameraProviderManager中的openSession调用获取到CameraDeviceSession的interface之后。就由libcameraservice的Camera3Device进行处理。

接口如下：

constructDefaultRequestSettings
configureStreams
processCaptureRequest
getCaptureRequestMetadataQueue
getCaptureResultMetadataQueue
flush

1. 1. CameraDeviceCallback与camera3_callback_ops

① CameraDeviceCallback 的实现函数

CameraDeviceCallback中的回调函数在libcameraservice的Camera3Device中定义：

hardware::Return<void> Camera3Device::notify(
const hardware::hidl_vec<hardware::camera::device::V3_2::NotifyMsg>& msgs) {
// Ideally we should grab mLock, but that can lead to deadlock, and
// it's not super important to get up to date value of mStatus for this
// warning print, hence skipping the lock here
if (mStatus == STATUS_ERROR) {
// Per API contract, HAL should act as closed after device error
// But mStatus can be set to error by framework as well, so just log
// a warning here.
ALOGW("%s: received notify message in error state.", __FUNCTION__);
}
for (const auto& msg : msgs) {
notify(msg);
}
return hardware::Void();
}
// Only one processCaptureResult should be called at a time, so
// the locks won't block. The locks are present here simply to enforce this.
hardware::Return<void> Camera3Device::processCaptureResult(
const hardware::hidl_vec<
hardware::camera::device::V3_2::CaptureResult>& results) {
hardware::hidl_vec<hardware::camera::device::V3_4::PhysicalCameraMetadata> noPhysMetadata;
// Ideally we should grab mLock, but that can lead to deadlock, and
// it's not super important to get up to date value of mStatus for this
// warning print, hence skipping the lock here
if (mStatus == STATUS_ERROR) {
// Per API contract, HAL should act as closed after device error
// But mStatus can be set to error by framework as well, so just log
// a warning here.
ALOGW("%s: received capture result in error state.", __FUNCTION__);
}
if (mProcessCaptureResultLock.tryLock() != OK) {
// This should never happen; it indicates a wrong client implementation
// that doesn't follow the contract. But, we can be tolerant here.
ALOGE("%s: callback overlapped! waiting 1s...",
__FUNCTION__);
if (mProcessCaptureResultLock.timedLock(1000000000 /* 1s */) != OK) {
ALOGE("%s: cannot acquire lock in 1s, dropping results",
__FUNCTION__);
// really don't know what to do, so bail out.
return hardware::Void();
}
}
for (const auto& result : results) {
processOneCaptureResultLocked(result, noPhysMetadata);
}
mProcessCaptureResultLock.unlock();
return hardware::Void();
}

源码位于：frameworks/av/services/camera/libcameraservice/device3/Camera3Device.cpp

notify 来自HAL层的异步通知回调
processCaptureResult 发送一个或者多个完成的或者未完成的capture request到framework。

理解这两个回调，尤其是processCaptureResult如何返回到APP层非常重要，涉及到许多细节先不分析。

②CameraDeviceCallback设置位置

在Camera3Device::initialize中：

status_t Camera3Device::initialize(sp<CameraProviderManager> manager, const String8& monitorTags) {
...
...
status_t res = manager->openSession(mId.string(), this,
/*out*/ &session);
...
...
}

之所以openSession 的第二个参数是this，是因为Camera3Device继承了ICameraDeviceCallback，如下：

class Camera3Device :
public CameraDeviceBase,
virtual public hardware::camera::device::V3_5::ICameraDeviceCallback {
public:
explicit Camera3Device(const String8& id);
virtual ~Camera3Device();
/**
* CameraDeviceBase interface
...
...
...
}

源码位于：frameworks/av/services/camera/libcameraservice/device3/Camera3Device.h

调用openSession后，然后调用CameraDevice 的open：

status_t CameraProviderManager::openSession(const std::string &id,
const sp<device::V1_0::ICameraDeviceCallback>& callback,
/*out*/
sp<device::V1_0::ICameraDevice> *session) {
...
...
auto interface = deviceInfo1->startDeviceInterface<
CameraProviderManager::ProviderInfo::DeviceInfo1::InterfaceT>();
...
...
hardware::Return<Status> status = interface->open(callback);
}

到HAL层的CameraDevice::open再到createSession，然后再到CameraDeviceSession的构建函数。然后赋值给CameraDeviceSession的内部成员mResultBatcher。

调用位置mResultBatcher：

void CameraDeviceSession::sProcessCaptureResult(
const camera3_callback_ops *cb,
const camera3_capture_result *hal_result) {
CameraDeviceSession *d =
const_cast<CameraDeviceSession*>(static_cast<const CameraDeviceSession*>(cb));
CaptureResult result = {};
camera3_capture_result shadowResult;
bool handlePhysCam = (d->mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_5);
std::vector<::android::hardware::camera::common::V1_0::helper::CameraMetadata> compactMds;
std::vector<const camera_metadata_t*> physCamMdArray;
sShrinkCaptureResult(&shadowResult, hal_result, &compactMds, &physCamMdArray, handlePhysCam);
status_t ret = d->constructCaptureResult(result, &shadowResult);
if (ret == OK) {
d->mResultBatcher.processCaptureResult(result);
}
}
void CameraDeviceSession::sNotify(
const camera3_callback_ops *cb,
const camera3_notify_msg *msg) {
CameraDeviceSession *d =
const_cast<CameraDeviceSession*>(static_cast<const CameraDeviceSession*>(cb));
NotifyMsg hidlMsg;
convertToHidl(msg, &hidlMsg);
if (hidlMsg.type == (MsgType) CAMERA3_MSG_ERROR &&
hidlMsg.msg.error.errorStreamId != -1) {
if (d->mStreamMap.count(hidlMsg.msg.error.errorStreamId) != 1) {
ALOGE("%s: unknown stream ID %d reports an error!",
__FUNCTION__, hidlMsg.msg.error.errorStreamId);
return;
}
}
if (static_cast<camera3_msg_type_t>(hidlMsg.type) == CAMERA3_MSG_ERROR) {
switch (hidlMsg.msg.error.errorCode) {
case ErrorCode::ERROR_DEVICE:
case ErrorCode::ERROR_REQUEST:
case ErrorCode::ERROR_RESULT: {
Mutex::Autolock _l(d->mInflightLock);
auto entry = d->mInflightAETriggerOverrides.find(
hidlMsg.msg.error.frameNumber);
if (d->mInflightAETriggerOverrides.end() != entry) {
d->mInflightAETriggerOverrides.erase(
hidlMsg.msg.error.frameNumber);
}
auto boostEntry = d->mInflightRawBoostPresent.find(
hidlMsg.msg.error.frameNumber);
if (d->mInflightRawBoostPresent.end() != boostEntry) {
d->mInflightRawBoostPresent.erase(
hidlMsg.msg.error.frameNumber);
}
}
break;
case ErrorCode::ERROR_BUFFER:
default:
break;
}
}
d->mResultBatcher.notify(hidlMsg);
}

这两个函数sProcessCaptureResult与sNotify在CameraDeviceSession构造函数中赋值给了camera3_callback_ops。

CameraDeviceSession::CameraDeviceSession(
camera3_device_t* device,
const camera_metadata_t* deviceInfo,
const sp<ICameraDeviceCallback>& callback) :
camera3_callback_ops({&sProcessCaptureResult, &sNotify, nullptr, nullptr}),
mDevice(device),
mDeviceVersion(device->common.version),
mFreeBufEarly(shouldFreeBufEarly()),
mIsAELockAvailable(false),
mDerivePostRawSensKey(false),
mNumPartialResults(1),
mResultBatcher(callback) {
mDeviceInfo = deviceInfo;
camera_metadata_entry partialResultsCount =
mDeviceInfo.find(ANDROID_REQUEST_PARTIAL_RESULT_COUNT);
if (partialResultsCount.count > 0) {
mNumPartialResults = partialResultsCount.data.i32[0];
}
...
...
}

CameraDeviceSession继承自camera3_callback_ops。

struct CameraDeviceSession : public virtual RefBase, protected camera3_callback_ops

在CameraDeviceSession::initialize中将使用this调用camera3_device_ops_t回调initialize，设置给原厂代码。

bool CameraDeviceSession::initialize() {
/** Initialize device with callback functions */
ATRACE_BEGIN("camera3->initialize");
status_t res = mDevice->ops->initialize(mDevice, this);
ATRACE_END();
...
...
}

原厂代码在哪里回调？

在实现结构体camera3_device_ops_t回调的initialize中函数中赋值给一个成员变量然后使用其进行回调，具体实现可分析 hardware/aw/camera/3_4/camera.cpp。

1. 1. CameraModule与camera_module_t

CameraModule的构建在LegacyCameraProviderImpl_2_4::initialize()函数中，源码如下：

bool LegacyCameraProviderImpl_2_4::initialize() {
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();
...
...
}

① 首先通过hw_get_module获取camera_module_t类型指针，也就是vendor使用legacy模式定义在一个SO库中的一个指针结构体，有许多函数指针。：

② 然后camera_module_t 作为传递参数，构建CameraModule类

原厂的camera_module_t结构体定义的成员如下：

static hw_module_methods_t v4l2_module_methods = {
.open = v4l2_camera_hal::open_dev};
camera_module_t HAL_MODULE_INFO_SYM __attribute__((visibility("default"))) = {
.common =
{
.tag = HARDWARE_MODULE_TAG,
.module_api_version = CAMERA_MODULE_API_VERSION_2_4,
.hal_api_version = HARDWARE_HAL_API_VERSION,
.id = CAMERA_HARDWARE_MODULE_ID,
.name = "V4L2 Camera HAL v3",
.author = "ZJW",
.methods = &v4l2_module_methods,
.dso = nullptr,
.reserved = {0},
},
.get_number_of_cameras = v4l2_camera_hal::get_number_of_cameras,
.get_camera_info = v4l2_camera_hal::get_camera_info,
.set_callbacks = v4l2_camera_hal::set_callbacks,
.get_vendor_tag_ops = v4l2_camera_hal::get_vendor_tag_ops,
.open_legacy = v4l2_camera_hal::open_legacy,
.set_torch_mode = v4l2_camera_hal::set_torch_mode,
.init = nullptr,
.reserved = {nullptr, nullptr}};

源码位于：hardware/aw/camera/3_4/v4l2_camera_hal.cpp

很明显CameraModule这个类就是用来封装camera_module_t的。在CameraModule通过mModule成员来回调camera_module_t结构体。而CameraDevice中的mModule是CameraModule类型。它们最终都是调用camera_module_t。通过分析这个结构体，我们可以明白，这些函数指针基本上都是用来初始化、获取或者设置camera信息的。那么处理配置 configure stream和处理capture request又在哪里呢？这就需要分析camera3_device_ops_t。

1. 1. camera3_device_ops_t

① 获取 camera3_device_t类型的device，hw_device_t

Return<void> CameraDevice::open(const sp<ICameraDeviceCallback>& callback,
ICameraDevice::open_cb _hidl_cb) {
...
...
...
camera3_device_t *device;
res = mModule->open(mCameraId.c_str(),
reinterpret_cast<hw_device_t**>(&device));
...
...
...
session = createSession(
device, info.static_camera_characteristics, callback);
...
...
return Void();
}

② 通过createSession构建CameraDeviceSession后传入device给mDevice

CameraDeviceSession::CameraDeviceSession(
camera3_device_t* device,
const camera_metadata_t* deviceInfo,
const sp<ICameraDeviceCallback>& callback) :
camera3_callback_ops({&sProcessCaptureResult, &sNotify, nullptr, nullptr}),
mDevice(device) {
}

mDevice在CameraDeviceSession的调用：

mDevice->ops->initialize 初始化camera3_callback_ops_t回到
mDevice->common.close
mDevice->ops->dump
mDevice->ops->construct_default_request_settings
mDevice->ops->configure_streams 配置stream
mDevice->ops->process_capture_request 处理capture request
mDevice->ops->flush

最终会调用到原厂实现的结构体camera3_device_ops_t，如下：

const camera3_device_ops_t Camera::sOps = {

.initialize = default_camera_hal::initialize,

.configure_streams = default_camera_hal::configure_streams,

.register_stream_buffers = nullptr,

.construct_default_request_settings

= default_camera_hal::construct_default_request_settings,

.process_capture_request = default_camera_hal::process_capture_request,

.get_metadata_vendor_tag_ops = nullptr,

.dump = default_camera_hal::dump,

.flush = default_camera_hal::flush,

.reserved = {0},

};

} // namespace default_camera_hal

源码位于：hardware/aw/camera/3_4/camera.cpp

不同芯片原厂实现的camera_module_t与camera3_device_ops_t的方式肯定不同，但都是要是实现HIDL接口的：

ICameraDeviceSession.hal
ICameraDeviceCallback.hal
ICameraDevice.hal
ICameraProvider.hal
ICameraDevicePreviewCallback.hal

给framework实际的调用函数。

如果使用legcay 模式需要实现结构体camera_module_t，以便 provider可以通过hw_get_module获取。

调用流程图

welljrj

关注

1
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
Android Camera HIDL交互分析

Android CameraHIDL交互分析1.1java层openCamera逻辑APP层调用CameraManager中的openCamera打开camera。APP-->openCamera|||---> openCameraForUid|||--->openCameraDeviceUserAsync① 首先通过cameraService = CameraManagerGlobal.get().getCa...
复制链接

扫一扫