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

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

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.aidl4 directories, 16 files

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 ...

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/android/hardware/camera2/ICameraDeviceUser.java
av/camera/aidl/android/hardware/camera2/ICameraDeviceCallbacks.java

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

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",...
}

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.cppandroid/hardware/ICameraServiceListener.h
android/hardware/BnCameraServiceListener.h
frameworks/av/camera/aidl/android/hardware/ICameraServiceListener.cppandroid/hardware/ICameraServiceProxy.h
android/hardware/BnCameraServiceProxy.h
frameworks/av/camera/aidl/android/hardware/ICameraServiceProxy.cppandroid/hardware/camera2/ICameraDeviceUser.h
android/hardware/camera2/BnCameraDeviceUser.h
frameworks/av/camera/aidl/android/hardware/camera2/ICameraDeviceUser.cppandroid/hardware/camera2/ICameraDeviceCallbacks.h
android/hardware/camera2/BnCameraDeviceCallbacks.h
frameworks/av/camera/aidl/android/hardware/camera2/ICameraDeviceCallbacks.cpp

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

1
2
3
4

package android.hardware;/** @hide */
parcelable CameraStatus cpp_header "camera/CameraBase.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

// .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

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 + hal1ICamera connect(ICameraClient client,int cameraId,String opPackageName,int clientUid, int clientPid);// api2 + hal3ICameraDeviceUser 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);
}

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);
}

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 的重复请求，并返回上次请求的帧 idlong 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);// 创建输入流，返回流 idint createInputStream(int width, int height, int format);// 返回输入流的 SurfaceSurface getInputSurface();// Keep in sync with public API in// frameworks/base/core/java/android/hardware/camera2/CameraDevice.javaconst 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();
}

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

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

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
...
}

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) {
}

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

1
2
3
4
5

// API1: CameraClient.h
sp<CameraHardwareInterface>     mHardware;
// device1: CameraHardwareInterface.h
sp<hardware::camera::device::V1_0::ICameraDevice> mHidlDevice;
// 这里的 ICameraDevice 即为 HAL1

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 requestTemplatestatus_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();...}...
}

1
2
3
4

.
├── Android.mk
├── cameraserver.rc         // rc 文件
└── main_cameraserver.cpp   // 主进程

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 callshardware::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 drmrpcioprio rt 4writepid /dev/cpuset/camera-daemon/tasks /dev/stune/top-app/tasks

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"; }...
}

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"; }
}

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 ，并连接 Hardwareres = enumerateProviders();if (res == OK) {mInitialized = true;}// CameraServiceProxy 服务是 Java 代码注册的// 但是 CameraService 启动时间很早，CameraServiceProxy 可能还并没有注册// 实际调试结果也是，这段代码实际不会调用 CameraServiceProxy 对应方法CameraService::pingCameraServiceProxy();
}

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() {...// 实例化 CameraProviderManagerif (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;
}

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>&notification) = 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>&notification) 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;

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;
}

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;
}

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;...
}

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 anystd::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;
}

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 nameconst std::string mId;    // ID section of full nameconst 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;
};

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));
}

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 availabilityStatus 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;}
}

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:...// FlashControlBasestatus_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:...// FlashControlBasestatus_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;

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 setTorchModemFlashControl =new CameraHardwareInterfaceFlashControl(mProviderManager,*mCallbacks);}return OK;
}

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);
}

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

CameraDevice.StateCallback mCameraDeviceStateCallback = new CameraDevice.StateCallback() {@Overridepublic void onOpened(@NonNull CameraDevice camera) {mCameraDevice = camera;//createCameraCaptureSession();}@Overridepublic void onDisconnected(@NonNull CameraDevice camera) {camera.close();mCameraDevice = null;}@Overridepublic void onError(@NonNull CameraDevice camera, int error) {camera.close();mCameraDevice = null;}
};try {mCameraManager.openCamera(mCameraId, mCameraDeviceStateCallback,mBackHandler);
} catch (CameraAccessException e) {e.printStackTrace();
}

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

// 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);
}private CameraDevice openCameraDeviceUserAsync(String cameraId,CameraDevice.StateCallback callback, Handler handler, final int uid)throws CameraAccessException {CameraCharacteristics characteristics = getCameraCharacteristics(cameraId);CameraDevice device = null;synchronized (mLock) {ICameraDeviceUser cameraUser = null;// 新建 CameraDeviceImpl 实例android.hardware.camera2.impl.CameraDeviceImpl deviceImpl =new android.hardware.camera2.impl.CameraDeviceImpl(cameraId,callback,handler,characteristics,mContext.getApplicationInfo().targetSdkVersion);// 获取 ICameraDeviceCallbacks 回调ICameraDeviceCallbacks callbacks = deviceImpl.getCallbacks();try {if (supportsCamera2ApiLocked(cameraId)) {// Use cameraservice's cameradeviceclient // implementation for HAL3.2+ devicesICameraService cameraService = CameraManagerGlobal.get().getCameraService();if (cameraService == null) {throw new ServiceSpecificException(...);}// 连接设备，并获取 ICameraDeviceUsercameraUser = cameraService.connectDevice(callbacks,cameraId, mContext.getOpPackageName(), uid);} else {// Use legacy camera implementation for HAL1 devicesint id;try {id = Integer.parseInt(cameraId);} catch (NumberFormatException e) {throw new IllegalArgumentException(...);}Log.i(TAG, "Using legacy camera HAL.");cameraUser = CameraDeviceUserShim.connectBinderShim(callbacks, id);}} catch (ServiceSpecificException e) {...} catch (RemoteException e) {...}// 关联 CameraDeviceImpl 和 ICameraDeviceUser ，方便直接通信deviceImpl.setRemoteDevice(cameraUser);device = deviceImpl;}return device;
}// CameraDeviceImpl.java
public void setRemoteDevice(ICameraDeviceUser remoteDevice) throws CameraAccessException {synchronized(mInterfaceLock) {...// 新建包装类，包装接口并处理对应访问异常mRemoteDevice = new ICameraDeviceUserWrapper(remoteDevice);...}
}

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

// CameraService.cpp
Status CameraService::connectDevice(const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb,const String16& cameraId,const String16& clientPackageName,int clientUid,/*out*/sp<hardware::camera2::ICameraDeviceUser>* device) {ATRACE_CALL();Status ret = Status::ok();String8 id = String8(cameraId);sp<CameraDeviceClient> client = nullptr;ret = connectHelper<hardware::camera2::ICameraDeviceCallbacks,CameraDeviceClient>(cameraCb, id,CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName,clientUid, USE_CALLING_PID, API_2,/*legacyMode*/ false, /*shimUpdateOnly*/ false,/*out*/client);...*device = client;return ret;
}template<class CALLBACK, class CLIENT>
Status CameraService::connectHelper(const sp<CALLBACK>& cameraCb,const String8& cameraId, int halVersion,const String16& clientPackageName, int clientUid, int clientPid,apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly,/*out*/sp<CLIENT>& device) {...{sp<BasicClient> tmp = nullptr;if(!(ret = makeClient(this, cameraCb, clientPackageName, cameraId, facing, clientPid, clientUid, getpid(),legacyMode, halVersion, deviceVersion, effectiveApiLevel,/*out*/&tmp)).isOk()) {return ret;}...err = client->initialize(mCameraProviderManager);...if (shimUpdateOnly) {mServiceLock.unlock();client->disconnect();mServiceLock.lock();} else {// Otherwise, add client to active clients listfinishConnectLocked(client, partial);}} // lock is destroyed, allow further connect callsdevice = client;return ret;
}

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

Status CameraService::makeClient(const sp<CameraService>& cameraService,const sp<IInterface>& cameraCb, const String16& packageName,const String8& cameraId, int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode,int halVersion, int deviceVersion, apiLevel effectiveApiLevel,/*out*/sp<BasicClient>* client) {if (halVersion < 0 || halVersion == deviceVersion) {switch(deviceVersion) {case CAMERA_DEVICE_API_VERSION_1_0:if (effectiveApiLevel == API_1) {  // Camera1 API routesp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());*client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId), facing, clientPid, clientUid, getpid(), legacyMode);} else { // Camera2 API routeALOGW("Camera using old HAL version: %d", deviceVersion);return STATUS_ERROR_FMT(...);}break;case CAMERA_DEVICE_API_VERSION_3_0:case CAMERA_DEVICE_API_VERSION_3_1:case CAMERA_DEVICE_API_VERSION_3_2:case CAMERA_DEVICE_API_VERSION_3_3:case CAMERA_DEVICE_API_VERSION_3_4:if (effectiveApiLevel == API_1) { // Camera1 API routesp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());*client = new Camera2Client(cameraService, tmp, packageName, cameraIdToInt(cameraId), facing,clientPid, clientUid, servicePid, legacyMode);} else { // Camera2 API routesp<hardware::camera2::ICameraDeviceCallbacks> tmp =static_cast<hardware::camera2::ICameraDeviceCallbacks*>(cameraCb.get());*client = new CameraDeviceClient(cameraService, tmp, packageName, cameraId, facing, clientPid,clientUid, servicePid);}break;default:// Should not be reachableALOGE("Unknown camera device HAL version:%d", deviceVersion);return STATUS_ERROR_FMT(...);}} else {if (deviceVersion > CAMERA_DEVICE_API_VERSION_1_0 &&halVersion == CAMERA_DEVICE_API_VERSION_1_0) {sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());*client = new CameraClient(cameraService, tmp, packageName,cameraIdToInt(cameraId), facing, clientPid, clientUid, servicePid, legacyMode);} else {ALOGE("Invalid camera HAL version ..");return STATUS_ERROR_FMT(...;}}return Status::ok();
}

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

// CameraService.h
class BasicClient : public virtual RefBase {
public:virtual status_t initialize(sp<CameraProviderManager> manager) = 0;...
private:...class OpsCallback : public BnAppOpsCallback {public:explicit OpsCallback(wp<BasicClient> client);virtual void opChanged(int32_t op, const String16& packageName);private:wp<BasicClient> mClient;}; // class OpsCallbacksp<OpsCallback> mOpsCallback;...
}// Camera3Device.h
class Camera3Device :public CameraDeviceBase,virtual public hardware::camera::device::V3_2::ICameraDeviceCallback,private camera3_callback_ops
{...}// Camera2ClientBase.h
template <typename TClientBase>
class Camera2ClientBase :public TClientBase,public CameraDeviceBase::NotificationListener
{
public:typedef typename TClientBase::TCamCallbacks TCamCallbacks;...
protected:// 实例为 Camera3Devicesp<CameraDeviceBase>  mDevice;...
private:...template<typename TProviderPtr>status_t              initializeImpl(TProviderPtr providerPtr);
};// CameraDeviceClient.h
struct CameraDeviceClientBase :public CameraService::BasicClient,public hardware::camera2::BnCameraDeviceUser
{typedef hardware::camera2::ICameraDeviceCallbacks TCamCallbacks;...protected:CameraDeviceClientBase(const sp<CameraService>& cameraService,const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback,const String16& clientPackageName,const String8& cameraId,int cameraFacing,int clientPid,uid_t clientUid,int servicePid);sp<hardware::camera2::ICameraDeviceCallbacks> mRemoteCallback;
};class CameraDeviceClient :public Camera2ClientBase<CameraDeviceClientBase>,public camera2::FrameProcessorBase::FilteredListener
{...}

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
80

// CameraDeviceClient.cpp
CameraDeviceClient::CameraDeviceClient(const sp<CameraService>& cameraService,const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback,const String16& clientPackageName,const String8& cameraId,int cameraFacing,int clientPid,uid_t clientUid,int servicePid) :Camera2ClientBase(cameraService, remoteCallback, clientPackageName,cameraId, cameraFacing, clientPid, clientUid, servicePid),mInputStream(),mStreamingRequestId(REQUEST_ID_NONE),mRequestIdCounter(0),mPrivilegedClient(false) {...
}// 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)
{...// 实例化 Camera3DevicemDevice = new Camera3Device(cameraId);
}// CameraDeviceClient.cpp
CameraDeviceClientBase::CameraDeviceClientBase(const sp<CameraService>& cameraService,const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback,const String16& clientPackageName,const String8& cameraId,int cameraFacing,int clientPid,uid_t clientUid,int servicePid) :BasicClient(cameraService,IInterface::asBinder(remoteCallback),clientPackageName,cameraId,cameraFacing,clientPid,clientUid,servicePid),mRemoteCallback(remoteCallback) {
}// CameraService.cpp
CameraService::BasicClient::BasicClient(const sp<CameraService>& cameraService,const sp<IBinder>& remoteCallback,const String16& clientPackageName,const String8& cameraIdStr, int cameraFacing,int clientPid, uid_t clientUid,int servicePid):mCameraIdStr(cameraIdStr), mCameraFacing(cameraFacing),mClientPackageName(clientPackageName), mClientPid(clientPid), mClientUid(clientUid),mServicePid(servicePid),mDisconnected(false),mRemoteBinder(remoteCallback)
{...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// CameraDeviceClient.cpp
template<typename TProviderPtr>
status_t CameraDeviceClient::initializeImpl(TProviderPtr providerPtr) {...res = Camera2ClientBase::initialize(providerPtr);...String8 threadName;mFrameProcessor = new FrameProcessorBase(mDevice);threadName = String8::format("CDU-%s-FrameProc", mCameraIdStr.string());mFrameProcessor->run(threadName.string());mFrameProcessor->registerListener(FRAME_PROCESSOR_LISTENER_MIN_ID,FRAME_PROCESSOR_LISTENER_MAX_ID,/*listener*/this,/*sendPartials*/true);return OK;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// Camera2ClientBase.cpp
template <typename TClientBase>
status_t Camera2ClientBase<TClientBase>::initialize(sp<CameraProviderManager> manager) {return initializeImpl(manager);
}template <typename TClientBase>
template <typename TProviderPtr>
status_t Camera2ClientBase<TClientBase>::initializeImpl(TProviderPtr providerPtr) {...res = mDevice->initialize(providerPtr);...return OK;
}

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

// Camera3Device.cpp
status_t Camera3Device::initialize(sp<CameraProviderManager> manager) {...sp<ICameraDeviceSession> session;// 打开会话，获取 ICameraDeviceSessionstatus_t res = manager->openSession(mId.string(), this,/*out*/ &session);...// 获取当前设备的配置信息，并保存到 CameraMetadata mDeviceInfores = manager->getCameraCharacteristics(mId.string(), &mDeviceInfo);...// 通过 ICameraDeviceSession 获取请求队列std::shared_ptr<RequestMetadataQueue> queue;auto requestQueueRet = session->getCaptureRequestMetadataQueue([&queue](const auto& descriptor) {queue = std::make_shared<RequestMetadataQueue>(descriptor);...});...// 通过 ICameraDeviceSession 获取结果队列std::unique_ptr<ResultMetadataQueue>& resQueue=mResultMetadataQueue;auto resultQueueRet = session->getCaptureResultMetadataQueue([&resQueue](const auto& descriptor) {resQueue=std::make_unique<ResultMetadataQueue>(descriptor);...});...// 新建 HalInterface 实例，并绑定 ICameraDeviceSession 以及请求队列mInterface = new HalInterface(session, queue);...return initializeCommonLocked();
}

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

// CameraProviderManager.cpp
status_t CameraProviderManager::openSession(const std::string &id,const sp<hardware::camera::device::V3_2::ICameraDeviceCallback>&callback, /*out*/sp<hardware::camera::device::V3_2::ICameraDeviceSession> *session){std::lock_guard<std::mutex> lock(mInterfaceMutex);auto deviceInfo = findDeviceInfoLocked(id,/*minVersion*/ {3,0}, /*maxVersion*/ {4,0});if (deviceInfo == nullptr) return NAME_NOT_FOUND;auto *deviceInfo3=static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);Status status;hardware::Return<void> ret;// 向 HAL 打开设备，并返回 ICameraDeviceSessionret = deviceInfo3->mInterface->open(callback, [&status, &session] (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {status = s;if (status == Status::OK) {*session = cameraSession;}});...
}

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

// Camera3Device.cpp
status_t Camera3Device::initializeCommonLocked() {/** Start up status tracker thread */mStatusTracker = new StatusTracker(this);status_t res = mStatusTracker->run(String8::format("C3Dev-%s-Status", mId.string()).string());.../** Register in-flight map to the status tracker */mInFlightStatusId = mStatusTracker->addComponent();/** Create buffer manager */mBufferManager = new Camera3BufferManager();mTagMonitor.initialize(mVendorTagId);/** Start up request queue thread */mRequestThread = new RequestThread(this, mStatusTracker, mInterface);res = mRequestThread->run(String8::format("C3Dev-%s-ReqQueue", mId.string()).string());...mPreparerThread = new PreparerThread();...return OK;
}

1
2
3
4
5

// CameraDevice.java
public abstract void createCaptureSession(@NonNull List<Surface> outputs,@NonNull CameraCaptureSession.StateCallback callback, @Nullable Handler handler)throws CameraAccessException;

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

// CameraDeviceImpl.java
@Override
public void createCaptureSession(List<Surface> outputs,CameraCaptureSession.StateCallback callback, Handler handler)throws CameraAccessException {// 将 Surface 转换为 OutputConfigurationList<OutputConfiguration> outConfigurations = new ArrayList<>(outputs.size());for (Surface surface : outputs) {outConfigurations.add(new OutputConfiguration(surface));}createCaptureSessionInternal(null, outConfigurations, callback, handler, ICameraDeviceUser.NORMAL_MODE);
}private void createCaptureSessionInternal(InputConfiguration inputConfig,List<OutputConfiguration> outputConfigurations,CameraCaptureSession.StateCallback callback, Handler handler,int operatingMode) throws CameraAccessException {...// 创建会话时，输入 Surface 为空Surface input = null;try {// configure streams and then block until IDLE// 向 Framework, HAL 发送信息，配置设备configureSuccess = configureStreamsChecked(inputConfig, outputConfigurations, operatingMode);if (configureSuccess == true && inputConfig != null) {input = mRemoteDevice.getInputSurface();}} catch (CameraAccessException e) {...}...CameraCaptureSessionCore newSession = null;// 根据模式来实例化对应的 Sessionif (isConstrainedHighSpeed) {newSession = new CameraConstrainedHighSpeedCaptureSessionImpl(mNextSessionId++, callback, handler, this, mDeviceHandler, configureSuccess, mCharacteristics);} else {// 假设实例化 CameraCaptureSessionImplnewSession = new CameraCaptureSessionImpl(mNextSessionId++, input, callback, handler, this, mDeviceHandler, configureSuccess);}mCurrentSession = newSession;...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

mCameraDevice.createCaptureSession(Arrays.asList(mTextureSurface, mImageReader.getSurface()), new CameraCaptureSession.StateCallback() {@Overridepublic void onConfigured(@NonNull CameraCaptureSession session) {Log.d(TAG, "onConfigured: ");mCameraCaptureSession = session;preview();}@Overridepublic void onConfigureFailed(@NonNull CameraCaptureSession session) {Log.e(TAG, "onConfigureFailed: ");}}, null);
} catch (CameraAccessException e) {e.printStackTrace();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public static abstract class StateCallback {public abstract void onConfigured(@NonNull CameraCaptureSession session);public abstract void onConfigureFailed(@NonNull CameraCaptureSession session);public void onReady(@NonNull CameraCaptureSession session) {// default empty implementation}public void onActive(@NonNull CameraCaptureSession session) {// default empty implementation}public void onCaptureQueueEmpty(@NonNull CameraCaptureSession session) {// default empty implementation}public void onClosed(@NonNull CameraCaptureSession session) {// default empty implementation}public void onSurfacePrepared(@NonNull CameraCaptureSession session,@NonNull Surface surface) {// default empty implementation}
}

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

// CameraCaptureSessionImpl.java
public class CameraCaptureSessionImpl extends CameraCaptureSessionimplements CameraCaptureSessionCore {CameraCaptureSessionImpl(int id, Surface input,CameraCaptureSession.StateCallback callback,Handler stateHandler,android.hardware.camera2.impl.CameraDeviceImpl deviceImpl,Handler deviceStateHandler, boolean configureSuccess) {...mStateCallback = createUserStateCallbackProxy(mStateHandler, callback);...// 根据传入的参数，响应 CameraCaptureSession.StateCallback 回调if (configureSuccess) {mStateCallback.onConfigured(this);if (DEBUG) Log.v(...);mConfigureSuccess = true;} else {mStateCallback.onConfigureFailed(this);mClosed = true; Log.e(...);mConfigureSuccess = false;}}...// 用户指定并传入的回调实现及对应线程private final CameraCaptureSession.StateCallback mStateCallback;private final Handler mStateHandler;private StateCallback createUserStateCallbackProxy(Handler handler,StateCallback callback) {InvokeDispatcher<StateCallback> userCallbackSink = new InvokeDispatcher<>(callback);HandlerDispatcher<StateCallback> handlerPassthrough =new HandlerDispatcher<>(userCallbackSink, handler);// 创建代理类return new CallbackProxies.SessionStateCallbackProxy(handlerPassthrough);}
}

1
2
3
4
5
6
7
8
9
10

/*** Proxy out invocations to the camera2 API callbacks into * a {@link Dispatchable}.** <p>Since abstract classes do not support Java's dynamic {@code Proxy},* we have to to use our own proxy mechanism.</p>*/
public class CallbackProxies {}

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

// CameraDeviceImpl.java
public boolean configureStreamsChecked(InputConfiguration inputConfig,List<OutputConfiguration> outputs, int operatingMode)throws CameraAccessException {...// createCaptureSession 时，imputConfig 为空checkInputConfiguration(inputConfig);boolean success = false;synchronized(mInterfaceLock) {...mDeviceHandler.post(mCallOnBusy);stopRepeating();try {waitUntilIdle();mRemoteDevice.beginConfigure();...// Delete all streams first (to free up HW resources)for (Integer streamId : deleteList) {mRemoteDevice.deleteStream(streamId);mConfiguredOutputs.delete(streamId);}// Add all new streamsfor (OutputConfiguration outConfig : outputs) {if (addSet.contains(outConfig)) {int streamId = mRemoteDevice.createStream(outConfig);mConfiguredOutputs.put(streamId, outConfig);}}operatingMode = (operatingMode | (customOpMode << 16));mRemoteDevice.endConfigure(operatingMode);success = true;} catch (...)}return success;
}

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

// CameraDeviceClient.cpp
binder::Status CameraDeviceClient::createStream(const hardware::camera2::params::OutputConfiguration &outputConfiguration,/*out*/int32_t* newStreamId) {...// 获取 IGraphicBufferProducer 的个数const std::vector<sp<IGraphicBufferProducer>>& bufferProducers =outputConfiguration.getGraphicBufferProducers();size_t numBufferProducers = bufferProducers.size();...std::vector<sp<Surface>> surfaces;std::vector<sp<IBinder>> binders;...OutputStreamInfo streamInfo;bool isStreamInfoValid = false;for (auto& bufferProducer : bufferProducers) {...// 创建 Native Surfacesp<Surface> surface;res = createSurfaceFromGbp(streamInfo, isStreamInfoValid, surface, bufferProducer);if (!res.isOk())return res;...binders.push_back(IInterface::asBinder(bufferProducer));surfaces.push_back(surface);}int streamId = camera3::CAMERA3_STREAM_ID_INVALID;// 调用 Camera3Device 创建流err = mDevice->createStream(surfaces, deferredConsumer, streamInfo.width, streamInfo.height, streamInfo.format, streamInfo.dataSpace,static_cast<camera3_stream_rotation_t>(outputConfiguration.getRotation()),&streamId, outputConfiguration.getSurfaceSetID(), isShared);if (err != OK) {...} else {...mStreamInfoMap[streamId] = streamInfo;...// Set transform flags to ensure preview to be rotated correctly.res = setStreamTransformLocked(streamId);*newStreamId = streamId;}return res;
}

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

binder::Status CameraDeviceClient::createSurfaceFromGbp(OutputStreamInfo& streamInfo, bool isStreamInfoValid,sp<Surface>& surface, const sp<IGraphicBufferProducer>& gbp) {...// 根据 IGraphicBufferProducer 创建 Surfacesurface = new Surface(gbp, useAsync);ANativeWindow *anw = surface.get();int width, height, format;android_dataspace dataSpace;// 查询对应的长、宽、格式、数据空间if ((err = anw->query(anw, NATIVE_WINDOW_WIDTH, &width)) != OK) {...}if ((err = anw->query(anw, NATIVE_WINDOW_HEIGHT, &height)) != OK) {...}if ((err = anw->query(anw, NATIVE_WINDOW_FORMAT, &format)) != OK) {...}if ((err = anw->query(anw, NATIVE_WINDOW_DEFAULT_DATASPACE,reinterpret_cast<int*>(&dataSpace))) != OK) {...}...// 赋值给输出流if (!isStreamInfoValid) {streamInfo.width = width;streamInfo.height = height;streamInfo.format = format;streamInfo.dataSpace = dataSpace;streamInfo.consumerUsage = consumerUsage;return binder::Status::ok();}...
}

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

typedef enum {HAL_PIXEL_FORMAT_RGBA_8888 = 1,HAL_PIXEL_FORMAT_RGBX_8888 = 2,HAL_PIXEL_FORMAT_RGB_888 = 3,HAL_PIXEL_FORMAT_RGB_565 = 4,HAL_PIXEL_FORMAT_BGRA_8888 = 5,HAL_PIXEL_FORMAT_RGBA_1010102 = 43, // 0x2BHAL_PIXEL_FORMAT_RGBA_FP16 = 22, // 0x16HAL_PIXEL_FORMAT_YV12 = 842094169, // 0x32315659HAL_PIXEL_FORMAT_Y8 = 538982489, // 0x20203859HAL_PIXEL_FORMAT_Y16 = 540422489, // 0x20363159HAL_PIXEL_FORMAT_RAW16 = 32, // 0x20HAL_PIXEL_FORMAT_RAW10 = 37, // 0x25HAL_PIXEL_FORMAT_RAW12 = 38, // 0x26HAL_PIXEL_FORMAT_RAW_OPAQUE = 36, // 0x24HAL_PIXEL_FORMAT_BLOB = 33, // 0x21HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED = 34, // 0x22HAL_PIXEL_FORMAT_YCBCR_420_888 = 35, // 0x23HAL_PIXEL_FORMAT_YCBCR_422_888 = 39, // 0x27HAL_PIXEL_FORMAT_YCBCR_444_888 = 40, // 0x28HAL_PIXEL_FORMAT_FLEX_RGB_888 = 41, // 0x29HAL_PIXEL_FORMAT_FLEX_RGBA_8888 = 42, // 0x2AHAL_PIXEL_FORMAT_YCBCR_422_SP = 16, // 0x10HAL_PIXEL_FORMAT_YCRCB_420_SP = 17, // 0x11HAL_PIXEL_FORMAT_YCBCR_422_I = 20, // 0x14HAL_PIXEL_FORMAT_JPEG = 256, // 0x100
} android_pixel_format_t;

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

// Camera3Device.cpp
status_t Camera3Device::createStream(const std::vector<sp<Surface>>& consumers,bool hasDeferredConsumer, uint32_t width, uint32_t height, int format, android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id,int streamSetId, bool isShared, uint64_t consumerUsage) {...// 拍照流if (format == HAL_PIXEL_FORMAT_BLOB) {ssize_t blobBufferSize;if (dataSpace != HAL_DATASPACE_DEPTH) {blobBufferSize = getJpegBufferSize(width, height);if (blobBufferSize <= 0) {SET_ERR_L(...);return BAD_VALUE;}} else {blobBufferSize = getPointCloudBufferSize();if (blobBufferSize <= 0) {SET_ERR_L(...);return BAD_VALUE;}}newStream = new Camera3OutputStream(mNextStreamId, consumers[0],width, height, blobBufferSize, format, dataSpace, rotation, mTimestampOffset, streamSetId);} else if (format == HAL_PIXEL_FORMAT_RAW_OPAQUE) {ssize_t rawOpaqueBufferSize = getRawOpaqueBufferSize(width, height);if (rawOpaqueBufferSize <= 0) {SET_ERR_L(...);return BAD_VALUE;}newStream = new Camera3OutputStream(mNextStreamId, consumers[0],width, height, rawOpaqueBufferSize, format, dataSpace, rotation, mTimestampOffset, streamSetId);}...else {newStream = new Camera3OutputStream(mNextStreamId, consumers[0],width, height, format, dataSpace, rotation,mTimestampOffset, streamSetId);}newStream->setStatusTracker(mStatusTracker);newStream->setBufferManager(mBufferManager);res = mOutputStreams.add(mNextStreamId, newStream);if (res < 0) {SET_ERR_L(...);return res;}*id = mNextStreamId++;mNeedConfig = true;...ALOGV("Camera %s: Created new stream", mId.string());return OK;
}

1
2
3
4
5
6
7

// CameraDeviceClient.cpp
binder::Status CameraDeviceClient::endConfigure(int operatingMode) {...status_t err = mDevice->configureStreams(operatingMode);...return res;
}

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

// Camera3Device.cpp
status_t Camera3Device::configureStreams(int operatingMode) {...return configureStreamsLocked(operatingMode);
}status_t Camera3Device::configureStreamsLocked(int operatingMode) {...camera3_stream_configuration config;config.operation_mode = mOperatingMode;config.num_streams = (mInputStream != NULL) + mOutputStreams.size();Vector<camera3_stream_t*> streams;streams.setCapacity(config.num_streams);if (mInputStream != NULL) {camera3_stream_t *inputStream;inputStream = mInputStream->startConfiguration();if (inputStream == NULL) {CLOGE("Can't start input stream configuration");cancelStreamsConfigurationLocked();return INVALID_OPERATION;}streams.add(inputStream);}for (size_t i = 0; i < mOutputStreams.size(); i++) {if (mOutputStreams[i].get() ==static_cast<Camera3StreamInterface*>(mInputStream.get())) {config.num_streams--;continue;}camera3_stream_t *outputStream;outputStream = mOutputStreams.editValueAt(i)->startConfiguration();if (outputStream == NULL) {CLOGE("Can't start output stream configuration");cancelStreamsConfigurationLocked();return INVALID_OPERATION;}streams.add(outputStream);}config.streams = streams.editArray();// Do the HAL configuration; will potentially touch stream// max_buffers, usage, priv fields.// 向 HAL 层发送配置信息res = mInterface->configureStreams(&config);...if (mInputStream != NULL && mInputStream->isConfiguring()) {res = mInputStream->finishConfiguration();if (res != OK) {CLOGE("Can't finish configuring input stream %d: %s (%d)",mInputStream->getId(), strerror(-res), res);cancelStreamsConfigurationLocked();return BAD_VALUE;}}for (size_t i = 0; i < mOutputStreams.size(); i++) {sp<Camera3OutputStreamInterface> outputStream =mOutputStreams.editValueAt(i);if (outputStream->isConfiguring() && !outputStream->isConsumerConfigurationDeferred()) {res = outputStream->finishConfiguration();if (res != OK) {CLOGE(...);cancelStreamsConfigurationLocked();return BAD_VALUE;}}}...
}

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

// Camera3Device.cpp
status_t Camera3Device::HalInterface::configureStreams(camera3_stream_configuration *config) {...// Invoke configureStreamsdevice::V3_3::HalStreamConfiguration finalConfiguration;common::V1_0::Status status;// See if we have v3.3 HALsp<device::V3_3::ICameraDeviceSession> hidlSession_3_3;auto castResult = device::V3_3::ICameraDeviceSession::castFrom(mHidlSession);if (castResult.isOk()) {hidlSession_3_3 = castResult;} else {ALOGE(...);}if (hidlSession_3_3 != nullptr) {// We do; use v3.3 for the callALOGV("%s: v3.3 device found", __FUNCTION__);auto err = hidlSession_3_3->configureStreams_3_3(requestedConfiguration,[&status, &finalConfiguration](common::V1_0::Status s, const device::V3_3::HalStreamConfiguration& halConfiguration) {finalConfiguration = halConfiguration;status = s;});if (!err.isOk()) {ALOGE(...);return DEAD_OBJECT;}} else {// We don't; use v3.2 call and // construct a v3.3 HalStreamConfigurationALOGV("%s: v3.2 device found", __FUNCTION__);HalStreamConfiguration finalConfiguration_3_2;auto err = mHidlSession->configureStreams(requestedConfiguration,[&status, &finalConfiguration_3_2](common::V1_0::Status s, const HalStreamConfiguration& halConfiguration) {finalConfiguration_3_2 = halConfiguration;status = s;});if (!err.isOk()) {ALOGE(...);return DEAD_OBJECT;}finalConfiguration.streams.resize(finalConfiguration_3_2.streams.size());for (size_t i = 0; i<finalConfiguration_3_2.streams.size(); i++){finalConfiguration.streams[i].v3_2 = finalConfiguration_3_2.streams[i];finalConfiguration.streams[i].overrideDataSpace =requestedConfiguration.streams[i].dataSpace;}}...
}

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

// Camera3Stream.cpp
status_t Camera3Stream::finishConfiguration() {....res = configureQueueLocked();...
}// Camera3OutputStream.cpp
status_t Camera3OutputStream::configureConsumerQueueLocked() {...// Configure consumer-side ANativeWindow interface. // to notify buffer manager (if it is used) of the returned buffers.res = mConsumer->connect(NATIVE_WINDOW_API_CAMERA,/*listener*/mBufferReleasedListener,/*reportBufferRemoval*/true);if (res != OK) {ALOGE(...);return res;}mConsumerName = mConsumer->getConsumerName();res = native_window_set_usage(mConsumer.get(), mUsage);if (res != OK) {ALOGE(...);return res;}res = native_window_set_scaling_mode(mConsumer.get(),NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);if (res != OK) {ALOGE(...);return res;}...
}

1
2
3
4
5
6
7
8
9
10

// CameraCaptureSession.java
// 预览和录像使用同一个 API
public abstract int setRepeatingRequest(@NonNull CaptureRequest request,@Nullable CaptureCallback listener, @Nullable Handler handler)throws CameraAccessException;
// 拍照
public abstract int capture(@NonNull CaptureRequest request,@Nullable CaptureCallback listener, @Nullable Handler handler)throws CameraAccessException;

1
2
3
4
5
6
7

// CameraDevice.java
public static final int TEMPLATE_PREVIEW = 1;
public static final int TEMPLATE_STILL_CAPTURE = 2;
public static final int TEMPLATE_RECORD  = 3;
public static final int TEMPLATE_VIDEO_SNAPSHOT = 4;
public static final int TEMPLATE_ZERO_SHUTTER_LAG = 5;
public static final int TEMPLATE_MANUAL = 6;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

CaptureRequest.Builder previewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
previewRequestBuilder.addTarget(mTextureSurface);
CameraCaptureSession.CaptureCallback captureCallback = new CameraCaptureSession.CaptureCallback() {@Overridepublic void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {//Log.d(TAG, "preview, onCaptureCompleted: ");}
};
mCameraCaptureSession.setRepeatingRequest(previewRequestBuilder.build(), captureCallback, mBackHandler);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

CaptureRequest.Builder captureRequestBuild = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
captureRequestBuild.addTarget(mImageReader.getSurface());
captureRequestBuild.set(CaptureRequest.CONTROL_AF_MODE,CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
captureRequestBuild.set(CaptureRequest.JPEG_ORIENTATION, mImageOrientation);
CameraCaptureSession.CaptureCallback captureCallback = new CameraCaptureSession.CaptureCallback() {@Overridepublic void onCaptureCompleted(@NonNull CameraCaptureSession session,@NonNull CaptureRequest request,@NonNull TotalCaptureResult result) {// Log.d(TAG, "takePicture, onCaptureCompleted: ");}
};
mCameraCaptureSession.stopRepeating();
mCameraCaptureSession.abortCaptures();
mCameraCaptureSession.capture(captureRequestBuild.build(),captureCallback, mBackHandler);

1
2
3
4
5
6
7

CaptureRequest.Builder recordCaptureBuild = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
recordCaptureBuild.addTarget(mMediaRecorder.getSurface());
recordCaptureBuild.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
mCameraCaptureSession.setRepeatingRequest(recordCaptureBuild.build(), null, null);

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

// CameraCaptureSession.java
public static abstract class CaptureCallback {public static final int NO_FRAMES_CAPTURED = -1;// 设备开始拍照时public void onCaptureStarted(@NonNull CameraCaptureSession session,@NonNull CaptureRequest request, long timestamp, long frameNumber) {// default empty implementation}// 返回部分数据public void onCapturePartial(CameraCaptureSession session,CaptureRequest request, CaptureResult result) {// default empty implementation}// 返回部分数据时，表示正在捕获数据过程中public void onCaptureProgressed(@NonNull CameraCaptureSession session,@NonNull CaptureRequest request, @NonNull CaptureResult partialResult) {// default empty implementation}// 数据捕获已经完成，回调最终总的结果集public void onCaptureCompleted(@NonNull CameraCaptureSession session,@NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {// default empty implementation}// 捕获失败public void onCaptureFailed(@NonNull CameraCaptureSession session,@NonNull CaptureRequest request, @NonNull CaptureFailure failure) {// default empty implementation}// 所有捕获结果已经发送完毕public void onCaptureSequenceCompleted(@NonNull CameraCaptureSession session,int sequenceId, long frameNumber) {// default empty implementation}// 请求捕获被中止public void onCaptureSequenceAborted(@NonNull CameraCaptureSession session,int sequenceId) {// default empty implementation}// 捕获的 buffer 不能成功显示public void onCaptureBufferLost(@NonNull CameraCaptureSession session,@NonNull CaptureRequest request, @NonNull Surface target, long frameNumber) {// default empty implementation}
}

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

// CameraDeviceClient.cpp
status_t CameraDeviceClient::initialize(sp<CameraProviderManager> manager) {return initializeImpl(manager);
}template<typename TProviderPtr>
status_t CameraDeviceClient::initializeImpl(TProviderPtr providerPtr) {...res = Camera2ClientBase::initialize(providerPtr);if (res != OK) {return res;}String8 threadName;mFrameProcessor = new FrameProcessorBase(mDevice);threadName = String8::format("CDU-%s-FrameProc", mCameraIdStr.string());mFrameProcessor->run(threadName.string());mFrameProcessor->registerListener(FRAME_PROCESSOR_LISTENER_MIN_ID,FRAME_PROCESSOR_LISTENER_MAX_ID,/*listener*/this,/*sendPartials*/true);return OK;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// Camera2ClientBase.cpp
template <typename TClientBase>
status_t Camera2ClientBase<TClientBase>::initialize(sp<CameraProviderManager> manager) {return initializeImpl(manager);
}template <typename TClientBase>
template <typename TProviderPtr>
status_t Camera2ClientBase<TClientBase>::initializeImpl(TProviderPtr providerPtr) {...res = mDevice->initialize(providerPtr);...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// Camera3Device.cpp
status_t Camera3Device::initialize(sp<CameraProviderManager> manager) {...return initializeCommonLocked();
}status_t Camera3Device::initializeCommonLocked() {.../** Start up request queue thread */mRequestThread = new RequestThread(this, mStatusTracker, mInterface);res = mRequestThread->run(String8::format("C3Dev-%s-ReqQueue", mId.string()).string());...return OK;
}

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

// Threads.cpp
int Thread::_threadLoop(void* user)
{Thread* const self = static_cast<Thread*>(user);...bool first = true;do {bool result;if (first) {first = false;self->mStatus = self->readyToRun();result = (self->mStatus == NO_ERROR);if (result && !self->exitPending()) {result = self->threadLoop();}} else {result = self->threadLoop();}...if (result == false || self->mExitPending) {...break;}...} while(strong != 0);return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// Camera3Device.h
class RequestThread : public Thread {...protected:...virtual bool threadLoop();private:...// Used to prepare a batch of requests.struct NextRequest {sp<CaptureRequest>              captureRequest;camera3_capture_request_t       halRequest;Vector<camera3_stream_buffer_t> outputBuffers;bool                            submitted;};Vector<NextRequest> mNextRequests;...Condition          mRequestSignal;RequestList        mRequestQueue;RequestList        mRepeatingRequests;...
}

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

// Camera3Device.cpp
bool Camera3Device::RequestThread::threadLoop() {...status_t res;// Handle paused state.if (waitIfPaused()) {return true;}// Wait for the next batch of requests.waitForNextRequestBatch();if (mNextRequests.size() == 0) {return true;}...// Prepare a batch of HAL requests and output buffers.res = prepareHalRequests();...
}void Camera3Device::RequestThread::waitForNextRequestBatch() {...NextRequest nextRequest;nextRequest.captureRequest = waitForNextRequestLocked();if (nextRequest.captureRequest == nullptr) {return;}...
}sp<Camera3Device::CaptureRequest>Camera3Device::RequestThread::waitForNextRequestLocked() {status_t res;sp<CaptureRequest> nextRequest;while (mRequestQueue.empty()) {if (!mRepeatingRequests.empty()) {const RequestList &requests = mRepeatingRequests;RequestList::const_iterator firstRequest =requests.begin();nextRequest = *firstRequest;mRequestQueue.insert(mRequestQueue.end(),++firstRequest,requests.end());mRepeatingLastFrameNumber = mFrameNumber+requests.size()-1;break;}// 条件变量 mRequestSignal 阻塞等待 kRequestTimeout res = mRequestSignal.waitRelative(mRequestLock, kRequestTimeout);...}
}

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

// FrameProcessorBase.h
class FrameProcessorBase: public Thread {public:...struct FilteredListener: virtual public RefBase {virtual void onResultAvailable(const CaptureResult &result) = 0;};protected:static const nsecs_t kWaitDuration = 10000000; // 10 mswp<CameraDeviceBase> mDevice;virtual bool threadLoop();...
}// FrameProcessorBase.cpp
bool FrameProcessorBase::threadLoop() {status_t res;sp<CameraDeviceBase> device;{device = mDevice.promote();if (device == 0) return false;}res = device->waitForNextFrame(kWaitDuration);if (res == OK) {processNewFrames(device);} else if (res != TIMED_OUT) {ALOGE(...);}return true;
}

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

// Camera3Device.h
class Camera3Device :public CameraDeviceBase,virtual public hardware::camera::device::V3_2::ICameraDeviceCallback,private camera3_callback_ops {...private:List<CaptureResult>   mResultQueue;Condition              mResultSignal;...
}// Camera3Device.cpp
status_t Camera3Device::waitForNextFrame(nsecs_t timeout) {...while (mResultQueue.empty()) {res = mResultSignal.waitRelative(mOutputLock, timeout);if (res == TIMED_OUT) {return res;} else if (res != OK) {ALOGW(...);return res;}}return OK;
}

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

// CameraCaptureSessionImpl.java
// 预览和录像
@Override
public int setRepeatingRequest(CaptureRequest request, CaptureCallback callback,Handler handler) throws CameraAccessException {...synchronized (mDeviceImpl.mInterfaceLock) {...return addPendingSequence(mDeviceImpl.setRepeatingRequest(request,createCaptureCallbackProxy(handler, callback), mDeviceHandler));}
}// 拍照
@Override
public int capture(CaptureRequest request, CaptureCallback callback,Handler handler) throws CameraAccessException {...synchronized (mDeviceImpl.mInterfaceLock) {...return addPendingSequence(mDeviceImpl.capture(request,createCaptureCallbackProxy(handler, callback), mDeviceHandler));}
}

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

// CameraDeviceImpl.java
// 预览和录像
public int setRepeatingRequest(CaptureRequest request, CaptureCallback callback,Handler handler) throws CameraAccessException {List<CaptureRequest> requestList = new ArrayList<CaptureRequest>();requestList.add(request);return submitCaptureRequest(requestList, callback, handler, /*streaming*/true);
}
// 拍照
public int capture(CaptureRequest request, CaptureCallback callback, Handler handler) throws CameraAccessException {List<CaptureRequest> requestList = new ArrayList<CaptureRequest>();requestList.add(request);return submitCaptureRequest(requestList, callback, handler, /*streaming*/false);
}private int submitCaptureRequest(List<CaptureRequest> requestList, CaptureCallback callback,Handler handler, boolean repeating) throws CameraAccessException {...synchronized(mInterfaceLock) {checkIfCameraClosedOrInError();if (repeating) {stopRepeating();}SubmitInfo requestInfo;CaptureRequest[] requestArray = requestList.toArray(new CaptureRequest[requestList.size()]);requestInfo = mRemoteDevice.submitRequestList(requestArray,repeating);...if (callback != null) {mCaptureCallbackMap.put(requestInfo.getRequestId(),new CaptureCallbackHolder(callback, requestList, handler, repeating, mNextSessionId - 1));} else {...}if (repeating) {if (mRepeatingRequestId != REQUEST_ID_NONE) {checkEarlyTriggerSequenceComplete(mRepeatingRequestId,requestInfo.getLastFrameNumber());}mRepeatingRequestId = requestInfo.getRequestId();} else {mRequestLastFrameNumbersList.add(new RequestLastFrameNumbersHolder(requestList,requestInfo));}...}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// CameraDeviceClient.cpp
binder::Status CameraDeviceClient::submitRequestList(const std::vector<hardware::camera2::CaptureRequest>& requests,bool streaming,/*out*/hardware::camera2::utils::SubmitInfo *submitInfo) {...if (streaming) {err = mDevice->setStreamingRequestList(metadataRequestList, surfaceMapList, &(submitInfo->mLastFrameNumber));...} else {err = mDevice->captureList(metadataRequestList, surfaceMapList,&(submitInfo->mLastFrameNumber));...}return res;
}

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

//Camera3Device.cpp
// 预览和录像
status_t Camera3Device::setStreamingRequestList(const List<const CameraMetadata> &requests,const std::list<const SurfaceMap> &surfaceMaps,int64_t *lastFrameNumber) {...return submitRequestsHelper(requests, surfaceMaps, /*repeating*/true, lastFrameNumber);
}
// 拍照
status_t Camera3Device::captureList(const List<const CameraMetadata> &requests,const std::list<const SurfaceMap> &surfaceMaps,int64_t *lastFrameNumber) {...return submitRequestsHelper(requests, surfaceMaps, /*repeating*/false, lastFrameNumber);
}status_t Camera3Device::submitRequestsHelper(const List<const CameraMetadata> &requests,const std::list<const SurfaceMap> &surfaceMaps,bool repeating, /*out*/ int64_t *lastFrameNumber) {...RequestList requestList;res = convertMetadataListToRequestListLocked(requests, surfaceMaps,repeating, /*out*/&requestList);...if (repeating) {res = mRequestThread->setRepeatingRequests(requestList,lastFrameNumber);} else {res = mRequestThread->queueRequestList(requestList,lastFrameNumber);}...return res;
}

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

// Camera3Device.cpp
// 预览和录像
status_t Camera3Device::RequestThread::setRepeatingRequests(const RequestList &requests,/*out*/int64_t *lastFrameNumber) {...if (lastFrameNumber != NULL) {*lastFrameNumber = mRepeatingLastFrameNumber;}mRepeatingRequests.clear();mRepeatingRequests.insert(mRepeatingRequests.begin(),requests.begin(), requests.end());unpauseForNewRequests();mRepeatingLastFrameNumber = ...ICameraDeviceUser::NO_IN_FLIGHT_REPEATING_FRAMES;return OK;
}
// 拍照
status_t Camera3Device::RequestThread::queueRequestList(List<sp<CaptureRequest> > &requests,/*out*/int64_t *lastFrameNumber) {...for (List<sp<CaptureRequest> >::iterator it = requests.begin();it != requests.end(); ++it) {mRequestQueue.push_back(*it);}if (lastFrameNumber != NULL) {*lastFrameNumber = mFrameNumber + mRequestQueue.size() - 1;ALOGV(...);}unpauseForNewRequests();return OK;
}void Camera3Device::RequestThread::unpauseForNewRequests() {...mRequestSignal.signal();...
}

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

// Camera3Device.cpp
bool Camera3Device::RequestThread::threadLoop() {...status_t res;...// Wait for the next batch of requests.// 阻塞等待waitForNextRequestBatch();if (mNextRequests.size() == 0) {return true;}...bool submitRequestSuccess = false;nsecs_t tRequestStart = systemTime(SYSTEM_TIME_MONOTONIC);if (mInterface->supportBatchRequest()) {submitRequestSuccess = sendRequestsBatch();} else {submitRequestSuccess = sendRequestsOneByOne();}...return submitRequestSuccess;
}bool Camera3Device::RequestThread::sendRequestsBatch() {status_t res;size_t batchSize = mNextRequests.size();std::vector<camera3_capture_request_t*> requests(batchSize);uint32_t numRequestProcessed = 0;for (size_t i = 0; i < batchSize; i++) {requests[i] = &mNextRequests.editItemAt(i).halRequest;}...res = mInterface->processBatchCaptureRequests(requests, &numRequestProcessed);...
}status_t Camera3Device::HalInterface::processBatchCaptureRequests(std::vector<camera3_capture_request_t*>& requests,/*out*/uint32_t* numRequestProcessed) {...hardware::hidl_vec<device::V3_2::CaptureRequest> captureRequests;size_t batchSize = requests.size();captureRequests.resize(batchSize);...auto err = mHidlSession->processCaptureRequest(captureRequests, cachesToRemove,[&status, &numRequestProcessed] (auto s, uint32_t n) {status = s;*numRequestProcessed = n;});...return CameraProviderManager::mapToStatusT(status);
}

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
80
81
82
83
84
85
86
87
88
89

// Camera3Device.cpp
hardware::Return<void> Camera3Device::processCaptureResult(const hardware::hidl_vec<hardware::camera::device::V3_2::CaptureResult>& results) {...for (const auto& result : results) {processOneCaptureResultLocked(result);}mProcessCaptureResultLock.unlock();return hardware::Void();
}void Camera3Device::processOneCaptureResultLocked(const hardware::camera::device::V3_2::CaptureResult& result) {camera3_capture_result r;...processCaptureResult(&r);
}void Camera3Device::processCaptureResult(const camera3_capture_result *result) {...if (result->partial_result != 0)request.resultExtras.partialResultCount = result->partial_result;// Check if this result carries only partial metadataif (mUsePartialResult && result->result != NULL) {...if (isPartialResult && request.hasCallback) {// Send partial capture resultsendPartialCaptureResult(result->result, request.resultExtras,frameNumber);}}...if (result->result != NULL && !isPartialResult) {if (shutterTimestamp == 0) {request.pendingMetadata = result->result;request.collectedPartialResult = collectedPartialResult;} else if (request.hasCallback) {CameraMetadata metadata;metadata = result->result;sendCaptureResult(metadata, request.resultExtras,collectedPartialResult, frameNumber,hasInputBufferInRequest);}}...
}void Camera3Device::sendPartialCaptureResult(const camera_metadata_t * partialResult,const CaptureResultExtras &resultExtras, uint32_t frameNumber) {...CaptureResult captureResult;captureResult.mResultExtras = resultExtras;captureResult.mMetadata = partialResult;insertResultLocked(&captureResult, frameNumber);
}void Camera3Device::sendCaptureResult(CameraMetadata &pendingMetadata,CaptureResultExtras &resultExtras,CameraMetadata &collectedPartialResult,uint32_t frameNumber,bool reprocess) {...CaptureResult captureResult;captureResult.mResultExtras = resultExtras;captureResult.mMetadata = pendingMetadata;...insertResultLocked(&captureResult, frameNumber);
}void Camera3Device::insertResultLocked(CaptureResult *result,uint32_t frameNumber) {...camera_metadata_t *meta = const_cast<camera_metadata_t *>(result->mMetadata.getAndLock());set_camera_metadata_vendor_id(meta, mVendorTagId);result->mMetadata.unlock(meta);...// Valid result, insert into queueList<CaptureResult>::iterator queuedResult =mResultQueue.insert(mResultQueue.end(), CaptureResult(*result));...mResultSignal.signal();
}

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

// FrameProcessorBase.cpp
void FrameProcessorBase::processNewFrames(const sp<CameraDeviceBase> &device) {status_t res;...while ( (res = device->getNextResult(&result)) == OK) {camera_metadata_entry_t entry;entry = result.mMetadata.find(ANDROID_REQUEST_FRAME_COUNT);...if (!processSingleFrame(result, device)) {break;}...}...return;
}bool FrameProcessorBase::processSingleFrame(CaptureResult &result,const sp<CameraDeviceBase> &device) {...return processListeners(result, device) == OK;
}status_t FrameProcessorBase::processListeners(const CaptureResult &result,const sp<CameraDeviceBase> &device) {...List<sp<FilteredListener> >::iterator item = listeners.begin();for (; item != listeners.end(); item++) {(*item)->onResultAvailable(result);}return OK;
}

1
2
3
4
5
6
7
8
9
10

// CameraDeviceClient.cpp
void CameraDeviceClient::onResultAvailable(const CaptureResult& result) {...sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = mRemoteCallback;if (remoteCb != NULL) {remoteCb->onResultReceived(result.mMetadata, result.mResultExtras);}
}

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
80
81
82
83
84
85
86
87
88

// CameraDeviceImpl.java
@Override
public void onResultReceived(CameraMetadataNative result,CaptureResultExtras resultExtras) throws RemoteException {int requestId = resultExtras.getRequestId();long frameNumber = resultExtras.getFrameNumber();...synchronized(mInterfaceLock) {...final CaptureCallbackHolder holder =CameraDeviceImpl.this.mCaptureCallbackMap.get(requestId);final CaptureRequest request = holder.getRequest(resultExtras.getSubsequenceId());boolean isPartialResult = (resultExtras.getPartialResultCount() < mTotalPartialCount);...if (isPartialResult) {final CaptureResult resultAsCapture =new CaptureResult(result, request, resultExtras);// Partial resultresultDispatch = new Runnable() {@Overridepublic void run() {if (!CameraDeviceImpl.this.isClosed()) {if (holder.hasBatchedOutputs()) {for (int i = 0; i < holder.getRequestCount(); i++) {CameraMetadataNative resultLocal =new CameraMetadataNative(resultCopy);CaptureResult resultInBatch = new CaptureResult(resultLocal, holder.getRequest(i), resultExtras);holder.getCallback().onCaptureProgressed(CameraDeviceImpl.this,holder.getRequest(i),resultInBatch);}} else {holder.getCallback().onCaptureProgressed(CameraDeviceImpl.this,request,resultAsCapture);}}}};finalResult = resultAsCapture;} else {List<CaptureResult> partialResults =mFrameNumberTracker.popPartialResults(frameNumber);...final TotalCaptureResult resultAsCapture = new TotalCaptureResult(result, request, resultExtras,partialResults, holder.getSessionId());// Final capture resultresultDispatch = new Runnable() {@Overridepublic void run() {if (!CameraDeviceImpl.this.isClosed()){if (holder.hasBatchedOutputs()) {for (int i = 0; i < holder.getRequestCount(); i++) {...TotalCaptureResult resultInBatch = new TotalCaptureResult(resultLocal, holder.getRequest(i), resultExtras,partialResults, holder.getSessionId());holder.getCallback().onCaptureCompleted(CameraDeviceImpl.this,holder.getRequest(i),resultInBatch);}} else {holder.getCallback().onCaptureCompleted(CameraDeviceImpl.this,request,resultAsCapture);}}}};finalResult = resultAsCapture;}...// Fire onCaptureSequenceCompletedif (!isPartialResult) {checkAndFireSequenceComplete();}}
}

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);
}

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

// CameraServiceProxy.java
public class CameraServiceProxy extends SystemServiceimplements Handler.Callback, IBinder.DeathRecipient {...private static final String CAMERA_SERVICE_BINDER_NAME = "media.camera";public static final String CAMERA_SERVICE_PROXY_BINDER_NAME = "media.camera.proxy";...// 构造方法中，初始化线程相关public CameraServiceProxy(Context context) {super(context);mContext = context;mHandlerThread = new ServiceThread(TAG, Process.THREAD_PRIORITY_DISPLAY, /*allowTo*/false);mHandlerThread.start();mHandler = new Handler(mHandlerThread.getLooper(), this);mNotifyNfc = SystemProperties.getInt(NFC_NOTIFICATION_PROP, 0)>0;if (DEBUG) Slog.v(...);}// onStart 主要是注册服务，并监听 User 相关广播@Overridepublic void onStart() {mUserManager = UserManager.get(mContext);...IntentFilter filter = new IntentFilter();filter.addAction(Intent.ACTION_USER_ADDED);filter.addAction(Intent.ACTION_USER_REMOVED);filter.addAction(Intent.ACTION_USER_INFO_CHANGED);filter.addAction(Intent.ACTION_MANAGED_PROFILE_ADDED);filter.addAction(Intent.ACTION_MANAGED_PROFILE_REMOVED);mContext.registerReceiver(mIntentReceiver, filter);// 注册 CameraServiceProxy 服务publishBinderService(CAMERA_SERVICE_PROXY_BINDER_NAME, mCameraServiceProxy);publishLocalService(CameraServiceProxy.class, this);CameraStatsJobService.schedule(mContext);}...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// CameraServiceProxy.java
private final ICameraServiceProxy.Stub mCameraServiceProxy = new ICameraServiceProxy.Stub() {@Overridepublic void pingForUserUpdate() {notifySwitchWithRetries(30);}@Overridepublic void notifyCameraState(String cameraId, int newCameraState,int facing, String clientName) {String state = cameraStateToString(newCameraState);String facingStr = cameraFacingToString(facing);if (DEBUG) Slog.v(...);updateActivityCount(cameraId, newCameraState,facing,clientName);}
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14

void CameraService::loadSound() {ATRACE_CALL();Mutex::Autolock lock(mSoundLock);LOG1("CameraService::loadSound ref=%d", mSoundRef);if (mSoundRef++) return;mSoundPlayer[SOUND_SHUTTER] = newMediaPlayer("/system/media/audio/ui/camera_click.ogg");mSoundPlayer[SOUND_RECORDING_START] = newMediaPlayer("/system/media/audio/ui/VideoRecord.ogg");mSoundPlayer[SOUND_RECORDING_STOP] = newMediaPlayer("/system/media/audio/ui/VideoStop.ogg");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

namespace android {...
class CameraMetadata: public Parcelable {
...
}namespace hardware {
namespace camera2 {
namespace impl {
using ::android::CameraMetadata;
typedef CameraMetadata CameraMetadataNative;
}
}
}