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