CameraBinderTests.cpp revision aebbe41461c597cdcb4be35edb5484410b9b2dff
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 "CameraBinderTests" 19 20#include <binder/IInterface.h> 21#include <binder/IServiceManager.h> 22#include <binder/Parcel.h> 23#include <binder/ProcessState.h> 24#include <utils/Errors.h> 25#include <utils/Log.h> 26#include <utils/List.h> 27#include <utils/String8.h> 28#include <utils/String16.h> 29#include <utils/Condition.h> 30#include <utils/Mutex.h> 31#include <system/graphics.h> 32#include <hardware/gralloc.h> 33 34#include <camera/CameraMetadata.h> 35#include <android/hardware/ICameraService.h> 36#include <android/hardware/ICameraServiceListener.h> 37#include <android/hardware/BnCameraServiceListener.h> 38#include <android/hardware/camera2/ICameraDeviceUser.h> 39#include <android/hardware/camera2/ICameraDeviceCallbacks.h> 40#include <android/hardware/camera2/BnCameraDeviceCallbacks.h> 41#include <camera/camera2/CaptureRequest.h> 42#include <camera/camera2/OutputConfiguration.h> 43#include <camera/camera2/SubmitInfo.h> 44 45#include <gui/BufferItemConsumer.h> 46#include <gui/IGraphicBufferProducer.h> 47#include <gui/Surface.h> 48 49#include <gtest/gtest.h> 50#include <unistd.h> 51#include <stdint.h> 52#include <utility> 53#include <vector> 54#include <map> 55#include <algorithm> 56 57using namespace android; 58 59#define ASSERT_NOT_NULL(x) \ 60 ASSERT_TRUE((x) != nullptr) 61 62#define SETUP_TIMEOUT 2000000000 // ns 63#define IDLE_TIMEOUT 2000000000 // ns 64 65// Stub listener implementation 66class TestCameraServiceListener : public hardware::BnCameraServiceListener { 67 std::map<String16, int32_t> mCameraTorchStatuses; 68 std::map<String16, int32_t> mCameraStatuses; 69 mutable Mutex mLock; 70 mutable Condition mCondition; 71 mutable Condition mTorchCondition; 72public: 73 virtual ~TestCameraServiceListener() {}; 74 75 virtual binder::Status onStatusChanged(int32_t status, const String16& cameraId) { 76 Mutex::Autolock l(mLock); 77 mCameraStatuses[cameraId] = status; 78 mCondition.broadcast(); 79 return binder::Status::ok(); 80 }; 81 82 virtual binder::Status onTorchStatusChanged(int32_t status, const String16& cameraId) { 83 Mutex::Autolock l(mLock); 84 mCameraTorchStatuses[cameraId] = status; 85 mTorchCondition.broadcast(); 86 return binder::Status::ok(); 87 }; 88 89 bool waitForNumCameras(size_t num) const { 90 Mutex::Autolock l(mLock); 91 92 if (mCameraStatuses.size() == num) { 93 return true; 94 } 95 96 while (mCameraStatuses.size() < num) { 97 if (mCondition.waitRelative(mLock, SETUP_TIMEOUT) != OK) { 98 return false; 99 } 100 } 101 return true; 102 }; 103 104 bool waitForTorchState(int32_t status, int32_t cameraId) const { 105 Mutex::Autolock l(mLock); 106 107 const auto& iter = mCameraTorchStatuses.find(String16(String8::format("%d", cameraId))); 108 if (iter != mCameraTorchStatuses.end() && iter->second == status) { 109 return true; 110 } 111 112 bool foundStatus = false; 113 while (!foundStatus) { 114 if (mTorchCondition.waitRelative(mLock, SETUP_TIMEOUT) != OK) { 115 return false; 116 } 117 const auto& iter = 118 mCameraTorchStatuses.find(String16(String8::format("%d", cameraId))); 119 foundStatus = (iter != mCameraTorchStatuses.end() && iter->second == status); 120 } 121 return true; 122 }; 123 124 int32_t getTorchStatus(int32_t cameraId) const { 125 Mutex::Autolock l(mLock); 126 const auto& iter = mCameraTorchStatuses.find(String16(String8::format("%d", cameraId))); 127 if (iter == mCameraTorchStatuses.end()) { 128 return hardware::ICameraServiceListener::TORCH_STATUS_UNKNOWN; 129 } 130 return iter->second; 131 }; 132 133 int32_t getStatus(const String16& cameraId) const { 134 Mutex::Autolock l(mLock); 135 const auto& iter = mCameraStatuses.find(cameraId); 136 if (iter == mCameraStatuses.end()) { 137 return hardware::ICameraServiceListener::STATUS_UNKNOWN; 138 } 139 return iter->second; 140 }; 141}; 142 143// Callback implementation 144class TestCameraDeviceCallbacks : public hardware::camera2::BnCameraDeviceCallbacks { 145public: 146 enum Status { 147 IDLE, 148 ERROR, 149 PREPARED, 150 RUNNING, 151 SENT_RESULT, 152 UNINITIALIZED, 153 REPEATING_REQUEST_ERROR, 154 REQUEST_QUEUE_EMPTY, 155 }; 156 157protected: 158 bool mError; 159 int32_t mLastStatus; 160 mutable std::vector<int32_t> mStatusesHit; 161 mutable Mutex mLock; 162 mutable Condition mStatusCondition; 163public: 164 TestCameraDeviceCallbacks() : mError(false), mLastStatus(UNINITIALIZED) {} 165 166 virtual ~TestCameraDeviceCallbacks() {} 167 168 virtual binder::Status onDeviceError(int errorCode, 169 const CaptureResultExtras& resultExtras) { 170 (void) resultExtras; 171 ALOGE("%s: onDeviceError occurred with: %d", __FUNCTION__, static_cast<int>(errorCode)); 172 Mutex::Autolock l(mLock); 173 mError = true; 174 mLastStatus = ERROR; 175 mStatusesHit.push_back(mLastStatus); 176 mStatusCondition.broadcast(); 177 return binder::Status::ok(); 178 } 179 180 virtual binder::Status onDeviceIdle() { 181 Mutex::Autolock l(mLock); 182 mLastStatus = IDLE; 183 mStatusesHit.push_back(mLastStatus); 184 mStatusCondition.broadcast(); 185 return binder::Status::ok(); 186 } 187 188 virtual binder::Status onCaptureStarted(const CaptureResultExtras& resultExtras, 189 int64_t timestamp) { 190 (void) resultExtras; 191 (void) timestamp; 192 Mutex::Autolock l(mLock); 193 mLastStatus = RUNNING; 194 mStatusesHit.push_back(mLastStatus); 195 mStatusCondition.broadcast(); 196 return binder::Status::ok(); 197 } 198 199 200 virtual binder::Status onResultReceived(const CameraMetadata& metadata, 201 const CaptureResultExtras& resultExtras) { 202 (void) metadata; 203 (void) resultExtras; 204 Mutex::Autolock l(mLock); 205 mLastStatus = SENT_RESULT; 206 mStatusesHit.push_back(mLastStatus); 207 mStatusCondition.broadcast(); 208 return binder::Status::ok(); 209 } 210 211 virtual binder::Status onPrepared(int streamId) { 212 (void) streamId; 213 Mutex::Autolock l(mLock); 214 mLastStatus = PREPARED; 215 mStatusesHit.push_back(mLastStatus); 216 mStatusCondition.broadcast(); 217 return binder::Status::ok(); 218 } 219 220 virtual binder::Status onRepeatingRequestError( 221 int64_t lastFrameNumber, int32_t stoppedSequenceId) { 222 (void) lastFrameNumber; 223 (void) stoppedSequenceId; 224 Mutex::Autolock l(mLock); 225 mLastStatus = REPEATING_REQUEST_ERROR; 226 mStatusesHit.push_back(mLastStatus); 227 mStatusCondition.broadcast(); 228 return binder::Status::ok(); 229 } 230 231 virtual binder::Status onRequestQueueEmpty() { 232 Mutex::Autolock l(mLock); 233 mLastStatus = REQUEST_QUEUE_EMPTY; 234 mStatusesHit.push_back(mLastStatus); 235 mStatusCondition.broadcast(); 236 return binder::Status::ok(); 237 } 238 239 // Test helper functions: 240 241 bool hadError() const { 242 Mutex::Autolock l(mLock); 243 return mError; 244 } 245 246 bool waitForStatus(Status status) const { 247 Mutex::Autolock l(mLock); 248 if (mLastStatus == status) { 249 return true; 250 } 251 252 while (std::find(mStatusesHit.begin(), mStatusesHit.end(), status) 253 == mStatusesHit.end()) { 254 255 if (mStatusCondition.waitRelative(mLock, IDLE_TIMEOUT) != OK) { 256 mStatusesHit.clear(); 257 return false; 258 } 259 } 260 mStatusesHit.clear(); 261 262 return true; 263 264 } 265 266 void clearStatus() const { 267 Mutex::Autolock l(mLock); 268 mStatusesHit.clear(); 269 } 270 271 bool waitForIdle() const { 272 return waitForStatus(IDLE); 273 } 274 275}; 276 277namespace { 278 Mutex gLock; 279 class DeathNotifier : public IBinder::DeathRecipient 280 { 281 public: 282 DeathNotifier() {} 283 284 virtual void binderDied(const wp<IBinder>& /*who*/) { 285 ALOGV("binderDied"); 286 Mutex::Autolock _l(gLock); 287 ALOGW("Camera service died!"); 288 } 289 }; 290 sp<DeathNotifier> gDeathNotifier; 291}; // anonymous namespace 292 293// Exercise basic binder calls for the camera service 294TEST(CameraServiceBinderTest, CheckBinderCameraService) { 295 ProcessState::self()->startThreadPool(); 296 sp<IServiceManager> sm = defaultServiceManager(); 297 sp<IBinder> binder = sm->getService(String16("media.camera")); 298 ASSERT_NOT_NULL(binder); 299 if (gDeathNotifier == NULL) { 300 gDeathNotifier = new DeathNotifier(); 301 } 302 binder->linkToDeath(gDeathNotifier); 303 sp<hardware::ICameraService> service = 304 interface_cast<hardware::ICameraService>(binder); 305 306 binder::Status res; 307 308 int32_t numCameras = 0; 309 res = service->getNumberOfCameras(hardware::ICameraService::CAMERA_TYPE_ALL, &numCameras); 310 EXPECT_TRUE(res.isOk()) << res; 311 EXPECT_LE(0, numCameras); 312 313 // Check listener binder calls 314 sp<TestCameraServiceListener> listener(new TestCameraServiceListener()); 315 std::vector<hardware::CameraStatus> statuses; 316 res = service->addListener(listener, &statuses); 317 EXPECT_TRUE(res.isOk()) << res; 318 319 EXPECT_EQ(numCameras, static_cast<const int>(statuses.size())); 320 for (const auto &it : statuses) { 321 listener->onStatusChanged(it.status, String16(it.cameraId)); 322 } 323 324 for (int32_t i = 0; i < numCameras; i++) { 325 String16 cameraId = String16(String8::format("%d", i)); 326 bool isSupported = false; 327 res = service->supportsCameraApi(cameraId, 328 hardware::ICameraService::API_VERSION_2, &isSupported); 329 EXPECT_TRUE(res.isOk()) << res; 330 331 // We only care about binder calls for the Camera2 API. Camera1 is deprecated. 332 if (!isSupported) { 333 continue; 334 } 335 336 // Check metadata binder call 337 CameraMetadata metadata; 338 res = service->getCameraCharacteristics(cameraId, &metadata); 339 EXPECT_TRUE(res.isOk()) << res; 340 EXPECT_FALSE(metadata.isEmpty()); 341 342 // Make sure we're available, or skip device tests otherwise 343 int32_t s = listener->getStatus(cameraId); 344 EXPECT_EQ(::android::hardware::ICameraServiceListener::STATUS_PRESENT, s); 345 if (s != ::android::hardware::ICameraServiceListener::STATUS_PRESENT) { 346 continue; 347 } 348 349 // Check connect binder calls 350 sp<TestCameraDeviceCallbacks> callbacks(new TestCameraDeviceCallbacks()); 351 sp<hardware::camera2::ICameraDeviceUser> device; 352 res = service->connectDevice(callbacks, cameraId, String16("meeeeeeeee!"), 353 hardware::ICameraService::USE_CALLING_UID, /*out*/&device); 354 EXPECT_TRUE(res.isOk()) << res; 355 ASSERT_NE(nullptr, device.get()); 356 device->disconnect(); 357 EXPECT_FALSE(callbacks->hadError()); 358 359 int32_t torchStatus = listener->getTorchStatus(i); 360 if (torchStatus == hardware::ICameraServiceListener::TORCH_STATUS_AVAILABLE_OFF) { 361 // Check torch calls 362 res = service->setTorchMode(cameraId, 363 /*enabled*/true, callbacks); 364 EXPECT_TRUE(res.isOk()) << res; 365 EXPECT_TRUE(listener->waitForTorchState( 366 hardware::ICameraServiceListener::TORCH_STATUS_AVAILABLE_ON, i)); 367 res = service->setTorchMode(cameraId, 368 /*enabled*/false, callbacks); 369 EXPECT_TRUE(res.isOk()) << res; 370 EXPECT_TRUE(listener->waitForTorchState( 371 hardware::ICameraServiceListener::TORCH_STATUS_AVAILABLE_OFF, i)); 372 } 373 } 374 375 res = service->removeListener(listener); 376 EXPECT_TRUE(res.isOk()) << res; 377} 378 379// Test fixture for client focused binder tests 380class CameraClientBinderTest : public testing::Test { 381protected: 382 sp<hardware::ICameraService> service; 383 int32_t numCameras; 384 std::vector<std::pair<sp<TestCameraDeviceCallbacks>, sp<hardware::camera2::ICameraDeviceUser>>> 385 openDeviceList; 386 sp<TestCameraServiceListener> serviceListener; 387 388 std::pair<sp<TestCameraDeviceCallbacks>, sp<hardware::camera2::ICameraDeviceUser>> 389 openNewDevice(const String16& deviceId) { 390 sp<TestCameraDeviceCallbacks> callbacks(new TestCameraDeviceCallbacks()); 391 sp<hardware::camera2::ICameraDeviceUser> device; 392 { 393 SCOPED_TRACE("openNewDevice"); 394 binder::Status res = service->connectDevice(callbacks, deviceId, String16("meeeeeeeee!"), 395 hardware::ICameraService::USE_CALLING_UID, /*out*/&device); 396 EXPECT_TRUE(res.isOk()) << res; 397 } 398 auto p = std::make_pair(callbacks, device); 399 openDeviceList.push_back(p); 400 return p; 401 } 402 403 void closeDevice(std::pair<sp<TestCameraDeviceCallbacks>, 404 sp<hardware::camera2::ICameraDeviceUser>>& p) { 405 if (p.second.get() != nullptr) { 406 binder::Status res = p.second->disconnect(); 407 EXPECT_TRUE(res.isOk()) << res; 408 { 409 SCOPED_TRACE("closeDevice"); 410 EXPECT_FALSE(p.first->hadError()); 411 } 412 } 413 auto iter = std::find(openDeviceList.begin(), openDeviceList.end(), p); 414 if (iter != openDeviceList.end()) { 415 openDeviceList.erase(iter); 416 } 417 } 418 419 virtual void SetUp() { 420 ProcessState::self()->startThreadPool(); 421 sp<IServiceManager> sm = defaultServiceManager(); 422 sp<IBinder> binder = sm->getService(String16("media.camera")); 423 service = interface_cast<hardware::ICameraService>(binder); 424 serviceListener = new TestCameraServiceListener(); 425 std::vector<hardware::CameraStatus> statuses; 426 service->addListener(serviceListener, &statuses); 427 for (const auto &it : statuses) { 428 serviceListener->onStatusChanged(it.status, String16(it.cameraId)); 429 } 430 service->getNumberOfCameras(hardware::ICameraService::CAMERA_TYPE_BACKWARD_COMPATIBLE, 431 &numCameras); 432 } 433 434 virtual void TearDown() { 435 service = nullptr; 436 numCameras = 0; 437 for (auto& p : openDeviceList) { 438 closeDevice(p); 439 } 440 } 441 442}; 443 444TEST_F(CameraClientBinderTest, CheckBinderCameraDeviceUser) { 445 ASSERT_NOT_NULL(service); 446 EXPECT_TRUE(serviceListener->waitForNumCameras(numCameras)); 447 for (int32_t i = 0; i < numCameras; i++) { 448 String8 cameraId8 = String8::format("%d", i); 449 // Make sure we're available, or skip device tests otherwise 450 String16 cameraId(cameraId8); 451 int32_t s = serviceListener->getStatus(cameraId); 452 EXPECT_EQ(hardware::ICameraServiceListener::STATUS_PRESENT, s); 453 if (s != hardware::ICameraServiceListener::STATUS_PRESENT) { 454 continue; 455 } 456 binder::Status res; 457 auto p = openNewDevice(cameraId); 458 sp<TestCameraDeviceCallbacks> callbacks = p.first; 459 sp<hardware::camera2::ICameraDeviceUser> device = p.second; 460 461 // Setup a buffer queue; I'm just using the vendor opaque format here as that is 462 // guaranteed to be present 463 sp<IGraphicBufferProducer> gbProducer; 464 sp<IGraphicBufferConsumer> gbConsumer; 465 BufferQueue::createBufferQueue(&gbProducer, &gbConsumer); 466 sp<BufferItemConsumer> opaqueConsumer = new BufferItemConsumer(gbConsumer, 467 GRALLOC_USAGE_SW_READ_NEVER, /*maxImages*/2, /*controlledByApp*/true); 468 EXPECT_TRUE(opaqueConsumer.get() != nullptr); 469 opaqueConsumer->setName(String8("nom nom nom")); 470 471 // Set to VGA dimens for default, as that is guaranteed to be present 472 EXPECT_EQ(OK, gbConsumer->setDefaultBufferSize(640, 480)); 473 EXPECT_EQ(OK, gbConsumer->setDefaultBufferFormat(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED)); 474 475 sp<Surface> surface(new Surface(gbProducer, /*controlledByApp*/false)); 476 477 OutputConfiguration output(gbProducer, /*rotation*/0); 478 479 // Can we configure? 480 res = device->beginConfigure(); 481 EXPECT_TRUE(res.isOk()) << res; 482 status_t streamId; 483 res = device->createStream(output, &streamId); 484 EXPECT_TRUE(res.isOk()) << res; 485 EXPECT_LE(0, streamId); 486 CameraMetadata sessionParams; 487 res = device->endConfigure(/*isConstrainedHighSpeed*/ false, sessionParams); 488 EXPECT_TRUE(res.isOk()) << res; 489 EXPECT_FALSE(callbacks->hadError()); 490 491 // Can we make requests? 492 CameraMetadata requestTemplate; 493 res = device->createDefaultRequest(/*preview template*/1, 494 /*out*/&requestTemplate); 495 EXPECT_TRUE(res.isOk()) << res; 496 497 hardware::camera2::CaptureRequest request; 498 request.mPhysicalCameraSettings.push_back({cameraId8.string(), requestTemplate}); 499 request.mSurfaceList.add(surface); 500 request.mIsReprocess = false; 501 int64_t lastFrameNumber = 0; 502 int64_t lastFrameNumberPrev = 0; 503 callbacks->clearStatus(); 504 505 hardware::camera2::utils::SubmitInfo info; 506 res = device->submitRequest(request, /*streaming*/true, /*out*/&info); 507 EXPECT_TRUE(res.isOk()) << res; 508 EXPECT_TRUE(callbacks->waitForStatus(TestCameraDeviceCallbacks::SENT_RESULT)); 509 EXPECT_LE(0, info.mRequestId); 510 511 // Can we stop requests? 512 res = device->cancelRequest(info.mRequestId, /*out*/&lastFrameNumber); 513 EXPECT_TRUE(res.isOk()) << res; 514 EXPECT_TRUE(callbacks->waitForIdle()); 515 EXPECT_FALSE(callbacks->hadError()); 516 517 // Can we do it again? 518 lastFrameNumberPrev = info.mLastFrameNumber; 519 lastFrameNumber = 0; 520 requestTemplate.clear(); 521 res = device->createDefaultRequest(hardware::camera2::ICameraDeviceUser::TEMPLATE_PREVIEW, 522 /*out*/&requestTemplate); 523 EXPECT_TRUE(res.isOk()) << res; 524 hardware::camera2::CaptureRequest request2; 525 request2.mPhysicalCameraSettings.push_back({cameraId8.string(), requestTemplate}); 526 request2.mSurfaceList.add(surface); 527 request2.mIsReprocess = false; 528 callbacks->clearStatus(); 529 hardware::camera2::utils::SubmitInfo info2; 530 res = device->submitRequest(request2, /*streaming*/true, 531 /*out*/&info2); 532 EXPECT_TRUE(res.isOk()) << res; 533 EXPECT_EQ(hardware::camera2::ICameraDeviceUser::NO_IN_FLIGHT_REPEATING_FRAMES, 534 info2.mLastFrameNumber); 535 lastFrameNumber = 0; 536 EXPECT_TRUE(callbacks->waitForStatus(TestCameraDeviceCallbacks::SENT_RESULT)); 537 EXPECT_LE(0, info2.mRequestId); 538 res = device->cancelRequest(info2.mRequestId, /*out*/&lastFrameNumber); 539 EXPECT_TRUE(res.isOk()) << res; 540 EXPECT_TRUE(callbacks->waitForIdle()); 541 EXPECT_LE(lastFrameNumberPrev, lastFrameNumber); 542 sleep(/*second*/1); // allow some time for errors to show up, if any 543 EXPECT_FALSE(callbacks->hadError()); 544 545 // Can we do it with a request list? 546 lastFrameNumberPrev = lastFrameNumber; 547 lastFrameNumber = 0; 548 requestTemplate.clear(); 549 CameraMetadata requestTemplate2; 550 res = device->createDefaultRequest(hardware::camera2::ICameraDeviceUser::TEMPLATE_PREVIEW, 551 /*out*/&requestTemplate); 552 EXPECT_TRUE(res.isOk()) << res; 553 res = device->createDefaultRequest(hardware::camera2::ICameraDeviceUser::TEMPLATE_PREVIEW, 554 /*out*/&requestTemplate2); 555 EXPECT_TRUE(res.isOk()) << res; 556 android::hardware::camera2::CaptureRequest request3; 557 android::hardware::camera2::CaptureRequest request4; 558 request3.mPhysicalCameraSettings.push_back({cameraId8.string(), requestTemplate}); 559 request3.mSurfaceList.add(surface); 560 request3.mIsReprocess = false; 561 request4.mPhysicalCameraSettings.push_back({cameraId8.string(), requestTemplate2}); 562 request4.mSurfaceList.add(surface); 563 request4.mIsReprocess = false; 564 std::vector<hardware::camera2::CaptureRequest> requestList; 565 requestList.push_back(request3); 566 requestList.push_back(request4); 567 568 callbacks->clearStatus(); 569 hardware::camera2::utils::SubmitInfo info3; 570 res = device->submitRequestList(requestList, /*streaming*/false, 571 /*out*/&info3); 572 EXPECT_TRUE(res.isOk()) << res; 573 EXPECT_LE(0, info3.mRequestId); 574 EXPECT_TRUE(callbacks->waitForStatus(TestCameraDeviceCallbacks::SENT_RESULT)); 575 EXPECT_TRUE(callbacks->waitForIdle()); 576 EXPECT_LE(lastFrameNumberPrev, info3.mLastFrameNumber); 577 sleep(/*second*/1); // allow some time for errors to show up, if any 578 EXPECT_FALSE(callbacks->hadError()); 579 580 // Can we unconfigure? 581 res = device->beginConfigure(); 582 EXPECT_TRUE(res.isOk()) << res; 583 res = device->deleteStream(streamId); 584 EXPECT_TRUE(res.isOk()) << res; 585 res = device->endConfigure(/*isConstrainedHighSpeed*/ false, sessionParams); 586 EXPECT_TRUE(res.isOk()) << res; 587 588 sleep(/*second*/1); // allow some time for errors to show up, if any 589 EXPECT_FALSE(callbacks->hadError()); 590 591 closeDevice(p); 592 } 593 594}; 595 596TEST_F(CameraClientBinderTest, CheckBinderCaptureRequest) { 597 sp<CaptureRequest> requestOriginal, requestParceled; 598 sp<IGraphicBufferProducer> gbProducer; 599 sp<IGraphicBufferConsumer> gbConsumer; 600 BufferQueue::createBufferQueue(&gbProducer, &gbConsumer); 601 sp<Surface> surface(new Surface(gbProducer, /*controlledByApp*/false)); 602 Vector<sp<Surface>> surfaceList; 603 surfaceList.push_back(surface); 604 std::string physicalDeviceId1 = "0"; 605 std::string physicalDeviceId2 = "1"; 606 CameraMetadata physicalDeviceSettings1, physicalDeviceSettings2; 607 uint8_t intent1 = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW; 608 uint8_t intent2 = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD; 609 EXPECT_EQ(OK, physicalDeviceSettings1.update(ANDROID_CONTROL_CAPTURE_INTENT, &intent1, 1)); 610 EXPECT_EQ(OK, physicalDeviceSettings2.update(ANDROID_CONTROL_CAPTURE_INTENT, &intent2, 1)); 611 612 requestParceled = new CaptureRequest(); 613 Parcel p; 614 EXPECT_TRUE(requestParceled->readFromParcel(&p) != OK); 615 p.writeInt32(0); 616 p.setDataPosition(0); 617 EXPECT_TRUE(requestParceled->readFromParcel(&p) != OK); 618 p.freeData(); 619 p.writeInt32(-1); 620 p.setDataPosition(0); 621 EXPECT_TRUE(requestParceled->readFromParcel(&p) != OK); 622 p.freeData(); 623 p.writeInt32(1); 624 p.setDataPosition(0); 625 EXPECT_TRUE(requestParceled->readFromParcel(&p) != OK); 626 627 requestOriginal = new CaptureRequest(); 628 requestOriginal->mPhysicalCameraSettings.push_back({physicalDeviceId1, 629 physicalDeviceSettings1}); 630 requestOriginal->mPhysicalCameraSettings.push_back({physicalDeviceId2, 631 physicalDeviceSettings2}); 632 requestOriginal->mSurfaceList.push_back(surface); 633 requestOriginal->mIsReprocess = false; 634 requestOriginal->mSurfaceConverted = false; 635 636 p.freeData(); 637 EXPECT_TRUE(requestOriginal->writeToParcel(&p) == OK); 638 p.setDataPosition(0); 639 EXPECT_TRUE(requestParceled->readFromParcel(&p) == OK); 640 EXPECT_EQ(requestParceled->mIsReprocess, false); 641 EXPECT_FALSE(requestParceled->mSurfaceList.empty()); 642 EXPECT_EQ(2u, requestParceled->mPhysicalCameraSettings.size()); 643 auto it = requestParceled->mPhysicalCameraSettings.begin(); 644 EXPECT_EQ(physicalDeviceId1, it->id); 645 EXPECT_TRUE(it->settings.exists(ANDROID_CONTROL_CAPTURE_INTENT)); 646 auto entry = it->settings.find(ANDROID_CONTROL_CAPTURE_INTENT); 647 EXPECT_EQ(entry.data.u8[0], intent1); 648 it++; 649 EXPECT_EQ(physicalDeviceId2, it->id); 650 EXPECT_TRUE(it->settings.exists(ANDROID_CONTROL_CAPTURE_INTENT)); 651 entry = it->settings.find(ANDROID_CONTROL_CAPTURE_INTENT); 652 EXPECT_EQ(entry.data.u8[0], intent2); 653}; 654