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