1 /*
2 * Copyright (C) 2022 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_TAG "VtsAidlCameraServiceTargetTest"
18 // #define LOG_NDEBUG 0
19
20 #include <CameraMetadata.h>
21 #include <aidl/android/frameworks/cameraservice/device/BnCameraDeviceCallback.h>
22 #include <aidl/android/frameworks/cameraservice/device/CaptureRequest.h>
23 #include <aidl/android/frameworks/cameraservice/device/ICameraDeviceUser.h>
24 #include <aidl/android/frameworks/cameraservice/device/OutputConfiguration.h>
25 #include <aidl/android/frameworks/cameraservice/device/StreamConfigurationMode.h>
26 #include <aidl/android/frameworks/cameraservice/device/SubmitInfo.h>
27 #include <aidl/android/frameworks/cameraservice/device/TemplateId.h>
28 #include <aidl/android/frameworks/cameraservice/service/BnCameraServiceListener.h>
29 #include <aidl/android/frameworks/cameraservice/service/CameraStatusAndId.h>
30 #include <aidl/android/frameworks/cameraservice/service/ICameraService.h>
31 #include <aidlcommonsupport/NativeHandle.h>
32 #include <android-base/properties.h>
33 #include <android/binder_manager.h>
34 #include <android/binder_process.h>
35 #include <android/log.h>
36 #include <android/native_window_aidl.h>
37 #include <fmq/AidlMessageQueue.h>
38 #include <gtest/gtest.h>
39 #include <hidl/GtestPrinter.h>
40 #include <hidl/ServiceManagement.h>
41 #include <media/NdkImageReader.h>
42 #include <stdint.h>
43 #include <system/camera_metadata.h>
44 #include <system/graphics.h>
45 #include <utils/Condition.h>
46 #include <utils/Mutex.h>
47 #include <utils/StrongPointer.h>
48
49 #include <algorithm>
50 #include <string>
51 #include <unordered_map>
52 #include <unordered_set>
53 #include <vector>
54
55 namespace android {
56
57 using ::aidl::android::frameworks::cameraservice::device::BnCameraDeviceCallback;
58 using ::aidl::android::frameworks::cameraservice::device::CaptureMetadataInfo;
59 using ::aidl::android::frameworks::cameraservice::device::CaptureRequest;
60 using ::aidl::android::frameworks::cameraservice::device::CaptureResultExtras;
61 using ::aidl::android::frameworks::cameraservice::device::ErrorCode;
62 using ::aidl::android::frameworks::cameraservice::device::ICameraDeviceUser;
63 using ::aidl::android::frameworks::cameraservice::device::OutputConfiguration;
64 using ::aidl::android::frameworks::cameraservice::device::PhysicalCaptureResultInfo;
65 using ::aidl::android::frameworks::cameraservice::device::StreamConfigurationMode;
66 using ::aidl::android::frameworks::cameraservice::device::SubmitInfo;
67 using ::aidl::android::frameworks::cameraservice::device::TemplateId;
68 using ::aidl::android::frameworks::cameraservice::service::BnCameraServiceListener;
69 using ::aidl::android::frameworks::cameraservice::service::CameraDeviceStatus;
70 using ::aidl::android::frameworks::cameraservice::service::CameraStatusAndId;
71 using ::aidl::android::frameworks::cameraservice::service::ICameraService;
72 using ::aidl::android::hardware::common::fmq::MQDescriptor;
73 using ::aidl::android::view::Surface;
74 using ::android::hardware::isHidlSupported;
75 using ::android::hardware::camera::common::helper::CameraMetadata;
76 using ::ndk::SpAIBinder;
77
78 using AidlCameraMetadata = ::aidl::android::frameworks::cameraservice::device::CameraMetadata;
79 using RequestMetadataQueue = AidlMessageQueue<int8_t, SynchronizedReadWrite>;
80
81 static constexpr int kCaptureRequestCount = 10;
82 static constexpr int kVGAImageWidth = 640;
83 static constexpr int kVGAImageHeight = 480;
84 static constexpr int kNumRequests = 4;
85
86 static const char kCameraServiceDisabledProperty[] = "config.disable_cameraservice";
87
88 #define IDLE_TIMEOUT 2000000000 // ns
89
90 using scoped_unique_image_reader = std::unique_ptr<AImageReader, decltype(&AImageReader_delete)>;
91
92 class CameraServiceListener : public BnCameraServiceListener {
93 std::map<std::string, CameraDeviceStatus> mCameraStatuses;
94 // map: logical camera id -> set of unavailable physical camera ids
95 std::map<std::string, std::set<std::string>> mUnavailablePhysicalCameras;
96 mutable Mutex mLock;
97
98 public:
99 ~CameraServiceListener() override = default;
100
onStatusChanged(CameraDeviceStatus in_status,const std::string & in_cameraId)101 ndk::ScopedAStatus onStatusChanged(CameraDeviceStatus in_status,
102 const std::string& in_cameraId) override {
103 Mutex::Autolock l(mLock);
104 mCameraStatuses[in_cameraId] = in_status;
105 return ndk::ScopedAStatus::ok();
106 }
107
onPhysicalCameraStatusChanged(CameraDeviceStatus in_status,const std::string & in_cameraId,const std::string & in_physicalCameraId)108 ndk::ScopedAStatus onPhysicalCameraStatusChanged(
109 CameraDeviceStatus in_status, const std::string& in_cameraId,
110 const std::string& in_physicalCameraId) override {
111 Mutex::Autolock l(mLock);
112 ALOGI("%s: Physical camera %s : %s status changed to %d", __FUNCTION__, in_cameraId.c_str(),
113 in_physicalCameraId.c_str(), in_status);
114
115 EXPECT_NE(mCameraStatuses.find(in_cameraId), mCameraStatuses.end());
116 EXPECT_EQ(mCameraStatuses[in_cameraId], CameraDeviceStatus::STATUS_PRESENT);
117
118 if (in_status == CameraDeviceStatus::STATUS_PRESENT) {
119 auto res = mUnavailablePhysicalCameras[in_cameraId].erase(in_physicalCameraId);
120 EXPECT_EQ(res, 1);
121 } else {
122 auto res = mUnavailablePhysicalCameras[in_cameraId].emplace(in_physicalCameraId);
123 EXPECT_TRUE(res.second);
124 }
125 return ndk::ScopedAStatus::ok();
126 }
127
initializeStatuses(const std::vector<CameraStatusAndId> & statuses)128 void initializeStatuses(const std::vector<CameraStatusAndId>& statuses) {
129 Mutex::Autolock l(mLock);
130
131 for (auto& status : statuses) {
132 mCameraStatuses[status.cameraId] = status.deviceStatus;
133 for (auto& physicalId : status.unavailPhysicalCameraIds) {
134 mUnavailablePhysicalCameras[status.cameraId].emplace(physicalId);
135 }
136 }
137 }
138 };
139
140 // ICameraDeviceCallback implementation
141 class CameraDeviceCallback : public BnCameraDeviceCallback {
142 public:
143 enum LocalCameraDeviceStatus {
144 ERROR,
145 RUNNING,
146 RESULT_RECEIVED,
147 UNINITIALIZED,
148 REPEATING_REQUEST_ERROR,
149 };
150
151 protected:
152 bool mSupportsPartialResults = false;
153 int32_t mPartialResultCount = 0;
154 bool mError = false;
155 LocalCameraDeviceStatus mLastStatus = UNINITIALIZED;
156 mutable std::vector<LocalCameraDeviceStatus> mStatusesHit;
157 // stream id -> prepared count;
158 mutable std::unordered_map<int, int> mStreamsPreparedCount;
159 mutable Mutex mLock;
160 mutable Condition mStatusCondition;
161 mutable Condition mPreparedCondition;
162 mutable bool mIsIdle = false;
163
164 public:
CameraDeviceCallback(bool supportsPartialResults,int32_t partialResultCount)165 CameraDeviceCallback(bool supportsPartialResults, int32_t partialResultCount) :
166 mSupportsPartialResults(supportsPartialResults), mPartialResultCount(partialResultCount) {}
167
onDeviceError(ErrorCode in_errorCode,const CaptureResultExtras &)168 ndk::ScopedAStatus onDeviceError(ErrorCode in_errorCode,
169 const CaptureResultExtras& /*in_resultExtras*/) override {
170 ALOGE("%s: onDeviceError occurred with: %d", __FUNCTION__, static_cast<int>(in_errorCode));
171 Mutex::Autolock l(mLock);
172 mError = true;
173 mLastStatus = ERROR;
174 mStatusesHit.push_back(mLastStatus);
175 mStatusCondition.broadcast();
176 return ndk::ScopedAStatus::ok();
177 }
178
onDeviceIdle()179 ndk::ScopedAStatus onDeviceIdle() override {
180 Mutex::Autolock l(mLock);
181 mIsIdle = true;
182 mStatusCondition.broadcast();
183 return ndk::ScopedAStatus::ok();
184 }
185
onCaptureStarted(const CaptureResultExtras &,int64_t)186 ndk::ScopedAStatus onCaptureStarted(const CaptureResultExtras& /*in_resultExtras*/,
187 int64_t /*in_timestamp*/) override {
188 Mutex::Autolock l(mLock);
189 mLastStatus = RUNNING;
190 mIsIdle = false;
191 mStatusesHit.push_back(mLastStatus);
192 mStatusCondition.broadcast();
193 return ndk::ScopedAStatus::ok();
194 }
195
onResultReceived(const CaptureMetadataInfo &,const CaptureResultExtras & in_resultExtras,const std::vector<PhysicalCaptureResultInfo> &)196 ndk::ScopedAStatus onResultReceived(
197 const CaptureMetadataInfo& /*in_result*/, const CaptureResultExtras& in_resultExtras,
198 const std::vector<PhysicalCaptureResultInfo>& /*in_physicalCaptureResultInfos*/) override {
199 if (mSupportsPartialResults &&
200 (in_resultExtras.partialResultCount != mPartialResultCount)) {
201 ALOGV("%s: Ignoring requestId: %d parial count: %d", __FUNCTION__,
202 in_resultExtras.requestId, in_resultExtras.partialResultCount);
203 return ndk::ScopedAStatus::ok();
204 }
205 Mutex::Autolock l(mLock);
206 mLastStatus = RESULT_RECEIVED;
207 mStatusesHit.push_back(mLastStatus);
208 mStatusCondition.broadcast();
209 return ndk::ScopedAStatus::ok();
210 }
211
onRepeatingRequestError(int64_t,int32_t)212 ndk::ScopedAStatus onRepeatingRequestError(int64_t /*in_lastFrameNumber*/,
213 int32_t /*in_repeatingRequestId*/) override {
214 Mutex::Autolock l(mLock);
215 mLastStatus = REPEATING_REQUEST_ERROR;
216 mStatusesHit.push_back(mLastStatus);
217 mStatusCondition.broadcast();
218 return ndk::ScopedAStatus::ok();
219 }
220
onPrepared(int32_t streamId)221 ndk::ScopedAStatus onPrepared(int32_t streamId) override {
222 Mutex::Autolock l(mLock);
223 if (mStreamsPreparedCount.find(streamId) == mStreamsPreparedCount.end()) {
224 mStreamsPreparedCount[streamId] = 0;
225 }
226 mStreamsPreparedCount[streamId]++;
227 mPreparedCondition.broadcast();
228 return ndk::ScopedAStatus::ok();
229 }
230
onClientSharedAccessPriorityChanged(bool)231 ndk::ScopedAStatus onClientSharedAccessPriorityChanged(bool /*isPrimaryClient*/) override {
232 return ndk::ScopedAStatus::ok();
233 }
234
waitForPreparedCount(int streamId,int count) const235 bool waitForPreparedCount(int streamId, int count) const {
236 Mutex::Autolock l(mLock);
237 if ((mStreamsPreparedCount.find(streamId) != mStreamsPreparedCount.end()) &&
238 (mStreamsPreparedCount[streamId] == count)) {
239 return true;
240 }
241
242 while ((mStreamsPreparedCount.find(streamId) == mStreamsPreparedCount.end()) ||
243 (mStreamsPreparedCount[streamId] < count)) {
244 if (mPreparedCondition.waitRelative(mLock, IDLE_TIMEOUT) != android::OK) {
245 return false;
246 }
247 }
248 return (mStreamsPreparedCount[streamId] == count);
249 }
250
251 // Test helper functions:
waitForStatus(LocalCameraDeviceStatus status,int count) const252 bool waitForStatus(LocalCameraDeviceStatus status, int count) const {
253 Mutex::Autolock l(mLock);
254 while (std::count(mStatusesHit.begin(), mStatusesHit.end(), status) < count) {
255 if (mStatusCondition.waitRelative(mLock, IDLE_TIMEOUT) != android::OK) {
256 mStatusesHit.clear();
257 return false;
258 }
259 }
260 mStatusesHit.clear();
261 return true;
262 }
263
264 // There is a *very* slim change of onCaptureStarted gets delayed after onIdle in
265 // cameraserver. If that happens, this wait will become invalid.
waitForIdle() const266 bool waitForIdle() const {
267 Mutex::Autolock l(mLock);
268 while (!mIsIdle) {
269 if (mStatusCondition.waitRelative(mLock, IDLE_TIMEOUT) != android::OK) {
270 return false;
271 }
272 }
273
274 return true;
275 }
276 };
277
isCameraServiceDisabled()278 static bool isCameraServiceDisabled() {
279 return ::android::base::GetBoolProperty(kCameraServiceDisabledProperty, false);
280 }
281
convertFromAidlCloned(const AidlCameraMetadata & metadata,CameraMetadata * rawMetadata)282 static bool convertFromAidlCloned(const AidlCameraMetadata& metadata, CameraMetadata* rawMetadata) {
283 const camera_metadata* buffer = (camera_metadata_t*)(metadata.metadata.data());
284 size_t expectedSize = metadata.metadata.size();
285 int ret = validate_camera_metadata_structure(buffer, &expectedSize);
286 if (ret == OK || ret == CAMERA_METADATA_VALIDATION_SHIFTED) {
287 *rawMetadata = buffer; // assignment operator clones
288 } else {
289 ALOGE("%s: Malformed camera metadata received from caller", __FUNCTION__);
290 return false;
291 }
292 return true;
293 }
294
295 struct StreamConfiguration {
296 int32_t width = -1;
297 int32_t height = -1;
298 };
299
300 class VtsAidlCameraServiceTargetTest : public ::testing::TestWithParam<std::string> {
301 public:
SetUp()302 void SetUp() override {
303 if (isCameraServiceDisabled()) {
304 ALOGI("Camera service is disabled on the device");
305 GTEST_SKIP() << "Camera service disabled, skipping this test";
306 }
307
308 bool success = ABinderProcess_setThreadPoolMaxThreadCount(5);
309 ASSERT_TRUE(success);
310 ABinderProcess_startThreadPool();
311
312 SpAIBinder cameraServiceBinder =
313 SpAIBinder(AServiceManager_checkService(GetParam().c_str()));
314 ASSERT_NE(cameraServiceBinder.get(), nullptr);
315
316 std::shared_ptr<ICameraService> cameraService =
317 ICameraService::fromBinder(cameraServiceBinder);
318 ASSERT_NE(cameraService.get(), nullptr);
319 mCameraService = cameraService;
320 }
321
TearDown()322 void TearDown() override {}
323
createOutputConfigurationMinimal()324 static OutputConfiguration createOutputConfigurationMinimal() {
325 OutputConfiguration output;
326 output.rotation = OutputConfiguration::Rotation::R0;
327 output.windowGroupId = -1;
328 output.width = 0;
329 output.height = 0;
330 output.isDeferred = false;
331 return output;
332 }
333
334 // creates an outputConfiguration with no deferred streams
createOutputConfiguration(const std::vector<native_handle_t * > & nhs)335 static OutputConfiguration createOutputConfiguration(const std::vector<native_handle_t*>& nhs) {
336 OutputConfiguration output = createOutputConfigurationMinimal();
337 output.windowHandles.reserve(nhs.size());
338 for (auto nh : nhs) {
339 output.windowHandles.push_back(::android::makeToAidl(nh));
340 }
341 return output;
342 }
343
createOutputConfiguration(const std::vector<ANativeWindow * > & windows)344 static OutputConfiguration createOutputConfiguration(
345 const std::vector<ANativeWindow*>& windows) {
346 OutputConfiguration output = createOutputConfigurationMinimal();
347 auto& surfaces = output.surfaces;
348 surfaces.reserve(windows.size());
349 for (auto anw : windows) {
350 surfaces.emplace_back(anw);
351 }
352 return output;
353 }
354
initializeCaptureRequestPartial(CaptureRequest * captureRequest,int32_t streamId,const std::string & cameraId,size_t settingsSize)355 static void initializeCaptureRequestPartial(CaptureRequest* captureRequest, int32_t streamId,
356 const std::string& cameraId, size_t settingsSize) {
357 captureRequest->physicalCameraSettings.resize(1);
358 captureRequest->physicalCameraSettings[0].id = cameraId;
359 captureRequest->streamAndWindowIds.resize(1);
360 captureRequest->streamAndWindowIds[0].streamId = streamId;
361 captureRequest->streamAndWindowIds[0].windowId = 0;
362 // Write the settings metadata into the fmq.
363 captureRequest->physicalCameraSettings[0]
364 .settings.set<CaptureMetadataInfo::fmqMetadataSize>(settingsSize);
365 }
366
doesCapabilityExist(const CameraMetadata & characteristics,int capability)367 static bool doesCapabilityExist(const CameraMetadata& characteristics, int capability) {
368 camera_metadata_ro_entry rawEntry =
369 characteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
370 EXPECT_TRUE(rawEntry.count > 0);
371 for (size_t i = 0; i < rawEntry.count; i++) {
372 if (rawEntry.data.u8[i] == capability) {
373 return true;
374 }
375 }
376 return false;
377 }
378
isSecureOnlyDevice(const CameraMetadata & characteristics)379 static bool isSecureOnlyDevice(const CameraMetadata& characteristics) {
380 camera_metadata_ro_entry rawEntry =
381 characteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
382 EXPECT_TRUE(rawEntry.count > 0);
383 if (rawEntry.count == 1 &&
384 rawEntry.data.u8[0] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA) {
385 return true;
386 }
387 return false;
388 }
389
390 // Return the first advertised available stream sizes for the given format
391 // and use-case.
getStreamConfiguration(const CameraMetadata & characteristics,uint32_t tag,int32_t chosenUse,int32_t chosenFormat)392 static StreamConfiguration getStreamConfiguration(const CameraMetadata& characteristics,
393 uint32_t tag, int32_t chosenUse,
394 int32_t chosenFormat) {
395 camera_metadata_ro_entry rawEntry = characteristics.find(tag);
396 StreamConfiguration streamConfig;
397 const size_t STREAM_FORMAT_OFFSET = 0;
398 const size_t STREAM_WIDTH_OFFSET = 1;
399 const size_t STREAM_HEIGHT_OFFSET = 2;
400 const size_t STREAM_INOUT_OFFSET = 3;
401 const size_t STREAM_CONFIG_SIZE = 4;
402 if (rawEntry.count < STREAM_CONFIG_SIZE) {
403 return streamConfig;
404 }
405 EXPECT_TRUE((rawEntry.count % STREAM_CONFIG_SIZE) == 0);
406 for (size_t i = 0; i < rawEntry.count; i += STREAM_CONFIG_SIZE) {
407 int32_t format = rawEntry.data.i32[i + STREAM_FORMAT_OFFSET];
408 int32_t use = rawEntry.data.i32[i + STREAM_INOUT_OFFSET];
409 if (format == chosenFormat && use == chosenUse) {
410 streamConfig.width = rawEntry.data.i32[i + STREAM_WIDTH_OFFSET];
411 streamConfig.height = rawEntry.data.i32[i + STREAM_HEIGHT_OFFSET];
412 return streamConfig;
413 }
414 }
415 return streamConfig;
416 }
417 template <class Func>
BasicCameraTests(bool prepareWindows,Func prepareOutputConfiguration)418 void BasicCameraTests(bool prepareWindows, Func prepareOutputConfiguration) {
419 std::shared_ptr<CameraServiceListener> listener =
420 ::ndk::SharedRefBase::make<CameraServiceListener>();
421 std::vector<CameraStatusAndId> cameraStatuses;
422
423 ndk::ScopedAStatus ret = mCameraService->addListener(listener, &cameraStatuses);
424 EXPECT_TRUE(ret.isOk());
425 listener->initializeStatuses(cameraStatuses);
426 for (const auto& it : cameraStatuses) {
427 CameraMetadata rawMetadata;
428 if (it.deviceStatus != CameraDeviceStatus::STATUS_PRESENT) {
429 continue;
430 }
431 AidlCameraMetadata aidlMetadata;
432 ret = mCameraService->getCameraCharacteristics(it.cameraId, &aidlMetadata);
433 EXPECT_TRUE(ret.isOk());
434 bool cStatus = convertFromAidlCloned(aidlMetadata, &rawMetadata);
435 EXPECT_TRUE(cStatus);
436 EXPECT_FALSE(rawMetadata.isEmpty());
437
438 bool partialResultSupported = false;
439 int32_t partialResultCount = 0;
440 auto entry = rawMetadata.find(ANDROID_REQUEST_PARTIAL_RESULT_COUNT);
441 if (entry.count > 0) {
442 partialResultCount = entry.data.i32[0];
443 partialResultSupported = true;
444 }
445
446 std::shared_ptr<CameraDeviceCallback> callbacks =
447 ndk::SharedRefBase::make<CameraDeviceCallback>(partialResultSupported,
448 partialResultCount);
449 std::shared_ptr<ICameraDeviceUser> deviceRemote = nullptr;
450 ret = mCameraService->connectDevice(callbacks, it.cameraId, &deviceRemote);
451 EXPECT_TRUE(ret.isOk());
452 EXPECT_TRUE(deviceRemote != nullptr);
453
454 MQDescriptor<int8_t, SynchronizedReadWrite> mqDesc;
455 ret = deviceRemote->getCaptureRequestMetadataQueue(&mqDesc);
456 EXPECT_TRUE(ret.isOk());
457 std::shared_ptr<RequestMetadataQueue> requestMQ =
458 std::make_shared<RequestMetadataQueue>(mqDesc);
459 EXPECT_TRUE(requestMQ->isValid());
460 EXPECT_TRUE((requestMQ->availableToWrite() >= 0));
461
462 bool isDepthOnlyDevice =
463 !doesCapabilityExist(rawMetadata,
464 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) &&
465 doesCapabilityExist(rawMetadata,
466 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT);
467 int chosenImageFormat = AIMAGE_FORMAT_YUV_420_888;
468 int chosenImageWidth = kVGAImageWidth;
469 int chosenImageHeight = kVGAImageHeight;
470 bool isSecureOnlyCamera = isSecureOnlyDevice(rawMetadata);
471 status_t mStatus = OK;
472 scoped_unique_image_reader readerPtr(nullptr, AImageReader_delete);
473
474 if (isSecureOnlyCamera) {
475 AImageReader* reader = nullptr;
476 StreamConfiguration secureStreamConfig = getStreamConfiguration(
477 rawMetadata, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
478 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
479 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED);
480 EXPECT_TRUE(secureStreamConfig.width != -1);
481 EXPECT_TRUE(secureStreamConfig.height != -1);
482 chosenImageFormat = AIMAGE_FORMAT_PRIVATE;
483 chosenImageWidth = secureStreamConfig.width;
484 chosenImageHeight = secureStreamConfig.height;
485 mStatus = AImageReader_newWithUsage(
486 chosenImageWidth, chosenImageHeight, chosenImageFormat,
487 AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT, kCaptureRequestCount, &reader);
488 EXPECT_EQ(mStatus, AMEDIA_OK);
489 readerPtr = scoped_unique_image_reader(reader, AImageReader_delete);
490 } else {
491 if (isDepthOnlyDevice) {
492 StreamConfiguration depthStreamConfig = getStreamConfiguration(
493 rawMetadata, ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS,
494 ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT,
495 HAL_PIXEL_FORMAT_Y16);
496 EXPECT_TRUE(depthStreamConfig.width != -1);
497 EXPECT_TRUE(depthStreamConfig.height != -1);
498 chosenImageFormat = AIMAGE_FORMAT_DEPTH16;
499 chosenImageWidth = depthStreamConfig.width;
500 chosenImageHeight = depthStreamConfig.height;
501 }
502 AImageReader* reader = nullptr;
503 mStatus = AImageReader_new(chosenImageWidth, chosenImageHeight, chosenImageFormat,
504 kCaptureRequestCount, &reader);
505 EXPECT_EQ(mStatus, AMEDIA_OK);
506 readerPtr = scoped_unique_image_reader(reader, AImageReader_delete);
507 }
508
509 OutputConfiguration output = prepareOutputConfiguration(readerPtr);
510
511 ret = deviceRemote->beginConfigure();
512 EXPECT_TRUE(ret.isOk());
513
514 int32_t streamId = -1;
515 ret = deviceRemote->createStream(output, &streamId);
516 EXPECT_TRUE(ret.isOk());
517 EXPECT_TRUE(streamId >= 0);
518
519 AidlCameraMetadata sessionParams;
520 ret = deviceRemote->endConfigure(StreamConfigurationMode::NORMAL_MODE, sessionParams,
521 systemTime());
522 EXPECT_TRUE(ret.isOk());
523
524 if (prepareWindows) {
525 ret = deviceRemote->prepare(streamId);
526 EXPECT_TRUE(ret.isOk());
527 EXPECT_TRUE(callbacks->waitForPreparedCount(streamId, 1));
528
529 ret = deviceRemote->prepare(streamId);
530 // We should get another callback;
531 EXPECT_TRUE(ret.isOk());
532 EXPECT_TRUE(callbacks->waitForPreparedCount(streamId, 2));
533 }
534 AidlCameraMetadata aidlSettingsMetadata;
535 ret = deviceRemote->createDefaultRequest(TemplateId::PREVIEW, &aidlSettingsMetadata);
536 EXPECT_TRUE(ret.isOk());
537 EXPECT_GE(aidlSettingsMetadata.metadata.size(), 0);
538 std::vector<CaptureRequest> captureRequests;
539 captureRequests.resize(kNumRequests);
540 for (int i = 0; i < kNumRequests; i++) {
541 CaptureRequest& captureRequest = captureRequests[i];
542 initializeCaptureRequestPartial(&captureRequest, streamId, it.cameraId,
543 aidlSettingsMetadata.metadata.size());
544 // Write the settings metadata into the fmq.
545 bool written = requestMQ->write(
546 reinterpret_cast<int8_t*>(aidlSettingsMetadata.metadata.data()),
547 aidlSettingsMetadata.metadata.size());
548 EXPECT_TRUE(written);
549 }
550
551 SubmitInfo info;
552 // Test a single capture
553 ret = deviceRemote->submitRequestList(captureRequests, false, &info);
554 EXPECT_TRUE(ret.isOk());
555 EXPECT_GE(info.requestId, 0);
556 EXPECT_TRUE(callbacks->waitForStatus(
557 CameraDeviceCallback::LocalCameraDeviceStatus::RESULT_RECEIVED, kNumRequests));
558 EXPECT_TRUE(callbacks->waitForIdle());
559
560 // Test repeating requests
561 CaptureRequest captureRequest;
562 initializeCaptureRequestPartial(&captureRequest, streamId, it.cameraId,
563 aidlSettingsMetadata.metadata.size());
564
565 bool written =
566 requestMQ->write(reinterpret_cast<int8_t*>(aidlSettingsMetadata.metadata.data()),
567 aidlSettingsMetadata.metadata.size());
568 EXPECT_TRUE(written);
569
570 ret = deviceRemote->submitRequestList({captureRequest}, true, &info);
571 EXPECT_TRUE(ret.isOk());
572 EXPECT_TRUE(callbacks->waitForStatus(
573 CameraDeviceCallback::LocalCameraDeviceStatus::RESULT_RECEIVED, 1));
574
575 int64_t lastFrameNumber = -1;
576 ret = deviceRemote->cancelRepeatingRequest(&lastFrameNumber);
577 EXPECT_TRUE(ret.isOk());
578 EXPECT_GE(lastFrameNumber, 0);
579
580 // Test waitUntilIdle()
581 auto statusRet = deviceRemote->waitUntilIdle();
582 EXPECT_TRUE(statusRet.isOk());
583
584 // Test deleteStream()
585 statusRet = deviceRemote->deleteStream(streamId);
586 EXPECT_TRUE(statusRet.isOk());
587
588 ret = deviceRemote->disconnect();
589 EXPECT_TRUE(ret.isOk());
590 }
591 ret = mCameraService->removeListener(listener);
592 EXPECT_TRUE(ret.isOk());
593 }
594
595 std::shared_ptr<ICameraService> mCameraService = nullptr;
596 };
597
598 // Basic AIDL calls for ICameraService
TEST_P(VtsAidlCameraServiceTargetTest,BasicCameraLifeCycleTest)599 TEST_P(VtsAidlCameraServiceTargetTest, BasicCameraLifeCycleTest) {
600 auto prepareOutputConfigurationWh = [](scoped_unique_image_reader& readerPtr) {
601 native_handle_t* wh = nullptr;
602 status_t status = AImageReader_getWindowNativeHandle(readerPtr.get(), &wh);
603 EXPECT_TRUE(status == AMEDIA_OK && wh != nullptr);
604
605 return createOutputConfiguration({wh});
606 };
607 auto prepareOutputConfigurationSurface = [](scoped_unique_image_reader& readerPtr) {
608 ANativeWindow* anw = nullptr;
609 status_t status = AImageReader_getWindow(readerPtr.get(), &anw);
610 EXPECT_TRUE(status == AMEDIA_OK && anw != nullptr);
611
612 return createOutputConfiguration({anw});
613 };
614
615 if (isHidlSupported()) {
616 BasicCameraTests(/*prepareWindows*/ false, prepareOutputConfigurationWh);
617 BasicCameraTests(/*prepareWindows*/ true, prepareOutputConfigurationWh);
618 }
619 // The framework supports AIDL interface version 2
620 BasicCameraTests(/*prepareWindows*/ false, prepareOutputConfigurationSurface);
621 BasicCameraTests(/*prepareWindows*/ true, prepareOutputConfigurationSurface);
622 }
623
TEST_P(VtsAidlCameraServiceTargetTest,CameraServiceListenerTest)624 TEST_P(VtsAidlCameraServiceTargetTest, CameraServiceListenerTest) {
625 std::shared_ptr<CameraServiceListener> listener =
626 ndk::SharedRefBase::make<CameraServiceListener>();
627 if (mCameraService == nullptr) return;
628
629 std::vector<CameraStatusAndId> cameraStatuses;
630 ndk::ScopedAStatus ret = mCameraService->addListener(listener, &cameraStatuses);
631 EXPECT_TRUE(ret.isOk());
632 listener->initializeStatuses(cameraStatuses);
633
634 for (const auto& it : cameraStatuses) {
635 CameraMetadata rawMetadata;
636 AidlCameraMetadata aidlCameraMetadata;
637 ret = mCameraService->getCameraCharacteristics(it.cameraId, &aidlCameraMetadata);
638 EXPECT_TRUE(ret.isOk());
639 bool cStatus = convertFromAidlCloned(aidlCameraMetadata, &rawMetadata);
640 EXPECT_TRUE(cStatus);
641 EXPECT_FALSE(rawMetadata.isEmpty());
642
643 bool isLogicalCamera = doesCapabilityExist(
644 rawMetadata, ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA);
645 if (!isLogicalCamera) {
646 EXPECT_TRUE(it.unavailPhysicalCameraIds.empty());
647 continue;
648 }
649 camera_metadata_entry entry = rawMetadata.find(ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
650 EXPECT_GT(entry.count, 0);
651
652 std::unordered_set<std::string> validPhysicalIds;
653 const uint8_t* ids = entry.data.u8;
654 size_t start = 0;
655 for (size_t i = 0; i < entry.count; i++) {
656 if (ids[i] == '\0') {
657 if (start != i) {
658 std::string currentId(reinterpret_cast<const char*>(ids + start));
659 validPhysicalIds.emplace(currentId);
660 }
661 start = i + 1;
662 }
663 }
664
665 std::unordered_set<std::string> unavailablePhysicalIds(it.unavailPhysicalCameraIds.begin(),
666 it.unavailPhysicalCameraIds.end());
667 EXPECT_EQ(unavailablePhysicalIds.size(), it.unavailPhysicalCameraIds.size());
668 for (auto& unavailablePhysicalId : unavailablePhysicalIds) {
669 EXPECT_NE(validPhysicalIds.find(unavailablePhysicalId), validPhysicalIds.end());
670 }
671 }
672
673 ret = mCameraService->removeListener(listener);
674 EXPECT_TRUE(ret.isOk());
675 }
676
TEST_P(VtsAidlCameraServiceTargetTest,SharedCameraTest)677 TEST_P(VtsAidlCameraServiceTargetTest, SharedCameraTest) {
678 if (mCameraService == nullptr) {
679 ALOGE("Cameraservice is not available");
680 return;
681 }
682
683 std::shared_ptr<CameraServiceListener> listener =
684 ::ndk::SharedRefBase::make<CameraServiceListener>();
685 std::vector<CameraStatusAndId> cameraStatuses;
686 ndk::ScopedAStatus ret = mCameraService->addListener(listener, &cameraStatuses);
687 EXPECT_TRUE(ret.isOk());
688 listener->initializeStatuses(cameraStatuses);
689 for (const auto& it : cameraStatuses) {
690 if (it.deviceStatus != CameraDeviceStatus::STATUS_PRESENT) {
691 continue;
692 }
693 AidlCameraMetadata aidlMetadata;
694 CameraMetadata rawMetadata;
695 ret = mCameraService->getCameraCharacteristics(it.cameraId, &aidlMetadata);
696 EXPECT_TRUE(ret.isOk());
697 bool cStatus = convertFromAidlCloned(aidlMetadata, &rawMetadata);
698 EXPECT_TRUE(cStatus);
699 EXPECT_FALSE(rawMetadata.isEmpty());
700
701 // Shared camera is only supported for system cameras.
702 bool isSystemCamera =
703 doesCapabilityExist(rawMetadata, ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA);
704 if (!isSystemCamera) {
705 continue;
706 }
707
708 auto entry = rawMetadata.find(ANDROID_SHARED_SESSION_OUTPUT_CONFIGURATIONS);
709 if (entry.count <= 0) {
710 continue;
711 }
712 int32_t width, height, format, physicalCamIdLen;
713 width = -1;
714
715 // From frameworks/av/camera/include/camera/camera2/OutputConfiguration.h
716 const int SURFACE_TYPE_IMAGE_READER = 4;
717 for (size_t i = 0; i < entry.count;) {
718 if (entry.data.i64[i] == SURFACE_TYPE_IMAGE_READER) {
719 width = entry.data.i64[i + 1];
720 height = entry.data.i64[i + 2];
721 format = entry.data.i64[i + 3];
722 break;
723 }
724 physicalCamIdLen = i + 10;
725 i += 11 + physicalCamIdLen;
726 }
727
728 if (width == -1) {
729 continue;
730 }
731
732 bool partialResultSupported = false;
733 int32_t partialResultCount = 0;
734 entry = rawMetadata.find(ANDROID_REQUEST_PARTIAL_RESULT_COUNT);
735 if (entry.count > 0) {
736 partialResultCount = entry.data.i32[0];
737 partialResultSupported = true;
738 }
739
740 std::shared_ptr<CameraDeviceCallback> callbacks =
741 ndk::SharedRefBase::make<CameraDeviceCallback>(partialResultSupported,
742 partialResultCount);
743 std::shared_ptr<ICameraDeviceUser> deviceRemote = nullptr;
744 ret = mCameraService->connectDeviceV2(callbacks, it.cameraId, /*sharedMode*/ true,
745 &deviceRemote);
746 EXPECT_TRUE(ret.isOk());
747 EXPECT_TRUE(deviceRemote != nullptr);
748 bool isPrimaryClient;
749 ret = deviceRemote->isPrimaryClient(&isPrimaryClient);
750 EXPECT_TRUE(ret.isOk());
751 // Since this is the only client, it should be the primary client.
752 EXPECT_TRUE(isPrimaryClient);
753 status_t status = OK;
754 AImageReader* reader = nullptr;
755 const int NUM_TEST_IMAGES = 10;
756 status = AImageReader_new(width, height, format, NUM_TEST_IMAGES, &reader);
757 EXPECT_EQ(status, AMEDIA_OK);
758 scoped_unique_image_reader readerPtr =
759 scoped_unique_image_reader(reader, AImageReader_delete);
760 ANativeWindow* anw = nullptr;
761 status = AImageReader_getWindow(readerPtr.get(), &anw);
762 EXPECT_TRUE(status == AMEDIA_OK && anw != nullptr);
763
764 OutputConfiguration output = createOutputConfiguration({anw});
765
766 ret = deviceRemote->beginConfigure();
767 EXPECT_TRUE(ret.isOk());
768
769 int32_t streamId = -1;
770 ret = deviceRemote->createStream(output, &streamId);
771 EXPECT_TRUE(ret.isOk());
772 EXPECT_TRUE(streamId >= 0);
773
774 AidlCameraMetadata sessionParams;
775 ret = deviceRemote->endConfigure(StreamConfigurationMode::NORMAL_MODE, sessionParams,
776 systemTime());
777 EXPECT_TRUE(ret.isOk());
778
779 SubmitInfo info;
780 std::vector<int> streamIds;
781 std::vector<int> surfaceIds;
782 streamIds.push_back(streamId);
783 surfaceIds.push_back(0);
784 ret = deviceRemote->startStreaming(streamIds, surfaceIds, &info);
785 EXPECT_TRUE(ret.isOk());
786 EXPECT_GE(info.requestId, 0);
787 EXPECT_TRUE(callbacks->waitForStatus(
788 CameraDeviceCallback::LocalCameraDeviceStatus::RESULT_RECEIVED, 1));
789
790 int64_t lastFrameNumber = -1;
791 ret = deviceRemote->cancelRepeatingRequest(&lastFrameNumber);
792 EXPECT_TRUE(ret.isOk());
793 EXPECT_GE(lastFrameNumber, 0);
794
795 // Test waitUntilIdle()
796 ret = deviceRemote->waitUntilIdle();
797 EXPECT_TRUE(ret.isOk());
798
799 // Test deleteStream()
800 ret = deviceRemote->deleteStream(streamId);
801 EXPECT_TRUE(ret.isOk());
802
803 ret = deviceRemote->disconnect();
804 EXPECT_TRUE(ret.isOk());
805 }
806 ret = mCameraService->removeListener(listener);
807 EXPECT_TRUE(ret.isOk());
808 }
809
810 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VtsAidlCameraServiceTargetTest);
811 INSTANTIATE_TEST_SUITE_P(PerInstance, VtsAidlCameraServiceTargetTest,
812 testing::ValuesIn({std::string(ICameraService::descriptor) + "/default"}),
813 android::hardware::PrintInstanceNameToString);
814
815 } // namespace android
816