1 /*
2 * Copyright (C) 2013 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 #include <gtest/gtest.h>
18 #include <iostream>
19
20 #include <binder/IPCThreadState.h>
21 #include <utils/Thread.h>
22
23 #include "Camera.h"
24 #include "ProCamera.h"
25 #include <utils/Vector.h>
26 #include <utils/Mutex.h>
27 #include <utils/Condition.h>
28
29 #include <gui/SurfaceComposerClient.h>
30 #include <gui/Surface.h>
31
32 #include <system/camera_metadata.h>
33 #include <hardware/camera2.h> // for CAMERA2_TEMPLATE_PREVIEW only
34 #include <camera/CameraMetadata.h>
35
36 #include <camera/ICameraServiceListener.h>
37
38 namespace android {
39 namespace camera2 {
40 namespace tests {
41 namespace client {
42
43 #define CAMERA_ID 0
44 #define TEST_DEBUGGING 0
45
46 #define TEST_LISTENER_TIMEOUT 1000000000 // 1 second listener timeout
47 #define TEST_FORMAT HAL_PIXEL_FORMAT_Y16 //TODO: YUY2 instead
48
49 #define TEST_FORMAT_MAIN HAL_PIXEL_FORMAT_Y8
50 #define TEST_FORMAT_DEPTH HAL_PIXEL_FORMAT_Y16
51
52 // defaults for display "test"
53 #define TEST_DISPLAY_FORMAT HAL_PIXEL_FORMAT_Y8
54 #define TEST_DISPLAY_WIDTH 320
55 #define TEST_DISPLAY_HEIGHT 240
56
57 #define TEST_CPU_FRAME_COUNT 2
58 #define TEST_CPU_HEAP_COUNT 5
59
60 #define TEST_FRAME_PROCESSING_DELAY_US 200000 // 200 ms
61
62 #if TEST_DEBUGGING
63 #define dout std::cerr
64 #else
65 #define dout if (0) std::cerr
66 #endif
67
68 #define EXPECT_OK(x) EXPECT_EQ(OK, (x))
69 #define ASSERT_OK(x) ASSERT_EQ(OK, (x))
70
71 class ProCameraTest;
72
73 struct ServiceListener : public BnCameraServiceListener {
74
ServiceListenerandroid::camera2::tests::client::ServiceListener75 ServiceListener() :
76 mLatestStatus(STATUS_UNKNOWN),
77 mPrevStatus(STATUS_UNKNOWN)
78 {
79 }
80
onStatusChangedandroid::camera2::tests::client::ServiceListener81 void onStatusChanged(Status status, int32_t cameraId) {
82 dout << "On status changed: 0x" << std::hex
83 << (unsigned int) status << " cameraId " << cameraId
84 << std::endl;
85
86 Mutex::Autolock al(mMutex);
87
88 mLatestStatus = status;
89 mCondition.broadcast();
90 }
91
waitForStatusChangeandroid::camera2::tests::client::ServiceListener92 status_t waitForStatusChange(Status& newStatus) {
93 Mutex::Autolock al(mMutex);
94
95 if (mLatestStatus != mPrevStatus) {
96 newStatus = mLatestStatus;
97 mPrevStatus = mLatestStatus;
98 return OK;
99 }
100
101 status_t stat = mCondition.waitRelative(mMutex,
102 TEST_LISTENER_TIMEOUT);
103
104 if (stat == OK) {
105 newStatus = mLatestStatus;
106 mPrevStatus = mLatestStatus;
107 }
108
109 return stat;
110 }
111
112 Condition mCondition;
113 Mutex mMutex;
114
115 Status mLatestStatus;
116 Status mPrevStatus;
117 };
118
119 enum ProEvent {
120 UNKNOWN,
121 ACQUIRED,
122 RELEASED,
123 STOLEN,
124 FRAME_RECEIVED,
125 RESULT_RECEIVED,
126 };
127
ProEvent_Mask(ProEvent e)128 inline int ProEvent_Mask(ProEvent e) {
129 return (1 << static_cast<int>(e));
130 }
131
132 typedef Vector<ProEvent> EventList;
133
134 class ProCameraTestThread : public Thread
135 {
136 public:
ProCameraTestThread()137 ProCameraTestThread() {
138 }
139
threadLoop()140 virtual bool threadLoop() {
141 mProc = ProcessState::self();
142 mProc->startThreadPool();
143
144 IPCThreadState *ptr = IPCThreadState::self();
145
146 ptr->joinThreadPool();
147
148 return false;
149 }
150
151 sp<ProcessState> mProc;
152 };
153
154 class ProCameraTestListener : public ProCameraListener {
155
156 public:
157 static const int EVENT_MASK_ALL = 0xFFFFFFFF;
158
ProCameraTestListener()159 ProCameraTestListener() {
160 mEventMask = EVENT_MASK_ALL;
161 mDropFrames = false;
162 }
163
WaitForEvent()164 status_t WaitForEvent() {
165 Mutex::Autolock cal(mConditionMutex);
166
167 {
168 Mutex::Autolock al(mListenerMutex);
169
170 if (mProEventList.size() > 0) {
171 return OK;
172 }
173 }
174
175 return mListenerCondition.waitRelative(mConditionMutex,
176 TEST_LISTENER_TIMEOUT);
177 }
178
179 /* Read events into out. Existing queue is flushed */
ReadEvents(EventList & out)180 void ReadEvents(EventList& out) {
181 Mutex::Autolock al(mListenerMutex);
182
183 for (size_t i = 0; i < mProEventList.size(); ++i) {
184 out.push(mProEventList[i]);
185 }
186
187 mProEventList.clear();
188 }
189
190 /**
191 * Dequeue 1 event from the event queue.
192 * Returns UNKNOWN if queue is empty
193 */
ReadEvent()194 ProEvent ReadEvent() {
195 Mutex::Autolock al(mListenerMutex);
196
197 if (mProEventList.size() == 0) {
198 return UNKNOWN;
199 }
200
201 ProEvent ev = mProEventList[0];
202 mProEventList.removeAt(0);
203
204 return ev;
205 }
206
SetEventMask(int eventMask)207 void SetEventMask(int eventMask) {
208 Mutex::Autolock al(mListenerMutex);
209 mEventMask = eventMask;
210 }
211
212 // Automatically acquire/release frames as they are available
SetDropFrames(bool dropFrames)213 void SetDropFrames(bool dropFrames) {
214 Mutex::Autolock al(mListenerMutex);
215 mDropFrames = dropFrames;
216 }
217
218 private:
QueueEvent(ProEvent ev)219 void QueueEvent(ProEvent ev) {
220 bool eventAdded = false;
221 {
222 Mutex::Autolock al(mListenerMutex);
223
224 // Drop events not part of mask
225 if (ProEvent_Mask(ev) & mEventMask) {
226 mProEventList.push(ev);
227 eventAdded = true;
228 }
229 }
230
231 if (eventAdded) {
232 mListenerCondition.broadcast();
233 }
234 }
235
236 protected:
237
238 //////////////////////////////////////////////////
239 ///////// ProCameraListener //////////////////////
240 //////////////////////////////////////////////////
241
242
243 // Lock has been acquired. Write operations now available.
onLockAcquired()244 virtual void onLockAcquired() {
245 QueueEvent(ACQUIRED);
246 }
247 // Lock has been released with exclusiveUnlock
onLockReleased()248 virtual void onLockReleased() {
249 QueueEvent(RELEASED);
250 }
251
252 // Lock has been stolen by another client.
onLockStolen()253 virtual void onLockStolen() {
254 QueueEvent(STOLEN);
255 }
256
257 // Lock free.
onTriggerNotify(int32_t ext1,int32_t ext2,int32_t ext3)258 virtual void onTriggerNotify(int32_t ext1, int32_t ext2, int32_t ext3) {
259
260 dout << "Trigger notify: " << ext1 << " " << ext2
261 << " " << ext3 << std::endl;
262 }
263
onFrameAvailable(int streamId,const sp<CpuConsumer> & consumer)264 virtual void onFrameAvailable(int streamId,
265 const sp<CpuConsumer>& consumer) {
266
267 QueueEvent(FRAME_RECEIVED);
268
269 Mutex::Autolock al(mListenerMutex);
270 if (mDropFrames) {
271 CpuConsumer::LockedBuffer buf;
272 status_t ret;
273
274 if (OK == (ret = consumer->lockNextBuffer(&buf))) {
275
276 dout << "Frame received on streamId = " << streamId <<
277 ", dataPtr = " << (void*)buf.data <<
278 ", timestamp = " << buf.timestamp << std::endl;
279
280 EXPECT_OK(consumer->unlockBuffer(buf));
281 }
282 } else {
283 dout << "Frame received on streamId = " << streamId << std::endl;
284 }
285 }
286
onResultReceived(int32_t requestId,camera_metadata * request)287 virtual void onResultReceived(int32_t requestId,
288 camera_metadata* request) {
289 dout << "Result received requestId = " << requestId
290 << ", requestPtr = " << (void*)request << std::endl;
291 QueueEvent(RESULT_RECEIVED);
292 free_camera_metadata(request);
293 }
294
notify(int32_t msg,int32_t ext1,int32_t ext2)295 virtual void notify(int32_t msg, int32_t ext1, int32_t ext2) {
296 dout << "Notify received: msg " << std::hex << msg
297 << ", ext1: " << std::hex << ext1 << ", ext2: " << std::hex << ext2
298 << std::endl;
299 }
300
301 Vector<ProEvent> mProEventList;
302 Mutex mListenerMutex;
303 Mutex mConditionMutex;
304 Condition mListenerCondition;
305 int mEventMask;
306 bool mDropFrames;
307 };
308
309 class ProCameraTest : public ::testing::Test {
310
311 public:
ProCameraTest()312 ProCameraTest() {
313 char* displaySecsEnv = getenv("TEST_DISPLAY_SECS");
314 if (displaySecsEnv != NULL) {
315 mDisplaySecs = atoi(displaySecsEnv);
316 if (mDisplaySecs < 0) {
317 mDisplaySecs = 0;
318 }
319 } else {
320 mDisplaySecs = 0;
321 }
322
323 char* displayFmtEnv = getenv("TEST_DISPLAY_FORMAT");
324 if (displayFmtEnv != NULL) {
325 mDisplayFmt = FormatFromString(displayFmtEnv);
326 } else {
327 mDisplayFmt = TEST_DISPLAY_FORMAT;
328 }
329
330 char* displayWidthEnv = getenv("TEST_DISPLAY_WIDTH");
331 if (displayWidthEnv != NULL) {
332 mDisplayW = atoi(displayWidthEnv);
333 if (mDisplayW < 0) {
334 mDisplayW = 0;
335 }
336 } else {
337 mDisplayW = TEST_DISPLAY_WIDTH;
338 }
339
340 char* displayHeightEnv = getenv("TEST_DISPLAY_HEIGHT");
341 if (displayHeightEnv != NULL) {
342 mDisplayH = atoi(displayHeightEnv);
343 if (mDisplayH < 0) {
344 mDisplayH = 0;
345 }
346 } else {
347 mDisplayH = TEST_DISPLAY_HEIGHT;
348 }
349 }
350
SetUpTestCase()351 static void SetUpTestCase() {
352 // Binder Thread Pool Initialization
353 mTestThread = new ProCameraTestThread();
354 mTestThread->run("ProCameraTestThread");
355 }
356
SetUp()357 virtual void SetUp() {
358 mCamera = ProCamera::connect(CAMERA_ID);
359 ASSERT_NE((void*)NULL, mCamera.get());
360
361 mListener = new ProCameraTestListener();
362 mCamera->setListener(mListener);
363 }
364
TearDown()365 virtual void TearDown() {
366 ASSERT_NE((void*)NULL, mCamera.get());
367 mCamera->disconnect();
368 }
369
370 protected:
371 sp<ProCamera> mCamera;
372 sp<ProCameraTestListener> mListener;
373
374 static sp<Thread> mTestThread;
375
376 int mDisplaySecs;
377 int mDisplayFmt;
378 int mDisplayW;
379 int mDisplayH;
380
381 sp<SurfaceComposerClient> mComposerClient;
382 sp<SurfaceControl> mSurfaceControl;
383
384 sp<SurfaceComposerClient> mDepthComposerClient;
385 sp<SurfaceControl> mDepthSurfaceControl;
386
getSurfaceWidth()387 int getSurfaceWidth() {
388 return 512;
389 }
getSurfaceHeight()390 int getSurfaceHeight() {
391 return 512;
392 }
393
createOnScreenSurface(sp<Surface> & surface)394 void createOnScreenSurface(sp<Surface>& surface) {
395 mComposerClient = new SurfaceComposerClient;
396 ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
397
398 mSurfaceControl = mComposerClient->createSurface(
399 String8("ProCameraTest StreamingImage Surface"),
400 getSurfaceWidth(), getSurfaceHeight(),
401 PIXEL_FORMAT_RGB_888, 0);
402
403 mSurfaceControl->setPosition(0, 0);
404
405 ASSERT_TRUE(mSurfaceControl != NULL);
406 ASSERT_TRUE(mSurfaceControl->isValid());
407
408 SurfaceComposerClient::openGlobalTransaction();
409 ASSERT_EQ(NO_ERROR, mSurfaceControl->setLayer(0x7FFFFFFF));
410 ASSERT_EQ(NO_ERROR, mSurfaceControl->show());
411 SurfaceComposerClient::closeGlobalTransaction();
412
413 sp<ANativeWindow> window = mSurfaceControl->getSurface();
414 surface = mSurfaceControl->getSurface();
415
416 ASSERT_NE((void*)NULL, surface.get());
417 }
418
createDepthOnScreenSurface(sp<Surface> & surface)419 void createDepthOnScreenSurface(sp<Surface>& surface) {
420 mDepthComposerClient = new SurfaceComposerClient;
421 ASSERT_EQ(NO_ERROR, mDepthComposerClient->initCheck());
422
423 mDepthSurfaceControl = mDepthComposerClient->createSurface(
424 String8("ProCameraTest StreamingImage Surface"),
425 getSurfaceWidth(), getSurfaceHeight(),
426 PIXEL_FORMAT_RGB_888, 0);
427
428 mDepthSurfaceControl->setPosition(640, 0);
429
430 ASSERT_TRUE(mDepthSurfaceControl != NULL);
431 ASSERT_TRUE(mDepthSurfaceControl->isValid());
432
433 SurfaceComposerClient::openGlobalTransaction();
434 ASSERT_EQ(NO_ERROR, mDepthSurfaceControl->setLayer(0x7FFFFFFF));
435 ASSERT_EQ(NO_ERROR, mDepthSurfaceControl->show());
436 SurfaceComposerClient::closeGlobalTransaction();
437
438 sp<ANativeWindow> window = mDepthSurfaceControl->getSurface();
439 surface = mDepthSurfaceControl->getSurface();
440
441 ASSERT_NE((void*)NULL, surface.get());
442 }
443
444 template <typename T>
ExistsItem(T needle,T * array,size_t count)445 static bool ExistsItem(T needle, T* array, size_t count) {
446 if (!array) {
447 return false;
448 }
449
450 for (size_t i = 0; i < count; ++i) {
451 if (array[i] == needle) {
452 return true;
453 }
454 }
455 return false;
456 }
457
458
FormatFromString(const char * str)459 static int FormatFromString(const char* str) {
460 std::string s(str);
461
462 #define CMP_STR(x, y) \
463 if (s == #x) return HAL_PIXEL_FORMAT_ ## y;
464 #define CMP_STR_SAME(x) CMP_STR(x, x)
465
466 CMP_STR_SAME( Y16);
467 CMP_STR_SAME( Y8);
468 CMP_STR_SAME( YV12);
469 CMP_STR(NV16, YCbCr_422_SP);
470 CMP_STR(NV21, YCrCb_420_SP);
471 CMP_STR(YUY2, YCbCr_422_I);
472 CMP_STR(RAW, RAW_SENSOR);
473 CMP_STR(RGBA, RGBA_8888);
474
475 std::cerr << "Unknown format string " << str << std::endl;
476 return -1;
477
478 }
479
480 /**
481 * Creating a streaming request for these output streams from a template,
482 * and submit it
483 */
createSubmitRequestForStreams(int32_t * streamIds,size_t count,int requestCount=-1)484 void createSubmitRequestForStreams(int32_t* streamIds, size_t count, int requestCount=-1) {
485
486 ASSERT_NE((void*)NULL, streamIds);
487 ASSERT_LT(0u, count);
488
489 camera_metadata_t *requestTmp = NULL;
490 EXPECT_OK(mCamera->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
491 /*out*/&requestTmp));
492 ASSERT_NE((void*)NULL, requestTmp);
493 CameraMetadata request(requestTmp);
494
495 // set the output streams. default is empty
496
497 uint32_t tag = static_cast<uint32_t>(ANDROID_REQUEST_OUTPUT_STREAMS);
498 request.update(tag, streamIds, count);
499
500 requestTmp = request.release();
501
502 if (requestCount < 0) {
503 EXPECT_OK(mCamera->submitRequest(requestTmp, /*streaming*/true));
504 } else {
505 for (int i = 0; i < requestCount; ++i) {
506 EXPECT_OK(mCamera->submitRequest(requestTmp,
507 /*streaming*/false));
508 }
509 }
510 request.acquire(requestTmp);
511 }
512 };
513
514 sp<Thread> ProCameraTest::mTestThread;
515
TEST_F(ProCameraTest,AvailableFormats)516 TEST_F(ProCameraTest, AvailableFormats) {
517 if (HasFatalFailure()) {
518 return;
519 }
520
521 CameraMetadata staticInfo = mCamera->getCameraInfo(CAMERA_ID);
522 ASSERT_FALSE(staticInfo.isEmpty());
523
524 uint32_t tag = static_cast<uint32_t>(ANDROID_SCALER_AVAILABLE_FORMATS);
525 EXPECT_TRUE(staticInfo.exists(tag));
526 camera_metadata_entry_t entry = staticInfo.find(tag);
527
528 EXPECT_TRUE(ExistsItem<int32_t>(HAL_PIXEL_FORMAT_YV12,
529 entry.data.i32, entry.count));
530 EXPECT_TRUE(ExistsItem<int32_t>(HAL_PIXEL_FORMAT_YCrCb_420_SP,
531 entry.data.i32, entry.count));
532 }
533
534 // test around exclusiveTryLock (immediate locking)
TEST_F(ProCameraTest,LockingImmediate)535 TEST_F(ProCameraTest, LockingImmediate) {
536
537 if (HasFatalFailure()) {
538 return;
539 }
540
541 mListener->SetEventMask(ProEvent_Mask(ACQUIRED) |
542 ProEvent_Mask(STOLEN) |
543 ProEvent_Mask(RELEASED));
544
545 EXPECT_FALSE(mCamera->hasExclusiveLock());
546 EXPECT_EQ(OK, mCamera->exclusiveTryLock());
547 // at this point we definitely have the lock
548
549 EXPECT_EQ(OK, mListener->WaitForEvent());
550 EXPECT_EQ(ACQUIRED, mListener->ReadEvent());
551
552 EXPECT_TRUE(mCamera->hasExclusiveLock());
553 EXPECT_EQ(OK, mCamera->exclusiveUnlock());
554
555 EXPECT_EQ(OK, mListener->WaitForEvent());
556 EXPECT_EQ(RELEASED, mListener->ReadEvent());
557
558 EXPECT_FALSE(mCamera->hasExclusiveLock());
559 }
560
561 // test around exclusiveLock (locking at some future point in time)
TEST_F(ProCameraTest,LockingAsynchronous)562 TEST_F(ProCameraTest, LockingAsynchronous) {
563
564 if (HasFatalFailure()) {
565 return;
566 }
567
568
569 mListener->SetEventMask(ProEvent_Mask(ACQUIRED) |
570 ProEvent_Mask(STOLEN) |
571 ProEvent_Mask(RELEASED));
572
573 // TODO: Add another procamera that has a lock here.
574 // then we can be test that the lock wont immediately be acquired
575
576 EXPECT_FALSE(mCamera->hasExclusiveLock());
577 EXPECT_EQ(OK, mCamera->exclusiveTryLock());
578 // at this point we definitely have the lock
579
580 EXPECT_EQ(OK, mListener->WaitForEvent());
581 EXPECT_EQ(ACQUIRED, mListener->ReadEvent());
582
583 EXPECT_TRUE(mCamera->hasExclusiveLock());
584 EXPECT_EQ(OK, mCamera->exclusiveUnlock());
585
586 EXPECT_EQ(OK, mListener->WaitForEvent());
587 EXPECT_EQ(RELEASED, mListener->ReadEvent());
588
589 EXPECT_FALSE(mCamera->hasExclusiveLock());
590 }
591
592 // Stream directly to the screen.
TEST_F(ProCameraTest,DISABLED_StreamingImageSingle)593 TEST_F(ProCameraTest, DISABLED_StreamingImageSingle) {
594 if (HasFatalFailure()) {
595 return;
596 }
597
598 sp<Surface> surface;
599 if (mDisplaySecs > 0) {
600 createOnScreenSurface(/*out*/surface);
601 }
602 else {
603 dout << "Skipping, will not render to screen" << std::endl;
604 return;
605 }
606
607 int depthStreamId = -1;
608
609 sp<ServiceListener> listener = new ServiceListener();
610 EXPECT_OK(ProCamera::addServiceListener(listener));
611
612 ServiceListener::Status currentStatus;
613
614 // when subscribing a new listener,
615 // we immediately get a callback to the current status
616 while (listener->waitForStatusChange(/*out*/currentStatus) != OK);
617 EXPECT_EQ(ServiceListener::STATUS_PRESENT, currentStatus);
618
619 dout << "Will now stream and resume infinitely..." << std::endl;
620 while (true) {
621
622 if (currentStatus == ServiceListener::STATUS_PRESENT) {
623
624 ASSERT_OK(mCamera->createStream(mDisplayW, mDisplayH, mDisplayFmt,
625 surface,
626 &depthStreamId));
627 EXPECT_NE(-1, depthStreamId);
628
629 EXPECT_OK(mCamera->exclusiveTryLock());
630
631 int32_t streams[] = { depthStreamId };
632 ASSERT_NO_FATAL_FAILURE(createSubmitRequestForStreams(
633 streams,
634 /*count*/1));
635 }
636
637 ServiceListener::Status stat = ServiceListener::STATUS_UNKNOWN;
638
639 // TODO: maybe check for getch every once in a while?
640 while (listener->waitForStatusChange(/*out*/stat) != OK);
641
642 if (currentStatus != stat) {
643 if (stat == ServiceListener::STATUS_PRESENT) {
644 dout << "Reconnecting to camera" << std::endl;
645 mCamera = ProCamera::connect(CAMERA_ID);
646 } else if (stat == ServiceListener::STATUS_NOT_AVAILABLE) {
647 dout << "Disconnecting from camera" << std::endl;
648 mCamera->disconnect();
649 } else if (stat == ServiceListener::STATUS_NOT_PRESENT) {
650 dout << "Camera unplugged" << std::endl;
651 mCamera = NULL;
652 } else {
653 dout << "Unknown status change "
654 << std::hex << stat << std::endl;
655 }
656
657 currentStatus = stat;
658 }
659 }
660
661 EXPECT_OK(ProCamera::removeServiceListener(listener));
662 EXPECT_OK(mCamera->deleteStream(depthStreamId));
663 EXPECT_OK(mCamera->exclusiveUnlock());
664 }
665
666 // Stream directly to the screen.
TEST_F(ProCameraTest,DISABLED_StreamingImageDual)667 TEST_F(ProCameraTest, DISABLED_StreamingImageDual) {
668 if (HasFatalFailure()) {
669 return;
670 }
671 sp<Surface> surface;
672 sp<Surface> depthSurface;
673 if (mDisplaySecs > 0) {
674 createOnScreenSurface(/*out*/surface);
675 createDepthOnScreenSurface(/*out*/depthSurface);
676 }
677
678 int streamId = -1;
679 EXPECT_OK(mCamera->createStream(/*width*/1280, /*height*/960,
680 TEST_FORMAT_MAIN, surface, &streamId));
681 EXPECT_NE(-1, streamId);
682
683 int depthStreamId = -1;
684 EXPECT_OK(mCamera->createStream(/*width*/320, /*height*/240,
685 TEST_FORMAT_DEPTH, depthSurface, &depthStreamId));
686 EXPECT_NE(-1, depthStreamId);
687
688 EXPECT_OK(mCamera->exclusiveTryLock());
689 /*
690 */
691 /* iterate in a loop submitting requests every frame.
692 * what kind of requests doesnt really matter, just whatever.
693 */
694
695 // it would probably be better to use CameraMetadata from camera service.
696 camera_metadata_t *request = NULL;
697 EXPECT_OK(mCamera->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
698 /*out*/&request));
699 EXPECT_NE((void*)NULL, request);
700
701 /*FIXME: dont need this later, at which point the above should become an
702 ASSERT_NE*/
703 if(request == NULL) request = allocate_camera_metadata(10, 100);
704
705 // set the output streams to just this stream ID
706
707 // wow what a verbose API.
708 int32_t allStreams[] = { streamId, depthStreamId };
709 // IMPORTANT. bad things will happen if its not a uint8.
710 size_t streamCount = sizeof(allStreams) / sizeof(allStreams[0]);
711 camera_metadata_entry_t entry;
712 uint32_t tag = static_cast<uint32_t>(ANDROID_REQUEST_OUTPUT_STREAMS);
713 int find = find_camera_metadata_entry(request, tag, &entry);
714 if (find == -ENOENT) {
715 if (add_camera_metadata_entry(request, tag, &allStreams,
716 /*data_count*/streamCount) != OK) {
717 camera_metadata_t *tmp = allocate_camera_metadata(1000, 10000);
718 ASSERT_OK(append_camera_metadata(tmp, request));
719 free_camera_metadata(request);
720 request = tmp;
721
722 ASSERT_OK(add_camera_metadata_entry(request, tag, &allStreams,
723 /*data_count*/streamCount));
724 }
725 } else {
726 ASSERT_OK(update_camera_metadata_entry(request, entry.index,
727 &allStreams, /*data_count*/streamCount, &entry));
728 }
729
730 EXPECT_OK(mCamera->submitRequest(request, /*streaming*/true));
731
732 dout << "will sleep now for " << mDisplaySecs << std::endl;
733 sleep(mDisplaySecs);
734
735 free_camera_metadata(request);
736
737 for (size_t i = 0; i < streamCount; ++i) {
738 EXPECT_OK(mCamera->deleteStream(allStreams[i]));
739 }
740 EXPECT_OK(mCamera->exclusiveUnlock());
741 }
742
TEST_F(ProCameraTest,CpuConsumerSingle)743 TEST_F(ProCameraTest, CpuConsumerSingle) {
744 if (HasFatalFailure()) {
745 return;
746 }
747
748 mListener->SetEventMask(ProEvent_Mask(ACQUIRED) |
749 ProEvent_Mask(STOLEN) |
750 ProEvent_Mask(RELEASED) |
751 ProEvent_Mask(FRAME_RECEIVED));
752 mListener->SetDropFrames(true);
753
754 int streamId = -1;
755 sp<CpuConsumer> consumer;
756 EXPECT_OK(mCamera->createStreamCpu(/*width*/320, /*height*/240,
757 TEST_FORMAT_DEPTH, TEST_CPU_HEAP_COUNT, &consumer, &streamId));
758 EXPECT_NE(-1, streamId);
759
760 EXPECT_OK(mCamera->exclusiveTryLock());
761 EXPECT_EQ(OK, mListener->WaitForEvent());
762 EXPECT_EQ(ACQUIRED, mListener->ReadEvent());
763 /* iterate in a loop submitting requests every frame.
764 * what kind of requests doesnt really matter, just whatever.
765 */
766
767 // it would probably be better to use CameraMetadata from camera service.
768 camera_metadata_t *request = NULL;
769 EXPECT_OK(mCamera->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
770 /*out*/&request));
771 EXPECT_NE((void*)NULL, request);
772
773 /*FIXME: dont need this later, at which point the above should become an
774 ASSERT_NE*/
775 if(request == NULL) request = allocate_camera_metadata(10, 100);
776
777 // set the output streams to just this stream ID
778
779 int32_t allStreams[] = { streamId };
780 camera_metadata_entry_t entry;
781 uint32_t tag = static_cast<uint32_t>(ANDROID_REQUEST_OUTPUT_STREAMS);
782 int find = find_camera_metadata_entry(request, tag, &entry);
783 if (find == -ENOENT) {
784 if (add_camera_metadata_entry(request, tag, &allStreams,
785 /*data_count*/1) != OK) {
786 camera_metadata_t *tmp = allocate_camera_metadata(1000, 10000);
787 ASSERT_OK(append_camera_metadata(tmp, request));
788 free_camera_metadata(request);
789 request = tmp;
790
791 ASSERT_OK(add_camera_metadata_entry(request, tag, &allStreams,
792 /*data_count*/1));
793 }
794 } else {
795 ASSERT_OK(update_camera_metadata_entry(request, entry.index,
796 &allStreams, /*data_count*/1, &entry));
797 }
798
799 EXPECT_OK(mCamera->submitRequest(request, /*streaming*/true));
800
801 // Consume a couple of frames
802 for (int i = 0; i < TEST_CPU_FRAME_COUNT; ++i) {
803 EXPECT_EQ(OK, mListener->WaitForEvent());
804 EXPECT_EQ(FRAME_RECEIVED, mListener->ReadEvent());
805 }
806
807 // Done: clean up
808 free_camera_metadata(request);
809 EXPECT_OK(mCamera->deleteStream(streamId));
810 EXPECT_OK(mCamera->exclusiveUnlock());
811 }
812
TEST_F(ProCameraTest,CpuConsumerDual)813 TEST_F(ProCameraTest, CpuConsumerDual) {
814 if (HasFatalFailure()) {
815 return;
816 }
817
818 mListener->SetEventMask(ProEvent_Mask(FRAME_RECEIVED));
819 mListener->SetDropFrames(true);
820
821 int streamId = -1;
822 sp<CpuConsumer> consumer;
823 EXPECT_OK(mCamera->createStreamCpu(/*width*/1280, /*height*/960,
824 TEST_FORMAT_MAIN, TEST_CPU_HEAP_COUNT, &consumer, &streamId));
825 EXPECT_NE(-1, streamId);
826
827 int depthStreamId = -1;
828 EXPECT_OK(mCamera->createStreamCpu(/*width*/320, /*height*/240,
829 TEST_FORMAT_DEPTH, TEST_CPU_HEAP_COUNT, &consumer, &depthStreamId));
830 EXPECT_NE(-1, depthStreamId);
831
832 EXPECT_OK(mCamera->exclusiveTryLock());
833 /*
834 */
835 /* iterate in a loop submitting requests every frame.
836 * what kind of requests doesnt really matter, just whatever.
837 */
838
839 // it would probably be better to use CameraMetadata from camera service.
840 camera_metadata_t *request = NULL;
841 EXPECT_OK(mCamera->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
842 /*out*/&request));
843 EXPECT_NE((void*)NULL, request);
844
845 if(request == NULL) request = allocate_camera_metadata(10, 100);
846
847 // set the output streams to just this stream ID
848
849 // wow what a verbose API.
850 int32_t allStreams[] = { streamId, depthStreamId };
851 size_t streamCount = 2;
852 camera_metadata_entry_t entry;
853 uint32_t tag = static_cast<uint32_t>(ANDROID_REQUEST_OUTPUT_STREAMS);
854 int find = find_camera_metadata_entry(request, tag, &entry);
855 if (find == -ENOENT) {
856 if (add_camera_metadata_entry(request, tag, &allStreams,
857 /*data_count*/streamCount) != OK) {
858 camera_metadata_t *tmp = allocate_camera_metadata(1000, 10000);
859 ASSERT_OK(append_camera_metadata(tmp, request));
860 free_camera_metadata(request);
861 request = tmp;
862
863 ASSERT_OK(add_camera_metadata_entry(request, tag, &allStreams,
864 /*data_count*/streamCount));
865 }
866 } else {
867 ASSERT_OK(update_camera_metadata_entry(request, entry.index,
868 &allStreams, /*data_count*/streamCount, &entry));
869 }
870
871 EXPECT_OK(mCamera->submitRequest(request, /*streaming*/true));
872
873 // Consume a couple of frames
874 for (int i = 0; i < TEST_CPU_FRAME_COUNT; ++i) {
875 // stream id 1
876 EXPECT_EQ(OK, mListener->WaitForEvent());
877 EXPECT_EQ(FRAME_RECEIVED, mListener->ReadEvent());
878
879 // stream id 2
880 EXPECT_EQ(OK, mListener->WaitForEvent());
881 EXPECT_EQ(FRAME_RECEIVED, mListener->ReadEvent());
882
883 //TODO: events should be a struct with some data like the stream id
884 }
885
886 // Done: clean up
887 free_camera_metadata(request);
888 EXPECT_OK(mCamera->deleteStream(streamId));
889 EXPECT_OK(mCamera->exclusiveUnlock());
890 }
891
TEST_F(ProCameraTest,ResultReceiver)892 TEST_F(ProCameraTest, ResultReceiver) {
893 if (HasFatalFailure()) {
894 return;
895 }
896
897 mListener->SetEventMask(ProEvent_Mask(RESULT_RECEIVED));
898 mListener->SetDropFrames(true);
899 //FIXME: if this is run right after the previous test we get FRAME_RECEIVED
900 // need to filter out events at read time
901
902 int streamId = -1;
903 sp<CpuConsumer> consumer;
904 EXPECT_OK(mCamera->createStreamCpu(/*width*/1280, /*height*/960,
905 TEST_FORMAT_MAIN, TEST_CPU_HEAP_COUNT, &consumer, &streamId));
906 EXPECT_NE(-1, streamId);
907
908 EXPECT_OK(mCamera->exclusiveTryLock());
909 /*
910 */
911 /* iterate in a loop submitting requests every frame.
912 * what kind of requests doesnt really matter, just whatever.
913 */
914
915 camera_metadata_t *request = NULL;
916 EXPECT_OK(mCamera->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
917 /*out*/&request));
918 EXPECT_NE((void*)NULL, request);
919
920 /*FIXME*/
921 if(request == NULL) request = allocate_camera_metadata(10, 100);
922
923 // set the output streams to just this stream ID
924
925 int32_t allStreams[] = { streamId };
926 size_t streamCount = 1;
927 camera_metadata_entry_t entry;
928 uint32_t tag = static_cast<uint32_t>(ANDROID_REQUEST_OUTPUT_STREAMS);
929 int find = find_camera_metadata_entry(request, tag, &entry);
930 if (find == -ENOENT) {
931 if (add_camera_metadata_entry(request, tag, &allStreams,
932 /*data_count*/streamCount) != OK) {
933 camera_metadata_t *tmp = allocate_camera_metadata(1000, 10000);
934 ASSERT_OK(append_camera_metadata(tmp, request));
935 free_camera_metadata(request);
936 request = tmp;
937
938 ASSERT_OK(add_camera_metadata_entry(request, tag, &allStreams,
939 /*data_count*/streamCount));
940 }
941 } else {
942 ASSERT_OK(update_camera_metadata_entry(request, entry.index,
943 &allStreams, /*data_count*/streamCount, &entry));
944 }
945
946 EXPECT_OK(mCamera->submitRequest(request, /*streaming*/true));
947
948 // Consume a couple of results
949 for (int i = 0; i < TEST_CPU_FRAME_COUNT; ++i) {
950 EXPECT_EQ(OK, mListener->WaitForEvent());
951 EXPECT_EQ(RESULT_RECEIVED, mListener->ReadEvent());
952 }
953
954 // Done: clean up
955 free_camera_metadata(request);
956 EXPECT_OK(mCamera->deleteStream(streamId));
957 EXPECT_OK(mCamera->exclusiveUnlock());
958 }
959
960 // FIXME: This is racy and sometimes fails on waitForFrameMetadata
TEST_F(ProCameraTest,DISABLED_WaitForResult)961 TEST_F(ProCameraTest, DISABLED_WaitForResult) {
962 if (HasFatalFailure()) {
963 return;
964 }
965
966 mListener->SetDropFrames(true);
967
968 int streamId = -1;
969 sp<CpuConsumer> consumer;
970 EXPECT_OK(mCamera->createStreamCpu(/*width*/1280, /*height*/960,
971 TEST_FORMAT_MAIN, TEST_CPU_HEAP_COUNT, &consumer, &streamId));
972 EXPECT_NE(-1, streamId);
973
974 EXPECT_OK(mCamera->exclusiveTryLock());
975
976 int32_t streams[] = { streamId };
977 ASSERT_NO_FATAL_FAILURE(createSubmitRequestForStreams(streams, /*count*/1));
978
979 // Consume a couple of results
980 for (int i = 0; i < TEST_CPU_FRAME_COUNT; ++i) {
981 EXPECT_OK(mCamera->waitForFrameMetadata());
982 CameraMetadata meta = mCamera->consumeFrameMetadata();
983 EXPECT_FALSE(meta.isEmpty());
984 }
985
986 // Done: clean up
987 EXPECT_OK(mCamera->deleteStream(streamId));
988 EXPECT_OK(mCamera->exclusiveUnlock());
989 }
990
TEST_F(ProCameraTest,WaitForSingleStreamBuffer)991 TEST_F(ProCameraTest, WaitForSingleStreamBuffer) {
992 if (HasFatalFailure()) {
993 return;
994 }
995
996 int streamId = -1;
997 sp<CpuConsumer> consumer;
998 EXPECT_OK(mCamera->createStreamCpu(/*width*/1280, /*height*/960,
999 TEST_FORMAT_MAIN, TEST_CPU_HEAP_COUNT, &consumer, &streamId));
1000 EXPECT_NE(-1, streamId);
1001
1002 EXPECT_OK(mCamera->exclusiveTryLock());
1003
1004 int32_t streams[] = { streamId };
1005 ASSERT_NO_FATAL_FAILURE(createSubmitRequestForStreams(streams, /*count*/1,
1006 /*requests*/TEST_CPU_FRAME_COUNT));
1007
1008 // Consume a couple of results
1009 for (int i = 0; i < TEST_CPU_FRAME_COUNT; ++i) {
1010 EXPECT_EQ(1, mCamera->waitForFrameBuffer(streamId));
1011
1012 CpuConsumer::LockedBuffer buf;
1013 EXPECT_OK(consumer->lockNextBuffer(&buf));
1014
1015 dout << "Buffer synchronously received on streamId = " << streamId <<
1016 ", dataPtr = " << (void*)buf.data <<
1017 ", timestamp = " << buf.timestamp << std::endl;
1018
1019 EXPECT_OK(consumer->unlockBuffer(buf));
1020 }
1021
1022 // Done: clean up
1023 EXPECT_OK(mCamera->deleteStream(streamId));
1024 EXPECT_OK(mCamera->exclusiveUnlock());
1025 }
1026
1027 // FIXME: This is racy and sometimes fails on waitForFrameMetadata
TEST_F(ProCameraTest,DISABLED_WaitForDualStreamBuffer)1028 TEST_F(ProCameraTest, DISABLED_WaitForDualStreamBuffer) {
1029 if (HasFatalFailure()) {
1030 return;
1031 }
1032
1033 const int REQUEST_COUNT = TEST_CPU_FRAME_COUNT * 10;
1034
1035 // 15 fps
1036 int streamId = -1;
1037 sp<CpuConsumer> consumer;
1038 EXPECT_OK(mCamera->createStreamCpu(/*width*/1280, /*height*/960,
1039 TEST_FORMAT_MAIN, TEST_CPU_HEAP_COUNT, &consumer, &streamId));
1040 EXPECT_NE(-1, streamId);
1041
1042 // 30 fps
1043 int depthStreamId = -1;
1044 sp<CpuConsumer> depthConsumer;
1045 EXPECT_OK(mCamera->createStreamCpu(/*width*/320, /*height*/240,
1046 TEST_FORMAT_DEPTH, TEST_CPU_HEAP_COUNT, &depthConsumer, &depthStreamId));
1047 EXPECT_NE(-1, depthStreamId);
1048
1049 EXPECT_OK(mCamera->exclusiveTryLock());
1050
1051 int32_t streams[] = { streamId, depthStreamId };
1052 ASSERT_NO_FATAL_FAILURE(createSubmitRequestForStreams(streams, /*count*/2,
1053 /*requests*/REQUEST_COUNT));
1054
1055 int depthFrames = 0;
1056 int greyFrames = 0;
1057
1058 // Consume two frames simultaneously. Unsynchronized by timestamps.
1059 for (int i = 0; i < REQUEST_COUNT; ++i) {
1060
1061 // Exhaust event queue so it doesn't keep growing
1062 while (mListener->ReadEvent() != UNKNOWN);
1063
1064 // Get the metadata
1065 EXPECT_OK(mCamera->waitForFrameMetadata());
1066 CameraMetadata meta = mCamera->consumeFrameMetadata();
1067 EXPECT_FALSE(meta.isEmpty());
1068
1069 // Get the buffers
1070
1071 EXPECT_EQ(1, mCamera->waitForFrameBuffer(depthStreamId));
1072
1073 /**
1074 * Guaranteed to be able to consume the depth frame,
1075 * since we waited on it.
1076 */
1077 CpuConsumer::LockedBuffer depthBuffer;
1078 EXPECT_OK(depthConsumer->lockNextBuffer(&depthBuffer));
1079
1080 dout << "Depth Buffer synchronously received on streamId = " <<
1081 streamId <<
1082 ", dataPtr = " << (void*)depthBuffer.data <<
1083 ", timestamp = " << depthBuffer.timestamp << std::endl;
1084
1085 EXPECT_OK(depthConsumer->unlockBuffer(depthBuffer));
1086
1087 depthFrames++;
1088
1089
1090 /** Consume Greyscale frames if there are any.
1091 * There may not be since it runs at half FPS */
1092 CpuConsumer::LockedBuffer greyBuffer;
1093 while (consumer->lockNextBuffer(&greyBuffer) == OK) {
1094
1095 dout << "GRAY Buffer synchronously received on streamId = " <<
1096 streamId <<
1097 ", dataPtr = " << (void*)greyBuffer.data <<
1098 ", timestamp = " << greyBuffer.timestamp << std::endl;
1099
1100 EXPECT_OK(consumer->unlockBuffer(greyBuffer));
1101
1102 greyFrames++;
1103 }
1104 }
1105
1106 dout << "Done, summary: depth frames " << std::dec << depthFrames
1107 << ", grey frames " << std::dec << greyFrames << std::endl;
1108
1109 // Done: clean up
1110 EXPECT_OK(mCamera->deleteStream(streamId));
1111 EXPECT_OK(mCamera->exclusiveUnlock());
1112 }
1113
TEST_F(ProCameraTest,WaitForSingleStreamBufferAndDropFramesSync)1114 TEST_F(ProCameraTest, WaitForSingleStreamBufferAndDropFramesSync) {
1115 if (HasFatalFailure()) {
1116 return;
1117 }
1118
1119 const int NUM_REQUESTS = 20 * TEST_CPU_FRAME_COUNT;
1120
1121 int streamId = -1;
1122 sp<CpuConsumer> consumer;
1123 EXPECT_OK(mCamera->createStreamCpu(/*width*/1280, /*height*/960,
1124 TEST_FORMAT_MAIN, TEST_CPU_HEAP_COUNT,
1125 /*synchronousMode*/true, &consumer, &streamId));
1126 EXPECT_NE(-1, streamId);
1127
1128 EXPECT_OK(mCamera->exclusiveTryLock());
1129
1130 int32_t streams[] = { streamId };
1131 ASSERT_NO_FATAL_FAILURE(createSubmitRequestForStreams(streams, /*count*/1,
1132 /*requests*/NUM_REQUESTS));
1133
1134 // Consume a couple of results
1135 for (int i = 0; i < NUM_REQUESTS; ++i) {
1136 int numFrames;
1137 EXPECT_TRUE((numFrames = mCamera->waitForFrameBuffer(streamId)) > 0);
1138
1139 // Drop all but the newest framebuffer
1140 EXPECT_EQ(numFrames-1, mCamera->dropFrameBuffer(streamId, numFrames-1));
1141
1142 dout << "Dropped " << (numFrames - 1) << " frames" << std::endl;
1143
1144 // Skip the counter ahead, don't try to consume these frames again
1145 i += numFrames-1;
1146
1147 // "Consume" the buffer
1148 CpuConsumer::LockedBuffer buf;
1149 EXPECT_OK(consumer->lockNextBuffer(&buf));
1150
1151 dout << "Buffer synchronously received on streamId = " << streamId <<
1152 ", dataPtr = " << (void*)buf.data <<
1153 ", timestamp = " << buf.timestamp << std::endl;
1154
1155 // Process at 10fps, stream is at 15fps.
1156 // This means we will definitely fill up the buffer queue with
1157 // extra buffers and need to drop them.
1158 usleep(TEST_FRAME_PROCESSING_DELAY_US);
1159
1160 EXPECT_OK(consumer->unlockBuffer(buf));
1161 }
1162
1163 // Done: clean up
1164 EXPECT_OK(mCamera->deleteStream(streamId));
1165 EXPECT_OK(mCamera->exclusiveUnlock());
1166 }
1167
TEST_F(ProCameraTest,WaitForSingleStreamBufferAndDropFramesAsync)1168 TEST_F(ProCameraTest, WaitForSingleStreamBufferAndDropFramesAsync) {
1169 if (HasFatalFailure()) {
1170 return;
1171 }
1172
1173 const int NUM_REQUESTS = 20 * TEST_CPU_FRAME_COUNT;
1174
1175 int streamId = -1;
1176 sp<CpuConsumer> consumer;
1177 EXPECT_OK(mCamera->createStreamCpu(/*width*/1280, /*height*/960,
1178 TEST_FORMAT_MAIN, TEST_CPU_HEAP_COUNT,
1179 /*synchronousMode*/false, &consumer, &streamId));
1180 EXPECT_NE(-1, streamId);
1181
1182 EXPECT_OK(mCamera->exclusiveTryLock());
1183
1184 int32_t streams[] = { streamId };
1185 ASSERT_NO_FATAL_FAILURE(createSubmitRequestForStreams(streams, /*count*/1,
1186 /*requests*/NUM_REQUESTS));
1187
1188 uint64_t lastFrameNumber = 0;
1189 int numFrames;
1190
1191 // Consume a couple of results
1192 int i;
1193 for (i = 0; i < NUM_REQUESTS && lastFrameNumber < NUM_REQUESTS; ++i) {
1194 EXPECT_LT(0, (numFrames = mCamera->waitForFrameBuffer(streamId)));
1195
1196 dout << "Dropped " << (numFrames - 1) << " frames" << std::endl;
1197
1198 // Skip the counter ahead, don't try to consume these frames again
1199 i += numFrames-1;
1200
1201 // "Consume" the buffer
1202 CpuConsumer::LockedBuffer buf;
1203
1204 EXPECT_EQ(OK, consumer->lockNextBuffer(&buf));
1205
1206 lastFrameNumber = buf.frameNumber;
1207
1208 dout << "Buffer asynchronously received on streamId = " << streamId <<
1209 ", dataPtr = " << (void*)buf.data <<
1210 ", timestamp = " << buf.timestamp <<
1211 ", framenumber = " << buf.frameNumber << std::endl;
1212
1213 // Process at 10fps, stream is at 15fps.
1214 // This means we will definitely fill up the buffer queue with
1215 // extra buffers and need to drop them.
1216 usleep(TEST_FRAME_PROCESSING_DELAY_US);
1217
1218 EXPECT_OK(consumer->unlockBuffer(buf));
1219 }
1220
1221 dout << "Done after " << i << " iterations " << std::endl;
1222
1223 // Done: clean up
1224 EXPECT_OK(mCamera->deleteStream(streamId));
1225 EXPECT_OK(mCamera->exclusiveUnlock());
1226 }
1227
1228
1229
1230 //TODO: refactor into separate file
TEST_F(ProCameraTest,ServiceListenersSubscribe)1231 TEST_F(ProCameraTest, ServiceListenersSubscribe) {
1232
1233 ASSERT_EQ(4u, sizeof(ServiceListener::Status));
1234
1235 sp<ServiceListener> listener = new ServiceListener();
1236
1237 EXPECT_EQ(BAD_VALUE, ProCamera::removeServiceListener(listener));
1238 EXPECT_OK(ProCamera::addServiceListener(listener));
1239
1240 EXPECT_EQ(ALREADY_EXISTS, ProCamera::addServiceListener(listener));
1241 EXPECT_OK(ProCamera::removeServiceListener(listener));
1242
1243 EXPECT_EQ(BAD_VALUE, ProCamera::removeServiceListener(listener));
1244 }
1245
1246 //TODO: refactor into separate file
TEST_F(ProCameraTest,ServiceListenersFunctional)1247 TEST_F(ProCameraTest, ServiceListenersFunctional) {
1248
1249 sp<ServiceListener> listener = new ServiceListener();
1250
1251 EXPECT_OK(ProCamera::addServiceListener(listener));
1252
1253 sp<Camera> cam = Camera::connect(CAMERA_ID,
1254 /*clientPackageName*/String16(),
1255 -1);
1256 EXPECT_NE((void*)NULL, cam.get());
1257
1258 ServiceListener::Status stat = ServiceListener::STATUS_UNKNOWN;
1259 EXPECT_OK(listener->waitForStatusChange(/*out*/stat));
1260
1261 EXPECT_EQ(ServiceListener::STATUS_NOT_AVAILABLE, stat);
1262
1263 if (cam.get()) {
1264 cam->disconnect();
1265 }
1266
1267 EXPECT_OK(listener->waitForStatusChange(/*out*/stat));
1268 EXPECT_EQ(ServiceListener::STATUS_PRESENT, stat);
1269
1270 EXPECT_OK(ProCamera::removeServiceListener(listener));
1271 }
1272
1273
1274
1275 }
1276 }
1277 }
1278 }
1279