1 /*
2 * Copyright (C) 2019 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 "VtsHalCameraServiceV2_0TargetTest"
18 //#define LOG_NDEBUG 0
19
20 #include <android/frameworks/cameraservice/device/2.0/ICameraDeviceUser.h>
21 #include <android/frameworks/cameraservice/device/2.1/ICameraDeviceUser.h>
22 #include <android/frameworks/cameraservice/service/2.0/ICameraService.h>
23 #include <android/frameworks/cameraservice/service/2.1/ICameraService.h>
24 #include <system/camera_metadata.h>
25 #include <system/graphics.h>
26
27 #include <fmq/MessageQueue.h>
28 #include <utils/Condition.h>
29 #include <utils/Mutex.h>
30 #include <utils/StrongPointer.h>
31
32 #include <gtest/gtest.h>
33 #include <hidl/GtestPrinter.h>
34 #include <hidl/ServiceManagement.h>
35 #include <stdint.h>
36 #include <unistd.h>
37
38 #include <stdio.h>
39 #include <algorithm>
40 #include <mutex>
41 #include <string>
42 #include <unordered_set>
43 #include <vector>
44
45 #include <media/NdkImageReader.h>
46
47 #include <android/log.h>
48
49 #include <CameraMetadata.h>
50
51 namespace android {
52
53 using android::Condition;
54 using android::Mutex;
55 using android::sp;
56 using android::frameworks::cameraservice::common::V2_0::Status;
57 using android::frameworks::cameraservice::device::V2_0::CaptureRequest;
58 using android::frameworks::cameraservice::device::V2_0::CaptureResultExtras;
59 using android::frameworks::cameraservice::device::V2_0::ErrorCode;
60 using android::frameworks::cameraservice::device::V2_0::FmqSizeOrMetadata;
61 using android::frameworks::cameraservice::device::V2_0::ICameraDeviceCallback;
62 using android::frameworks::cameraservice::device::V2_0::ICameraDeviceUser;
63 using android::frameworks::cameraservice::device::V2_0::OutputConfiguration;
64 using android::frameworks::cameraservice::device::V2_0::PhysicalCaptureResultInfo;
65 using android::frameworks::cameraservice::device::V2_0::StreamConfigurationMode;
66 using android::frameworks::cameraservice::device::V2_0::SubmitInfo;
67 using android::frameworks::cameraservice::device::V2_0::TemplateId;
68 using android::frameworks::cameraservice::service::V2_0::CameraDeviceStatus;
69 using android::frameworks::cameraservice::service::V2_0::CameraStatusAndId;
70 using android::frameworks::cameraservice::service::V2_0::ICameraService;
71 using android::frameworks::cameraservice::service::V2_0::ICameraServiceListener;
72 using android::frameworks::cameraservice::service::V2_1::PhysicalCameraStatusAndId;
73 using android::hardware::hidl_string;
74 using android::hardware::hidl_vec;
75 using android::hardware::Return;
76 using android::hardware::Void;
77 using android::hardware::camera::common::V1_0::helper::CameraMetadata;
78 using camera_metadata_enum_android_depth_available_depth_stream_configurations::
79 ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT;
80 using RequestMetadataQueue = hardware::MessageQueue<uint8_t, hardware::kSynchronizedReadWrite>;
81
82 static constexpr int kCaptureRequestCount = 10;
83 static constexpr int kVGAImageWidth = 640;
84 static constexpr int kVGAImageHeight = 480;
85 static constexpr int kNumRequests = 4;
86
87 #define ASSERT_NOT_NULL(x) ASSERT_TRUE((x) != nullptr)
88
89 #define SETUP_TIMEOUT 2000000000 // ns
90 #define IDLE_TIMEOUT 2000000000 // ns
91
92 using scoped_unique_image_reader = std::unique_ptr<AImageReader, decltype(&AImageReader_delete)>;
93
94 // Stub listener implementation
95 class CameraServiceListener : public ICameraServiceListener {
96 std::map<hidl_string, CameraDeviceStatus> mCameraStatuses;
97 mutable Mutex mLock;
98
99 public:
~CameraServiceListener()100 virtual ~CameraServiceListener(){};
101
onStatusChanged(const CameraStatusAndId & statusAndId)102 virtual Return<void> onStatusChanged(const CameraStatusAndId& statusAndId) override {
103 Mutex::Autolock l(mLock);
104 mCameraStatuses[statusAndId.cameraId] = statusAndId.deviceStatus;
105 return Void();
106 };
107 };
108
109 class CameraServiceListener2_1
110 : public android::frameworks::cameraservice::service::V2_1::ICameraServiceListener {
111 std::map<hidl_string, CameraDeviceStatus> mCameraStatuses;
112 std::map<hidl_string, std::set<hidl_string>> mUnavailablePhysicalCameras;
113 mutable Mutex mLock;
114
115 public:
~CameraServiceListener2_1()116 virtual ~CameraServiceListener2_1(){};
117
onStatusChanged(const CameraStatusAndId & statusAndId)118 virtual Return<void> onStatusChanged(const CameraStatusAndId& statusAndId) override {
119 Mutex::Autolock l(mLock);
120 mCameraStatuses[statusAndId.cameraId] = statusAndId.deviceStatus;
121 return Void();
122 };
123
onPhysicalCameraStatusChanged(const PhysicalCameraStatusAndId & statusAndId)124 virtual Return<void> onPhysicalCameraStatusChanged(
125 const PhysicalCameraStatusAndId& statusAndId) override {
126 Mutex::Autolock l(mLock);
127 ALOGI("%s: Physical camera %s : %s status changed to %d", __FUNCTION__,
128 statusAndId.cameraId.c_str(), statusAndId.physicalCameraId.c_str(),
129 statusAndId.deviceStatus);
130
131 EXPECT_NE(mCameraStatuses.find(statusAndId.cameraId), mCameraStatuses.end());
132 EXPECT_EQ(mCameraStatuses[statusAndId.cameraId], CameraDeviceStatus::STATUS_PRESENT);
133
134 if (statusAndId.deviceStatus == CameraDeviceStatus::STATUS_NOT_PRESENT) {
135 auto res = mUnavailablePhysicalCameras[statusAndId.cameraId].emplace(
136 statusAndId.physicalCameraId);
137 EXPECT_TRUE(res.second);
138 } else {
139 auto res = mUnavailablePhysicalCameras[statusAndId.cameraId].erase(
140 statusAndId.physicalCameraId);
141 EXPECT_EQ(res, 1);
142 }
143 return Void();
144 };
145
initializeStatuses(const hidl_vec<android::frameworks::cameraservice::service::V2_1::CameraStatusAndId> & statuses)146 void initializeStatuses(
147 const hidl_vec<android::frameworks::cameraservice::service::V2_1::CameraStatusAndId>&
148 statuses) {
149 Mutex::Autolock l(mLock);
150
151 for (auto& status : statuses) {
152 mCameraStatuses[status.v2_0.cameraId] = status.v2_0.deviceStatus;
153 for (auto& physicalId : status.unavailPhysicalCameraIds) {
154 mUnavailablePhysicalCameras[status.v2_0.cameraId].emplace(physicalId);
155 }
156 }
157 }
158 };
159
160 // ICameraDeviceCallback implementation
161 class CameraDeviceCallbacks : public ICameraDeviceCallback {
162 public:
163 enum Status {
164 IDLE,
165 ERROR,
166 PREPARED,
167 RUNNING,
168 RESULT_RECEIVED,
169 UNINITIALIZED,
170 REPEATING_REQUEST_ERROR,
171 };
172
173 protected:
174 bool mError = false;
175 Status mLastStatus = UNINITIALIZED;
176 mutable std::vector<Status> mStatusesHit;
177 mutable Mutex mLock;
178 mutable Condition mStatusCondition;
179
180 public:
CameraDeviceCallbacks()181 CameraDeviceCallbacks() {}
182
~CameraDeviceCallbacks()183 virtual ~CameraDeviceCallbacks() {}
184
onDeviceError(ErrorCode errorCode,const CaptureResultExtras & resultExtras)185 virtual Return<void> onDeviceError(ErrorCode errorCode,
186 const CaptureResultExtras& resultExtras) override {
187 (void)resultExtras;
188 ALOGE("%s: onDeviceError occurred with: %d", __FUNCTION__, static_cast<int>(errorCode));
189 Mutex::Autolock l(mLock);
190 mError = true;
191 mLastStatus = ERROR;
192 mStatusesHit.push_back(mLastStatus);
193 mStatusCondition.broadcast();
194 return Void();
195 }
196
onDeviceIdle()197 virtual Return<void> onDeviceIdle() override {
198 Mutex::Autolock l(mLock);
199 mLastStatus = IDLE;
200 mStatusesHit.push_back(mLastStatus);
201 mStatusCondition.broadcast();
202 return Void();
203 }
204
onCaptureStarted(const CaptureResultExtras & resultExtras,uint64_t timestamp)205 virtual Return<void> onCaptureStarted(const CaptureResultExtras& resultExtras,
206 uint64_t timestamp) override {
207 (void)resultExtras;
208 (void)timestamp;
209 Mutex::Autolock l(mLock);
210 mLastStatus = RUNNING;
211 mStatusesHit.push_back(mLastStatus);
212 mStatusCondition.broadcast();
213 return Void();
214 }
215
onResultReceived(const FmqSizeOrMetadata & sizeOrMetadata,const CaptureResultExtras & resultExtras,const hidl_vec<PhysicalCaptureResultInfo> & physicalResultInfos)216 virtual Return<void> onResultReceived(
217 const FmqSizeOrMetadata& sizeOrMetadata, const CaptureResultExtras& resultExtras,
218 const hidl_vec<PhysicalCaptureResultInfo>& physicalResultInfos) override {
219 (void)sizeOrMetadata;
220 (void)resultExtras;
221 (void)physicalResultInfos;
222 Mutex::Autolock l(mLock);
223 mLastStatus = RESULT_RECEIVED;
224 mStatusesHit.push_back(mLastStatus);
225 mStatusCondition.broadcast();
226 return Void();
227 }
228
onRepeatingRequestError(uint64_t lastFrameNumber,int32_t stoppedSequenceId)229 virtual Return<void> onRepeatingRequestError(uint64_t lastFrameNumber,
230 int32_t stoppedSequenceId) override {
231 (void)lastFrameNumber;
232 (void)stoppedSequenceId;
233 Mutex::Autolock l(mLock);
234 mLastStatus = REPEATING_REQUEST_ERROR;
235 mStatusesHit.push_back(mLastStatus);
236 mStatusCondition.broadcast();
237 return Void();
238 }
239
240 // Test helper functions:
241
hadError() const242 bool hadError() const {
243 Mutex::Autolock l(mLock);
244 return mError;
245 }
waitForStatus(Status status) const246 bool waitForStatus(Status status) const {
247 Mutex::Autolock l(mLock);
248 if (mLastStatus == status) {
249 return true;
250 }
251
252 while (std::find(mStatusesHit.begin(), mStatusesHit.end(), status) == mStatusesHit.end()) {
253 if (mStatusCondition.waitRelative(mLock, IDLE_TIMEOUT) != android::OK) {
254 mStatusesHit.clear();
255 return false;
256 }
257 }
258 mStatusesHit.clear();
259
260 return true;
261 }
262
clearStatus() const263 void clearStatus() const {
264 Mutex::Autolock l(mLock);
265 mStatusesHit.clear();
266 }
267
waitForIdle() const268 bool waitForIdle() const { return waitForStatus(IDLE); }
269 };
270
convertFromHidlCloned(const hidl_vec<uint8_t> & metadata,CameraMetadata * rawMetadata)271 static bool convertFromHidlCloned(const hidl_vec<uint8_t>& metadata, CameraMetadata* rawMetadata) {
272 const camera_metadata* buffer = (camera_metadata_t*)(metadata.data());
273 size_t expectedSize = metadata.size();
274 int ret = validate_camera_metadata_structure(buffer, &expectedSize);
275 if (ret == OK || ret == CAMERA_METADATA_VALIDATION_SHIFTED) {
276 *rawMetadata = buffer;
277 } else {
278 ALOGE("%s: Malformed camera metadata received from caller", __FUNCTION__);
279 return false;
280 }
281 return true;
282 }
283
284 struct StreamConfiguration {
285 int32_t width = -1;
286 int32_t height = -1;
287 };
288
289 class VtsHalCameraServiceV2_0TargetTest : public ::testing::TestWithParam<std::string> {
290 public:
SetUp()291 void SetUp() override {
292 cs = ICameraService::getService(GetParam());
293
294 auto castResult =
295 android::frameworks::cameraservice::service::V2_1::ICameraService::castFrom(cs);
296 if (castResult.isOk()) {
297 cs2_1 = castResult;
298 }
299 }
300
TearDown()301 void TearDown() override {}
302 // creates an outputConfiguration with no deferred streams
createOutputConfiguration(const std::vector<native_handle_t * > & nhs)303 OutputConfiguration createOutputConfiguration(const std::vector<native_handle_t*>& nhs) {
304 OutputConfiguration output;
305 output.rotation = OutputConfiguration::Rotation::R0;
306 output.windowGroupId = -1;
307 output.windowHandles.resize(nhs.size());
308 output.width = 0;
309 output.height = 0;
310 output.isDeferred = false;
311 for (size_t i = 0; i < nhs.size(); i++) {
312 output.windowHandles[i] = nhs[i];
313 }
314 return output;
315 }
316
initializeCaptureRequestPartial(CaptureRequest * captureRequest,int32_t streamId,const hidl_string & cameraId,size_t settingsSize)317 void initializeCaptureRequestPartial(CaptureRequest* captureRequest, int32_t streamId,
318 const hidl_string& cameraId, size_t settingsSize) {
319 captureRequest->physicalCameraSettings.resize(1);
320 captureRequest->physicalCameraSettings[0].id = cameraId;
321 captureRequest->streamAndWindowIds.resize(1);
322 captureRequest->streamAndWindowIds[0].streamId = streamId;
323 captureRequest->streamAndWindowIds[0].windowId = 0;
324 // Write the settings metadata into the fmq.
325 captureRequest->physicalCameraSettings[0].settings.fmqMetadataSize(settingsSize);
326 }
327
doesCapabilityExist(const CameraMetadata & characteristics,int capability)328 bool doesCapabilityExist(const CameraMetadata& characteristics, int capability) {
329 camera_metadata_ro_entry rawEntry =
330 characteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
331 EXPECT_TRUE(rawEntry.count > 0);
332 for (size_t i = 0; i < rawEntry.count; i++) {
333 if (rawEntry.data.u8[i] == capability) {
334 return true;
335 }
336 }
337 return false;
338 }
339
isSecureOnlyDevice(const CameraMetadata & characteristics)340 bool isSecureOnlyDevice(const CameraMetadata& characteristics) {
341 camera_metadata_ro_entry rawEntry =
342 characteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
343 EXPECT_TRUE(rawEntry.count > 0);
344 if (rawEntry.count == 1 &&
345 rawEntry.data.u8[0] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA) {
346 return true;
347 }
348 return false;
349 }
350
351 // Return the first advertised available stream sizes for the given format
352 // and use-case.
getStreamConfiguration(const CameraMetadata & characteristics,uint32_t tag,int32_t chosenUse,int32_t chosenFormat)353 StreamConfiguration getStreamConfiguration(const CameraMetadata& characteristics, uint32_t tag,
354 int32_t chosenUse, int32_t chosenFormat) {
355 camera_metadata_ro_entry rawEntry = characteristics.find(tag);
356 StreamConfiguration streamConfig;
357 const size_t STREAM_FORMAT_OFFSET = 0;
358 const size_t STREAM_WIDTH_OFFSET = 1;
359 const size_t STREAM_HEIGHT_OFFSET = 2;
360 const size_t STREAM_INOUT_OFFSET = 3;
361 const size_t STREAM_CONFIG_SIZE = 4;
362 if (rawEntry.count < STREAM_CONFIG_SIZE) {
363 return streamConfig;
364 }
365 EXPECT_TRUE((rawEntry.count % STREAM_CONFIG_SIZE) == 0);
366 for (size_t i = 0; i < rawEntry.count; i += STREAM_CONFIG_SIZE) {
367 int32_t format = rawEntry.data.i32[i + STREAM_FORMAT_OFFSET];
368 int32_t use = rawEntry.data.i32[i + STREAM_INOUT_OFFSET];
369 if (format == chosenFormat && use == chosenUse) {
370 streamConfig.width = rawEntry.data.i32[i + STREAM_WIDTH_OFFSET];
371 streamConfig.height = rawEntry.data.i32[i + STREAM_HEIGHT_OFFSET];
372 return streamConfig;
373 }
374 }
375 return streamConfig;
376 }
377
378 sp<ICameraService> cs = nullptr;
379 sp<android::frameworks::cameraservice::service::V2_1::ICameraService> cs2_1 = nullptr;
380 };
381
382 // Basic HIDL calls for ICameraService
TEST_P(VtsHalCameraServiceV2_0TargetTest,BasicCameraLifeCycleTest)383 TEST_P(VtsHalCameraServiceV2_0TargetTest, BasicCameraLifeCycleTest) {
384 sp<CameraServiceListener> listener(new CameraServiceListener());
385 hidl_vec<CameraStatusAndId> cameraStatuses{};
386 Status status = Status::NO_ERROR;
387 auto remoteRet =
388 cs->addListener(listener, [&status, &cameraStatuses](Status s, auto& retStatuses) {
389 status = s;
390 cameraStatuses = retStatuses;
391 });
392 EXPECT_TRUE(remoteRet.isOk() && status == Status::NO_ERROR);
393
394 for (const auto& it : cameraStatuses) {
395 CameraMetadata rawMetadata;
396 if (it.deviceStatus != CameraDeviceStatus::STATUS_PRESENT) {
397 continue;
398 }
399 remoteRet = cs->getCameraCharacteristics(
400 it.cameraId, [&status, &rawMetadata](auto s, const hidl_vec<uint8_t>& metadata) {
401 status = s;
402 bool cStatus = convertFromHidlCloned(metadata, &rawMetadata);
403 EXPECT_TRUE(cStatus);
404 });
405 EXPECT_TRUE(remoteRet.isOk() && status == Status::NO_ERROR);
406 EXPECT_FALSE(rawMetadata.isEmpty());
407 sp<CameraDeviceCallbacks> callbacks(new CameraDeviceCallbacks());
408 sp<ICameraDeviceUser> deviceRemote = nullptr;
409 remoteRet = cs->connectDevice(callbacks, it.cameraId,
410 [&status, &deviceRemote](auto s, auto& device) {
411 status = s;
412 deviceRemote = device;
413 });
414 EXPECT_TRUE(remoteRet.isOk() && status == Status::NO_ERROR);
415 EXPECT_TRUE(deviceRemote != nullptr);
416
417 std::shared_ptr<RequestMetadataQueue> requestMQ = nullptr;
418 remoteRet = deviceRemote->getCaptureRequestMetadataQueue([&requestMQ](const auto& mqD) {
419 requestMQ = std::make_shared<RequestMetadataQueue>(mqD);
420 EXPECT_TRUE(requestMQ->isValid() && (requestMQ->availableToWrite() >= 0));
421 });
422 EXPECT_TRUE(remoteRet.isOk());
423 AImageReader* reader = nullptr;
424 bool isDepthOnlyDevice =
425 !doesCapabilityExist(rawMetadata,
426 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) &&
427 doesCapabilityExist(rawMetadata, ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT);
428 int chosenImageFormat = AIMAGE_FORMAT_YUV_420_888;
429 int chosenImageWidth = kVGAImageWidth;
430 int chosenImageHeight = kVGAImageHeight;
431 bool isSecureOnlyCamera = isSecureOnlyDevice(rawMetadata);
432 status_t mStatus = OK;
433 scoped_unique_image_reader readerPtr(nullptr, AImageReader_delete);
434 if (isSecureOnlyCamera) {
435 AImageReader* reader = nullptr;
436 StreamConfiguration secureStreamConfig =
437 getStreamConfiguration(rawMetadata, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
438 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
439 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED);
440 EXPECT_TRUE(secureStreamConfig.width != -1);
441 EXPECT_TRUE(secureStreamConfig.height != -1);
442 chosenImageFormat = AIMAGE_FORMAT_PRIVATE;
443 chosenImageWidth = secureStreamConfig.width;
444 chosenImageHeight = secureStreamConfig.height;
445 mStatus = AImageReader_newWithUsage(
446 chosenImageWidth, chosenImageHeight, chosenImageFormat,
447 AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT, kCaptureRequestCount, &reader);
448 EXPECT_EQ(mStatus, AMEDIA_OK);
449 readerPtr = scoped_unique_image_reader(reader, AImageReader_delete);
450
451 } else {
452 AImageReader* reader = nullptr;
453 if (isDepthOnlyDevice) {
454 StreamConfiguration depthStreamConfig = getStreamConfiguration(
455 rawMetadata, ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS,
456 ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT,
457 HAL_PIXEL_FORMAT_Y16);
458 EXPECT_TRUE(depthStreamConfig.width != -1);
459 EXPECT_TRUE(depthStreamConfig.height != -1);
460 chosenImageFormat = AIMAGE_FORMAT_DEPTH16;
461 chosenImageWidth = depthStreamConfig.width;
462 chosenImageHeight = depthStreamConfig.height;
463 }
464 mStatus = AImageReader_new(chosenImageWidth, chosenImageHeight, chosenImageFormat,
465 kCaptureRequestCount, &reader);
466 EXPECT_EQ(mStatus, AMEDIA_OK);
467 readerPtr = scoped_unique_image_reader(reader, AImageReader_delete);
468 }
469
470 native_handle_t* wh = nullptr;
471 mStatus = AImageReader_getWindowNativeHandle(readerPtr.get(), &wh);
472 EXPECT_TRUE(mStatus == AMEDIA_OK && wh != nullptr);
473 OutputConfiguration output = createOutputConfiguration({wh});
474 Return<Status> ret = deviceRemote->beginConfigure();
475 EXPECT_TRUE(ret.isOk() && ret == Status::NO_ERROR);
476 int32_t streamId = -1;
477 remoteRet = deviceRemote->createStream(output, [&status, &streamId](Status s, auto sId) {
478 status = s;
479 streamId = sId;
480 });
481 EXPECT_TRUE(remoteRet.isOk() && status == Status::NO_ERROR);
482 EXPECT_TRUE(streamId >= 0);
483 hidl_vec<uint8_t> hidlParams;
484 ret = deviceRemote->endConfigure(StreamConfigurationMode::NORMAL_MODE, hidlParams);
485 EXPECT_TRUE(ret.isOk() && ret == Status::NO_ERROR);
486 hidl_vec<uint8_t> settingsMetadata;
487 remoteRet = deviceRemote->createDefaultRequest(
488 TemplateId::PREVIEW, [&status, &settingsMetadata](auto s, const hidl_vec<uint8_t> m) {
489 status = s;
490 settingsMetadata = m;
491 });
492 EXPECT_TRUE(remoteRet.isOk() && status == Status::NO_ERROR);
493 EXPECT_GE(settingsMetadata.size(), 0);
494 hidl_vec<CaptureRequest> captureRequests;
495 captureRequests.resize(kNumRequests);
496 for (int i = 0; i < kNumRequests; i++) {
497 CaptureRequest& captureRequest = captureRequests[i];
498 initializeCaptureRequestPartial(&captureRequest, streamId, it.cameraId,
499 settingsMetadata.size());
500 // Write the settings metadata into the fmq.
501 bool written = requestMQ->write(settingsMetadata.data(), settingsMetadata.size());
502 EXPECT_TRUE(written);
503 }
504 SubmitInfo info;
505
506 // Test a single capture
507 remoteRet = deviceRemote->submitRequestList(captureRequests, false,
508 [&status, &info](auto s, auto& submitInfo) {
509 status = s;
510 info = submitInfo;
511 });
512 EXPECT_TRUE(remoteRet.isOk() && status == Status::NO_ERROR);
513 EXPECT_GE(info.requestId, 0);
514 EXPECT_TRUE(callbacks->waitForStatus(CameraDeviceCallbacks::Status::RESULT_RECEIVED));
515 EXPECT_TRUE(callbacks->waitForIdle());
516
517 // Test repeating requests
518 CaptureRequest captureRequest;
519
520 initializeCaptureRequestPartial(&captureRequest, streamId, it.cameraId,
521 settingsMetadata.size());
522
523 bool written = requestMQ->write(settingsMetadata.data(), settingsMetadata.size());
524 EXPECT_TRUE(written);
525
526 remoteRet = deviceRemote->submitRequestList({captureRequest}, true,
527 [&status, &info](auto s, auto& submitInfo) {
528 status = s;
529 info = submitInfo;
530 });
531 EXPECT_TRUE(callbacks->waitForStatus(CameraDeviceCallbacks::Status::RESULT_RECEIVED));
532 int64_t lastFrameNumber = -1;
533 remoteRet =
534 deviceRemote->cancelRepeatingRequest([&status, &lastFrameNumber](auto s, int64_t lf) {
535 status = s;
536 lastFrameNumber = lf;
537 });
538 EXPECT_TRUE(remoteRet.isOk() && status == Status::NO_ERROR);
539 EXPECT_GE(lastFrameNumber, 0);
540
541 // Test waitUntilIdle()
542 auto statusRet = deviceRemote->waitUntilIdle();
543 EXPECT_TRUE(statusRet.isOk() && statusRet == Status::NO_ERROR);
544
545 // Test deleteStream()
546 statusRet = deviceRemote->deleteStream(streamId);
547 EXPECT_TRUE(statusRet.isOk() && statusRet == Status::NO_ERROR);
548
549 /**
550 * For camera device V2.1, test newly added functions.
551 * TODO: Refactor the device 2.1 test into a separate test for service 2.2.
552 */
553 auto castResult =
554 android::frameworks::cameraservice::device::V2_1::ICameraDeviceUser::castFrom(
555 deviceRemote);
556 sp<android::frameworks::cameraservice::device::V2_1::ICameraDeviceUser> deviceRemote2_1;
557 if (castResult.isOk()) {
558 deviceRemote2_1 = castResult;
559 }
560 if (deviceRemote2_1 != nullptr) {
561 // Reconfigure a capture session using v2.1 version of the device
562 ret = deviceRemote2_1->beginConfigure();
563 EXPECT_TRUE(ret.isOk() && ret == Status::NO_ERROR);
564 remoteRet =
565 deviceRemote2_1->createStream(output, [&status, &streamId](Status s, auto sId) {
566 status = s;
567 streamId = sId;
568 });
569 EXPECT_TRUE(remoteRet.isOk() && status == Status::NO_ERROR);
570 EXPECT_TRUE(streamId >= 0);
571 ret = deviceRemote2_1->endConfigure_2_1(StreamConfigurationMode::NORMAL_MODE,
572 hidlParams, systemTime());
573 EXPECT_TRUE(ret.isOk() && ret == Status::NO_ERROR);
574 }
575
576 remoteRet = deviceRemote->disconnect();
577 EXPECT_TRUE(remoteRet.isOk());
578 }
579 Return<Status> ret = cs->removeListener(listener);
580 EXPECT_TRUE(ret.isOk() && ret == Status::NO_ERROR);
581 }
582
TEST_P(VtsHalCameraServiceV2_0TargetTest,CameraServiceListener2_1Test)583 TEST_P(VtsHalCameraServiceV2_0TargetTest, CameraServiceListener2_1Test) {
584 sp<CameraServiceListener2_1> listener2_1(new CameraServiceListener2_1());
585 hidl_vec<android::frameworks::cameraservice::service::V2_1::CameraStatusAndId>
586 cameraStatuses2_1{};
587 Status status = Status::NO_ERROR;
588
589 if (cs2_1 == nullptr) return;
590
591 auto remoteRet = cs2_1->addListener_2_1(
592 listener2_1, [&status, &cameraStatuses2_1](Status s, auto& retStatuses) {
593 status = s;
594 cameraStatuses2_1 = retStatuses;
595 });
596 EXPECT_TRUE(remoteRet.isOk() && status == Status::NO_ERROR);
597 listener2_1->initializeStatuses(cameraStatuses2_1);
598
599 for (const auto& it : cameraStatuses2_1) {
600 CameraMetadata rawMetadata;
601 remoteRet = cs2_1->getCameraCharacteristics(
602 it.v2_0.cameraId, [&status, &rawMetadata](auto s, const hidl_vec<uint8_t>& metadata) {
603 status = s;
604 bool cStatus = convertFromHidlCloned(metadata, &rawMetadata);
605 EXPECT_TRUE(cStatus);
606 });
607 EXPECT_TRUE(remoteRet.isOk() && status == Status::NO_ERROR);
608 EXPECT_FALSE(rawMetadata.isEmpty());
609 bool isLogicalCamera = doesCapabilityExist(
610 rawMetadata, ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA);
611 if (!isLogicalCamera) {
612 EXPECT_TRUE(it.unavailPhysicalCameraIds.size() == 0);
613 continue;
614 }
615 camera_metadata_entry entry = rawMetadata.find(ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
616 EXPECT_GT(entry.count, 0);
617
618 std::unordered_set<std::string> validPhysicalIds;
619 const uint8_t* ids = entry.data.u8;
620 size_t start = 0;
621 for (size_t i = 0; i < entry.count; i++) {
622 if (ids[i] == '\0') {
623 if (start != i) {
624 std::string currentId(reinterpret_cast<const char*>(ids + start));
625 validPhysicalIds.emplace(currentId);
626 }
627 start = i + 1;
628 }
629 }
630
631 std::unordered_set<std::string> unavailablePhysicalIds(it.unavailPhysicalCameraIds.begin(),
632 it.unavailPhysicalCameraIds.end());
633 EXPECT_EQ(unavailablePhysicalIds.size(), it.unavailPhysicalCameraIds.size());
634 for (auto& unavailablePhysicalId : unavailablePhysicalIds) {
635 EXPECT_NE(validPhysicalIds.find(unavailablePhysicalId), validPhysicalIds.end());
636 }
637 }
638
639 auto remoteStatus = cs2_1->removeListener(listener2_1);
640 EXPECT_TRUE(remoteStatus.isOk() && remoteStatus == Status::NO_ERROR);
641 }
642
643 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VtsHalCameraServiceV2_0TargetTest);
644 INSTANTIATE_TEST_SUITE_P(
645 PerInstance, VtsHalCameraServiceV2_0TargetTest,
646 testing::ValuesIn(android::hardware::getAllHalInstanceNames(ICameraService::descriptor)),
647 android::hardware::PrintInstanceNameToString);
648 } // namespace android
649