1 /*
2 * Copyright (C) 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 //#define LOG_NDEBUG 0
18 #define LOG_TAG "ACameraDeviceVendor"
19
20 #include "ACameraCaptureSession.h"
21 #include "ACameraMetadata.h"
22 #include "ACaptureRequest.h"
23 #include "ndk_vendor/impl/ACameraDevice.h"
24 #include "utils.h"
25 #include <CameraMetadata.h>
26 #include <aidl/android/frameworks/cameraservice/device/CameraMetadata.h>
27 #include <aidl/android/frameworks/cameraservice/device/OutputConfiguration.h>
28 #include <aidl/android/frameworks/cameraservice/device/SessionConfiguration.h>
29 #include <aidlcommonsupport/NativeHandle.h>
30 #include <inttypes.h>
31 #include <map>
32 #include <utility>
33 #include <vector>
34
35 #define CHECK_TRANSACTION_AND_RET(ret, callName) \
36 if (!remoteRet.isOk()) { \
37 if (remoteRet.getExceptionCode() != EX_SERVICE_SPECIFIC) { \
38 ALOGE("%s: Transaction error during %s call %d", __FUNCTION__, callName, \
39 ret.getExceptionCode()); \
40 return ACAMERA_ERROR_UNKNOWN; \
41 } else { \
42 Status errStatus = static_cast<Status>(remoteRet.getServiceSpecificError()); \
43 std::string errorMsg = \
44 aidl::android::frameworks::cameraservice::common::toString(errStatus); \
45 ALOGE("%s: %s call failed: %s", __FUNCTION__, callName, errorMsg.c_str()); \
46 return utils::convertFromAidl(errStatus); \
47 } \
48 }
49
50 using namespace android;
51
~ACameraDevice()52 ACameraDevice::~ACameraDevice() {
53 mDevice->stopLooperAndDisconnect();
54 }
55
56 namespace android {
57 namespace acam {
58
59 using AidlCameraMetadata = ::aidl::android::frameworks::cameraservice::device::CameraMetadata;
60 using ::aidl::android::frameworks::cameraservice::device::OutputConfiguration;
61 using ::aidl::android::frameworks::cameraservice::device::SessionConfiguration;
62 using ::ndk::ScopedAStatus;
63
64 // Static member definitions
65 const char* CameraDevice::kContextKey = "Context";
66 const char* CameraDevice::kDeviceKey = "Device";
67 const char* CameraDevice::kErrorCodeKey = "ErrorCode";
68 const char* CameraDevice::kCallbackFpKey = "Callback";
69 const char* CameraDevice::kSessionSpKey = "SessionSp";
70 const char* CameraDevice::kCaptureRequestKey = "CaptureRequest";
71 const char* CameraDevice::kTimeStampKey = "TimeStamp";
72 const char* CameraDevice::kCaptureResultKey = "CaptureResult";
73 const char* CameraDevice::kPhysicalCaptureResultKey = "PhysicalCaptureResult";
74 const char* CameraDevice::kCaptureFailureKey = "CaptureFailure";
75 const char* CameraDevice::kSequenceIdKey = "SequenceId";
76 const char* CameraDevice::kFrameNumberKey = "FrameNumber";
77 const char* CameraDevice::kAnwKey = "Anw";
78 const char* CameraDevice::kFailingPhysicalCameraId= "FailingPhysicalCameraId";
79
80 /**
81 * CameraDevice Implementation
82 */
CameraDevice(const char * id,ACameraDevice_StateCallbacks * cb,sp<ACameraMetadata> chars,ACameraDevice * wrapper)83 CameraDevice::CameraDevice(
84 const char* id,
85 ACameraDevice_StateCallbacks* cb,
86 sp<ACameraMetadata> chars,
87 ACameraDevice* wrapper) :
88 mCameraId(id),
89 mAppCallbacks(*cb),
90 mChars(std::move(chars)),
91 mWrapper(wrapper),
92 mInError(false),
93 mError(ACAMERA_OK),
94 mIdle(true),
95 mCurrentSession(nullptr) {
96 mClosing = false;
97 // Setup looper thread to perfrom device callbacks to app
98 mCbLooper = new ALooper;
99 mCbLooper->setName("C2N-dev-looper");
100 status_t err = mCbLooper->start(
101 /*runOnCallingThread*/false,
102 /*canCallJava*/ true,
103 PRIORITY_DEFAULT);
104 if (err != OK) {
105 ALOGE("%s: Unable to start camera device callback looper: %s (%d)",
106 __FUNCTION__, strerror(-err), err);
107 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE);
108 }
109 mHandler = new CallbackHandler(id);
110 mCbLooper->registerHandler(mHandler);
111
112 const CameraMetadata& metadata = mChars->getInternalData();
113 camera_metadata_ro_entry entry = metadata.find(ANDROID_REQUEST_PARTIAL_RESULT_COUNT);
114 if (entry.count != 1) {
115 ALOGW("%s: bad count %zu for partial result count", __FUNCTION__, entry.count);
116 mPartialResultCount = 1;
117 } else {
118 mPartialResultCount = entry.data.i32[0];
119 }
120
121 entry = metadata.find(ANDROID_LENS_INFO_SHADING_MAP_SIZE);
122 if (entry.count != 2) {
123 ALOGW("%s: bad count %zu for shading map size", __FUNCTION__, entry.count);
124 mShadingMapSize[0] = 0;
125 mShadingMapSize[1] = 0;
126 } else {
127 mShadingMapSize[0] = entry.data.i32[0];
128 mShadingMapSize[1] = entry.data.i32[1];
129 }
130 }
131
~CameraDevice()132 CameraDevice::~CameraDevice() { }
133
init()134 void CameraDevice::init() {
135 mServiceCallback = ndk::SharedRefBase::make<ServiceCallback>(weak_from_this());
136 }
137
postSessionMsgAndCleanup(sp<AMessage> & msg)138 void CameraDevice::postSessionMsgAndCleanup(sp<AMessage>& msg) {
139 msg->post();
140 msg.clear();
141 sp<AMessage> cleanupMsg = new AMessage(kWhatCleanUpSessions, mHandler);
142 cleanupMsg->post();
143 }
144
145 // TODO: cached created request?
createCaptureRequest(ACameraDevice_request_template templateId,const ACameraIdList * physicalCameraIdList,ACaptureRequest ** request) const146 camera_status_t CameraDevice::createCaptureRequest(
147 ACameraDevice_request_template templateId,
148 const ACameraIdList* physicalCameraIdList,
149 ACaptureRequest** request) const {
150 Mutex::Autolock _l(mDeviceLock);
151 camera_status_t ret = checkCameraClosedOrErrorLocked();
152 if (ret != ACAMERA_OK) {
153 return ret;
154 }
155 if (mRemote == nullptr) {
156 return ACAMERA_ERROR_CAMERA_DISCONNECTED;
157 }
158
159 AidlCameraMetadata aidlMetadata;
160 ScopedAStatus remoteRet = mRemote->createDefaultRequest(
161 utils::convertToAidl(templateId), &aidlMetadata);
162 CHECK_TRANSACTION_AND_RET(remoteRet, "createDefaultRequest()")
163
164 camera_metadata_t* rawRequest;
165 utils::cloneFromAidl(aidlMetadata, &rawRequest);
166 ACaptureRequest* outReq = new ACaptureRequest();
167 outReq->settings = new ACameraMetadata(rawRequest, ACameraMetadata::ACM_REQUEST);
168 if (physicalCameraIdList != nullptr) {
169 for (auto i = 0; i < physicalCameraIdList->numCameras; i++) {
170 outReq->physicalSettings.emplace(physicalCameraIdList->cameraIds[i],
171 new ACameraMetadata(*(outReq->settings)));
172 }
173 }
174 outReq->targets = new ACameraOutputTargets();
175 *request = outReq;
176 return ACAMERA_OK;
177 }
178
createCaptureSession(const ACaptureSessionOutputContainer * outputs,const ACaptureRequest * sessionParameters,const ACameraCaptureSession_stateCallbacks * callbacks,ACameraCaptureSession ** session)179 camera_status_t CameraDevice::createCaptureSession(
180 const ACaptureSessionOutputContainer* outputs,
181 const ACaptureRequest* sessionParameters,
182 const ACameraCaptureSession_stateCallbacks* callbacks,
183 /*out*/ACameraCaptureSession** session) {
184 nsecs_t startTimeNs = systemTime();
185 sp<ACameraCaptureSession> currentSession = mCurrentSession.promote();
186 Mutex::Autolock _l(mDeviceLock);
187 camera_status_t ret = checkCameraClosedOrErrorLocked();
188 if (ret != ACAMERA_OK) {
189 return ret;
190 }
191
192 if (currentSession != nullptr) {
193 currentSession->closeByDevice();
194 stopRepeatingLocked();
195 }
196
197 // Create new session
198 ret = configureStreamsLocked(outputs, sessionParameters, startTimeNs);
199 if (ret != ACAMERA_OK) {
200 ALOGE("Fail to create new session. cannot configure streams");
201 return ret;
202 }
203
204 ACameraCaptureSession* newSession = new ACameraCaptureSession(
205 mNextSessionId++, outputs, callbacks, weak_from_this());
206
207 // set new session as current session
208 newSession->incStrong((void *) ACameraDevice_createCaptureSession);
209 mCurrentSession = newSession;
210 mFlushing = false;
211 *session = newSession;
212 return ACAMERA_OK;
213 }
214
isSessionConfigurationSupported(const ACaptureSessionOutputContainer * sessionOutputContainer) const215 camera_status_t CameraDevice::isSessionConfigurationSupported(
216 const ACaptureSessionOutputContainer* sessionOutputContainer) const {
217 Mutex::Autolock _l(mDeviceLock);
218 camera_status_t ret = checkCameraClosedOrErrorLocked();
219 if (ret != ACAMERA_OK) {
220 return ret;
221 }
222
223 SessionConfiguration sessionConfig;
224 sessionConfig.inputWidth = 0;
225 sessionConfig.inputHeight = 0;
226 sessionConfig.inputFormat = -1;
227 sessionConfig.operationMode = StreamConfigurationMode::NORMAL_MODE;
228 sessionConfig.outputStreams.resize(sessionOutputContainer->mOutputs.size());
229 size_t index = 0;
230 for (const auto& output : sessionOutputContainer->mOutputs) {
231 OutputConfiguration& outputStream = sessionConfig.outputStreams[index];
232 outputStream.rotation = utils::convertToAidl(output.mRotation);
233 outputStream.windowGroupId = -1;
234 outputStream.windowHandles.resize(output.mSharedWindows.size() + 1);
235 outputStream.windowHandles[0] = std::move(dupToAidl(output.mWindow));
236 outputStream.physicalCameraId = output.mPhysicalCameraId;
237 index++;
238 }
239
240 bool configSupported = false;
241 ScopedAStatus remoteRet = mRemote->isSessionConfigurationSupported(
242 sessionConfig, &configSupported);
243 CHECK_TRANSACTION_AND_RET(remoteRet, "isSessionConfigurationSupported()")
244 return configSupported ? ACAMERA_OK : ACAMERA_ERROR_STREAM_CONFIGURE_FAIL;
245 }
246
addMetadataToPhysicalCameraSettings(const CameraMetadata * metadata,const std::string & cameraId,PhysicalCameraSettings * physicalCameraSettings)247 static void addMetadataToPhysicalCameraSettings(const CameraMetadata *metadata,
248 const std::string &cameraId, PhysicalCameraSettings *physicalCameraSettings) {
249 const camera_metadata_t* cameraMetadata = metadata->getAndLock();
250 AidlCameraMetadata aidlCameraMetadata;
251 utils::convertToAidl(cameraMetadata, &aidlCameraMetadata);
252 metadata->unlock(cameraMetadata);
253 physicalCameraSettings->settings.set<CaptureMetadataInfo::metadata>(
254 std::move(aidlCameraMetadata));
255 physicalCameraSettings->id = cameraId;
256 }
257
addRequestSettingsMetadata(ACaptureRequest * aCaptureRequest,sp<CaptureRequest> & req)258 void CameraDevice::addRequestSettingsMetadata(ACaptureRequest *aCaptureRequest,
259 sp<CaptureRequest> &req) {
260 req->mPhysicalCameraSettings.resize(1 + aCaptureRequest->physicalSettings.size());
261 addMetadataToPhysicalCameraSettings(
262 &(aCaptureRequest->settings->getInternalData()),
263 getId(),&(req->mPhysicalCameraSettings[0]));
264 size_t i = 1;
265 for (auto &physicalSetting : aCaptureRequest->physicalSettings) {
266 addMetadataToPhysicalCameraSettings(&(physicalSetting.second->getInternalData()),
267 physicalSetting.first, &(req->mPhysicalCameraSettings[i]));
268 i++;
269 }
270 }
271
updateOutputConfigurationLocked(ACaptureSessionOutput * output)272 camera_status_t CameraDevice::updateOutputConfigurationLocked(ACaptureSessionOutput *output) {
273 camera_status_t ret = checkCameraClosedOrErrorLocked();
274 if (ret != ACAMERA_OK) {
275 return ret;
276 }
277
278 if (output == nullptr) {
279 return ACAMERA_ERROR_INVALID_PARAMETER;
280 }
281
282 if (!output->mIsShared) {
283 ALOGE("Error output configuration is not shared");
284 return ACAMERA_ERROR_INVALID_OPERATION;
285 }
286
287 int32_t streamId = -1;
288 for (auto& kvPair : mConfiguredOutputs) {
289 if (kvPair.second.first == output->mWindow) {
290 streamId = kvPair.first;
291 break;
292 }
293 }
294 if (streamId < 0) {
295 ALOGE("Error: Invalid output configuration");
296 return ACAMERA_ERROR_INVALID_PARAMETER;
297 }
298
299 OutputConfiguration outConfig;
300 outConfig.rotation = utils::convertToAidl(output->mRotation);
301 outConfig.windowHandles.resize(output->mSharedWindows.size() + 1);
302 outConfig.windowHandles[0] = std::move(dupToAidl(output->mWindow));
303 outConfig.physicalCameraId = output->mPhysicalCameraId;
304 int i = 1;
305 for (auto& anw : output->mSharedWindows) {
306 outConfig.windowHandles[i++] = std::move(dupToAidl(anw));
307 }
308
309 auto remoteRet = mRemote->updateOutputConfiguration(streamId,
310 outConfig);
311
312 if (!remoteRet.isOk()) {
313 if (remoteRet.getExceptionCode() == EX_SERVICE_SPECIFIC) {
314 Status st = static_cast<Status>(remoteRet.getServiceSpecificError());
315 switch (st) {
316 case Status::NO_ERROR:
317 break;
318 case Status::INVALID_OPERATION:
319 ALOGE("Camera device %s invalid operation", getId());
320 return ACAMERA_ERROR_INVALID_OPERATION;
321 case Status::ALREADY_EXISTS:
322 ALOGE("Camera device %s output surface already exists", getId());
323 return ACAMERA_ERROR_INVALID_PARAMETER;
324 case Status::ILLEGAL_ARGUMENT:
325 ALOGE("Camera device %s invalid input argument", getId());
326 return ACAMERA_ERROR_INVALID_PARAMETER;
327 default:
328 ALOGE("Camera device %s failed to add shared output", getId());
329 return ACAMERA_ERROR_UNKNOWN;
330 }
331 } else {
332 ALOGE("%s: Transaction error in updating OutputConfiguration: %d", __FUNCTION__,
333 remoteRet.getExceptionCode());
334 return ACAMERA_ERROR_UNKNOWN;
335 }
336 }
337
338 mConfiguredOutputs[streamId] = std::make_pair(output->mWindow,
339 std::move(outConfig));
340 return ACAMERA_OK;
341 }
342
prepareLocked(ACameraWindowType * window)343 camera_status_t CameraDevice::prepareLocked(ACameraWindowType *window) {
344 camera_status_t ret = checkCameraClosedOrErrorLocked();
345 if (ret != ACAMERA_OK) {
346 return ret;
347 }
348
349 if (window == nullptr) {
350 return ACAMERA_ERROR_INVALID_PARAMETER;
351 }
352
353 int32_t streamId = -1;
354 for (auto& kvPair : mConfiguredOutputs) {
355 if (window == kvPair.second.first) {
356 streamId = kvPair.first;
357 break;
358 }
359 }
360 if (streamId < 0) {
361 ALOGE("Error: Invalid output configuration");
362 return ACAMERA_ERROR_INVALID_PARAMETER;
363 }
364
365 auto remoteRet = mRemote->prepare(streamId);
366 CHECK_TRANSACTION_AND_RET(remoteRet, "prepare()")
367 return ACAMERA_OK;
368 }
369
allocateCaptureRequestLocked(const ACaptureRequest * request,sp<CaptureRequest> & outReq)370 camera_status_t CameraDevice::allocateCaptureRequestLocked(
371 const ACaptureRequest* request, /*out*/sp<CaptureRequest> &outReq) {
372 sp<CaptureRequest> req(new CaptureRequest());
373 req->mCaptureRequest.physicalCameraSettings.resize(1 + request->physicalSettings.size());
374
375 size_t index = 0;
376 allocateOneCaptureRequestMetadata(
377 req->mCaptureRequest.physicalCameraSettings[index++],
378 mCameraId, request->settings);
379
380 for (auto& physicalEntry : request->physicalSettings) {
381 allocateOneCaptureRequestMetadata(
382 req->mCaptureRequest.physicalCameraSettings[index++],
383 physicalEntry.first, physicalEntry.second);
384 }
385
386 std::vector<int32_t> requestStreamIdxList;
387 std::vector<int32_t> requestSurfaceIdxList;
388
389 for (auto& outputTarget : request->targets->mOutputs) {
390 native_handle_ptr_wrapper anw = outputTarget.mWindow;
391 bool found = false;
392 req->mSurfaceList.push_back(anw);
393 // lookup stream/surface ID
394 for (const auto& kvPair : mConfiguredOutputs) {
395 int streamId = kvPair.first;
396 const OutputConfiguration& outConfig = kvPair.second.second;
397 const auto& windowHandles = outConfig.windowHandles;
398 for (int surfaceId = 0; surfaceId < (int) windowHandles.size(); surfaceId++) {
399 // If two window handles point to the same native window,
400 // they have the same surfaces.
401 if (utils::isWindowNativeHandleEqual(anw, windowHandles[surfaceId])) {
402 found = true;
403 requestStreamIdxList.push_back(streamId);
404 requestSurfaceIdxList.push_back(surfaceId);
405 break;
406 }
407 }
408 if (found) {
409 break;
410 }
411 }
412 if (!found) {
413 ALOGE("Unconfigured output target %p in capture request!", anw.mWindow);
414 return ACAMERA_ERROR_INVALID_PARAMETER;
415 }
416 }
417 req->mCaptureRequest.streamAndWindowIds.resize(requestStreamIdxList.size());
418 for (int i = 0; i < requestStreamIdxList.size(); i++) {
419 req->mCaptureRequest.streamAndWindowIds[i].streamId = requestStreamIdxList[i];
420 req->mCaptureRequest.streamAndWindowIds[i].windowId = requestSurfaceIdxList[i];
421 }
422 outReq = req;
423 return ACAMERA_OK;
424 }
425
allocateOneCaptureRequestMetadata(PhysicalCameraSettings & cameraSettings,const std::string & id,const sp<ACameraMetadata> & metadata)426 void CameraDevice::allocateOneCaptureRequestMetadata(
427 PhysicalCameraSettings& cameraSettings,
428 const std::string& id, const sp<ACameraMetadata>& metadata) {
429 cameraSettings.id = id;
430
431 if (metadata == nullptr) {
432 return;
433 }
434
435 const camera_metadata_t* cameraMetadata = metadata->getInternalData().getAndLock();
436 AidlCameraMetadata aidlCameraMetadata;
437 utils::convertToAidl(cameraMetadata, &aidlCameraMetadata);
438 metadata->getInternalData().unlock(cameraMetadata);
439
440 if (aidlCameraMetadata.metadata.data() != nullptr &&
441 mCaptureRequestMetadataQueue != nullptr &&
442 mCaptureRequestMetadataQueue->write(
443 reinterpret_cast<const int8_t*>(aidlCameraMetadata.metadata.data()),
444 aidlCameraMetadata.metadata.size())) {
445 cameraSettings.settings.set<CaptureMetadataInfo::fmqMetadataSize>(
446 aidlCameraMetadata.metadata.size());
447 } else {
448 ALOGE("Fmq write capture result failed, falling back to hwbinder");
449 cameraSettings.settings.set<CaptureMetadataInfo::metadata>(std::move(aidlCameraMetadata));
450 }
451 }
452
453
allocateACaptureRequest(sp<CaptureRequest> & req,const char * deviceId)454 ACaptureRequest* CameraDevice::allocateACaptureRequest(sp<CaptureRequest>& req,
455 const char* deviceId) {
456 ACaptureRequest* pRequest = new ACaptureRequest();
457 for (size_t i = 0; i < req->mPhysicalCameraSettings.size(); i++) {
458 const std::string& id = req->mPhysicalCameraSettings[i].id;
459 camera_metadata_t* clone;
460 AidlCameraMetadata& aidlCameraMetadata = req->mPhysicalCameraSettings[i].settings
461 .get<CaptureMetadataInfo::metadata>();
462 utils::cloneFromAidl(aidlCameraMetadata, &clone);
463
464 if (id == deviceId) {
465 pRequest->settings = new ACameraMetadata(clone, ACameraMetadata::ACM_REQUEST);
466 } else {
467 pRequest->physicalSettings[req->mPhysicalCameraSettings[i].id] =
468 new ACameraMetadata(clone, ACameraMetadata::ACM_REQUEST);
469 }
470 }
471 pRequest->targets = new ACameraOutputTargets();
472 for (size_t i = 0; i < req->mSurfaceList.size(); i++) {
473 native_handle_ptr_wrapper anw = req->mSurfaceList[i];
474 ACameraOutputTarget outputTarget(anw);
475 pRequest->targets->mOutputs.insert(std::move(outputTarget));
476 }
477 return pRequest;
478 }
479
freeACaptureRequest(ACaptureRequest * req)480 void CameraDevice::freeACaptureRequest(ACaptureRequest* req) {
481 if (req == nullptr) {
482 return;
483 }
484 req->settings.clear();
485 delete req->targets;
486 delete req;
487 }
488
489 void
notifySessionEndOfLifeLocked(ACameraCaptureSession * session)490 CameraDevice::notifySessionEndOfLifeLocked(ACameraCaptureSession* session) {
491 if (isClosed()) {
492 // Device is closing already. do nothing
493 return;
494 }
495
496 if (mCurrentSession != session) {
497 // Session has been replaced by other session or device is closed
498 return;
499 }
500 mCurrentSession = nullptr;
501
502 // Should not happen
503 if (!session->mIsClosed) {
504 ALOGE("Error: unclosed session %p reaches end of life!", session);
505 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE);
506 return;
507 }
508
509 // No new session, un-configure now
510 // Note: The un-configuration of session won't be accounted for session
511 // latency because a stream configuration with 0 streams won't ever become
512 // active.
513 nsecs_t startTimeNs = systemTime();
514 camera_status_t ret = configureStreamsLocked(nullptr, nullptr, startTimeNs);
515 if (ret != ACAMERA_OK) {
516 ALOGE("Unconfigure stream failed. Device might still be configured! ret %d", ret);
517 }
518 }
519
520 void
disconnectLocked(sp<ACameraCaptureSession> & session)521 CameraDevice::disconnectLocked(sp<ACameraCaptureSession>& session) {
522 if (mClosing.exchange(true)) {
523 // Already closing, just return
524 ALOGW("Camera device %s is already closing.", getId());
525 return;
526 }
527
528 if (mRemote != nullptr) {
529 ALOGD("%s: binder disconnect reached", __FUNCTION__);
530 auto ret = mRemote->disconnect();
531 if (!ret.isOk()) {
532 ALOGE("%s: Transaction error while disconnecting device %d", __FUNCTION__,
533 ret.getExceptionCode());
534 }
535 }
536 mRemote = nullptr;
537
538 if (session != nullptr) {
539 session->closeByDevice();
540 }
541 }
542
stopRepeatingLocked()543 camera_status_t CameraDevice::stopRepeatingLocked() {
544 camera_status_t ret = checkCameraClosedOrErrorLocked();
545 if (ret != ACAMERA_OK) {
546 ALOGE("Camera %s stop repeating failed! ret %d", getId(), ret);
547 return ret;
548 }
549 if (mRepeatingSequenceId != REQUEST_ID_NONE) {
550 int repeatingSequenceId = mRepeatingSequenceId;
551 mRepeatingSequenceId = REQUEST_ID_NONE;
552
553 int64_t lastFrameNumber;
554 ScopedAStatus remoteRet = mRemote->cancelRepeatingRequest(&lastFrameNumber);
555 CHECK_TRANSACTION_AND_RET(remoteRet, "cancelRepeatingRequest()");
556 checkRepeatingSequenceCompleteLocked(repeatingSequenceId, lastFrameNumber);
557 }
558 return ACAMERA_OK;
559 }
560
flushLocked(ACameraCaptureSession * session)561 camera_status_t CameraDevice::flushLocked(ACameraCaptureSession* session) {
562 camera_status_t ret = checkCameraClosedOrErrorLocked();
563 if (ret != ACAMERA_OK) {
564 ALOGE("Camera %s abort captures failed! ret %d", getId(), ret);
565 return ret;
566 }
567
568 // This should never happen because creating a new session will close
569 // previous one and thus reject any API call from previous session.
570 // But still good to check here in case something unexpected happen.
571 if (mCurrentSession != session) {
572 ALOGE("Camera %s session %p is not current active session!", getId(), session);
573 return ACAMERA_ERROR_INVALID_OPERATION;
574 }
575
576 if (mFlushing) {
577 ALOGW("Camera %s is already aborting captures", getId());
578 return ACAMERA_OK;
579 }
580
581 mFlushing = true;
582
583 // Send onActive callback to guarantee there is always active->ready transition
584 sp<AMessage> msg = new AMessage(kWhatSessionStateCb, mHandler);
585 msg->setPointer(kContextKey, session->mUserSessionCallback.context);
586 msg->setObject(kSessionSpKey, session);
587 msg->setPointer(kCallbackFpKey, (void*) session->mUserSessionCallback.onActive);
588 postSessionMsgAndCleanup(msg);
589
590 // If device is already idling, send callback and exit early
591 if (mIdle) {
592 sp<AMessage> msg = new AMessage(kWhatSessionStateCb, mHandler);
593 msg->setPointer(kContextKey, session->mUserSessionCallback.context);
594 msg->setObject(kSessionSpKey, session);
595 msg->setPointer(kCallbackFpKey, (void*) session->mUserSessionCallback.onReady);
596 postSessionMsgAndCleanup(msg);
597 mFlushing = false;
598 return ACAMERA_OK;
599 }
600
601 int64_t lastFrameNumber;
602 ScopedAStatus remoteRet = mRemote->flush(&lastFrameNumber);
603 CHECK_TRANSACTION_AND_RET(remoteRet, "flush()")
604 if (mRepeatingSequenceId != REQUEST_ID_NONE) {
605 checkRepeatingSequenceCompleteLocked(mRepeatingSequenceId, lastFrameNumber);
606 }
607 return ACAMERA_OK;
608 }
609
waitUntilIdleLocked()610 camera_status_t CameraDevice::waitUntilIdleLocked() {
611 camera_status_t ret = checkCameraClosedOrErrorLocked();
612 if (ret != ACAMERA_OK) {
613 ALOGE("Wait until camera %s idle failed! ret %d", getId(), ret);
614 return ret;
615 }
616
617 if (mRepeatingSequenceId != REQUEST_ID_NONE) {
618 ALOGE("Camera device %s won't go to idle when there is repeating request!", getId());
619 return ACAMERA_ERROR_INVALID_OPERATION;
620 }
621
622 auto remoteRet = mRemote->waitUntilIdle();
623 CHECK_TRANSACTION_AND_RET(remoteRet, "waitUntilIdle()")
624 return ACAMERA_OK;
625 }
626
configureStreamsLocked(const ACaptureSessionOutputContainer * outputs,const ACaptureRequest * sessionParameters,nsecs_t startTimeNs)627 camera_status_t CameraDevice::configureStreamsLocked(const ACaptureSessionOutputContainer* outputs,
628 const ACaptureRequest* sessionParameters,
629 nsecs_t startTimeNs) {
630 ACaptureSessionOutputContainer emptyOutput;
631 if (outputs == nullptr) {
632 outputs = &emptyOutput;
633 }
634
635 camera_status_t ret = checkCameraClosedOrErrorLocked();
636 if (ret != ACAMERA_OK) {
637 return ret;
638 }
639
640 std::map<native_handle_ptr_wrapper, OutputConfiguration> handleToConfig;
641 for (const auto& outConfig : outputs->mOutputs) {
642 native_handle_ptr_wrapper anw = outConfig.mWindow;
643 OutputConfiguration outConfigInsert;
644 outConfigInsert.rotation = utils::convertToAidl(outConfig.mRotation);
645 outConfigInsert.windowGroupId = -1;
646 outConfigInsert.windowHandles.resize(outConfig.mSharedWindows.size() + 1);
647 outConfigInsert.windowHandles[0] = std::move(dupToAidl(anw));
648 outConfigInsert.physicalCameraId = outConfig.mPhysicalCameraId;
649 handleToConfig.insert({anw, std::move(outConfigInsert)});
650 }
651
652 std::set<native_handle_ptr_wrapper> addSet;
653 for (auto& kvPair : handleToConfig) {
654 addSet.insert(kvPair.first);
655 }
656
657 std::vector<int32_t> deleteList;
658
659 // Determine which streams need to be created, which to be deleted
660 for (auto& kvPair : mConfiguredOutputs) {
661 int32_t streamId = kvPair.first;
662 auto& outputPair = kvPair.second;
663 auto& anw = outputPair.first;
664 auto& configuredOutput = outputPair.second;
665
666 auto itr = handleToConfig.find(anw);
667 if (itr != handleToConfig.end() && (itr->second) == configuredOutput) {
668 deleteList.push_back(streamId);
669 } else {
670 addSet.erase(anw);
671 }
672 }
673
674 ret = stopRepeatingLocked();
675 if (ret != ACAMERA_OK) {
676 ALOGE("Camera device %s stop repeating failed, ret %d", getId(), ret);
677 return ret;
678 }
679
680 ret = waitUntilIdleLocked();
681 if (ret != ACAMERA_OK) {
682 ALOGE("Camera device %s wait until idle failed, ret %d", getId(), ret);
683 return ret;
684 }
685
686 // Send onReady to previous session
687 // CurrentSession will be updated after configureStreamLocked, so here
688 // mCurrentSession is the session to be replaced by a new session
689 if (!mIdle && mCurrentSession != nullptr) {
690 if (mBusySession != mCurrentSession) {
691 ALOGE("Current session != busy session");
692 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE);
693 return ACAMERA_ERROR_CAMERA_DEVICE;
694 }
695 sp<AMessage> msg = new AMessage(kWhatSessionStateCb, mHandler);
696 msg->setPointer(kContextKey, mBusySession->mUserSessionCallback.context);
697 msg->setObject(kSessionSpKey, mBusySession);
698 msg->setPointer(kCallbackFpKey, (void*) mBusySession->mUserSessionCallback.onReady);
699 mBusySession.clear();
700 postSessionMsgAndCleanup(msg);
701 }
702 mIdle = true;
703
704 auto remoteRet = mRemote->beginConfigure();
705 CHECK_TRANSACTION_AND_RET(remoteRet, "beginConfigure()")
706
707 // delete to-be-deleted streams
708 for (auto streamId : deleteList) {
709 remoteRet = mRemote->deleteStream(streamId);
710 CHECK_TRANSACTION_AND_RET(remoteRet, "deleteStream()")
711 mConfiguredOutputs.erase(streamId);
712 }
713
714 // add new streams
715 for (const auto &anw : addSet) {
716 int32_t streamId;
717 auto itr = handleToConfig.find(anw);
718 remoteRet = mRemote->createStream(itr->second, &streamId);
719 CHECK_TRANSACTION_AND_RET(remoteRet, "createStream()")
720 mConfiguredOutputs.insert(std::make_pair(streamId,
721 std::make_pair(anw,
722 std::move(itr->second))));
723 handleToConfig.erase(itr);
724 }
725
726 AidlCameraMetadata aidlParams;
727 if ((sessionParameters != nullptr) && (sessionParameters->settings != nullptr)) {
728 const CameraMetadata ¶ms = sessionParameters->settings->getInternalData();
729 const camera_metadata_t* paramsMetadata = params.getAndLock();
730 utils::convertToAidl(paramsMetadata, &aidlParams);
731 params.unlock(paramsMetadata);
732 }
733 remoteRet = mRemote->endConfigure(StreamConfigurationMode::NORMAL_MODE,
734 aidlParams, startTimeNs);
735 CHECK_TRANSACTION_AND_RET(remoteRet, "endConfigure()")
736 return ACAMERA_OK;
737 }
738
setRemoteDevice(std::shared_ptr<ICameraDeviceUser> remote)739 void CameraDevice::setRemoteDevice(std::shared_ptr<ICameraDeviceUser> remote) {
740 Mutex::Autolock _l(mDeviceLock);
741 mRemote = std::move(remote);
742 }
743
setDeviceMetadataQueues()744 bool CameraDevice::setDeviceMetadataQueues() {
745 if (mRemote == nullptr) {
746 ALOGE("mRemote must not be null while trying to fetch metadata queues");
747 return false;
748 }
749 std::shared_ptr<RequestMetadataQueue> &reqQueue = mCaptureRequestMetadataQueue;
750 MQDescriptor<int8_t, SynchronizedReadWrite> reqMqDescriptor;
751 ScopedAStatus ret = mRemote->getCaptureRequestMetadataQueue(&reqMqDescriptor);
752 if (!ret.isOk()) {
753 ALOGE("Transaction error trying to get capture request metadata queue");
754 return false;
755 }
756 reqQueue = std::make_shared<RequestMetadataQueue>(reqMqDescriptor);
757 if (!reqQueue->isValid() || reqQueue->availableToWrite() <= 0) {
758 ALOGE("Empty fmq from cameraserver");
759 reqQueue = nullptr;
760 }
761
762 MQDescriptor<int8_t, SynchronizedReadWrite> resMqDescriptor;
763 std::shared_ptr<ResultMetadataQueue> &resQueue = mCaptureResultMetadataQueue;
764 ret = mRemote->getCaptureResultMetadataQueue(&resMqDescriptor);
765 if (!ret.isOk()) {
766 ALOGE("Transaction error trying to get capture result metadata queue");
767 return false;
768 }
769 resQueue = std::make_shared<ResultMetadataQueue>(resMqDescriptor);
770 if (!resQueue->isValid() || resQueue->availableToWrite() <= 0) {
771 ALOGE("Empty fmq from cameraserver");
772 }
773
774 return true;
775 }
776
checkCameraClosedOrErrorLocked() const777 camera_status_t CameraDevice::checkCameraClosedOrErrorLocked() const {
778 if (mRemote == nullptr) {
779 ALOGE("%s: camera device already closed", __FUNCTION__);
780 return ACAMERA_ERROR_CAMERA_DISCONNECTED;
781 }
782 if (mInError) { // triggered by onDeviceError
783 ALOGE("%s: camera device has encountered a serious error: %d", __FUNCTION__, mError);
784 return mError;
785 }
786 return ACAMERA_OK;
787 }
788
setCameraDeviceErrorLocked(camera_status_t error)789 void CameraDevice::setCameraDeviceErrorLocked(camera_status_t error) {
790 mInError = true;
791 mError = error;
792 }
793
updateTracker(int64_t frameNumber,bool isError)794 void CameraDevice::FrameNumberTracker::updateTracker(int64_t frameNumber, bool isError) {
795 ALOGV("updateTracker frame %" PRId64 " isError %d", frameNumber, isError);
796 if (isError) {
797 mFutureErrorSet.insert(frameNumber);
798 } else if (frameNumber <= mCompletedFrameNumber) {
799 ALOGE("Frame number %" PRId64 " decreased! current fn %" PRId64,
800 frameNumber, mCompletedFrameNumber);
801 return;
802 } else {
803 if (frameNumber != mCompletedFrameNumber + 1) {
804 ALOGE("Frame number out of order. Expect %" PRId64 " but get %" PRId64,
805 mCompletedFrameNumber + 1, frameNumber);
806 // Do not assert as in java implementation
807 }
808 mCompletedFrameNumber = frameNumber;
809 }
810 update();
811 }
812
update()813 void CameraDevice::FrameNumberTracker::update() {
814 for (auto it = mFutureErrorSet.begin(); it != mFutureErrorSet.end();) {
815 int64_t errorFrameNumber = *it;
816 if (errorFrameNumber == mCompletedFrameNumber + 1) {
817 mCompletedFrameNumber++;
818 it = mFutureErrorSet.erase(it);
819 } else if (errorFrameNumber <= mCompletedFrameNumber) {
820 // This should not happen, but deal with it anyway
821 ALOGE("Completd frame number passed through current frame number!");
822 // erase the old error since it's no longer useful
823 it = mFutureErrorSet.erase(it);
824 } else {
825 // Normal requests hasn't catched up error frames, just break
826 break;
827 }
828 }
829 ALOGV("Update complete frame %" PRId64, mCompletedFrameNumber);
830 }
831
onCaptureErrorLocked(ErrorCode errorCode,const CaptureResultExtras & resultExtras)832 void CameraDevice::onCaptureErrorLocked(ErrorCode errorCode,
833 const CaptureResultExtras& resultExtras) {
834 int sequenceId = resultExtras.requestId;
835 int64_t frameNumber = resultExtras.frameNumber;
836 int32_t burstId = resultExtras.burstId;
837 auto it = mSequenceCallbackMap.find(sequenceId);
838 if (it == mSequenceCallbackMap.end()) {
839 ALOGE("%s: Error: capture sequence index %d not found!",
840 __FUNCTION__, sequenceId);
841 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE);
842 return;
843 }
844
845 CallbackHolder cbh = it->second;
846 sp<ACameraCaptureSession> session = cbh.mSession;
847 if ((size_t) burstId >= cbh.mRequests.size()) {
848 ALOGE("%s: Error: request index %d out of bound (size %zu)",
849 __FUNCTION__, burstId, cbh.mRequests.size());
850 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE);
851 return;
852 }
853 sp<CaptureRequest> request = cbh.mRequests[burstId];
854
855 // Handle buffer error
856 if (errorCode == ErrorCode::CAMERA_BUFFER) {
857 int32_t streamId = resultExtras.errorStreamId;
858 ACameraCaptureSession_captureCallback_bufferLost onBufferLost =
859 cbh.mOnCaptureBufferLost;
860 auto outputPairIt = mConfiguredOutputs.find(streamId);
861 if (outputPairIt == mConfiguredOutputs.end()) {
862 ALOGE("%s: Error: stream id %d does not exist", __FUNCTION__, streamId);
863 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE);
864 return;
865 }
866
867 // Get the surfaces corresponding to the error stream id, go through
868 // them and try to match the surfaces in the corresponding
869 // CaptureRequest.
870 const auto& errorWindowHandles =
871 outputPairIt->second.second.windowHandles;
872 for (const auto& errorWindowHandle : errorWindowHandles) {
873 for (const auto &requestStreamAndWindowId :
874 request->mCaptureRequest.streamAndWindowIds) {
875 // Go through the surfaces in the capture request and see which
876 // ones match the surfaces in the error stream.
877 int32_t requestWindowId = requestStreamAndWindowId.windowId;
878 auto requestSurfacePairIt =
879 mConfiguredOutputs.find(requestStreamAndWindowId.streamId);
880 if (requestSurfacePairIt == mConfiguredOutputs.end()) {
881 ALOGE("%s: Error: request stream id %d does not exist", __FUNCTION__,
882 requestStreamAndWindowId.streamId);
883 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE);
884 return;
885 }
886
887 const auto &requestWindowHandles =
888 requestSurfacePairIt->second.second.windowHandles;
889
890 if (requestWindowHandles[requestWindowId] == errorWindowHandle) {
891 const native_handle_t* anw = makeFromAidl(
892 requestWindowHandles[requestWindowId]);
893 ALOGV("Camera %s Lost output buffer for ANW %p frame %" PRId64,
894 getId(), anw, frameNumber);
895
896 sp<AMessage> msg = new AMessage(kWhatCaptureBufferLost, mHandler);
897 msg->setPointer(kContextKey, cbh.mContext);
898 msg->setObject(kSessionSpKey, session);
899 msg->setPointer(kCallbackFpKey, (void*) onBufferLost);
900 msg->setObject(kCaptureRequestKey, request);
901 msg->setPointer(kAnwKey, (void*) anw);
902 msg->setInt64(kFrameNumberKey, frameNumber);
903 postSessionMsgAndCleanup(msg);
904 }
905 }
906 }
907 } else { // Handle other capture failures
908 // Fire capture failure callback if there is one registered
909 ACameraCaptureSession_captureCallback_failed onError = cbh.mOnCaptureFailed;
910 sp<CameraCaptureFailure> failure(new CameraCaptureFailure());
911 failure->frameNumber = frameNumber;
912 // TODO: refine this when implementing flush
913 failure->reason = CAPTURE_FAILURE_REASON_ERROR;
914 failure->sequenceId = sequenceId;
915 failure->wasImageCaptured = (errorCode == ErrorCode::CAMERA_RESULT);
916
917 sp<AMessage> msg = new AMessage(cbh.mIsLogicalCameraCallback ? kWhatLogicalCaptureFail
918 : kWhatCaptureFail,
919 mHandler);
920 msg->setPointer(kContextKey, cbh.mContext);
921 msg->setObject(kSessionSpKey, session);
922 if (cbh.mIsLogicalCameraCallback) {
923 if (!resultExtras.errorPhysicalCameraId.empty()) {
924 msg->setString(kFailingPhysicalCameraId,
925 resultExtras.errorPhysicalCameraId.c_str(),
926 resultExtras.errorPhysicalCameraId.size());
927 }
928 msg->setPointer(kCallbackFpKey, (void*) cbh.mOnLogicalCameraCaptureFailed);
929 } else {
930 msg->setPointer(kCallbackFpKey, (void*) onError);
931 }
932 msg->setObject(kCaptureRequestKey, request);
933 msg->setObject(kCaptureFailureKey, failure);
934 postSessionMsgAndCleanup(msg);
935
936 // Update tracker
937 mFrameNumberTracker.updateTracker(frameNumber, /*isError*/true);
938 checkAndFireSequenceCompleteLocked();
939 }
940 }
941
CallbackHandler(const char * id)942 CameraDevice::CallbackHandler::CallbackHandler(const char *id) : mId(id) { }
943
onMessageReceived(const sp<AMessage> & msg)944 void CameraDevice::CallbackHandler::onMessageReceived(
945 const sp<AMessage> &msg) {
946 switch (msg->what()) {
947 case kWhatOnDisconnected:
948 case kWhatOnError:
949 case kWhatSessionStateCb:
950 case kWhatCaptureStart:
951 case kWhatCaptureStart2:
952 case kWhatCaptureResult:
953 case kWhatLogicalCaptureResult:
954 case kWhatCaptureFail:
955 case kWhatLogicalCaptureFail:
956 case kWhatCaptureSeqEnd:
957 case kWhatCaptureSeqAbort:
958 case kWhatCaptureBufferLost:
959 case kWhatPreparedCb:
960 ALOGV("%s: Received msg %d", __FUNCTION__, msg->what());
961 break;
962 case kWhatCleanUpSessions:
963 mCachedSessions.clear();
964 return;
965 default:
966 ALOGE("%s:Error: unknown device callback %d", __FUNCTION__, msg->what());
967 return;
968 }
969 // Check the common part of all message
970 void* context;
971 bool found = msg->findPointer(kContextKey, &context);
972 if (!found) {
973 ALOGE("%s: Cannot find callback context!", __FUNCTION__);
974 return;
975 }
976 switch (msg->what()) {
977 case kWhatOnDisconnected:
978 {
979 ACameraDevice* dev;
980 found = msg->findPointer(kDeviceKey, (void**) &dev);
981 if (!found || dev == nullptr) {
982 ALOGE("%s: Cannot find device pointer!", __FUNCTION__);
983 return;
984 }
985 ACameraDevice_StateCallback onDisconnected;
986 found = msg->findPointer(kCallbackFpKey, (void**) &onDisconnected);
987 if (!found) {
988 ALOGE("%s: Cannot find onDisconnected!", __FUNCTION__);
989 return;
990 }
991 if (onDisconnected == nullptr) {
992 return;
993 }
994 (*onDisconnected)(context, dev);
995 break;
996 }
997 case kWhatOnError:
998 {
999 ACameraDevice* dev;
1000 found = msg->findPointer(kDeviceKey, (void**) &dev);
1001 if (!found || dev == nullptr) {
1002 ALOGE("%s: Cannot find device pointer!", __FUNCTION__);
1003 return;
1004 }
1005 ACameraDevice_ErrorStateCallback onError;
1006 found = msg->findPointer(kCallbackFpKey, (void**) &onError);
1007 if (!found) {
1008 ALOGE("%s: Cannot find onError!", __FUNCTION__);
1009 return;
1010 }
1011 int errorCode;
1012 found = msg->findInt32(kErrorCodeKey, &errorCode);
1013 if (!found) {
1014 ALOGE("%s: Cannot find error code!", __FUNCTION__);
1015 return;
1016 }
1017 if (onError == nullptr) {
1018 return;
1019 }
1020 (*onError)(context, dev, errorCode);
1021 break;
1022 }
1023 case kWhatSessionStateCb:
1024 case kWhatCaptureStart:
1025 case kWhatCaptureStart2:
1026 case kWhatCaptureResult:
1027 case kWhatLogicalCaptureResult:
1028 case kWhatCaptureFail:
1029 case kWhatLogicalCaptureFail:
1030 case kWhatCaptureSeqEnd:
1031 case kWhatCaptureSeqAbort:
1032 case kWhatCaptureBufferLost:
1033 case kWhatPreparedCb:
1034 {
1035 sp<RefBase> obj;
1036 found = msg->findObject(kSessionSpKey, &obj);
1037 if (!found || obj == nullptr) {
1038 ALOGE("%s: Cannot find session pointer!", __FUNCTION__);
1039 return;
1040 }
1041 sp<ACameraCaptureSession> session(static_cast<ACameraCaptureSession*>(obj.get()));
1042 mCachedSessions.push_back(session);
1043 sp<CaptureRequest> requestSp = nullptr;
1044 const char *id_cstr = mId.c_str();
1045 switch (msg->what()) {
1046 case kWhatCaptureStart:
1047 case kWhatCaptureStart2:
1048 case kWhatCaptureResult:
1049 case kWhatLogicalCaptureResult:
1050 case kWhatCaptureFail:
1051 case kWhatLogicalCaptureFail:
1052 case kWhatCaptureBufferLost:
1053 found = msg->findObject(kCaptureRequestKey, &obj);
1054 if (!found) {
1055 ALOGE("%s: Cannot find capture request!", __FUNCTION__);
1056 return;
1057 }
1058 requestSp = static_cast<CaptureRequest*>(obj.get());
1059 break;
1060 }
1061
1062 switch (msg->what()) {
1063 case kWhatSessionStateCb:
1064 {
1065 ACameraCaptureSession_stateCallback onState;
1066 found = msg->findPointer(kCallbackFpKey, (void**) &onState);
1067 if (!found) {
1068 ALOGE("%s: Cannot find state callback!", __FUNCTION__);
1069 return;
1070 }
1071 if (onState == nullptr) {
1072 return;
1073 }
1074 (*onState)(context, session.get());
1075 break;
1076 }
1077 case kWhatPreparedCb:
1078 {
1079 ACameraCaptureSession_prepareCallback onWindowPrepared;
1080 found = msg->findPointer(kCallbackFpKey, (void**) &onWindowPrepared);
1081 if (!found) {
1082 ALOGE("%s: Cannot find state callback!", __FUNCTION__);
1083 return;
1084 }
1085 if (onWindowPrepared == nullptr) {
1086 return;
1087 }
1088 native_handle_t* anw;
1089 found = msg->findPointer(kAnwKey, (void**) &anw);
1090 if (!found) {
1091 ALOGE("%s: Cannot find ANativeWindow: %d!", __FUNCTION__, __LINE__);
1092 return;
1093 }
1094 (*onWindowPrepared)(context, anw, session.get());
1095 break;
1096 }
1097 case kWhatCaptureStart:
1098 {
1099 ACameraCaptureSession_captureCallback_start onStart;
1100 found = msg->findPointer(kCallbackFpKey, (void**) &onStart);
1101 if (!found) {
1102 ALOGE("%s: Cannot find capture start callback!", __FUNCTION__);
1103 return;
1104 }
1105 if (onStart == nullptr) {
1106 return;
1107 }
1108 int64_t timestamp;
1109 found = msg->findInt64(kTimeStampKey, ×tamp);
1110 if (!found) {
1111 ALOGE("%s: Cannot find timestamp!", __FUNCTION__);
1112 return;
1113 }
1114 ACaptureRequest* request = allocateACaptureRequest(requestSp, id_cstr);
1115 (*onStart)(context, session.get(), request, timestamp);
1116 freeACaptureRequest(request);
1117 break;
1118 }
1119 case kWhatCaptureStart2:
1120 {
1121 ACameraCaptureSession_captureCallback_startV2 onStart2;
1122 found = msg->findPointer(kCallbackFpKey, (void**) &onStart2);
1123 if (!found) {
1124 ALOGE("%s: Cannot find capture startV2 callback!", __FUNCTION__);
1125 return;
1126 }
1127 if (onStart2 == nullptr) {
1128 return;
1129 }
1130 int64_t timestamp;
1131 found = msg->findInt64(kTimeStampKey, ×tamp);
1132 if (!found) {
1133 ALOGE("%s: Cannot find timestamp!", __FUNCTION__);
1134 return;
1135 }
1136 int64_t frameNumber;
1137 found = msg->findInt64(kFrameNumberKey, &frameNumber);
1138 if (!found) {
1139 ALOGE("%s: Cannot find frame number!", __FUNCTION__);
1140 return;
1141 }
1142
1143 ACaptureRequest* request = allocateACaptureRequest(requestSp, id_cstr);
1144 (*onStart2)(context, session.get(), request, timestamp, frameNumber);
1145 freeACaptureRequest(request);
1146 break;
1147 }
1148 case kWhatCaptureResult:
1149 {
1150 ACameraCaptureSession_captureCallback_result onResult;
1151 found = msg->findPointer(kCallbackFpKey, (void**) &onResult);
1152 if (!found) {
1153 ALOGE("%s: Cannot find capture result callback!", __FUNCTION__);
1154 return;
1155 }
1156 if (onResult == nullptr) {
1157 return;
1158 }
1159
1160 found = msg->findObject(kCaptureResultKey, &obj);
1161 if (!found) {
1162 ALOGE("%s: Cannot find capture result!", __FUNCTION__);
1163 return;
1164 }
1165 sp<ACameraMetadata> result(static_cast<ACameraMetadata*>(obj.get()));
1166 ACaptureRequest* request = allocateACaptureRequest(requestSp, id_cstr);
1167 (*onResult)(context, session.get(), request, result.get());
1168 freeACaptureRequest(request);
1169 break;
1170 }
1171 case kWhatLogicalCaptureResult:
1172 {
1173 ACameraCaptureSession_logicalCamera_captureCallback_result onResult;
1174 found = msg->findPointer(kCallbackFpKey, (void**) &onResult);
1175 if (!found) {
1176 ALOGE("%s: Cannot find capture result callback!", __FUNCTION__);
1177 return;
1178 }
1179 if (onResult == nullptr) {
1180 return;
1181 }
1182
1183 found = msg->findObject(kCaptureResultKey, &obj);
1184 if (!found) {
1185 ALOGE("%s: Cannot find capture result!", __FUNCTION__);
1186 return;
1187 }
1188 sp<ACameraMetadata> result(static_cast<ACameraMetadata*>(obj.get()));
1189
1190 found = msg->findObject(kPhysicalCaptureResultKey, &obj);
1191 if (!found) {
1192 ALOGE("%s: Cannot find physical capture result!", __FUNCTION__);
1193 return;
1194 }
1195 sp<ACameraPhysicalCaptureResultInfo> physicalResult(
1196 static_cast<ACameraPhysicalCaptureResultInfo*>(obj.get()));
1197 std::vector<PhysicalCaptureResultInfoLocal>& physicalResultInfo =
1198 physicalResult->mPhysicalResultInfo;
1199
1200 std::vector<std::string> physicalCameraIds;
1201 std::vector<sp<ACameraMetadata>> physicalMetadataCopy;
1202 for (size_t i = 0; i < physicalResultInfo.size(); i++) {
1203 physicalCameraIds.push_back(physicalResultInfo[i].physicalCameraId);
1204
1205 CameraMetadata clone = physicalResultInfo[i].physicalMetadata;
1206 clone.update(ANDROID_SYNC_FRAME_NUMBER,
1207 &physicalResult->mFrameNumber, /*data_count*/1);
1208 sp<ACameraMetadata> metadata =
1209 new ACameraMetadata(clone.release(),
1210 ACameraMetadata::ACM_RESULT);
1211 physicalMetadataCopy.push_back(metadata);
1212 }
1213 std::vector<const char*> physicalCameraIdPtrs;
1214 std::vector<const ACameraMetadata*> physicalMetadataCopyPtrs;
1215 for (size_t i = 0; i < physicalResultInfo.size(); i++) {
1216 physicalCameraIdPtrs.push_back(physicalCameraIds[i].c_str());
1217 physicalMetadataCopyPtrs.push_back(physicalMetadataCopy[i].get());
1218 }
1219
1220 ACaptureRequest* request = allocateACaptureRequest(requestSp, id_cstr);
1221 (*onResult)(context, session.get(), request, result.get(),
1222 physicalResultInfo.size(), physicalCameraIdPtrs.data(),
1223 physicalMetadataCopyPtrs.data());
1224 freeACaptureRequest(request);
1225 break;
1226 }
1227
1228 case kWhatCaptureFail:
1229 {
1230 ACameraCaptureSession_captureCallback_failed onFail;
1231 found = msg->findPointer(kCallbackFpKey, (void**) &onFail);
1232 if (!found) {
1233 ALOGE("%s: Cannot find capture fail callback!", __FUNCTION__);
1234 return;
1235 }
1236 if (onFail == nullptr) {
1237 return;
1238 }
1239
1240 found = msg->findObject(kCaptureFailureKey, &obj);
1241 if (!found) {
1242 ALOGE("%s: Cannot find capture failure!", __FUNCTION__);
1243 return;
1244 }
1245 sp<CameraCaptureFailure> failureSp(
1246 static_cast<CameraCaptureFailure*>(obj.get()));
1247 ACameraCaptureFailure* failure =
1248 static_cast<ACameraCaptureFailure*>(failureSp.get());
1249 ACaptureRequest* request = allocateACaptureRequest(requestSp, id_cstr);
1250 (*onFail)(context, session.get(), request, failure);
1251 freeACaptureRequest(request);
1252 break;
1253 }
1254 case kWhatLogicalCaptureFail:
1255 {
1256 ACameraCaptureSession_logicalCamera_captureCallback_failed onFail;
1257 found = msg->findPointer(kCallbackFpKey, (void**) &onFail);
1258 if (!found) {
1259 ALOGE("%s: Cannot find capture fail callback!", __FUNCTION__);
1260 return;
1261 }
1262 if (onFail == nullptr) {
1263 return;
1264 }
1265
1266 found = msg->findObject(kCaptureFailureKey, &obj);
1267 if (!found) {
1268 ALOGE("%s: Cannot find capture failure!", __FUNCTION__);
1269 return;
1270 }
1271 sp<CameraCaptureFailure> failureSp(
1272 static_cast<CameraCaptureFailure*>(obj.get()));
1273 ALogicalCameraCaptureFailure failure;
1274 AString physicalCameraId;
1275 found = msg->findString(kFailingPhysicalCameraId, &physicalCameraId);
1276 if (found && !physicalCameraId.empty()) {
1277 failure.physicalCameraId = physicalCameraId.c_str();
1278 } else {
1279 failure.physicalCameraId = nullptr;
1280 }
1281 failure.captureFailure = *failureSp;
1282 ACaptureRequest* request = allocateACaptureRequest(requestSp, id_cstr);
1283 (*onFail)(context, session.get(), request, &failure);
1284 freeACaptureRequest(request);
1285 break;
1286 }
1287 case kWhatCaptureSeqEnd:
1288 {
1289 ACameraCaptureSession_captureCallback_sequenceEnd onSeqEnd;
1290 found = msg->findPointer(kCallbackFpKey, (void**) &onSeqEnd);
1291 if (!found) {
1292 ALOGE("%s: Cannot find sequence end callback!", __FUNCTION__);
1293 return;
1294 }
1295 if (onSeqEnd == nullptr) {
1296 return;
1297 }
1298 int seqId;
1299 found = msg->findInt32(kSequenceIdKey, &seqId);
1300 if (!found) {
1301 ALOGE("%s: Cannot find frame number!", __FUNCTION__);
1302 return;
1303 }
1304 int64_t frameNumber;
1305 found = msg->findInt64(kFrameNumberKey, &frameNumber);
1306 if (!found) {
1307 ALOGE("%s: Cannot find frame number!", __FUNCTION__);
1308 return;
1309 }
1310 (*onSeqEnd)(context, session.get(), seqId, frameNumber);
1311 break;
1312 }
1313 case kWhatCaptureSeqAbort:
1314 {
1315 ACameraCaptureSession_captureCallback_sequenceAbort onSeqAbort;
1316 found = msg->findPointer(kCallbackFpKey, (void**) &onSeqAbort);
1317 if (!found) {
1318 ALOGE("%s: Cannot find sequence end callback!", __FUNCTION__);
1319 return;
1320 }
1321 if (onSeqAbort == nullptr) {
1322 return;
1323 }
1324 int seqId;
1325 found = msg->findInt32(kSequenceIdKey, &seqId);
1326 if (!found) {
1327 ALOGE("%s: Cannot find frame number!", __FUNCTION__);
1328 return;
1329 }
1330 (*onSeqAbort)(context, session.get(), seqId);
1331 break;
1332 }
1333 case kWhatCaptureBufferLost:
1334 {
1335 ACameraCaptureSession_captureCallback_bufferLost onBufferLost;
1336 found = msg->findPointer(kCallbackFpKey, (void**) &onBufferLost);
1337 if (!found) {
1338 ALOGE("%s: Cannot find buffer lost callback!", __FUNCTION__);
1339 return;
1340 }
1341 if (onBufferLost == nullptr) {
1342 return;
1343 }
1344
1345 native_handle_t* anw;
1346 found = msg->findPointer(kAnwKey, (void**) &anw);
1347 if (!found) {
1348 ALOGE("%s: Cannot find native_handle_t!", __FUNCTION__);
1349 return;
1350 }
1351
1352 int64_t frameNumber;
1353 found = msg->findInt64(kFrameNumberKey, &frameNumber);
1354 if (!found) {
1355 ALOGE("%s: Cannot find frame number!", __FUNCTION__);
1356 return;
1357 }
1358
1359 ACaptureRequest* request = allocateACaptureRequest(requestSp, id_cstr);
1360 (*onBufferLost)(context, session.get(), request, anw, frameNumber);
1361 freeACaptureRequest(request);
1362 native_handle_delete(anw); // clean up anw as it was copied from AIDL
1363 break;
1364 }
1365 }
1366 break;
1367 }
1368 }
1369 }
1370
CallbackHolder(sp<ACameraCaptureSession> session,std::vector<sp<CaptureRequest>> requests,bool isRepeating,ACameraCaptureSession_captureCallbacks * cbs)1371 CameraDevice::CallbackHolder::CallbackHolder(
1372 sp<ACameraCaptureSession> session,
1373 std::vector<sp<CaptureRequest>> requests,
1374 bool isRepeating,
1375 ACameraCaptureSession_captureCallbacks* cbs) :
1376 mSession(std::move(session)), mRequests(std::move(requests)),
1377 mIsRepeating(isRepeating),
1378 mIs2Callback(false),
1379 mIsLogicalCameraCallback(false) {
1380 initCaptureCallbacks(cbs);
1381
1382 if (cbs != nullptr) {
1383 mOnCaptureCompleted = cbs->onCaptureCompleted;
1384 mOnCaptureFailed = cbs->onCaptureFailed;
1385 }
1386 }
1387
CallbackHolder(sp<ACameraCaptureSession> session,std::vector<sp<CaptureRequest>> requests,bool isRepeating,ACameraCaptureSession_logicalCamera_captureCallbacks * lcbs)1388 CameraDevice::CallbackHolder::CallbackHolder(
1389 sp<ACameraCaptureSession> session,
1390 std::vector<sp<CaptureRequest>> requests,
1391 bool isRepeating,
1392 ACameraCaptureSession_logicalCamera_captureCallbacks* lcbs) :
1393 mSession(std::move(session)), mRequests(std::move(requests)),
1394 mIsRepeating(isRepeating),
1395 mIs2Callback(false),
1396 mIsLogicalCameraCallback(true) {
1397 initCaptureCallbacks(lcbs);
1398
1399 if (lcbs != nullptr) {
1400 mOnLogicalCameraCaptureCompleted = lcbs->onLogicalCameraCaptureCompleted;
1401 mOnLogicalCameraCaptureFailed = lcbs->onLogicalCameraCaptureFailed;
1402 }
1403 }
1404
CallbackHolder(sp<ACameraCaptureSession> session,std::vector<sp<CaptureRequest>> requests,bool isRepeating,ACameraCaptureSession_captureCallbacksV2 * cbs)1405 CameraDevice::CallbackHolder::CallbackHolder(
1406 sp<ACameraCaptureSession> session,
1407 std::vector<sp<CaptureRequest>> requests,
1408 bool isRepeating,
1409 ACameraCaptureSession_captureCallbacksV2* cbs) :
1410 mSession(std::move(session)), mRequests(std::move(requests)),
1411 mIsRepeating(isRepeating),
1412 mIs2Callback(true),
1413 mIsLogicalCameraCallback(false) {
1414 initCaptureCallbacksV2(cbs);
1415
1416 if (cbs != nullptr) {
1417 mOnCaptureCompleted = cbs->onCaptureCompleted;
1418 mOnCaptureFailed = cbs->onCaptureFailed;
1419 }
1420 }
1421
CallbackHolder(sp<ACameraCaptureSession> session,std::vector<sp<CaptureRequest>> requests,bool isRepeating,ACameraCaptureSession_logicalCamera_captureCallbacksV2 * lcbs)1422 CameraDevice::CallbackHolder::CallbackHolder(
1423 sp<ACameraCaptureSession> session,
1424 std::vector<sp<CaptureRequest>> requests,
1425 bool isRepeating,
1426 ACameraCaptureSession_logicalCamera_captureCallbacksV2* lcbs) :
1427 mSession(std::move(session)), mRequests(std::move(requests)),
1428 mIsRepeating(isRepeating),
1429 mIs2Callback(true),
1430 mIsLogicalCameraCallback(true) {
1431 initCaptureCallbacksV2(lcbs);
1432
1433 if (lcbs != nullptr) {
1434 mOnLogicalCameraCaptureCompleted = lcbs->onLogicalCameraCaptureCompleted;
1435 mOnLogicalCameraCaptureFailed = lcbs->onLogicalCameraCaptureFailed;
1436 }
1437 }
1438
1439 void
checkRepeatingSequenceCompleteLocked(const int sequenceId,const int64_t lastFrameNumber)1440 CameraDevice::checkRepeatingSequenceCompleteLocked(
1441 const int sequenceId, const int64_t lastFrameNumber) {
1442 ALOGV("Repeating seqId %d lastFrameNumer %" PRId64, sequenceId, lastFrameNumber);
1443 if (lastFrameNumber == NO_FRAMES_CAPTURED) {
1444 if (mSequenceCallbackMap.count(sequenceId) == 0) {
1445 ALOGW("No callback found for sequenceId %d", sequenceId);
1446 return;
1447 }
1448 // remove callback holder from callback map
1449 auto cbIt = mSequenceCallbackMap.find(sequenceId);
1450 CallbackHolder cbh = cbIt->second;
1451 mSequenceCallbackMap.erase(cbIt);
1452 // send seq aborted callback
1453 sp<AMessage> msg = new AMessage(kWhatCaptureSeqAbort, mHandler);
1454 msg->setPointer(kContextKey, cbh.mContext);
1455 msg->setObject(kSessionSpKey, cbh.mSession);
1456 msg->setPointer(kCallbackFpKey, (void*) cbh.mOnCaptureSequenceAborted);
1457 msg->setInt32(kSequenceIdKey, sequenceId);
1458 postSessionMsgAndCleanup(msg);
1459 } else {
1460 // Use mSequenceLastFrameNumberMap to track
1461 mSequenceLastFrameNumberMap.insert(std::make_pair(sequenceId, lastFrameNumber));
1462
1463 // Last frame might have arrived. Check now
1464 checkAndFireSequenceCompleteLocked();
1465 }
1466 }
1467
1468 void
checkAndFireSequenceCompleteLocked()1469 CameraDevice::checkAndFireSequenceCompleteLocked() {
1470 int64_t completedFrameNumber = mFrameNumberTracker.getCompletedFrameNumber();
1471 auto it = mSequenceLastFrameNumberMap.begin();
1472 while (it != mSequenceLastFrameNumberMap.end()) {
1473 int sequenceId = it->first;
1474 int64_t lastFrameNumber = it->second;
1475 bool seqCompleted = false;
1476 bool hasCallback = true;
1477
1478 if (mRemote == nullptr) {
1479 ALOGW("Camera %s closed while checking sequence complete", getId());
1480 return;
1481 }
1482
1483 // Check if there is callback for this sequence
1484 // This should not happen because we always register callback (with nullptr inside)
1485 if (mSequenceCallbackMap.count(sequenceId) == 0) {
1486 ALOGW("No callback found for sequenceId %d", sequenceId);
1487 hasCallback = false;
1488 }
1489
1490 if (lastFrameNumber <= completedFrameNumber) {
1491 ALOGV("seq %d reached last frame %" PRId64 ", completed %" PRId64,
1492 sequenceId, lastFrameNumber, completedFrameNumber);
1493 seqCompleted = true;
1494 }
1495
1496 if (seqCompleted && hasCallback) {
1497 // remove callback holder from callback map
1498 auto cbIt = mSequenceCallbackMap.find(sequenceId);
1499 CallbackHolder cbh = cbIt->second;
1500 mSequenceCallbackMap.erase(cbIt);
1501 // send seq complete callback
1502 sp<AMessage> msg = new AMessage(kWhatCaptureSeqEnd, mHandler);
1503 msg->setPointer(kContextKey, cbh.mContext);
1504 msg->setObject(kSessionSpKey, cbh.mSession);
1505 msg->setPointer(kCallbackFpKey, (void*) cbh.mOnCaptureSequenceCompleted);
1506 msg->setInt32(kSequenceIdKey, sequenceId);
1507 msg->setInt64(kFrameNumberKey, lastFrameNumber);
1508
1509 // Clear the session sp before we send out the message
1510 // This will guarantee the rare case where the message is processed
1511 // before cbh goes out of scope and causing we call the session
1512 // destructor while holding device lock
1513 cbh.mSession.clear();
1514
1515 postSessionMsgAndCleanup(msg);
1516 }
1517
1518 // No need to track sequence complete if there is no callback registered
1519 if (seqCompleted || !hasCallback) {
1520 it = mSequenceLastFrameNumberMap.erase(it);
1521 } else {
1522 ++it;
1523 }
1524 }
1525 }
1526
stopLooperAndDisconnect()1527 void CameraDevice::stopLooperAndDisconnect() {
1528 Mutex::Autolock _l(mDeviceLock);
1529 sp<ACameraCaptureSession> session = mCurrentSession.promote();
1530 if (!isClosed()) {
1531 disconnectLocked(session);
1532 }
1533 mCurrentSession = nullptr;
1534 if (mCbLooper != nullptr) {
1535 mCbLooper->unregisterHandler(mHandler->id());
1536 mCbLooper->stop();
1537 }
1538 mCbLooper.clear();
1539 mHandler.clear();
1540 }
1541
1542 /**
1543 * Camera service callback implementation
1544 */
onDeviceError(ErrorCode errorCode,const CaptureResultExtras & resultExtras)1545 ScopedAStatus CameraDevice::ServiceCallback::onDeviceError(
1546 ErrorCode errorCode, const CaptureResultExtras& resultExtras) {
1547 ALOGD("Device error received, code %d, frame number %" PRId64 ", request ID %d, subseq ID %d"
1548 " physical camera ID %s", errorCode, resultExtras.frameNumber, resultExtras.requestId,
1549 resultExtras.burstId, resultExtras.errorPhysicalCameraId.c_str());
1550
1551 std::shared_ptr<CameraDevice> dev = mDevice.lock();
1552 if (dev == nullptr) {
1553 return ScopedAStatus::ok(); // device has been closed
1554 }
1555
1556 sp<ACameraCaptureSession> session = dev->mCurrentSession.promote();
1557 Mutex::Autolock _l(dev->mDeviceLock);
1558 if (dev->mRemote == nullptr) {
1559 return ScopedAStatus::ok(); // device has been closed
1560 }
1561 switch (errorCode) {
1562 case ErrorCode::CAMERA_DISCONNECTED:
1563 {
1564 // Camera is disconnected, close the session and expect no more callbacks
1565 if (session != nullptr) {
1566 session->closeByDevice();
1567 }
1568 dev->mCurrentSession = nullptr;
1569 sp<AMessage> msg = new AMessage(kWhatOnDisconnected, dev->mHandler);
1570 msg->setPointer(kContextKey, dev->mAppCallbacks.context);
1571 msg->setPointer(kDeviceKey, (void*) dev->getWrapper());
1572 msg->setPointer(kCallbackFpKey, (void*) dev->mAppCallbacks.onDisconnected);
1573 msg->post();
1574 break;
1575 }
1576 default:
1577 ALOGE("Unknown error from camera device: %d", errorCode);
1578 [[fallthrough]];
1579 case ErrorCode::CAMERA_DEVICE:
1580 case ErrorCode::CAMERA_SERVICE:
1581 {
1582 int32_t errorVal = ::ERROR_CAMERA_DEVICE;
1583 // We keep this switch since this block might be encountered with
1584 // more than just 2 states. The default fallthrough could have us
1585 // handling more unmatched error cases.
1586 switch (errorCode) {
1587 case ErrorCode::CAMERA_DEVICE:
1588 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE);
1589 break;
1590 case ErrorCode::CAMERA_SERVICE:
1591 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE);
1592 errorVal = ::ERROR_CAMERA_SERVICE;
1593 break;
1594 default:
1595 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_UNKNOWN);
1596 break;
1597 }
1598 sp<AMessage> msg = new AMessage(kWhatOnError, dev->mHandler);
1599 msg->setPointer(kContextKey, dev->mAppCallbacks.context);
1600 msg->setPointer(kDeviceKey, (void*) dev->getWrapper());
1601 msg->setPointer(kCallbackFpKey, (void*) dev->mAppCallbacks.onError);
1602 msg->setInt32(kErrorCodeKey, errorVal);
1603 msg->post();
1604 break;
1605 }
1606 case ErrorCode::CAMERA_REQUEST:
1607 case ErrorCode::CAMERA_RESULT:
1608 case ErrorCode::CAMERA_BUFFER:
1609 dev->onCaptureErrorLocked(errorCode, resultExtras);
1610 break;
1611 }
1612 return ScopedAStatus::ok();
1613 }
1614
onDeviceIdle()1615 ScopedAStatus CameraDevice::ServiceCallback::onDeviceIdle() {
1616 ALOGV("Camera is now idle");
1617
1618 std::shared_ptr<CameraDevice> dev = mDevice.lock();
1619 if (dev == nullptr) {
1620 return ScopedAStatus::ok(); // device has been closed
1621 }
1622
1623 Mutex::Autolock _l(dev->mDeviceLock);
1624 if (dev->isClosed() || dev->mRemote == nullptr) {
1625 return ScopedAStatus::ok();
1626 }
1627
1628 if (dev->mIdle) {
1629 // Already in idle state. Possibly other thread did waitUntilIdle
1630 return ScopedAStatus::ok();
1631 }
1632
1633 if (dev->mCurrentSession != nullptr) {
1634 ALOGE("onDeviceIdle sending state cb");
1635 if (dev->mBusySession != dev->mCurrentSession) {
1636 ALOGE("Current session != busy session");
1637 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE);
1638 return ScopedAStatus::ok();
1639 }
1640
1641 sp<AMessage> msg = new AMessage(kWhatSessionStateCb, dev->mHandler);
1642 msg->setPointer(kContextKey, dev->mBusySession->mUserSessionCallback.context);
1643 msg->setObject(kSessionSpKey, dev->mBusySession);
1644 msg->setPointer(kCallbackFpKey,
1645 (void*) dev->mBusySession->mUserSessionCallback.onReady);
1646 // Make sure we clear the sp first so the session destructor can
1647 // only happen on handler thread (where we don't hold device/session lock)
1648 dev->mBusySession.clear();
1649 dev->postSessionMsgAndCleanup(msg);
1650 }
1651 dev->mIdle = true;
1652 dev->mFlushing = false;
1653 return ScopedAStatus::ok();
1654 }
1655
1656
1657
onCaptureStarted(const CaptureResultExtras & resultExtras,int64_t timestamp)1658 ndk::ScopedAStatus CameraDevice::ServiceCallback::onCaptureStarted(
1659 const CaptureResultExtras& resultExtras, int64_t timestamp) {
1660 std::shared_ptr<CameraDevice> dev = mDevice.lock();
1661 if (dev == nullptr) {
1662 return ScopedAStatus::ok(); // device has been closed
1663 }
1664 Mutex::Autolock _l(dev->mDeviceLock);
1665 if (dev->isClosed() || dev->mRemote == nullptr) {
1666 return ScopedAStatus::ok();
1667 }
1668
1669 int32_t sequenceId = resultExtras.requestId;
1670 int32_t burstId = resultExtras.burstId;
1671 int64_t frameNumber = resultExtras.frameNumber;
1672
1673 auto it = dev->mSequenceCallbackMap.find(sequenceId);
1674 if (it != dev->mSequenceCallbackMap.end()) {
1675 CallbackHolder &cbh = it->second;
1676 ACameraCaptureSession_captureCallback_start onStart = cbh.mOnCaptureStarted;
1677 ACameraCaptureSession_captureCallback_startV2 onStart2 = cbh.mOnCaptureStarted2;
1678 bool v2Callback = cbh.mIs2Callback;
1679 sp<ACameraCaptureSession> session = cbh.mSession;
1680 if ((size_t) burstId >= cbh.mRequests.size()) {
1681 ALOGE("%s: Error: request index %d out of bound (size %zu)",
1682 __FUNCTION__, burstId, cbh.mRequests.size());
1683 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE);
1684 }
1685 sp<CaptureRequest> request = cbh.mRequests[burstId];
1686 ALOGE("%s: request = %p", __FUNCTION__, request.get());
1687 sp<AMessage> msg = nullptr;
1688 if (v2Callback) {
1689 msg = new AMessage(kWhatCaptureStart2, dev->mHandler);
1690 msg->setPointer(kCallbackFpKey, (void*) onStart2);
1691 } else {
1692 msg = new AMessage(kWhatCaptureStart, dev->mHandler);
1693 msg->setPointer(kCallbackFpKey, (void*) onStart);
1694 }
1695 msg->setPointer(kContextKey, cbh.mContext);
1696 msg->setObject(kSessionSpKey, session);
1697 msg->setObject(kCaptureRequestKey, request);
1698 msg->setInt64(kTimeStampKey, timestamp);
1699 msg->setInt64(kFrameNumberKey, frameNumber);
1700 dev->postSessionMsgAndCleanup(msg);
1701 }
1702 return ScopedAStatus::ok();
1703 }
1704
onResultReceived(const CaptureMetadataInfo & resultMetadata,const CaptureResultExtras & resultExtras,const std::vector<PhysicalCaptureResultInfo> & physicalResultInfos)1705 ScopedAStatus CameraDevice::ServiceCallback::onResultReceived(
1706 const CaptureMetadataInfo& resultMetadata,
1707 const CaptureResultExtras& resultExtras,
1708 const std::vector<PhysicalCaptureResultInfo>& physicalResultInfos) {
1709
1710 std::shared_ptr<CameraDevice> dev = mDevice.lock();
1711 if (dev == nullptr) {
1712 return ScopedAStatus::ok(); // device has been closed
1713 }
1714 int32_t sequenceId = resultExtras.requestId;
1715 int64_t frameNumber = resultExtras.frameNumber;
1716 int32_t burstId = resultExtras.burstId;
1717 bool isPartialResult = (resultExtras.partialResultCount < dev->mPartialResultCount);
1718
1719 if (!isPartialResult) {
1720 ALOGV("SeqId %d frame %" PRId64 " result arrive.", sequenceId, frameNumber);
1721 }
1722
1723 Mutex::Autolock _l(dev->mDeviceLock);
1724 if (dev->mRemote == nullptr) {
1725 return ScopedAStatus::ok(); // device has been disconnected
1726 }
1727
1728 if (dev->isClosed()) {
1729 if (!isPartialResult) {
1730 dev->mFrameNumberTracker.updateTracker(frameNumber, /*isError*/false);
1731 }
1732 // early return to avoid callback sent to closed devices
1733 return ScopedAStatus::ok();
1734 }
1735
1736 CameraMetadata metadataCopy;
1737 camera_status_t status = readOneResultMetadata(resultMetadata,
1738 dev->mCaptureResultMetadataQueue.get(), &metadataCopy);
1739 if (status != ACAMERA_OK) {
1740 ALOGE("%s: result metadata couldn't be converted", __FUNCTION__);
1741 return ScopedAStatus::ok();
1742 }
1743
1744 metadataCopy.update(ANDROID_LENS_INFO_SHADING_MAP_SIZE, dev->mShadingMapSize,
1745 /* data_count= */ 2);
1746 metadataCopy.update(ANDROID_SYNC_FRAME_NUMBER, &frameNumber, /* data_count= */1);
1747
1748 auto it = dev->mSequenceCallbackMap.find(sequenceId);
1749 if (it != dev->mSequenceCallbackMap.end()) {
1750 CallbackHolder cbh = (*it).second;
1751 sp<ACameraCaptureSession> session = cbh.mSession;
1752 if ((size_t) burstId >= cbh.mRequests.size()) {
1753 ALOGE("%s: Error: request index %d out of bound (size %zu)",
1754 __FUNCTION__, burstId, cbh.mRequests.size());
1755 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE);
1756 }
1757 sp<CaptureRequest> request = cbh.mRequests[burstId];
1758 sp<ACameraMetadata> result(new ACameraMetadata(
1759 metadataCopy.release(), ACameraMetadata::ACM_RESULT));
1760
1761 std::vector<PhysicalCaptureResultInfoLocal> localPhysicalResult;
1762 localPhysicalResult.resize(physicalResultInfos.size());
1763 for (size_t i = 0; i < physicalResultInfos.size(); i++) {
1764 localPhysicalResult[i].physicalCameraId = physicalResultInfos[i].physicalCameraId;
1765 status = readOneResultMetadata(physicalResultInfos[i].physicalCameraMetadata,
1766 dev->mCaptureResultMetadataQueue.get(),
1767 &localPhysicalResult[i].physicalMetadata);
1768 if (status != ACAMERA_OK) {
1769 ALOGE("%s: physical camera result metadata couldn't be converted", __FUNCTION__);
1770 return ScopedAStatus::ok();
1771 }
1772 }
1773 sp<ACameraPhysicalCaptureResultInfo> physicalResult(
1774 new ACameraPhysicalCaptureResultInfo(localPhysicalResult, frameNumber));
1775
1776 sp<AMessage> msg = new AMessage(
1777 cbh.mIsLogicalCameraCallback ? kWhatLogicalCaptureResult : kWhatCaptureResult,
1778 dev->mHandler);
1779 msg->setPointer(kContextKey, cbh.mContext);
1780 msg->setObject(kSessionSpKey, session);
1781 msg->setObject(kCaptureRequestKey, request);
1782 msg->setObject(kCaptureResultKey, result);
1783 if (isPartialResult) {
1784 msg->setPointer(kCallbackFpKey,
1785 (void *)cbh.mOnCaptureProgressed);
1786 } else if (cbh.mIsLogicalCameraCallback) {
1787 msg->setPointer(kCallbackFpKey,
1788 (void *)cbh.mOnLogicalCameraCaptureCompleted);
1789 msg->setObject(kPhysicalCaptureResultKey, physicalResult);
1790 } else {
1791 msg->setPointer(kCallbackFpKey,
1792 (void *)cbh.mOnCaptureCompleted);
1793 }
1794 dev->postSessionMsgAndCleanup(msg);
1795 }
1796
1797 if (!isPartialResult) {
1798 dev->mFrameNumberTracker.updateTracker(frameNumber, /*isError*/false);
1799 dev->checkAndFireSequenceCompleteLocked();
1800 }
1801
1802 return ScopedAStatus::ok();
1803 }
1804
onRepeatingRequestError(int64_t lastFrameNumber,int32_t stoppedSequenceId)1805 ScopedAStatus CameraDevice::ServiceCallback::onRepeatingRequestError(int64_t lastFrameNumber,
1806 int32_t stoppedSequenceId) {
1807 std::shared_ptr<CameraDevice> dev = mDevice.lock();
1808 if (dev == nullptr) {
1809 return ScopedAStatus::ok(); // device has been closed
1810 }
1811
1812 Mutex::Autolock _l(dev->mDeviceLock);
1813
1814 int repeatingSequenceId = dev->mRepeatingSequenceId;
1815 if (stoppedSequenceId == repeatingSequenceId) {
1816 dev->mRepeatingSequenceId = REQUEST_ID_NONE;
1817 }
1818
1819 dev->checkRepeatingSequenceCompleteLocked(repeatingSequenceId, lastFrameNumber);
1820
1821 return ScopedAStatus::ok();
1822 }
1823
onPrepared(int32_t streamId)1824 ScopedAStatus CameraDevice::ServiceCallback::onPrepared(int32_t streamId) {
1825 ALOGV("%s: callback for stream id %d", __FUNCTION__, streamId);
1826 std::shared_ptr<CameraDevice> dev = mDevice.lock();
1827 if (dev == nullptr) {
1828 return ScopedAStatus::ok();
1829 }
1830 Mutex::Autolock _l(dev->mDeviceLock);
1831 if (dev->isClosed() || dev->mRemote == nullptr) {
1832 return ScopedAStatus::ok();
1833 }
1834 auto it = dev->mConfiguredOutputs.find(streamId);
1835 if (it == dev->mConfiguredOutputs.end()) {
1836 ALOGE("%s: stream id %d does not exist", __FUNCTION__ , streamId);
1837 return ScopedAStatus::ok();
1838 }
1839 sp<ACameraCaptureSession> session = dev->mCurrentSession.promote();
1840 if (session == nullptr) {
1841 ALOGE("%s: Session is dead already", __FUNCTION__ );
1842 return ScopedAStatus::ok();
1843 }
1844 // We've found the window corresponding to the surface id.
1845 const native_handle_t *anw = it->second.first.mWindow;
1846 sp<AMessage> msg = new AMessage(kWhatPreparedCb, dev->mHandler);
1847 msg->setPointer(kContextKey, session->mPreparedCb.context);
1848 msg->setPointer(kAnwKey, (void *)anw);
1849 msg->setObject(kSessionSpKey, session);
1850 msg->setPointer(kCallbackFpKey, (void *)session->mPreparedCb.onWindowPrepared);
1851 dev->postSessionMsgAndCleanup(msg);
1852 return ScopedAStatus::ok();
1853 }
1854
readOneResultMetadata(const CaptureMetadataInfo & captureMetadataInfo,ResultMetadataQueue * metadataQueue,CameraMetadata * metadata)1855 camera_status_t CameraDevice::ServiceCallback::readOneResultMetadata(
1856 const CaptureMetadataInfo& captureMetadataInfo, ResultMetadataQueue* metadataQueue,
1857 CameraMetadata* metadata) {
1858 if (metadataQueue == nullptr || metadata == nullptr) {
1859 return ACAMERA_ERROR_INVALID_PARAMETER;
1860 }
1861 bool converted;
1862 AidlCameraMetadata aidlCameraMetadata;
1863 std::vector<uint8_t>& metadataVec = aidlCameraMetadata.metadata;
1864 camera_metadata_t* clonedMetadata;
1865 if (captureMetadataInfo.getTag() == CaptureMetadataInfo::fmqMetadataSize) {
1866 int64_t size = captureMetadataInfo.get<CaptureMetadataInfo::fmqMetadataSize>();
1867 metadataVec.resize(size);
1868 bool read = metadataQueue->read(reinterpret_cast<int8_t*>(metadataVec.data()), size);
1869 if (!read) {
1870 ALOGE("%s capture request settings could't be read from fmq", __FUNCTION__);
1871 return ACAMERA_ERROR_UNKNOWN;
1872 }
1873 // TODO: Do we actually need to clone here ?
1874 converted = utils::cloneFromAidl(aidlCameraMetadata, &clonedMetadata);
1875 } else {
1876 const AidlCameraMetadata &embeddedMetadata =
1877 captureMetadataInfo.get<CaptureMetadataInfo::metadata>();
1878 converted = utils::cloneFromAidl(embeddedMetadata, &clonedMetadata);
1879 }
1880
1881 if (converted) {
1882 *metadata = CameraMetadata(clonedMetadata);
1883 return ACAMERA_OK;
1884 }
1885
1886 return ACAMERA_ERROR_UNKNOWN;
1887 }
1888
1889 } // namespace acam
1890 } // namespace android
1891