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/binder_manager.h>
33 #include <android/binder_process.h>
34 #include <android/log.h>
35 #include <fmq/AidlMessageQueue.h>
36 #include <gtest/gtest.h>
37 #include <hidl/GtestPrinter.h>
38 #include <media/NdkImageReader.h>
39 #include <stdint.h>
40 #include <system/camera_metadata.h>
41 #include <system/graphics.h>
42 #include <utils/Condition.h>
43 #include <utils/Mutex.h>
44 #include <utils/StrongPointer.h>
45
46 #include <algorithm>
47 #include <string>
48 #include <unordered_map>
49 #include <unordered_set>
50 #include <vector>
51
52 namespace android {
53
54 using ::aidl::android::frameworks::cameraservice::device::BnCameraDeviceCallback;
55 using ::aidl::android::frameworks::cameraservice::device::CaptureMetadataInfo;
56 using ::aidl::android::frameworks::cameraservice::device::CaptureRequest;
57 using ::aidl::android::frameworks::cameraservice::device::CaptureResultExtras;
58 using ::aidl::android::frameworks::cameraservice::device::ErrorCode;
59 using ::aidl::android::frameworks::cameraservice::device::ICameraDeviceUser;
60 using ::aidl::android::frameworks::cameraservice::device::OutputConfiguration;
61 using ::aidl::android::frameworks::cameraservice::device::PhysicalCaptureResultInfo;
62 using ::aidl::android::frameworks::cameraservice::device::StreamConfigurationMode;
63 using ::aidl::android::frameworks::cameraservice::device::SubmitInfo;
64 using ::aidl::android::frameworks::cameraservice::device::TemplateId;
65 using ::aidl::android::frameworks::cameraservice::service::BnCameraServiceListener;
66 using ::aidl::android::frameworks::cameraservice::service::CameraDeviceStatus;
67 using ::aidl::android::frameworks::cameraservice::service::CameraStatusAndId;
68 using ::aidl::android::frameworks::cameraservice::service::ICameraService;
69 using ::aidl::android::hardware::common::fmq::MQDescriptor;
70 using ::android::hardware::camera::common::helper::CameraMetadata;
71 using ::ndk::SpAIBinder;
72
73 using AidlCameraMetadata = ::aidl::android::frameworks::cameraservice::device::CameraMetadata;
74 using RequestMetadataQueue = AidlMessageQueue<int8_t, SynchronizedReadWrite>;
75
76 static constexpr int kCaptureRequestCount = 10;
77 static constexpr int kVGAImageWidth = 640;
78 static constexpr int kVGAImageHeight = 480;
79 static constexpr int kNumRequests = 4;
80
81 #define IDLE_TIMEOUT 2000000000 // ns
82
83 class CameraServiceListener : public BnCameraServiceListener {
84 std::map<std::string, CameraDeviceStatus> mCameraStatuses;
85 // map: logical camera id -> set of unavailable physical camera ids
86 std::map<std::string, std::set<std::string>> mUnavailablePhysicalCameras;
87 mutable Mutex mLock;
88
89 public:
90 ~CameraServiceListener() override = default;
91
onStatusChanged(CameraDeviceStatus in_status,const std::string & in_cameraId)92 ndk::ScopedAStatus onStatusChanged(CameraDeviceStatus in_status,
93 const std::string& in_cameraId) override {
94 Mutex::Autolock l(mLock);
95 mCameraStatuses[in_cameraId] = in_status;
96 return ndk::ScopedAStatus::ok();
97 }
98
onPhysicalCameraStatusChanged(CameraDeviceStatus in_status,const std::string & in_cameraId,const std::string & in_physicalCameraId)99 ndk::ScopedAStatus onPhysicalCameraStatusChanged(
100 CameraDeviceStatus in_status, const std::string& in_cameraId,
101 const std::string& in_physicalCameraId) override {
102 Mutex::Autolock l(mLock);
103 ALOGI("%s: Physical camera %s : %s status changed to %d", __FUNCTION__, in_cameraId.c_str(),
104 in_physicalCameraId.c_str(), in_status);
105
106 EXPECT_NE(mCameraStatuses.find(in_cameraId), mCameraStatuses.end());
107 EXPECT_EQ(mCameraStatuses[in_cameraId], CameraDeviceStatus::STATUS_PRESENT);
108
109 if (in_status == CameraDeviceStatus::STATUS_PRESENT) {
110 auto res = mUnavailablePhysicalCameras[in_cameraId].erase(in_physicalCameraId);
111 EXPECT_EQ(res, 1);
112 } else {
113 auto res = mUnavailablePhysicalCameras[in_cameraId].emplace(in_physicalCameraId);
114 EXPECT_TRUE(res.second);
115 }
116 return ndk::ScopedAStatus::ok();
117 }
118
initializeStatuses(const std::vector<CameraStatusAndId> & statuses)119 void initializeStatuses(const std::vector<CameraStatusAndId>& statuses) {
120 Mutex::Autolock l(mLock);
121
122 for (auto& status : statuses) {
123 mCameraStatuses[status.cameraId] = status.deviceStatus;
124 for (auto& physicalId : status.unavailPhysicalCameraIds) {
125 mUnavailablePhysicalCameras[status.cameraId].emplace(physicalId);
126 }
127 }
128 }
129 };
130
131 // ICameraDeviceCallback implementation
132 class CameraDeviceCallback : public BnCameraDeviceCallback {
133 public:
134 enum LocalCameraDeviceStatus {
135 IDLE,
136 ERROR,
137 RUNNING,
138 RESULT_RECEIVED,
139 UNINITIALIZED,
140 REPEATING_REQUEST_ERROR,
141 };
142
143 protected:
144 bool mError = false;
145 LocalCameraDeviceStatus mLastStatus = UNINITIALIZED;
146 mutable std::vector<LocalCameraDeviceStatus> mStatusesHit;
147 // stream id -> prepared count;
148 mutable std::unordered_map<int, int> mStreamsPreparedCount;
149 mutable Mutex mLock;
150 mutable Condition mStatusCondition;
151 mutable Condition mPreparedCondition;
152
153 public:
CameraDeviceCallback()154 CameraDeviceCallback() {}
155
onDeviceError(ErrorCode in_errorCode,const CaptureResultExtras &)156 ndk::ScopedAStatus onDeviceError(ErrorCode in_errorCode,
157 const CaptureResultExtras& /*in_resultExtras*/) override {
158 ALOGE("%s: onDeviceError occurred with: %d", __FUNCTION__, static_cast<int>(in_errorCode));
159 Mutex::Autolock l(mLock);
160 mError = true;
161 mLastStatus = ERROR;
162 mStatusesHit.push_back(mLastStatus);
163 mStatusCondition.broadcast();
164 return ndk::ScopedAStatus::ok();
165 }
166
onDeviceIdle()167 ndk::ScopedAStatus onDeviceIdle() override {
168 Mutex::Autolock l(mLock);
169 mLastStatus = IDLE;
170 mStatusesHit.push_back(mLastStatus);
171 mStatusCondition.broadcast();
172 return ndk::ScopedAStatus::ok();
173 }
174
onCaptureStarted(const CaptureResultExtras &,int64_t)175 ndk::ScopedAStatus onCaptureStarted(const CaptureResultExtras& /*in_resultExtras*/,
176 int64_t /*in_timestamp*/) override {
177 Mutex::Autolock l(mLock);
178 mLastStatus = RUNNING;
179 mStatusesHit.push_back(mLastStatus);
180 mStatusCondition.broadcast();
181 return ndk::ScopedAStatus::ok();
182 }
183
onResultReceived(const CaptureMetadataInfo &,const CaptureResultExtras &,const std::vector<PhysicalCaptureResultInfo> &)184 ndk::ScopedAStatus onResultReceived(
185 const CaptureMetadataInfo& /*in_result*/, const CaptureResultExtras& /*in_resultExtras*/,
186 const std::vector<PhysicalCaptureResultInfo>& /*in_physicalCaptureResultInfos*/) override {
187 Mutex::Autolock l(mLock);
188 mLastStatus = RESULT_RECEIVED;
189 mStatusesHit.push_back(mLastStatus);
190 mStatusCondition.broadcast();
191 return ndk::ScopedAStatus::ok();
192 }
193
onRepeatingRequestError(int64_t,int32_t)194 ndk::ScopedAStatus onRepeatingRequestError(int64_t /*in_lastFrameNumber*/,
195 int32_t /*in_repeatingRequestId*/) override {
196 Mutex::Autolock l(mLock);
197 mLastStatus = REPEATING_REQUEST_ERROR;
198 mStatusesHit.push_back(mLastStatus);
199 mStatusCondition.broadcast();
200 return ndk::ScopedAStatus::ok();
201 }
202
onPrepared(int32_t streamId)203 ndk::ScopedAStatus onPrepared(int32_t streamId) override {
204 Mutex::Autolock l(mLock);
205 if (mStreamsPreparedCount.find(streamId) == mStreamsPreparedCount.end()) {
206 mStreamsPreparedCount[streamId] = 0;
207 }
208 mStreamsPreparedCount[streamId]++;
209 mPreparedCondition.broadcast();
210 return ndk::ScopedAStatus::ok();
211 }
212
waitForPreparedCount(int streamId,int count) const213 bool waitForPreparedCount(int streamId, int count) const {
214 Mutex::Autolock l(mLock);
215 if ((mStreamsPreparedCount.find(streamId) != mStreamsPreparedCount.end()) &&
216 (mStreamsPreparedCount[streamId] == count)) {
217 return true;
218 }
219
220 while ((mStreamsPreparedCount.find(streamId) == mStreamsPreparedCount.end()) ||
221 (mStreamsPreparedCount[streamId] < count)) {
222 if (mPreparedCondition.waitRelative(mLock, IDLE_TIMEOUT) != android::OK) {
223 return false;
224 }
225 }
226 return (mStreamsPreparedCount[streamId] == count);
227 }
228
229 // Test helper functions:
waitForStatus(LocalCameraDeviceStatus status) const230 bool waitForStatus(LocalCameraDeviceStatus status) const {
231 Mutex::Autolock l(mLock);
232 if (mLastStatus == status) {
233 return true;
234 }
235
236 while (std::find(mStatusesHit.begin(), mStatusesHit.end(), status) == mStatusesHit.end()) {
237 if (mStatusCondition.waitRelative(mLock, IDLE_TIMEOUT) != android::OK) {
238 mStatusesHit.clear();
239 return false;
240 }
241 }
242 mStatusesHit.clear();
243
244 return true;
245 }
246
waitForIdle() const247 bool waitForIdle() const { return waitForStatus(IDLE); }
248 };
249
convertFromAidlCloned(const AidlCameraMetadata & metadata,CameraMetadata * rawMetadata)250 static bool convertFromAidlCloned(const AidlCameraMetadata& metadata, CameraMetadata* rawMetadata) {
251 const camera_metadata* buffer = (camera_metadata_t*)(metadata.metadata.data());
252 size_t expectedSize = metadata.metadata.size();
253 int ret = validate_camera_metadata_structure(buffer, &expectedSize);
254 if (ret == OK || ret == CAMERA_METADATA_VALIDATION_SHIFTED) {
255 *rawMetadata = buffer; // assignment operator clones
256 } else {
257 ALOGE("%s: Malformed camera metadata received from caller", __FUNCTION__);
258 return false;
259 }
260 return true;
261 }
262
263 struct StreamConfiguration {
264 int32_t width = -1;
265 int32_t height = -1;
266 };
267
268 class VtsAidlCameraServiceTargetTest : public ::testing::TestWithParam<std::string> {
269 public:
SetUp()270 void SetUp() override {
271 bool success = ABinderProcess_setThreadPoolMaxThreadCount(5);
272 ASSERT_TRUE(success);
273 ABinderProcess_startThreadPool();
274
275 SpAIBinder cameraServiceBinder =
276 SpAIBinder(AServiceManager_checkService(GetParam().c_str()));
277 ASSERT_NE(cameraServiceBinder.get(), nullptr);
278
279 std::shared_ptr<ICameraService> cameraService =
280 ICameraService::fromBinder(cameraServiceBinder);
281 ASSERT_NE(cameraService.get(), nullptr);
282 mCameraService = cameraService;
283 }
284
TearDown()285 void TearDown() override {}
286
287 // creates an outputConfiguration with no deferred streams
createOutputConfiguration(const std::vector<native_handle_t * > & nhs)288 static OutputConfiguration createOutputConfiguration(const std::vector<native_handle_t*>& nhs) {
289 OutputConfiguration output;
290 output.rotation = OutputConfiguration::Rotation::R0;
291 output.windowGroupId = -1;
292 output.width = 0;
293 output.height = 0;
294 output.isDeferred = false;
295 output.windowHandles.reserve(nhs.size());
296 for (auto nh : nhs) {
297 output.windowHandles.push_back(::android::makeToAidl(nh));
298 }
299 return output;
300 }
301
initializeCaptureRequestPartial(CaptureRequest * captureRequest,int32_t streamId,const std::string & cameraId,size_t settingsSize)302 static void initializeCaptureRequestPartial(CaptureRequest* captureRequest, int32_t streamId,
303 const std::string& cameraId, size_t settingsSize) {
304 captureRequest->physicalCameraSettings.resize(1);
305 captureRequest->physicalCameraSettings[0].id = cameraId;
306 captureRequest->streamAndWindowIds.resize(1);
307 captureRequest->streamAndWindowIds[0].streamId = streamId;
308 captureRequest->streamAndWindowIds[0].windowId = 0;
309 // Write the settings metadata into the fmq.
310 captureRequest->physicalCameraSettings[0]
311 .settings.set<CaptureMetadataInfo::fmqMetadataSize>(settingsSize);
312 }
313
doesCapabilityExist(const CameraMetadata & characteristics,int capability)314 static bool doesCapabilityExist(const CameraMetadata& characteristics, int capability) {
315 camera_metadata_ro_entry rawEntry =
316 characteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
317 EXPECT_TRUE(rawEntry.count > 0);
318 for (size_t i = 0; i < rawEntry.count; i++) {
319 if (rawEntry.data.u8[i] == capability) {
320 return true;
321 }
322 }
323 return false;
324 }
325
isSecureOnlyDevice(const CameraMetadata & characteristics)326 static bool isSecureOnlyDevice(const CameraMetadata& characteristics) {
327 camera_metadata_ro_entry rawEntry =
328 characteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
329 EXPECT_TRUE(rawEntry.count > 0);
330 if (rawEntry.count == 1 &&
331 rawEntry.data.u8[0] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA) {
332 return true;
333 }
334 return false;
335 }
336
337 // Return the first advertised available stream sizes for the given format
338 // and use-case.
getStreamConfiguration(const CameraMetadata & characteristics,uint32_t tag,int32_t chosenUse,int32_t chosenFormat)339 static StreamConfiguration getStreamConfiguration(const CameraMetadata& characteristics,
340 uint32_t tag, int32_t chosenUse,
341 int32_t chosenFormat) {
342 camera_metadata_ro_entry rawEntry = characteristics.find(tag);
343 StreamConfiguration streamConfig;
344 const size_t STREAM_FORMAT_OFFSET = 0;
345 const size_t STREAM_WIDTH_OFFSET = 1;
346 const size_t STREAM_HEIGHT_OFFSET = 2;
347 const size_t STREAM_INOUT_OFFSET = 3;
348 const size_t STREAM_CONFIG_SIZE = 4;
349 if (rawEntry.count < STREAM_CONFIG_SIZE) {
350 return streamConfig;
351 }
352 EXPECT_TRUE((rawEntry.count % STREAM_CONFIG_SIZE) == 0);
353 for (size_t i = 0; i < rawEntry.count; i += STREAM_CONFIG_SIZE) {
354 int32_t format = rawEntry.data.i32[i + STREAM_FORMAT_OFFSET];
355 int32_t use = rawEntry.data.i32[i + STREAM_INOUT_OFFSET];
356 if (format == chosenFormat && use == chosenUse) {
357 streamConfig.width = rawEntry.data.i32[i + STREAM_WIDTH_OFFSET];
358 streamConfig.height = rawEntry.data.i32[i + STREAM_HEIGHT_OFFSET];
359 return streamConfig;
360 }
361 }
362 return streamConfig;
363 }
BasicCameraTests(bool prepareWindows)364 void BasicCameraTests(bool prepareWindows) {
365 std::shared_ptr<CameraServiceListener> listener =
366 ::ndk::SharedRefBase::make<CameraServiceListener>();
367 std::vector<CameraStatusAndId> cameraStatuses;
368
369 ndk::ScopedAStatus ret = mCameraService->addListener(listener, &cameraStatuses);
370 EXPECT_TRUE(ret.isOk());
371 listener->initializeStatuses(cameraStatuses);
372
373 for (const auto& it : cameraStatuses) {
374 CameraMetadata rawMetadata;
375 if (it.deviceStatus != CameraDeviceStatus::STATUS_PRESENT) {
376 continue;
377 }
378 AidlCameraMetadata aidlMetadata;
379 ret = mCameraService->getCameraCharacteristics(it.cameraId, &aidlMetadata);
380 EXPECT_TRUE(ret.isOk());
381 bool cStatus = convertFromAidlCloned(aidlMetadata, &rawMetadata);
382 EXPECT_TRUE(cStatus);
383 EXPECT_FALSE(rawMetadata.isEmpty());
384
385 std::shared_ptr<CameraDeviceCallback> callbacks =
386 ndk::SharedRefBase::make<CameraDeviceCallback>();
387 std::shared_ptr<ICameraDeviceUser> deviceRemote = nullptr;
388 ret = mCameraService->connectDevice(callbacks, it.cameraId, &deviceRemote);
389 EXPECT_TRUE(ret.isOk());
390 EXPECT_TRUE(deviceRemote != nullptr);
391
392 MQDescriptor<int8_t, SynchronizedReadWrite> mqDesc;
393 ret = deviceRemote->getCaptureRequestMetadataQueue(&mqDesc);
394 EXPECT_TRUE(ret.isOk());
395 std::shared_ptr<RequestMetadataQueue> requestMQ =
396 std::make_shared<RequestMetadataQueue>(mqDesc);
397 EXPECT_TRUE(requestMQ->isValid());
398 EXPECT_TRUE((requestMQ->availableToWrite() >= 0));
399
400 AImageReader* reader = nullptr;
401 bool isDepthOnlyDevice =
402 !doesCapabilityExist(rawMetadata,
403 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) &&
404 doesCapabilityExist(rawMetadata,
405 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT);
406 int chosenImageFormat = AIMAGE_FORMAT_YUV_420_888;
407 int chosenImageWidth = kVGAImageWidth;
408 int chosenImageHeight = kVGAImageHeight;
409 bool isSecureOnlyCamera = isSecureOnlyDevice(rawMetadata);
410 status_t mStatus = OK;
411 if (isSecureOnlyCamera) {
412 StreamConfiguration secureStreamConfig = getStreamConfiguration(
413 rawMetadata, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
414 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
415 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED);
416 EXPECT_TRUE(secureStreamConfig.width != -1);
417 EXPECT_TRUE(secureStreamConfig.height != -1);
418 chosenImageFormat = AIMAGE_FORMAT_PRIVATE;
419 chosenImageWidth = secureStreamConfig.width;
420 chosenImageHeight = secureStreamConfig.height;
421 mStatus = AImageReader_newWithUsage(
422 chosenImageWidth, chosenImageHeight, chosenImageFormat,
423 AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT, kCaptureRequestCount, &reader);
424
425 } else {
426 if (isDepthOnlyDevice) {
427 StreamConfiguration depthStreamConfig = getStreamConfiguration(
428 rawMetadata, ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS,
429 ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT,
430 HAL_PIXEL_FORMAT_Y16);
431 EXPECT_TRUE(depthStreamConfig.width != -1);
432 EXPECT_TRUE(depthStreamConfig.height != -1);
433 chosenImageFormat = AIMAGE_FORMAT_DEPTH16;
434 chosenImageWidth = depthStreamConfig.width;
435 chosenImageHeight = depthStreamConfig.height;
436 }
437 mStatus = AImageReader_new(chosenImageWidth, chosenImageHeight, chosenImageFormat,
438 kCaptureRequestCount, &reader);
439 }
440
441 EXPECT_EQ(mStatus, AMEDIA_OK);
442 native_handle_t* wh = nullptr;
443 mStatus = AImageReader_getWindowNativeHandle(reader, &wh);
444 EXPECT_TRUE(mStatus == AMEDIA_OK && wh != nullptr);
445
446 ret = deviceRemote->beginConfigure();
447 EXPECT_TRUE(ret.isOk());
448
449 OutputConfiguration output = createOutputConfiguration({wh});
450 int32_t streamId = -1;
451 ret = deviceRemote->createStream(output, &streamId);
452 EXPECT_TRUE(ret.isOk());
453 EXPECT_TRUE(streamId >= 0);
454
455 AidlCameraMetadata sessionParams;
456 ret = deviceRemote->endConfigure(StreamConfigurationMode::NORMAL_MODE, sessionParams,
457 systemTime());
458 EXPECT_TRUE(ret.isOk());
459
460 if (prepareWindows) {
461 ret = deviceRemote->prepare(streamId);
462 EXPECT_TRUE(ret.isOk());
463 EXPECT_TRUE(callbacks->waitForPreparedCount(streamId, 1));
464
465 ret = deviceRemote->prepare(streamId);
466 // We should get another callback;
467 EXPECT_TRUE(ret.isOk());
468 EXPECT_TRUE(callbacks->waitForPreparedCount(streamId, 2));
469 }
470 AidlCameraMetadata aidlSettingsMetadata;
471 ret = deviceRemote->createDefaultRequest(TemplateId::PREVIEW, &aidlSettingsMetadata);
472 EXPECT_TRUE(ret.isOk());
473 EXPECT_GE(aidlSettingsMetadata.metadata.size(), 0);
474 std::vector<CaptureRequest> captureRequests;
475 captureRequests.resize(kNumRequests);
476 for (int i = 0; i < kNumRequests; i++) {
477 CaptureRequest& captureRequest = captureRequests[i];
478 initializeCaptureRequestPartial(&captureRequest, streamId, it.cameraId,
479 aidlSettingsMetadata.metadata.size());
480 // Write the settings metadata into the fmq.
481 bool written = requestMQ->write(
482 reinterpret_cast<int8_t*>(aidlSettingsMetadata.metadata.data()),
483 aidlSettingsMetadata.metadata.size());
484 EXPECT_TRUE(written);
485 }
486
487 SubmitInfo info;
488 // Test a single capture
489 ret = deviceRemote->submitRequestList(captureRequests, false, &info);
490 EXPECT_TRUE(ret.isOk());
491 EXPECT_GE(info.requestId, 0);
492 EXPECT_TRUE(callbacks->waitForStatus(
493 CameraDeviceCallback::LocalCameraDeviceStatus::RESULT_RECEIVED));
494 EXPECT_TRUE(callbacks->waitForIdle());
495
496 // Test repeating requests
497 CaptureRequest captureRequest;
498 initializeCaptureRequestPartial(&captureRequest, streamId, it.cameraId,
499 aidlSettingsMetadata.metadata.size());
500
501 bool written =
502 requestMQ->write(reinterpret_cast<int8_t*>(aidlSettingsMetadata.metadata.data()),
503 aidlSettingsMetadata.metadata.size());
504 EXPECT_TRUE(written);
505
506 ret = deviceRemote->submitRequestList({captureRequest}, true, &info);
507 EXPECT_TRUE(ret.isOk());
508 EXPECT_TRUE(callbacks->waitForStatus(
509 CameraDeviceCallback::LocalCameraDeviceStatus::RESULT_RECEIVED));
510
511 int64_t lastFrameNumber = -1;
512 ret = deviceRemote->cancelRepeatingRequest(&lastFrameNumber);
513 EXPECT_TRUE(ret.isOk());
514 EXPECT_GE(lastFrameNumber, 0);
515
516 // Test waitUntilIdle()
517 auto statusRet = deviceRemote->waitUntilIdle();
518 EXPECT_TRUE(statusRet.isOk());
519
520 // Test deleteStream()
521 statusRet = deviceRemote->deleteStream(streamId);
522 EXPECT_TRUE(statusRet.isOk());
523
524 ret = deviceRemote->disconnect();
525 EXPECT_TRUE(ret.isOk());
526 }
527 ret = mCameraService->removeListener(listener);
528 EXPECT_TRUE(ret.isOk());
529 }
530
531 std::shared_ptr<ICameraService> mCameraService = nullptr;
532 };
533
534 // Basic AIDL calls for ICameraService
TEST_P(VtsAidlCameraServiceTargetTest,BasicCameraLifeCycleTest)535 TEST_P(VtsAidlCameraServiceTargetTest, BasicCameraLifeCycleTest) {
536 BasicCameraTests(/*prepareWindows*/ false);
537 BasicCameraTests(/*prepareWindows*/ true);
538 }
539
TEST_P(VtsAidlCameraServiceTargetTest,CameraServiceListenerTest)540 TEST_P(VtsAidlCameraServiceTargetTest, CameraServiceListenerTest) {
541 std::shared_ptr<CameraServiceListener> listener =
542 ndk::SharedRefBase::make<CameraServiceListener>();
543 if (mCameraService == nullptr) return;
544
545 std::vector<CameraStatusAndId> cameraStatuses;
546 ndk::ScopedAStatus ret = mCameraService->addListener(listener, &cameraStatuses);
547 EXPECT_TRUE(ret.isOk());
548 listener->initializeStatuses(cameraStatuses);
549
550 for (const auto& it : cameraStatuses) {
551 CameraMetadata rawMetadata;
552 AidlCameraMetadata aidlCameraMetadata;
553 ret = mCameraService->getCameraCharacteristics(it.cameraId, &aidlCameraMetadata);
554 EXPECT_TRUE(ret.isOk());
555 bool cStatus = convertFromAidlCloned(aidlCameraMetadata, &rawMetadata);
556 EXPECT_TRUE(cStatus);
557 EXPECT_FALSE(rawMetadata.isEmpty());
558
559 bool isLogicalCamera = doesCapabilityExist(
560 rawMetadata, ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA);
561 if (!isLogicalCamera) {
562 EXPECT_TRUE(it.unavailPhysicalCameraIds.empty());
563 continue;
564 }
565 camera_metadata_entry entry = rawMetadata.find(ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
566 EXPECT_GT(entry.count, 0);
567
568 std::unordered_set<std::string> validPhysicalIds;
569 const uint8_t* ids = entry.data.u8;
570 size_t start = 0;
571 for (size_t i = 0; i < entry.count; i++) {
572 if (ids[i] == '\0') {
573 if (start != i) {
574 std::string currentId(reinterpret_cast<const char*>(ids + start));
575 validPhysicalIds.emplace(currentId);
576 }
577 start = i + 1;
578 }
579 }
580
581 std::unordered_set<std::string> unavailablePhysicalIds(it.unavailPhysicalCameraIds.begin(),
582 it.unavailPhysicalCameraIds.end());
583 EXPECT_EQ(unavailablePhysicalIds.size(), it.unavailPhysicalCameraIds.size());
584 for (auto& unavailablePhysicalId : unavailablePhysicalIds) {
585 EXPECT_NE(validPhysicalIds.find(unavailablePhysicalId), validPhysicalIds.end());
586 }
587 }
588
589 ret = mCameraService->removeListener(listener);
590 EXPECT_TRUE(ret.isOk());
591 }
592
593 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VtsAidlCameraServiceTargetTest);
594 INSTANTIATE_TEST_SUITE_P(PerInstance, VtsAidlCameraServiceTargetTest,
595 testing::ValuesIn({std::string(ICameraService::descriptor) + "/default"}),
596 android::hardware::PrintInstanceNameToString);
597
598 } // namespace android
599