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 "NativeCamera"
19 #include <log/log.h>
20
21 #include <chrono>
22 #include <cinttypes>
23 #include <condition_variable>
24 #include <dlfcn.h>
25 #include <map>
26 #include <mutex>
27 #include <string>
28 #include <vector>
29 #include <unistd.h>
30 #include <assert.h>
31 #include <jni.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <unordered_map>
35 #include <set>
36
37 #include <android/native_window_jni.h>
38
39 #include "camera/NdkCameraError.h"
40 #include "camera/NdkCameraManager.h"
41 #include "camera/NdkCameraMetadata.h"
42 #include "camera/NdkCameraDevice.h"
43 #include "camera/NdkCameraCaptureSession.h"
44 #include "media/NdkImage.h"
45 #include "media/NdkImageReader.h"
46
47 #include "NdkNameToTag.h"
48
49 #define LOG_ERROR(buf, ...) sprintf(buf, __VA_ARGS__); \
50 ALOGE("%s", buf);
51
52 namespace {
53 const int MAX_ERROR_STRING_LEN = 512;
54 char errorString[MAX_ERROR_STRING_LEN];
55 }
56
57 template <>
58 struct std::default_delete<ACameraMetadata> {
operator ()std::default_delete59 inline void operator()(ACameraMetadata* chars) const { ACameraMetadata_free(chars); }
60 };
61
62 const char kLibandroidPath[] = "libcamera2ndk.so";
63
64 typedef camera_status_t (*ACameraManager_openSharedCameraNative)(
65 ACameraManager* manager, const char* cameraId, ACameraDevice_StateCallbacks* callback,
66 /*out*/ ACameraDevice** device, /*out*/ bool* isPrimaryClient);
67 typedef camera_status_t (*ACameraManager_isCameraDeviceSharingSupportedNative)(
68 ACameraManager* manager, const char* cameraId, bool* isSharingSupported);
69 typedef camera_status_t (*ACameraCaptureSessionShared_startStreamingNative)(
70 ACameraCaptureSession* sharedSession, ACameraCaptureSession_captureCallbacksV2 *callbacks,
71 int numOutputWindows, ANativeWindow **window, int *captureSequenceId);
72 typedef camera_status_t (*ACameraCaptureSessionShared_stopStreamingNative)(
73 ACameraCaptureSession* sharedSession);
74
75 template <typename T>
getLibFunction(void * handle,const char * identifier,T * out)76 void getLibFunction(void* handle, const char* identifier, T* out) {
77 auto result = reinterpret_cast<T>(dlsym(handle, identifier));
78 if (!result) {
79 ALOGE("dlsym error: %s %s %s", __func__, dlerror(), identifier);
80 assert(result);
81 }
82 *out = result;
83 }
84
85 class CameraServiceListener {
86 public:
87 typedef std::set<std::pair<std::string, std::string>> StringPairSet;
88
onAvailable(void * obj,const char * cameraId)89 static void onAvailable(void* obj, const char* cameraId) {
90 ALOGV("Camera %s onAvailable", cameraId);
91 if (obj == nullptr) {
92 return;
93 }
94 CameraServiceListener* thiz = reinterpret_cast<CameraServiceListener*>(obj);
95 std::lock_guard<std::mutex> lock(thiz->mMutex);
96 thiz->mOnAvailableCount++;
97 thiz->mAvailableMap[cameraId] = true;
98 return;
99 }
100
onUnavailable(void * obj,const char * cameraId)101 static void onUnavailable(void* obj, const char* cameraId) {
102 ALOGV("Camera %s onUnavailable", cameraId);
103 if (obj == nullptr) {
104 return;
105 }
106 CameraServiceListener* thiz = reinterpret_cast<CameraServiceListener*>(obj);
107 std::lock_guard<std::mutex> lock(thiz->mMutex);
108 thiz->mOnUnavailableCount++;
109 thiz->mAvailableMap[cameraId] = false;
110 return;
111 }
112
113
onCameraAccessPrioritiesChanged(void * obj)114 static void onCameraAccessPrioritiesChanged(void* obj) {
115 ALOGV("onCameraAccessPrioritiesChanged");
116 if (obj == nullptr) {
117 return;
118 }
119 CameraServiceListener* thiz = reinterpret_cast<CameraServiceListener*>(obj);
120 std::lock_guard<std::mutex> lock(thiz->mMutex);
121 thiz->mOnCameraAccessPrioritiesChangedCount++;
122 return;
123 }
124
onPhysicalCameraAvailable(void * obj,const char * cameraId,const char * physicalCameraId)125 static void onPhysicalCameraAvailable(void* obj, const char* cameraId,
126 const char* physicalCameraId) {
127 ALOGV("Camera %s : %s onAvailable", cameraId, physicalCameraId);
128 if (obj == nullptr) {
129 return;
130 }
131 CameraServiceListener* thiz = reinterpret_cast<CameraServiceListener*>(obj);
132 std::lock_guard<std::mutex> lock(thiz->mMutex);
133 thiz->mOnPhysicalCameraAvailableCount++;
134 return;
135 }
136
onPhysicalCameraUnavailable(void * obj,const char * cameraId,const char * physicalCameraId)137 static void onPhysicalCameraUnavailable(void* obj, const char* cameraId,
138 const char* physicalCameraId) {
139 ALOGV("Camera %s : %s onUnavailable", cameraId, physicalCameraId);
140 if (obj == nullptr) {
141 return;
142 }
143 CameraServiceListener* thiz = reinterpret_cast<CameraServiceListener*>(obj);
144 std::lock_guard<std::mutex> lock(thiz->mMutex);
145 thiz->mUnavailablePhysicalCameras.emplace(cameraId, physicalCameraId);
146 return;
147 }
148
149
resetCount()150 void resetCount() {
151 std::lock_guard<std::mutex> lock(mMutex);
152 mOnAvailableCount = 0;
153 mOnUnavailableCount = 0;
154 mOnCameraAccessPrioritiesChangedCount = 0;
155 mOnPhysicalCameraAvailableCount = 0;
156 mUnavailablePhysicalCameras.clear();
157 return;
158 }
159
getAvailableCount()160 int getAvailableCount() {
161 std::lock_guard<std::mutex> lock(mMutex);
162 return mOnAvailableCount;
163 }
164
getUnavailableCount()165 int getUnavailableCount() {
166 std::lock_guard<std::mutex> lock(mMutex);
167 return mOnUnavailableCount;
168 }
169
getCameraAccessPrioritiesChangedCount()170 int getCameraAccessPrioritiesChangedCount() {
171 std::lock_guard<std::mutex> lock(mMutex);
172 return mOnCameraAccessPrioritiesChangedCount;
173 }
174
getPhysicalCameraAvailableCount()175 int getPhysicalCameraAvailableCount() {
176 std::lock_guard<std::mutex> lock(mMutex);
177 return mOnPhysicalCameraAvailableCount;
178 }
179
getUnavailablePhysicalCameras()180 StringPairSet getUnavailablePhysicalCameras() {
181 std::lock_guard<std::mutex> lock(mMutex);
182 return mUnavailablePhysicalCameras;
183 }
184
isAvailable(const char * cameraId)185 bool isAvailable(const char* cameraId) {
186 std::lock_guard<std::mutex> lock(mMutex);
187 if (mAvailableMap.count(cameraId) == 0) {
188 return false;
189 }
190 return mAvailableMap[cameraId];
191 }
192
193 private:
194 std::mutex mMutex;
195 int mOnAvailableCount = 0;
196 int mOnUnavailableCount = 0;
197 int mOnCameraAccessPrioritiesChangedCount = 0;
198 int mOnPhysicalCameraAvailableCount = 0;
199 std::map<std::string, bool> mAvailableMap;
200 StringPairSet mUnavailablePhysicalCameras;
201 };
202
203 class CameraDeviceListener {
204 public:
onDisconnected(void * obj,ACameraDevice * device)205 static void onDisconnected(void* obj, ACameraDevice* device) {
206 ALOGV("Camera %s is disconnected!", ACameraDevice_getId(device));
207 if (obj == nullptr) {
208 return;
209 }
210 CameraDeviceListener* thiz = reinterpret_cast<CameraDeviceListener*>(obj);
211 std::lock_guard<std::mutex> lock(thiz->mMutex);
212 thiz->mOnDisconnect++;
213 return;
214 }
215
onError(void * obj,ACameraDevice * device,int errorCode)216 static void onError(void* obj, ACameraDevice* device, int errorCode) {
217 ALOGV("Camera %s receive error %d!", ACameraDevice_getId(device), errorCode);
218 if (obj == nullptr) {
219 return;
220 }
221 CameraDeviceListener* thiz = reinterpret_cast<CameraDeviceListener*>(obj);
222 std::lock_guard<std::mutex> lock(thiz->mMutex);
223 thiz->mOnError++;
224 thiz->mLatestError = errorCode;
225 return;
226 }
227
onClientSharedAccessPriorityChanged(void * obj,ACameraDevice * device,bool primaryClient)228 static void onClientSharedAccessPriorityChanged(void* obj, ACameraDevice* device, bool primaryClient) {
229 ALOGV("Camera %s receive onClientSharedAccessPriorityChanged %d!",
230 ACameraDevice_getId(device), primaryClient);
231 if (obj == nullptr) {
232 return;
233 }
234 CameraDeviceListener* thiz = reinterpret_cast<CameraDeviceListener*>(obj);
235 std::lock_guard<std::mutex> lock(thiz->mMutex);
236 thiz->mOnClientAccessPrioritiesChangedCount++;
237 thiz->mClientSharedModeStatus = primaryClient;
238 return;
239 }
240
getDisconnectCount()241 int getDisconnectCount() {
242 std::lock_guard<std::mutex> lock(mMutex);
243 return mOnDisconnect;
244 }
245
getClientAccessPrioritiesChangedCountAndReset()246 int getClientAccessPrioritiesChangedCountAndReset() {
247 std::lock_guard<std::mutex> lock(mMutex);
248 int ret = mOnClientAccessPrioritiesChangedCount;
249 mOnClientAccessPrioritiesChangedCount = 0;
250 return ret;
251 }
252
getClientSharedModeStatus()253 bool getClientSharedModeStatus() {
254 std::lock_guard<std::mutex> lock(mMutex);
255 return mClientSharedModeStatus;
256 }
257
258 private:
259 std::mutex mMutex;
260 int mOnDisconnect = 0;
261 int mOnClientAccessPrioritiesChangedCount = 0;
262 bool mClientSharedModeStatus;
263 int mOnError = 0;
264 int mLatestError = 0;
265 };
266
267 class CaptureSessionListener {
268
269 public:
onClosed(void * obj,ACameraCaptureSession * session)270 static void onClosed(void* obj, ACameraCaptureSession *session) {
271 // TODO: might want an API to query cameraId even session is closed?
272 ALOGV("Session %p is closed!", session);
273 if (obj == nullptr) {
274 return;
275 }
276 CaptureSessionListener* thiz = reinterpret_cast<CaptureSessionListener*>(obj);
277 std::lock_guard<std::mutex> lock(thiz->mMutex);
278 thiz->mIsClosed = true;
279 thiz->mOnClosed++; // Should never > 1
280 }
281
onReady(void * obj,ACameraCaptureSession * session)282 static void onReady(void* obj, ACameraCaptureSession *session) {
283 ALOGV("%s", __FUNCTION__);
284 if (obj == nullptr) {
285 return;
286 }
287 CaptureSessionListener* thiz = reinterpret_cast<CaptureSessionListener*>(obj);
288 std::lock_guard<std::mutex> lock(thiz->mMutex);
289 ACameraDevice* device = nullptr;
290 camera_status_t ret = ACameraCaptureSession_getDevice(session, &device);
291 // There will be one onReady fired after session closed
292 if (ret != ACAMERA_OK && !thiz->mIsClosed) {
293 ALOGE("%s Getting camera device from session callback failed!",
294 __FUNCTION__);
295 thiz->mInError = true;
296 }
297 ALOGV("Session for camera %s is ready!", ACameraDevice_getId(device));
298 thiz->mIsIdle = true;
299 thiz->mOnReady++;
300 }
301
onWindowPrepared(void * obj,ANativeWindow * anw,ACameraCaptureSession * session)302 static void onWindowPrepared(
303 void* obj, ANativeWindow* anw, ACameraCaptureSession* session) {
304 ALOGV("%s", __FUNCTION__);
305 if (obj == nullptr) {
306 ALOGE("%s ctx ptr is null ?", __FUNCTION__);
307 return;
308 }
309 CaptureSessionListener* thiz = reinterpret_cast<CaptureSessionListener*>(obj);
310 std::lock_guard<std::mutex> lock(thiz->mMutex);
311 // Reduce the pending prepared count of anw by 1. If count is 0, remove the key.
312 if(thiz->mPendingPreparedCbs.find(anw) == thiz->mPendingPreparedCbs.end()) {
313 ALOGE("%s: ANW %p was not being prepared at all ?", __FUNCTION__, anw);
314 return;
315 }
316 if (thiz->mPendingPreparedCbs[anw] == 0) {
317 ALOGE("%s: ANW %p pending prepared cbs is already 0", __FUNCTION__, anw);
318 return;
319 }
320 thiz->mPendingPreparedCbs[anw]--;
321 if (thiz->mPendingPreparedCbs[anw] == 0) {
322 thiz->mPendingPreparedCbs.erase(anw);
323 }
324 }
onActive(void * obj,ACameraCaptureSession * session)325 static void onActive(void* obj, ACameraCaptureSession* session) {
326 ALOGV("%s", __FUNCTION__);
327 if (obj == nullptr) {
328 return;
329 }
330 CaptureSessionListener* thiz = reinterpret_cast<CaptureSessionListener*>(obj);
331 std::lock_guard<std::mutex> lock(thiz->mMutex);
332 ACameraDevice* device = nullptr;
333 camera_status_t ret = ACameraCaptureSession_getDevice(session, &device);
334 if (ret != ACAMERA_OK) {
335 ALOGE("%s Getting camera device from session callback failed!",
336 __FUNCTION__);
337 thiz->mInError = true;
338 }
339 ALOGV("Session for camera %s is busy!", ACameraDevice_getId(device));
340 thiz->mIsIdle = false;
341 thiz->mOnActive;
342 }
gotAllPreparedCallbacksWithErrorLog()343 bool gotAllPreparedCallbacksWithErrorLog() {
344 std::lock_guard<std::mutex> lock(mMutex);
345 bool ret = (mPendingPreparedCbs.size() == 0);
346 if (!ret) {
347 ALOGE("%s: mPendingPreparedCbs has the following expected callbacks", __FUNCTION__);
348 for (auto pair : mPendingPreparedCbs) {
349 ALOGE("%s: ANW: %p : pending callbacks %d", __FUNCTION__, pair.first, pair.second);
350 }
351 }
352 return ret;
353 }
354
incPendingPrepared(ANativeWindow * anw)355 void incPendingPrepared(ANativeWindow *anw) {
356 std::lock_guard<std::mutex> lock(mMutex);
357 if ((mPendingPreparedCbs.find(anw) == mPendingPreparedCbs.end())) {
358 mPendingPreparedCbs[anw] = 1;
359 return;
360 }
361 mPendingPreparedCbs[anw]++;
362 }
isClosed()363 bool isClosed() {
364 std::lock_guard<std::mutex> lock(mMutex);
365 return mIsClosed;
366 }
367
isIdle()368 bool isIdle() {
369 std::lock_guard<std::mutex> lock(mMutex);
370 return mIsIdle;
371 }
372
isInError()373 bool isInError() {
374 std::lock_guard<std::mutex> lock(mMutex);
375 return mInError;
376 }
377
onClosedCount()378 int onClosedCount() {
379 std::lock_guard<std::mutex> lock(mMutex);
380 return mOnClosed;
381 }
382
onReadyCount()383 int onReadyCount() {
384 std::lock_guard<std::mutex> lock(mMutex);
385 return mOnReady;
386 }
387
onActiveCount()388 int onActiveCount() {
389 std::lock_guard<std::mutex> lock(mMutex);
390 return mOnActive;
391 }
392
reset()393 void reset() {
394 std::lock_guard<std::mutex> lock(mMutex);
395 mIsClosed = false;
396 mIsIdle = true;
397 mInError = false;
398 mOnClosed = 0;
399 mOnReady = 0;
400 mOnActive = 0;
401 }
402
403 private:
404 std::mutex mMutex;
405 bool mIsClosed = false;
406 bool mIsIdle = true;
407 bool mInError = false; // should always stay false
408 int mOnClosed = 0;
409 int mOnReady = 0;
410 int mOnActive = 0;
411 // ANativeWindow -> # expected callbacks
412 std::unordered_map<ANativeWindow *, int> mPendingPreparedCbs;
413 };
414
415 class CaptureResultListener {
416 public:
~CaptureResultListener()417 ~CaptureResultListener() {
418 std::unique_lock<std::mutex> l(mMutex);
419 clearSavedRequestsLocked();
420 mCompletedFrameNumbers.clear();
421 mStartedFrameNumbers.clear();
422 clearFailedLostFrameNumbersLocked();
423 }
424
onCaptureStart(void *,ACameraCaptureSession *,const ACaptureRequest *,int64_t)425 static void onCaptureStart(void* /*obj*/, ACameraCaptureSession* /*session*/,
426 const ACaptureRequest* /*request*/, int64_t /*timestamp*/) {
427 //Not used for now
428 }
429
onCaptureStartV2(void * obj,ACameraCaptureSession *,const ACaptureRequest *,int64_t,int64_t frameNumber)430 static void onCaptureStartV2(void* obj, ACameraCaptureSession* /*session*/,
431 const ACaptureRequest* /*request*/, int64_t /*timestamp*/, int64_t frameNumber) {
432 if ((obj == nullptr) || (frameNumber < 0)) {
433 return;
434 }
435 CaptureResultListener* thiz = reinterpret_cast<CaptureResultListener*>(obj);
436 std::lock_guard<std::mutex> lock(thiz->mMutex);
437
438 thiz->mStartedFrameNumbers.insert(frameNumber);
439 thiz->mStartCondition.notify_one();
440 }
441
onCaptureProgressed(void *,ACameraCaptureSession *,ACaptureRequest *,const ACameraMetadata *)442 static void onCaptureProgressed(void* /*obj*/, ACameraCaptureSession* /*session*/,
443 ACaptureRequest* /*request*/, const ACameraMetadata* /*result*/) {
444 //Not used for now
445 }
446
onCaptureCompleted(void * obj,ACameraCaptureSession *,ACaptureRequest * request,const ACameraMetadata * result)447 static void onCaptureCompleted(void* obj, ACameraCaptureSession* /*session*/,
448 ACaptureRequest* request, const ACameraMetadata* result) {
449 ALOGV("%s", __FUNCTION__);
450 if ((obj == nullptr) || (result == nullptr)) {
451 return;
452 }
453 CaptureResultListener* thiz = reinterpret_cast<CaptureResultListener*>(obj);
454 std::lock_guard<std::mutex> lock(thiz->mMutex);
455 ACameraMetadata_const_entry entry;
456 auto ret = ACameraMetadata_getConstEntry(result, ACAMERA_SYNC_FRAME_NUMBER, &entry);
457 if (ret != ACAMERA_OK) {
458 ALOGE("Error: Sync frame number missing from result!");
459 return;
460 }
461
462 ACameraMetadata* copy = ACameraMetadata_copy(result);
463 ACameraMetadata_const_entry entryCopy;
464 ret = ACameraMetadata_getConstEntry(copy, ACAMERA_SYNC_FRAME_NUMBER, &entryCopy);
465 if (ret != ACAMERA_OK) {
466 ALOGE("Error: Sync frame number missing from result copy!");
467 return;
468 }
469
470 if (entry.data.i64[0] != entryCopy.data.i64[0]) {
471 ALOGE("Error: Sync frame number %" PRId64 " mismatch result copy %" PRId64,
472 entry.data.i64[0], entryCopy.data.i64[0]);
473 return;
474 }
475 ACameraMetadata_free(copy);
476
477 if (thiz->mSaveCompletedRequests) {
478 thiz->mCompletedRequests.push_back(ACaptureRequest_copy(request));
479 }
480
481 thiz->mCompletedFrameNumbers.insert(entry.data.i64[0]);
482 thiz->mResultCondition.notify_one();
483 }
484
onLogicalCameraCaptureCompleted(void * obj,ACameraCaptureSession *,ACaptureRequest * request,const ACameraMetadata * result,size_t physicalResultCount,const char ** physicalCameraIds,const ACameraMetadata ** physicalResults)485 static void onLogicalCameraCaptureCompleted(void* obj, ACameraCaptureSession* /*session*/,
486 ACaptureRequest* request, const ACameraMetadata* result,
487 size_t physicalResultCount, const char** physicalCameraIds,
488 const ACameraMetadata** physicalResults) {
489 ALOGV("%s", __FUNCTION__);
490 if ((obj == nullptr) || (result == nullptr)) {
491 return;
492 }
493 CaptureResultListener* thiz = reinterpret_cast<CaptureResultListener*>(obj);
494 std::lock_guard<std::mutex> lock(thiz->mMutex);
495 ACameraMetadata_const_entry entry;
496 auto ret = ACameraMetadata_getConstEntry(result, ACAMERA_SYNC_FRAME_NUMBER, &entry);
497 if (ret != ACAMERA_OK) {
498 ALOGE("Error: Sync frame number missing from result!");
499 return;
500 }
501
502 ACameraMetadata* copy = ACameraMetadata_copy(result);
503 ACameraMetadata_const_entry entryCopy;
504 ret = ACameraMetadata_getConstEntry(copy, ACAMERA_SYNC_FRAME_NUMBER, &entryCopy);
505 if (ret != ACAMERA_OK) {
506 ALOGE("Error: Sync frame number missing from result copy!");
507 return;
508 }
509
510 if (entry.data.i64[0] != entryCopy.data.i64[0]) {
511 ALOGE("Error: Sync frame number %" PRId64 " mismatch result copy %" PRId64,
512 entry.data.i64[0], entryCopy.data.i64[0]);
513 return;
514 }
515
516 if (thiz->mRegisteredPhysicalIds.size() != physicalResultCount) {
517 ALOGE("Error: Number of registered physical camera Ids %zu is different than received"
518 " physical camera Ids %zu", thiz->mRegisteredPhysicalIds.size(),
519 physicalResultCount);
520 return;
521 }
522 for (size_t i = 0; i < physicalResultCount; i++) {
523 if (physicalCameraIds[i] == nullptr) {
524 ALOGE("Error: Invalid physical camera id in capture result");
525 return;
526 }
527 if (physicalResults[i] == nullptr) {
528 ALOGE("Error: Invalid physical camera metadata in capture result");
529 return;
530 }
531 ACameraMetadata_const_entry physicalEntry;
532 auto ret = ACameraMetadata_getConstEntry(physicalResults[i], ACAMERA_SYNC_FRAME_NUMBER,
533 &physicalEntry);
534 if (ret != ACAMERA_OK) {
535 ALOGE("Error: Sync frame number missing from physical camera result metadata!");
536 return;
537 }
538 if (physicalEntry.data.i64[0] != entryCopy.data.i64[0]) {
539 ALOGE("Error: Physical camera sync frame number %" PRId64
540 " mismatch result copy %" PRId64,
541 physicalEntry.data.i64[0], entryCopy.data.i64[0]);
542 return;
543 }
544
545 auto foundId = std::find(thiz->mRegisteredPhysicalIds.begin(),
546 thiz->mRegisteredPhysicalIds.end(), physicalCameraIds[i]);
547 if (foundId == thiz->mRegisteredPhysicalIds.end()) {
548 ALOGE("Error: Returned physical camera Id %s is not registered",
549 physicalCameraIds[i]);
550 return;
551 }
552 }
553 ACameraMetadata_free(copy);
554
555 if (thiz->mSaveCompletedRequests) {
556 thiz->mCompletedRequests.push_back(ACaptureRequest_copy(request));
557 }
558
559 thiz->mCompletedFrameNumbers.insert(entry.data.i64[0]);
560 thiz->mResultCondition.notify_one();
561 }
562
onCaptureFailed(void * obj,ACameraCaptureSession *,ACaptureRequest *,ACameraCaptureFailure * failure)563 static void onCaptureFailed(void* obj, ACameraCaptureSession* /*session*/,
564 ACaptureRequest* /*request*/, ACameraCaptureFailure* failure) {
565 ALOGV("%s", __FUNCTION__);
566 if ((obj == nullptr) || (failure == nullptr)) {
567 return;
568 }
569 CaptureResultListener* thiz = reinterpret_cast<CaptureResultListener*>(obj);
570 std::lock_guard<std::mutex> lock(thiz->mMutex);
571 thiz->mFailedFrameNumbers.insert(failure->frameNumber);
572 thiz->mResultCondition.notify_one();
573 }
574
onLogicalCameraCaptureFailed(void * obj,ACameraCaptureSession *,ACaptureRequest *,ALogicalCameraCaptureFailure * failure)575 static void onLogicalCameraCaptureFailed(void* obj, ACameraCaptureSession* /*session*/,
576 ACaptureRequest* /*request*/, ALogicalCameraCaptureFailure* failure) {
577 ALOGV("%s", __FUNCTION__);
578 if ((obj == nullptr) || (failure == nullptr)) {
579 return;
580 }
581 if (failure->physicalCameraId != nullptr) {
582 ALOGV("%s: physicalCameraId: %s", __FUNCTION__, failure->physicalCameraId);
583 }
584 CaptureResultListener* thiz = reinterpret_cast<CaptureResultListener*>(obj);
585 std::lock_guard<std::mutex> lock(thiz->mMutex);
586 thiz->mFailedFrameNumbers.insert(failure->captureFailure.frameNumber);
587 thiz->mResultCondition.notify_one();
588 }
589
onCaptureSequenceCompleted(void * obj,ACameraCaptureSession *,int sequenceId,int64_t frameNumber)590 static void onCaptureSequenceCompleted(void* obj, ACameraCaptureSession* /*session*/,
591 int sequenceId, int64_t frameNumber) {
592 ALOGV("%s", __FUNCTION__);
593 if (obj == nullptr) {
594 return;
595 }
596 CaptureResultListener* thiz = reinterpret_cast<CaptureResultListener*>(obj);
597 std::lock_guard<std::mutex> lock(thiz->mMutex);
598 thiz->mLastSequenceIdCompleted = sequenceId;
599 thiz->mLastSequenceFrameNumber = frameNumber;
600 thiz->mResultCondition.notify_one();
601 }
602
onCaptureSequenceAborted(void *,ACameraCaptureSession *,int)603 static void onCaptureSequenceAborted(void* /*obj*/, ACameraCaptureSession* /*session*/,
604 int /*sequenceId*/) {
605 //Not used for now
606 }
607
onCaptureBufferLost(void * obj,ACameraCaptureSession *,ACaptureRequest *,ANativeWindow *,int64_t frameNumber)608 static void onCaptureBufferLost(void* obj, ACameraCaptureSession* /*session*/,
609 ACaptureRequest* /*request*/, ANativeWindow* /*window*/, int64_t frameNumber) {
610 ALOGV("%s", __FUNCTION__);
611 if (obj == nullptr) {
612 return;
613 }
614 CaptureResultListener* thiz = reinterpret_cast<CaptureResultListener*>(obj);
615 std::lock_guard<std::mutex> lock(thiz->mMutex);
616 thiz->mBufferLostFrameNumbers.insert(frameNumber);
617 thiz->mResultCondition.notify_one();
618 }
619
getCaptureSequenceLastFrameNumber(int64_t sequenceId,uint32_t timeoutSec)620 int64_t getCaptureSequenceLastFrameNumber(int64_t sequenceId, uint32_t timeoutSec) {
621 int64_t ret = -1;
622 std::unique_lock<std::mutex> l(mMutex);
623
624 while (mLastSequenceIdCompleted != sequenceId) {
625 auto timeout = std::chrono::system_clock::now() +
626 std::chrono::seconds(timeoutSec);
627 if (std::cv_status::timeout == mResultCondition.wait_until(l, timeout)) {
628 break;
629 }
630 }
631
632 if (mLastSequenceIdCompleted == sequenceId) {
633 ret = mLastSequenceFrameNumber;
634 }
635
636 return ret;
637 }
638
waitForFrameNumber(int64_t frameNumber,uint32_t timeoutSec)639 bool waitForFrameNumber(int64_t frameNumber, uint32_t timeoutSec) {
640 bool ret = false;
641 std::unique_lock<std::mutex> l(mMutex);
642
643 while ((mCompletedFrameNumbers.find(frameNumber) == mCompletedFrameNumbers.end()) &&
644 !checkForFailureOrLossLocked(frameNumber)) {
645 auto timeout = std::chrono::system_clock::now() +
646 std::chrono::seconds(timeoutSec);
647 if (std::cv_status::timeout == mResultCondition.wait_until(l, timeout)) {
648 break;
649 }
650 }
651
652 if ((mCompletedFrameNumbers.find(frameNumber) != mCompletedFrameNumbers.end()) ||
653 checkForFailureOrLossLocked(frameNumber)) {
654 ret = true;
655 }
656
657 return ret;
658 }
659
waitForFrameNumberStarted(int64_t frameNumber,uint32_t timeoutSec)660 bool waitForFrameNumberStarted(int64_t frameNumber, uint32_t timeoutSec) {
661 bool ret = false;
662 std::unique_lock<std::mutex> l(mMutex);
663
664 while ((mStartedFrameNumbers.find(frameNumber) == mStartedFrameNumbers.end())) {
665 auto timeout = std::chrono::system_clock::now() +
666 std::chrono::seconds(timeoutSec);
667 if (std::cv_status::timeout == mStartCondition.wait_until(l, timeout)) {
668 break;
669 }
670 }
671
672 if ((mStartedFrameNumbers.find(frameNumber) != mStartedFrameNumbers.end())) {
673 ret = true;
674 }
675
676 return ret;
677 }
678
waitForCaptureStarted(uint32_t timeoutSec)679 bool waitForCaptureStarted(uint32_t timeoutSec) {
680 bool ret = false;
681 std::unique_lock<std::mutex> l(mMutex);
682
683 while (mStartedFrameNumbers.empty()) {
684 auto timeout = std::chrono::system_clock::now() +
685 std::chrono::seconds(timeoutSec);
686 if (std::cv_status::timeout == mStartCondition.wait_until(l, timeout)) {
687 break;
688 }
689 }
690
691 if (!mStartedFrameNumbers.empty()) {
692 ret = true;
693 }
694 return ret;
695 }
696
setRequestSave(bool enable)697 void setRequestSave(bool enable) {
698 std::unique_lock<std::mutex> l(mMutex);
699 if (!enable) {
700 clearSavedRequestsLocked();
701 }
702 mSaveCompletedRequests = enable;
703 }
704
705 // The lifecycle of returned ACaptureRequest* is still managed by CaptureResultListener
getCompletedRequests(std::vector<ACaptureRequest * > * out)706 void getCompletedRequests(std::vector<ACaptureRequest*>* out) {
707 std::unique_lock<std::mutex> l(mMutex);
708 *out = mCompletedRequests;
709 }
710
registerPhysicalResults(size_t physicalIdCnt,const char * const * physicalOutputs)711 void registerPhysicalResults(size_t physicalIdCnt, const char*const* physicalOutputs) {
712 std::unique_lock<std::mutex> l(mMutex);
713 mRegisteredPhysicalIds.clear();
714 for (size_t i = 0; i < physicalIdCnt; i++) {
715 mRegisteredPhysicalIds.push_back(physicalOutputs[i]);
716 }
717 }
718
checkForFailureOrLoss(int64_t frameNumber)719 bool checkForFailureOrLoss(int64_t frameNumber) {
720 std::lock_guard<std::mutex> lock(mMutex);
721 return checkForFailureOrLossLocked(frameNumber);
722 }
723
reset()724 void reset() {
725 std::lock_guard<std::mutex> lock(mMutex);
726 mLastSequenceIdCompleted = -1;
727 mLastSequenceFrameNumber = -1;
728 mSaveCompletedRequests = false;
729 clearSavedRequestsLocked();
730 mCompletedFrameNumbers.clear();
731 clearFailedLostFrameNumbersLocked();
732 }
733
734 private:
735 std::mutex mMutex;
736 std::condition_variable mResultCondition;
737 std::condition_variable mStartCondition;
738 int mLastSequenceIdCompleted = -1;
739 int64_t mLastSequenceFrameNumber = -1;
740 std::set<int64_t> mCompletedFrameNumbers;
741 std::set<int64_t> mStartedFrameNumbers;
742 std::set<int64_t> mFailedFrameNumbers, mBufferLostFrameNumbers;
743 bool mSaveCompletedRequests = false;
744 std::vector<ACaptureRequest*> mCompletedRequests;
745 // Registered physical camera Ids that are being requested upon.
746 std::vector<std::string> mRegisteredPhysicalIds;
747
clearSavedRequestsLocked()748 void clearSavedRequestsLocked() {
749 for (ACaptureRequest* req : mCompletedRequests) {
750 ACaptureRequest_free(req);
751 }
752 mCompletedRequests.clear();
753 }
754
clearFailedLostFrameNumbersLocked()755 void clearFailedLostFrameNumbersLocked() {
756 mFailedFrameNumbers.clear();
757 mBufferLostFrameNumbers.clear();
758 }
759
checkForFailureOrLossLocked(int64_t frameNumber)760 bool checkForFailureOrLossLocked(int64_t frameNumber) {
761 return (mFailedFrameNumbers.find(frameNumber) != mFailedFrameNumbers.end()) ||
762 (mBufferLostFrameNumbers.find(frameNumber) != mBufferLostFrameNumbers.end());
763 }
764 };
765
766 class ImageReaderListener {
767 public:
ImageReaderListener()768 ImageReaderListener() {
769 mBufferTs.insert(mLastBufferTs);
770 }
771
772 // count, acquire, validate, and delete AImage when a new image is available
validateImageCb(void * obj,AImageReader * reader)773 static void validateImageCb(void* obj, AImageReader* reader) {
774 ALOGV("%s", __FUNCTION__);
775 if (obj == nullptr) {
776 return;
777 }
778 ImageReaderListener* thiz = reinterpret_cast<ImageReaderListener*>(obj);
779 std::lock_guard<std::mutex> lock(thiz->mMutex);
780 thiz->mOnImageAvailableCount++;
781
782 AImage* img = nullptr;
783 media_status_t ret = AImageReader_acquireNextImage(reader, &img);
784 if (ret != AMEDIA_OK || img == nullptr) {
785 ALOGE("%s: acquire image from reader %p failed! ret: %d, img %p",
786 __FUNCTION__, reader, ret, img);
787 return;
788 }
789
790 // TODO: validate image content
791 int32_t format = -1;
792 ret = AImage_getFormat(img, &format);
793 if (ret != AMEDIA_OK || format == -1) {
794 ALOGE("%s: get format for image %p failed! ret: %d, format %d",
795 __FUNCTION__, img, ret, format);
796 }
797
798 // Save jpeg to SD card
799 if (thiz->mDumpFilePathBase && format == AIMAGE_FORMAT_JPEG) {
800 int32_t numPlanes = 0;
801 ret = AImage_getNumberOfPlanes(img, &numPlanes);
802 if (ret != AMEDIA_OK || numPlanes != 1) {
803 ALOGE("%s: get numPlanes for image %p failed! ret: %d, numPlanes %d",
804 __FUNCTION__, img, ret, numPlanes);
805 AImage_delete(img);
806 return;
807 }
808
809 int32_t width = -1, height = -1;
810 ret = AImage_getWidth(img, &width);
811 if (ret != AMEDIA_OK || width <= 0) {
812 ALOGE("%s: get width for image %p failed! ret: %d, width %d",
813 __FUNCTION__, img, ret, width);
814 AImage_delete(img);
815 return;
816 }
817
818 ret = AImage_getHeight(img, &height);
819 if (ret != AMEDIA_OK || height <= 0) {
820 ALOGE("%s: get height for image %p failed! ret: %d, height %d",
821 __FUNCTION__, img, ret, height);
822 AImage_delete(img);
823 return;
824 }
825
826 uint8_t* data = nullptr;
827 int dataLength = 0;
828 ret = AImage_getPlaneData(img, /*planeIdx*/0, &data, &dataLength);
829 if (ret != AMEDIA_OK || data == nullptr || dataLength <= 0) {
830 ALOGE("%s: get jpeg data for image %p failed! ret: %d, data %p, len %d",
831 __FUNCTION__, img, ret, data, dataLength);
832 AImage_delete(img);
833 return;
834 }
835
836 #if 0
837 char dumpFilePath[512];
838 sprintf(dumpFilePath, "%s/%dx%d.jpg", thiz->mDumpFilePathBase, width, height);
839 ALOGI("Writing jpeg file to %s", dumpFilePath);
840 FILE* file = fopen(dumpFilePath,"w+");
841
842 if (file != nullptr) {
843 fwrite(data, 1, dataLength, file);
844 fflush(file);
845 fclose(file);
846 }
847 #endif
848 }
849
850 AImage_delete(img);
851 }
852
853 // count, acquire image but not delete the image
acquireImageCb(void * obj,AImageReader * reader)854 static void acquireImageCb(void* obj, AImageReader* reader) {
855 ALOGV("%s", __FUNCTION__);
856 if (obj == nullptr) {
857 return;
858 }
859 ImageReaderListener* thiz = reinterpret_cast<ImageReaderListener*>(obj);
860 std::lock_guard<std::mutex> lock(thiz->mMutex);
861 thiz->mOnImageAvailableCount++;
862
863 // Acquire, but not closing.
864 AImage* img = nullptr;
865 media_status_t ret = AImageReader_acquireNextImage(reader, &img);
866 if (ret != AMEDIA_OK || img == nullptr) {
867 ALOGE("%s: acquire image from reader %p failed! ret: %d, img %p",
868 __FUNCTION__, reader, ret, img);
869 return;
870 }
871 return;
872 }
873
onImageAvailableCount()874 int onImageAvailableCount() {
875 std::lock_guard<std::mutex> lock(mMutex);
876 return mOnImageAvailableCount;
877 }
878
setDumpFilePathBase(const char * path)879 void setDumpFilePathBase(const char* path) {
880 std::lock_guard<std::mutex> lock(mMutex);
881 mDumpFilePathBase = path;
882 }
883
884 // acquire image, query the corresponding timestamp but not delete the image
signalImageCb(void * obj,AImageReader * reader)885 static void signalImageCb(void* obj, AImageReader* reader) {
886 ALOGV("%s", __FUNCTION__);
887 if (obj == nullptr) {
888 return;
889 }
890 ImageReaderListener* thiz = reinterpret_cast<ImageReaderListener*>(obj);
891 std::lock_guard<std::mutex> lock(thiz->mMutex);
892
893 AImage* img = nullptr;
894 media_status_t ret = AImageReader_acquireNextImage(reader, &img);
895 if (ret != AMEDIA_OK || img == nullptr) {
896 ALOGE("%s: acquire image from reader %p failed! ret: %d, img %p",
897 __FUNCTION__, reader, ret, img);
898 thiz->mBufferCondition.notify_one();
899 return;
900 }
901
902 int64_t currentTs = -1;
903 ret = AImage_getTimestamp(img, ¤tTs);
904 if (ret != AMEDIA_OK || currentTs == -1) {
905 ALOGE("%s: acquire image from reader %p failed! ret: %d", __FUNCTION__, reader, ret);
906 AImage_delete(img);
907 thiz->mBufferCondition.notify_one();
908 return;
909 }
910
911 thiz->mBufferTs.insert(currentTs);
912 thiz->mBufferCondition.notify_one();
913 return;
914 }
915
waitForNextBuffer(uint32_t timeoutSec)916 bool waitForNextBuffer(uint32_t timeoutSec) {
917 bool ret = false;
918 std::unique_lock<std::mutex> l(mMutex);
919
920 auto it = mBufferTs.find(mLastBufferTs);
921 if (it == mBufferTs.end()) {
922 ALOGE("%s: Last buffer timestamp: %" PRId64 " not found!", __FUNCTION__, mLastBufferTs);
923 return false;
924 }
925 it++;
926
927 if (it == mBufferTs.end()) {
928 auto timeout = std::chrono::system_clock::now() + std::chrono::seconds(timeoutSec);
929 if (std::cv_status::no_timeout == mBufferCondition.wait_until(l, timeout)) {
930 it = mBufferTs.find(mLastBufferTs);
931 it++;
932 }
933 }
934
935 if (it != mBufferTs.end()) {
936 mLastBufferTs = *it;
937 ret = true;
938 }
939
940 return ret;
941 }
942
943 private:
944 // TODO: add mReader to make sure each listener is associated to one reader?
945 std::mutex mMutex;
946 int mOnImageAvailableCount = 0;
947 const char* mDumpFilePathBase = nullptr;
948 std::condition_variable mBufferCondition;
949 int64_t mLastBufferTs = -1;
950 std::set<int64_t> mBufferTs;
951 };
952
953 class StaticInfo {
954 public:
StaticInfo(ACameraMetadata * chars)955 explicit StaticInfo(ACameraMetadata* chars) : mChars(chars) {}
956
isColorOutputSupported()957 bool isColorOutputSupported() {
958 return isCapabilitySupported(ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE);
959 }
960
isCapabilitySupported(acamera_metadata_enum_android_request_available_capabilities_t cap)961 bool isCapabilitySupported(acamera_metadata_enum_android_request_available_capabilities_t cap) {
962 ACameraMetadata_const_entry entry;
963 ACameraMetadata_getConstEntry(mChars, ACAMERA_REQUEST_AVAILABLE_CAPABILITIES, &entry);
964 for (uint32_t i = 0; i < entry.count; i++) {
965 if (entry.data.u8[i] == cap) {
966 return true;
967 }
968 }
969 return false;
970 }
971
getMinFrameDurationFor(int64_t format,int64_t width,int64_t height)972 int64_t getMinFrameDurationFor(int64_t format, int64_t width, int64_t height) {
973 int32_t minFrameDurationTag = (format == AIMAGE_FORMAT_HEIC) ?
974 ACAMERA_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS :
975 (format == AIMAGE_FORMAT_DEPTH_JPEG) ?
976 ACAMERA_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS :
977 ACAMERA_SCALER_AVAILABLE_MIN_FRAME_DURATIONS;
978 return getDurationFor(minFrameDurationTag, format, width, height);
979 }
980
getStallDurationFor(int64_t format,int64_t width,int64_t height)981 int64_t getStallDurationFor(int64_t format, int64_t width, int64_t height) {
982 int32_t stallDurationTag = (format == AIMAGE_FORMAT_HEIC) ?
983 ACAMERA_HEIC_AVAILABLE_HEIC_STALL_DURATIONS : (format == AIMAGE_FORMAT_DEPTH_JPEG) ?
984 ACAMERA_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS :
985 ACAMERA_SCALER_AVAILABLE_STALL_DURATIONS;
986 return getDurationFor(stallDurationTag, format, width, height);
987 }
988
getMaxSizeForFormat(int32_t format,int32_t * width,int32_t * height)989 bool getMaxSizeForFormat(int32_t format, int32_t *width, int32_t *height) {
990 ACameraMetadata_const_entry entry;
991
992 int32_t streamConfigTag, streamConfigOutputTag;
993 switch (format) {
994 case AIMAGE_FORMAT_HEIC:
995 streamConfigTag = ACAMERA_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS;
996 streamConfigOutputTag = ACAMERA_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_OUTPUT;
997 break;
998 case AIMAGE_FORMAT_DEPTH_JPEG:
999 streamConfigTag = ACAMERA_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS;
1000 streamConfigOutputTag =
1001 ACAMERA_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_OUTPUT;
1002 break;
1003 case AIMAGE_FORMAT_JPEG:
1004 case AIMAGE_FORMAT_Y8:
1005 default:
1006 streamConfigTag = ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS;
1007 streamConfigOutputTag = ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT;
1008 break;
1009 }
1010
1011 bool supported = false;
1012 camera_status_t status = ACameraMetadata_getConstEntry(mChars, streamConfigTag, &entry);
1013 if (status == ACAMERA_ERROR_METADATA_NOT_FOUND) {
1014 return supported;
1015 }
1016
1017 int32_t w = 0, h = 0;
1018 for (uint32_t i = 0; i < entry.count; i += 4) {
1019 if (entry.data.i32[i] == format &&
1020 entry.data.i32[i+3] == streamConfigOutputTag &&
1021 entry.data.i32[i+1] * entry.data.i32[i+2] > w * h) {
1022 w = entry.data.i32[i+1];
1023 h = entry.data.i32[i+2];
1024 supported = true;
1025 }
1026 }
1027
1028 if (supported) {
1029 *width = w;
1030 *height = h;
1031 }
1032 return supported;
1033 }
1034
isSizeSupportedForFormat(int32_t format,int32_t width,int32_t height)1035 bool isSizeSupportedForFormat(int32_t format, int32_t width, int32_t height) {
1036 ACameraMetadata_const_entry entry;
1037
1038 int32_t streamConfigTag, streamConfigOutputTag;
1039 switch (format) {
1040 case AIMAGE_FORMAT_HEIC:
1041 streamConfigTag = ACAMERA_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS;
1042 streamConfigOutputTag = ACAMERA_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS_OUTPUT;
1043 break;
1044 case AIMAGE_FORMAT_JPEG:
1045 case AIMAGE_FORMAT_Y8:
1046 default:
1047 streamConfigTag = ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS;
1048 streamConfigOutputTag = ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT;
1049 break;
1050 }
1051
1052 auto ret = ACameraMetadata_getConstEntry(mChars, streamConfigTag, &entry);
1053 if (ret != ACAMERA_OK) {
1054 return false;
1055 }
1056 for (uint32_t i = 0; i < entry.count; i += 4) {
1057 if (entry.data.i32[i] == format &&
1058 entry.data.i32[i+3] == streamConfigOutputTag &&
1059 entry.data.i32[i+1] == width &&
1060 entry.data.i32[i+2] == height) {
1061 return true;
1062 }
1063 }
1064 return false;
1065 }
1066 private:
getDurationFor(uint32_t tag,int64_t format,int64_t width,int64_t height)1067 int64_t getDurationFor(uint32_t tag, int64_t format, int64_t width, int64_t height) {
1068 if (tag != ACAMERA_SCALER_AVAILABLE_MIN_FRAME_DURATIONS &&
1069 tag != ACAMERA_SCALER_AVAILABLE_STALL_DURATIONS &&
1070 tag != ACAMERA_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS &&
1071 tag != ACAMERA_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS &&
1072 tag != ACAMERA_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS &&
1073 tag != ACAMERA_HEIC_AVAILABLE_HEIC_STALL_DURATIONS &&
1074 tag != ACAMERA_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS &&
1075 tag != ACAMERA_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS) {
1076 return -1;
1077 }
1078 ACameraMetadata_const_entry entry;
1079 ACameraMetadata_getConstEntry(mChars, tag, &entry);
1080 for (uint32_t i = 0; i < entry.count; i += 4) {
1081 if (entry.data.i64[i] == format &&
1082 entry.data.i64[i+1] == width &&
1083 entry.data.i64[i+2] == height) {
1084 return entry.data.i64[i+3];
1085 }
1086 }
1087 return -1;
1088 }
1089 const ACameraMetadata* mChars;
1090 };
1091
1092 class PreviewTestCase {
1093 public:
~PreviewTestCase()1094 ~PreviewTestCase() {
1095 resetCamera();
1096 deInit();
1097 if (mCameraManager) {
1098 ACameraManager_delete(mCameraManager);
1099 mCameraManager = nullptr;
1100 }
1101 }
1102
PreviewTestCase()1103 PreviewTestCase() {
1104 // create is guaranteed to succeed;
1105 createManager();
1106 }
1107
1108 // Free all resources except camera manager
resetCamera()1109 void resetCamera() {
1110 mSessionListener.reset();
1111 mResultListener.reset();
1112 if (mSession) {
1113 ACameraCaptureSession_close(mSession);
1114 mSession = nullptr;
1115 }
1116 if (mDevice) {
1117 ACameraDevice_close(mDevice);
1118 mDevice = nullptr;
1119 }
1120 if (mImgReader) {
1121 AImageReader_delete(mImgReader);
1122 // No need to call ANativeWindow_release on imageReaderAnw
1123 mImgReaderAnw = nullptr;
1124 mImgReader = nullptr;
1125 }
1126 if (mPreviewAnw) {
1127 ANativeWindow_release(mPreviewAnw);
1128 mPreviewAnw = nullptr;
1129 }
1130 if (mOutputs) {
1131 ACaptureSessionOutputContainer_free(mOutputs);
1132 mOutputs = nullptr;
1133 }
1134 if (mPreviewOutput) {
1135 ACaptureSessionOutput_free(mPreviewOutput);
1136 mPreviewOutput = nullptr;
1137 }
1138 if (mImgReaderOutput) {
1139 ACaptureSessionOutput_free(mImgReaderOutput);
1140 mImgReaderOutput = nullptr;
1141 }
1142 if (mPreviewRequest) {
1143 ACaptureRequest_free(mPreviewRequest);
1144 mPreviewRequest = nullptr;
1145 }
1146 if (mStillRequest) {
1147 ACaptureRequest_free(mStillRequest);
1148 mStillRequest = nullptr;
1149 }
1150 if (mReqPreviewOutput) {
1151 ACameraOutputTarget_free(mReqPreviewOutput);
1152 mReqPreviewOutput = nullptr;
1153 }
1154 if (mReqImgReaderOutput) {
1155 ACameraOutputTarget_free(mReqImgReaderOutput);
1156 mReqImgReaderOutput = nullptr;
1157 }
1158
1159 mImgReaderInited = false;
1160 mPreviewInited = false;
1161 }
1162
initWithErrorLog()1163 camera_status_t initWithErrorLog() {
1164 return initWithErrorLog(nullptr /*env*/, nullptr /*jOverrideCameraId*/);
1165 }
1166
initWithErrorLog(JNIEnv * env,jstring jOverrideCameraId)1167 camera_status_t initWithErrorLog(JNIEnv* env, jstring jOverrideCameraId) {
1168 camera_status_t ret = ACameraManager_getCameraIdList(
1169 mCameraManager, &mCameraIdList);
1170 if (ret != ACAMERA_OK) {
1171 LOG_ERROR(errorString, "Get camera id list failed: ret %d", ret);
1172 return ret;
1173 }
1174
1175 if (env != nullptr && jOverrideCameraId != nullptr) {
1176 mOverrideCameraId = env->GetStringUTFChars(jOverrideCameraId, 0);
1177 }
1178 ret = ACameraManager_registerAvailabilityCallback(mCameraManager, &mServiceCb);
1179 if (ret != ACAMERA_OK) {
1180 LOG_ERROR(errorString, "Register availability callback failed: ret %d", ret);
1181 return ret;
1182 }
1183 mMgrInited = true;
1184 mJOverrideCameraId = jOverrideCameraId;
1185 mJNIEnv = env;
1186 return ACAMERA_OK;
1187 }
1188
deInit()1189 camera_status_t deInit () {
1190 if (!mMgrInited) {
1191 return ACAMERA_OK;
1192 }
1193
1194 camera_status_t ret = ACameraManager_unregisterAvailabilityCallback(
1195 mCameraManager, &mServiceCb);
1196 if (ret != ACAMERA_OK) {
1197 ALOGE("Unregister availability callback failed: ret %d", ret);
1198 return ret;
1199 }
1200
1201 if (mCameraIdList) {
1202 ACameraManager_deleteCameraIdList(mCameraIdList);
1203 mCameraIdList = nullptr;
1204 }
1205 mMgrInited = false;
1206 if (mOverrideCameraId != nullptr && mJNIEnv != nullptr) {
1207 mJNIEnv->ReleaseStringUTFChars(mJOverrideCameraId, mOverrideCameraId);
1208 mOverrideCameraId = nullptr;
1209 mJOverrideCameraId = nullptr;
1210 mJNIEnv = nullptr;
1211 }
1212 return ACAMERA_OK;
1213 }
1214
deInitImageReader()1215 void deInitImageReader() {
1216 if (mImgReader) {
1217 AImageReader_delete(mImgReader);
1218 mImgReaderAnw = nullptr;
1219 mImgReader = nullptr;
1220 }
1221 mImgReaderInited = false;
1222 }
1223
getNumCameras()1224 int getNumCameras() {
1225 if (!mMgrInited || !mCameraIdList) {
1226 ALOGE("%s CameraManager not inited yet.", __FUNCTION__);
1227 return -1;
1228 }
1229 if (mOverrideCameraId != nullptr) {
1230 return 1;
1231 }
1232 return mCameraIdList->numCameras;
1233 }
1234
getCameraId(int idx)1235 const char* getCameraId(int idx) {
1236 if (!mMgrInited || !mCameraIdList || idx < 0 || idx >= mCameraIdList->numCameras) {
1237 return nullptr;
1238 }
1239 if (mOverrideCameraId != nullptr) {
1240 if (idx >= 1) {
1241 return nullptr;
1242 } else {
1243 return mOverrideCameraId;
1244 }
1245 }
1246 return mCameraIdList->cameraIds[idx];
1247 }
1248
1249 // Caller is responsible to free returned characteristics metadata
getCameraChars(int idx)1250 ACameraMetadata* getCameraChars(int idx) {
1251 if (!mMgrInited || !mCameraIdList || idx < 0 || idx >= mCameraIdList->numCameras) {
1252 return nullptr;
1253 }
1254 const char* cameraId = mCameraIdList->cameraIds[idx];
1255 if (mOverrideCameraId != nullptr) {
1256 if (idx >= 1) {
1257 return nullptr;
1258 } else {
1259 cameraId = mOverrideCameraId;
1260 }
1261 }
1262
1263 ACameraMetadata* chars;
1264 camera_status_t ret = ACameraManager_getCameraCharacteristics(
1265 mCameraManager, cameraId, &chars);
1266 if (ret != ACAMERA_OK) {
1267 LOG_ERROR(errorString, "Get camera characteristics failed: ret %d", ret);
1268 return nullptr;
1269 }
1270 return chars;
1271 }
1272
1273 // Caller is responsible to free returned characteristics metadata.
getCameraChars(const char * id)1274 ACameraMetadata* getCameraChars(const char* id) {
1275 if (!mMgrInited || id == nullptr) {
1276 return nullptr;
1277 }
1278
1279 ACameraMetadata* chars;
1280 camera_status_t ret = ACameraManager_getCameraCharacteristics(mCameraManager, id, &chars);
1281 if (ret != ACAMERA_OK) {
1282 LOG_ERROR(errorString, "Get camera characteristics failed: ret %d", ret);
1283 return nullptr;
1284 }
1285 return chars;
1286 }
1287
updateOutput(JNIEnv * env,ACaptureSessionOutput * output)1288 camera_status_t updateOutput(JNIEnv* env, ACaptureSessionOutput *output) {
1289 if (mSession == nullptr) {
1290 ALOGE("Testcase cannot update output configuration session %p",
1291 mSession);
1292 return ACAMERA_ERROR_UNKNOWN;
1293 }
1294
1295 return ACameraCaptureSession_updateSharedOutput(mSession, output);
1296 }
1297
openCamera(const char * cameraId)1298 camera_status_t openCamera(const char* cameraId) {
1299 if (mDevice) {
1300 ALOGE("Cannot open camera before closing previously open one");
1301 return ACAMERA_ERROR_INVALID_PARAMETER;
1302 }
1303 mCameraId = cameraId;
1304 return ACameraManager_openCamera(mCameraManager, cameraId, &mDeviceCb, &mDevice);
1305 }
1306
openSharedCamera(const char * cameraId,bool * isPrimary)1307 camera_status_t openSharedCamera(const char* cameraId, bool* isPrimary) {
1308 if (mDevice) {
1309 ALOGE("Cannot open camera before closing previously open one");
1310 return ACAMERA_ERROR_INVALID_PARAMETER;
1311 }
1312 camera_status_t ret = ACAMERA_ERROR_UNKNOWN;
1313 mCameraId = cameraId;
1314 // Load system api using dlsym.
1315 void* handle = dlopen(kLibandroidPath, RTLD_NOW | RTLD_LOCAL);
1316 if (!handle) {
1317 ALOGE("dlopen error: %s %s", __func__, dlerror());
1318 return ret;
1319 }
1320 ACameraManager_openSharedCameraNative openSharedCamera;
1321 getLibFunction(handle, "ACameraManager_openSharedCamera", &openSharedCamera);
1322 dlclose(handle);
1323 if (openSharedCamera == nullptr) {
1324 ALOGE("ACameraManager_openSharedCamera function not present in ndk.");
1325 return ret;
1326 }
1327
1328 ret = openSharedCamera(mCameraManager, cameraId, &mDeviceCb, &mDevice, isPrimary);
1329 return ret;
1330 }
1331
closeCamera()1332 camera_status_t closeCamera() {
1333 camera_status_t ret = ACameraDevice_close(mDevice);
1334 mDevice = nullptr;
1335 return ret;
1336 }
1337
isCameraAvailable(const char * cameraId)1338 bool isCameraAvailable(const char* cameraId) {
1339 if (!mMgrInited) {
1340 ALOGE("Camera service listener has not been registered!");
1341 }
1342 return mServiceListener.isAvailable(cameraId);
1343 }
1344
initImageReaderWithErrorLog(int32_t width,int32_t height,int32_t format,int32_t maxImages)1345 media_status_t initImageReaderWithErrorLog(
1346 int32_t width, int32_t height, int32_t format, int32_t maxImages) {
1347 return initImageReaderWithErrorLog(width, height, format, maxImages, &mReaderCb);
1348 }
1349
initImageReaderWithErrorLog(int32_t width,int32_t height,int32_t format,int32_t maxImages,AImageReader_ImageListener * listener)1350 media_status_t initImageReaderWithErrorLog(
1351 int32_t width, int32_t height, int32_t format, int32_t maxImages,
1352 AImageReader_ImageListener* listener) {
1353 if (mImgReader || mImgReaderAnw) {
1354 LOG_ERROR(errorString, "Cannot init image reader before closing existing one");
1355 return AMEDIA_ERROR_UNKNOWN;
1356 }
1357
1358 media_status_t ret = initImageReaderWithErrorLog(
1359 width, height, format, maxImages, listener, &mImgReader,
1360 &mImgReaderAnw);
1361 if (ret != AMEDIA_OK) {
1362 return ret;
1363 }
1364
1365 mImgReaderInited = true;
1366 return AMEDIA_OK;
1367 }
1368
initImageReaderWithErrorLog(int32_t width,int32_t height,int32_t format,int32_t maxImages,AImageReader_ImageListener * listener,AImageReader ** imgReader,ANativeWindow ** imgReaderAnw)1369 media_status_t initImageReaderWithErrorLog(
1370 int32_t width, int32_t height, int32_t format, int32_t maxImages,
1371 AImageReader_ImageListener* listener, AImageReader **imgReader,
1372 ANativeWindow **imgReaderAnw) {
1373
1374 media_status_t ret = AImageReader_new(
1375 width, height, format,
1376 maxImages, imgReader);
1377 if (ret != AMEDIA_OK) {
1378 LOG_ERROR(errorString, "Create image reader. ret %d", ret);
1379 return ret;
1380 }
1381 if (*imgReader == nullptr) {
1382 LOG_ERROR(errorString, "null image reader created");
1383 return AMEDIA_ERROR_UNKNOWN;
1384 }
1385
1386 ret = AImageReader_setImageListener(*imgReader, listener);
1387 if (ret != AMEDIA_OK) {
1388 LOG_ERROR(errorString, "Set AImageReader listener failed. ret %d", ret);
1389 return ret;
1390 }
1391
1392 ret = AImageReader_getWindow(*imgReader, imgReaderAnw);
1393 if (ret != AMEDIA_OK) {
1394 LOG_ERROR(errorString, "AImageReader_getWindow failed. ret %d", ret);
1395 return ret;
1396 }
1397 if (*imgReaderAnw == nullptr) {
1398 LOG_ERROR(errorString, "Null ANW from AImageReader!");
1399 return AMEDIA_ERROR_UNKNOWN;
1400 }
1401 return AMEDIA_OK;
1402 }
1403
initPreviewAnw(JNIEnv * env,jobject jSurface)1404 ANativeWindow* initPreviewAnw(JNIEnv* env, jobject jSurface) {
1405 if (mPreviewAnw) {
1406 ALOGE("Cannot init preview twice!");
1407 return nullptr;
1408 }
1409 mPreviewAnw = ANativeWindow_fromSurface(env, jSurface);
1410 mPreviewInited = true;
1411 return mPreviewAnw;
1412 }
1413
createCaptureSessionWithLog(bool isPreviewShared=false,ACaptureRequest * sessionParameters=nullptr)1414 camera_status_t createCaptureSessionWithLog(bool isPreviewShared = false,
1415 ACaptureRequest *sessionParameters = nullptr) {
1416 std::vector<ACaptureSessionOutput*> extraOutputs;
1417 return createCaptureSessionWithLog(extraOutputs, isPreviewShared, sessionParameters);
1418 }
1419
createCaptureSessionOutputContainer(const std::vector<ACaptureSessionOutput * > extraOutputs,ACaptureSessionOutputContainer ** outputs,bool isPreviewShared=false,ACaptureRequest * sessionParameters=nullptr)1420 camera_status_t createCaptureSessionOutputContainer(
1421 const std::vector<ACaptureSessionOutput*> extraOutputs,
1422 ACaptureSessionOutputContainer** outputs,
1423 bool isPreviewShared = false, ACaptureRequest *sessionParameters = nullptr) {
1424 if (!mMgrInited || (!mImgReaderInited && !mPreviewInited) || !outputs) {
1425 LOG_ERROR(errorString, "Cannot create session output container. mgrInit %d "
1426 "readerInit %d previewInit %d outputs %p",
1427 mMgrInited, mImgReaderInited, mPreviewInited, outputs);
1428 return ACAMERA_ERROR_UNKNOWN;
1429 }
1430
1431 camera_status_t ret = ACaptureSessionOutputContainer_create(outputs);
1432 if (ret != ACAMERA_OK) {
1433 LOG_ERROR(errorString, "Create capture session output container failed. ret %d", ret);
1434 return ret;
1435 }
1436
1437 if (mImgReaderInited) {
1438 if (isPreviewShared) {
1439 ret = ACaptureSessionSharedOutput_create(mImgReaderAnw, &mImgReaderOutput);
1440 } else {
1441 ret = ACaptureSessionOutput_create(mImgReaderAnw, &mImgReaderOutput);
1442 }
1443 if (ret != ACAMERA_OK || mImgReaderOutput == nullptr) {
1444 LOG_ERROR(errorString,
1445 "Session image reader output create fail! ret %d output %p",
1446 ret, mImgReaderOutput);
1447 if (ret == ACAMERA_OK) {
1448 ret = ACAMERA_ERROR_UNKNOWN; // ret OK but output is null
1449 }
1450 return ret;
1451 }
1452
1453 ret = ACaptureSessionOutputContainer_add(*outputs, mImgReaderOutput);
1454 if (ret != ACAMERA_OK) {
1455 LOG_ERROR(errorString, "Session image reader output add failed! ret %d", ret);
1456 return ret;
1457 }
1458 }
1459
1460 for (auto extraOutput : extraOutputs) {
1461 ret = ACaptureSessionOutputContainer_add(*outputs, extraOutput);
1462 if (ret != ACAMERA_OK) {
1463 LOG_ERROR(errorString, "Session image reader output add failed! ret %d", ret);
1464 return ret;
1465 }
1466 }
1467
1468 if (mPreviewInited) {
1469 if (isPreviewShared) {
1470 ret = ACaptureSessionSharedOutput_create(mPreviewAnw, &mPreviewOutput);
1471 } else {
1472 ret = ACaptureSessionOutput_create(mPreviewAnw, &mPreviewOutput);
1473 }
1474 if (ret != ACAMERA_OK || mPreviewOutput == nullptr) {
1475 LOG_ERROR(errorString,
1476 "Session preview output create fail! ret %d output %p",
1477 ret, mPreviewOutput);
1478 if (ret == ACAMERA_OK) {
1479 ret = ACAMERA_ERROR_UNKNOWN; // ret OK but output is null
1480 }
1481 return ret;
1482 }
1483
1484 ret = ACaptureSessionOutputContainer_add(*outputs, mPreviewOutput);
1485 if (ret != ACAMERA_OK) {
1486 LOG_ERROR(errorString, "Session preview output add failed! ret %d", ret);
1487 return ret;
1488 }
1489 }
1490 return ret;
1491 }
1492
createCaptureSessionWithLog(const std::vector<ACaptureSessionOutput * > extraOutputs,bool isPreviewShared=false,ACaptureRequest * sessionParameters=nullptr,bool sessionConfigurationDefault=true)1493 camera_status_t createCaptureSessionWithLog(
1494 const std::vector<ACaptureSessionOutput*> extraOutputs,
1495 bool isPreviewShared = false, ACaptureRequest *sessionParameters = nullptr,
1496 bool sessionConfigurationDefault = true) {
1497 if (mSession) {
1498 LOG_ERROR(errorString, "Cannot create session before closing existing one");
1499 return ACAMERA_ERROR_UNKNOWN;
1500 }
1501
1502 camera_status_t ret = createCaptureSessionOutputContainer(
1503 extraOutputs, &mOutputs, isPreviewShared, sessionParameters);
1504 if (ret != ACAMERA_OK) {
1505 LOG_ERROR(errorString, "Failed to create session output container! ret %d", ret);
1506 return ret;
1507 }
1508
1509 ret = ACameraDevice_isSessionConfigurationSupported(mDevice, mOutputs);
1510 if (ret != ACAMERA_OK && ret != ACAMERA_ERROR_UNSUPPORTED_OPERATION &&
1511 ret != ACAMERA_ERROR_STREAM_CONFIGURE_FAIL) {
1512 LOG_ERROR(errorString, "isSessionConfigurationSupported must return either OK "
1513 ", UNSUPPORTED_OPERATION, or STREAM_CONFIGURE_FAIL, but returns %d", ret);
1514 return ret;
1515 }
1516
1517 // If session configuration is not supported by default, return early
1518 // when camera device doesn't explicitly claim support.
1519 if (ret != ACAMERA_OK && !sessionConfigurationDefault) {
1520 return ret;
1521 }
1522
1523 ret = ACameraDevice_createCaptureSessionWithSessionParameters(
1524 mDevice, mOutputs, sessionParameters, &mSessionCb, &mSession);
1525 if (ret != ACAMERA_OK || mSession == nullptr) {
1526 LOG_ERROR(errorString, "Create session for camera %s failed. ret %d session %p",
1527 mCameraId, ret, mSession);
1528 if (ret == ACAMERA_OK) {
1529 ret = ACAMERA_ERROR_UNKNOWN; // ret OK but session is null
1530 }
1531 return ret;
1532 }
1533
1534 return ACAMERA_OK;
1535 }
1536
prepareWindow(ANativeWindow * window)1537 camera_status_t prepareWindow(ANativeWindow *window) {
1538 if (mSession == nullptr) {
1539 ALOGE("%s: Called when session hasn't been configured", __FUNCTION__);
1540 return ACAMERA_ERROR_INVALID_OPERATION;
1541 }
1542 mSessionListener.incPendingPrepared(window);
1543 return ACameraCaptureSession_prepareWindow(mSession, window);
1544 }
1545
setWindowPreparedCallback()1546 camera_status_t setWindowPreparedCallback() {
1547 if (mSession == nullptr) {
1548 ALOGE("%s: Called when session hasn't been configured", __FUNCTION__);
1549 return ACAMERA_ERROR_INVALID_OPERATION;
1550 }
1551 return ACameraCaptureSession_setWindowPreparedCallback(mSession, &mSessionListener,
1552 mPreparedCb);
1553 }
1554
gotAllPreparedCallbacksWithErrorLog()1555 bool gotAllPreparedCallbacksWithErrorLog() {
1556 return mSessionListener.gotAllPreparedCallbacksWithErrorLog();
1557 }
closeSession()1558 void closeSession() {
1559 if (mSession != nullptr) {
1560 ACameraCaptureSession_close(mSession);
1561 }
1562 if (mOutputs) {
1563 ACaptureSessionOutputContainer_free(mOutputs);
1564 mOutputs = nullptr;
1565 }
1566 if (mPreviewOutput) {
1567 ACaptureSessionOutput_free(mPreviewOutput);
1568 mPreviewOutput = nullptr;
1569 }
1570 if (mImgReaderOutput) {
1571 ACaptureSessionOutput_free(mImgReaderOutput);
1572 mImgReaderOutput = nullptr;
1573 }
1574 mSession = nullptr;
1575 }
1576
createRequestsWithErrorLog()1577 camera_status_t createRequestsWithErrorLog() {
1578 std::vector<ACameraOutputTarget*> extraOutputs;
1579 return createRequestsWithErrorLog(extraOutputs);
1580 }
1581
createRequestsWithErrorLog(const std::vector<ACameraOutputTarget * > extraOutputs,const ACameraIdList * physicalCameraIdList=nullptr)1582 camera_status_t createRequestsWithErrorLog(
1583 const std::vector<ACameraOutputTarget*> extraOutputs,
1584 const ACameraIdList* physicalCameraIdList = nullptr) {
1585 if (mPreviewRequest || mStillRequest) {
1586 LOG_ERROR(errorString, "Cannot create requests before deleteing existing one");
1587 return ACAMERA_ERROR_UNKNOWN;
1588 }
1589
1590 if (mDevice == nullptr || (!mPreviewInited && !mImgReaderInited)) {
1591 LOG_ERROR(errorString,
1592 "Cannot create request. device %p previewInit %d readeInit %d",
1593 mDevice, mPreviewInited, mImgReaderInited);
1594 return ACAMERA_ERROR_UNKNOWN;
1595 }
1596
1597 camera_status_t ret;
1598 bool usePhysicalSettings = (physicalCameraIdList != nullptr);
1599 if (mPreviewInited) {
1600 if (!usePhysicalSettings) {
1601 ret = ACameraDevice_createCaptureRequest(
1602 mDevice, TEMPLATE_PREVIEW, &mPreviewRequest);
1603 } else {
1604 ret = ACameraDevice_createCaptureRequest_withPhysicalIds(
1605 mDevice, TEMPLATE_PREVIEW, physicalCameraIdList, &mPreviewRequest);
1606 }
1607 if (ret != ACAMERA_OK) {
1608 LOG_ERROR(errorString, "Camera %s create preview request failed. ret %d",
1609 mCameraId, ret);
1610 return ret;
1611 }
1612
1613 if (usePhysicalSettings) {
1614 for (int i = 0; i < physicalCameraIdList->numCameras; i++) {
1615 // Check physical camera specific metadata functions.
1616 uint8_t aeMode = ACAMERA_CONTROL_AE_MODE_ON;
1617 ret = ACaptureRequest_setEntry_physicalCamera_u8(mPreviewRequest,
1618 physicalCameraIdList->cameraIds[i], ACAMERA_CONTROL_AE_MODE,
1619 1 /*count*/, &aeMode);
1620 if (ret != ACAMERA_OK) {
1621 LOG_ERROR(errorString,
1622 "Error: Camera %s update AE mode key fail. ret %d",
1623 physicalCameraIdList->cameraIds[i], ret);
1624 return ret;
1625 }
1626
1627 ACameraMetadata_const_entry entry;
1628 ret = ACaptureRequest_getConstEntry_physicalCamera(mPreviewRequest,
1629 physicalCameraIdList->cameraIds[i],
1630 ACAMERA_CONTROL_AE_MODE, &entry);
1631 if (ret != ACAMERA_OK) {
1632 LOG_ERROR(errorString, "Get AE mode key for physicalCamera %s failed."
1633 " ret %d", physicalCameraIdList->cameraIds[i], ret);
1634 return ret;
1635 }
1636 if (entry.data.u8[0] != aeMode) {
1637 LOG_ERROR(errorString,
1638 "Error: AE mode key is not updated. expect %d but get %d",
1639 aeMode, entry.data.u8[0]);
1640 return ACAMERA_ERROR_UNKNOWN;
1641 }
1642 }
1643 }
1644
1645 ret = ACameraOutputTarget_create(mPreviewAnw, &mReqPreviewOutput);
1646 if (ret != ACAMERA_OK) {
1647 LOG_ERROR(errorString,
1648 "Camera %s create request preview output target failed. ret %d",
1649 mCameraId, ret);
1650 return ret;
1651 }
1652
1653 ret = ACaptureRequest_addTarget(mPreviewRequest, mReqPreviewOutput);
1654 if (ret != ACAMERA_OK) {
1655 LOG_ERROR(errorString, "Camera %s add preview request output failed. ret %d",
1656 mCameraId, ret);
1657 return ret;
1658 }
1659
1660 // Add extraOutputs to the request
1661 for (auto extraOutput : extraOutputs) {
1662 ret = ACaptureRequest_addTarget(mPreviewRequest, extraOutput);
1663 if (ret != ACAMERA_OK) {
1664 LOG_ERROR(errorString, "Camera %s add extra request output failed. ret %d",
1665 mCameraId, ret);
1666 return ret;
1667 }
1668 }
1669 } else {
1670 ALOGI("Preview not inited. Will not create preview request!");
1671 }
1672
1673 if (mImgReaderInited) {
1674 ret = ACameraDevice_createCaptureRequest(
1675 mDevice, TEMPLATE_STILL_CAPTURE, &mStillRequest);
1676 if (ret != ACAMERA_OK) {
1677 LOG_ERROR(errorString, "Camera %s create still request failed. ret %d",
1678 mCameraId, ret);
1679 return ret;
1680 }
1681
1682 ret = ACameraOutputTarget_create(mImgReaderAnw, &mReqImgReaderOutput);
1683 if (ret != ACAMERA_OK) {
1684 LOG_ERROR(errorString,
1685 "Camera %s create request reader output target failed. ret %d",
1686 mCameraId, ret);
1687 return ret;
1688 }
1689
1690 ret = ACaptureRequest_addTarget(mStillRequest, mReqImgReaderOutput);
1691 if (ret != ACAMERA_OK) {
1692 LOG_ERROR(errorString, "Camera %s add still request output failed. ret %d",
1693 mCameraId, ret);
1694 return ret;
1695 }
1696
1697 if (mPreviewInited) {
1698 ret = ACaptureRequest_addTarget(mStillRequest, mReqPreviewOutput);
1699 if (ret != ACAMERA_OK) {
1700 LOG_ERROR(errorString,
1701 "Camera %s add still request preview output failed. ret %d",
1702 mCameraId, ret);
1703 return ret;
1704 }
1705 }
1706 } else {
1707 ALOGI("AImageReader not inited. Will not create still request!");
1708 }
1709
1710 return ACAMERA_OK;
1711 }
1712
1713 // The output ACaptureRequest* is still managed by testcase class
getStillRequest(ACaptureRequest ** out)1714 camera_status_t getStillRequest(ACaptureRequest** out) {
1715 if (mStillRequest == nullptr) {
1716 ALOGE("Camera %s Still capture request hasn't been created", mCameraId);
1717 return ACAMERA_ERROR_INVALID_PARAMETER;
1718 }
1719 *out = mStillRequest;
1720 return ACAMERA_OK;
1721 }
1722
getPreviewRequest(ACaptureRequest ** out)1723 camera_status_t getPreviewRequest(ACaptureRequest** out) {
1724 if (mPreviewRequest == nullptr) {
1725 ALOGE("Camera %s Preview capture request hasn't been created", mCameraId);
1726 return ACAMERA_ERROR_INVALID_PARAMETER;
1727 }
1728 *out = mPreviewRequest;
1729 return ACAMERA_OK;
1730 }
1731
startPreview(int * sequenceId=nullptr,size_t physicalIdCnt=0,const char * const * extraPhysicalOutputs=nullptr,bool v2Callbacks=false)1732 camera_status_t startPreview(int *sequenceId = nullptr, size_t physicalIdCnt = 0,
1733 const char*const* extraPhysicalOutputs = nullptr, bool v2Callbacks = false) {
1734 if (mSession == nullptr || mPreviewRequest == nullptr) {
1735 ALOGE("Testcase cannot start preview: session %p, preview request %p",
1736 mSession, mPreviewRequest);
1737 return ACAMERA_ERROR_UNKNOWN;
1738 }
1739 int previewSeqId;
1740 camera_status_t ret;
1741 if (sequenceId == nullptr) {
1742 ret = ACameraCaptureSession_setRepeatingRequest(
1743 mSession, nullptr, 1, &mPreviewRequest, &previewSeqId);
1744 } else if (physicalIdCnt == 0) {
1745 if (v2Callbacks) {
1746 ret = ACameraCaptureSession_setRepeatingRequestV2(
1747 mSession, &mResultCb2, 1, &mPreviewRequest, sequenceId);
1748 } else {
1749 ret = ACameraCaptureSession_setRepeatingRequest(
1750 mSession, &mResultCb, 1, &mPreviewRequest, sequenceId);
1751 }
1752 } else {
1753 if (extraPhysicalOutputs == nullptr) {
1754 ALOGE("Testcase missing valid physical camera Ids for logical camera");
1755 return ACAMERA_ERROR_INVALID_PARAMETER;
1756 }
1757 CaptureResultListener* resultListener =
1758 static_cast<CaptureResultListener*>(mLogicalCameraResultCb.context);
1759 resultListener->registerPhysicalResults(physicalIdCnt, extraPhysicalOutputs);
1760 if (v2Callbacks) {
1761 ret = ACameraCaptureSession_logicalCamera_setRepeatingRequestV2(
1762 mSession, &mLogicalCameraResultCb2, 1, &mPreviewRequest, sequenceId);
1763 } else {
1764 ret = ACameraCaptureSession_logicalCamera_setRepeatingRequest(
1765 mSession, &mLogicalCameraResultCb, 1, &mPreviewRequest, sequenceId);
1766 }
1767 }
1768 return ret;
1769 }
1770
startRepeatingRequest(int * sequenceId,ACaptureRequest * request,ACameraCaptureSession_captureCallbacks * resultCb)1771 camera_status_t startRepeatingRequest(int *sequenceId, ACaptureRequest *request,
1772 ACameraCaptureSession_captureCallbacks *resultCb) {
1773 if (mSession == nullptr || request == nullptr || resultCb == nullptr) {
1774 ALOGE("Testcase cannot start repeating request: session %p, request %p resultCb %p",
1775 mSession, request, resultCb);
1776 return ACAMERA_ERROR_UNKNOWN;
1777 }
1778
1779 return ACameraCaptureSession_setRepeatingRequest(mSession, resultCb, 1, &request,
1780 sequenceId);
1781 }
1782
stopPreview()1783 camera_status_t stopPreview() {
1784 if (mSession == nullptr) {
1785 ALOGE("Testcase cannot stop preview: session %p", mSession);
1786 return ACAMERA_ERROR_UNKNOWN;
1787 }
1788 return ACameraCaptureSession_stopRepeating(mSession);
1789 }
1790
startSharedStreaming()1791 camera_status_t startSharedStreaming() {
1792 // Load system api using dlsym.
1793 camera_status_t ret = ACAMERA_ERROR_UNKNOWN;
1794 void* handle = dlopen(kLibandroidPath, RTLD_NOW | RTLD_LOCAL);
1795 if (!handle) {
1796 ALOGE("dlopen error: %s %s", __func__, dlerror());
1797 return ret;
1798 }
1799 ACameraCaptureSessionShared_startStreamingNative startStreaming;
1800 getLibFunction(handle, "ACameraCaptureSessionShared_startStreaming", &startStreaming);
1801 dlclose(handle);
1802 if (startStreaming == nullptr) {
1803 ALOGE("ACameraCaptureSessionShared_startStreaming function not present in ndk.");
1804 return ret;
1805 }
1806 return startStreaming(mSession, &mResultCb2, 1, &mImgReaderAnw, &mSharedStreamingSeqId);
1807 }
1808
stopSharedStreaming()1809 camera_status_t stopSharedStreaming() {
1810 camera_status_t ret = ACAMERA_ERROR_UNKNOWN;
1811 // Load system api using dlsym.
1812 void* handle = dlopen(kLibandroidPath, RTLD_NOW | RTLD_LOCAL);
1813 if (!handle) {
1814 ALOGE("dlopen error: %s %s", __func__, dlerror());
1815 return ret;
1816 }
1817 ACameraCaptureSessionShared_stopStreamingNative stopStreaming;
1818 getLibFunction(handle, "ACameraCaptureSessionShared_stopStreaming", &stopStreaming);
1819 dlclose(handle);
1820 if (stopStreaming == nullptr) {
1821 ALOGE("ACameraCaptureSessionShared_stopStreaming function not present in ndk.");
1822 return ret;
1823 }
1824 return stopStreaming(mSession);
1825 }
1826
getSharedStreamingSeqId()1827 int getSharedStreamingSeqId() {
1828 return mSharedStreamingSeqId;
1829 }
1830
abortCaptures()1831 camera_status_t abortCaptures() {
1832 if (mSession == nullptr) {
1833 ALOGE("Testcase cannot abort session %p", mSession);
1834 return ACAMERA_ERROR_UNKNOWN;
1835 }
1836 return ACameraCaptureSession_abortCaptures(mSession);
1837 }
1838
updateRepeatingRequest(ACaptureRequest * updatedRequest,int * sequenceId=nullptr)1839 camera_status_t updateRepeatingRequest(ACaptureRequest *updatedRequest,
1840 int *sequenceId = nullptr) {
1841 if (mSession == nullptr || updatedRequest == nullptr) {
1842 ALOGE("Testcase cannot update repeating request: session %p, updated request %p",
1843 mSession, updatedRequest);
1844 return ACAMERA_ERROR_UNKNOWN;
1845 }
1846
1847 int previewSeqId;
1848 camera_status_t ret;
1849 if (sequenceId == nullptr) {
1850 ret = ACameraCaptureSession_setRepeatingRequest(
1851 mSession, nullptr, 1, &updatedRequest, &previewSeqId);
1852 } else {
1853 ret = ACameraCaptureSession_setRepeatingRequest(
1854 mSession, &mResultCb, 1, &updatedRequest, sequenceId);
1855 }
1856 return ret;
1857 }
1858
getCaptureSequenceLastFrameNumber(int64_t sequenceId,uint32_t timeoutSec)1859 int64_t getCaptureSequenceLastFrameNumber(int64_t sequenceId, uint32_t timeoutSec) {
1860 return mResultListener.getCaptureSequenceLastFrameNumber(sequenceId, timeoutSec);
1861 }
1862
waitForFrameNumber(int64_t frameNumber,uint32_t timeoutSec)1863 bool waitForFrameNumber(int64_t frameNumber, uint32_t timeoutSec) {
1864 return mResultListener.waitForFrameNumber(frameNumber, timeoutSec);
1865 }
1866
waitForFrameNumberStarted(int64_t frameNumber,uint32_t timeoutSec)1867 bool waitForFrameNumberStarted(int64_t frameNumber, uint32_t timeoutSec) {
1868 return mResultListener.waitForFrameNumberStarted(frameNumber, timeoutSec);
1869 }
1870
waitForCaptureStarted(uint32_t timeoutSec)1871 bool waitForCaptureStarted(uint32_t timeoutSec) {
1872 return mResultListener.waitForCaptureStarted(timeoutSec);
1873 }
1874
takePicture()1875 camera_status_t takePicture() {
1876 if (mSession == nullptr || mStillRequest == nullptr) {
1877 ALOGE("Testcase cannot take picture: session %p, still request %p",
1878 mSession, mStillRequest);
1879 return ACAMERA_ERROR_UNKNOWN;
1880 }
1881 int seqId;
1882 return ACameraCaptureSession_capture(
1883 mSession, nullptr, 1, &mStillRequest, &seqId);
1884 }
1885
capture(ACaptureRequest * request,ACameraCaptureSession_captureCallbacks * listener,int * seqId)1886 camera_status_t capture(ACaptureRequest* request,
1887 ACameraCaptureSession_captureCallbacks* listener,
1888 /*out*/int* seqId) {
1889 if (mSession == nullptr || request == nullptr) {
1890 ALOGE("Testcase cannot capture session: session %p, request %p",
1891 mSession, request);
1892 return ACAMERA_ERROR_UNKNOWN;
1893 }
1894 return ACameraCaptureSession_capture(
1895 mSession, listener, 1, &request, seqId);
1896 }
1897
resetWithErrorLog()1898 camera_status_t resetWithErrorLog() {
1899 camera_status_t ret;
1900
1901 closeSession();
1902
1903 for (int i = 0; i < 50; i++) {
1904 usleep(100000); // sleep 100ms
1905 if (mSessionListener.isClosed()) {
1906 ALOGI("Session take ~%d ms to close", i*100);
1907 break;
1908 }
1909 }
1910
1911 if (!mSessionListener.isClosed() || mSessionListener.onClosedCount() != 1) {
1912 LOG_ERROR(errorString,
1913 "Session for camera %s close error. isClosde %d close count %d",
1914 mCameraId, mSessionListener.isClosed(), mSessionListener.onClosedCount());
1915 return ACAMERA_ERROR_UNKNOWN;
1916 }
1917 mSessionListener.reset();
1918 mResultListener.reset();
1919
1920 ret = closeCamera();
1921 if (ret != ACAMERA_OK) {
1922 LOG_ERROR(errorString, "Close camera device %s failure. ret %d", mCameraId, ret);
1923 return ret;
1924 }
1925
1926 resetCamera();
1927 return ACAMERA_OK;
1928 }
1929
getDeviceListener()1930 CameraDeviceListener* getDeviceListener() { return &mDeviceListener; }
1931
getSessionListener()1932 CaptureSessionListener* getSessionListener() {
1933 return &mSessionListener;
1934 }
1935
getCameraDevice()1936 ACameraDevice* getCameraDevice() {
1937 return mDevice;
1938 }
1939
getPreviewOutput()1940 ACaptureSessionOutput *getPreviewOutput() {
1941 return mPreviewOutput;
1942 }
1943
getImageReaderOutput()1944 ACaptureSessionOutput* getImageReaderOutput() { return mImgReaderOutput; }
1945
getImageReaderNativeWindow()1946 ANativeWindow* getImageReaderNativeWindow() { return mImgReaderAnw; }
1947
1948 private:
createManager()1949 ACameraManager* createManager() {
1950 if (!mCameraManager) {
1951 mCameraManager = ACameraManager_create();
1952 }
1953 return mCameraManager;
1954 }
1955
1956 ImageReaderListener mReaderListener;
1957 AImageReader_ImageListener mReaderCb {
1958 &mReaderListener,
1959 ImageReaderListener::validateImageCb
1960 };
1961
1962 CameraServiceListener mServiceListener;
1963 ACameraManager_AvailabilityCallbacks mServiceCb {
1964 &mServiceListener,
1965 CameraServiceListener::onAvailable,
1966 CameraServiceListener::onUnavailable
1967 };
1968 CameraDeviceListener mDeviceListener;
1969 ACameraDevice_StateCallbacks mDeviceCb {
1970 &mDeviceListener,
1971 CameraDeviceListener::onDisconnected,
1972 CameraDeviceListener::onError,
1973 CameraDeviceListener::onClientSharedAccessPriorityChanged
1974 };
1975 CaptureSessionListener mSessionListener;
1976 ACameraCaptureSession_stateCallbacks mSessionCb {
1977 &mSessionListener,
1978 CaptureSessionListener::onClosed,
1979 CaptureSessionListener::onReady,
1980 CaptureSessionListener::onActive
1981 };
1982
1983 ACameraCaptureSession_prepareCallback mPreparedCb = &CaptureSessionListener::onWindowPrepared;
1984
1985 CaptureResultListener mResultListener;
1986 ACameraCaptureSession_captureCallbacks mResultCb {
1987 &mResultListener,
1988 CaptureResultListener::onCaptureStart,
1989 CaptureResultListener::onCaptureProgressed,
1990 CaptureResultListener::onCaptureCompleted,
1991 CaptureResultListener::onCaptureFailed,
1992 CaptureResultListener::onCaptureSequenceCompleted,
1993 CaptureResultListener::onCaptureSequenceAborted,
1994 CaptureResultListener::onCaptureBufferLost
1995 };
1996
1997 ACameraCaptureSession_captureCallbacksV2 mResultCb2 {
1998 &mResultListener,
1999 CaptureResultListener::onCaptureStartV2,
2000 CaptureResultListener::onCaptureProgressed,
2001 CaptureResultListener::onCaptureCompleted,
2002 CaptureResultListener::onCaptureFailed,
2003 CaptureResultListener::onCaptureSequenceCompleted,
2004 CaptureResultListener::onCaptureSequenceAborted,
2005 CaptureResultListener::onCaptureBufferLost
2006 };
2007
2008 ACameraCaptureSession_logicalCamera_captureCallbacksV2 mLogicalCameraResultCb2 {
2009 &mResultListener,
2010 CaptureResultListener::onCaptureStartV2,
2011 CaptureResultListener::onCaptureProgressed,
2012 CaptureResultListener::onLogicalCameraCaptureCompleted,
2013 CaptureResultListener::onLogicalCameraCaptureFailed,
2014 CaptureResultListener::onCaptureSequenceCompleted,
2015 CaptureResultListener::onCaptureSequenceAborted,
2016 CaptureResultListener::onCaptureBufferLost
2017 };
2018
2019 ACameraCaptureSession_logicalCamera_captureCallbacks mLogicalCameraResultCb {
2020 &mResultListener,
2021 CaptureResultListener::onCaptureStart,
2022 CaptureResultListener::onCaptureProgressed,
2023 CaptureResultListener::onLogicalCameraCaptureCompleted,
2024 CaptureResultListener::onLogicalCameraCaptureFailed,
2025 CaptureResultListener::onCaptureSequenceCompleted,
2026 CaptureResultListener::onCaptureSequenceAborted,
2027 CaptureResultListener::onCaptureBufferLost
2028 };
2029
2030 ACameraIdList* mCameraIdList = nullptr;
2031 ACameraDevice* mDevice = nullptr;
2032 AImageReader* mImgReader = nullptr;
2033 ANativeWindow* mImgReaderAnw = nullptr;
2034 ANativeWindow* mPreviewAnw = nullptr;
2035 ACameraManager* mCameraManager = nullptr;
2036 ACaptureSessionOutputContainer* mOutputs = nullptr;
2037 ACaptureSessionOutput* mPreviewOutput = nullptr;
2038 ACaptureSessionOutput* mImgReaderOutput = nullptr;
2039 ACameraCaptureSession* mSession = nullptr;
2040 ACaptureRequest* mPreviewRequest = nullptr;
2041 ACaptureRequest* mStillRequest = nullptr;
2042 ACameraOutputTarget* mReqPreviewOutput = nullptr;
2043 ACameraOutputTarget* mReqImgReaderOutput = nullptr;
2044 const char* mCameraId;
2045 JNIEnv* mJNIEnv = nullptr;
2046 jstring mJOverrideCameraId;
2047 const char* mOverrideCameraId = nullptr;
2048
2049 bool mMgrInited = false; // cameraId, serviceListener
2050 bool mImgReaderInited = false;
2051 bool mPreviewInited = false;
2052 int mSharedStreamingSeqId = 0;
2053 };
2054
throwAssertionError(JNIEnv * env,const char * message)2055 jint throwAssertionError(JNIEnv* env, const char* message)
2056 {
2057 jclass assertionClass;
2058 const char* className = "junit/framework/AssertionFailedError";
2059
2060 assertionClass = env->FindClass(className);
2061 if (assertionClass == nullptr) {
2062 ALOGE("Native throw error: cannot find class %s", className);
2063 return -1;
2064 }
2065 return env->ThrowNew(assertionClass, message);
2066 }
2067
2068 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraManagerTest_testCameraManagerGetAndCloseNative(JNIEnv * env,jclass)2069 Java_android_hardware_camera2_cts_NativeCameraManagerTest_\
2070 testCameraManagerGetAndCloseNative(
2071 JNIEnv* env, jclass /*clazz*/) {
2072 bool pass = false;
2073 ALOGV("%s", __FUNCTION__);
2074 ACameraManager* cameraManager2 = nullptr;
2075 ACameraManager* cameraManager3 = nullptr;
2076 ACameraManager* cameraManager4 = nullptr;
2077 camera_status_t ret = ACAMERA_OK;
2078 ACameraManager* cameraManager = ACameraManager_create();
2079 if (cameraManager == nullptr) {
2080 LOG_ERROR(errorString, "ACameraManager_create returns nullptr");
2081 goto cleanup;
2082 }
2083 ACameraManager_delete(cameraManager);
2084 cameraManager = nullptr;
2085
2086 // Test get/close multiple instances
2087 cameraManager = ACameraManager_create();
2088 cameraManager2 = ACameraManager_create();
2089 if (cameraManager2 == nullptr) {
2090 LOG_ERROR(errorString, "ACameraManager_create 2 returns nullptr");
2091 goto cleanup;
2092 }
2093 ACameraManager_delete(cameraManager);
2094 cameraManager = nullptr;
2095 cameraManager3 = ACameraManager_create();
2096 if (cameraManager3 == nullptr) {
2097 LOG_ERROR(errorString, "ACameraManager_create 3 returns nullptr");
2098 goto cleanup;
2099 }
2100 cameraManager4 = ACameraManager_create();
2101 if (cameraManager4 == nullptr) {
2102 LOG_ERROR(errorString, "ACameraManager_create 4 returns nullptr");
2103 goto cleanup;
2104 }
2105 ACameraManager_delete(cameraManager3);
2106 ACameraManager_delete(cameraManager2);
2107 ACameraManager_delete(cameraManager4);
2108
2109 pass = true;
2110 cleanup:
2111 if (cameraManager) {
2112 ACameraManager_delete(cameraManager);
2113 }
2114 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "fail");
2115 if (!pass) {
2116 throwAssertionError(env, errorString);
2117 }
2118 return pass;
2119 }
2120
2121 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraManagerTest_testCameraManagerGetCameraIdsNative(JNIEnv * env,jclass)2122 Java_android_hardware_camera2_cts_NativeCameraManagerTest_\
2123 testCameraManagerGetCameraIdsNative(
2124 JNIEnv* env, jclass /*clazz*/) {
2125 ALOGV("%s", __FUNCTION__);
2126 bool pass = false;
2127 ACameraManager* mgr = ACameraManager_create();
2128 ACameraIdList *cameraIdList = nullptr;
2129 camera_status_t ret = ACameraManager_getCameraIdList(mgr, &cameraIdList);
2130 if (ret != ACAMERA_OK || cameraIdList == nullptr) {
2131 LOG_ERROR(errorString, "Get camera id list failed: ret %d, cameraIdList %p",
2132 ret, cameraIdList);
2133 goto cleanup;
2134 }
2135 ALOGI("Number of cameras: %d", cameraIdList->numCameras);
2136 for (int i = 0; i < cameraIdList->numCameras; i++) {
2137 ALOGI("Camera ID: %s", cameraIdList->cameraIds[i]);
2138 }
2139 ACameraManager_deleteCameraIdList(cameraIdList);
2140 cameraIdList = nullptr;
2141
2142 pass = true;
2143 cleanup:
2144 if (mgr) {
2145 ACameraManager_delete(mgr);
2146 }
2147 if (cameraIdList) {
2148 ACameraManager_deleteCameraIdList(cameraIdList);
2149 }
2150 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "fail");
2151 if (!pass) {
2152 throwAssertionError(env, errorString);
2153 }
2154 return pass;
2155 }
2156
2157 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraManagerTest_testCameraManagerExtendedAvailabilityCallbackNative(JNIEnv * env,jclass)2158 Java_android_hardware_camera2_cts_NativeCameraManagerTest_\
2159 testCameraManagerExtendedAvailabilityCallbackNative(
2160 JNIEnv* env, jclass /*clazz*/) {
2161 ALOGV("%s", __FUNCTION__);
2162 bool pass = false;
2163 ACameraManager* mgr = ACameraManager_create();
2164 ACameraIdList *cameraIdList = nullptr;
2165 camera_status_t ret = ACameraManager_getCameraIdList(mgr, &cameraIdList);
2166 int numCameras = cameraIdList->numCameras;
2167 CameraServiceListener listener;
2168 CameraServiceListener::StringPairSet unavailablePhysicalCameras;
2169 CameraServiceListener::StringPairSet physicalCameraIdPairs;
2170 ACameraManager_ExtendedAvailabilityCallbacks cbs {
2171 {
2172 &listener,
2173 CameraServiceListener::onAvailable,
2174 CameraServiceListener::onUnavailable
2175 },
2176 CameraServiceListener::onCameraAccessPrioritiesChanged,
2177 CameraServiceListener::onPhysicalCameraAvailable,
2178 CameraServiceListener::onPhysicalCameraUnavailable,
2179 {}
2180 };
2181
2182 ret = ACameraManager_registerExtendedAvailabilityCallback(mgr, &cbs);
2183 if (ret != ACAMERA_OK) {
2184 LOG_ERROR(errorString, "Register extended availability callback failed: ret %d", ret);
2185 goto cleanup;
2186 }
2187 sleep(1); // sleep a second to give some time for callbacks to happen
2188
2189 // Should at least get onAvailable for each camera once
2190 if (listener.getAvailableCount() < numCameras) {
2191 LOG_ERROR(errorString, "Expect at least %d available callback but only got %d",
2192 numCameras, listener.getAvailableCount());
2193 goto cleanup;
2194 }
2195
2196 {
2197 int availablePhysicalCamera = listener.getPhysicalCameraAvailableCount();
2198 if (availablePhysicalCamera > 0) {
2199 LOG_ERROR(errorString, "Expect no available callback, but got %d",
2200 availablePhysicalCamera);
2201 }
2202 }
2203
2204 unavailablePhysicalCameras = listener.getUnavailablePhysicalCameras();
2205 for (int i = 0; i < numCameras; i++) {
2206 const char* cameraId = cameraIdList->cameraIds[i];
2207 if (cameraId == nullptr) {
2208 LOG_ERROR(errorString, "Testcase returned null camera id for camera %d", i);
2209 goto cleanup;
2210 }
2211 ACameraMetadata* c;
2212 ret = ACameraManager_getCameraCharacteristics(mgr, cameraId, &c);
2213 if (ret != ACAMERA_OK || c == nullptr) {
2214 LOG_ERROR(errorString, "Get camera %s characteristics failure", cameraId);
2215 goto cleanup;
2216 }
2217 std::unique_ptr<ACameraMetadata> chars(c);
2218
2219 size_t physicalCameraCnt = 0;
2220 const char *const* physicalCameraIds = nullptr;
2221 if (!ACameraMetadata_isLogicalMultiCamera(
2222 chars.get(), &physicalCameraCnt, &physicalCameraIds)) {
2223 continue;
2224 }
2225 for (size_t j = 0; j < physicalCameraCnt; j++) {
2226 physicalCameraIdPairs.emplace(cameraId, physicalCameraIds[j]);
2227 }
2228 }
2229 for (const auto& unavailIdPair : unavailablePhysicalCameras) {
2230 bool validPair = false;
2231 for (const auto& idPair : physicalCameraIdPairs) {
2232 if (idPair.first == unavailIdPair.first && idPair.second == unavailIdPair.second) {
2233 validPair = true;
2234 break;
2235 }
2236 }
2237 if (!validPair) {
2238 LOG_ERROR(errorString, "Expect valid unavailable physical cameras, but got %s : %s",
2239 unavailIdPair.first.c_str(), unavailIdPair.second.c_str());
2240 goto cleanup;
2241 }
2242 }
2243
2244 ret = ACameraManager_unregisterExtendedAvailabilityCallback(mgr, &cbs);
2245 if (ret != ACAMERA_OK) {
2246 LOG_ERROR(errorString, "Unregister extended availability callback failed: ret %d", ret);
2247 goto cleanup;
2248 }
2249 pass = true;
2250 cleanup:
2251 if (cameraIdList) {
2252 ACameraManager_deleteCameraIdList(cameraIdList);
2253 }
2254 if (mgr) {
2255 ACameraManager_delete(mgr);
2256 }
2257 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
2258 if (!pass) {
2259 throwAssertionError(env, errorString);
2260 }
2261 return pass;
2262 }
2263
2264 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraManagerTest_testCameraManagerAvailabilityCallbackNative(JNIEnv * env,jclass)2265 Java_android_hardware_camera2_cts_NativeCameraManagerTest_\
2266 testCameraManagerAvailabilityCallbackNative(
2267 JNIEnv* env, jclass /*clazz*/) {
2268 ALOGV("%s", __FUNCTION__);
2269 bool pass = false;
2270 ACameraManager* mgr = ACameraManager_create();
2271 ACameraIdList *cameraIdList = nullptr;
2272 camera_status_t ret = ACameraManager_getCameraIdList(mgr, &cameraIdList);
2273 int numCameras = cameraIdList->numCameras;
2274 CameraServiceListener listener;
2275 ACameraManager_AvailabilityCallbacks cbs {
2276 &listener,
2277 CameraServiceListener::onAvailable,
2278 CameraServiceListener::onUnavailable};
2279 ret = ACameraManager_registerAvailabilityCallback(mgr, &cbs);
2280 if (ret != ACAMERA_OK) {
2281 LOG_ERROR(errorString, "Register availability callback failed: ret %d", ret);
2282 goto cleanup;
2283 }
2284 sleep(1); // sleep a second to give some time for callbacks to happen
2285
2286 // Should at least get onAvailable for each camera once
2287 if (listener.getAvailableCount() < numCameras) {
2288 LOG_ERROR(errorString, "Expect at least %d available callback but only got %d",
2289 numCameras, listener.getAvailableCount());
2290 goto cleanup;
2291 }
2292
2293 ret = ACameraManager_unregisterAvailabilityCallback(mgr, &cbs);
2294 if (ret != ACAMERA_OK) {
2295 LOG_ERROR(errorString, "Unregister availability callback failed: ret %d", ret);
2296 goto cleanup;
2297 }
2298 pass = true;
2299 cleanup:
2300 if (cameraIdList) {
2301 ACameraManager_deleteCameraIdList(cameraIdList);
2302 }
2303 if (mgr) {
2304 ACameraManager_delete(mgr);
2305 }
2306 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
2307 if (!pass) {
2308 throwAssertionError(env, errorString);
2309 }
2310 return pass;
2311 }
2312
2313 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraManagerTest_testCameraManagerCharacteristicsNative(JNIEnv * env,jclass)2314 Java_android_hardware_camera2_cts_NativeCameraManagerTest_\
2315 testCameraManagerCharacteristicsNative(
2316 JNIEnv* env, jclass /*clazz*/) {
2317 ALOGV("%s", __FUNCTION__);
2318 bool pass = false;
2319 ACameraManager* mgr = ACameraManager_create();
2320 ACameraIdList *cameraIdList = nullptr;
2321 ACameraMetadata* chars = nullptr;
2322 ACameraMetadata* copy = nullptr;
2323 int numCameras = 0;
2324 camera_status_t ret = ACameraManager_getCameraIdList(mgr, &cameraIdList);
2325 if (ret != ACAMERA_OK || cameraIdList == nullptr) {
2326 LOG_ERROR(errorString, "Get camera id list failed: ret %d, cameraIdList %p",
2327 ret, cameraIdList);
2328 goto cleanup;
2329 }
2330 numCameras = cameraIdList->numCameras;
2331
2332 for (int i = 0; i < numCameras; i++) {
2333 ret = ACameraManager_getCameraCharacteristics(
2334 mgr, cameraIdList->cameraIds[i], &chars);
2335 if (ret != ACAMERA_OK) {
2336 LOG_ERROR(errorString, "Get camera characteristics failed: ret %d", ret);
2337 goto cleanup;
2338 }
2339
2340 int32_t numTags = 0;
2341 const uint32_t* tags = nullptr;
2342 ret = ACameraMetadata_getAllTags(chars, &numTags, &tags);
2343 if (ret != ACAMERA_OK) {
2344 LOG_ERROR(errorString, "Get camera characteristics tags failed: ret %d", ret);
2345 goto cleanup;
2346 }
2347
2348 for (int tid = 0; tid < numTags; tid++) {
2349 uint32_t tagId = tags[tid];
2350 ALOGV("%s camera characteristics contains key %u", __FUNCTION__, tagId);
2351 uint32_t sectionId = tagId >> 16;
2352 if (sectionId >= ACAMERA_SECTION_COUNT && sectionId < ACAMERA_VENDOR) {
2353 LOG_ERROR(errorString, "Unknown tagId %u, sectionId %u", tagId, sectionId);
2354 goto cleanup;
2355 }
2356 }
2357
2358 for (const auto keyAndTag : ndk_metadata_name_to_tag) {
2359 uint32_t returnedTag = 0;
2360 ret = ACameraMetadata_getTagFromName(chars, /*name*/keyAndTag.first, &returnedTag);
2361 if (ret != ACAMERA_OK) {
2362 LOG_ERROR(errorString, "ACameraMetadata_getTagFromName() failed: ret %d", ret);
2363 goto cleanup;
2364 }
2365 if (keyAndTag.second != returnedTag) {
2366 LOG_ERROR(errorString, "ACameraMetadata_getTagFromName returned incorrect tag"
2367 "value %u for tag %s, expected value %u", returnedTag, keyAndTag.first,
2368 keyAndTag.second);
2369 goto cleanup;
2370 }
2371 }
2372
2373
2374 ACameraMetadata_const_entry entry;
2375 ret = ACameraMetadata_getConstEntry(chars, ACAMERA_REQUEST_AVAILABLE_CAPABILITIES, &entry);
2376 if (ret != ACAMERA_OK) {
2377 LOG_ERROR(errorString, "Get const available capabilities key failed. ret %d", ret);
2378 goto cleanup;
2379 }
2380
2381 // Check the entry is actually legit
2382 if (entry.tag != ACAMERA_REQUEST_AVAILABLE_CAPABILITIES ||
2383 entry.count == 0 || entry.type != ACAMERA_TYPE_BYTE || entry.data.i32 == nullptr) {
2384 LOG_ERROR(errorString,
2385 "Bad available capabilities key: tag: %d (expected %d), count %u (expect > 0), "
2386 "type %d (expected %d), data %p (expected not null)",
2387 entry.tag, ACAMERA_REQUEST_AVAILABLE_CAPABILITIES, entry.count,
2388 entry.type, ACAMERA_TYPE_BYTE, entry.data.i32);
2389 goto cleanup;
2390 }
2391 // All camera supports BC except depth only cameras
2392 bool supportBC = false, supportDepth = false;
2393 for (uint32_t i = 0; i < entry.count; i++) {
2394 if (entry.data.u8[i] == ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
2395 supportBC = true;
2396 }
2397 if (entry.data.u8[i] == ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT) {
2398 supportDepth = true;
2399 }
2400 }
2401 if (!(supportBC || supportDepth)) {
2402 LOG_ERROR(errorString, "Error: camera device %s does not support either BC or DEPTH",
2403 cameraIdList->cameraIds[i]);
2404 goto cleanup;
2405 }
2406
2407 // Check copy works
2408 copy = ACameraMetadata_copy(chars);
2409
2410 // Compare copy with original
2411 ACameraMetadata_const_entry entryCopy;
2412 ret = ACameraMetadata_getConstEntry(
2413 copy, ACAMERA_REQUEST_AVAILABLE_CAPABILITIES, &entryCopy);
2414 if (ret != ACAMERA_OK) {
2415 LOG_ERROR(errorString, "Get const available capabilities key failed. ret %d", ret);
2416 goto cleanup;
2417 }
2418 for (uint32_t i = 0; i < entry.count; i++) {
2419 if (entry.data.u8[i] != entryCopy.data.u8[i]) {
2420 LOG_ERROR(errorString,
2421 "Copy of available capability key[%d]: %d mismatches original %d",
2422 i, entryCopy.data.u8[i], entry.data.u8[i]);
2423 goto cleanup;
2424 }
2425 }
2426
2427 // Check get unknown value fails
2428 uint32_t badTag = (uint32_t) ACAMERA_VENDOR_START - 1;
2429 ret = ACameraMetadata_getConstEntry(chars, badTag, &entry);
2430 if (ret == ACAMERA_OK) {
2431 LOG_ERROR(errorString, "Error: get unknown tag should fail!");
2432 goto cleanup;
2433 }
2434
2435 ACameraMetadata_free(chars);
2436 ACameraMetadata_free(copy);
2437 chars = nullptr;
2438 copy = nullptr;
2439 }
2440
2441 pass = true;
2442 cleanup:
2443 if (chars) {
2444 ACameraMetadata_free(chars);
2445 }
2446 if (copy) {
2447 ACameraMetadata_free(copy);
2448 }
2449 ACameraManager_deleteCameraIdList(cameraIdList);
2450 ACameraManager_delete(mgr);
2451 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
2452 if (!pass) {
2453 throwAssertionError(env, errorString);
2454 }
2455 return pass;
2456 }
2457
2458 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraDeviceTest_testCameraDeviceOpenAndCloseNative(JNIEnv * env,jclass,jstring jOverrideCameraId)2459 Java_android_hardware_camera2_cts_NativeCameraDeviceTest_\
2460 testCameraDeviceOpenAndCloseNative(
2461 JNIEnv* env, jclass /*clazz*/, jstring jOverrideCameraId) {
2462 ALOGV("%s", __FUNCTION__);
2463 int numCameras = 0;
2464 bool pass = false;
2465 PreviewTestCase testCase;
2466
2467 camera_status_t ret = testCase.initWithErrorLog(env, jOverrideCameraId);
2468 if (ret != ACAMERA_OK) {
2469 // Don't log error here. testcase did it
2470 goto cleanup;
2471 }
2472
2473 numCameras = testCase.getNumCameras();
2474 if (numCameras < 0) {
2475 LOG_ERROR(errorString, "Testcase returned negavtive number of cameras: %d", numCameras);
2476 goto cleanup;
2477 }
2478
2479 for (int i = 0; i < numCameras; i++) {
2480 const char* cameraId = testCase.getCameraId(i);
2481 if (cameraId == nullptr) {
2482 LOG_ERROR(errorString, "Testcase returned null camera id for camera %d", i);
2483 goto cleanup;
2484 }
2485
2486 ret = testCase.openCamera(cameraId);
2487 if (ret != ACAMERA_OK) {
2488 LOG_ERROR(errorString, "Open camera device %s failure. ret %d", cameraId, ret);
2489 goto cleanup;
2490 }
2491
2492 usleep(100000); // sleep to give some time for callbacks to happen
2493
2494 if (testCase.isCameraAvailable(cameraId)) {
2495 LOG_ERROR(errorString, "Camera %s should be unavailable now", cameraId);
2496 goto cleanup;
2497 }
2498
2499 ret = testCase.closeCamera();
2500 if (ret != ACAMERA_OK) {
2501 LOG_ERROR(errorString, "Close camera device %s failure. ret %d", cameraId, ret);
2502 goto cleanup;
2503 }
2504
2505 usleep(100000); // sleep to give some time for callbacks to happen
2506
2507 if (!testCase.isCameraAvailable(cameraId)) {
2508 LOG_ERROR(errorString, "Camera %s should be available now", cameraId);
2509 goto cleanup;
2510 }
2511 }
2512
2513 ret = testCase.deInit();
2514 if (ret != ACAMERA_OK) {
2515 LOG_ERROR(errorString, "Testcase deInit failed: ret %d", ret);
2516 goto cleanup;
2517 }
2518
2519 pass = true;
2520 cleanup:
2521 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
2522 if (!pass) {
2523 throwAssertionError(env, errorString);
2524 }
2525 return pass;
2526 }
2527
2528 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraDeviceTest_testCameraDeviceCreateCaptureRequestNative(JNIEnv * env,jclass,jstring jOverrideCameraId)2529 Java_android_hardware_camera2_cts_NativeCameraDeviceTest_\
2530 testCameraDeviceCreateCaptureRequestNative(
2531 JNIEnv* env, jclass /*clazz*/, jstring jOverrideCameraId) {
2532 ALOGV("%s", __FUNCTION__);
2533 bool pass = false;
2534 ACameraManager* mgr = ACameraManager_create();
2535 ACameraIdList* cameraIdList = nullptr;
2536 ACameraDevice* device = nullptr;
2537 ACaptureRequest* request = nullptr;
2538 ACameraMetadata* chars = nullptr;
2539 camera_status_t ret = ACameraManager_getCameraIdList(mgr, &cameraIdList);
2540
2541 int numCameras = cameraIdList->numCameras;
2542 const char* overrideCameraId = nullptr;
2543 if (jOverrideCameraId != nullptr) {
2544 overrideCameraId = env->GetStringUTFChars(jOverrideCameraId, nullptr);
2545 }
2546
2547 for (int i = 0; i < numCameras; i++) {
2548 CameraDeviceListener deviceListener;
2549 const char* cameraId = cameraIdList->cameraIds[i];
2550 if (overrideCameraId != nullptr && strcmp(overrideCameraId, cameraId)) {
2551 // Skip other cameras if overriding camera id to be tested.
2552 continue;
2553 }
2554 ACameraDevice_StateCallbacks deviceCb {
2555 &deviceListener,
2556 CameraDeviceListener::onDisconnected,
2557 CameraDeviceListener::onError
2558 };
2559 ret = ACameraManager_openCamera(mgr, cameraId, &deviceCb, &device);
2560 if (ret != ACAMERA_OK) {
2561 LOG_ERROR(errorString, "Open camera device %s failure. ret %d", cameraId, ret);
2562 goto cleanup;
2563 }
2564
2565 ret = ACameraManager_getCameraCharacteristics(mgr, cameraId, &chars);
2566 if (ret != ACAMERA_OK || chars == nullptr) {
2567 LOG_ERROR(errorString, "Get camera %s characteristics failure. ret %d, chars %p",
2568 cameraId, ret, chars);
2569 goto cleanup;
2570 }
2571 StaticInfo staticInfo(chars);
2572
2573 for (int t = TEMPLATE_PREVIEW; t <= TEMPLATE_MANUAL; t++) {
2574 ACameraDevice_request_template templateId =
2575 static_cast<ACameraDevice_request_template>(t);
2576 ret = ACameraDevice_createCaptureRequest(device, templateId, &request);
2577 if (ret == ACAMERA_ERROR_INVALID_PARAMETER) {
2578 // template not supported. skip
2579 continue;
2580 }
2581
2582 if (ret != ACAMERA_OK) {
2583 LOG_ERROR(errorString, "Create capture request failed!: ret %d", ret);
2584 goto cleanup;
2585 }
2586
2587 int32_t numTags = 0;
2588 const uint32_t* tags = nullptr;
2589 ret = ACaptureRequest_getAllTags(request, &numTags, &tags);
2590 if (ret != ACAMERA_OK) {
2591 LOG_ERROR(errorString, "Get capture request tags failed: ret %d", ret);
2592 goto cleanup;
2593 }
2594
2595 for (int tid = 0; tid < numTags; tid++) {
2596 uint32_t tagId = tags[tid];
2597 ALOGV("%s capture request contains key %u", __FUNCTION__, tagId);
2598 uint32_t sectionId = tagId >> 16;
2599 if (sectionId >= ACAMERA_SECTION_COUNT && sectionId < ACAMERA_VENDOR) {
2600 LOG_ERROR(errorString, "Unknown tagId %u, sectionId %u", tagId, sectionId);
2601 goto cleanup;
2602 }
2603 }
2604
2605 void* context = nullptr;
2606 ret = ACaptureRequest_getUserContext(request, &context);
2607 if (ret != ACAMERA_OK) {
2608 LOG_ERROR(errorString, "Get capture request context failed: ret %d", ret);
2609 goto cleanup;
2610 }
2611 if (context != nullptr) {
2612 LOG_ERROR(errorString, "Capture request context is not null: %p", context);
2613 goto cleanup;
2614 }
2615
2616 intptr_t magic_num = 0xBEEF;
2617 ret = ACaptureRequest_setUserContext(request, (void*) magic_num);
2618 if (ret != ACAMERA_OK) {
2619 LOG_ERROR(errorString, "Set capture request context failed: ret %d", ret);
2620 goto cleanup;
2621 }
2622
2623 ret = ACaptureRequest_getUserContext(request, &context);
2624 if (ret != ACAMERA_OK) {
2625 LOG_ERROR(errorString, "Get capture request context failed: ret %d", ret);
2626 goto cleanup;
2627 }
2628 if (context != (void*) magic_num) {
2629 LOG_ERROR(errorString, "Capture request context is wrong: %p", context);
2630 goto cleanup;
2631 }
2632
2633 // try get/set capture request fields
2634 ACameraMetadata_const_entry entry;
2635 ret = ACaptureRequest_getConstEntry_physicalCamera(request, nullptr,
2636 ACAMERA_CONTROL_AE_MODE, &entry);
2637 if (ret != ACAMERA_ERROR_INVALID_PARAMETER) {
2638 LOG_ERROR(errorString, "Get AE mode key for null physical id should fail. ret %d",
2639 ret);
2640 goto cleanup;
2641 }
2642 ret = ACaptureRequest_getConstEntry_physicalCamera(request, cameraId,
2643 ACAMERA_CONTROL_AE_MODE, &entry);
2644 if (ret != ACAMERA_ERROR_INVALID_PARAMETER) {
2645 LOG_ERROR(errorString, "Get AE mode key for physical id should fail. ret %d",
2646 ret);
2647 goto cleanup;
2648 }
2649 ret = ACaptureRequest_getConstEntry(request, ACAMERA_CONTROL_AE_MODE, &entry);
2650 if (ret != ACAMERA_OK) {
2651 LOG_ERROR(errorString, "Get AE mode key failed. ret %d", ret);
2652 goto cleanup;
2653 }
2654
2655 if (entry.tag != ACAMERA_CONTROL_AE_MODE || entry.type != ACAMERA_TYPE_BYTE ||\
2656 entry.count != 1) {
2657 LOG_ERROR(errorString,
2658 "Bad AE mode key. tag 0x%x (expect 0x%x), type %d (expect %d), "
2659 "count %d (expect %d)",
2660 entry.tag, ACAMERA_CONTROL_AE_MODE, entry.type, ACAMERA_TYPE_BYTE,
2661 entry.count, 1);
2662 goto cleanup;
2663 }
2664 if (t == TEMPLATE_MANUAL) {
2665 if (entry.data.u8[0] != ACAMERA_CONTROL_AE_MODE_OFF) {
2666 LOG_ERROR(errorString, "Error: MANUAL template AE mode %d (expect %d)",
2667 entry.data.u8[0], ACAMERA_CONTROL_AE_MODE_OFF);
2668 goto cleanup;
2669 }
2670 // try set AE_MODE_ON
2671 uint8_t aeMode = ACAMERA_CONTROL_AE_MODE_ON;
2672 ret = ACaptureRequest_setEntry_physicalCamera_u8(
2673 request, nullptr, ACAMERA_CONTROL_AE_MODE, /*count*/ 1, &aeMode);
2674 if (ret != ACAMERA_ERROR_INVALID_PARAMETER) {
2675 LOG_ERROR(errorString, "Error: camera %s setEntry_physicalCamera_u8 should "
2676 "fail. ret %d", cameraId, ret);
2677 goto cleanup;
2678 }
2679 ret = ACaptureRequest_setEntry_physicalCamera_u8(
2680 request, cameraId, ACAMERA_CONTROL_AE_MODE, /*count*/ 1, &aeMode);
2681 if (ret != ACAMERA_ERROR_INVALID_PARAMETER) {
2682 LOG_ERROR(errorString, "Error: camera %s setEntry_physicalCamera_u8 should "
2683 "fail. ret %d", cameraId, ret);
2684 goto cleanup;
2685 }
2686 ret = ACaptureRequest_setEntry_u8(
2687 request, ACAMERA_CONTROL_AE_MODE, /*count*/ 1, &aeMode);
2688 if (ret != ACAMERA_OK) {
2689 LOG_ERROR(errorString,
2690 "Error: Camera %s template %d: update AE mode key fail. ret %d",
2691 cameraId, t, ret);
2692 goto cleanup;
2693 }
2694 ret = ACaptureRequest_getConstEntry(
2695 request, ACAMERA_CONTROL_AE_MODE, &entry);
2696 if (ret != ACAMERA_OK) {
2697 LOG_ERROR(errorString, "Get AE mode key failed. ret %d", ret);
2698 goto cleanup;
2699 }
2700 if (entry.data.u8[0] != aeMode) {
2701 LOG_ERROR(errorString,
2702 "Error: AE mode key is not updated. expect %d but get %d",
2703 aeMode, entry.data.u8[0]);
2704 goto cleanup;
2705 }
2706 } else {
2707 if (staticInfo.isColorOutputSupported()) {
2708 if (entry.data.u8[0] != ACAMERA_CONTROL_AE_MODE_ON) {
2709 LOG_ERROR(errorString,
2710 "Error: Template %d has wrong AE mode %d (expect %d)",
2711 t, entry.data.u8[0], ACAMERA_CONTROL_AE_MODE_ON);
2712 goto cleanup;
2713 }
2714 // try set AE_MODE_OFF
2715 if (staticInfo.isCapabilitySupported(
2716 ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR)) {
2717 uint8_t aeMode = ACAMERA_CONTROL_AE_MODE_OFF;
2718 ret = ACaptureRequest_setEntry_u8(
2719 request, ACAMERA_CONTROL_AE_MODE, /*count*/ 1, &aeMode);
2720 if (ret != ACAMERA_OK) {
2721 LOG_ERROR(errorString,
2722 "Error: Camera %s template %d: update AE mode key fail. ret %d",
2723 cameraId, t, ret);
2724 goto cleanup;
2725 }
2726 ret = ACaptureRequest_getConstEntry(
2727 request, ACAMERA_CONTROL_AE_MODE, &entry);
2728 if (ret != ACAMERA_OK) {
2729 LOG_ERROR(errorString, "Get AE mode key failed. ret %d", ret);
2730 goto cleanup;
2731 }
2732 if (entry.data.u8[0] != aeMode) {
2733 LOG_ERROR(errorString,
2734 "Error: AE mode key is not updated. expect %d but get %d",
2735 aeMode, entry.data.u8[0]);
2736 goto cleanup;
2737 }
2738 }
2739 }
2740 }
2741 ACaptureRequest_free(request);
2742 request = nullptr;
2743 }
2744
2745 ACameraMetadata_free(chars);
2746 chars = nullptr;
2747 ACameraDevice_close(device);
2748 device = nullptr;
2749 }
2750
2751 pass = true;
2752 cleanup:
2753 if (cameraIdList) {
2754 ACameraManager_deleteCameraIdList(cameraIdList);
2755 }
2756 if (request) {
2757 ACaptureRequest_free(request);
2758 }
2759 if (chars) {
2760 ACameraMetadata_free(chars);
2761 }
2762 if (device) {
2763 ACameraDevice_close(device);
2764 }
2765 if (mgr) {
2766 ACameraManager_delete(mgr);
2767 }
2768 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
2769 if (!pass) {
2770 throwAssertionError(env, errorString);
2771 }
2772 return pass;
2773 }
2774
2775 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraDeviceTest_testCameraDeviceSessionOpenAndCloseNative(JNIEnv * env,jclass,jobject jPreviewSurface,jstring jOverrideCameraId)2776 Java_android_hardware_camera2_cts_NativeCameraDeviceTest_\
2777 testCameraDeviceSessionOpenAndCloseNative(
2778 JNIEnv* env, jclass /*clazz*/, jobject jPreviewSurface,
2779 jstring jOverrideCameraId) {
2780 ALOGV("%s", __FUNCTION__);
2781 int numCameras = 0;
2782 bool pass = false;
2783 PreviewTestCase testCase;
2784
2785 camera_status_t ret = testCase.initWithErrorLog(env, jOverrideCameraId);
2786 if (ret != ACAMERA_OK) {
2787 // Don't log error here. testcase did it
2788 goto cleanup;
2789 }
2790
2791 numCameras = testCase.getNumCameras();
2792 if (numCameras < 0) {
2793 LOG_ERROR(errorString, "Testcase returned negavtive number of cameras: %d", numCameras);
2794 goto cleanup;
2795 }
2796
2797 for (int i = 0; i < numCameras; i++) {
2798 const char* cameraId = testCase.getCameraId(i);
2799 if (cameraId == nullptr) {
2800 LOG_ERROR(errorString, "Testcase returned null camera id for camera %d", i);
2801 goto cleanup;
2802 }
2803
2804 {
2805 ACameraMetadata* chars = testCase.getCameraChars(cameraId);
2806 StaticInfo staticInfo(chars);
2807 if (!staticInfo.isColorOutputSupported()) {
2808 ALOGI("%s: camera %s does not support color output. skipping",
2809 __FUNCTION__, cameraId);
2810 ACameraMetadata_free(chars);
2811 continue;
2812 }
2813 ACameraMetadata_free(chars);
2814 }
2815
2816 ret = testCase.openCamera(cameraId);
2817 if (ret != ACAMERA_OK) {
2818 LOG_ERROR(errorString, "Open camera device %s failure. ret %d", cameraId, ret);
2819 goto cleanup;
2820 }
2821
2822 usleep(100000); // sleep to give some time for callbacks to happen
2823
2824 if (testCase.isCameraAvailable(cameraId)) {
2825 LOG_ERROR(errorString, "Camera %s should be unavailable now", cameraId);
2826 goto cleanup;
2827 }
2828
2829 ANativeWindow* previewAnw = testCase.initPreviewAnw(env, jPreviewSurface);
2830 if (previewAnw == nullptr) {
2831 LOG_ERROR(errorString, "Null ANW from preview surface!");
2832 goto cleanup;
2833 }
2834
2835 CaptureSessionListener* sessionListener = testCase.getSessionListener();
2836 if (sessionListener == nullptr) {
2837 LOG_ERROR(errorString, "Session listener camera %s is null", cameraId);
2838 goto cleanup;
2839 }
2840
2841 // Try open/close session multiple times
2842 for (int j = 0; j < 5; j++) {
2843 ret = testCase.createCaptureSessionWithLog();
2844 if (ret != ACAMERA_OK) {
2845 // Don't log error here. testcase did it
2846 goto cleanup;
2847 }
2848
2849 usleep(100000); // sleep to give some time for callbacks to happen
2850
2851 if (!sessionListener->isIdle()) {
2852 LOG_ERROR(errorString, "Session for camera %s should be idle right after creation",
2853 cameraId);
2854 goto cleanup;
2855 }
2856
2857 testCase.closeSession();
2858
2859 usleep(100000); // sleep to give some time for callbacks to happen
2860 if (!sessionListener->isClosed() || sessionListener->onClosedCount() != 1) {
2861 LOG_ERROR(errorString,
2862 "Session for camera %s close error. isClosde %d close count %d",
2863 cameraId, sessionListener->isClosed(), sessionListener->onClosedCount());
2864 goto cleanup;
2865 }
2866 sessionListener->reset();
2867 }
2868
2869 // Try open/close really fast
2870 ret = testCase.createCaptureSessionWithLog();
2871 if (ret != ACAMERA_OK) {
2872 LOG_ERROR(errorString, "Create session for camera %s failed. ret %d",
2873 cameraId, ret);
2874 goto cleanup;
2875 }
2876 testCase.closeSession();
2877 usleep(100000); // sleep to give some time for callbacks to happen
2878 if (!sessionListener->isClosed() || sessionListener->onClosedCount() != 1) {
2879 LOG_ERROR(errorString,
2880 "Session for camera %s close error. isClosde %d close count %d",
2881 cameraId, sessionListener->isClosed(), sessionListener->onClosedCount());
2882 goto cleanup;
2883 }
2884
2885 ret = testCase.resetWithErrorLog();
2886 if (ret != ACAMERA_OK) {
2887 // Don't log error here. testcase did it
2888 goto cleanup;
2889 }
2890
2891 usleep(100000); // sleep to give some time for callbacks to happen
2892
2893 if (!testCase.isCameraAvailable(cameraId)) {
2894 LOG_ERROR(errorString, "Camera %s should be available now", cameraId);
2895 goto cleanup;
2896 }
2897 }
2898
2899 ret = testCase.deInit();
2900 if (ret != ACAMERA_OK) {
2901 LOG_ERROR(errorString, "Testcase deInit failed: ret %d", ret);
2902 goto cleanup;
2903 }
2904
2905 pass = true;
2906 cleanup:
2907 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
2908 if (!pass) {
2909 throwAssertionError(env, errorString);
2910 }
2911 return pass;
2912 }
2913
2914 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraDeviceTest_testCameraDeviceSharedOutputUpdate(JNIEnv * env,jclass,jobject jPreviewSurface,jobject jSharedSurface,jstring jOverrideCameraId)2915 Java_android_hardware_camera2_cts_NativeCameraDeviceTest_\
2916 testCameraDeviceSharedOutputUpdate(
2917 JNIEnv* env, jclass /*clazz*/, jobject jPreviewSurface, jobject jSharedSurface,
2918 jstring jOverrideCameraId) {
2919 ALOGV("%s", __FUNCTION__);
2920 int numCameras = 0;
2921 bool pass = false;
2922 PreviewTestCase testCase;
2923 int sequenceId = -1;
2924 int64_t lastFrameNumber = 0;
2925 bool frameArrived = false;
2926 ANativeWindow* previewAnw = nullptr;
2927 ANativeWindow* sharedAnw = ANativeWindow_fromSurface(env, jSharedSurface);
2928 ACaptureRequest* updatedRequest = nullptr;
2929 ACameraOutputTarget* reqPreviewOutput = nullptr;
2930 ACameraOutputTarget* reqSharedOutput = nullptr;
2931 ACaptureSessionOutput *previewOutput = nullptr;
2932 uint32_t timeoutSec = 1;
2933 uint32_t runPreviewSec = 2;
2934
2935 camera_status_t ret = testCase.initWithErrorLog(env, jOverrideCameraId);
2936 if (ret != ACAMERA_OK) {
2937 // Don't log error here. testcase did it
2938 goto cleanup;
2939 }
2940
2941 numCameras = testCase.getNumCameras();
2942 if (numCameras < 0) {
2943 LOG_ERROR(errorString, "Testcase returned negavtive number of cameras: %d", numCameras);
2944 goto cleanup;
2945 }
2946
2947 for (int i = 0; i < numCameras; i++) {
2948 const char* cameraId = testCase.getCameraId(i);
2949 if (cameraId == nullptr) {
2950 LOG_ERROR(errorString, "Testcase returned null camera id for camera %d", i);
2951 goto cleanup;
2952 }
2953
2954 {
2955 ACameraMetadata* chars = testCase.getCameraChars(cameraId);
2956 StaticInfo staticInfo(chars);
2957 if (!staticInfo.isColorOutputSupported()) {
2958 ALOGI("%s: camera %s does not support color output. skipping",
2959 __FUNCTION__, cameraId);
2960 ACameraMetadata_free(chars);
2961 continue;
2962 }
2963 ACameraMetadata_free(chars);
2964 }
2965
2966 ret = testCase.openCamera(cameraId);
2967 if (ret != ACAMERA_OK) {
2968 LOG_ERROR(errorString, "Open camera device %s failure. ret %d", cameraId, ret);
2969 goto cleanup;
2970 }
2971
2972 usleep(100000); // sleep to give some time for callbacks to happen
2973
2974 if (testCase.isCameraAvailable(cameraId)) {
2975 LOG_ERROR(errorString, "Camera %s should be unavailable now", cameraId);
2976 goto cleanup;
2977 }
2978
2979 previewAnw = testCase.initPreviewAnw(env, jPreviewSurface);
2980 if (previewAnw == nullptr) {
2981 LOG_ERROR(errorString, "Null ANW from preview surface!");
2982 goto cleanup;
2983 }
2984
2985 ret = testCase.createCaptureSessionWithLog(true);
2986 if (ret != ACAMERA_OK) {
2987 // Don't log error here. testcase did it
2988 goto cleanup;
2989 }
2990
2991 ret = testCase.createRequestsWithErrorLog();
2992 if (ret != ACAMERA_OK) {
2993 // Don't log error here. testcase did it
2994 goto cleanup;
2995 }
2996
2997 ret = testCase.startPreview();
2998 if (ret != ACAMERA_OK) {
2999 LOG_ERROR(errorString, "Start preview failed!");
3000 goto cleanup;
3001 }
3002
3003 sleep(runPreviewSec);
3004
3005 previewOutput = testCase.getPreviewOutput();
3006 //Try some bad input
3007 ret = ACaptureSessionSharedOutput_add(previewOutput, previewAnw);
3008 if (ret != ACAMERA_ERROR_INVALID_PARAMETER) {
3009 LOG_ERROR(errorString, "ACaptureSessionSharedOutput_add should return invalid "
3010 "parameter! %d", ret);
3011 goto cleanup;
3012 }
3013
3014 ret = ACaptureSessionSharedOutput_remove(previewOutput, previewAnw);
3015 if (ret != ACAMERA_ERROR_INVALID_PARAMETER) {
3016 LOG_ERROR(errorString, "ACaptureSessionSharedOutput_remove should return invalid "
3017 "parameter! %d", ret);
3018 goto cleanup;
3019 }
3020
3021 //Now try with valid input
3022 ret = ACaptureSessionSharedOutput_add(previewOutput, sharedAnw);
3023 if (ret != ACAMERA_OK) {
3024 LOG_ERROR(errorString, "ACaptureSessionSharedOutput_add failed!")
3025 goto cleanup;
3026 }
3027
3028 ret = testCase.updateOutput(env, previewOutput);
3029 if (ret != ACAMERA_OK) {
3030 LOG_ERROR(errorString, "Failed to update output configuration!")
3031 goto cleanup;
3032 }
3033
3034 ret = ACameraDevice_createCaptureRequest(
3035 testCase.getCameraDevice(), TEMPLATE_PREVIEW, &updatedRequest);
3036 if (ret != ACAMERA_OK) {
3037 LOG_ERROR(errorString, "Camera %s create preview request failed. ret %d",
3038 cameraId, ret);
3039 goto cleanup;
3040 }
3041
3042 ret = ACameraOutputTarget_create(previewAnw, &reqPreviewOutput);
3043 if (ret != ACAMERA_OK) {
3044 LOG_ERROR(errorString,
3045 "Camera %s create request preview output target failed. ret %d",
3046 cameraId, ret);
3047 goto cleanup;
3048 }
3049
3050 ret = ACaptureRequest_addTarget(updatedRequest, reqPreviewOutput);
3051 if (ret != ACAMERA_OK) {
3052 LOG_ERROR(errorString, "Camera %s add preview request output failed. ret %d",
3053 cameraId, ret);
3054 goto cleanup;
3055 }
3056
3057 ret = ACameraOutputTarget_create(sharedAnw, &reqSharedOutput);
3058 if (ret != ACAMERA_OK) {
3059 LOG_ERROR(errorString,
3060 "Camera %s create request preview output target failed. ret %d",
3061 cameraId, ret);
3062 goto cleanup;
3063 }
3064
3065 ret = ACaptureRequest_addTarget(updatedRequest, reqSharedOutput);
3066 if (ret != ACAMERA_OK) {
3067 LOG_ERROR(errorString, "Camera %s add preview request output failed. ret %d",
3068 cameraId, ret);
3069 goto cleanup;
3070 }
3071
3072 ret = testCase.updateRepeatingRequest(updatedRequest, &sequenceId);
3073 if (ret != ACAMERA_OK) {
3074 LOG_ERROR(errorString, "Camera %s failed to update repeated request. ret %d",
3075 cameraId, ret);
3076 goto cleanup;
3077 }
3078
3079 sleep(runPreviewSec);
3080
3081 ret = ACaptureSessionSharedOutput_remove(previewOutput, sharedAnw);
3082 if (ret != ACAMERA_OK) {
3083 LOG_ERROR(errorString, "ACaptureSessionSharedOutput_remove failed!");
3084 goto cleanup;
3085 }
3086
3087 //Try removing shared output which still has pending camera requests
3088 ret = testCase.updateOutput(env, previewOutput);
3089 if (ret != ACAMERA_ERROR_INVALID_PARAMETER) {
3090 LOG_ERROR(errorString, "updateOutput should fail!");
3091 goto cleanup;
3092 }
3093
3094 //Remove the shared output correctly by updating the repeating request
3095 //first
3096 ret = ACaptureRequest_removeTarget(updatedRequest, reqSharedOutput);
3097 if (ret != ACAMERA_OK) {
3098 LOG_ERROR(errorString, "Camera %s remove target output failed. ret %d",
3099 cameraId, ret);
3100 goto cleanup;
3101 }
3102
3103 ret = testCase.updateRepeatingRequest(updatedRequest);
3104 if (ret != ACAMERA_OK) {
3105 LOG_ERROR(errorString, "Camera %s failed to update repeated request. ret %d",
3106 cameraId, ret);
3107 goto cleanup;
3108 }
3109
3110 //Then wait for all old requests to flush
3111 lastFrameNumber = testCase.getCaptureSequenceLastFrameNumber(sequenceId, timeoutSec);
3112 if (lastFrameNumber < 0) {
3113 LOG_ERROR(errorString, "Camera %s failed to acquire last frame number!",
3114 cameraId);
3115 goto cleanup;
3116 }
3117
3118 frameArrived = testCase.waitForFrameNumber(lastFrameNumber, timeoutSec);
3119 if (!frameArrived) {
3120 LOG_ERROR(errorString, "Camera %s timed out waiting on last frame number!",
3121 cameraId);
3122 goto cleanup;
3123 }
3124
3125 ret = testCase.updateOutput(env, previewOutput);
3126 if (ret != ACAMERA_OK) {
3127 LOG_ERROR(errorString, "updateOutput failed!");
3128 goto cleanup;
3129 }
3130
3131 sleep(runPreviewSec);
3132
3133 ret = testCase.resetWithErrorLog();
3134 if (ret != ACAMERA_OK) {
3135 // Don't log error here. testcase did it
3136 goto cleanup;
3137 }
3138
3139 usleep(100000); // sleep to give some time for callbacks to happen
3140
3141 if (!testCase.isCameraAvailable(cameraId)) {
3142 LOG_ERROR(errorString, "Camera %s should be available now", cameraId);
3143 goto cleanup;
3144 }
3145 }
3146
3147 ret = testCase.deInit();
3148 if (ret != ACAMERA_OK) {
3149 LOG_ERROR(errorString, "Testcase deInit failed: ret %d", ret);
3150 goto cleanup;
3151 }
3152
3153 pass = true;
3154
3155 cleanup:
3156
3157 if (updatedRequest != nullptr) {
3158 ACaptureRequest_free(updatedRequest);
3159 updatedRequest = nullptr;
3160 }
3161
3162 if (reqPreviewOutput != nullptr) {
3163 ACameraOutputTarget_free(reqPreviewOutput);
3164 reqPreviewOutput = nullptr;
3165 }
3166
3167 if (reqSharedOutput != nullptr) {
3168 ACameraOutputTarget_free(reqSharedOutput);
3169 reqSharedOutput = nullptr;
3170 }
3171
3172 if (sharedAnw) {
3173 ANativeWindow_release(sharedAnw);
3174 sharedAnw = nullptr;
3175 }
3176
3177 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
3178 if (!pass) {
3179 throwAssertionError(env, errorString);
3180 }
3181 return pass;
3182 }
3183
testCameraDeviceSimplePreviewNativeInternal(JNIEnv * env,jclass,jobject jPreviewSurface,jstring jOverrideCameraId,bool v2Callbacks)3184 bool testCameraDeviceSimplePreviewNativeInternal(
3185 JNIEnv* env, jclass /*clazz*/, jobject jPreviewSurface,
3186 jstring jOverrideCameraId, bool v2Callbacks) {
3187 ALOGV("%s", __FUNCTION__);
3188 int numCameras = 0;
3189 bool pass = false;
3190 const int timeoutSec = 1;
3191 PreviewTestCase testCase;
3192
3193 camera_status_t ret = testCase.initWithErrorLog(env, jOverrideCameraId);
3194 if (ret != ACAMERA_OK) {
3195 // Don't log error here. testcase did it
3196 goto cleanup;
3197 }
3198
3199 numCameras = testCase.getNumCameras();
3200 if (numCameras < 0) {
3201 LOG_ERROR(errorString, "Testcase returned negavtive number of cameras: %d", numCameras);
3202 goto cleanup;
3203 }
3204
3205 for (int i = 0; i < numCameras; i++) {
3206 const char* cameraId = testCase.getCameraId(i);
3207 if (cameraId == nullptr) {
3208 LOG_ERROR(errorString, "Testcase returned null camera id for camera %d", i);
3209 goto cleanup;
3210 }
3211
3212 {
3213 ACameraMetadata* chars = testCase.getCameraChars(cameraId);
3214 StaticInfo staticInfo(chars);
3215 if (!staticInfo.isColorOutputSupported()) {
3216 ALOGI("%s: camera %s does not support color output. skipping",
3217 __FUNCTION__, cameraId);
3218 ACameraMetadata_free(chars);
3219 continue;
3220 }
3221 ACameraMetadata_free(chars);
3222 }
3223
3224 ret = testCase.openCamera(cameraId);
3225 if (ret != ACAMERA_OK) {
3226 LOG_ERROR(errorString, "Open camera device %s failure. ret %d", cameraId, ret);
3227 goto cleanup;
3228 }
3229
3230 usleep(100000); // sleep to give some time for callbacks to happen
3231
3232 if (testCase.isCameraAvailable(cameraId)) {
3233 LOG_ERROR(errorString, "Camera %s should be unavailable now", cameraId);
3234 goto cleanup;
3235 }
3236
3237 ANativeWindow* previewAnw = testCase.initPreviewAnw(env, jPreviewSurface);
3238 if (previewAnw == nullptr) {
3239 LOG_ERROR(errorString, "Null ANW from preview surface!");
3240 goto cleanup;
3241 }
3242
3243 ret = testCase.createCaptureSessionWithLog();
3244 if (ret != ACAMERA_OK) {
3245 // Don't log error here. testcase did it
3246 goto cleanup;
3247 }
3248
3249 ret = testCase.createRequestsWithErrorLog();
3250 if (ret != ACAMERA_OK) {
3251 // Don't log error here. testcase did it
3252 goto cleanup;
3253 }
3254 int sequenceId = 0;
3255 ret = testCase.startPreview(&sequenceId, 0, nullptr, v2Callbacks);
3256 if (ret != ACAMERA_OK) {
3257 LOG_ERROR(errorString, "Start preview failed!");
3258 goto cleanup;
3259 }
3260
3261 sleep(3);
3262
3263 ret = testCase.stopPreview();
3264 if (ret != ACAMERA_OK) {
3265 ALOGE("%s: stopPreview failed", __FUNCTION__);
3266 LOG_ERROR(errorString, "stopPreview failed!");
3267 goto cleanup;
3268 }
3269
3270 //Then wait for all old requests to flush
3271 int64_t lastFrameNumber =
3272 testCase.getCaptureSequenceLastFrameNumber(sequenceId, timeoutSec);
3273 if (lastFrameNumber < 0) {
3274 LOG_ERROR(errorString, "Camera %s failed to acquire last frame number!",
3275 cameraId);
3276 goto cleanup;
3277 }
3278 if (v2Callbacks) {
3279 bool frameStarted = testCase.waitForFrameNumberStarted(lastFrameNumber, timeoutSec);
3280 if (!frameStarted) {
3281 LOG_ERROR(errorString, "Camera %s timed out waiting on onCaptureStart for last"
3282 "frame number!", cameraId);
3283 goto cleanup;
3284 }
3285
3286 }
3287
3288 ret = testCase.resetWithErrorLog();
3289 if (ret != ACAMERA_OK) {
3290 // Don't log error here. testcase did it
3291 goto cleanup;
3292 }
3293
3294 usleep(100000); // sleep to give some time for callbacks to happen
3295
3296 if (!testCase.isCameraAvailable(cameraId)) {
3297 LOG_ERROR(errorString, "Camera %s should be available now", cameraId);
3298 goto cleanup;
3299 }
3300 }
3301
3302 ret = testCase.deInit();
3303 if (ret != ACAMERA_OK) {
3304 LOG_ERROR(errorString, "Testcase deInit failed: ret %d", ret);
3305 goto cleanup;
3306 }
3307
3308 pass = true;
3309 cleanup:
3310 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
3311 if (!pass) {
3312 throwAssertionError(env, errorString);
3313 }
3314 return pass;
3315 }
3316
3317 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraDeviceTest_testCameraDeviceSimplePreviewNative(JNIEnv * env,jclass clazz,jobject jPreviewSurface,jstring jOverrideCameraId)3318 Java_android_hardware_camera2_cts_NativeCameraDeviceTest_\
3319 testCameraDeviceSimplePreviewNative(
3320 JNIEnv* env, jclass clazz, jobject jPreviewSurface,
3321 jstring jOverrideCameraId) {
3322 return testCameraDeviceSimplePreviewNativeInternal(env, clazz, jPreviewSurface,
3323 jOverrideCameraId, /*v2Callbacks*/false);
3324 }
3325
3326 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraDeviceTest_testCameraDeviceSimplePreviewNative2(JNIEnv * env,jclass clazz,jobject jPreviewSurface,jstring jOverrideCameraId)3327 Java_android_hardware_camera2_cts_NativeCameraDeviceTest_\
3328 testCameraDeviceSimplePreviewNative2(
3329 JNIEnv* env, jclass clazz, jobject jPreviewSurface,
3330 jstring jOverrideCameraId) {
3331 return testCameraDeviceSimplePreviewNativeInternal(env, clazz, jPreviewSurface,
3332 jOverrideCameraId, /*v2Callbacks*/true);
3333 }
3334
3335 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraDeviceTest_testCameraDevicePreviewWithSessionParametersNative(JNIEnv * env,jclass,jobject jPreviewSurface,jstring jOverrideCameraId)3336 Java_android_hardware_camera2_cts_NativeCameraDeviceTest_\
3337 testCameraDevicePreviewWithSessionParametersNative(
3338 JNIEnv* env, jclass /*clazz*/, jobject jPreviewSurface,
3339 jstring jOverrideCameraId) {
3340 ALOGV("%s", __FUNCTION__);
3341 int numCameras = 0;
3342 bool pass = false;
3343 ACameraManager* mgr = ACameraManager_create();
3344 ACameraMetadata* chars = nullptr;
3345 PreviewTestCase testCase;
3346
3347 camera_status_t ret = testCase.initWithErrorLog(env, jOverrideCameraId);
3348 if (ret != ACAMERA_OK) {
3349 // Don't log error here. testcase did it
3350 goto cleanup;
3351 }
3352
3353 numCameras = testCase.getNumCameras();
3354 if (numCameras < 0) {
3355 LOG_ERROR(errorString, "Testcase returned negavtive number of cameras: %d", numCameras);
3356 goto cleanup;
3357 }
3358
3359 for (int i = 0; i < numCameras; i++) {
3360 const char* cameraId = testCase.getCameraId(i);
3361 if (cameraId == nullptr) {
3362 LOG_ERROR(errorString, "Testcase returned null camera id for camera %d", i);
3363 goto cleanup;
3364 }
3365
3366 ret = ACameraManager_getCameraCharacteristics(
3367 mgr, cameraId, &chars);
3368 if (ret != ACAMERA_OK) {
3369 LOG_ERROR(errorString, "Get camera characteristics failed: ret %d", ret);
3370 goto cleanup;
3371 }
3372
3373 StaticInfo staticInfo(chars);
3374 ACameraMetadata_const_entry sessionParamKeys{};
3375 ret = ACameraMetadata_getConstEntry(chars, ACAMERA_REQUEST_AVAILABLE_SESSION_KEYS,
3376 &sessionParamKeys);
3377 if ((ret != ACAMERA_OK) || (sessionParamKeys.count == 0) ||
3378 !staticInfo.isColorOutputSupported()) {
3379 ACameraMetadata_free(chars);
3380 chars = nullptr;
3381 continue;
3382 }
3383
3384 ret = testCase.openCamera(cameraId);
3385 if (ret != ACAMERA_OK) {
3386 LOG_ERROR(errorString, "Open camera device %s failure. ret %d", cameraId, ret);
3387 goto cleanup;
3388 }
3389
3390 usleep(100000); // sleep to give some time for callbacks to happen
3391
3392 if (testCase.isCameraAvailable(cameraId)) {
3393 LOG_ERROR(errorString, "Camera %s should be unavailable now", cameraId);
3394 goto cleanup;
3395 }
3396
3397 ANativeWindow* previewAnw = testCase.initPreviewAnw(env, jPreviewSurface);
3398 if (previewAnw == nullptr) {
3399 LOG_ERROR(errorString, "Null ANW from preview surface!");
3400 goto cleanup;
3401 }
3402
3403 ret = testCase.createRequestsWithErrorLog();
3404 if (ret != ACAMERA_OK) {
3405 // Don't log error here. testcase did it
3406 goto cleanup;
3407 }
3408
3409 ACaptureRequest *previewRequest = nullptr;
3410 ret = testCase.getPreviewRequest(&previewRequest);
3411 if ((ret != ACAMERA_OK) || (previewRequest == nullptr)) {
3412 LOG_ERROR(errorString, "Preview request query failed!");
3413 goto cleanup;
3414 }
3415
3416 ret = testCase.createCaptureSessionWithLog(/*isPreviewShared*/ false, previewRequest);
3417 if (ret != ACAMERA_OK) {
3418 // Don't log error here. testcase did it
3419 goto cleanup;
3420 }
3421
3422 ret = testCase.startPreview();
3423 if (ret != ACAMERA_OK) {
3424 LOG_ERROR(errorString, "Start preview failed!");
3425 goto cleanup;
3426 }
3427
3428 sleep(3);
3429
3430 ret = testCase.resetWithErrorLog();
3431 if (ret != ACAMERA_OK) {
3432 // Don't log error here. testcase did it
3433 goto cleanup;
3434 }
3435
3436 usleep(100000); // sleep to give some time for callbacks to happen
3437
3438 if (!testCase.isCameraAvailable(cameraId)) {
3439 LOG_ERROR(errorString, "Camera %s should be available now", cameraId);
3440 goto cleanup;
3441 }
3442
3443 ACameraMetadata_free(chars);
3444 chars = nullptr;
3445 }
3446
3447 ret = testCase.deInit();
3448 if (ret != ACAMERA_OK) {
3449 LOG_ERROR(errorString, "Testcase deInit failed: ret %d", ret);
3450 goto cleanup;
3451 }
3452
3453 pass = true;
3454 cleanup:
3455 if (chars) {
3456 ACameraMetadata_free(chars);
3457 }
3458 ACameraManager_delete(mgr);
3459 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
3460 if (!pass) {
3461 throwAssertionError(env, errorString);
3462 }
3463 return pass;
3464 }
3465
nativeCameraDeviceTestPrepareSurface(JNIEnv * env,jobject jPreviewSurface,jstring jOverrideCameraId)3466 bool nativeCameraDeviceTestPrepareSurface(
3467 JNIEnv* env, jobject jPreviewSurface,
3468 jstring jOverrideCameraId) {
3469 const int NUM_TEST_IMAGES = 10;
3470 const int TEST_WIDTH = 640;
3471 const int TEST_HEIGHT = 480;
3472 ALOGV("%s", __FUNCTION__);
3473 int numCameras = 0;
3474 bool pass = false;
3475 ACameraManager* mgr = ACameraManager_create();
3476 ACameraMetadata* chars = nullptr;
3477 media_status_t mediaRet = AMEDIA_ERROR_UNKNOWN;
3478 PreviewTestCase testCase;
3479 int64_t lastFrameNumber = 0;
3480 bool frameStarted = false;
3481 bool frameArrived = false;
3482 uint32_t timeoutSec = 1;
3483 uint32_t runPreviewSec = 2;
3484
3485 camera_status_t ret = testCase.initWithErrorLog(env, jOverrideCameraId);
3486 if (ret != ACAMERA_OK) {
3487 // Don't log error here. testcase did it
3488 goto cleanup;
3489 }
3490
3491 numCameras = testCase.getNumCameras();
3492 if (numCameras < 0) {
3493 LOG_ERROR(errorString, "Testcase returned negative number of cameras: %d", numCameras);
3494 goto cleanup;
3495 }
3496
3497 for (int i = 0; i < numCameras; i++) {
3498 const char* cameraId = testCase.getCameraId(i);
3499 if (cameraId == nullptr) {
3500 LOG_ERROR(errorString, "Testcase returned null camera id for camera %d", i);
3501 goto cleanup;
3502 }
3503
3504 chars = testCase.getCameraChars(cameraId);
3505 if (chars == nullptr) {
3506 LOG_ERROR(errorString, "Get camera %s characteristics failure", cameraId);
3507 goto cleanup;
3508 }
3509 StaticInfo staticInfo(chars);
3510 if (!staticInfo.isColorOutputSupported()) {
3511 ALOGI("%s: camera %s does not support color output. skipping",
3512 __FUNCTION__, cameraId);
3513 ACameraMetadata_free(chars);
3514 chars = nullptr;
3515 continue;
3516 }
3517 ACameraMetadata_free(chars);
3518 chars = nullptr;
3519
3520 ret = testCase.openCamera(cameraId);
3521 if (ret != ACAMERA_OK) {
3522 LOG_ERROR(errorString, "Open camera device %s failure. ret %d", cameraId, ret);
3523 goto cleanup;
3524 }
3525
3526 usleep(1000000); // sleep to give some time for callbacks to happen
3527
3528 if (testCase.isCameraAvailable(cameraId)) {
3529 LOG_ERROR(errorString, "Camera %s should be unavailable now", cameraId);
3530 goto cleanup;
3531 }
3532 ImageReaderListener readerListener;
3533 AImageReader* reader = nullptr;
3534 ANativeWindow* readerAnw = nullptr;
3535 ACaptureSessionOutput* readerSessionOutput = nullptr;
3536 ACameraOutputTarget* readerOutput = nullptr;
3537 AImageReader_ImageListener readerCb {
3538 &readerListener,
3539 ImageReaderListener::validateImageCb
3540 };
3541
3542 mediaRet = testCase.initImageReaderWithErrorLog(
3543 TEST_WIDTH, TEST_HEIGHT, AIMAGE_FORMAT_YUV_420_888, NUM_TEST_IMAGES,
3544 &readerCb, &reader, &readerAnw);
3545 if (mediaRet != AMEDIA_OK) {
3546 // Don't log error here. testcase did it
3547 goto cleanup;
3548 }
3549
3550 ret = ACaptureSessionOutput_create(readerAnw,
3551 &readerSessionOutput);
3552 if (ret != ACAMERA_OK || readerSessionOutput == nullptr) {
3553 // Don't log error here. testcase did it
3554 goto cleanup;
3555 }
3556
3557 ret = ACameraOutputTarget_create(readerAnw, &readerOutput);
3558 if (ret != ACAMERA_OK) {
3559 // Don't log error here. testcase did it
3560 goto cleanup;
3561 }
3562
3563 ANativeWindow* previewAnw = testCase.initPreviewAnw(env, jPreviewSurface);
3564 if (previewAnw == nullptr) {
3565 LOG_ERROR(errorString, "Null ANW from preview surface!");
3566 goto cleanup;
3567 }
3568 std::vector<ACaptureSessionOutput *> readerSessionOutputs = {readerSessionOutput};
3569 ret = testCase.createCaptureSessionWithLog(readerSessionOutputs, false /*isPreviewShared*/,
3570 nullptr /*sessionParameters*/, false /*sessionConfigurationDefault*/);
3571 if (ret == ACAMERA_ERROR_UNSUPPORTED_OPERATION ||
3572 ret == ACAMERA_ERROR_STREAM_CONFIGURE_FAIL) {
3573 // Camera device doesn't support the stream combination, skip the
3574 // current camera.
3575 testCase.closeCamera();
3576 testCase.resetCamera();
3577 continue;
3578 } else if (ret != ACAMERA_OK) {
3579 // Don't log error here. testcase did it
3580 goto cleanup;
3581 }
3582 // Set the callback on the created capture session and prepare all the surfaces
3583 if (testCase.setWindowPreparedCallback() != ACAMERA_OK ||
3584 testCase.prepareWindow(previewAnw) != ACAMERA_OK) {
3585 goto cleanup;
3586 }
3587 if (testCase.prepareWindow(readerAnw) != ACAMERA_OK) {
3588 goto cleanup;
3589 }
3590 // Wait for some time - we should've gotten onWindowPrepared callbacks for all the
3591 // ANativeWindows.
3592 usleep(200000);
3593 if (!testCase.gotAllPreparedCallbacksWithErrorLog()) {
3594 goto cleanup;
3595 }
3596 std::vector<ACameraOutputTarget* > readerOutputs = {readerOutput};
3597 ret = testCase.createRequestsWithErrorLog(readerOutputs);
3598 if (ret != ACAMERA_OK) {
3599 // Don't log error here. testcase did it
3600 goto cleanup;
3601 }
3602
3603 ACaptureRequest *previewRequest = nullptr;
3604 ret = testCase.getPreviewRequest(&previewRequest);
3605 if ((ret != ACAMERA_OK) || (previewRequest == nullptr)) {
3606 LOG_ERROR(errorString, "Preview request query failed!");
3607 goto cleanup;
3608 }
3609
3610 int sequenceId = 0;
3611 ret = testCase.startPreview(&sequenceId);
3612 if (ret != ACAMERA_OK) {
3613 LOG_ERROR(errorString, "Start preview failed!");
3614 goto cleanup;
3615 }
3616
3617 sleep(runPreviewSec);
3618
3619 ret = testCase.stopPreview();
3620 if (ret != ACAMERA_OK) {
3621 ALOGE("%s: stopPreview failed", __FUNCTION__);
3622 LOG_ERROR(errorString, "stopPreview failed!");
3623 goto cleanup;
3624 }
3625
3626 //Then wait for all old requests to flush
3627 lastFrameNumber = testCase.getCaptureSequenceLastFrameNumber(sequenceId, timeoutSec);
3628 if (lastFrameNumber < 0) {
3629 LOG_ERROR(errorString, "Camera %s failed to acquire last frame number!",
3630 cameraId);
3631 goto cleanup;
3632 }
3633 frameArrived = testCase.waitForFrameNumber(lastFrameNumber, timeoutSec);
3634 if (!frameArrived) {
3635 LOG_ERROR(errorString, "Camera %s timed out waiting on last frame number!",
3636 cameraId);
3637 goto cleanup;
3638 }
3639
3640 ret = testCase.resetWithErrorLog();
3641 if (ret != ACAMERA_OK) {
3642 // Don't log error here. testcase did it
3643 goto cleanup;
3644 }
3645
3646 usleep(100000); // sleep to give some time for callbacks to happen
3647
3648 if (!testCase.isCameraAvailable(cameraId)) {
3649 LOG_ERROR(errorString, "Camera %s should be available now", cameraId);
3650 goto cleanup;
3651 }
3652 }
3653
3654 ret = testCase.deInit();
3655 if (ret != ACAMERA_OK) {
3656 LOG_ERROR(errorString, "Testcase deInit failed: ret %d", ret);
3657 goto cleanup;
3658 }
3659
3660 pass = true;
3661 cleanup:
3662 if (chars) {
3663 ACameraMetadata_free(chars);
3664 }
3665 ACameraManager_delete(mgr);
3666 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
3667 if (!pass) {
3668 throwAssertionError(env, errorString);
3669 }
3670 return pass;
3671 }
3672
3673 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraDeviceTest_testCameraDevicePrepareSurface(JNIEnv * env,jclass,jobject jPreviewSurface,jstring jOverrideCameraId)3674 Java_android_hardware_camera2_cts_NativeCameraDeviceTest_\
3675 testCameraDevicePrepareSurface(
3676 JNIEnv* env, jclass /*clazz*/, jobject jPreviewSurface,
3677 jstring jOverrideCameraId) {
3678 return nativeCameraDeviceTestPrepareSurface(env,
3679 jPreviewSurface, jOverrideCameraId);
3680 }
3681
nativeCameraDeviceLogicalPhysicalStreaming(JNIEnv * env,jobject jPreviewSurface,bool usePhysicalSettings,jstring jOverrideCameraId,bool v2Callbacks)3682 bool nativeCameraDeviceLogicalPhysicalStreaming(
3683 JNIEnv* env, jobject jPreviewSurface, bool usePhysicalSettings,
3684 jstring jOverrideCameraId, bool v2Callbacks) {
3685 const int NUM_TEST_IMAGES = 10;
3686 const int TEST_WIDTH = 640;
3687 const int TEST_HEIGHT = 480;
3688 ALOGV("%s", __FUNCTION__);
3689 int numCameras = 0;
3690 bool pass = false;
3691 ACameraManager* mgr = ACameraManager_create();
3692 ACameraMetadata* chars = nullptr;
3693 media_status_t mediaRet = AMEDIA_ERROR_UNKNOWN;
3694 PreviewTestCase testCase;
3695 int64_t lastFrameNumber = 0;
3696 bool frameStarted = false;
3697 bool frameArrived = false;
3698 uint32_t timeoutSec = 1;
3699 uint32_t runPreviewSec = 2;
3700
3701 camera_status_t ret = testCase.initWithErrorLog(env, jOverrideCameraId);
3702 if (ret != ACAMERA_OK) {
3703 // Don't log error here. testcase did it
3704 goto cleanup;
3705 }
3706
3707 numCameras = testCase.getNumCameras();
3708 if (numCameras < 0) {
3709 LOG_ERROR(errorString, "Testcase returned negavtive number of cameras: %d", numCameras);
3710 goto cleanup;
3711 }
3712
3713 for (int i = 0; i < numCameras; i++) {
3714 const char* cameraId = testCase.getCameraId(i);
3715 if (cameraId == nullptr) {
3716 LOG_ERROR(errorString, "Testcase returned null camera id for camera %d", i);
3717 goto cleanup;
3718 }
3719
3720 if (chars != nullptr) {
3721 ACameraMetadata_free(chars);
3722 chars = nullptr;
3723 }
3724 chars = testCase.getCameraChars(i);
3725 if (chars == nullptr) {
3726 LOG_ERROR(errorString, "Get camera %s characteristics failure", cameraId);
3727 goto cleanup;
3728 }
3729
3730 size_t physicalCameraCnt = 0;
3731 const char *const* physicalCameraIds = nullptr;
3732 if (!ACameraMetadata_isLogicalMultiCamera(
3733 chars, &physicalCameraCnt, &physicalCameraIds)) {
3734 continue;
3735 }
3736 if (physicalCameraCnt < 2) {
3737 LOG_ERROR(errorString, "Logical camera device %s only has %zu physical cameras",
3738 cameraId, physicalCameraCnt);
3739 goto cleanup;
3740 }
3741
3742 std::vector<const char*> candidateIds;
3743 for (size_t i = 0; i < physicalCameraCnt && candidateIds.size() < 2; i++) {
3744 ACameraMetadata* physicalChars = testCase.getCameraChars(physicalCameraIds[i]);
3745 if (physicalChars == nullptr) {
3746 LOG_ERROR(errorString,
3747 "Get camera %s characteristics failure", physicalCameraIds[i]);
3748 goto cleanup;
3749 }
3750 StaticInfo info(physicalChars);
3751 bool testSizeSupported = info.isSizeSupportedForFormat(AIMAGE_FORMAT_YUV_420_888,
3752 TEST_WIDTH, TEST_HEIGHT);
3753 ACameraMetadata_free(physicalChars);
3754 if (!testSizeSupported) {
3755 continue;
3756 }
3757 candidateIds.push_back(physicalCameraIds[i]);
3758 }
3759 if (candidateIds.size() < 2) {
3760 continue;
3761 }
3762
3763 // Check physical camera request keys
3764 if (usePhysicalSettings) {
3765 ACameraMetadata_const_entry entry;
3766 camera_status_t status = ACameraMetadata_getConstEntry(
3767 chars, ACAMERA_REQUEST_AVAILABLE_PHYSICAL_CAMERA_REQUEST_KEYS, &entry);
3768 if (status == ACAMERA_ERROR_METADATA_NOT_FOUND) {
3769 // No supported PHYSICAL_CAMERA_REQUEST_KEYS, skip test
3770 ALOGI("%s camera id %s physical request keys not reported, skipping",
3771 __FUNCTION__, cameraId);
3772 continue;
3773 } else if (status != ACAMERA_OK) {
3774 // Do not log error here. testcase did it.
3775 goto cleanup;
3776 } else if (entry.count == 0) {
3777 // No supported PHYSICAL_CAMERA_REQUEST_KEYS, skip test
3778 continue;
3779 }
3780 }
3781
3782 ret = testCase.openCamera(cameraId);
3783 if (ret != ACAMERA_OK) {
3784 LOG_ERROR(errorString, "Open camera device %s failure. ret %d", cameraId, ret);
3785 goto cleanup;
3786 }
3787
3788 usleep(100000); // sleep to give some time for callbacks to happen
3789
3790 if (testCase.isCameraAvailable(cameraId)) {
3791 LOG_ERROR(errorString, "Camera %s should be unavailable now", cameraId);
3792 goto cleanup;
3793 }
3794
3795 std::vector<ImageReaderListener> readerListeners(2);
3796 std::vector<AImageReader_ImageListener> readerCbs;
3797 std::vector<AImageReader*> readers;
3798 std::vector<ANativeWindow*> readerAnws;
3799 std::vector<ACaptureSessionOutput*> readerSessionOutputs;
3800 std::vector<ACameraOutputTarget*> readerOutputs;
3801 for (size_t i = 0; i < 2; i++) {
3802 AImageReader_ImageListener readerCb {
3803 &readerListeners[i],
3804 ImageReaderListener::validateImageCb
3805 };
3806 readerCbs.push_back(readerCb);
3807
3808 AImageReader* reader = nullptr;
3809 ANativeWindow* readerAnw = nullptr;
3810 ACaptureSessionOutput* readerSessionOutput = nullptr;
3811 ACameraOutputTarget* readerOutput = nullptr;
3812 mediaRet = testCase.initImageReaderWithErrorLog(
3813 TEST_WIDTH, TEST_HEIGHT, AIMAGE_FORMAT_YUV_420_888, NUM_TEST_IMAGES,
3814 &readerCb, &reader, &readerAnw);
3815 if (mediaRet != AMEDIA_OK) {
3816 // Don't log error here. testcase did it
3817 goto cleanup;
3818 }
3819
3820 camera_status_t ret = ACaptureSessionPhysicalOutput_create(readerAnw,
3821 candidateIds[i], &readerSessionOutput);
3822 if (ret != ACAMERA_OK || readerSessionOutput == nullptr) {
3823 if (ret == ACAMERA_OK) {
3824 ret = ACAMERA_ERROR_UNKNOWN; // ret OK but output is null
3825 }
3826 // Don't log error here. testcase did it
3827 goto cleanup;
3828 }
3829
3830 ret = ACameraOutputTarget_create(readerAnw, &readerOutput);
3831 if (ret != ACAMERA_OK) {
3832 // Don't log error here. testcase did it
3833 goto cleanup;
3834 }
3835
3836 readers.push_back(reader);
3837 readerAnws.push_back(readerAnw);
3838 readerSessionOutputs.push_back(readerSessionOutput);
3839 readerOutputs.push_back(readerOutput);
3840 }
3841
3842 ANativeWindow* previewAnw = testCase.initPreviewAnw(env, jPreviewSurface);
3843 if (previewAnw == nullptr) {
3844 LOG_ERROR(errorString, "Null ANW from preview surface!");
3845 goto cleanup;
3846 }
3847
3848 ret = testCase.createCaptureSessionWithLog(readerSessionOutputs, false /*isPreviewShared*/,
3849 nullptr /*sessionParameters*/, false /*sessionConfigurationDefault*/);
3850 if (ret == ACAMERA_ERROR_UNSUPPORTED_OPERATION ||
3851 ret == ACAMERA_ERROR_STREAM_CONFIGURE_FAIL) {
3852 // Camera device doesn't support the stream combination, skip the
3853 // current camera.
3854 testCase.closeCamera();
3855 testCase.resetCamera();
3856 continue;
3857 } else if (ret != ACAMERA_OK) {
3858 // Don't log error here. testcase did it
3859 goto cleanup;
3860 }
3861
3862 if (usePhysicalSettings) {
3863 std::vector<const char*> twoNullStr = {nullptr, nullptr};
3864 ACameraIdList nullCameraIdList = {2, twoNullStr.data()};
3865 ret = testCase.createRequestsWithErrorLog(readerOutputs, &nullCameraIdList);
3866 if (ret != ACAMERA_ERROR_INVALID_PARAMETER) {
3867 LOG_ERROR(errorString, "Null physical camera ids must fail createCaptureRequest. "
3868 "ret %d", ret);
3869 goto cleanup;
3870 }
3871
3872 std::string invalidId = "";
3873 std::vector<const char*> one0LengthStr = {invalidId.c_str()};
3874 ACameraIdList invalidCameraIdList = {1, one0LengthStr.data()};
3875 ret = testCase.createRequestsWithErrorLog(readerOutputs, &invalidCameraIdList);
3876 if (ret != ACAMERA_ERROR_INVALID_PARAMETER) {
3877 LOG_ERROR(errorString, "zero-length physical camera ids must fail "
3878 "createCaptureRequest. ret %d", ret);
3879 goto cleanup;
3880 }
3881
3882 ACameraIdList physicalCameraIdList = {2, candidateIds.data()};
3883 ret = testCase.createRequestsWithErrorLog(readerOutputs, &physicalCameraIdList);
3884 } else {
3885 ret = testCase.createRequestsWithErrorLog(readerOutputs);
3886 }
3887 if (ret != ACAMERA_OK) {
3888 // Don't log error here. testcase did it
3889 goto cleanup;
3890 }
3891
3892 ACaptureRequest *previewRequest = nullptr;
3893 ret = testCase.getPreviewRequest(&previewRequest);
3894 if ((ret != ACAMERA_OK) || (previewRequest == nullptr)) {
3895 LOG_ERROR(errorString, "Preview request query failed!");
3896 goto cleanup;
3897 }
3898
3899 int sequenceId = 0;
3900 ret = testCase.startPreview(&sequenceId, 2, candidateIds.data(), v2Callbacks);
3901 if (ret != ACAMERA_OK) {
3902 LOG_ERROR(errorString, "Start preview failed!");
3903 goto cleanup;
3904 }
3905
3906 sleep(runPreviewSec);
3907
3908 ret = testCase.stopPreview();
3909 if (ret != ACAMERA_OK) {
3910 ALOGE("%s: stopPreview failed", __FUNCTION__);
3911 LOG_ERROR(errorString, "stopPreview failed!");
3912 goto cleanup;
3913 }
3914
3915 //Then wait for all old requests to flush
3916 lastFrameNumber = testCase.getCaptureSequenceLastFrameNumber(sequenceId, timeoutSec);
3917 if (lastFrameNumber < 0) {
3918 LOG_ERROR(errorString, "Camera %s failed to acquire last frame number!",
3919 cameraId);
3920 goto cleanup;
3921 }
3922 if (v2Callbacks) {
3923 frameStarted = testCase.waitForFrameNumberStarted(lastFrameNumber, timeoutSec);
3924 if (!frameStarted) {
3925 LOG_ERROR(errorString, "Camera %s timed out waiting on onCaptureStart for last"
3926 "frame number!", cameraId);
3927 goto cleanup;
3928 }
3929
3930 }
3931
3932 frameArrived = testCase.waitForFrameNumber(lastFrameNumber, timeoutSec);
3933 if (!frameArrived) {
3934 LOG_ERROR(errorString, "Camera %s timed out waiting on last frame number!",
3935 cameraId);
3936 goto cleanup;
3937 }
3938
3939 ret = testCase.resetWithErrorLog();
3940 if (ret != ACAMERA_OK) {
3941 // Don't log error here. testcase did it
3942 goto cleanup;
3943 }
3944
3945 usleep(100000); // sleep to give some time for callbacks to happen
3946
3947 if (!testCase.isCameraAvailable(cameraId)) {
3948 LOG_ERROR(errorString, "Camera %s should be available now", cameraId);
3949 goto cleanup;
3950 }
3951 }
3952
3953 ret = testCase.deInit();
3954 if (ret != ACAMERA_OK) {
3955 LOG_ERROR(errorString, "Testcase deInit failed: ret %d", ret);
3956 goto cleanup;
3957 }
3958
3959 pass = true;
3960 cleanup:
3961 if (chars) {
3962 ACameraMetadata_free(chars);
3963 }
3964 ACameraManager_delete(mgr);
3965 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
3966 if (!pass) {
3967 throwAssertionError(env, errorString);
3968 }
3969 return pass;
3970 }
3971
3972 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraDeviceTest_testCameraDeviceLogicalPhysicalStreamingNative(JNIEnv * env,jclass,jobject jPreviewSurface,jstring jOverrideCameraId)3973 Java_android_hardware_camera2_cts_NativeCameraDeviceTest_\
3974 testCameraDeviceLogicalPhysicalStreamingNative(
3975 JNIEnv* env, jclass /*clazz*/, jobject jPreviewSurface,
3976 jstring jOverrideCameraId) {
3977 return nativeCameraDeviceLogicalPhysicalStreaming(env,
3978 jPreviewSurface, false /*usePhysicalSettings*/,
3979 jOverrideCameraId, /*v2Callbacks*/false);
3980 }
3981
3982 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraDeviceTest_testCameraDeviceLogicalPhysicalStreamingNative2(JNIEnv * env,jclass,jobject jPreviewSurface,jstring jOverrideCameraId)3983 Java_android_hardware_camera2_cts_NativeCameraDeviceTest_\
3984 testCameraDeviceLogicalPhysicalStreamingNative2(
3985 JNIEnv* env, jclass /*clazz*/, jobject jPreviewSurface,
3986 jstring jOverrideCameraId) {
3987 return nativeCameraDeviceLogicalPhysicalStreaming(env,
3988 jPreviewSurface, false /*usePhysicalSettings*/,
3989 jOverrideCameraId, /*v2Callbacks*/true);
3990 }
3991
3992 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraDeviceTest_testCameraDeviceLogicalPhysicalSettingsNative(JNIEnv * env,jclass,jobject jPreviewSurface,jstring jOverrideCameraId)3993 Java_android_hardware_camera2_cts_NativeCameraDeviceTest_\
3994 testCameraDeviceLogicalPhysicalSettingsNative(
3995 JNIEnv* env, jclass /*clazz*/, jobject jPreviewSurface,
3996 jstring jOverrideCameraId) {
3997 return nativeCameraDeviceLogicalPhysicalStreaming(env,
3998 jPreviewSurface, true /*usePhysicalSettings*/,
3999 jOverrideCameraId, /*v2Callbacks*/false);
4000 }
4001
4002 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraDeviceTest_testCameraDeviceLogicalPhysicalSettingsNative2(JNIEnv * env,jclass,jobject jPreviewSurface,jstring jOverrideCameraId)4003 Java_android_hardware_camera2_cts_NativeCameraDeviceTest_\
4004 testCameraDeviceLogicalPhysicalSettingsNative2(
4005 JNIEnv* env, jclass /*clazz*/, jobject jPreviewSurface,
4006 jstring jOverrideCameraId) {
4007 return nativeCameraDeviceLogicalPhysicalStreaming(env,
4008 jPreviewSurface, true /*usePhysicalSettings*/,
4009 jOverrideCameraId, /*v2Callbacks*/ true);
4010 }
4011
nativeImageReaderTestBase(JNIEnv * env,jstring jOutPath,jint format,AImageReader_ImageCallback cb,jstring jOverrideCameraId)4012 bool nativeImageReaderTestBase(
4013 JNIEnv* env, jstring jOutPath, jint format, AImageReader_ImageCallback cb,
4014 jstring jOverrideCameraId) {
4015 const int NUM_TEST_IMAGES = 10;
4016 media_status_t mediaRet = AMEDIA_ERROR_UNKNOWN;
4017 int numCameras = 0;
4018 bool pass = false;
4019 PreviewTestCase testCase;
4020 ACameraMetadata* chars = nullptr;
4021
4022 const char* outPath = (jOutPath == nullptr) ? nullptr :
4023 env->GetStringUTFChars(jOutPath, nullptr);
4024 if (outPath != nullptr) {
4025 ALOGI("%s: out path is %s", __FUNCTION__, outPath);
4026 }
4027
4028 camera_status_t ret = testCase.initWithErrorLog(env, jOverrideCameraId);
4029 if (ret != ACAMERA_OK) {
4030 // Don't log error here. testcase did it
4031 goto cleanup;
4032 }
4033
4034 numCameras = testCase.getNumCameras();
4035 if (numCameras < 0) {
4036 LOG_ERROR(errorString, "Testcase returned negavtive number of cameras: %d", numCameras);
4037 goto cleanup;
4038 }
4039
4040 for (int i = 0; i < numCameras; i++) {
4041 const char* cameraId = testCase.getCameraId(i);
4042 if (cameraId == nullptr) {
4043 LOG_ERROR(errorString, "Testcase returned null camera id for camera %d", i);
4044 goto cleanup;
4045 }
4046
4047 {
4048 ACameraMetadata* chars = testCase.getCameraChars(cameraId);
4049 StaticInfo staticInfo(chars);
4050 if (!staticInfo.isColorOutputSupported()) {
4051 ALOGI("%s: camera %s does not support color output. skipping",
4052 __FUNCTION__, cameraId);
4053 ACameraMetadata_free(chars);
4054 continue;
4055 }
4056 ACameraMetadata_free(chars);
4057 }
4058
4059 ret = testCase.openCamera(cameraId);
4060 if (ret != ACAMERA_OK) {
4061 LOG_ERROR(errorString, "Open camera device %s failure. ret %d", cameraId, ret);
4062 goto cleanup;
4063 }
4064
4065 chars = testCase.getCameraChars(i);
4066 if (chars == nullptr) {
4067 LOG_ERROR(errorString, "Get camera %s characteristics failure", cameraId);
4068 goto cleanup;
4069 }
4070 StaticInfo staticInfo(chars);
4071
4072 usleep(200000); // sleep to give some time for callbacks to happen
4073
4074 if (testCase.isCameraAvailable(cameraId)) {
4075 LOG_ERROR(errorString, "Camera %s should be unavailable now", cameraId);
4076 goto cleanup;
4077 }
4078
4079 ImageReaderListener readerListener;
4080 AImageReader_ImageListener readerCb { &readerListener, cb };
4081 readerListener.setDumpFilePathBase(outPath);
4082
4083 int32_t testWidth, testHeight;
4084 switch (format) {
4085 case AIMAGE_FORMAT_JPEG:
4086 case AIMAGE_FORMAT_Y8:
4087 case AIMAGE_FORMAT_HEIC:
4088 case AIMAGE_FORMAT_DEPTH_JPEG:
4089 if (!staticInfo.getMaxSizeForFormat(format, &testWidth, &testHeight)) {
4090 // No corresponding format support, skip this device.
4091 ACameraMetadata_free(chars);
4092 chars = nullptr;
4093 ret = testCase.closeCamera();
4094 if (ret != ACAMERA_OK) {
4095 LOG_ERROR(errorString, "Camera %s failed to close. ret %d ", cameraId, ret);
4096 goto cleanup;
4097 }
4098
4099 continue;
4100 }
4101 break;
4102 default:
4103 LOG_ERROR(errorString, "Testcase doesn't yet support format %d", format);
4104 goto cleanup;
4105 }
4106 mediaRet = testCase.initImageReaderWithErrorLog(
4107 testWidth, testHeight, format, NUM_TEST_IMAGES,
4108 &readerCb);
4109 if (mediaRet != AMEDIA_OK) {
4110 // Don't log error here. testcase did it
4111 goto cleanup;
4112 }
4113
4114 ret = testCase.createCaptureSessionWithLog();
4115 if (ret != ACAMERA_OK) {
4116 // Don't log error here. testcase did it
4117 goto cleanup;
4118 }
4119
4120 ret = testCase.createRequestsWithErrorLog();
4121 if (ret != ACAMERA_OK) {
4122 // Don't log error here. testcase did it
4123 goto cleanup;
4124 }
4125
4126 CaptureResultListener resultListener;
4127 ACameraCaptureSession_captureCallbacks resultCb {
4128 &resultListener,
4129 CaptureResultListener::onCaptureStart,
4130 CaptureResultListener::onCaptureProgressed,
4131 CaptureResultListener::onCaptureCompleted,
4132 CaptureResultListener::onCaptureFailed,
4133 CaptureResultListener::onCaptureSequenceCompleted,
4134 CaptureResultListener::onCaptureSequenceAborted,
4135 CaptureResultListener::onCaptureBufferLost
4136 };
4137 resultListener.setRequestSave(true);
4138 ACaptureRequest* requestTemplate = nullptr;
4139 ret = testCase.getStillRequest(&requestTemplate);
4140 if (ret != ACAMERA_OK || requestTemplate == nullptr) {
4141 // Don't log error here. testcase did it
4142 goto cleanup;
4143 }
4144
4145 // Do some still capture
4146 int lastSeqId = -1;
4147 for (intptr_t capture = 0; capture < NUM_TEST_IMAGES; capture++) {
4148 ACaptureRequest* req = ACaptureRequest_copy(requestTemplate);
4149 ACaptureRequest_setUserContext(req, (void*) capture);
4150 int seqId;
4151 ret = testCase.capture(req, &resultCb, &seqId);
4152 if (ret != ACAMERA_OK) {
4153 LOG_ERROR(errorString, "Camera %s capture(%" PRIdPTR ") failed. ret %d",
4154 cameraId, capture, ret);
4155 goto cleanup;
4156 }
4157 if (capture == NUM_TEST_IMAGES - 1) {
4158 lastSeqId = seqId;
4159 }
4160 ACaptureRequest_free(req);
4161 }
4162
4163 // wait until last sequence complete
4164 resultListener.getCaptureSequenceLastFrameNumber(lastSeqId, /*timeoutSec*/ 5);
4165
4166 std::vector<ACaptureRequest*> completedRequests;
4167 resultListener.getCompletedRequests(&completedRequests);
4168
4169 if (completedRequests.size() != NUM_TEST_IMAGES) {
4170 LOG_ERROR(errorString, "Camera %s fails to capture %d capture results. Got %zu",
4171 cameraId, NUM_TEST_IMAGES, completedRequests.size());
4172 goto cleanup;
4173 }
4174
4175 for (intptr_t i = 0; i < NUM_TEST_IMAGES; i++) {
4176 intptr_t userContext = -1;
4177 ret = ACaptureRequest_getUserContext(completedRequests[i], (void**) &userContext);
4178 if (ret != ACAMERA_OK) {
4179 LOG_ERROR(errorString, "Camera %s fails to get request user context", cameraId);
4180 goto cleanup;
4181 }
4182
4183 if (userContext != i) {
4184 LOG_ERROR(errorString, "Camera %s fails to return matching user context. "
4185 "Expect %" PRIdPTR ", got %" PRIdPTR, cameraId, i, userContext);
4186 goto cleanup;
4187 }
4188 }
4189
4190 int64_t minFrameDurationNs = staticInfo.getMinFrameDurationFor(
4191 format, testWidth, testHeight);
4192 if (minFrameDurationNs < 0) {
4193 LOG_ERROR(errorString, "Get camera %s minFrameDuration failed", cameraId);
4194 goto cleanup;
4195 }
4196 int64_t stallDurationNs = (format == AIMAGE_FORMAT_Y8) ? 0 :
4197 staticInfo.getStallDurationFor(format, testWidth, testHeight);
4198 if (stallDurationNs < 0) {
4199 LOG_ERROR(errorString, "Get camera %s stallDuration failed", cameraId);
4200 goto cleanup;
4201 }
4202
4203 int64_t expectedDurationNs = (minFrameDurationNs + stallDurationNs) * NUM_TEST_IMAGES;
4204 constexpr int64_t waitPerIterationUs = 100000;
4205 constexpr int64_t usToNs = 1000;
4206 int totalWaitIteration = 50;
4207
4208 // Allow 1.5x margin
4209 if (expectedDurationNs * 3 / 2 > totalWaitIteration * waitPerIterationUs * usToNs) {
4210 totalWaitIteration = expectedDurationNs * 3 / 2 / waitPerIterationUs / usToNs;
4211 }
4212
4213 // wait until all capture finished
4214 for (int i = 0; i < totalWaitIteration; i++) {
4215 usleep(waitPerIterationUs);
4216 if (readerListener.onImageAvailableCount() == NUM_TEST_IMAGES) {
4217 ALOGI("Session take ~%d ms to capture %d images",
4218 i*100, NUM_TEST_IMAGES);
4219 break;
4220 }
4221 }
4222
4223 if (readerListener.onImageAvailableCount() != NUM_TEST_IMAGES) {
4224 LOG_ERROR(errorString, "Camera %s timeout capturing %d images. Got %d",
4225 cameraId, NUM_TEST_IMAGES, readerListener.onImageAvailableCount());
4226 goto cleanup;
4227 }
4228
4229 ret = testCase.resetWithErrorLog();
4230 if (ret != ACAMERA_OK) {
4231 // Don't log error here. testcase did it
4232 goto cleanup;
4233 }
4234
4235 usleep(200000); // sleep to give some time for callbacks to happen
4236
4237 if (!testCase.isCameraAvailable(cameraId)) {
4238 LOG_ERROR(errorString, "Camera %s should be available now", cameraId);
4239 goto cleanup;
4240 }
4241 }
4242
4243 ret = testCase.deInit();
4244 if (ret != ACAMERA_OK) {
4245 LOG_ERROR(errorString, "Testcase deInit failed: ret %d", ret);
4246 goto cleanup;
4247 }
4248
4249 pass = true;
4250
4251 cleanup:
4252 if (outPath != nullptr) {
4253 env->ReleaseStringUTFChars(jOutPath, outPath);
4254 }
4255
4256 if (chars != nullptr) {
4257 ACameraMetadata_free(chars);
4258 chars = nullptr;
4259 }
4260
4261 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
4262 if (!pass) {
4263 throwAssertionError(env, errorString);
4264 }
4265 return pass;
4266 }
4267
4268 // Test the camera NDK capture failure path by acquiring the maximum amount of
4269 // ImageReader buffers available. Since there is no circulation of camera
4270 // images, the registered output surface will eventually run out of free buffers
4271 // and start reporting capture errors or lost buffers.
4272 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeCameraDeviceTest_testCameraDeviceCaptureFailureNative(JNIEnv * env,jclass,jstring jOverrideCameraId)4273 Java_android_hardware_camera2_cts_NativeCameraDeviceTest_\
4274 testCameraDeviceCaptureFailureNative(JNIEnv* env, jclass /*clazz*/, jstring jOverrideCameraId) {
4275 const size_t NUM_TEST_IMAGES = 10;
4276 const size_t NUM_FAILED_FRAMES = 3; // Wait for at least 3 consecutive failed capture requests
4277 const int64_t NUM_TOTAL_FRAMES = 60; // Avoid waiting for more than 60 frames
4278 const size_t TEST_WIDTH = 640;
4279 const size_t TEST_HEIGHT = 480;
4280 media_status_t mediaRet = AMEDIA_ERROR_UNKNOWN;
4281 int numCameras = 0;
4282 bool pass = false;
4283 PreviewTestCase testCase;
4284 uint32_t bufferTimeoutSec = 1;
4285 uint32_t timeoutSec = 10; // It is important to keep this timeout bigger than the framework
4286 // timeout
4287
4288 camera_status_t ret = testCase.initWithErrorLog(env, jOverrideCameraId);
4289 if (ret != ACAMERA_OK) {
4290 // Don't log error here. testcase did it
4291 goto exit;
4292 }
4293
4294 numCameras = testCase.getNumCameras();
4295 if (numCameras < 0) {
4296 LOG_ERROR(errorString, "Testcase returned negative number of cameras: %d", numCameras);
4297 goto exit;
4298 }
4299
4300 for (int i = 0; i < numCameras; i++) {
4301 const char* cameraId = testCase.getCameraId(i);
4302 if (cameraId == nullptr) {
4303 LOG_ERROR(errorString, "Testcase returned null camera id for camera %d", i);
4304 goto exit;
4305 }
4306
4307 std::unique_ptr<ACameraMetadata> chars(testCase.getCameraChars(i));
4308 if (chars.get() == nullptr) {
4309 LOG_ERROR(errorString, "Get camera %s characteristics failure", cameraId);
4310 goto exit;
4311 }
4312 StaticInfo staticInfo(chars.get());
4313
4314 if (!staticInfo.isColorOutputSupported()) {
4315 continue;
4316 }
4317
4318 ret = testCase.openCamera(cameraId);
4319 if (ret != ACAMERA_OK) {
4320 LOG_ERROR(errorString, "Open camera device %s failure. ret %d", cameraId, ret);
4321 goto exit;
4322 }
4323
4324 usleep(100000); // sleep to give some time for callbacks to happen
4325
4326 if (testCase.isCameraAvailable(cameraId)) {
4327 LOG_ERROR(errorString, "Camera %s should be unavailable now", cameraId);
4328 goto exit;
4329 }
4330
4331 ImageReaderListener readerListener;
4332 AImageReader_ImageListener readerCb =
4333 { &readerListener, ImageReaderListener::signalImageCb };
4334 mediaRet = testCase.initImageReaderWithErrorLog(TEST_WIDTH, TEST_HEIGHT,
4335 AIMAGE_FORMAT_YUV_420_888, NUM_TEST_IMAGES, &readerCb);
4336 if (mediaRet != AMEDIA_OK) {
4337 // Don't log error here. testcase did it
4338 goto exit;
4339 }
4340
4341 ret = testCase.createCaptureSessionWithLog();
4342 if (ret != ACAMERA_OK) {
4343 // Don't log error here. testcase did it
4344 goto exit;
4345 }
4346
4347 ret = testCase.createRequestsWithErrorLog();
4348 if (ret != ACAMERA_OK) {
4349 // Don't log error here. testcase did it
4350 goto exit;
4351 }
4352
4353 CaptureResultListener resultListener;
4354 ACameraCaptureSession_captureCallbacks resultCb {
4355 &resultListener,
4356 CaptureResultListener::onCaptureStart,
4357 CaptureResultListener::onCaptureProgressed,
4358 CaptureResultListener::onCaptureCompleted,
4359 CaptureResultListener::onCaptureFailed,
4360 CaptureResultListener::onCaptureSequenceCompleted,
4361 CaptureResultListener::onCaptureSequenceAborted,
4362 CaptureResultListener::onCaptureBufferLost
4363 };
4364 ACaptureRequest* requestTemplate = nullptr;
4365 ret = testCase.getStillRequest(&requestTemplate);
4366 if (ret != ACAMERA_OK || requestTemplate == nullptr) {
4367 // Don't log error here. testcase did it
4368 goto exit;
4369 }
4370
4371 int seqId;
4372 ret = testCase.startRepeatingRequest(&seqId, requestTemplate, &resultCb);
4373 if (ret != ACAMERA_OK) {
4374 // Don't log error here. testcase did it
4375 goto exit;
4376 }
4377
4378 size_t failedRequestCount;
4379 int64_t lastFrameNumber;
4380 int64_t lastFailedRequestNumber = -1;
4381 failedRequestCount = lastFrameNumber = 0;
4382 while ((failedRequestCount < NUM_FAILED_FRAMES) && (lastFrameNumber < NUM_TOTAL_FRAMES)) {
4383 auto frameArrived = resultListener.waitForFrameNumber(lastFrameNumber, timeoutSec);
4384 if (!frameArrived) {
4385 LOG_ERROR(errorString, "Camera %s timed out waiting on last frame number!",
4386 cameraId);
4387 goto exit;
4388 }
4389 readerListener.waitForNextBuffer(bufferTimeoutSec);
4390 auto failedFrameNumber = resultListener.checkForFailureOrLoss(lastFrameNumber) ?
4391 lastFrameNumber : -1;
4392 if (lastFailedRequestNumber != failedFrameNumber) {
4393 if ((lastFailedRequestNumber + 1) == failedFrameNumber) {
4394 failedRequestCount++;
4395 } else {
4396 failedRequestCount = 1;
4397 }
4398 lastFailedRequestNumber = failedFrameNumber;
4399 }
4400 lastFrameNumber++;
4401 }
4402
4403 ret = testCase.abortCaptures();
4404 if (ret != ACAMERA_OK) {
4405 LOG_ERROR(errorString, "abort captures failed!");
4406 goto exit;
4407 }
4408
4409 ret = testCase.resetWithErrorLog();
4410 if (ret != ACAMERA_OK) {
4411 // Don't log error here. testcase did it
4412 goto exit;
4413 }
4414
4415 usleep(100000); // sleep to give some time for callbacks to happen
4416
4417 if (!testCase.isCameraAvailable(cameraId)) {
4418 LOG_ERROR(errorString, "Camera %s should be available now", cameraId);
4419 goto exit;
4420 }
4421
4422 if (failedRequestCount < NUM_FAILED_FRAMES) {
4423 LOG_ERROR(errorString, "Unable to receive %zu consecutive capture failures within"
4424 " %" PRId64 " capture requests", NUM_FAILED_FRAMES, NUM_TOTAL_FRAMES);
4425 goto exit;
4426 }
4427 }
4428
4429 ret = testCase.deInit();
4430 if (ret != ACAMERA_OK) {
4431 LOG_ERROR(errorString, "Testcase deInit failed: ret %d", ret);
4432 goto exit;
4433 }
4434
4435 pass = true;
4436
4437 exit:
4438
4439 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
4440 if (!pass) {
4441 throwAssertionError(env, errorString);
4442 }
4443
4444 return pass;
4445 }
4446
4447 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeImageReaderTest_testJpegNative(JNIEnv * env,jclass,jstring jOutPath,jstring jOverrideCameraId)4448 Java_android_hardware_camera2_cts_NativeImageReaderTest_\
4449 testJpegNative(
4450 JNIEnv* env, jclass /*clazz*/, jstring jOutPath,
4451 jstring jOverrideCameraId) {
4452 ALOGV("%s", __FUNCTION__);
4453 return nativeImageReaderTestBase(env, jOutPath, AIMAGE_FORMAT_JPEG,
4454 ImageReaderListener::validateImageCb, jOverrideCameraId);
4455 }
4456
4457 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeImageReaderTest_testY8Native(JNIEnv * env,jclass,jstring jOutPath,jstring jOverrideCameraId)4458 Java_android_hardware_camera2_cts_NativeImageReaderTest_\
4459 testY8Native(
4460 JNIEnv* env, jclass /*clazz*/, jstring jOutPath,
4461 jstring jOverrideCameraId) {
4462 ALOGV("%s", __FUNCTION__);
4463 return nativeImageReaderTestBase(env, jOutPath, AIMAGE_FORMAT_Y8,
4464 ImageReaderListener::validateImageCb, jOverrideCameraId);
4465 }
4466
4467 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeImageReaderTest_testHeicNative(JNIEnv * env,jclass,jstring jOutPath,jstring jOverrideCameraId)4468 Java_android_hardware_camera2_cts_NativeImageReaderTest_\
4469 testHeicNative(
4470 JNIEnv* env, jclass /*clazz*/, jstring jOutPath,
4471 jstring jOverrideCameraId) {
4472 ALOGV("%s", __FUNCTION__);
4473 return nativeImageReaderTestBase(env, jOutPath, AIMAGE_FORMAT_HEIC,
4474 ImageReaderListener::validateImageCb, jOverrideCameraId);
4475 }
4476
4477 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeImageReaderTest_testDepthJpegNative(JNIEnv * env,jclass,jstring jOutPath,jstring jOverrideCameraId)4478 Java_android_hardware_camera2_cts_NativeImageReaderTest_\
4479 testDepthJpegNative(
4480 JNIEnv* env, jclass /*clazz*/, jstring jOutPath,
4481 jstring jOverrideCameraId) {
4482 ALOGV("%s", __FUNCTION__);
4483 return nativeImageReaderTestBase(env, jOutPath, AIMAGE_FORMAT_DEPTH_JPEG,
4484 ImageReaderListener::validateImageCb, jOverrideCameraId);
4485 }
4486
4487 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeImageReaderTest_testImageReaderCloseAcquiredImagesNative(JNIEnv * env,jclass,jstring jOverrideCameraId)4488 Java_android_hardware_camera2_cts_NativeImageReaderTest_\
4489 testImageReaderCloseAcquiredImagesNative(
4490 JNIEnv* env, jclass /*clazz*/,
4491 jstring jOverrideCameraId) {
4492 ALOGV("%s", __FUNCTION__);
4493 return nativeImageReaderTestBase(env, nullptr, AIMAGE_FORMAT_JPEG,
4494 ImageReaderListener::acquireImageCb, jOverrideCameraId);
4495 }
4496
4497 template <>
4498 struct std::default_delete<ACameraManager> {
operator ()std::default_delete4499 inline void operator()(ACameraManager* manager) const { ACameraManager_delete(manager); }
4500 };
4501
4502 class AvailabilityContext {
4503 public:
4504 AvailabilityContext();
4505 ~AvailabilityContext();
4506
4507 camera_status_t initialize();
4508 int getAcessCallbackCountAndReset();
4509
4510 private:
4511 std::unique_ptr<ACameraManager> mCameraManager;
4512 std::unique_ptr<CameraServiceListener> mServiceListener;
4513 std::unique_ptr<ACameraManager_ExtendedAvailabilityCallbacks> mServiceCb;
4514 };
4515
AvailabilityContext()4516 AvailabilityContext::AvailabilityContext() :
4517 mCameraManager(ACameraManager_create()),
4518 mServiceListener(std::make_unique<CameraServiceListener>()),
4519 mServiceCb(std::make_unique<ACameraManager_ExtendedAvailabilityCallbacks>()) {
4520 mServiceCb->availabilityCallbacks.context = mServiceListener.get();
4521 mServiceCb->availabilityCallbacks.onCameraAvailable = CameraServiceListener::onAvailable;
4522 mServiceCb->availabilityCallbacks.onCameraUnavailable =
4523 CameraServiceListener::onUnavailable;
4524 mServiceCb->onCameraAccessPrioritiesChanged =
4525 CameraServiceListener::onCameraAccessPrioritiesChanged;
4526 mServiceCb->onPhysicalCameraAvailable =
4527 CameraServiceListener::onPhysicalCameraAvailable;
4528 mServiceCb->onPhysicalCameraUnavailable =
4529 CameraServiceListener::onPhysicalCameraUnavailable;
4530 }
4531
initialize()4532 camera_status_t AvailabilityContext::initialize() {
4533 auto rc = ACameraManager_registerExtendedAvailabilityCallback(mCameraManager.get(),
4534 mServiceCb.get());
4535 if (rc != ACAMERA_OK) {
4536 LOG_ERROR(errorString, "Register availability callback failed: rc %d", rc);
4537 return rc;
4538 }
4539
4540 ACameraIdList* cameraIdList = nullptr;
4541 rc = ACameraManager_getCameraIdList(mCameraManager.get(), &cameraIdList);
4542 if (rc != ACAMERA_OK) {
4543 LOG_ERROR(errorString, "Get camera id list failed: ret %d", rc);
4544 return rc;
4545 }
4546 ACameraManager_deleteCameraIdList(cameraIdList);
4547
4548 return rc;
4549 }
4550
getAcessCallbackCountAndReset()4551 int AvailabilityContext::getAcessCallbackCountAndReset() {
4552 auto ret = mServiceListener->getCameraAccessPrioritiesChangedCount();
4553 mServiceListener->resetCount();
4554 return ret;
4555 }
4556
~AvailabilityContext()4557 AvailabilityContext::~AvailabilityContext() {
4558 if (mServiceCb != nullptr) {
4559 camera_status_t ret = ACameraManager_unregisterExtendedAvailabilityCallback(
4560 mCameraManager.get(), mServiceCb.get());
4561 if (ret != ACAMERA_OK) {
4562 ALOGE("Unregister availability callback failed: ret %d", ret);
4563 }
4564 }
4565 }
4566
4567 extern "C" jlong
Java_android_hardware_multiprocess_camera_cts_CameraEvictionTest_initializeAvailabilityCallbacksNative(JNIEnv * env,jclass)4568 Java_android_hardware_multiprocess_camera_cts_CameraEvictionTest_\
4569 initializeAvailabilityCallbacksNative(
4570 JNIEnv* env, jclass /*clazz*/) {
4571 ALOGV("%s", __FUNCTION__);
4572
4573 AvailabilityContext *ctx = new AvailabilityContext();
4574
4575 auto rc = ctx->initialize();
4576 if (rc != ACAMERA_OK) {
4577 delete ctx;
4578 LOG_ERROR(errorString, "Availability context initialization failed: %d", rc);
4579 return 0;
4580 }
4581
4582 return (jlong) ctx;
4583 }
4584
4585 extern "C" jint
Java_android_hardware_multiprocess_camera_cts_CameraEvictionTest_getAccessCallbacksCountAndResetNative(JNIEnv * env,jclass,jlong context)4586 Java_android_hardware_multiprocess_camera_cts_CameraEvictionTest_\
4587 getAccessCallbacksCountAndResetNative(
4588 JNIEnv* env, jclass /*clazz*/, jlong context) {
4589 ALOGV("%s", __FUNCTION__);
4590
4591 if (context == 0) {
4592 LOG_ERROR(errorString, "Invalid availability context");
4593 return 0;
4594 }
4595
4596 AvailabilityContext* ctx = reinterpret_cast<AvailabilityContext*>(context);
4597 return ctx->getAcessCallbackCountAndReset();
4598 }
4599
4600 extern "C" void
Java_android_hardware_multiprocess_camera_cts_CameraEvictionTest_releaseAvailabilityCallbacksNative(JNIEnv * env,jclass,jlong context)4601 Java_android_hardware_multiprocess_camera_cts_CameraEvictionTest_\
4602 releaseAvailabilityCallbacksNative(
4603 JNIEnv* env, jclass /*clazz*/, jlong context) {
4604 ALOGV("%s", __FUNCTION__);
4605
4606 if (context == 0) {
4607 return;
4608 }
4609
4610 AvailabilityContext* ctx = reinterpret_cast<AvailabilityContext*>(context);
4611 delete ctx;
4612 }
4613
4614 extern "C" jboolean
Java_android_hardware_camera2_cts_NativeStillCaptureTest_testStillCaptureNative(JNIEnv * env,jclass,jstring jOutPath,jobject jPreviewSurface,jstring jOverrideCameraId)4615 Java_android_hardware_camera2_cts_NativeStillCaptureTest_\
4616 testStillCaptureNative(
4617 JNIEnv* env, jclass /*clazz*/, jstring jOutPath, jobject jPreviewSurface,
4618 jstring jOverrideCameraId) {
4619 ALOGV("%s", __FUNCTION__);
4620 const int NUM_TEST_IMAGES = 10;
4621 media_status_t mediaRet = AMEDIA_ERROR_UNKNOWN;
4622 int numCameras = 0;
4623 bool pass = false;
4624 PreviewTestCase testCase;
4625 ACameraMetadata* chars = nullptr;
4626
4627 const char* outPath = env->GetStringUTFChars(jOutPath, nullptr);
4628 ALOGI("%s: out path is %s", __FUNCTION__, outPath);
4629
4630 camera_status_t ret = testCase.initWithErrorLog(env, jOverrideCameraId);
4631 if (ret != ACAMERA_OK) {
4632 // Don't log error here. testcase did it
4633 goto cleanup;
4634 }
4635
4636 numCameras = testCase.getNumCameras();
4637 if (numCameras < 0) {
4638 LOG_ERROR(errorString, "Testcase returned negavtive number of cameras: %d", numCameras);
4639 goto cleanup;
4640 }
4641
4642 for (int i = 0; i < numCameras; i++) {
4643 const char* cameraId = testCase.getCameraId(i);
4644 if (cameraId == nullptr) {
4645 LOG_ERROR(errorString, "Testcase returned null camera id for camera %d", i);
4646 goto cleanup;
4647 }
4648
4649 {
4650 ACameraMetadata* chars = testCase.getCameraChars(cameraId);
4651 StaticInfo staticInfo(chars);
4652 if (!staticInfo.isColorOutputSupported()) {
4653 ALOGI("%s: camera %s does not support color output. skipping",
4654 __FUNCTION__, cameraId);
4655 ACameraMetadata_free(chars);
4656 continue;
4657 }
4658 ACameraMetadata_free(chars);
4659 }
4660
4661 ret = testCase.openCamera(cameraId);
4662 if (ret != ACAMERA_OK) {
4663 LOG_ERROR(errorString, "Open camera device %s failure. ret %d", cameraId, ret);
4664 goto cleanup;
4665 }
4666
4667 chars = testCase.getCameraChars(i);
4668 if (chars == nullptr) {
4669 LOG_ERROR(errorString, "Get camera %s characteristics failure", cameraId);
4670 goto cleanup;
4671 }
4672 StaticInfo staticInfo(chars);
4673
4674 usleep(100000); // sleep to give some time for callbacks to happen
4675
4676 if (testCase.isCameraAvailable(cameraId)) {
4677 LOG_ERROR(errorString, "Camera %s should be unavailable now", cameraId);
4678 goto cleanup;
4679 }
4680
4681 ImageReaderListener readerListener;
4682 AImageReader_ImageListener readerCb {
4683 &readerListener,
4684 ImageReaderListener::validateImageCb
4685 };
4686 readerListener.setDumpFilePathBase(outPath);
4687 int32_t testWidth, testHeight;
4688 if (!staticInfo.getMaxSizeForFormat(AIMAGE_FORMAT_JPEG, &testWidth, &testHeight)) {
4689 goto cleanup;
4690 }
4691 mediaRet = testCase.initImageReaderWithErrorLog(
4692 testWidth, testHeight, AIMAGE_FORMAT_JPEG, NUM_TEST_IMAGES,
4693 &readerCb);
4694 if (mediaRet != AMEDIA_OK) {
4695 // Don't log error here. testcase did it
4696 goto cleanup;
4697 }
4698
4699 ANativeWindow* previewAnw = testCase.initPreviewAnw(env, jPreviewSurface);
4700 if (previewAnw == nullptr) {
4701 LOG_ERROR(errorString, "Null ANW from preview surface!");
4702 goto cleanup;
4703 }
4704
4705 ret = testCase.createCaptureSessionWithLog();
4706 if (ret != ACAMERA_OK) {
4707 // Don't log error here. testcase did it
4708 goto cleanup;
4709 }
4710
4711 ret = testCase.createRequestsWithErrorLog();
4712 if (ret != ACAMERA_OK) {
4713 // Don't log error here. testcase did it
4714 goto cleanup;
4715 }
4716
4717 ret = testCase.startPreview();
4718 if (ret != ACAMERA_OK) {
4719 LOG_ERROR(errorString, "Start preview failed!");
4720 goto cleanup;
4721 }
4722
4723 // Let preview run some time
4724 sleep(3);
4725
4726 // Do some still capture
4727 for (int capture = 0; capture < NUM_TEST_IMAGES; capture++) {
4728 ret = testCase.takePicture();
4729 if (ret != ACAMERA_OK) {
4730 LOG_ERROR(errorString, "Camera %s capture(%d) failed. ret %d",
4731 cameraId, capture, ret);
4732 goto cleanup;
4733 }
4734 }
4735
4736 int64_t minFrameDurationNs = staticInfo.getMinFrameDurationFor(
4737 AIMAGE_FORMAT_JPEG, testWidth, testHeight);
4738 if (minFrameDurationNs < 0) {
4739 LOG_ERROR(errorString, "Get camera %s minFrameDuration failed", cameraId);
4740 goto cleanup;
4741 }
4742 int64_t stallDurationNs = staticInfo.getStallDurationFor(
4743 AIMAGE_FORMAT_JPEG, testWidth, testHeight);
4744 if (stallDurationNs < 0) {
4745 LOG_ERROR(errorString, "Get camera %s stallDuration failed", cameraId);
4746 goto cleanup;
4747 }
4748
4749 int64_t expectedDurationNs = (minFrameDurationNs + stallDurationNs) * NUM_TEST_IMAGES;
4750 constexpr int64_t waitPerIterationUs = 100000;
4751 constexpr int64_t usToNs = 1000;
4752 int totalWaitIteration = 60;
4753
4754 // Allow 1.5x margin
4755 if (expectedDurationNs * 3 / 2 > totalWaitIteration * waitPerIterationUs * usToNs) {
4756 totalWaitIteration = expectedDurationNs * 3 / 2 / waitPerIterationUs / usToNs;
4757 }
4758
4759 // wait until all capture finished
4760 for (int i = 0; i < totalWaitIteration; i++) {
4761 usleep(waitPerIterationUs);
4762 if (readerListener.onImageAvailableCount() == NUM_TEST_IMAGES) {
4763 ALOGI("Session take ~%d ms to capture %d images",
4764 i*100, NUM_TEST_IMAGES);
4765 break;
4766 }
4767 }
4768
4769 if (readerListener.onImageAvailableCount() != NUM_TEST_IMAGES) {
4770 LOG_ERROR(errorString, "Camera %s timeout capturing %d images. Got %d",
4771 cameraId, NUM_TEST_IMAGES, readerListener.onImageAvailableCount());
4772 testCase.resetWithErrorLog();
4773 goto cleanup;
4774 }
4775
4776 ret = testCase.resetWithErrorLog();
4777 if (ret != ACAMERA_OK) {
4778 // Don't log error here. testcase did it
4779 goto cleanup;
4780 }
4781
4782 usleep(100000); // sleep to give some time for callbacks to happen
4783
4784 if (!testCase.isCameraAvailable(cameraId)) {
4785 LOG_ERROR(errorString, "Camera %s should be available now", cameraId);
4786 goto cleanup;
4787 }
4788 }
4789
4790 ret = testCase.deInit();
4791 if (ret != ACAMERA_OK) {
4792 LOG_ERROR(errorString, "Testcase deInit failed: ret %d", ret);
4793 goto cleanup;
4794 }
4795
4796 pass = true;
4797 cleanup:
4798 env->ReleaseStringUTFChars(jOutPath, outPath);
4799
4800 if (chars != nullptr) {
4801 ACameraMetadata_free(chars);
4802 chars = nullptr;
4803 }
4804
4805 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
4806 if (!pass) {
4807 throwAssertionError(env, errorString);
4808 }
4809 return pass;
4810 }
4811
4812 extern "C" jboolean
Java_android_hardware_camera2_cts_CaptureResultTest_validateACameraMetadataFromCameraMetadataCriticalTagsNative(JNIEnv * env,jclass,jobject captureResult,jlong javaTimestamp)4813 Java_android_hardware_camera2_cts_CaptureResultTest_\
4814 validateACameraMetadataFromCameraMetadataCriticalTagsNative(
4815 JNIEnv* env, jclass /*clazz*/, jobject captureResult,
4816 jlong javaTimestamp) {
4817 ALOGV("%s", __FUNCTION__);
4818 ACameraMetadata* ndkResult =
4819 ACameraMetadata_fromCameraMetadata(env, captureResult);
4820 if (!ndkResult) {
4821 ALOGE("validateCriticalTags failed: "
4822 "ACameraMetadata_fromCameraMetadata returned nullptr.");
4823 return false;
4824 }
4825
4826 camera_status_t ret;
4827 ACameraMetadata_const_entry entry;
4828
4829 ret = ACameraMetadata_getConstEntry(ndkResult, ACAMERA_SENSOR_TIMESTAMP,
4830 &entry);
4831
4832 if (ret != ACAMERA_OK) {
4833 ALOGE("validateCriticalTags failed: "
4834 "ACameraMetadata_getConstEntry returned %d.", ret);
4835 ACameraMetadata_free(ndkResult);
4836 return false;
4837 }
4838 if (entry.type != ACAMERA_TYPE_INT64) {
4839 ALOGE("validateCriticalTags failed: entry.type is %u but should be %u.",
4840 entry.type, ACAMERA_TYPE_INT64);
4841 ACameraMetadata_free(ndkResult);
4842 return false;
4843 }
4844 if (entry.count != 1) {
4845 ALOGE("validateCriticalTags failed: entry.count is %u but should be %u.",
4846 entry.count, 1);
4847 ACameraMetadata_free(ndkResult);
4848 return false;
4849 }
4850 if (entry.data.i64 == nullptr) {
4851 ALOGE("validateCriticalTags failed: entry.data.i64 is nullptr.");
4852 ACameraMetadata_free(ndkResult);
4853 return false;
4854 }
4855
4856 const int64_t javaTimestampI64 = static_cast<int64_t>(javaTimestamp);
4857 const int64_t ndkTimestampI64 = *(entry.data.i64);
4858 ALOGV("javaTimestampI64 = %" PRId64 ", ndkTimestampI64 = %" PRId64,
4859 javaTimestampI64, ndkTimestampI64);
4860
4861 ACameraMetadata_free(ndkResult);
4862
4863 return (javaTimestampI64 == ndkTimestampI64);
4864 }
4865
4866 static ACameraMetadata *sStashedMetadata = nullptr;
4867
4868 // Test holding on to a ACameraMetadata past a single local JNI call
4869 extern "C" jboolean
Java_android_hardware_camera2_cts_CaptureResultTest_stashACameraMetadataFromCameraMetadataNative(JNIEnv * env,jclass,jobject captureResult)4870 Java_android_hardware_camera2_cts_CaptureResultTest_\
4871 stashACameraMetadataFromCameraMetadataNative(
4872 JNIEnv* env, jclass /*clazz*/, jobject captureResult) {
4873 ALOGV("%s", __FUNCTION__);
4874 ACameraMetadata* ndkResult =
4875 ACameraMetadata_fromCameraMetadata(env, captureResult);
4876 if (ndkResult == nullptr) return false;
4877 sStashedMetadata = ndkResult;
4878
4879 return true;
4880 }
4881
4882 extern "C" jboolean
Java_android_hardware_camera2_cts_CaptureResultTest_validateStashedACameraMetadataFromCameraMetadataNative(JNIEnv * env,jclass,jlong timestamp)4883 Java_android_hardware_camera2_cts_CaptureResultTest_\
4884 validateStashedACameraMetadataFromCameraMetadataNative(
4885 JNIEnv* env, jclass /*clazz*/, jlong timestamp) {
4886 ALOGV("%s", __FUNCTION__);
4887 if (sStashedMetadata == nullptr) return false;
4888
4889 camera_status_t ret;
4890 ACameraMetadata_const_entry entry;
4891
4892 ret = ACameraMetadata_getConstEntry(sStashedMetadata, ACAMERA_SENSOR_TIMESTAMP,
4893 &entry);
4894
4895 if (ret != ACAMERA_OK) {
4896 ALOGE("validateStashed failed: "
4897 "ACameraMetadata_getConstEntry returned %d.", ret);
4898 ACameraMetadata_free(sStashedMetadata);
4899 sStashedMetadata = nullptr;
4900 return false;
4901 }
4902 if (entry.type != ACAMERA_TYPE_INT64) {
4903 ALOGE("validateStashed failed: entry.type is %u but should be %u.",
4904 entry.type, ACAMERA_TYPE_INT64);
4905 ACameraMetadata_free(sStashedMetadata);
4906 sStashedMetadata = nullptr;
4907 return false;
4908 }
4909 if (entry.count != 1) {
4910 ALOGE("validateStashed failed: entry.count is %u but should be %u.",
4911 entry.count, 1);
4912 ACameraMetadata_free(sStashedMetadata);
4913 sStashedMetadata = nullptr;
4914 return false;
4915 }
4916 if (entry.data.i64 == nullptr) {
4917 ALOGE("validateStashed failed: entry.data.i64 is nullptr.");
4918 ACameraMetadata_free(sStashedMetadata);
4919 sStashedMetadata = nullptr;
4920 return false;
4921 }
4922
4923 const int64_t javaTimestampI64 = static_cast<int64_t>(timestamp);
4924 const int64_t ndkTimestampI64 = *(entry.data.i64);
4925
4926 ACameraMetadata_free(sStashedMetadata);
4927 sStashedMetadata = nullptr;
4928 ALOGV("javaTimestampI64 = %" PRId64 ", ndkTimestampI64 = %" PRId64,
4929 javaTimestampI64, ndkTimestampI64);
4930 return (javaTimestampI64 == ndkTimestampI64);
4931
4932 }
4933
4934
4935
4936 extern "C" jboolean
Java_android_hardware_camera2_cts_CameraManagerTest_validateACameraMetadataFromCameraMetadataCriticalTagsNative(JNIEnv * env,jclass,jobject cameraCharacteristics,jint javaLensFacing)4937 Java_android_hardware_camera2_cts_CameraManagerTest_\
4938 validateACameraMetadataFromCameraMetadataCriticalTagsNative(
4939 JNIEnv* env, jclass /*clazz*/, jobject cameraCharacteristics,
4940 jint javaLensFacing) {
4941 ALOGV("%s", __FUNCTION__);
4942 ACameraMetadata* ndkCharacteristics =
4943 ACameraMetadata_fromCameraMetadata(env, cameraCharacteristics);
4944 if (!ndkCharacteristics) {
4945 ALOGE("validateCriticalTags failed: "
4946 "ACameraMetadata_fromCameraMetadata returned nullptr.");
4947 return false;
4948 }
4949
4950 camera_status_t ret;
4951 ACameraMetadata_const_entry entry;
4952
4953 ret = ACameraMetadata_getConstEntry(ndkCharacteristics,
4954 ACAMERA_LENS_FACING, &entry);
4955 ACameraMetadata_free(ndkCharacteristics);
4956
4957 if (ret != ACAMERA_OK) {
4958 ALOGE("validateCriticalTags failed: "
4959 "ACameraMetadata_getConstEntry returned %d", ret);
4960 return false;
4961 }
4962 if (entry.type != ACAMERA_TYPE_BYTE) {
4963 ALOGE("validateCriticalTags failed: entry.type is %u but should be %u.",
4964 entry.type, ACAMERA_TYPE_BYTE);
4965 return false;
4966 }
4967 if (entry.count != 1) {
4968 ALOGE("validateCriticalTags failed: entry.count is %u but should be %u.",
4969 entry.count, 1);
4970 return false;
4971 }
4972 if (entry.data.u8 == nullptr) {
4973 ALOGE("validateCriticalTags failed: entry.data.u8 is nullptr.");
4974 return false;
4975 }
4976
4977 const uint8_t javaLensFacingU8 = static_cast<uint8_t>(javaLensFacing);
4978 const uint8_t ndkLensFacingU8 = *(entry.data.u8);
4979 ALOGV("javaLensFacingU8 = %d, ndkLensFacingU8 = %d",
4980 javaLensFacingU8, ndkLensFacingU8);
4981 return (javaLensFacingU8 == ndkLensFacingU8);
4982 }
4983
Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_testIsCameraDeviceSharingSupportedNative(JNIEnv * env,jclass,jstring jCameraId,jbooleanArray result)4984 extern "C" jboolean Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_\
4985 testIsCameraDeviceSharingSupportedNative(JNIEnv* env, jclass /*clazz*/, jstring jCameraId,
4986 jbooleanArray result) {
4987 bool pass = false;
4988 ALOGV("%s", __FUNCTION__);
4989 const char *camId = nullptr;
4990 bool sharingSupported = false;
4991 camera_status_t ret = ACAMERA_OK;
4992 ACameraManager* mgr = nullptr;
4993 ACameraManager_isCameraDeviceSharingSupportedNative isCameraDeviceSharingSupported;
4994 // Load system api using dlsym.
4995 void* handle = dlopen(kLibandroidPath, RTLD_NOW | RTLD_LOCAL);
4996 if (!handle) {
4997 LOG_ERROR(errorString, "dlopen error: %s %s", __func__, dlerror());
4998 goto cleanup;
4999 }
5000 getLibFunction(handle, "ACameraManager_isCameraDeviceSharingSupported",
5001 &isCameraDeviceSharingSupported);
5002 dlclose(handle);
5003 if (isCameraDeviceSharingSupported == nullptr) {
5004 LOG_ERROR(errorString, "ACameraManager_isCameraDeviceSharingSupported func is nullptr");
5005 goto cleanup;
5006 }
5007 mgr = ACameraManager_create();
5008 if (mgr == nullptr) {
5009 LOG_ERROR(errorString, "ACameraManager_create returns nullptr");
5010 goto cleanup;
5011 }
5012 if (env != nullptr && jCameraId != nullptr) {
5013 camId = env->GetStringUTFChars(jCameraId, 0);
5014 }
5015 if (camId == nullptr) {
5016 LOG_ERROR(errorString, "Camera ID is nullptr");
5017 goto cleanup;
5018 }
5019 ret = isCameraDeviceSharingSupported(mgr, camId, &sharingSupported);
5020 if (ret != ACAMERA_OK) {
5021 LOG_ERROR(errorString, "ACameraManager_isCameraDeviceSharingSupported failed: ret %d", ret);
5022 goto cleanup;
5023 }
5024 jboolean outArr[1];
5025 outArr[0] = sharingSupported;
5026 env->SetBooleanArrayRegion(result, 0, 1, outArr);
5027 pass = true;
5028 cleanup:
5029 if (mgr) {
5030 ACameraManager_delete(mgr);
5031 }
5032 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "fail");
5033 if (!pass) {
5034 throwAssertionError(env, errorString);
5035 }
5036 return pass;
5037 }
5038
Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_testInitAndOpenSharedCameraNative(JNIEnv * env,jclass,jstring jCameraId,jboolean expectedClient,jboolean expectFail)5039 extern "C" jlong Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_\
5040 testInitAndOpenSharedCameraNative(
5041 JNIEnv* env, jclass /*clazz*/, jstring jCameraId, jboolean expectedClient,
5042 jboolean expectFail) {
5043 ALOGV("%s", __FUNCTION__);
5044 bool pass = false;
5045 int numCameras;
5046 const char* cameraId = nullptr;
5047 bool isPrimary;
5048 PreviewTestCase* testCase = new PreviewTestCase();
5049 camera_status_t ret = testCase->initWithErrorLog(env, jCameraId);
5050 if (ret != ACAMERA_OK) {
5051 LOG_ERROR(errorString, "initWithErrorLog failed: ret %d", ret);
5052 goto cleanup;
5053 }
5054 numCameras = testCase->getNumCameras();
5055 if (numCameras < 0) {
5056 LOG_ERROR(errorString, "Testcase returned negative number of cameras: %d", numCameras);
5057 goto cleanup;
5058 }
5059 cameraId = testCase->getCameraId(0);
5060 if (cameraId == nullptr) {
5061 LOG_ERROR(errorString, "Testcase returned null camera id for camera");
5062 goto cleanup;
5063 }
5064 ret = testCase->openSharedCamera(cameraId, &isPrimary);
5065 if (!expectFail) {
5066 if (ret != ACAMERA_OK) {
5067 LOG_ERROR(errorString, "Open camera device %s in shared mode failure. ret %d", cameraId,
5068 ret);
5069 goto cleanup;
5070 }
5071 usleep(100000); // sleep to give some time for callbacks to happen
5072 if (isPrimary != expectedClient) {
5073 LOG_ERROR(errorString,
5074 "Camera device %s is opened in shared mode as primary=%d expected=%d", cameraId,
5075 isPrimary, expectedClient);
5076 goto cleanup;
5077 }
5078 } else {
5079 if (ret == ACAMERA_OK) {
5080 LOG_ERROR(errorString,
5081 "Open camera device in shared mode was expected to fail for camera %s",
5082 cameraId);
5083 goto cleanup;
5084 }
5085 }
5086 pass = true;
5087 cleanup:
5088 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "fail");
5089 if (!pass) {
5090 throwAssertionError(env, errorString);
5091 if (testCase) {
5092 delete testCase;
5093 }
5094 return 0;
5095 }
5096 return (jlong)testCase;
5097 }
5098
Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_testInitAndOpenCameraNative(JNIEnv * env,jclass,jstring jCameraId,jboolean expectFail)5099 extern "C" jlong Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_\
5100 testInitAndOpenCameraNative(JNIEnv* env, jclass /*clazz*/, jstring jCameraId, jboolean expectFail) {
5101 ALOGV("%s", __FUNCTION__);
5102 bool pass = false;
5103 int numCameras;
5104 const char* cameraId = nullptr;
5105 PreviewTestCase* testCase = new PreviewTestCase();
5106 camera_status_t ret = testCase->initWithErrorLog(env, jCameraId);
5107 if (ret != ACAMERA_OK) {
5108 LOG_ERROR(errorString, "initWithErrorLog failed: ret %d", ret);
5109 goto cleanup;
5110 }
5111 numCameras = testCase->getNumCameras();
5112 if (numCameras < 0) {
5113 LOG_ERROR(errorString, "Testcase returned negative number of cameras: %d", numCameras);
5114 goto cleanup;
5115 }
5116 cameraId = testCase->getCameraId(0);
5117 if (cameraId == nullptr) {
5118 LOG_ERROR(errorString, "Testcase returned null camera id for camera");
5119 goto cleanup;
5120 }
5121 ret = testCase->openCamera(cameraId);
5122 if ((ret != ACAMERA_OK) != expectFail) {
5123 if (expectFail) {
5124 LOG_ERROR(errorString, "Open camera device %s success. Expected failure. ret %d",
5125 cameraId, ret);
5126 } else {
5127 LOG_ERROR(errorString, "Open camera device %s failure. Expected success. ret %d",
5128 cameraId, ret);
5129 }
5130 goto cleanup;
5131 }
5132 pass = true;
5133 cleanup:
5134 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "fail");
5135 if (!pass) {
5136 throwAssertionError(env, errorString);
5137 if (testCase) {
5138 delete testCase;
5139 }
5140 return 0;
5141 }
5142 return (jlong)testCase;
5143 }
5144
Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_testIsCameraEvictedNative(JNIEnv * env,jclass,jlong sharedTestContext)5145 extern "C" jboolean Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_\
5146 testIsCameraEvictedNative(JNIEnv* env, jclass /*clazz*/, jlong sharedTestContext) {
5147 ALOGV("%s", __FUNCTION__);
5148 bool pass = false;
5149 PreviewTestCase* sharedCtx = nullptr;
5150 int disconnectedCount;
5151 if (sharedTestContext == 0) {
5152 LOG_ERROR(errorString, "Invalid shared Test Context");
5153 goto cleanup;
5154 }
5155 sharedCtx = reinterpret_cast<PreviewTestCase*>(sharedTestContext);
5156 disconnectedCount = sharedCtx->getDeviceListener()->getDisconnectCount();
5157 if (disconnectedCount == 0) {
5158 LOG_ERROR(errorString, "Camera eviction failure: disconnectedCount %d", 0);
5159 goto cleanup;
5160 }
5161 pass = true;
5162 cleanup:
5163 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
5164 if (!pass) {
5165 throwAssertionError(env, errorString);
5166 }
5167 return pass;
5168 }
5169
Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_testClientAccessPriorityChangedNative(JNIEnv * env,jclass,jlong sharedTestContext,jboolean expectedClient)5170 extern "C" jboolean Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_\
5171 testClientAccessPriorityChangedNative(JNIEnv* env, jclass /*clazz*/, jlong sharedTestContext,
5172 jboolean expectedClient) {
5173 ALOGV("%s", __FUNCTION__);
5174 bool pass = false;
5175 int clientAccessPrioritiesChangedCount;
5176 bool clientSharedModeStatus;
5177 PreviewTestCase* sharedCtx = nullptr;
5178 if (sharedTestContext == 0) {
5179 LOG_ERROR(errorString, "Invalid shared Test Context");
5180 goto cleanup;
5181 }
5182 sharedCtx = reinterpret_cast<PreviewTestCase*>(sharedTestContext);
5183 clientAccessPrioritiesChangedCount =
5184 sharedCtx->getDeviceListener()->getClientAccessPrioritiesChangedCountAndReset();
5185 if (clientAccessPrioritiesChangedCount == 0) {
5186 LOG_ERROR(errorString,
5187 "testClientAccessPriorityChangedNative failure");
5188 goto cleanup;
5189 }
5190 clientSharedModeStatus = sharedCtx->getDeviceListener()->getClientSharedModeStatus();
5191 if (clientSharedModeStatus != expectedClient) {
5192 LOG_ERROR(errorString,
5193 "client shared mode status mismatch expected primary client as %d but was %d",
5194 expectedClient, clientSharedModeStatus);
5195 goto cleanup;
5196 }
5197 pass = true;
5198 cleanup:
5199 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
5200 if (!pass) {
5201 throwAssertionError(env, errorString);
5202 }
5203 return pass;
5204 }
5205
Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_testDeInitAndCloseSharedCameraNative(JNIEnv * env,jclass,jlong sharedTestContext,jboolean expectCameraAlreadyClosed)5206 extern "C" jboolean Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_\
5207 testDeInitAndCloseSharedCameraNative(JNIEnv* env, jclass /*clazz*/, jlong sharedTestContext,
5208 jboolean expectCameraAlreadyClosed) {
5209 ALOGV("%s", __FUNCTION__);
5210 bool pass = false;
5211 camera_status_t ret = ACAMERA_ERROR_UNKNOWN;
5212 PreviewTestCase* sharedCtx = nullptr;
5213 if (sharedTestContext == 0) {
5214 LOG_ERROR(errorString, "Invalid shared Test Context");
5215 goto cleanup;
5216 }
5217 sharedCtx = reinterpret_cast<PreviewTestCase*>(sharedTestContext);
5218
5219 if (!expectCameraAlreadyClosed) {
5220 ret = sharedCtx->closeCamera();
5221 if (ret != ACAMERA_OK) {
5222 LOG_ERROR(errorString, "Close camera device failure: ret %d", ret);
5223 goto cleanup;
5224 }
5225 }
5226
5227 usleep(100000); // sleep to give some time for callbacks to happen
5228 ret = sharedCtx->deInit();
5229 if (ret != ACAMERA_OK) {
5230 LOG_ERROR(errorString, "Testcase deInit failed: ret %d", ret);
5231 goto cleanup;
5232 }
5233 pass = true;
5234 cleanup:
5235 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
5236 if (sharedCtx) {
5237 delete sharedCtx;
5238 sharedCtx = nullptr;
5239 }
5240 if (!pass) {
5241 throwAssertionError(env, errorString);
5242 }
5243 return pass;
5244 }
5245
Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_testCreateCaptureSessionNative(JNIEnv * env,jclass,jlong sharedTestContext,int width,int height,int format)5246 extern "C" jboolean Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_\
5247 testCreateCaptureSessionNative(JNIEnv* env, jclass /*clazz*/, jlong sharedTestContext, int width,
5248 int height, int format) {
5249 ALOGV("%s", __FUNCTION__);
5250 bool pass = false;
5251 const int NUM_TEST_IMAGES = 10;
5252 media_status_t mediaRet = AMEDIA_ERROR_UNKNOWN;
5253 camera_status_t ret = ACAMERA_ERROR_UNKNOWN;
5254 PreviewTestCase* sharedCtx = nullptr;
5255 if (sharedTestContext == 0) {
5256 LOG_ERROR(errorString, "Invalid shared Test Context");
5257 goto cleanup;
5258 }
5259 sharedCtx = reinterpret_cast<PreviewTestCase*>(sharedTestContext);
5260 mediaRet = sharedCtx->initImageReaderWithErrorLog(width, height, format, NUM_TEST_IMAGES);
5261 if (mediaRet != AMEDIA_OK) {
5262 LOG_ERROR(errorString, "initImageReaderWithErrorLog failure: ret %d", mediaRet);
5263 goto cleanup;
5264 }
5265 ret = sharedCtx->createCaptureSessionWithLog();
5266 if (ret != ACAMERA_OK) {
5267 LOG_ERROR(errorString, "Create capture session failure: ret %d", ret);
5268 goto cleanup;
5269 }
5270 pass = true;
5271 cleanup:
5272 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
5273 if (!pass) {
5274 throwAssertionError(env, errorString);
5275 }
5276 return pass;
5277 }
5278
Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_testStartSharedStreamingNative(JNIEnv * env,jclass,jlong sharedTestContext)5279 extern "C" jboolean Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_\
5280 testStartSharedStreamingNative(JNIEnv* env, jclass /*clazz*/, jlong sharedTestContext) {
5281 ALOGV("%s", __FUNCTION__);
5282 bool pass = false;
5283 camera_status_t ret = ACAMERA_ERROR_UNKNOWN;
5284 bool frameStarted = false;
5285 const int timeoutSec = 1;
5286 PreviewTestCase* sharedCtx = nullptr;
5287 if (sharedTestContext == 0) {
5288 LOG_ERROR(errorString, "Invalid shared Test Context");
5289 goto cleanup;
5290 }
5291 sharedCtx = reinterpret_cast<PreviewTestCase*>(sharedTestContext);
5292 ret = sharedCtx->startSharedStreaming();
5293 if (ret != ACAMERA_OK) {
5294 LOG_ERROR(errorString, "Start Streaming failure: ret %d", ret);
5295 goto cleanup;
5296 }
5297 frameStarted = sharedCtx->waitForCaptureStarted(timeoutSec);
5298 if (!frameStarted) {
5299 LOG_ERROR(errorString, "Camera timed out waiting on onCaptureStart for last"
5300 "frame number!");
5301 goto cleanup;
5302 }
5303 pass = true;
5304 cleanup:
5305 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
5306 if (!pass) {
5307 throwAssertionError(env, errorString);
5308 }
5309 return pass;
5310 }
5311
Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_testStopSharedStreamingNative(JNIEnv * env,jclass,jlong sharedTestContext)5312 extern "C" jboolean Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_\
5313 testStopSharedStreamingNative(JNIEnv* env, jclass /*clazz*/, jlong sharedTestContext) {
5314 ALOGV("%s", __FUNCTION__);
5315 bool pass = false;
5316 camera_status_t ret = ACAMERA_ERROR_UNKNOWN;
5317 bool frameStarted = false;
5318 bool frameArrived = false;
5319 int64_t lastFrameNumber;
5320 const int timeoutSec = 1;
5321 int sequenceId;
5322 PreviewTestCase* sharedCtx = nullptr;
5323 if (sharedTestContext == 0) {
5324 LOG_ERROR(errorString, "Invalid shared Test Context");
5325 goto cleanup;
5326 }
5327 sharedCtx = reinterpret_cast<PreviewTestCase*>(sharedTestContext);
5328 sequenceId = sharedCtx->getSharedStreamingSeqId();
5329 ret = sharedCtx->stopSharedStreaming();
5330 if (ret != ACAMERA_OK) {
5331 LOG_ERROR(errorString, "Stop Streaming failure: ret %d", ret);
5332 goto cleanup;
5333 }
5334 lastFrameNumber = sharedCtx->getCaptureSequenceLastFrameNumber(sequenceId, timeoutSec);
5335 if (lastFrameNumber < 0) {
5336 LOG_ERROR(errorString, "Camera failed to acquire last frame number!");
5337 goto cleanup;
5338 }
5339 frameStarted = sharedCtx->waitForFrameNumberStarted(lastFrameNumber, timeoutSec);
5340 if (!frameStarted) {
5341 LOG_ERROR(errorString, "Camera timed out waiting on onCaptureStart for last"
5342 "frame number!");
5343 goto cleanup;
5344 }
5345 frameArrived = sharedCtx->waitForFrameNumber(lastFrameNumber, timeoutSec);
5346 if (!frameArrived) {
5347 LOG_ERROR(errorString, "Camera timed out waiting on last frame number!");
5348 goto cleanup;
5349 }
5350
5351 pass = true;
5352 cleanup:
5353 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
5354 if (!pass) {
5355 throwAssertionError(env, errorString);
5356 }
5357 return pass;
5358 }
5359
Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_testCloseSessionNative(JNIEnv * env,jclass,jlong sharedTestContext)5360 extern "C" jboolean Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_\
5361 testCloseSessionNative(JNIEnv* env, jclass /*clazz*/, jlong sharedTestContext) {
5362 ALOGV("%s", __FUNCTION__);
5363 bool pass = false;
5364 camera_status_t ret = ACAMERA_ERROR_UNKNOWN;
5365 CaptureSessionListener* sessionListener;
5366 PreviewTestCase* sharedCtx = nullptr;
5367 if (sharedTestContext == 0) {
5368 LOG_ERROR(errorString, "Invalid shared Test Context");
5369 goto cleanup;
5370 }
5371 sharedCtx = reinterpret_cast<PreviewTestCase*>(sharedTestContext);
5372 sessionListener = sharedCtx->getSessionListener();
5373 if (sessionListener == nullptr) {
5374 LOG_ERROR(errorString, "Session listener is null");
5375 goto cleanup;
5376 }
5377 sharedCtx->closeSession();
5378 usleep(100000); // sleep to give some time for callbacks to happen
5379 if (!sessionListener->isClosed() || sessionListener->onClosedCount() != 1) {
5380 LOG_ERROR(errorString,
5381 "Session for camera close error. isClosed %d close count %d",
5382 sessionListener->isClosed(), sessionListener->onClosedCount());
5383 goto cleanup;
5384 }
5385 sessionListener->reset();
5386 pass = true;
5387 cleanup:
5388 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
5389 if (!pass) {
5390 throwAssertionError(env, errorString);
5391 }
5392 return pass;
5393 }
5394
Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_testPerformUnsupportedOperationsNative(JNIEnv * env,jclass,jlong sharedTestContext,int width,int height,int format)5395 extern "C" jboolean Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_\
5396 testPerformUnsupportedOperationsNative(JNIEnv* env, jclass /*clazz*/, jlong sharedTestContext,
5397 int width, int height, int format) {
5398 ALOGV("%s", __FUNCTION__);
5399 bool pass = false;
5400 const int NUM_TEST_IMAGES = 10;
5401 media_status_t mediaRet = AMEDIA_ERROR_UNKNOWN;
5402 camera_status_t ret = ACAMERA_ERROR_UNKNOWN;
5403 PreviewTestCase* sharedCtx = nullptr;
5404 if (sharedTestContext == 0) {
5405 LOG_ERROR(errorString, "Invalid shared Test Context");
5406 goto cleanup;
5407 }
5408 sharedCtx = reinterpret_cast<PreviewTestCase*>(sharedTestContext);
5409 mediaRet = sharedCtx->initImageReaderWithErrorLog(width, height, format, NUM_TEST_IMAGES);
5410 if (mediaRet != AMEDIA_OK) {
5411 LOG_ERROR(errorString, "initImageReaderWithErrorLog failure: ret %d", mediaRet);
5412 goto cleanup;
5413 }
5414 ret = sharedCtx->createRequestsWithErrorLog();
5415 if (ret == ACAMERA_OK) {
5416 LOG_ERROR(errorString,
5417 "Expected failure for createRequestsWithErrorLog, but got success: ret %d", ret);
5418 goto cleanup;
5419 }
5420 // Create capture session with shared output enabled.
5421 ret = sharedCtx->createCaptureSessionWithLog(true);
5422 if (ret == ACAMERA_OK) {
5423 LOG_ERROR(errorString,
5424 "Expected failure for createCaptureSession with shared output, but got success:"
5425 " ret %d",
5426 ret);
5427 goto cleanup;
5428 }
5429 pass = true;
5430 cleanup:
5431 sharedCtx->deInitImageReader();
5432 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
5433 if (!pass) {
5434 throwAssertionError(env, errorString);
5435 }
5436 return pass;
5437 }
5438
Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_testUnsupportedCaptureSessionCommandsNative(JNIEnv * env,jclass,jlong sharedTestContext)5439 extern "C" jboolean Java_android_hardware_multiprocess_camera_cts_SharedCameraTest_\
5440 testUnsupportedCaptureSessionCommandsNative(JNIEnv* env, jclass /*clazz*/,
5441 jlong sharedTestContext) {
5442 ALOGV("%s", __FUNCTION__);
5443 bool pass = false;
5444 camera_status_t ret = ACAMERA_ERROR_UNKNOWN;
5445 bool frameStarted = false;
5446 bool frameArrived = false;
5447 const int timeoutSec = 1;
5448 int64_t lastFrameNumber;
5449 PreviewTestCase* sharedCtx = nullptr;
5450 ANativeWindow* anw = nullptr;
5451 ACaptureSessionOutput* imgReaderOutput = nullptr;
5452 int sequenceId;
5453 if (sharedTestContext == 0) {
5454 LOG_ERROR(errorString, "Invalid shared Test Context");
5455 goto cleanup;
5456 }
5457 sharedCtx = reinterpret_cast<PreviewTestCase*>(sharedTestContext);
5458 anw = sharedCtx->getImageReaderNativeWindow();
5459 if (anw == nullptr) {
5460 LOG_ERROR(errorString, "Image reader is not initialized");
5461 goto cleanup;
5462 }
5463 ret = sharedCtx->prepareWindow(anw);
5464 if (ret == ACAMERA_OK) {
5465 LOG_ERROR(errorString, "Expected failure for prepareWindow, but got success: ret %d", ret);
5466 goto cleanup;
5467 }
5468 imgReaderOutput = sharedCtx->getImageReaderOutput();
5469 ret = sharedCtx->updateOutput(env, imgReaderOutput);
5470 if (ret == ACAMERA_OK) {
5471 LOG_ERROR(errorString,
5472 "Expected failure for updateOutputConfiguration, but got success:"
5473 " ret %d",
5474 ret);
5475 goto cleanup;
5476 }
5477 ret = sharedCtx->startSharedStreaming();
5478 if (ret != ACAMERA_OK) {
5479 LOG_ERROR(errorString, "Start Streaming failure: ret %d", ret);
5480 goto cleanup;
5481 }
5482 frameStarted = sharedCtx->waitForCaptureStarted(timeoutSec);
5483 if (!frameStarted) {
5484 LOG_ERROR(errorString,
5485 "Camera timed out waiting on onCaptureStart for last"
5486 "frame number!");
5487 goto cleanup;
5488 }
5489 ret = sharedCtx->abortCaptures();
5490 if (ret == ACAMERA_OK) {
5491 LOG_ERROR(errorString, "Expected failure for abortCaptures, but got success: ret %d", ret);
5492 goto cleanup;
5493 }
5494 ret = sharedCtx->stopPreview();
5495 if (ret == ACAMERA_OK) {
5496 LOG_ERROR(errorString, "Expected failure for stopRepeating, but got success: ret %d", ret);
5497 goto cleanup;
5498 }
5499 sequenceId = sharedCtx->getSharedStreamingSeqId();
5500 ret = sharedCtx->stopSharedStreaming();
5501 if (ret != ACAMERA_OK) {
5502 LOG_ERROR(errorString, "Stop Streaming failure: ret %d", ret);
5503 goto cleanup;
5504 }
5505 lastFrameNumber = sharedCtx->getCaptureSequenceLastFrameNumber(sequenceId, timeoutSec);
5506 if (lastFrameNumber < 0) {
5507 LOG_ERROR(errorString, "Camera failed to acquire last frame number!");
5508 goto cleanup;
5509 }
5510 frameArrived = sharedCtx->waitForFrameNumber(lastFrameNumber, timeoutSec);
5511 if (!frameArrived) {
5512 LOG_ERROR(errorString, "Camera timed out waiting on last frame number!");
5513 goto cleanup;
5514 }
5515 pass = true;
5516 cleanup:
5517 ALOGI("%s %s", __FUNCTION__, pass ? "pass" : "failed");
5518 if (!pass) {
5519 throwAssertionError(env, errorString);
5520 }
5521 return pass;
5522 }
5523