Android Camera setRepeatingRequest
前情回顾
前面我们我们看了一遍createCaptureSession的过程，知道它的作用是维护会话状态，为后续的捕获请求提供基础，那现在就开始看看setRepeatingRequest，也就是起预览的流程，这个流程是跟配流过程强相关的。
APP 层
既然提到app层，那我们肯定要看下上层如何使用，也就是调用API2的接口的，为了方便描述，还是将完整的打开相机，配流，以及起预览过程代码都写一下，我按顺序摆放了一下，可以直接按顺序看就行，流程一目了然：
// 重要变量需要注意 private CameraDevice mCameraDevice; private CameraCaptureSession mCaptureSession; private CaptureRequest.Builder mPreviewRequestBuilder; // 打开相机 private void openCamera() { if (mCameraId == null || mCameraManager == null) { return; } try { // 检查权限 if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) { return; } // 打开相机，传入相机ID、状态回调和后台处理器 mCameraManager.openCamera(mCameraId, mStateCallback, mBackgroundHandler); } catch (CameraAccessException e) { e.printStackTrace(); runOnUiThread(() -> Toast.makeText(this, \"打开相机失败\", Toast.LENGTH_SHORT).show()); } } // 相机设备状态回调，处理相机打开、关闭、错误等状态，在成功打开回调方法里开始创建捕获会话 private final CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() { @Override public void onOpened(@NonNull CameraDevice camera) { // 相机成功打开，保存相机设备实例并配置流 mCameraDevice = camera; createCameraCaptureSession(); } @Override public void onDisconnected(@NonNull CameraDevice camera) { camera.close(); mCameraDevice = null; } @Override public void onError(@NonNull CameraDevice camera, int error) { camera.close(); mCameraDevice = null; runOnUiThread(() -> Toast.makeText(Camera2PreviewActivity.this, \"相机打开失败: \" + error, Toast.LENGTH_SHORT).show()); } }; // 创建相机捕获会话（配流过程） private void createCameraCaptureSession() { if (mCameraDevice == null || !mTextureView.isAvailable()) { return; } try { // 获取TextureView的SurfaceTexture并创建Surface SurfaceTexture surfaceTexture = mTextureView.getSurfaceTexture(); surfaceTexture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight()); Surface previewSurface = new Surface(surfaceTexture); // 创建预览请求构建器 mPreviewRequestBuilder = mCameraDevice.createCaptureRequest( CameraDevice.TEMPLATE_PREVIEW); // 将Surface作为预览的目标（配流：指定数据输出到哪里） mPreviewRequestBuilder.addTarget(previewSurface); // 准备输出表面列表（当前只有预览一个流） List<Surface> outputSurfaces = new ArrayList(); outputSurfaces.add(previewSurface); // 创建相机捕获会话，配置输出流 mCameraDevice.createCaptureSession(outputSurfaces, mSessionCallback, mBackgroundHandler); } catch (CameraAccessException e) { e.printStackTrace(); } } // 捕获会话状态回调，处理会话创建结果 private final CameraCaptureSession.StateCallback mSessionCallback = new CameraCaptureSession.StateCallback() { @Override public void onConfigured(@NonNull CameraCaptureSession session) { // 会话配置成功，开始预览 mCaptureSession = session; startPreview(); } @Override public void onConfigureFailed(@NonNull CameraCaptureSession session) { runOnUiThread(() -> Toast.makeText(Camera2PreviewActivity.this, \"预览配置失败\", Toast.LENGTH_SHORT).show()); } }; // 启动预览，这也是这篇文章需要说明的对象 private void startPreview() { if (mCameraDevice == null || mCaptureSession == null || mPreviewRequestBuilder == null) { return; } try { // 配置自动对焦模式 mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE); // 配置自动曝光模式 mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH); // 发送重复捕获请求以持续预览 mCaptureSession.setRepeatingRequest(mPreviewRequestBuilder.build(), null, mBackgroundHandler); runOnUiThread(() -> Toast.makeText(Camera2PreviewActivity.this, \"预览已启动\", Toast.LENGTH_SHORT).show()); } catch (CameraAccessException e) { e.printStackTrace(); } }到这里应用层的代码实现已经走完了，接下来就是Framework层代码了
Framework
按惯例，我们需要了解一下什么时候回调的onConfigured
frameworks/base/core/java/android/hardware/camera2/impl/CameraDeviceImpl.java
private void createCaptureSessionInternal(InputConfiguration inputConfig, List<OutputConfiguration> outputConfigurations, CameraCaptureSession.StateCallback callback, Executor executor, int operatingMode, CaptureRequest sessionParams) throws CameraAccessException { //让我们回顾一下配流过程，先配流，配流成功返回状态 try { configureSuccess = configureStreamsChecked(inputConfig, outputConfigurations, operatingMode, sessionParams, createSessionStartTime); } catch (CameraAccessException e) { } // 官方注释引路，说明是在下面代码里面实现了onConfigured回调调用 // Fire onConfigured if configureOutputs succeeded, fire onConfigureFailed otherwise. // isConstrainedHighSpeed一般都是false，除非开启特殊慢录模式，这 //个我们不讨论，但CameraConstrainedHighSpeedCaptureSessionImpl //里面也是最终会调用到onConfigured，这里不再赘述，感兴趣的可以自行看下 if (isConstrainedHighSpeed) { newSession = new CameraConstrainedHighSpeedCaptureSessionImpl(mNextSessionId++, callback, executor, this, mDeviceExecutor, configureSuccess, mCharacteristics); } else { newSession = new CameraCaptureSessionImpl(mNextSessionId++, input, callback, executor, this, mDeviceExecutor, configureSuccess); } }可以看到下面是实例化了CameraCaptureSessionImpl，那这里面是怎么调用到onConfigured的呢，接着往下看它的构造函数：
frameworks/base/core/java/android/hardware/camera2/impl/CameraCaptureSessionImpl.java
CameraCaptureSessionImpl(int id, Surface input, CameraCaptureSession.StateCallback callback, Executor stateExecutor, android.hardware.camera2.impl.CameraDeviceImpl deviceImpl, Executor deviceStateExecutor, boolean configureSuccess) { //那传入的configureSuccess肯定是true啊，那顺理成章就会回调到onConfigured了 if (configureSuccess) { mStateCallback.onConfigured(this); if (DEBUG) Log.v(TAG, mIdString + \"Created session successfully\"); mConfigureSuccess = true; } else { mStateCallback.onConfigureFailed(this); mClosed = true; // do not fire any other callbacks, do not allow any other work Log.e(TAG, mIdString + \"Failed to create capture session; configuration failed\"); mConfigureSuccess = false; } }OK，看到这里就知道何时调用到onConfigured，如何调用到onConfigured，并且知道回调给的参数其实就是CameraCaptureSessionImpl，也就是app层提到的mCaptureSession是CameraCaptureSessionImpl实例， 这里我们可以开始我们的主线任务了，在回调到onConfigured之后，就会调用到关键函数setRepeatingRequest，对应app层代码里面的
// 发送重复捕获请求以持续预览 mCaptureSession.setRepeatingRequest(mPreviewRequestBuilder.build(), null, mBackgroundHandler);那就继续看下面的代码
frameworks/base/core/java/android/hardware/camera2/impl/CameraCaptureSessionImpl.java
@Override public int setRepeatingRequest(CaptureRequest request, CaptureCallback callback, Handler handler) throws CameraAccessException { checkRepeatingRequest(request); synchronized (mDeviceImpl.mInterfaceLock) { checkNotClosed(); handler = checkHandler(handler, callback); if (DEBUG) { Log.v(TAG, mIdString + \"setRepeatingRequest - request \" + request + \", callback \" + callback + \" handler\" + \" \" + handler); } return addPendingSequence(mDeviceImpl.setRepeatingRequest(request, createCaptureCallbackProxy(handler, callback), mDeviceExecutor)); } }需要注意的是他有一个请求，预览请求相关变量是CameraDevice.TEMPLATE_PREVIEW，前面app层也展现过，想了解可以回顾一下，那继续以主线跳转往下跟踪
/** * Notify the session that a pending capture sequence has just been queued. * * <p>During a shutdown/close, the session waits until all pending sessions are finished * before taking any further steps to shut down itself.</p> * * @see #finishPendingSequence */ private int addPendingSequence(int sequenceId) { mSequenceDrainer.taskStarted(sequenceId); return sequenceId; }到这里咋不按套路出牌了呢，看注释意思是一个待处理的捕获序列刚刚已入队，啥啊，这里我们先放一下，回头看看这具体干啥的，先回头看看上一步是不是漏了什么
return addPendingSequence(mDeviceImpl.setRepeatingRequest(request, createCaptureCallbackProxy(handler, callback), mDeviceExecutor));可以看到上一步里面其实传了个看起来像是起预览的操作，只不过是调用mDeviceImpl里面的setRepeatingRequest函数，那我们直接过去看看怎么个事儿
frameworks/base/core/java/android/hardware/camera2/impl/CameraDeviceImpl.java
public int setRepeatingRequest(CaptureRequest request, CaptureCallback callback, Executor executor) throws CameraAccessException { List<CaptureRequest> requestList = new ArrayList<CaptureRequest>(); requestList.add(request); return submitCaptureRequest(requestList, callback, executor, /*streaming*/true); }继续
private int submitCaptureRequest(List<CaptureRequest> requestList, CaptureCallback callback, Executor executor, boolean repeating) throws CameraAccessException { //这里会看请求是不是带了surface的，没带的会执行报错的，所以app层的addTarget()是必要步骤 // Make sure that there all requests have at least 1 surface; all surfaces are non-null; for (CaptureRequest request : requestList) { if (request.getTargets().isEmpty()) { throw new IllegalArgumentException( \"Each request must have at least one Surface target\"); } for (Surface surface : request.getTargets()) { if (surface == null) { throw new IllegalArgumentException(\"Null Surface targets are not allowed\"); } } } //传入的是true，需要先停止前面的repeating if (repeating) { stopRepeating(); } //关键函数，后面继续从这里跟踪起预览过程，这里就开始进入native服务了，不再多解释， //不了解的话可以重新跟一下前面的文章，我想早点“下班”了，休假咋都在写文章啊我 requestInfo = mRemoteDevice.submitRequestList(requestArray, repeating); return requestInfo.getRequestId(); }然后就通过binder调用到这里了
frameworks/av/services/camera/libcameraservice/api2/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;}直接上高速，加速中
frameworks/av/services/camera/libcameraservice/device3/Camera3Device.cpp
status_t Camera3Device::setStreamingRequestList( const List<const PhysicalCameraSettingsList> &requestsList, const std::list<const SurfaceMap> &surfaceMaps, int64_t *lastFrameNumber) { ATRACE_CALL(); return submitRequestsHelper(requestsList, surfaceMaps, /*repeating*/true, lastFrameNumber);}status_t Camera3Device::submitRequestsHelper( const List<const PhysicalCameraSettingsList> &requests, const std::list<const SurfaceMap> &surfaceMaps, bool repeating, /*out*/ int64_t *lastFrameNumber) { if (repeating) { //预览流程 res = mRequestThread->setRepeatingRequests(requestList, lastFrameNumber); } else { //拍照流程 res = mRequestThread->queueRequestList(requestList, lastFrameNumber); } return res; }继续预览流程
status_t Camera3Device::RequestThread::setRepeatingRequests( const RequestList &requests, /*out*/ int64_t *lastFrameNumber) { ATRACE_CALL(); Mutex::Autolock l(mRequestLock); if (lastFrameNumber != NULL) { *lastFrameNumber = mRepeatingLastFrameNumber; } mRepeatingRequests.clear(); mFirstRepeating = true; // mRepeatingRequests: 类型为RequestList，预览请求队列，这次请求添加之后，等待后续执行消费 mRepeatingRequests.insert(mRepeatingRequests.begin(), requests.begin(), requests.end()); unpauseForNewRequests(); mRepeatingLastFrameNumber = hardware::camera2::ICameraDeviceUser::NO_IN_FLIGHT_REPEATING_FRAMES; return OK;}所以相当于到这里先告一段落了，现在要去跟踪怎么去消费添加到队列的预览请求
frameworks/av/services/camera/libcameraservice/device3/Camera3Device.cpp
bool Camera3Device::RequestThread::threadLoop() { //省略n行代码，直接找重点 submitRequestSuccess = sendRequestsBatch(); return submitRequestSuccess; }然后看sendRequestsBatch对应实现
bool Camera3Device::RequestThread::sendRequestsBatch() { res = mInterface->processBatchCaptureRequests(requests, &numRequestProcessed); return true;}status_t Camera3Device::HalInterface::processBatchCaptureRequests( std::vector<camera_capture_request_t*>& requests,/*out*/uint32_t* numRequestProcessed) { err = mHidlSession->processCaptureRequest(captureRequests, cachesToRemove, resultCallback);}HAL 层
熟悉吧，这是跳转到最终函数
hardware/qcom/camera/msm8998/QCamera2/HAL3/QCamera3HWI.cpp
int QCamera3HardwareInterface::processCaptureRequest( camera3_capture_request_t *request, List<InternalRequest> &internallyRequestedStreams){ if (mRawDumpChannel) { rc = mRawDumpChannel->initialize(IS_TYPE_NONE); if (rc != NO_ERROR) { LOGE(\"Error: Raw Dump Channel init failed\"); pthread_mutex_unlock(&mMutex); goto error_exit; } } if (mHdrPlusRawSrcChannel) { rc = mHdrPlusRawSrcChannel->initialize(IS_TYPE_NONE); if (rc != NO_ERROR) { LOGE(\"Error: HDR+ RAW Source Channel init failed\"); pthread_mutex_unlock(&mMutex); goto error_exit; } } if (mSupportChannel) { rc = mSupportChannel->initialize(IS_TYPE_NONE); if (rc < 0) { LOGE(\"Support channel initialization failed\"); pthread_mutex_unlock(&mMutex); goto error_exit; } } if (mAnalysisChannel) { rc = mAnalysisChannel->initialize(IS_TYPE_NONE); if (rc < 0) { LOGE(\"Analysis channel initialization failed\"); pthread_mutex_unlock(&mMutex); goto error_exit; } } if (mDummyBatchChannel) { rc = mDummyBatchChannel->setBatchSize(mBatchSize); if (rc < 0) { LOGE(\"mDummyBatchChannel setBatchSize failed\"); pthread_mutex_unlock(&mMutex); goto error_exit; } rc = mDummyBatchChannel->initialize(IS_TYPE_NONE); if (rc < 0) { LOGE(\"mDummyBatchChannel initialization failed\"); pthread_mutex_unlock(&mMutex); goto error_exit; } } if (mState == CONFIGURED && mChannelHandle) { //Then start them. LOGH(\"Start META Channel\"); rc = mMetadataChannel->start(); if (rc < 0) { LOGE(\"META channel start failed\"); pthread_mutex_unlock(&mMutex); return rc; } if (mAnalysisChannel) { rc = mAnalysisChannel->start(); if (rc < 0) { LOGE(\"Analysis channel start failed\"); mMetadataChannel->stop(); pthread_mutex_unlock(&mMutex); return rc; } } if (mSupportChannel) { rc = mSupportChannel->start(); if (rc < 0) { LOGE(\"Support channel start failed\"); mMetadataChannel->stop(); /* Although support and analysis are mutually exclusive today adding it in anycase for future proofing */ if (mAnalysisChannel) { mAnalysisChannel->stop(); } pthread_mutex_unlock(&mMutex); return rc; } for (List<stream_info_t *>::iterator it = mStreamInfo.begin();it != mStreamInfo.end(); it++) { QCamera3Channel *channel = (QCamera3Channel *)(*it)->stream->priv; LOGH(\"Start Processing Channel mask=%d\", channel->getStreamTypeMask()); rc = channel->start(); //最终在这里开启预览通道 if (rc < 0) { LOGE(\"channel start failed\"); pthread_mutex_unlock(&mMutex); return rc; } } } }说明一下上面开启的几个辅助通道：
分析通道（Analysis Channel，即代码中的 mAnalysisChannel）：用于将相机数据传递给上层进行算法分析（如人脸检测、条码识别等），不直接参与屏幕显示。
元数据通道（Metadata Channel，即 mMetadataChannel）：专门处理相机的元数据（如曝光时间、ISO、对焦距离等），用于控制和反馈相机参数。
支持通道（Support Channel，mSupportChannel）：辅助功能通道，可能用于特定硬件的扩展功能（如多摄像头协同、特殊模式处理等）。
通道的启动思路：先启动控制 / 辅助通道：确保元数据处理、算法分析等基础能力就绪。
再启动数据流通道，在辅助通道就绪后，启动实际的图像数据传输（如预览、拍照），保证数据处理链路完整。
QCamera3RegularChannel,QCamera3PicChannel这些通道存储在 stream->priv 中，每个通道对应一个具体的相机流（如预览流、拍照流），负责处理实际的图像数据传输（如预览画面、照片数据）
收工！
总结
终于算是告一段落了，后面有时间再优化一下，目前先这样，此文仅仅是了解起预览的过程，再后面就是拍照和录制视频流程了，看了前面的几章，我们基本了解相机子系统了。
