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