1 /* 2 * Copyright (C) 2015 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 "ACameraDevice" 19 20 #include <vector> 21 #include <inttypes.h> 22 #include <android/hardware/ICameraService.h> 23 #include <camera2/SubmitInfo.h> 24 #include <gui/Surface.h> 25 #include "ACameraDevice.h" 26 #include "ACameraMetadata.h" 27 #include "ACaptureRequest.h" 28 #include "ACameraCaptureSession.h" 29 30 using namespace android; 31 32 namespace android { 33 // Static member definitions 34 const char* CameraDevice::kContextKey = "Context"; 35 const char* CameraDevice::kDeviceKey = "Device"; 36 const char* CameraDevice::kErrorCodeKey = "ErrorCode"; 37 const char* CameraDevice::kCallbackFpKey = "Callback"; 38 const char* CameraDevice::kSessionSpKey = "SessionSp"; 39 const char* CameraDevice::kCaptureRequestKey = "CaptureRequest"; 40 const char* CameraDevice::kTimeStampKey = "TimeStamp"; 41 const char* CameraDevice::kCaptureResultKey = "CaptureResult"; 42 const char* CameraDevice::kCaptureFailureKey = "CaptureFailure"; 43 const char* CameraDevice::kSequenceIdKey = "SequenceId"; 44 const char* CameraDevice::kFrameNumberKey = "FrameNumber"; 45 const char* CameraDevice::kAnwKey = "Anw"; 46 47 /** 48 * CameraDevice Implementation 49 */ 50 CameraDevice::CameraDevice( 51 const char* id, 52 ACameraDevice_StateCallbacks* cb, 53 std::unique_ptr<ACameraMetadata> chars, 54 ACameraDevice* wrapper) : 55 mCameraId(id), 56 mAppCallbacks(*cb), 57 mChars(std::move(chars)), 58 mServiceCallback(new ServiceCallback(this)), 59 mWrapper(wrapper), 60 mInError(false), 61 mError(ACAMERA_OK), 62 mIdle(true) { 63 mClosing = false; 64 // Setup looper thread to perfrom device callbacks to app 65 mCbLooper = new ALooper; 66 mCbLooper->setName("C2N-dev-looper"); 67 status_t err = mCbLooper->start( 68 /*runOnCallingThread*/false, 69 /*canCallJava*/ true, 70 PRIORITY_DEFAULT); 71 if (err != OK) { 72 ALOGE("%s: Unable to start camera device callback looper: %s (%d)", 73 __FUNCTION__, strerror(-err), err); 74 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE); 75 } 76 mHandler = new CallbackHandler(); 77 mCbLooper->registerHandler(mHandler); 78 79 const CameraMetadata& metadata = mChars->getInternalData(); 80 camera_metadata_ro_entry entry = metadata.find(ANDROID_REQUEST_PARTIAL_RESULT_COUNT); 81 if (entry.count != 1) { 82 ALOGW("%s: bad count %zu for partial result count", __FUNCTION__, entry.count); 83 mPartialResultCount = 1; 84 } else { 85 mPartialResultCount = entry.data.i32[0]; 86 } 87 88 entry = metadata.find(ANDROID_LENS_INFO_SHADING_MAP_SIZE); 89 if (entry.count != 2) { 90 ALOGW("%s: bad count %zu for shading map size", __FUNCTION__, entry.count); 91 mShadingMapSize[0] = 0; 92 mShadingMapSize[1] = 0; 93 } else { 94 mShadingMapSize[0] = entry.data.i32[0]; 95 mShadingMapSize[1] = entry.data.i32[1]; 96 } 97 } 98 99 // Device close implementaiton 100 CameraDevice::~CameraDevice() { 101 Mutex::Autolock _l(mDeviceLock); 102 if (!isClosed()) { 103 disconnectLocked(); 104 } 105 if (mCbLooper != nullptr) { 106 mCbLooper->unregisterHandler(mHandler->id()); 107 mCbLooper->stop(); 108 } 109 mCbLooper.clear(); 110 mHandler.clear(); 111 } 112 113 // TODO: cached created request? 114 camera_status_t 115 CameraDevice::createCaptureRequest( 116 ACameraDevice_request_template templateId, 117 ACaptureRequest** request) const { 118 Mutex::Autolock _l(mDeviceLock); 119 camera_status_t ret = checkCameraClosedOrErrorLocked(); 120 if (ret != ACAMERA_OK) { 121 return ret; 122 } 123 if (mRemote == nullptr) { 124 return ACAMERA_ERROR_CAMERA_DISCONNECTED; 125 } 126 CameraMetadata rawRequest; 127 binder::Status remoteRet = mRemote->createDefaultRequest(templateId, &rawRequest); 128 if (remoteRet.serviceSpecificErrorCode() == 129 hardware::ICameraService::ERROR_ILLEGAL_ARGUMENT) { 130 ALOGW("Create capture request failed! template %d is not supported on this device", 131 templateId); 132 return ACAMERA_ERROR_INVALID_PARAMETER; 133 } else if (!remoteRet.isOk()) { 134 ALOGE("Create capture request failed: %s", remoteRet.toString8().string()); 135 return ACAMERA_ERROR_UNKNOWN; 136 } 137 ACaptureRequest* outReq = new ACaptureRequest(); 138 outReq->settings = new ACameraMetadata(rawRequest.release(), ACameraMetadata::ACM_REQUEST); 139 outReq->targets = new ACameraOutputTargets(); 140 *request = outReq; 141 return ACAMERA_OK; 142 } 143 144 camera_status_t 145 CameraDevice::createCaptureSession( 146 const ACaptureSessionOutputContainer* outputs, 147 const ACameraCaptureSession_stateCallbacks* callbacks, 148 /*out*/ACameraCaptureSession** session) { 149 Mutex::Autolock _l(mDeviceLock); 150 camera_status_t ret = checkCameraClosedOrErrorLocked(); 151 if (ret != ACAMERA_OK) { 152 return ret; 153 } 154 155 if (mCurrentSession != nullptr) { 156 mCurrentSession->closeByDevice(); 157 stopRepeatingLocked(); 158 } 159 160 // Create new session 161 ret = configureStreamsLocked(outputs); 162 if (ret != ACAMERA_OK) { 163 ALOGE("Fail to create new session. cannot configure streams"); 164 return ret; 165 } 166 167 ACameraCaptureSession* newSession = new ACameraCaptureSession( 168 mNextSessionId++, outputs, callbacks, this); 169 170 // set new session as current session 171 newSession->incStrong((void *) ACameraDevice_createCaptureSession); 172 mCurrentSession = newSession; 173 mFlushing = false; 174 *session = newSession; 175 return ACAMERA_OK; 176 } 177 178 camera_status_t 179 CameraDevice::captureLocked( 180 sp<ACameraCaptureSession> session, 181 /*optional*/ACameraCaptureSession_captureCallbacks* cbs, 182 int numRequests, ACaptureRequest** requests, 183 /*optional*/int* captureSequenceId) { 184 return submitRequestsLocked( 185 session, cbs, numRequests, requests, captureSequenceId, /*isRepeating*/false); 186 } 187 188 camera_status_t 189 CameraDevice::setRepeatingRequestsLocked( 190 sp<ACameraCaptureSession> session, 191 /*optional*/ACameraCaptureSession_captureCallbacks* cbs, 192 int numRequests, ACaptureRequest** requests, 193 /*optional*/int* captureSequenceId) { 194 return submitRequestsLocked( 195 session, cbs, numRequests, requests, captureSequenceId, /*isRepeating*/true); 196 } 197 198 camera_status_t 199 CameraDevice::submitRequestsLocked( 200 sp<ACameraCaptureSession> session, 201 /*optional*/ACameraCaptureSession_captureCallbacks* cbs, 202 int numRequests, ACaptureRequest** requests, 203 /*optional*/int* captureSequenceId, 204 bool isRepeating) { 205 camera_status_t ret = checkCameraClosedOrErrorLocked(); 206 if (ret != ACAMERA_OK) { 207 ALOGE("Camera %s submit capture request failed! ret %d", getId(), ret); 208 return ret; 209 } 210 211 // Form two vectors of capture request, one for internal tracking 212 std::vector<hardware::camera2::CaptureRequest> requestList; 213 Vector<sp<CaptureRequest> > requestsV; 214 requestsV.setCapacity(numRequests); 215 for (int i = 0; i < numRequests; i++) { 216 sp<CaptureRequest> req; 217 ret = allocateCaptureRequest(requests[i], req); 218 if (ret != ACAMERA_OK) { 219 ALOGE("Convert capture request to internal format failure! ret %d", ret); 220 return ret; 221 } 222 if (req->mSurfaceList.empty()) { 223 ALOGE("Capture request without output target cannot be submitted!"); 224 return ACAMERA_ERROR_INVALID_PARAMETER; 225 } 226 requestList.push_back(*(req.get())); 227 requestsV.push_back(req); 228 } 229 230 if (isRepeating) { 231 ret = stopRepeatingLocked(); 232 if (ret != ACAMERA_OK) { 233 ALOGE("Camera %s stop repeating failed! ret %d", getId(), ret); 234 return ret; 235 } 236 } 237 238 binder::Status remoteRet; 239 hardware::camera2::utils::SubmitInfo info; 240 remoteRet = mRemote->submitRequestList(requestList, isRepeating, &info); 241 int sequenceId = info.mRequestId; 242 int64_t lastFrameNumber = info.mLastFrameNumber; 243 if (sequenceId < 0) { 244 ALOGE("Camera %s submit request remote failure: ret %d", getId(), sequenceId); 245 return ACAMERA_ERROR_UNKNOWN; 246 } 247 248 CallbackHolder cbHolder(session, requestsV, isRepeating, cbs); 249 mSequenceCallbackMap.insert(std::make_pair(sequenceId, cbHolder)); 250 251 if (isRepeating) { 252 // stopRepeating above should have cleanup repeating sequence id 253 if (mRepeatingSequenceId != REQUEST_ID_NONE) { 254 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE); 255 return ACAMERA_ERROR_CAMERA_DEVICE; 256 } 257 mRepeatingSequenceId = sequenceId; 258 } else { 259 mSequenceLastFrameNumberMap.insert(std::make_pair(sequenceId, lastFrameNumber)); 260 } 261 262 if (mIdle) { 263 sp<AMessage> msg = new AMessage(kWhatSessionStateCb, mHandler); 264 msg->setPointer(kContextKey, session->mUserSessionCallback.context); 265 msg->setObject(kSessionSpKey, session); 266 msg->setPointer(kCallbackFpKey, (void*) session->mUserSessionCallback.onActive); 267 msg->post(); 268 } 269 mIdle = false; 270 mBusySession = session; 271 272 if (captureSequenceId) { 273 *captureSequenceId = sequenceId; 274 } 275 return ACAMERA_OK; 276 } 277 278 camera_status_t 279 CameraDevice::allocateCaptureRequest( 280 const ACaptureRequest* request, /*out*/sp<CaptureRequest>& outReq) { 281 camera_status_t ret; 282 sp<CaptureRequest> req(new CaptureRequest()); 283 req->mMetadata = request->settings->getInternalData(); 284 req->mIsReprocess = false; // NDK does not support reprocessing yet 285 286 for (auto outputTarget : request->targets->mOutputs) { 287 ANativeWindow* anw = outputTarget.mWindow; 288 sp<Surface> surface; 289 ret = getSurfaceFromANativeWindow(anw, surface); 290 if (ret != ACAMERA_OK) { 291 ALOGE("Bad output target in capture request! ret %d", ret); 292 return ret; 293 } 294 req->mSurfaceList.push_back(surface); 295 } 296 outReq = req; 297 return ACAMERA_OK; 298 } 299 300 ACaptureRequest* 301 CameraDevice::allocateACaptureRequest(sp<CaptureRequest>& req) { 302 ACaptureRequest* pRequest = new ACaptureRequest(); 303 CameraMetadata clone = req->mMetadata; 304 pRequest->settings = new ACameraMetadata(clone.release(), ACameraMetadata::ACM_REQUEST); 305 pRequest->targets = new ACameraOutputTargets(); 306 for (size_t i = 0; i < req->mSurfaceList.size(); i++) { 307 ANativeWindow* anw = static_cast<ANativeWindow*>(req->mSurfaceList[i].get()); 308 ACameraOutputTarget outputTarget(anw); 309 pRequest->targets->mOutputs.insert(outputTarget); 310 } 311 return pRequest; 312 } 313 314 void 315 CameraDevice::freeACaptureRequest(ACaptureRequest* req) { 316 if (req == nullptr) { 317 return; 318 } 319 delete req->settings; 320 delete req->targets; 321 delete req; 322 } 323 324 void 325 CameraDevice::notifySessionEndOfLifeLocked(ACameraCaptureSession* session) { 326 if (isClosed()) { 327 // Device is closing already. do nothing 328 return; 329 } 330 331 if (session != mCurrentSession) { 332 // Session has been replaced by other seesion or device is closed 333 return; 334 } 335 mCurrentSession = nullptr; 336 337 // Should not happen 338 if (!session->mIsClosed) { 339 ALOGE("Error: unclosed session %p reaches end of life!", session); 340 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE); 341 return; 342 } 343 344 // No new session, unconfigure now 345 camera_status_t ret = configureStreamsLocked(nullptr); 346 if (ret != ACAMERA_OK) { 347 ALOGE("Unconfigure stream failed. Device might still be configured! ret %d", ret); 348 } 349 } 350 351 void 352 CameraDevice::disconnectLocked() { 353 if (mClosing.exchange(true)) { 354 // Already closing, just return 355 ALOGW("Camera device %s is already closing.", getId()); 356 return; 357 } 358 359 if (mRemote != nullptr) { 360 mRemote->disconnect(); 361 } 362 mRemote = nullptr; 363 364 if (mCurrentSession != nullptr) { 365 mCurrentSession->closeByDevice(); 366 mCurrentSession = nullptr; 367 } 368 } 369 370 camera_status_t 371 CameraDevice::stopRepeatingLocked() { 372 camera_status_t ret = checkCameraClosedOrErrorLocked(); 373 if (ret != ACAMERA_OK) { 374 ALOGE("Camera %s stop repeating failed! ret %d", getId(), ret); 375 return ret; 376 } 377 if (mRepeatingSequenceId != REQUEST_ID_NONE) { 378 int repeatingSequenceId = mRepeatingSequenceId; 379 mRepeatingSequenceId = REQUEST_ID_NONE; 380 381 int64_t lastFrameNumber; 382 binder::Status remoteRet = mRemote->cancelRequest(repeatingSequenceId, &lastFrameNumber); 383 if (remoteRet.serviceSpecificErrorCode() == 384 hardware::ICameraService::ERROR_ILLEGAL_ARGUMENT) { 385 ALOGV("Repeating request is already stopped."); 386 return ACAMERA_OK; 387 } else if (!remoteRet.isOk()) { 388 ALOGE("Stop repeating request fails in remote: %s", remoteRet.toString8().string()); 389 return ACAMERA_ERROR_UNKNOWN; 390 } 391 checkRepeatingSequenceCompleteLocked(repeatingSequenceId, lastFrameNumber); 392 } 393 return ACAMERA_OK; 394 } 395 396 camera_status_t 397 CameraDevice::flushLocked(ACameraCaptureSession* session) { 398 camera_status_t ret = checkCameraClosedOrErrorLocked(); 399 if (ret != ACAMERA_OK) { 400 ALOGE("Camera %s abort captures failed! ret %d", getId(), ret); 401 return ret; 402 } 403 404 // This should never happen because creating a new session will close 405 // previous one and thus reject any API call from previous session. 406 // But still good to check here in case something unexpected happen. 407 if (session != mCurrentSession) { 408 ALOGE("Camera %s session %p is not current active session!", getId(), session); 409 return ACAMERA_ERROR_INVALID_OPERATION; 410 } 411 412 if (mFlushing) { 413 ALOGW("Camera %s is already aborting captures", getId()); 414 return ACAMERA_OK; 415 } 416 417 mFlushing = true; 418 // Send onActive callback to guarantee there is always active->ready transition 419 sp<AMessage> msg = new AMessage(kWhatSessionStateCb, mHandler); 420 msg->setPointer(kContextKey, session->mUserSessionCallback.context); 421 msg->setObject(kSessionSpKey, session); 422 msg->setPointer(kCallbackFpKey, (void*) session->mUserSessionCallback.onActive); 423 msg->post(); 424 425 // If device is already idling, send callback and exit early 426 if (mIdle) { 427 sp<AMessage> msg = new AMessage(kWhatSessionStateCb, mHandler); 428 msg->setPointer(kContextKey, session->mUserSessionCallback.context); 429 msg->setObject(kSessionSpKey, session); 430 msg->setPointer(kCallbackFpKey, (void*) session->mUserSessionCallback.onReady); 431 msg->post(); 432 mFlushing = false; 433 return ACAMERA_OK; 434 } 435 436 int64_t lastFrameNumber; 437 binder::Status remoteRet = mRemote->flush(&lastFrameNumber); 438 if (!remoteRet.isOk()) { 439 ALOGE("Abort captures fails in remote: %s", remoteRet.toString8().string()); 440 return ACAMERA_ERROR_UNKNOWN; 441 } 442 if (mRepeatingSequenceId != REQUEST_ID_NONE) { 443 checkRepeatingSequenceCompleteLocked(mRepeatingSequenceId, lastFrameNumber); 444 } 445 return ACAMERA_OK; 446 } 447 448 camera_status_t 449 CameraDevice::waitUntilIdleLocked() { 450 camera_status_t ret = checkCameraClosedOrErrorLocked(); 451 if (ret != ACAMERA_OK) { 452 ALOGE("Wait until camera %s idle failed! ret %d", getId(), ret); 453 return ret; 454 } 455 456 if (mRepeatingSequenceId != REQUEST_ID_NONE) { 457 ALOGE("Camera device %s won't go to idle when there is repeating request!", getId()); 458 return ACAMERA_ERROR_INVALID_OPERATION; 459 } 460 461 binder::Status remoteRet = mRemote->waitUntilIdle(); 462 if (!remoteRet.isOk()) { 463 ALOGE("Camera device %s waitUntilIdle failed: %s", getId(), remoteRet.toString8().string()); 464 // TODO: define a function to convert status_t -> camera_status_t 465 return ACAMERA_ERROR_UNKNOWN; 466 } 467 468 return ACAMERA_OK; 469 } 470 471 camera_status_t 472 CameraDevice::getIGBPfromAnw( 473 ANativeWindow* anw, 474 sp<IGraphicBufferProducer>& out) { 475 if (anw == nullptr) { 476 ALOGE("Error: output ANativeWindow is null"); 477 return ACAMERA_ERROR_INVALID_PARAMETER; 478 } 479 int value; 480 int err = (*anw->query)(anw, NATIVE_WINDOW_CONCRETE_TYPE, &value); 481 if (err != OK || value != NATIVE_WINDOW_SURFACE) { 482 ALOGE("Error: ANativeWindow is not backed by Surface!"); 483 return ACAMERA_ERROR_INVALID_PARAMETER; 484 } 485 const sp<Surface> surface(static_cast<Surface*>(anw)); 486 out = surface->getIGraphicBufferProducer(); 487 return ACAMERA_OK; 488 } 489 490 camera_status_t 491 CameraDevice::getSurfaceFromANativeWindow( 492 ANativeWindow* anw, sp<Surface>& out) { 493 if (anw == nullptr) { 494 ALOGE("Error: output ANativeWindow is null"); 495 return ACAMERA_ERROR_INVALID_PARAMETER; 496 } 497 int value; 498 int err = (*anw->query)(anw, NATIVE_WINDOW_CONCRETE_TYPE, &value); 499 if (err != OK || value != NATIVE_WINDOW_SURFACE) { 500 ALOGE("Error: ANativeWindow is not backed by Surface!"); 501 return ACAMERA_ERROR_INVALID_PARAMETER; 502 } 503 sp<Surface> surface(static_cast<Surface*>(anw)); 504 out = surface; 505 return ACAMERA_OK; 506 } 507 508 camera_status_t 509 CameraDevice::configureStreamsLocked(const ACaptureSessionOutputContainer* outputs) { 510 ACaptureSessionOutputContainer emptyOutput; 511 if (outputs == nullptr) { 512 outputs = &emptyOutput; 513 } 514 515 camera_status_t ret = checkCameraClosedOrErrorLocked(); 516 if (ret != ACAMERA_OK) { 517 return ret; 518 } 519 520 std::set<std::pair<ANativeWindow*, OutputConfiguration>> outputSet; 521 for (auto outConfig : outputs->mOutputs) { 522 ANativeWindow* anw = outConfig.mWindow; 523 sp<IGraphicBufferProducer> iGBP(nullptr); 524 ret = getIGBPfromAnw(anw, iGBP); 525 if (ret != ACAMERA_OK) { 526 return ret; 527 } 528 outputSet.insert(std::make_pair( 529 anw, OutputConfiguration(iGBP, outConfig.mRotation))); 530 } 531 auto addSet = outputSet; 532 std::vector<int> deleteList; 533 534 // Determine which streams need to be created, which to be deleted 535 for (auto& kvPair : mConfiguredOutputs) { 536 int streamId = kvPair.first; 537 auto& outputPair = kvPair.second; 538 if (outputSet.count(outputPair) == 0) { 539 deleteList.push_back(streamId); // Need to delete a no longer needed stream 540 } else { 541 addSet.erase(outputPair); // No need to add already existing stream 542 } 543 } 544 545 ret = stopRepeatingLocked(); 546 if (ret != ACAMERA_OK) { 547 ALOGE("Camera device %s stop repeating failed, ret %d", getId(), ret); 548 return ret; 549 } 550 551 ret = waitUntilIdleLocked(); 552 if (ret != ACAMERA_OK) { 553 ALOGE("Camera device %s wait until idle failed, ret %d", getId(), ret); 554 return ret; 555 } 556 557 // Send onReady to previous session 558 // CurrentSession will be updated after configureStreamLocked, so here 559 // mCurrentSession is the session to be replaced by a new session 560 if (!mIdle && mCurrentSession != nullptr) { 561 if (mBusySession != mCurrentSession) { 562 ALOGE("Current session != busy session"); 563 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE); 564 return ACAMERA_ERROR_CAMERA_DEVICE; 565 } 566 sp<AMessage> msg = new AMessage(kWhatSessionStateCb, mHandler); 567 msg->setPointer(kContextKey, mBusySession->mUserSessionCallback.context); 568 msg->setObject(kSessionSpKey, mBusySession); 569 msg->setPointer(kCallbackFpKey, (void*) mBusySession->mUserSessionCallback.onReady); 570 mBusySession.clear(); 571 msg->post(); 572 } 573 mIdle = true; 574 575 binder::Status remoteRet = mRemote->beginConfigure(); 576 if (!remoteRet.isOk()) { 577 ALOGE("Camera device %s begin configure failed: %s", getId(), remoteRet.toString8().string()); 578 return ACAMERA_ERROR_UNKNOWN; 579 } 580 581 // delete to-be-deleted streams 582 for (auto streamId : deleteList) { 583 remoteRet = mRemote->deleteStream(streamId); 584 if (!remoteRet.isOk()) { 585 ALOGE("Camera device %s failed to remove stream %d: %s", getId(), streamId, 586 remoteRet.toString8().string()); 587 return ACAMERA_ERROR_UNKNOWN; 588 } 589 mConfiguredOutputs.erase(streamId); 590 } 591 592 // add new streams 593 for (auto outputPair : addSet) { 594 int streamId; 595 remoteRet = mRemote->createStream(outputPair.second, &streamId); 596 if (!remoteRet.isOk()) { 597 ALOGE("Camera device %s failed to create stream: %s", getId(), 598 remoteRet.toString8().string()); 599 return ACAMERA_ERROR_UNKNOWN; 600 } 601 mConfiguredOutputs.insert(std::make_pair(streamId, outputPair)); 602 } 603 604 remoteRet = mRemote->endConfigure(/*isConstrainedHighSpeed*/ false); 605 if (remoteRet.serviceSpecificErrorCode() == hardware::ICameraService::ERROR_ILLEGAL_ARGUMENT) { 606 ALOGE("Camera device %s cannnot support app output configuration: %s", getId(), 607 remoteRet.toString8().string()); 608 return ACAMERA_ERROR_STREAM_CONFIGURE_FAIL; 609 } else if (!remoteRet.isOk()) { 610 ALOGE("Camera device %s end configure failed: %s", getId(), remoteRet.toString8().string()); 611 return ACAMERA_ERROR_UNKNOWN; 612 } 613 614 return ACAMERA_OK; 615 } 616 617 void 618 CameraDevice::setRemoteDevice(sp<hardware::camera2::ICameraDeviceUser> remote) { 619 Mutex::Autolock _l(mDeviceLock); 620 mRemote = remote; 621 } 622 623 camera_status_t 624 CameraDevice::checkCameraClosedOrErrorLocked() const { 625 if (mRemote == nullptr) { 626 ALOGE("%s: camera device already closed", __FUNCTION__); 627 return ACAMERA_ERROR_CAMERA_DISCONNECTED; 628 } 629 if (mInError) {// triggered by onDeviceError 630 ALOGE("%s: camera device has encountered a serious error", __FUNCTION__); 631 return mError; 632 } 633 return ACAMERA_OK; 634 } 635 636 void 637 CameraDevice::setCameraDeviceErrorLocked(camera_status_t error) { 638 mInError = true; 639 mError = error; 640 return; 641 } 642 643 void 644 CameraDevice::FrameNumberTracker::updateTracker(int64_t frameNumber, bool isError) { 645 ALOGV("updateTracker frame %" PRId64 " isError %d", frameNumber, isError); 646 if (isError) { 647 mFutureErrorSet.insert(frameNumber); 648 } else if (frameNumber <= mCompletedFrameNumber) { 649 ALOGE("Frame number %" PRId64 " decreased! current fn %" PRId64, 650 frameNumber, mCompletedFrameNumber); 651 return; 652 } else { 653 if (frameNumber != mCompletedFrameNumber + 1) { 654 ALOGE("Frame number out of order. Expect %" PRId64 " but get %" PRId64, 655 mCompletedFrameNumber + 1, frameNumber); 656 // Do not assert as in java implementation 657 } 658 mCompletedFrameNumber = frameNumber; 659 } 660 update(); 661 } 662 663 void 664 CameraDevice::FrameNumberTracker::update() { 665 for (auto it = mFutureErrorSet.begin(); it != mFutureErrorSet.end();) { 666 int64_t errorFrameNumber = *it; 667 if (errorFrameNumber == mCompletedFrameNumber + 1) { 668 mCompletedFrameNumber++; 669 it = mFutureErrorSet.erase(it); 670 } else if (errorFrameNumber <= mCompletedFrameNumber) { 671 // This should not happen, but deal with it anyway 672 ALOGE("Completd frame number passed through current frame number!"); 673 // erase the old error since it's no longer useful 674 it = mFutureErrorSet.erase(it); 675 } else { 676 // Normal requests hasn't catched up error frames, just break 677 break; 678 } 679 } 680 ALOGV("Update complete frame %" PRId64, mCompletedFrameNumber); 681 } 682 683 void 684 CameraDevice::onCaptureErrorLocked( 685 int32_t errorCode, 686 const CaptureResultExtras& resultExtras) { 687 int sequenceId = resultExtras.requestId; 688 int64_t frameNumber = resultExtras.frameNumber; 689 int32_t burstId = resultExtras.burstId; 690 auto it = mSequenceCallbackMap.find(sequenceId); 691 if (it == mSequenceCallbackMap.end()) { 692 ALOGE("%s: Error: capture sequence index %d not found!", 693 __FUNCTION__, sequenceId); 694 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE); 695 return; 696 } 697 698 CallbackHolder cbh = (*it).second; 699 sp<ACameraCaptureSession> session = cbh.mSession; 700 if ((size_t) burstId >= cbh.mRequests.size()) { 701 ALOGE("%s: Error: request index %d out of bound (size %zu)", 702 __FUNCTION__, burstId, cbh.mRequests.size()); 703 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE); 704 return; 705 } 706 sp<CaptureRequest> request = cbh.mRequests[burstId]; 707 708 // Handle buffer error 709 if (errorCode == hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER) { 710 int32_t streamId = resultExtras.errorStreamId; 711 ACameraCaptureSession_captureCallback_bufferLost onBufferLost = 712 cbh.mCallbacks.onCaptureBufferLost; 713 auto outputPairIt = mConfiguredOutputs.find(streamId); 714 if (outputPairIt == mConfiguredOutputs.end()) { 715 ALOGE("%s: Error: stream id %d does not exist", __FUNCTION__, streamId); 716 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE); 717 return; 718 } 719 ANativeWindow* anw = outputPairIt->second.first; 720 721 ALOGV("Camera %s Lost output buffer for ANW %p frame %" PRId64, 722 getId(), anw, frameNumber); 723 724 sp<AMessage> msg = new AMessage(kWhatCaptureBufferLost, mHandler); 725 msg->setPointer(kContextKey, cbh.mCallbacks.context); 726 msg->setObject(kSessionSpKey, session); 727 msg->setPointer(kCallbackFpKey, (void*) onBufferLost); 728 msg->setObject(kCaptureRequestKey, request); 729 msg->setPointer(kAnwKey, (void*) anw); 730 msg->setInt64(kFrameNumberKey, frameNumber); 731 msg->post(); 732 } else { // Handle other capture failures 733 // Fire capture failure callback if there is one registered 734 ACameraCaptureSession_captureCallback_failed onError = cbh.mCallbacks.onCaptureFailed; 735 sp<CameraCaptureFailure> failure(new CameraCaptureFailure()); 736 failure->frameNumber = frameNumber; 737 // TODO: refine this when implementing flush 738 failure->reason = CAPTURE_FAILURE_REASON_ERROR; 739 failure->sequenceId = sequenceId; 740 failure->wasImageCaptured = (errorCode == 741 hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT); 742 743 sp<AMessage> msg = new AMessage(kWhatCaptureFail, mHandler); 744 msg->setPointer(kContextKey, cbh.mCallbacks.context); 745 msg->setObject(kSessionSpKey, session); 746 msg->setPointer(kCallbackFpKey, (void*) onError); 747 msg->setObject(kCaptureRequestKey, request); 748 msg->setObject(kCaptureFailureKey, failure); 749 msg->post(); 750 751 // Update tracker 752 mFrameNumberTracker.updateTracker(frameNumber, /*isError*/true); 753 checkAndFireSequenceCompleteLocked(); 754 } 755 return; 756 } 757 758 void CameraDevice::CallbackHandler::onMessageReceived( 759 const sp<AMessage> &msg) { 760 switch (msg->what()) { 761 case kWhatOnDisconnected: 762 case kWhatOnError: 763 case kWhatSessionStateCb: 764 case kWhatCaptureStart: 765 case kWhatCaptureResult: 766 case kWhatCaptureFail: 767 case kWhatCaptureSeqEnd: 768 case kWhatCaptureSeqAbort: 769 case kWhatCaptureBufferLost: 770 ALOGV("%s: Received msg %d", __FUNCTION__, msg->what()); 771 break; 772 default: 773 ALOGE("%s:Error: unknown device callback %d", __FUNCTION__, msg->what()); 774 return; 775 } 776 // Check the common part of all message 777 void* context; 778 bool found = msg->findPointer(kContextKey, &context); 779 if (!found) { 780 ALOGE("%s: Cannot find callback context!", __FUNCTION__); 781 return; 782 } 783 switch (msg->what()) { 784 case kWhatOnDisconnected: 785 { 786 ACameraDevice* dev; 787 found = msg->findPointer(kDeviceKey, (void**) &dev); 788 if (!found || dev == nullptr) { 789 ALOGE("%s: Cannot find device pointer!", __FUNCTION__); 790 return; 791 } 792 ACameraDevice_StateCallback onDisconnected; 793 found = msg->findPointer(kCallbackFpKey, (void**) &onDisconnected); 794 if (!found) { 795 ALOGE("%s: Cannot find onDisconnected!", __FUNCTION__); 796 return; 797 } 798 if (onDisconnected == nullptr) { 799 return; 800 } 801 (*onDisconnected)(context, dev); 802 break; 803 } 804 case kWhatOnError: 805 { 806 ACameraDevice* dev; 807 found = msg->findPointer(kDeviceKey, (void**) &dev); 808 if (!found || dev == nullptr) { 809 ALOGE("%s: Cannot find device pointer!", __FUNCTION__); 810 return; 811 } 812 ACameraDevice_ErrorStateCallback onError; 813 found = msg->findPointer(kCallbackFpKey, (void**) &onError); 814 if (!found) { 815 ALOGE("%s: Cannot find onError!", __FUNCTION__); 816 return; 817 } 818 int errorCode; 819 found = msg->findInt32(kErrorCodeKey, &errorCode); 820 if (!found) { 821 ALOGE("%s: Cannot find error code!", __FUNCTION__); 822 return; 823 } 824 if (onError == nullptr) { 825 return; 826 } 827 (*onError)(context, dev, errorCode); 828 break; 829 } 830 case kWhatSessionStateCb: 831 case kWhatCaptureStart: 832 case kWhatCaptureResult: 833 case kWhatCaptureFail: 834 case kWhatCaptureSeqEnd: 835 case kWhatCaptureSeqAbort: 836 case kWhatCaptureBufferLost: 837 { 838 sp<RefBase> obj; 839 found = msg->findObject(kSessionSpKey, &obj); 840 if (!found || obj == nullptr) { 841 ALOGE("%s: Cannot find session pointer!", __FUNCTION__); 842 return; 843 } 844 sp<ACameraCaptureSession> session(static_cast<ACameraCaptureSession*>(obj.get())); 845 sp<CaptureRequest> requestSp = nullptr; 846 switch (msg->what()) { 847 case kWhatCaptureStart: 848 case kWhatCaptureResult: 849 case kWhatCaptureFail: 850 case kWhatCaptureBufferLost: 851 found = msg->findObject(kCaptureRequestKey, &obj); 852 if (!found) { 853 ALOGE("%s: Cannot find capture request!", __FUNCTION__); 854 return; 855 } 856 requestSp = static_cast<CaptureRequest*>(obj.get()); 857 break; 858 } 859 860 switch (msg->what()) { 861 case kWhatSessionStateCb: 862 { 863 ACameraCaptureSession_stateCallback onState; 864 found = msg->findPointer(kCallbackFpKey, (void**) &onState); 865 if (!found) { 866 ALOGE("%s: Cannot find state callback!", __FUNCTION__); 867 return; 868 } 869 if (onState == nullptr) { 870 return; 871 } 872 (*onState)(context, session.get()); 873 break; 874 } 875 case kWhatCaptureStart: 876 { 877 ACameraCaptureSession_captureCallback_start onStart; 878 found = msg->findPointer(kCallbackFpKey, (void**) &onStart); 879 if (!found) { 880 ALOGE("%s: Cannot find capture start callback!", __FUNCTION__); 881 return; 882 } 883 if (onStart == nullptr) { 884 return; 885 } 886 int64_t timestamp; 887 found = msg->findInt64(kTimeStampKey, ×tamp); 888 if (!found) { 889 ALOGE("%s: Cannot find timestamp!", __FUNCTION__); 890 return; 891 } 892 ACaptureRequest* request = allocateACaptureRequest(requestSp); 893 (*onStart)(context, session.get(), request, timestamp); 894 freeACaptureRequest(request); 895 break; 896 } 897 case kWhatCaptureResult: 898 { 899 ACameraCaptureSession_captureCallback_result onResult; 900 found = msg->findPointer(kCallbackFpKey, (void**) &onResult); 901 if (!found) { 902 ALOGE("%s: Cannot find capture result callback!", __FUNCTION__); 903 return; 904 } 905 if (onResult == nullptr) { 906 return; 907 } 908 909 found = msg->findObject(kCaptureResultKey, &obj); 910 if (!found) { 911 ALOGE("%s: Cannot find capture result!", __FUNCTION__); 912 return; 913 } 914 sp<ACameraMetadata> result(static_cast<ACameraMetadata*>(obj.get())); 915 ACaptureRequest* request = allocateACaptureRequest(requestSp); 916 (*onResult)(context, session.get(), request, result.get()); 917 freeACaptureRequest(request); 918 break; 919 } 920 case kWhatCaptureFail: 921 { 922 ACameraCaptureSession_captureCallback_failed onFail; 923 found = msg->findPointer(kCallbackFpKey, (void**) &onFail); 924 if (!found) { 925 ALOGE("%s: Cannot find capture fail callback!", __FUNCTION__); 926 return; 927 } 928 if (onFail == nullptr) { 929 return; 930 } 931 932 found = msg->findObject(kCaptureFailureKey, &obj); 933 if (!found) { 934 ALOGE("%s: Cannot find capture failure!", __FUNCTION__); 935 return; 936 } 937 sp<CameraCaptureFailure> failureSp( 938 static_cast<CameraCaptureFailure*>(obj.get())); 939 ACameraCaptureFailure* failure = 940 static_cast<ACameraCaptureFailure*>(failureSp.get()); 941 ACaptureRequest* request = allocateACaptureRequest(requestSp); 942 (*onFail)(context, session.get(), request, failure); 943 freeACaptureRequest(request); 944 delete failure; 945 break; 946 } 947 case kWhatCaptureSeqEnd: 948 { 949 ACameraCaptureSession_captureCallback_sequenceEnd onSeqEnd; 950 found = msg->findPointer(kCallbackFpKey, (void**) &onSeqEnd); 951 if (!found) { 952 ALOGE("%s: Cannot find sequence end callback!", __FUNCTION__); 953 return; 954 } 955 if (onSeqEnd == nullptr) { 956 return; 957 } 958 int seqId; 959 found = msg->findInt32(kSequenceIdKey, &seqId); 960 if (!found) { 961 ALOGE("%s: Cannot find frame number!", __FUNCTION__); 962 return; 963 } 964 int64_t frameNumber; 965 found = msg->findInt64(kFrameNumberKey, &frameNumber); 966 if (!found) { 967 ALOGE("%s: Cannot find frame number!", __FUNCTION__); 968 return; 969 } 970 (*onSeqEnd)(context, session.get(), seqId, frameNumber); 971 break; 972 } 973 case kWhatCaptureSeqAbort: 974 { 975 ACameraCaptureSession_captureCallback_sequenceAbort onSeqAbort; 976 found = msg->findPointer(kCallbackFpKey, (void**) &onSeqAbort); 977 if (!found) { 978 ALOGE("%s: Cannot find sequence end callback!", __FUNCTION__); 979 return; 980 } 981 if (onSeqAbort == nullptr) { 982 return; 983 } 984 int seqId; 985 found = msg->findInt32(kSequenceIdKey, &seqId); 986 if (!found) { 987 ALOGE("%s: Cannot find frame number!", __FUNCTION__); 988 return; 989 } 990 (*onSeqAbort)(context, session.get(), seqId); 991 break; 992 } 993 case kWhatCaptureBufferLost: 994 { 995 ACameraCaptureSession_captureCallback_bufferLost onBufferLost; 996 found = msg->findPointer(kCallbackFpKey, (void**) &onBufferLost); 997 if (!found) { 998 ALOGE("%s: Cannot find buffer lost callback!", __FUNCTION__); 999 return; 1000 } 1001 if (onBufferLost == nullptr) { 1002 return; 1003 } 1004 1005 ANativeWindow* anw; 1006 found = msg->findPointer(kAnwKey, (void**) &anw); 1007 if (!found) { 1008 ALOGE("%s: Cannot find ANativeWindow!", __FUNCTION__); 1009 return; 1010 } 1011 1012 int64_t frameNumber; 1013 found = msg->findInt64(kFrameNumberKey, &frameNumber); 1014 if (!found) { 1015 ALOGE("%s: Cannot find frame number!", __FUNCTION__); 1016 return; 1017 } 1018 1019 ACaptureRequest* request = allocateACaptureRequest(requestSp); 1020 (*onBufferLost)(context, session.get(), request, anw, frameNumber); 1021 freeACaptureRequest(request); 1022 break; 1023 } 1024 } 1025 break; 1026 } 1027 } 1028 } 1029 1030 CameraDevice::CallbackHolder::CallbackHolder( 1031 sp<ACameraCaptureSession> session, 1032 const Vector<sp<CaptureRequest> >& requests, 1033 bool isRepeating, 1034 ACameraCaptureSession_captureCallbacks* cbs) : 1035 mSession(session), mRequests(requests), 1036 mIsRepeating(isRepeating), mCallbacks(fillCb(cbs)) {} 1037 1038 void 1039 CameraDevice::checkRepeatingSequenceCompleteLocked( 1040 const int sequenceId, const int64_t lastFrameNumber) { 1041 ALOGV("Repeating seqId %d lastFrameNumer %" PRId64, sequenceId, lastFrameNumber); 1042 if (lastFrameNumber == NO_FRAMES_CAPTURED) { 1043 if (mSequenceCallbackMap.count(sequenceId) == 0) { 1044 ALOGW("No callback found for sequenceId %d", sequenceId); 1045 return; 1046 } 1047 // remove callback holder from callback map 1048 auto cbIt = mSequenceCallbackMap.find(sequenceId); 1049 CallbackHolder cbh = cbIt->second; 1050 mSequenceCallbackMap.erase(cbIt); 1051 // send seq aborted callback 1052 sp<AMessage> msg = new AMessage(kWhatCaptureSeqAbort, mHandler); 1053 msg->setPointer(kContextKey, cbh.mCallbacks.context); 1054 msg->setObject(kSessionSpKey, cbh.mSession); 1055 msg->setPointer(kCallbackFpKey, (void*) cbh.mCallbacks.onCaptureSequenceAborted); 1056 msg->setInt32(kSequenceIdKey, sequenceId); 1057 msg->post(); 1058 } else { 1059 // Use mSequenceLastFrameNumberMap to track 1060 mSequenceLastFrameNumberMap.insert(std::make_pair(sequenceId, lastFrameNumber)); 1061 1062 // Last frame might have arrived. Check now 1063 checkAndFireSequenceCompleteLocked(); 1064 } 1065 } 1066 1067 void 1068 CameraDevice::checkAndFireSequenceCompleteLocked() { 1069 int64_t completedFrameNumber = mFrameNumberTracker.getCompletedFrameNumber(); 1070 //std::map<int, int64_t> mSequenceLastFrameNumberMap; 1071 auto it = mSequenceLastFrameNumberMap.begin(); 1072 while (it != mSequenceLastFrameNumberMap.end()) { 1073 int sequenceId = it->first; 1074 int64_t lastFrameNumber = it->second; 1075 bool seqCompleted = false; 1076 bool hasCallback = true; 1077 1078 if (mRemote == nullptr) { 1079 ALOGW("Camera %s closed while checking sequence complete", getId()); 1080 return; 1081 } 1082 1083 // Check if there is callback for this sequence 1084 // This should not happen because we always register callback (with nullptr inside) 1085 if (mSequenceCallbackMap.count(sequenceId) == 0) { 1086 ALOGW("No callback found for sequenceId %d", sequenceId); 1087 hasCallback = false; 1088 } 1089 1090 if (lastFrameNumber <= completedFrameNumber) { 1091 ALOGV("seq %d reached last frame %" PRId64 ", completed %" PRId64, 1092 sequenceId, lastFrameNumber, completedFrameNumber); 1093 seqCompleted = true; 1094 } 1095 1096 if (seqCompleted && hasCallback) { 1097 // remove callback holder from callback map 1098 auto cbIt = mSequenceCallbackMap.find(sequenceId); 1099 CallbackHolder cbh = cbIt->second; 1100 mSequenceCallbackMap.erase(cbIt); 1101 // send seq complete callback 1102 sp<AMessage> msg = new AMessage(kWhatCaptureSeqEnd, mHandler); 1103 msg->setPointer(kContextKey, cbh.mCallbacks.context); 1104 msg->setObject(kSessionSpKey, cbh.mSession); 1105 msg->setPointer(kCallbackFpKey, (void*) cbh.mCallbacks.onCaptureSequenceCompleted); 1106 msg->setInt32(kSequenceIdKey, sequenceId); 1107 msg->setInt64(kFrameNumberKey, lastFrameNumber); 1108 1109 // Clear the session sp before we send out the message 1110 // This will guarantee the rare case where the message is processed 1111 // before cbh goes out of scope and causing we call the session 1112 // destructor while holding device lock 1113 cbh.mSession.clear(); 1114 msg->post(); 1115 } 1116 1117 // No need to track sequence complete if there is no callback registered 1118 if (seqCompleted || !hasCallback) { 1119 it = mSequenceLastFrameNumberMap.erase(it); 1120 } else { 1121 ++it; 1122 } 1123 } 1124 } 1125 1126 /** 1127 * Camera service callback implementation 1128 */ 1129 binder::Status 1130 CameraDevice::ServiceCallback::onDeviceError( 1131 int32_t errorCode, 1132 const CaptureResultExtras& resultExtras) { 1133 ALOGD("Device error received, code %d, frame number %" PRId64 ", request ID %d, subseq ID %d", 1134 errorCode, resultExtras.frameNumber, resultExtras.requestId, resultExtras.burstId); 1135 binder::Status ret = binder::Status::ok(); 1136 sp<CameraDevice> dev = mDevice.promote(); 1137 if (dev == nullptr) { 1138 return ret; // device has been closed 1139 } 1140 1141 Mutex::Autolock _l(dev->mDeviceLock); 1142 if (dev->mRemote == nullptr) { 1143 return ret; // device has been closed 1144 } 1145 switch (errorCode) { 1146 case ERROR_CAMERA_DISCONNECTED: 1147 { 1148 // Camera is disconnected, close the session and expect no more callbacks 1149 if (dev->mCurrentSession != nullptr) { 1150 dev->mCurrentSession->closeByDevice(); 1151 dev->mCurrentSession = nullptr; 1152 } 1153 sp<AMessage> msg = new AMessage(kWhatOnDisconnected, dev->mHandler); 1154 msg->setPointer(kContextKey, dev->mAppCallbacks.context); 1155 msg->setPointer(kDeviceKey, (void*) dev->getWrapper()); 1156 msg->setPointer(kCallbackFpKey, (void*) dev->mAppCallbacks.onDisconnected); 1157 msg->post(); 1158 break; 1159 } 1160 default: 1161 ALOGE("Unknown error from camera device: %d", errorCode); 1162 // no break 1163 case ERROR_CAMERA_DEVICE: 1164 case ERROR_CAMERA_SERVICE: 1165 { 1166 switch (errorCode) { 1167 case ERROR_CAMERA_DEVICE: 1168 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE); 1169 break; 1170 case ERROR_CAMERA_SERVICE: 1171 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE); 1172 break; 1173 default: 1174 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_UNKNOWN); 1175 break; 1176 } 1177 sp<AMessage> msg = new AMessage(kWhatOnError, dev->mHandler); 1178 msg->setPointer(kContextKey, dev->mAppCallbacks.context); 1179 msg->setPointer(kDeviceKey, (void*) dev->getWrapper()); 1180 msg->setPointer(kCallbackFpKey, (void*) dev->mAppCallbacks.onError); 1181 msg->setInt32(kErrorCodeKey, errorCode); 1182 msg->post(); 1183 break; 1184 } 1185 case ERROR_CAMERA_REQUEST: 1186 case ERROR_CAMERA_RESULT: 1187 case ERROR_CAMERA_BUFFER: 1188 dev->onCaptureErrorLocked(errorCode, resultExtras); 1189 break; 1190 } 1191 return ret; 1192 } 1193 1194 binder::Status 1195 CameraDevice::ServiceCallback::onDeviceIdle() { 1196 ALOGV("Camera is now idle"); 1197 binder::Status ret = binder::Status::ok(); 1198 sp<CameraDevice> dev = mDevice.promote(); 1199 if (dev == nullptr) { 1200 return ret; // device has been closed 1201 } 1202 1203 Mutex::Autolock _l(dev->mDeviceLock); 1204 if (dev->isClosed() || dev->mRemote == nullptr) { 1205 return ret; 1206 } 1207 1208 if (dev->mIdle) { 1209 // Already in idle state. Possibly other thread did waitUntilIdle 1210 return ret; 1211 } 1212 1213 if (dev->mCurrentSession != nullptr) { 1214 ALOGE("onDeviceIdle sending state cb"); 1215 if (dev->mBusySession != dev->mCurrentSession) { 1216 ALOGE("Current session != busy session"); 1217 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE); 1218 return ret; 1219 } 1220 sp<AMessage> msg = new AMessage(kWhatSessionStateCb, dev->mHandler); 1221 msg->setPointer(kContextKey, dev->mBusySession->mUserSessionCallback.context); 1222 msg->setObject(kSessionSpKey, dev->mBusySession); 1223 msg->setPointer(kCallbackFpKey, (void*) dev->mBusySession->mUserSessionCallback.onReady); 1224 // Make sure we clear the sp first so the session destructor can 1225 // only happen on handler thread (where we don't hold device/session lock) 1226 dev->mBusySession.clear(); 1227 msg->post(); 1228 } 1229 dev->mIdle = true; 1230 dev->mFlushing = false; 1231 return ret; 1232 } 1233 1234 binder::Status 1235 CameraDevice::ServiceCallback::onCaptureStarted( 1236 const CaptureResultExtras& resultExtras, 1237 int64_t timestamp) { 1238 binder::Status ret = binder::Status::ok(); 1239 1240 sp<CameraDevice> dev = mDevice.promote(); 1241 if (dev == nullptr) { 1242 return ret; // device has been closed 1243 } 1244 Mutex::Autolock _l(dev->mDeviceLock); 1245 if (dev->isClosed() || dev->mRemote == nullptr) { 1246 return ret; 1247 } 1248 1249 int sequenceId = resultExtras.requestId; 1250 int32_t burstId = resultExtras.burstId; 1251 1252 auto it = dev->mSequenceCallbackMap.find(sequenceId); 1253 if (it != dev->mSequenceCallbackMap.end()) { 1254 CallbackHolder cbh = (*it).second; 1255 ACameraCaptureSession_captureCallback_start onStart = cbh.mCallbacks.onCaptureStarted; 1256 sp<ACameraCaptureSession> session = cbh.mSession; 1257 if ((size_t) burstId >= cbh.mRequests.size()) { 1258 ALOGE("%s: Error: request index %d out of bound (size %zu)", 1259 __FUNCTION__, burstId, cbh.mRequests.size()); 1260 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE); 1261 } 1262 sp<CaptureRequest> request = cbh.mRequests[burstId]; 1263 sp<AMessage> msg = new AMessage(kWhatCaptureStart, dev->mHandler); 1264 msg->setPointer(kContextKey, cbh.mCallbacks.context); 1265 msg->setObject(kSessionSpKey, session); 1266 msg->setPointer(kCallbackFpKey, (void*) onStart); 1267 msg->setObject(kCaptureRequestKey, request); 1268 msg->setInt64(kTimeStampKey, timestamp); 1269 msg->post(); 1270 } 1271 return ret; 1272 } 1273 1274 binder::Status 1275 CameraDevice::ServiceCallback::onResultReceived( 1276 const CameraMetadata& metadata, 1277 const CaptureResultExtras& resultExtras) { 1278 binder::Status ret = binder::Status::ok(); 1279 1280 sp<CameraDevice> dev = mDevice.promote(); 1281 if (dev == nullptr) { 1282 return ret; // device has been closed 1283 } 1284 int sequenceId = resultExtras.requestId; 1285 int64_t frameNumber = resultExtras.frameNumber; 1286 int32_t burstId = resultExtras.burstId; 1287 bool isPartialResult = (resultExtras.partialResultCount < dev->mPartialResultCount); 1288 1289 if (!isPartialResult) { 1290 ALOGV("SeqId %d frame %" PRId64 " result arrive.", sequenceId, frameNumber); 1291 } 1292 1293 Mutex::Autolock _l(dev->mDeviceLock); 1294 if (dev->mRemote == nullptr) { 1295 return ret; // device has been disconnected 1296 } 1297 1298 if (dev->isClosed()) { 1299 if (!isPartialResult) { 1300 dev->mFrameNumberTracker.updateTracker(frameNumber, /*isError*/false); 1301 } 1302 // early return to avoid callback sent to closed devices 1303 return ret; 1304 } 1305 1306 CameraMetadata metadataCopy = metadata; 1307 metadataCopy.update(ANDROID_LENS_INFO_SHADING_MAP_SIZE, dev->mShadingMapSize, /*data_count*/2); 1308 metadataCopy.update(ANDROID_SYNC_FRAME_NUMBER, &frameNumber, /*data_count*/1); 1309 1310 auto it = dev->mSequenceCallbackMap.find(sequenceId); 1311 if (it != dev->mSequenceCallbackMap.end()) { 1312 CallbackHolder cbh = (*it).second; 1313 ACameraCaptureSession_captureCallback_result onResult = isPartialResult ? 1314 cbh.mCallbacks.onCaptureProgressed : 1315 cbh.mCallbacks.onCaptureCompleted; 1316 sp<ACameraCaptureSession> session = cbh.mSession; 1317 if ((size_t) burstId >= cbh.mRequests.size()) { 1318 ALOGE("%s: Error: request index %d out of bound (size %zu)", 1319 __FUNCTION__, burstId, cbh.mRequests.size()); 1320 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE); 1321 } 1322 sp<CaptureRequest> request = cbh.mRequests[burstId]; 1323 sp<ACameraMetadata> result(new ACameraMetadata( 1324 metadataCopy.release(), ACameraMetadata::ACM_RESULT)); 1325 1326 sp<AMessage> msg = new AMessage(kWhatCaptureResult, dev->mHandler); 1327 msg->setPointer(kContextKey, cbh.mCallbacks.context); 1328 msg->setObject(kSessionSpKey, session); 1329 msg->setPointer(kCallbackFpKey, (void*) onResult); 1330 msg->setObject(kCaptureRequestKey, request); 1331 msg->setObject(kCaptureResultKey, result); 1332 msg->post(); 1333 } 1334 1335 if (!isPartialResult) { 1336 dev->mFrameNumberTracker.updateTracker(frameNumber, /*isError*/false); 1337 dev->checkAndFireSequenceCompleteLocked(); 1338 } 1339 1340 return ret; 1341 } 1342 1343 binder::Status 1344 CameraDevice::ServiceCallback::onPrepared(int) { 1345 // Prepare not yet implemented in NDK 1346 return binder::Status::ok(); 1347 } 1348 1349 binder::Status 1350 CameraDevice::ServiceCallback::onRepeatingRequestError(int64_t lastFrameNumber) { 1351 binder::Status ret = binder::Status::ok(); 1352 1353 sp<CameraDevice> dev = mDevice.promote(); 1354 if (dev == nullptr) { 1355 return ret; // device has been closed 1356 } 1357 1358 Mutex::Autolock _l(dev->mDeviceLock); 1359 1360 int repeatingSequenceId = dev->mRepeatingSequenceId; 1361 dev->mRepeatingSequenceId = REQUEST_ID_NONE; 1362 1363 dev->checkRepeatingSequenceCompleteLocked(repeatingSequenceId, lastFrameNumber); 1364 1365 return ret; 1366 } 1367 1368 1369 } // namespace android 1370