Camera Framework
本文主要介绍分析Camera API2
相关。
类别文件速查表
类文件目录
1 2 3 4 5 6 |
1. Framework Java API1:frameworks/base/core/java/android/hardware/Camera.java 2. Framework Java API2:frameworks/base/core/java/android/hardware/camera2 3. Framework JNI: frameworks/base/core/jni/ 4. AIDL: frameworks/av/camera/aidl 5. Framework Native: frameworks/av/camera 6. Framework Service: frameworks/av/services/camera/libcameraservice |
JNI
相关
1 2 3 4 5 6 7 8 |
// frameworks/base/core/jni ./android_hardware_camera2_legacy_LegacyCameraDevice.cpp ./android_hardware_Camera.cpp ./android/graphics/Camera.cpp ./include/android_runtime/android_hardware_camera2_CameraMetadata.h ./android_hardware_camera2_DngCreator.cpp ./android_hardware_camera2_CameraMetadata.cpp ./android_hardware_camera2_legacy_PerfMeasurement.cpp |
API 1
中,使用jni
通过Binder
机制和CameraService
通信。API 2
中,直接在CameraManager.java
中通过Binder
机制和CameraService
通信。
AIDL
相关
Framework Camere AIDL
是Camera
跨过程通信中使用的客户端和服务端AIDL
文件、代码都在frameworks/av/camera/
其中,目录aidl
文件一共有 16 个:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
xmt@server005:~/frameworks/av/camera/aidl/android/hardware$ tree . ├── camera2 │ ├── CaptureRequest.aidl │ ├── ICameraDeviceCallbacks.aidl │ ├── ICameraDeviceUser.aidl │ ├── impl │ │ ├── CameraMetadataNative.aidl │ │ └── CaptureResultExtras.aidl │ ├── params │ │ ├── OutputConfiguration.aidl │ │ ├── VendorTagDescriptor.aidl │ │ └── VendorTagDescriptorCache.aidl │ └── utils │ └── SubmitInfo.aidl ├── CameraInfo.aidl ├── CameraStatus.aidl ├── ICamera.aidl ├── ICameraClient.aidl ├── ICameraService.aidl ├── ICameraServiceListener.aidl └── ICameraServiceProxy.aidl 4 directories, 16 files |
frameworks/av/camera/aidl/
目录下的aidl
有两种类型的文件:
- 作为
Binder
中的IInterface
可以在跨过程通信中提供的方法 - 作为
Binder
中的parcelable
跨过程通信数据传输的数据结构
这两种类型的文件很容易区分名称,IInterface
所有类型的文件都是以I
开头,如:ICameraService.aidl, ICameraDeviceUser.aidl
等等。不管是什么类型的。aidl
它们都生成相应的文件.java, .h, .cpp
分别提供文件Java
层和CPP
层调用。
IInterface
类型文件
IInterface
类型文件一共有 7 个,它们的.java, .h, .cpp
大部分文件都是自动生成的。
Java
文件是在frameworks/base/Android.mk
在编译过程中自动定义规则:
1 2 3 4 5 6 7 8 9 10 11 |
// frameworks/base/Android.mk LOCAL_SRC_FILES = ... ../av/camera/aidl/android/hardware/ICameraService.aidl ../av/camera/aidl/android/hardware/ICameraServiceListener.aidl ../av/camera/aidl/android/hardware/ICameraServiceProxy.aidl ../av/camera/aidl/android/hardware/ICamera.aidl ../av/camera/aidl/android/hardware/ICameraClient.aidl ../av/camera/aidl/android/hardware/camera2/ICameraDeviceUser.aidl ../av/camera/aidl/android/hardware/camera2/ICameraDeviceCallbacks.aidl ... |
在out/target/common/obj/JAVA_LIBRARIES/framework_intermediates/dotdot/
生成对应的目录Java
文件:
1 2 3 4 5 6 7 8 |
// out/target/common/obj/JAVA_LIBRARIES/framework_intermediates/dotdot/ av/camera/aidl/android/hardware/ICameraService.java av/camera/aidl/android/hardware/ICameraServiceListener.java av/camera/aidl/android/hardware/ICameraServiceProxy.java av/camera/aidl/android/hardware/ICamera.java av/camera/aidl/android/hardware/ICameraClient.java av/camera/aidl/androd/hardware/camera2/ICameraDeviceUser.java av/camera/aidl/android/hardware/camera2/ICameraDeviceCallbacks.java |
.h, .cpp
文件中,ICamera.aidl, ICameraClient.aidl
两个文件是直接以代码形式手动实现的:
1 2 3 4 5 6 7 8 9 |
// 1. ICameraClient.aidl frameworks/av/camera/aidl/android/hardware/ICameraClient.aidl frameworks/av/camera/include/camera/android/hardware/ICameraClient.h frameworks/av/camera/ICameraClient.cpp // 2. ICamera.aidl frameworks/av/camera/aidl/android/hardware/ICamera.aidl frameworks/av/camera/include/camera/android/hardware/ICamera.h frameworks/av/camera/ICamera.cpp |
其他 5 个 aidl
文件是在 frameworks/av/camera/Android.bp
中定义规则,编译时自动生成对应的 .h, .cpp
文件:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
// frameworks/av/camera/Android.bp cc_library_shared { name: "libcamera_client", aidl: { export_aidl_headers: true, local_include_dirs: ["aidl"], include_dirs: [ "frameworks/native/aidl/gui", ], }, srcs: [ // AIDL files for camera interfaces // The headers for these interfaces will be // available to any modules that // include libcamera_client, at the path "aidl/package/path/BnFoo.h" "aidl/android/hardware/ICameraService.aidl", "aidl/android/hardware/ICameraServiceListener.aidl", "aidl/android/hardware/ICameraServiceProxy.aidl", "aidl/android/hardware/camera2/ICameraDeviceCallbacks.aidl", "aidl/android/hardware/camera2/ICameraDeviceUser.aidl", // Source for camera interface parcelables, // and manually-written interfaces "Camera.cpp", "CameraMetadata.cpp", "CameraParameters.cpp", ... } |
在 out/soong/.intermediates/frameworks/av/camera/libcamera_client/
目录下生成对应的 .h, .cpp
文件,通常在该目录下会同时生成 32 和 64 位两套代码,但实际两份代码是一样的,这里选取 64 位的:
- 64 位:
android_arm64_armv8-a_shared_core
- 32 位:
android_arm_armv7-a-neon_cortex-a53_shared_core
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
// 目录 out/soong/.intermediates/frameworks/av/camera/libcamera_client // 64 位 android_arm64_armv8-a_shared_core/gen/aidl/ android/hardware/ICameraService.h android/hardware/BnCameraService.h frameworks/av/camera/aidl/android/hardware/ICameraService.cpp android/hardware/ICameraServiceListener.h android/hardware/BnCameraServiceListener.h frameworks/av/camera/aidl/android/hardware/ICameraServiceListener.cpp android/hardware/ICameraServiceProxy.h android/hardware/BnCameraServiceProxy.h frameworks/av/camera/aidl/android/hardware/ICameraServiceProxy.cpp android/hardware/camera2/ICameraDeviceUser.h android/hardware/camera2/BnCameraDeviceUser.h frameworks/av/camera/aidl/android/hardware/camera2/ICameraDeviceUser.cpp android/hardware/camera2/ICameraDeviceCallbacks.h android/hardware/camera2/BnCameraDeviceCallbacks.h frameworks/av/camera/aidl/android/hardware/camera2/ICameraDeviceCallbacks.cpp |
parcelable
类型文件
parcelable
类型文件一共有 9 个,它们都是手动编写的代码。
Java
文件目录为 frameworks/base/core/java/android/hardware/
:
1 2 3 4 5 6 7 8 9 10 |
// frameworks/base/core/java/android/hardware/ camera2/CaptureRequest.java camera2/impl/CameraMetadataNative.java camera2/impl/CaptureResultExtras.java camera2/params/OutputConfiguration.java camera2/params/VendorTagDescriptor.java camera2/params/VendorTagDescriptorCache.java camera2/utils/SubmitInfo.java CameraInfo.java CameraStatus.java |
.h, .cpp
文件并不一定是和 aidl
文件名称一一对应的,而是在 aidl
文件中定义的,比如 CameraStatus.aidl
定义如下:
1 2 3 4 |
package android.hardware; /** @hide */ parcelable CameraStatus cpp_header "camera/CameraBase.h"; |
parcelable
类型的 aidl
文件对应的 .h, .cpp
文件目录为 frameworks/av/camera
,对应关系整理如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
// .h, .cpp 文件目录 frameworks/av/camera // CaptureRequest.aidl include/camera/camera2/CaptureRequest.h camera2/CaptureRequest.cpp // CameraMetadataNative.aidl include/camera/CameraMetadata.h CameraMetadata.cpp // CaptureResultExtras.aidl include/camera/CaptureResult.h CaptureResult.cpp // OutputConfiguration.aidl include/camera/camera2/OutputConfiguration.h camera2/OutputConfiguration.cpp // VendorTagDescriptor.aidl 和 VendorTagDescriptorCache.aidl include/camera/VendorTagDescriptor.h VendorTagDescriptor.cpp // SubmitInfo.aidl include/camera/camera2/SubmitInfo.h camera2/SubmitInfo.cpp // CameraInfo.aidl 和 CameraStatus.aidl include/camera/CameraBase.h CameraBase.cpp |
ICameraService
相关
分为客户端向服务端的请求 ICameraService.aidl
和客户端监听服务端的变化 ICameraServiceListener.aidl
。这两个 AIDL
是在 CameraService.cpp
中实现对应功能的。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 |
interface { ... const int CAMERA_TYPE_BACKWARD_COMPATIBLE = 0; const int CAMERA_TYPE_ALL = 1; // 返回指定类型的相机设备数量 int getNumberOfCameras(int type); // 根据 id 返回当前相机设备信息 CameraInfo getCameraInfo(int cameraId); ... const int CAMERA_HAL_API_VERSION_UNSPECIFIED = -1; // api1 + hal1 ICamera connect(ICameraClient client, int cameraId, String opPackageName, int clientUid, int clientPid); // api2 + hal3 ICameraDeviceUser connectDevice(ICameraDeviceCallbacks callbacks, String cameraId, String opPackageName, int clientUid); // api1 + 指定 hal 版本(通常为 hal1) ICamera connectLegacy(ICameraClient client, int cameraId, int halVersion, String opPackageName, int clientUid); // 添加和移除 ICameraServiceListener 监听 CameraStatus[] addListener(ICameraServiceListener listener); void removeListener(ICameraServiceListener listener); // 根据 id 返回相机支持的属性 CameraMetadataNative getCameraCharacteristics(String cameraId); // 获取 vendor tag VendorTagDescriptor getCameraVendorTagDescriptor(); VendorTagDescriptorCache getCameraVendorTagCache(); // camera api 1 获取参数信息 String getLegacyParameters(int cameraId); const int API_VERSION_1 = 1; const int API_VERSION_2 = 2; // 指定 id 支持的 API 版本 boolean supportsCameraApi(String cameraId, int apiVersion); // 指定 id 设置手电筒模式 void setTorchMode(String cameraId, boolean enabled, IBinder clientBinder); // 服务端向系统打印系统消息 const int EVENT_NONE = 0; const int EVENT_USER_SWITCHED = 1; oneway void notifySystemEvent(int eventId, in int[] args); } // 2. ICameraServiceListener.aidl interface ICameraServiceListener { const int STATUS_NOT_PRESENT = 0; const int STATUS_PRESENT = 1; const int STATUS_ENUMERATING = 2; const int STATUS_NOT_AVAILABLE = -2; const int STATUS_UNKNOWN = -1; // 相机设备状态变化事件 oneway void onStatusChanged(int status, String cameraId); const int TORCH_STATUS_NOT_AVAILABLE = 0; const int TORCH_STATUS_AVAILABLE_OFF = 1; const int TORCH_STATUS_AVAILABLE_ON = 2; const int TORCH_STATUS_UNKNOWN = -1; // 手电筒状态变化事件 oneway void onTorchStatusChanged(int status, String cameraId); } |
ICameraServiceProxy.aidl
文件
CameraServiceProxy
服务是在 Java
层注册的:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
interface ICameraServiceProxy { // CameraService 向代理服务发送消息,通知用户更新 oneway void pingForUserUpdate(); const int CAMERA_STATE_OPEN = 0; const int CAMERA_STATE_ACTIVE = 1; const int CAMERA_STATE_IDLE = 2; const int CAMERA_STATE_CLOSED = 3; const int CAMERA_FACING_BACK = 0; const int CAMERA_FACING_FRONT = 1; const int CAMERA_FACING_EXTERNAL = 2; // CameraService 向代理服务发送消息,通知相机设备状态更新 oneway void notifyCameraState(String cameraId, int facing, int newCameraState, String clientName); } |
ICamera
相关
Camera API1
才会使用到,分为 ICamera.aidl, ICameraClient.aidl
它们的代码是手动实现的,参考:CameraClient.h/cpp, Camera.h/cpp
ICameraDevice
相关
Camera API2
才会使用到,分为客户端向服务端的请求 ICameraDeviceUser.aidl
和服务端发给客户端的回调 ICameraDeviceCallbacks.aidl
。 表示相机设备具备的能力,能够提供的函数;这两个 AIDL
是在 CameraDeviceClient
中实现对应功能的。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 |
// 1. ICameraDeviceUser.aidl interface ICameraDeviceUser { void disconnect(); const int NO_IN_FLIGHT_REPEATING_FRAMES = -1; // 向设备提交捕获请求 SubmitInfo submitRequest(in CaptureRequest request, boolean streaming); SubmitInfo submitRequestList(in CaptureRequest[] requestList, boolean streaming); // 取消置顶 id 的重复请求,并返回上次请求的帧 id long cancelRequest(int requestId); const int NORMAL_MODE = 0; const int CONSTRAINED_HIGH_SPEED_MODE = 1; const int VENDOR_MODE_START = 0x8000; // 在流处理前执行配置请求 void beginConfigure(); // 根据指定输出配置,创建流 int createStream(in OutputConfiguration outputConfiguration); void endConfigure(int operatingMode); void deleteStream(int streamId); // 创建输入流,返回流 id int createInputStream(int width, int height, int format); // 返回输入流的 Surface Surface getInputSurface(); // Keep in sync with public API in // frameworks/base/core/java/android/hardware/camera2/CameraDevice.java const int TEMPLATE_PREVIEW = 1; const int TEMPLATE_STILL_CAPTURE = 2; const int TEMPLATE_RECORD = 3; const int TEMPLATE_VIDEO_SNAPSHOT = 4; const int TEMPLATE_ZERO_SHUTTER_LAG = 5; const int TEMPLATE_MANUAL = 6; // 根据模板创建默认请求,返回相机参数信息 CameraMetadataNative createDefaultRequest(int templateId); // 获取相机参数信息 CameraMetadataNative getCameraInfo(); void waitUntilIdle(); long flush(); void prepare(int streamId); void tearDown(int streamId); void prepare2(int maxCount, int streamId); void finalizeOutputConfigurations(int streamId, in OutputConfiguration outputConfiguration); } // 2. ICameraDeviceCallbacks.aidl interface ICameraDeviceCallbacks { ... oneway void onDeviceError(int errorCode, in CaptureResultExtras resultExtras); oneway void onDeviceIdle(); oneway void onCaptureStarted(in CaptureResultExtras resultExtras, long timestamp); oneway void onResultReceived(in CameraMetadataNative result, in CaptureResultExtras resultExtras); oneway void onPrepared(int streamId); // 重复请求引起的错误回调 oneway void onRepeatingRequestError(in long lastFrameNumber, in int repeatingRequestId); oneway void onRequestQueueEmpty(); } |
Services
目录下的文件介绍
frameworks/av/services/camera/libcameraservice
AOSP
中这个目录下是 87 个文件,而 Qcom
的基线中增加了 27 个文件,分别为 api1/qticlient2
目录下的 25 个文件,以及 QTICamera2Client.cpp, QTICamera2Client.h
两个文件。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
. ├── Android.mk ├── api1 │ ├── client2 │ └── qticlient2 ├── api2 ├── CameraFlashlight.cpp ├── CameraFlashlight.h ├── CameraService.cpp ├── CameraService.h ├── common ├── device1 ├── device3 ├── gui ├── MODULE_LICENSE_APACHE2 ├── NOTICE ├── tests └── utils |
从目录结构上可以看出,API1/2
和 HAL1/3
就是在这一层体现的。
API1/API2
APP Java
客户端调用服务端方法时,Camera API1/2
接口对应功能都是在 CameraService
中实现的,而这里的 API1/2
目录对应的就是对上层不同版本接口的处理。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
api1 ├── Camera2Client.cpp ├── Camera2Client.h ├── CameraClient.cpp ├── CameraClient.h ├── client2 │ ├── CallbackProcessor.cpp │ ├── CallbackProcessor.h │ ├── Camera2Heap.h │ ├── CaptureSequencer.cpp │ ├── CaptureSequencer.h │ ├── FrameProcessor.cpp │ ├── FrameProcessor.h │ ├── JpegCompressor.cpp │ ├── JpegCompressor.h │ ├── JpegProcessor.cpp │ ├── JpegProcessor.h │ ├── Parameters.cpp │ ├── Parameters.h │ ├── StreamingProcessor.cpp │ ├── StreamingProcessor.h │ ├── ZslProcessor.cpp │ └── ZslProcessor.h ├── QTICamera2Client.cpp ├── QTICamera2Client.h └── qticlient2 ├── CallbackProcessor.cpp ├── CallbackProcessor.h ├── Camera2Heap.h ├── CaptureSequencer.cpp ├── CaptureSequencer.h ├── FrameProcessor.cpp ├── FrameProcessor.h ├── JpegCompressor.cpp ├── JpegCompressor.h ├── JpegProcessor.cpp ├── JpegProcessor.h ├── Parameters.cpp ├── Parameters.h ├── QTICaptureSequencer.cpp ├── QTICaptureSequencer.h ├── QTIFrameProcessor.cpp ├── QTIFrameProcessor.h ├── QTIParameters.cpp ├── QTIParameters.h ├── RawProcessor.cpp ├── RawProcessor.h ├── StreamingProcessor.cpp ├── StreamingProcessor.h ├── ZslProcessor.cpp └── ZslProcessor.h api2 ├── CameraDeviceClient.cpp └── CameraDeviceClient.h |
BasicClient
有三个重要的子类:
CameraClient
如果平台仅支持HAL 1
,即CAMERA_DEVICE_API_VERSION_1_0
;使用API 1/2 + HAL 1
都会对应该客户端。Camera2Client
如果平台支持HAL 3
,即CAMERA_DEVICE_API_VERSION_3_0
及以上版本;使用API 1 + HAL 3
对应的客户端。Camera2Client
会将API1
中的接口转换为API2
中对应的功能。CameraDeviceClient
如果平台支持HAL 3
,使用API 2 + HAL 3
对应的客户端。
平台仅支持 HAL 1
时,API 2
在 openCamera
时,通过 CameraDeviceUserShim
将 API 2
转换为 API 1
,即 HAL 1 + API 1
向下发起请求。LegacyCameraDevice
会将 CAMERA API2
转换为 CAMERA API1
,而 CameraDeviceUserShim
封装了 LegacyCameraDevice
。
QTICamera2Client
Qcom
的基线中增加了 27 个文件,分别为 api1/qticlient2
目录下的 25 个文件,以及 QTICamera2Client.cpp, QTICamera2Client.h
两个文件。 而 QTICamera2Client
是高通针对 API1
做的优化?在什么情况下会转换为 QTICamera2Client
呢?看如下源码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
// 1. Camera2Client.h class Camera2Client : public Camera2ClientBase<CameraService::Client> { friend class QTICamera2Client; #endif ... sp<camera2::RawProcessor> mRawProcessor; #endif ... sp<QTICamera2Client> mQTICamera2Client; #endif ... } // 2. Camera2Client.cpp template<typename TProviderPtr> status_t Camera2Client::initializeImpl(TProviderPtr providerPtr) { ... mQTICamera2Client = new QTICamera2Client(this); #endif ... mRawProcessor = new RawProcessor(this, mCaptureSequencer); threadName = String8::format("C2-%d-RawProc", mCameraId); mRawProcessor->run(threadName.string()); #endif ... } |
QTICamera2Client
是高通对 API 1
中 Camera2Client
做的一层封装,添加了部分功能,主要是向上提供 raw
数据。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// 1. QTICamera2Client.h class QTICamera2Client: public virtual RefBase{ private: wp<Camera2Client> mParentClient; status_t stopPreviewExtn(); public: QTICamera2Client(sp<Camera2Client> client); ~QTICamera2Client(); ... } // 2. QTICamera2Client.cpp QTICamera2Client::QTICamera2Client(sp<Camera2Client> client): mParentClient(client) { } |
device1/device3
device1/device3
可以理解为 Framework
层对应 HAL
层的 HAL 1/3
。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
device1 ├── CameraHardwareInterface.cpp └── CameraHardwareInterface.h device3 ├── Camera3BufferManager.cpp ├── Camera3BufferManager.h ├── Camera3Device.cpp ├── Camera3Device.h ├── Camera3DummyStream.cpp ├── Camera3DummyStream.h ├── Camera3InputStream.cpp ├── Camera3InputStream.h ├── Camera3IOStreamBase.cpp ├── Camera3IOStreamBase.h ├── Camera3OutputStream.cpp ├── Camera3OutputStream.h ├── Camera3OutputStreamInterface.h ├── Camera3SharedOutputStream.cpp ├── Camera3SharedOutputStream.h ├── Camera3StreamBufferFreedListener.h ├── Camera3StreamBufferListener.h ├── Camera3Stream.cpp ├── Camera3Stream.h ├── Camera3StreamInterface.h ├── Camera3StreamSplitter.cpp ├── Camera3StreamSplitter.h ├── StatusTracker.cpp └── StatusTracker.h |
API1/device1/HAL1
的连接过程
1 2 3 4 5 |
// API1: CameraClient.h sp<CameraHardwareInterface> mHardware; // device1: CameraHardwareInterface.h sp<hardware::camera::device::V1_0::ICameraDevice> mHidlDevice; // 这里的 ICameraDevice 即为 HAL1 |
API1
的客户端 CameraClient
对应的 device1: CameraHardwareInterface
,而它直接包含了 HAL1
中 ICameraDevice
。
API1/3/device3/HAL3
的连接过程1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
// API1: Camera2Client.h class Camera2Client : public Camera2ClientBase<CameraService::Client>{...} // API2: CameraDeviceClient.h class CameraDeviceClient : public Camera2ClientBase<CameraDeviceClientBase>, public camera2::FrameProcessorBase::FilteredListener{...} // Camera2ClientBase.h sp<CameraDeviceBase> mDevice; // Camera2ClientBase.cpp template <typename TClientBase> Camera2ClientBase<TClientBase>::Camera2ClientBase( const sp<CameraService>& cameraService, const sp<TCamCallbacks>& remoteCallback, const String16& clientPackageName, const String8& cameraId, int cameraFacing, int clientPid, uid_t clientUid, int servicePid): TClientBase(cameraService, remoteCallback, clientPackageName, cameraId, cameraFacing, clientPid, clientUid, servicePid), mSharedCameraCallbacks(remoteCallback), mDeviceVersion(cameraService->getDeviceVersion( TClientBase::mCameraIdStr)), mDeviceActive(false) { ... mInitialClientPid = clientPid; // 只要是 HAL3 ,则 device 都是对应的 Camera3Device mDevice = new Camera3Device(cameraId); ... }
从源码可以看出,不管是 API1/2
,只要是 HAL 3
,Camera2Client, CameraDeviceClient
两个客户端对应的都是 device3: Camera3Device
。
Camera3Device::HalInterface
内部类,用于和 HAL
层通信,实现了 HAL
层 ICameraDeviceSession.hal
部分代码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
// Camera3Device.h class Camera3Device : ... class HalInterface : public camera3::Camera3StreamBufferFreedListener { public: ... // Calls into the HAL interface // Caller takes ownership of requestTemplate status_t constructDefaultRequestSettings( camera3_request_template_t templateId, /*out*/ camera_metadata_t **requestTemplate); status_t configureStreams( /*inout*/ camera3_stream_configuration *config); status_t processCaptureRequest(camera3_capture_request_t *request); status_t flush(); status_t close(); ... } ... } |
cameraserver
进程
cameraserver
进程的源码在 frameworks/av/camera/cameraserver
目录下,该目录只有三个文件:
1 2 3 4 |
. ├── Android.mk ├── cameraserver.rc // rc 文件 └── main_cameraserver.cpp // 主进程 |
cameraserver
进程在启动时,做了三件事:
- 设置
Socket
通信时,对端关闭读取时进程不退出,返回错误信息(Socket
用在了哪?) HIDL
通信初始化Native Binder
初始化,CameraService
向service_manager
注册服务
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
// frameworks/av/camera/cameraserver/main_cameraserver.cpp int main(int argc __unused, char** argv __unused) { // 1. Socket 通信时,对端关闭读取时进程不退出,返回错误信息 signal(SIGPIPE, SIG_IGN); // 2. HIDL 通信初始化 // Set 3 threads for HIDL calls hardware::configureRpcThreadpool(3, /*willjoin*/ false); // 3. Native Binder 初始化,CameraService 是具体的服务 sp<ProcessState> proc(ProcessState::self()); sp<IServiceManager> sm = defaultServiceManager(); ALOGI("ServiceManager: %p", sm.get()); CameraService::instantiate(); ProcessState::self()->startThreadPool(); IPCThreadState::self()->joinThreadPool(); } |
1 2 3 4 5 6 7 8 9 10 |
// init 进程启动名字为 cameraserver 的进程及对应路径 service cameraserver /system/bin/cameraserver // class 表示类别,同一类别的进程同时启动 class main // 用户名 user cameraserver // 分组 group audio camera input drmrpc ioprio rt 4 writepid /dev/cpuset/camera-daemon/tasks /dev/stune/top-app/tasks |
CameraService
启动服务注册流程图:
CameraService
服务
CameraService
服务的名称为:media.camera
,主要有两个功能:
- 作为服务端 实现
AIDL
对应功能,当API1/2
客户端发出请求后,作为服务端响应并处理这些功能。 - 作为客户端 实现
HIDL
回调,用于响应HAL
层发回的回调。并且通过CameraProviderManager
和HAL
层实现双向通信。
服务名称
CameraService
继承了 BinderService<CameraService>
,将 CameraService::instantiate();
代码展开:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
// BinderService.h template<typename SERVICE> class BinderService { public: static status_t publish(bool allowIsolated = false) { sp<IServiceManager> sm(defaultServiceManager()); return sm->addService( String16(SERVICE::getServiceName()), new SERVICE(), allowIsolated); } ... static void instantiate() { publish(); } ... } // IServiceManager.h class IServiceManager : public IInterface { public: ... virtual status_t addService( const String16& name, const sp<IBinder>& service, bool allowIsolated = false) = 0; ... } // CameraService.h class CameraService : public BinderService<CameraService>, public virtual ::android::hardware::BnCameraService, public virtual IBinder::DeathRecipient, public camera_module_callbacks_t, public virtual CameraProviderManager::StatusListener { ... // Implementation of BinderService<T> static char const* getServiceName() { return "media.camera"; } ... } |
从继承关系及 CameraService.h
源码,getServiceName
设置了 CameraService
服务的名称为 media.camera
。
注册流程图
CameraService 注册流程,查看原图
源码分析
先来看 CameraService.h
头文件相关定义:
1 2 3 4 5 6 7 8 9 10 11 |
// CameraService.h class CameraService : public BinderService<CameraService>, public virtual ::android::hardware::BnCameraService, public virtual IBinder::DeathRecipient, public camera_module_callbacks_t, public virtual CameraProviderManager::StatusListener { static char const* getServiceName() { return "media.camera"; } } |
BinderService
继承了BinderService
,用于注册服务。服务名称为media.camera
。camera_module_callbacks_t
继承了camera_module_callbacks_t
,它是在HAL
中定义的,用于HAL
向Framework
发送通知。StatusListener
继承了StatusListener
,它是在CameraProviderManager.h
中定义的,用于CameraProviderManager
向CameraService
发送通知。
现在查看 CameraService
的构造方法,因为在注册服务时 BinderService
会对 CameraService
强指针引用,所以会调用对应函数 onFirstRef
:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
// CameraService.cpp CameraService::CameraService() : mEventLog(DEFAULT_EVENT_LOG_LENGTH), mNumberOfCameras(0), mNumberOfNormalCameras(0), mSoundRef(0), mInitialized(false) { // camera_module_callbacks_t 结构体的函数指针赋值 this->camera_device_status_change = android::camera_device_status_change; this->torch_mode_status_change = android::torch_mode_status_change; ... } void CameraService::onFirstRef() { ... BatteryNotifier& notifier(BatteryNotifier::getInstance()); notifier.noteResetCamera(); notifier.noteResetFlashlight(); status_t res = INVALID_OPERATION; // 实例化 CameraProviderManager ,并连接 Hardware res = enumerateProviders(); if (res == OK) { mInitialized = true; } // CameraServiceProxy 服务是 Java 代码注册的 // 但是 CameraService 启动时间很早,CameraServiceProxy 可能还并没有注册 // 实际调试结果也是,这段代码实际不会调用 CameraServiceProxy 对应方法 CameraService::pingCameraServiceProxy(); } |
构造函数中非常简单,仅仅是将 camera_module_callbacks_t
结构体的函数指针赋值;在 onFirstRef
中,主要通过 enumerateProviders
来实例化对应的 CameraProviderManager
并连接 HAL
,最后去 ping
一次 CameraServiceProxy
代理服务,实际上是 ping
不通的,因为 CameraService.cpp
一定是比 CameraServiceProxy.java
启动的早。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
// CameraService.cpp status_t CameraService::enumerateProviders() { ... // 实例化 CameraProviderManager if (nullptr == mCameraProviderManager.get()) { mCameraProviderManager = new CameraProviderManager(); res = mCameraProviderManager->initialize(this); ... } mNumberOfCameras = mCameraProviderManager->getCameraCount(); mNumberOfNormalCameras = mCameraProviderManager->getAPI1CompatibleCameraCount(); mCameraProviderManager->setUpVendorTags(); if (nullptr == mFlashlight.get()) { mFlashlight = new CameraFlashlight(mCameraProviderManager, this); } res = mFlashlight->findFlashUnits(); ... for (auto& cameraId : mCameraProviderManager->getCameraDeviceIds()){ ... onDeviceStatusChanged(id8, CameraDeviceStatus::PRESENT); ... } return OK; } |
如果 mCameraProviderManager
为空,则实例化并调用 initialize
;接着实例化 CameraFlashlight
;先看头文件 CameraProviderManager.h
中定义的几个重要数据结构和函数:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
// CameraProviderManager.h class CameraProviderManager : virtual public hidl::manager::V1_0::IServiceNotification { public: ... // 定义纯虚函数 struct ServiceInteractionProxy { virtual bool registerForNotifications( const std::string &serviceName, const sp<hidl::manager::V1_0::IServiceNotification> ¬ification) = 0; virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService(const std::string &serviceName) = 0; virtual ~ServiceInteractionProxy() {} }; // 调用 ICameraProvider 实现这些方法 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); } }; struct StatusListener : virtual public RefBase { ~StatusListener() {} virtual void onDeviceStatusChanged(const String8 &cameraId, 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; }; virtual hardware::Return<void> onRegistration( const hardware::hidl_string& fqName, const hardware::hidl_string& name, bool preexisting) override; status_t initialize(wp<StatusListener> listener, ServiceInteractionProxy *proxy = &sHardwareServiceInteractionProxy); private: static HardwareServiceInteractionProxy sHardwareServiceInteractionProxy; |
ServiceInteractionProxy
定义了几个纯虚函数,用于向HAL
系统服务中注册registerForNotifications
监听ICameraProvider.hal
的消息;getService
返回ICameraProvider
的实例。HardwareServiceInteractionProxy
ServiceInteractionProxy
的实现结构体,具体调用ICameraProvider
对应的registerForNotifications, getService
;也就是CameraProviderManager
持有ICameraProvider
的远程实例。onRegistration
registerForNotifications
的回调函数,注册成功后回调。StatusListener
状态监听接口,这些接口是在CameraService
中实现的;用于CameraProviderManager
回调CameraService
。sHardwareServiceInteractionProxy
静态变量,是初始化initialize
函数形参ServiceInteractionProxy
的默认值。
从 CameraService
中调用 CameraProviderManager::initialize
时,传入的是 CameraService
的实例,仅仅一个参数,所以 ServiceInteractionProxy
使用的是默认的 sHardwareServiceInteractionProxy
实例。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// CameraProviderManager.cpp // 实例化 HAL 代理 CameraProviderManager::HardwareServiceInteractionProxy CameraProviderManager::sHardwareServiceInteractionProxy{}; status_t CameraProviderManager::initialize( wp<CameraProviderManager::StatusListener> listener, ServiceInteractionProxy* proxy) { ... mListener = listener; mServiceProxy = proxy; bool success = mServiceProxy->registerForNotifications( /* instance name, empty means no filter */ "", this); ... addProviderLocked(kLegacyProviderName, /*expected*/ false); return OK; } |
CameraProviderManager::initialize
中主要是初始化赋值 mListener, mServiceProxy
,并通过 sHardwareServiceInteractionProxy->registerForNotifications
向 HIDL
服务管理注册了自己,最后调用 addProviderLocked
。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
// CameraProviderManager.cpp status_t CameraProviderManager::addProviderLocked( const std::string& newProvider, bool expected) { for (const auto& providerInfo : mProviders) { if (providerInfo->mProviderName == newProvider) { ALOGW(...); return ALREADY_EXISTS; } } // HIDL 通信,通过 ICameraProvider 和 HAL 层通信 sp<provider::V2_4::ICameraProvider> interface; interface = mServiceProxy->getService(newProvider); if (interface == nullptr) { ... } sp<ProviderInfo> providerInfo = new ProviderInfo(newProvider, interface, this); status_t res = providerInfo->initialize(); if (res != OK) { return res; } mProviders.push_back(providerInfo); return OK; } |
addProviderLocked
中有如下信息:
- 通过代理获取
ICameraProvider
实例,用于和HAL
通信 - 新建
ProviderInfo
并初始化,保存ICameraProvider
实例 mProviders
保存所有的ProviderInfo
(实测只有一个实例元素,名称为legacy/0
)
1 2 3 4 5 6 7 8 9 10 11 12 |
// CameraProviderManager.h struct ProviderInfo : virtual public hardware::camera::provider::V2_4::ICameraProviderCallback, virtual public hardware::hidl_death_recipient { const std::string mProviderName; const sp<hardware::camera::provider::V2_4::ICameraProvider> mInterface; const metadata_vendor_id_t mProviderTagid; ... } |
ProviderInfo
继承了 ICameraProviderCallback, hidl_death_recipient
,它会处理来着 ICameraProvider
的回调。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
// CameraProviderManager.cpp CameraProviderManager::ProviderInfo::ProviderInfo( const std::string &providerName, sp<provider::V2_4::ICameraProvider>& interface, CameraProviderManager *manager) : mProviderName(providerName), mInterface(interface), mProviderTagid(generateVendorTagId(providerName)), mUniqueDeviceCount(0), mManager(manager) { (void) mManager; } status_t CameraProviderManager::ProviderInfo::initialize() { status_t res = parseProviderName(mProviderName, &mType, &mId); ... // 设置回调 hardware::Return<Status> status = mInterface->setCallback(this); ... // HIDL 连接 hardware::Return<bool> linked = mInterface->linkToDeath(this, /*cookie*/ mId); ... // Get initial list of camera devices, if any std::vector<std::string> devices; // 获取 CameraIdList ,实际是获取的一组设备名 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; // 添加从 HAL 返回的每个设备名 status_t res = addDevice(device, hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT, &id); ... } ... return OK; } |
ProviderInfo::initialize
初始化,主要是从 HAL
获取设备名后,添加具体的设备信息。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
// CameraProviderManager.h struct DeviceInfo { const std::string mName; // Full instance name const std::string mId; // ID section of full name const hardware::hidl_version mVersion; const metadata_vendor_id_t mProviderTagid; ... protected: bool mHasFlashUnit; template<class InterfaceT> static status_t setTorchMode(InterfaceT& interface, bool enabled); }; // HALv1-specific camera fields, including the actual device interface struct DeviceInfo1 : public DeviceInfo { typedef hardware::camera::device::V1_0::ICameraDevice InterfaceT; const sp<InterfaceT> mInterface; ... private: CameraParameters2 mDefaultParameters; }; // HALv3-specific camera fields, including the actual device interface struct DeviceInfo3 : public DeviceInfo { typedef hardware::camera::device::V3_2::ICameraDevice InterfaceT; const sp<InterfaceT> mInterface; ... private: CameraMetadata mCameraCharacteristics; }; |
头文件中可以看出,DeviceInfo
有两个子类,分别对应 HAL 1
和 HAL 3
,并将具体的 ICameraDevice
版本保存到 mInterface
中;所以设备添加时也会根据不同版本分别添加:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 |
// CameraProviderManager.cpp status_t CameraProviderManager::ProviderInfo::addDevice( const std::string& name, CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) { ... status_t res = parseDeviceName(name, &major, &minor, &type, &id); ... 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(...); return BAD_VALUE; } ... return OK; } 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) const { Status status; auto cameraInterface = getDeviceInterface<typename DeviceInfoT::InterfaceT>(name); if (cameraInterface == nullptr) return nullptr; CameraResourceCost resourceCost; cameraInterface->getResourceCost([&status, &resourceCost]( Status s, CameraResourceCost cost) { status = s; resourceCost = cost; }); ... return std::unique_ptr<DeviceInfo>( new DeviceInfoT(name, tagId, id, minorVersion, resourceCost, cameraInterface)); } |
根据传入的 deviceName
解析版本号、类型、设备 Id
(前后摄),并根据 major
版本号(表示 HAL 1
或者 HAL 3
) 分别初始化对应的 DeviceInfo
;在 initializeDeviceInfo
中通过 getDeviceInterface
获取对应的 ICameraDevice
版本,在对应版本 DeviceInfo
实例化时保存;也就是将 DeviceInfo
和 HAL
层的 ICameraDevice
绑定。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
// CameraProviderManager.cpp 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; // 获取 Camera 设备配置信息 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(...); 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
的构造函数,它会向 HAL
层请求当前设备的配置信息,并保存 mCameraCharacteristics
,后续查看属性时都会通过这个变量查询。CameraService::enumerateProviders
中,首先新建并初始化 CameraProviderManager
,其持有和 HAL
通信的实例;接着新建并初始化 CameraFlashlight
,用于控制闪光灯。先看头文件:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
// CameraFlashlight.h class FlashControlBase : public virtual VirtualLightRefBase { public: ... virtual status_t hasFlashUnit(const String8& cameraId, bool *hasFlash) = 0; virtual status_t setTorchMode(const String8& cameraId, bool enabled) = 0; }; // HAL 3 闪光灯控制 class ProviderFlashControl : public FlashControlBase { public: ... // FlashControlBase status_t hasFlashUnit(const String8& cameraId, bool *hasFlash); status_t setTorchMode(const String8& cameraId, bool enabled); private: sp<CameraProviderManager> mProviderManager; ... }; // HAL 1 闪光灯控制,通过 CameraHardwareInterface 向下调用 class CameraHardwareInterfaceFlashControl : public FlashControlBase { public: ... // FlashControlBase status_t setTorchMode(const String8& cameraId, bool enabled); status_t hasFlashUnit(const String8& cameraId, bool *hasFlash); private: sp<CameraProviderManager> mProviderManager; const camera_module_callbacks_t *mCallbacks; sp<CameraHardwareInterface> mDevice; String8 mCameraId; CameraParameters mParameters; ... } class CameraFlashlight : public virtual VirtualLightRefBase { public: ... bool hasFlashUnit(const String8& cameraId); status_t setTorchMode(const String8& cameraId, bool enabled); private: sp<FlashControlBase> mFlashControl; sp<CameraProviderManager> mProviderManager; const camera_module_callbacks_t *mCallbacks; |
头文件定义的几个信息:
CameraHardwareInterfaceFlashControl
HAL 1
闪光灯控制类,通过CameraHardwareInterface
向下调用。ProviderFlashControl
HAL 3
闪光灯控制类。FlashControlBase
基类。CameraProviderManager
主要用于ProviderFlashControl
向下发送信息。camera_module_callbacks_t
HAL
层的回调。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
// CameraFlashlight.cpp CameraFlashlight::CameraFlashlight( sp<CameraProviderManager> providerManager, camera_module_callbacks_t* callbacks) : mProviderManager(providerManager), mCallbacks(callbacks), mFlashlightMapInitialized(false) { } status_t CameraFlashlight::findFlashUnits() { ... mFlashControl.clear(); for (auto &id : cameraIds) { ssize_t index = mHasFlashlightMap.indexOfKey(id); if (0 <= index) { continue; } bool hasFlash = false; res = createFlashlightControl(id); ... } ... return OK; } status_t CameraFlashlight::createFlashlightControl( const String8& cameraId) { ... if (mProviderManager->supportSetTorchMode(cameraId.string())) { mFlashControl = new ProviderFlashControl(mProviderManager); } else { // Only HAL1 devices do not support setTorchMode mFlashControl = new CameraHardwareInterfaceFlashControl(mProviderManager, *mCallbacks); } return OK; } |
CameraFlashlight
的构造函数仅仅初始化了几个本地变量,CameraService
中调用 CameraFlashlight::findFlashUnits
时,会根据 HAL 1/3
分别来创建对应的闪光灯控制类。至此整个 CameraService
注册流程结束。
小结
CameraService
初始化和注册流程中,实例化了两个对象:
CameraProviderManager mCameraProviderManager
对象Flashlight mFlashlight
对象
CameraProviderManager
初始化完后:
mProviders
保存了ProviderInfo
对象;并关联了ICameraProvider
,用于和HAL
通信ProviderInfo
中mDevices
保存了所有的DeviceInfo1, DeviceInfo3
设备信息,并关联ICameraDevice
实例,用于直接通信DeviceInfo1
中保存了CameraParameters2 mDefaultParameters
参数信息DeviceInfo3
中保存了CameraMetadata mCameraCharacteristics
参数信息
CameraFlashlight
新建和初始化后:
- 如果是
HAL 1
会实例化控制类CameraHardwareInterfaceFlashControl
- 如果是
HAL 3
会实例化控制类ProviderFlashControl
Camera Open
流程
API
Camera API 2
开启摄像头设备时,通过 CameraManager.openCamera
来打开:
1 2 3 4 5 6 7 8 9 |
// CameraManager.java @RequiresPermission(android.Manifest.permission.CAMERA) public void openCamera(@NonNull String cameraId, @NonNull final CameraDevice.StateCallback callback, @Nullable Handler handler) throws CameraAccessException { openCameraForUid(cameraId, callback, handler, USE_CALLING_UID); } |
String cameraId
表示前后摄的ID
,通常 0 表示后摄。CameraDevice.StateCallback callback
打开设备时,状态回调接口。Handler handler
表示回调接口在哪