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
57 using 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
66 class TestCameraServiceListener : public hardware::BnCameraServiceListener {
67 std::map<String16, int32_t> mCameraTorchStatuses;
68 std::map<int32_t, int32_t> mCameraStatuses;
69 mutable Mutex mLock;
70 mutable Condition mCondition;
71 mutable Condition mTorchCondition;
72 public:
~TestCameraServiceListener()73 virtual ~TestCameraServiceListener() {};
74
onStatusChanged(int32_t status,int32_t cameraId)75 virtual binder::Status onStatusChanged(int32_t status, int32_t cameraId) {
76 Mutex::Autolock l(mLock);
77 mCameraStatuses[cameraId] = status;
78 mCondition.broadcast();
79 return binder::Status::ok();
80 };
81
onTorchStatusChanged(int32_t status,const String16 & cameraId)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
waitForNumCameras(size_t num) const89 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
waitForTorchState(int32_t status,int32_t cameraId) const104 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
getTorchStatus(int32_t cameraId) const124 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
getStatus(int32_t cameraId) const133 int32_t getStatus(int32_t 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
144 class TestCameraDeviceCallbacks : public hardware::camera2::BnCameraDeviceCallbacks {
145 public:
146 enum Status {
147 IDLE,
148 ERROR,
149 PREPARED,
150 RUNNING,
151 SENT_RESULT,
152 UNINITIALIZED,
153 REPEATING_REQUEST_ERROR,
154 };
155
156 protected:
157 bool mError;
158 int32_t mLastStatus;
159 mutable std::vector<int32_t> mStatusesHit;
160 mutable Mutex mLock;
161 mutable Condition mStatusCondition;
162 public:
TestCameraDeviceCallbacks()163 TestCameraDeviceCallbacks() : mError(false), mLastStatus(UNINITIALIZED) {}
164
~TestCameraDeviceCallbacks()165 virtual ~TestCameraDeviceCallbacks() {}
166
onDeviceError(int errorCode,const CaptureResultExtras & resultExtras)167 virtual binder::Status onDeviceError(int errorCode,
168 const CaptureResultExtras& resultExtras) {
169 (void) resultExtras;
170 ALOGE("%s: onDeviceError occurred with: %d", __FUNCTION__, static_cast<int>(errorCode));
171 Mutex::Autolock l(mLock);
172 mError = true;
173 mLastStatus = ERROR;
174 mStatusesHit.push_back(mLastStatus);
175 mStatusCondition.broadcast();
176 return binder::Status::ok();
177 }
178
onDeviceIdle()179 virtual binder::Status onDeviceIdle() {
180 Mutex::Autolock l(mLock);
181 mLastStatus = IDLE;
182 mStatusesHit.push_back(mLastStatus);
183 mStatusCondition.broadcast();
184 return binder::Status::ok();
185 }
186
onCaptureStarted(const CaptureResultExtras & resultExtras,int64_t timestamp)187 virtual binder::Status onCaptureStarted(const CaptureResultExtras& resultExtras,
188 int64_t timestamp) {
189 (void) resultExtras;
190 (void) timestamp;
191 Mutex::Autolock l(mLock);
192 mLastStatus = RUNNING;
193 mStatusesHit.push_back(mLastStatus);
194 mStatusCondition.broadcast();
195 return binder::Status::ok();
196 }
197
198
onResultReceived(const CameraMetadata & metadata,const CaptureResultExtras & resultExtras)199 virtual binder::Status onResultReceived(const CameraMetadata& metadata,
200 const CaptureResultExtras& resultExtras) {
201 (void) metadata;
202 (void) resultExtras;
203 Mutex::Autolock l(mLock);
204 mLastStatus = SENT_RESULT;
205 mStatusesHit.push_back(mLastStatus);
206 mStatusCondition.broadcast();
207 return binder::Status::ok();
208 }
209
onPrepared(int streamId)210 virtual binder::Status onPrepared(int streamId) {
211 (void) streamId;
212 Mutex::Autolock l(mLock);
213 mLastStatus = PREPARED;
214 mStatusesHit.push_back(mLastStatus);
215 mStatusCondition.broadcast();
216 return binder::Status::ok();
217 }
218
onRepeatingRequestError(int64_t lastFrameNumber)219 virtual binder::Status onRepeatingRequestError(int64_t lastFrameNumber) {
220 (void) lastFrameNumber;
221 Mutex::Autolock l(mLock);
222 mLastStatus = REPEATING_REQUEST_ERROR;
223 mStatusesHit.push_back(mLastStatus);
224 mStatusCondition.broadcast();
225 return binder::Status::ok();
226 }
227
228 // Test helper functions:
229
hadError() const230 bool hadError() const {
231 Mutex::Autolock l(mLock);
232 return mError;
233 }
234
waitForStatus(Status status) const235 bool waitForStatus(Status status) const {
236 Mutex::Autolock l(mLock);
237 if (mLastStatus == status) {
238 return true;
239 }
240
241 while (std::find(mStatusesHit.begin(), mStatusesHit.end(), status)
242 == mStatusesHit.end()) {
243
244 if (mStatusCondition.waitRelative(mLock, IDLE_TIMEOUT) != OK) {
245 mStatusesHit.clear();
246 return false;
247 }
248 }
249 mStatusesHit.clear();
250
251 return true;
252
253 }
254
clearStatus() const255 void clearStatus() const {
256 Mutex::Autolock l(mLock);
257 mStatusesHit.clear();
258 }
259
waitForIdle() const260 bool waitForIdle() const {
261 return waitForStatus(IDLE);
262 }
263
264 };
265
266 namespace {
267 Mutex gLock;
268 class DeathNotifier : public IBinder::DeathRecipient
269 {
270 public:
DeathNotifier()271 DeathNotifier() {}
272
binderDied(const wp<IBinder> &)273 virtual void binderDied(const wp<IBinder>& /*who*/) {
274 ALOGV("binderDied");
275 Mutex::Autolock _l(gLock);
276 ALOGW("Camera service died!");
277 }
278 };
279 sp<DeathNotifier> gDeathNotifier;
280 }; // anonymous namespace
281
282 // Exercise basic binder calls for the camera service
TEST(CameraServiceBinderTest,CheckBinderCameraService)283 TEST(CameraServiceBinderTest, CheckBinderCameraService) {
284 ProcessState::self()->startThreadPool();
285 sp<IServiceManager> sm = defaultServiceManager();
286 sp<IBinder> binder = sm->getService(String16("media.camera"));
287 ASSERT_NOT_NULL(binder);
288 if (gDeathNotifier == NULL) {
289 gDeathNotifier = new DeathNotifier();
290 }
291 binder->linkToDeath(gDeathNotifier);
292 sp<hardware::ICameraService> service =
293 interface_cast<hardware::ICameraService>(binder);
294
295 binder::Status res;
296
297 int32_t numCameras = 0;
298 res = service->getNumberOfCameras(hardware::ICameraService::CAMERA_TYPE_ALL, &numCameras);
299 EXPECT_TRUE(res.isOk()) << res;
300 EXPECT_LE(0, numCameras);
301
302 // Check listener binder calls
303 sp<TestCameraServiceListener> listener(new TestCameraServiceListener());
304 res = service->addListener(listener);
305 EXPECT_TRUE(res.isOk()) << res;
306
307 EXPECT_TRUE(listener->waitForNumCameras(numCameras));
308
309 for (int32_t i = 0; i < numCameras; i++) {
310 bool isSupported = false;
311 res = service->supportsCameraApi(i,
312 hardware::ICameraService::API_VERSION_2, &isSupported);
313 EXPECT_TRUE(res.isOk()) << res;
314
315 // We only care about binder calls for the Camera2 API. Camera1 is deprecated.
316 if (!isSupported) {
317 continue;
318 }
319
320 // Check metadata binder call
321 CameraMetadata metadata;
322 res = service->getCameraCharacteristics(i, &metadata);
323 EXPECT_TRUE(res.isOk()) << res;
324 EXPECT_FALSE(metadata.isEmpty());
325
326 // Make sure we're available, or skip device tests otherwise
327 int32_t s = listener->getStatus(i);
328 EXPECT_EQ(::android::hardware::ICameraServiceListener::STATUS_PRESENT, s);
329 if (s != ::android::hardware::ICameraServiceListener::STATUS_PRESENT) {
330 continue;
331 }
332
333 // Check connect binder calls
334 sp<TestCameraDeviceCallbacks> callbacks(new TestCameraDeviceCallbacks());
335 sp<hardware::camera2::ICameraDeviceUser> device;
336 res = service->connectDevice(callbacks, i, String16("meeeeeeeee!"),
337 hardware::ICameraService::USE_CALLING_UID, /*out*/&device);
338 EXPECT_TRUE(res.isOk()) << res;
339 ASSERT_NE(nullptr, device.get());
340 device->disconnect();
341 EXPECT_FALSE(callbacks->hadError());
342
343 int32_t torchStatus = listener->getTorchStatus(i);
344 if (torchStatus == hardware::ICameraServiceListener::TORCH_STATUS_AVAILABLE_OFF) {
345 // Check torch calls
346 res = service->setTorchMode(String16(String8::format("%d", i)),
347 /*enabled*/true, callbacks);
348 EXPECT_TRUE(res.isOk()) << res;
349 EXPECT_TRUE(listener->waitForTorchState(
350 hardware::ICameraServiceListener::TORCH_STATUS_AVAILABLE_ON, i));
351 res = service->setTorchMode(String16(String8::format("%d", i)),
352 /*enabled*/false, callbacks);
353 EXPECT_TRUE(res.isOk()) << res;
354 EXPECT_TRUE(listener->waitForTorchState(
355 hardware::ICameraServiceListener::TORCH_STATUS_AVAILABLE_OFF, i));
356 }
357 }
358
359 res = service->removeListener(listener);
360 EXPECT_TRUE(res.isOk()) << res;
361 }
362
363 // Test fixture for client focused binder tests
364 class CameraClientBinderTest : public testing::Test {
365 protected:
366 sp<hardware::ICameraService> service;
367 int32_t numCameras;
368 std::vector<std::pair<sp<TestCameraDeviceCallbacks>, sp<hardware::camera2::ICameraDeviceUser>>>
369 openDeviceList;
370 sp<TestCameraServiceListener> serviceListener;
371
372 std::pair<sp<TestCameraDeviceCallbacks>, sp<hardware::camera2::ICameraDeviceUser>>
openNewDevice(int deviceId)373 openNewDevice(int deviceId) {
374 sp<TestCameraDeviceCallbacks> callbacks(new TestCameraDeviceCallbacks());
375 sp<hardware::camera2::ICameraDeviceUser> device;
376 {
377 SCOPED_TRACE("openNewDevice");
378 binder::Status res = service->connectDevice(callbacks, deviceId, String16("meeeeeeeee!"),
379 hardware::ICameraService::USE_CALLING_UID, /*out*/&device);
380 EXPECT_TRUE(res.isOk()) << res;
381 }
382 auto p = std::make_pair(callbacks, device);
383 openDeviceList.push_back(p);
384 return p;
385 }
386
closeDevice(std::pair<sp<TestCameraDeviceCallbacks>,sp<hardware::camera2::ICameraDeviceUser>> & p)387 void closeDevice(std::pair<sp<TestCameraDeviceCallbacks>,
388 sp<hardware::camera2::ICameraDeviceUser>>& p) {
389 if (p.second.get() != nullptr) {
390 binder::Status res = p.second->disconnect();
391 EXPECT_TRUE(res.isOk()) << res;
392 {
393 SCOPED_TRACE("closeDevice");
394 EXPECT_FALSE(p.first->hadError());
395 }
396 }
397 auto iter = std::find(openDeviceList.begin(), openDeviceList.end(), p);
398 if (iter != openDeviceList.end()) {
399 openDeviceList.erase(iter);
400 }
401 }
402
SetUp()403 virtual void SetUp() {
404 ProcessState::self()->startThreadPool();
405 sp<IServiceManager> sm = defaultServiceManager();
406 sp<IBinder> binder = sm->getService(String16("media.camera"));
407 service = interface_cast<hardware::ICameraService>(binder);
408 serviceListener = new TestCameraServiceListener();
409 service->addListener(serviceListener);
410 service->getNumberOfCameras(hardware::ICameraService::CAMERA_TYPE_BACKWARD_COMPATIBLE,
411 &numCameras);
412 }
413
TearDown()414 virtual void TearDown() {
415 service = nullptr;
416 numCameras = 0;
417 for (auto& p : openDeviceList) {
418 closeDevice(p);
419 }
420 }
421
422 };
423
TEST_F(CameraClientBinderTest,CheckBinderCameraDeviceUser)424 TEST_F(CameraClientBinderTest, CheckBinderCameraDeviceUser) {
425 ASSERT_NOT_NULL(service);
426 EXPECT_TRUE(serviceListener->waitForNumCameras(numCameras));
427 for (int32_t i = 0; i < numCameras; i++) {
428 // Make sure we're available, or skip device tests otherwise
429 int32_t s = serviceListener->getStatus(i);
430 EXPECT_EQ(hardware::ICameraServiceListener::STATUS_PRESENT, s);
431 if (s != hardware::ICameraServiceListener::STATUS_PRESENT) {
432 continue;
433 }
434 binder::Status res;
435
436 auto p = openNewDevice(i);
437 sp<TestCameraDeviceCallbacks> callbacks = p.first;
438 sp<hardware::camera2::ICameraDeviceUser> device = p.second;
439
440 // Setup a buffer queue; I'm just using the vendor opaque format here as that is
441 // guaranteed to be present
442 sp<IGraphicBufferProducer> gbProducer;
443 sp<IGraphicBufferConsumer> gbConsumer;
444 BufferQueue::createBufferQueue(&gbProducer, &gbConsumer);
445 sp<BufferItemConsumer> opaqueConsumer = new BufferItemConsumer(gbConsumer,
446 GRALLOC_USAGE_SW_READ_NEVER, /*maxImages*/2, /*controlledByApp*/true);
447 EXPECT_TRUE(opaqueConsumer.get() != nullptr);
448 opaqueConsumer->setName(String8("nom nom nom"));
449
450 // Set to VGA dimens for default, as that is guaranteed to be present
451 EXPECT_EQ(OK, gbConsumer->setDefaultBufferSize(640, 480));
452 EXPECT_EQ(OK, gbConsumer->setDefaultBufferFormat(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED));
453
454 sp<Surface> surface(new Surface(gbProducer, /*controlledByApp*/false));
455
456 OutputConfiguration output(gbProducer, /*rotation*/0);
457
458 // Can we configure?
459 res = device->beginConfigure();
460 EXPECT_TRUE(res.isOk()) << res;
461 status_t streamId;
462 res = device->createStream(output, &streamId);
463 EXPECT_TRUE(res.isOk()) << res;
464 EXPECT_LE(0, streamId);
465 res = device->endConfigure(/*isConstrainedHighSpeed*/ false);
466 EXPECT_TRUE(res.isOk()) << res;
467 EXPECT_FALSE(callbacks->hadError());
468
469 // Can we make requests?
470 CameraMetadata requestTemplate;
471 res = device->createDefaultRequest(/*preview template*/1,
472 /*out*/&requestTemplate);
473 EXPECT_TRUE(res.isOk()) << res;
474
475 hardware::camera2::CaptureRequest request;
476 request.mMetadata = requestTemplate;
477 request.mSurfaceList.add(surface);
478 request.mIsReprocess = false;
479 int64_t lastFrameNumber = 0;
480 int64_t lastFrameNumberPrev = 0;
481 callbacks->clearStatus();
482
483 hardware::camera2::utils::SubmitInfo info;
484 res = device->submitRequest(request, /*streaming*/true, /*out*/&info);
485 EXPECT_TRUE(res.isOk()) << res;
486 EXPECT_TRUE(callbacks->waitForStatus(TestCameraDeviceCallbacks::SENT_RESULT));
487 EXPECT_LE(0, info.mRequestId);
488
489 // Can we stop requests?
490 res = device->cancelRequest(info.mRequestId, /*out*/&lastFrameNumber);
491 EXPECT_TRUE(res.isOk()) << res;
492 EXPECT_TRUE(callbacks->waitForIdle());
493 EXPECT_FALSE(callbacks->hadError());
494
495 // Can we do it again?
496 lastFrameNumberPrev = info.mLastFrameNumber;
497 lastFrameNumber = 0;
498 requestTemplate.clear();
499 res = device->createDefaultRequest(hardware::camera2::ICameraDeviceUser::TEMPLATE_PREVIEW,
500 /*out*/&requestTemplate);
501 EXPECT_TRUE(res.isOk()) << res;
502 hardware::camera2::CaptureRequest request2;
503 request2.mMetadata = requestTemplate;
504 request2.mSurfaceList.add(surface);
505 request2.mIsReprocess = false;
506 callbacks->clearStatus();
507 hardware::camera2::utils::SubmitInfo info2;
508 res = device->submitRequest(request2, /*streaming*/true,
509 /*out*/&info2);
510 EXPECT_TRUE(res.isOk()) << res;
511 EXPECT_EQ(hardware::camera2::ICameraDeviceUser::NO_IN_FLIGHT_REPEATING_FRAMES,
512 info2.mLastFrameNumber);
513 lastFrameNumber = 0;
514 EXPECT_TRUE(callbacks->waitForStatus(TestCameraDeviceCallbacks::SENT_RESULT));
515 EXPECT_LE(0, info2.mRequestId);
516 res = device->cancelRequest(info2.mRequestId, /*out*/&lastFrameNumber);
517 EXPECT_TRUE(res.isOk()) << res;
518 EXPECT_TRUE(callbacks->waitForIdle());
519 EXPECT_LE(lastFrameNumberPrev, lastFrameNumber);
520 sleep(/*second*/1); // allow some time for errors to show up, if any
521 EXPECT_FALSE(callbacks->hadError());
522
523 // Can we do it with a request list?
524 lastFrameNumberPrev = lastFrameNumber;
525 lastFrameNumber = 0;
526 requestTemplate.clear();
527 CameraMetadata requestTemplate2;
528 res = device->createDefaultRequest(hardware::camera2::ICameraDeviceUser::TEMPLATE_PREVIEW,
529 /*out*/&requestTemplate);
530 EXPECT_TRUE(res.isOk()) << res;
531 res = device->createDefaultRequest(hardware::camera2::ICameraDeviceUser::TEMPLATE_PREVIEW,
532 /*out*/&requestTemplate2);
533 EXPECT_TRUE(res.isOk()) << res;
534 android::hardware::camera2::CaptureRequest request3;
535 android::hardware::camera2::CaptureRequest request4;
536 request3.mMetadata = requestTemplate;
537 request3.mSurfaceList.add(surface);
538 request3.mIsReprocess = false;
539 request4.mMetadata = requestTemplate2;
540 request4.mSurfaceList.add(surface);
541 request4.mIsReprocess = false;
542 std::vector<hardware::camera2::CaptureRequest> requestList;
543 requestList.push_back(request3);
544 requestList.push_back(request4);
545
546 callbacks->clearStatus();
547 hardware::camera2::utils::SubmitInfo info3;
548 res = device->submitRequestList(requestList, /*streaming*/false,
549 /*out*/&info3);
550 EXPECT_TRUE(res.isOk()) << res;
551 EXPECT_LE(0, info3.mRequestId);
552 EXPECT_TRUE(callbacks->waitForStatus(TestCameraDeviceCallbacks::SENT_RESULT));
553 EXPECT_TRUE(callbacks->waitForIdle());
554 EXPECT_LE(lastFrameNumberPrev, info3.mLastFrameNumber);
555 sleep(/*second*/1); // allow some time for errors to show up, if any
556 EXPECT_FALSE(callbacks->hadError());
557
558 // Can we unconfigure?
559 res = device->beginConfigure();
560 EXPECT_TRUE(res.isOk()) << res;
561 res = device->deleteStream(streamId);
562 EXPECT_TRUE(res.isOk()) << res;
563 res = device->endConfigure(/*isConstrainedHighSpeed*/ false);
564 EXPECT_TRUE(res.isOk()) << res;
565
566 sleep(/*second*/1); // allow some time for errors to show up, if any
567 EXPECT_FALSE(callbacks->hadError());
568
569 closeDevice(p);
570 }
571
572 };
573