1 /*
2 * Copyright (C) 2016 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 "CameraProviderManagerTest"
19
20 #include "../common/CameraProviderManager.h"
21 #include <aidl/android/hardware/camera/device/BnCameraDevice.h>
22 #include <aidl/android/hardware/camera/provider/BnCameraProvider.h>
23 #include <android_companion_virtualdevice_flags.h>
24 #include <android/binder_auto_utils.h>
25 #include <android/binder_ibinder.h>
26 #include <android/binder_interface_utils.h>
27 #include <android/binder_libbinder.h>
28 #include <android/binder_manager.h>
29 #include <android/binder_parcel.h>
30 #include <android/hardware/camera/device/3.2/ICameraDeviceCallback.h>
31 #include <android/hardware/camera/device/3.2/ICameraDeviceSession.h>
32 #include <android/hidl/manager/1.0/IServiceManager.h>
33 #include <android/hidl/manager/1.0/IServiceNotification.h>
34 #include <binder/IServiceManager.h>
35 #include <camera_metadata_hidden.h>
36 #include <com_android_internal_camera_flags.h>
37 #include <flag_macros.h>
38 #include <gmock/gmock.h>
39 #include <gtest/gtest.h>
40 #include <hidl/HidlBinderSupport.h>
41 #include <utility>
42
43 using namespace android;
44 using namespace android::hardware::camera;
45 using ::aidl::android::hardware::camera::provider::ICameraProviderCallback;
46 using android::hardware::camera::common::V1_0::CameraMetadataType;
47 using android::hardware::camera::common::V1_0::Status;
48 using android::hardware::camera::common::V1_0::VendorTag;
49 using android::hardware::camera::common::V1_0::VendorTagSection;
50 using android::hardware::camera::device::V3_2::ICameraDeviceCallback;
51 using android::hardware::camera::device::V3_2::ICameraDeviceSession;
52 using android::hardware::camera::provider::V2_5::DeviceState;
53 using ::testing::ElementsAre;
54
55 namespace flags = com::android::internal::camera::flags;
56 namespace vd_flags = android::companion::virtualdevice::flags;
57
58 /**
59 * Basic test implementation of a camera ver. 3.2 device interface
60 */
61 struct TestDeviceInterface : public device::V3_2::ICameraDevice {
62 std::vector<hardware::hidl_string> mDeviceNames;
63 android::hardware::hidl_vec<uint8_t> mCharacteristics;
64
TestDeviceInterfaceTestDeviceInterface65 TestDeviceInterface(std::vector<hardware::hidl_string> deviceNames,
66 android::hardware::hidl_vec<uint8_t> chars) :
67 mDeviceNames(deviceNames), mCharacteristics(chars) {}
68
TestDeviceInterfaceTestDeviceInterface69 TestDeviceInterface(std::vector<hardware::hidl_string> deviceNames) :
70 mDeviceNames(deviceNames) {}
71
72 using getResourceCost_cb = std::function<void(
73 hardware::camera::common::V1_0::Status status,
74 const hardware::camera::common::V1_0::CameraResourceCost& resourceCost)>;
getResourceCostTestDeviceInterface75 virtual ::android::hardware::Return<void> getResourceCost(
76 getResourceCost_cb _hidl_cb) override {
77 hardware::camera::common::V1_0::CameraResourceCost resourceCost = {100,
78 mDeviceNames};
79 _hidl_cb(Status::OK, resourceCost);
80 return hardware::Void();
81 }
82
83 using getCameraCharacteristics_cb = std::function<void(
84 hardware::camera::common::V1_0::Status status,
85 const hardware::hidl_vec<uint8_t>& cameraCharacteristics)>;
getCameraCharacteristicsTestDeviceInterface86 hardware::Return<void> getCameraCharacteristics(
87 getCameraCharacteristics_cb _hidl_cb) override {
88 _hidl_cb(Status::OK, mCharacteristics);
89 return hardware::Void();
90 }
91
setTorchModeTestDeviceInterface92 hardware::Return<hardware::camera::common::V1_0::Status> setTorchMode(
93 ::android::hardware::camera::common::V1_0::TorchMode) override {
94 return Status::OK;
95 }
96
97 using open_cb = std::function<void(
98 ::android::hardware::camera::common::V1_0::Status status,
99 const ::android::sp<ICameraDeviceSession>& session)>;
openTestDeviceInterface100 hardware::Return<void> open(
101 const ::android::sp<ICameraDeviceCallback>&,
102 open_cb _hidl_cb) override {
103 sp<ICameraDeviceSession> deviceSession = nullptr;
104 _hidl_cb(Status::OK, deviceSession);
105 return hardware::Void();
106 }
107
dumpStateTestDeviceInterface108 hardware::Return<void> dumpState(
109 const ::android::hardware::hidl_handle&) override {
110 return hardware::Void();
111 }
112 };
113
114 /**
115 * Basic test implementation of a camera provider
116 */
117 struct TestICameraProvider : virtual public provider::V2_5::ICameraProvider {
118 sp<provider::V2_4::ICameraProviderCallback> mCallbacks;
119 std::vector<hardware::hidl_string> mDeviceNames;
120 sp<device::V3_2::ICameraDevice> mDeviceInterface;
121 hardware::hidl_vec<common::V1_0::VendorTagSection> mVendorTagSections;
122
123 // Whether to call a physical camera unavailable callback upon setCallback
124 bool mHasPhysicalCameraUnavailableCallback;
125 hardware::hidl_string mLogicalCameraId;
126 hardware::hidl_string mUnavailablePhysicalCameraId;
127
TestICameraProviderTestICameraProvider128 TestICameraProvider(const std::vector<hardware::hidl_string> &devices,
129 const hardware::hidl_vec<common::V1_0::VendorTagSection> &vendorSection) :
130 mDeviceNames(devices),
131 mDeviceInterface(new TestDeviceInterface(devices)),
132 mVendorTagSections (vendorSection),
133 mHasPhysicalCameraUnavailableCallback(false) {}
134
TestICameraProviderTestICameraProvider135 TestICameraProvider(const std::vector<hardware::hidl_string> &devices,
136 const hardware::hidl_vec<common::V1_0::VendorTagSection> &vendorSection,
137 android::hardware::hidl_vec<uint8_t> chars) :
138 mDeviceNames(devices),
139 mDeviceInterface(new TestDeviceInterface(devices, chars)),
140 mVendorTagSections (vendorSection),
141 mHasPhysicalCameraUnavailableCallback(false) {}
142
TestICameraProviderTestICameraProvider143 TestICameraProvider(const std::vector<hardware::hidl_string> &devices,
144 const hardware::hidl_vec<common::V1_0::VendorTagSection> &vendorSection,
145 android::hardware::hidl_vec<uint8_t> chars,
146 const hardware::hidl_string& logicalCameraId,
147 const hardware::hidl_string& unavailablePhysicalCameraId) :
148 mDeviceNames(devices),
149 mDeviceInterface(new TestDeviceInterface(devices, chars)),
150 mVendorTagSections (vendorSection),
151 mHasPhysicalCameraUnavailableCallback(true),
152 mLogicalCameraId(logicalCameraId),
153 mUnavailablePhysicalCameraId(unavailablePhysicalCameraId) {}
154
setCallbackTestICameraProvider155 virtual hardware::Return<Status> setCallback(
156 const sp<provider::V2_4::ICameraProviderCallback>& callbacks) override {
157 mCalledCounter[SET_CALLBACK]++;
158 mCallbacks = callbacks;
159 if (mHasPhysicalCameraUnavailableCallback) {
160 auto cast26 = provider::V2_6::ICameraProviderCallback::castFrom(callbacks);
161 if (!cast26.isOk()) {
162 ADD_FAILURE() << "Failed to cast ICameraProviderCallback to V2_6";
163 } else {
164 sp<provider::V2_6::ICameraProviderCallback> callback26 = cast26;
165 if (callback26 == nullptr) {
166 ADD_FAILURE() << "V2_6::ICameraProviderCallback is null after conversion";
167 } else {
168 callback26->physicalCameraDeviceStatusChange(mLogicalCameraId,
169 mUnavailablePhysicalCameraId,
170 android::hardware::camera::common::V1_0::CameraDeviceStatus::NOT_PRESENT);
171 }
172 }
173 }
174 return hardware::Return<Status>(Status::OK);
175 }
176
177 using getVendorTags_cb = std::function<void(Status status,
178 const hardware::hidl_vec<common::V1_0::VendorTagSection>& sections)>;
getVendorTagsTestICameraProvider179 hardware::Return<void> getVendorTags(getVendorTags_cb _hidl_cb) override {
180 mCalledCounter[GET_VENDOR_TAGS]++;
181 _hidl_cb(Status::OK, mVendorTagSections);
182 return hardware::Void();
183 }
184
185 using isSetTorchModeSupported_cb = std::function<void(
186 ::android::hardware::camera::common::V1_0::Status status,
187 bool support)>;
isSetTorchModeSupportedTestICameraProvider188 virtual ::hardware::Return<void> isSetTorchModeSupported(
189 isSetTorchModeSupported_cb _hidl_cb) override {
190 mCalledCounter[IS_SET_TORCH_MODE_SUPPORTED]++;
191 _hidl_cb(Status::OK, false);
192 return hardware::Void();
193 }
194
195 using getCameraIdList_cb = std::function<void(Status status,
196 const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames)>;
getCameraIdListTestICameraProvider197 virtual hardware::Return<void> getCameraIdList(getCameraIdList_cb _hidl_cb) override {
198 mCalledCounter[GET_CAMERA_ID_LIST]++;
199 _hidl_cb(Status::OK, mDeviceNames);
200 return hardware::Void();
201 }
202
203 using getCameraDeviceInterface_V1_x_cb = std::function<void(Status status,
204 const sp<device::V1_0::ICameraDevice>& device)>;
getCameraDeviceInterface_V1_xTestICameraProvider205 virtual hardware::Return<void> getCameraDeviceInterface_V1_x(
206 [[maybe_unused]] const hardware::hidl_string& cameraDeviceName,
207 getCameraDeviceInterface_V1_x_cb _hidl_cb) override {
208 _hidl_cb(Status::OK, nullptr); //TODO: impl. of ver. 1.0 device interface
209 // otherwise enumeration will fail.
210 return hardware::Void();
211 }
212
213 using getCameraDeviceInterface_V3_x_cb = std::function<void(Status status,
214 const sp<device::V3_2::ICameraDevice>& device)>;
getCameraDeviceInterface_V3_xTestICameraProvider215 virtual hardware::Return<void> getCameraDeviceInterface_V3_x(
216 const hardware::hidl_string&,
217 getCameraDeviceInterface_V3_x_cb _hidl_cb) override {
218 _hidl_cb(Status::OK, mDeviceInterface);
219 return hardware::Void();
220 }
221
notifyDeviceStateChangeTestICameraProvider222 virtual hardware::Return<void> notifyDeviceStateChange(
223 hardware::hidl_bitfield<DeviceState> newState) override {
224 mCalledCounter[NOTIFY_DEVICE_STATE]++;
225 mCurrentState = newState;
226 return hardware::Void();
227 }
228
linkToDeathTestICameraProvider229 virtual ::android::hardware::Return<bool> linkToDeath(
230 const ::android::sp<::android::hardware::hidl_death_recipient>& recipient,
231 uint64_t cookie) {
232 if (mInitialDeathRecipient.get() == nullptr) {
233 mInitialDeathRecipient =
234 std::make_unique<::android::hardware::hidl_binder_death_recipient>(recipient,
235 cookie, this);
236 }
237 return true;
238 }
239
signalInitialBinderDeathRecipientTestICameraProvider240 void signalInitialBinderDeathRecipient() {
241 if (mInitialDeathRecipient.get() != nullptr) {
242 mInitialDeathRecipient->binderDied(nullptr /*who*/);
243 }
244 }
245
246 std::unique_ptr<::android::hardware::hidl_binder_death_recipient> mInitialDeathRecipient;
247
248 enum MethodNames {
249 SET_CALLBACK,
250 GET_VENDOR_TAGS,
251 IS_SET_TORCH_MODE_SUPPORTED,
252 NOTIFY_DEVICE_STATE,
253 GET_CAMERA_ID_LIST,
254
255 METHOD_NAME_COUNT
256 };
257 int mCalledCounter[METHOD_NAME_COUNT] {0};
258
259 hardware::hidl_bitfield<DeviceState> mCurrentState = 0xFFFFFFFF; // Unlikely to be a real state
260 };
261
262 struct TestAidlCameraDevice : public aidl::android::hardware::camera::device::BnCameraDevice {
getCameraCharacteristicsTestAidlCameraDevice263 ::ndk::ScopedAStatus getCameraCharacteristics(
264 ::aidl::android::hardware::camera::device::CameraMetadata*) override {
265 return ndk::ScopedAStatus::ok();
266 }
getPhysicalCameraCharacteristicsTestAidlCameraDevice267 ::ndk::ScopedAStatus getPhysicalCameraCharacteristics(
268 const std::string&,
269 ::aidl::android::hardware::camera::device::CameraMetadata*) override {
270 return ndk::ScopedAStatus::ok();
271 }
getResourceCostTestAidlCameraDevice272 ::ndk::ScopedAStatus getResourceCost(
273 ::aidl::android::hardware::camera::common::CameraResourceCost* aidl_return) override {
274 auto cost = ::aidl::android::hardware::camera::common::CameraResourceCost();
275 aidl_return->resourceCost = 100;
276 return ndk::ScopedAStatus::ok();
277 }
isStreamCombinationSupportedTestAidlCameraDevice278 ::ndk::ScopedAStatus isStreamCombinationSupported(
279 const ::aidl::android::hardware::camera::device::StreamConfiguration&, bool*) override {
280 return ndk::ScopedAStatus::ok();
281 }
282 ::ndk::ScopedAStatus
openTestAidlCameraDevice283 open(const std::shared_ptr<::aidl::android::hardware::camera::device::ICameraDeviceCallback>&,
284 std::shared_ptr<::aidl::android::hardware::camera::device::ICameraDeviceSession>*)
285 override {
286 return ndk::ScopedAStatus::ok();
287 }
openInjectionSessionTestAidlCameraDevice288 ::ndk::ScopedAStatus openInjectionSession(
289 const std::shared_ptr<
290 ::aidl::android::hardware::camera::device::ICameraDeviceCallback>&,
291 std::shared_ptr<::aidl::android::hardware::camera::device::ICameraInjectionSession>*)
292 override {
293 return ndk::ScopedAStatus::ok();
294 }
setTorchModeTestAidlCameraDevice295 ::ndk::ScopedAStatus setTorchMode(bool) override { return ndk::ScopedAStatus::ok(); }
turnOnTorchWithStrengthLevelTestAidlCameraDevice296 ::ndk::ScopedAStatus turnOnTorchWithStrengthLevel(int32_t) override {
297 return ndk::ScopedAStatus::ok();
298 }
getTorchStrengthLevelTestAidlCameraDevice299 ::ndk::ScopedAStatus getTorchStrengthLevel(int32_t*) override {
300 return ndk::ScopedAStatus::ok();
301 }
constructDefaultRequestSettingsTestAidlCameraDevice302 ::ndk::ScopedAStatus constructDefaultRequestSettings(
303 ::aidl::android::hardware::camera::device::RequestTemplate,
304 ::aidl::android::hardware::camera::device::CameraMetadata*) override {
305 return ndk::ScopedAStatus::ok();
306 }
isStreamCombinationWithSettingsSupportedTestAidlCameraDevice307 ::ndk::ScopedAStatus isStreamCombinationWithSettingsSupported(
308 const ::aidl::android::hardware::camera::device::StreamConfiguration&,
309 bool*) override {
310 return ndk::ScopedAStatus::ok();
311 }
312
getSessionCharacteristicsTestAidlCameraDevice313 ::ndk::ScopedAStatus getSessionCharacteristics(
314 const ::aidl::android::hardware::camera::device::StreamConfiguration&,
315 ::aidl::android::hardware::camera::device::CameraMetadata*) override {
316 return ndk::ScopedAStatus::ok();
317 }
318 };
319
320 /**
321 * Basic test implementation of a AIDL camera provider
322 */
323 class TestAidlICameraProvider : public aidl::android::hardware::camera::provider::BnCameraProvider {
324 public:
325 std::shared_ptr<ICameraProviderCallback> mCallback;
326 std::vector<std::string> mDeviceNames;
327
TestAidlICameraProvider(const std::vector<std::string> & deviceNames)328 TestAidlICameraProvider(const std::vector<std::string>& deviceNames) {
329 mDeviceNames = deviceNames;
330 }
331
setCallback(const std::shared_ptr<::aidl::android::hardware::camera::provider::ICameraProviderCallback> & callback)332 ::ndk::ScopedAStatus setCallback(
333 const std::shared_ptr<
334 ::aidl::android::hardware::camera::provider::ICameraProviderCallback>& callback)
335 override {
336 mCallback = callback;
337 return ndk::ScopedAStatus::ok();
338 }
getVendorTags(std::vector<::aidl::android::hardware::camera::common::VendorTagSection> *)339 ::ndk::ScopedAStatus getVendorTags(
340 std::vector<::aidl::android::hardware::camera::common::VendorTagSection>*) override {
341 return ndk::ScopedAStatus::ok();
342 }
getCameraIdList(std::vector<std::string> * camera_list)343 ::ndk::ScopedAStatus getCameraIdList(std::vector<std::string>* camera_list) override {
344 ALOGW("getCameraIdList");
345 for (size_t i = 0; i < mDeviceNames.size(); i++) {
346 camera_list->push_back(mDeviceNames.at(i));
347 }
348 return ndk::ScopedAStatus::ok();
349 }
getCameraDeviceInterface(const std::string &,std::shared_ptr<::aidl::android::hardware::camera::device::ICameraDevice> * device)350 ::ndk::ScopedAStatus getCameraDeviceInterface(
351 const std::string&,
352 std::shared_ptr<::aidl::android::hardware::camera::device::ICameraDevice>* device)
353 override {
354 *device = ndk::SharedRefBase::make<TestAidlCameraDevice>();
355 return ndk::ScopedAStatus::ok();
356 }
notifyDeviceStateChange(int64_t)357 ::ndk::ScopedAStatus notifyDeviceStateChange(int64_t) override {
358 return ndk::ScopedAStatus::ok();
359 }
getConcurrentCameraIds(std::vector<::aidl::android::hardware::camera::provider::ConcurrentCameraIdCombination> *)360 ::ndk::ScopedAStatus getConcurrentCameraIds(
361 std::vector<
362 ::aidl::android::hardware::camera::provider::ConcurrentCameraIdCombination>*)
363 override {
364 return ndk::ScopedAStatus::ok();
365 }
isConcurrentStreamCombinationSupported(const std::vector<::aidl::android::hardware::camera::provider::CameraIdAndStreamCombination> &,bool *)366 ::ndk::ScopedAStatus isConcurrentStreamCombinationSupported(
367 const std::vector<
368 ::aidl::android::hardware::camera::provider::CameraIdAndStreamCombination>&,
369 bool*) override {
370 return ndk::ScopedAStatus::ok();
371 }
372 };
373
374 /**
375 * Simple test version of HidlServiceInteractionProxy, to use to inject onRegistered calls to the
376 * CameraProviderManager
377 */
378 struct TestHidlInteractionProxy : public CameraProviderManager::HidlServiceInteractionProxy {
379 sp<hidl::manager::V1_0::IServiceNotification> mManagerNotificationInterface;
380 sp<TestICameraProvider> mTestCameraProvider;
381
TestHidlInteractionProxyTestHidlInteractionProxy382 TestHidlInteractionProxy() {}
383
setProviderTestHidlInteractionProxy384 void setProvider(sp<TestICameraProvider> provider) {
385 mTestCameraProvider = provider;
386 }
387
388 std::vector<std::string> mLastRequestedServiceNames;
389
~TestHidlInteractionProxyTestHidlInteractionProxy390 virtual ~TestHidlInteractionProxy() {}
391
registerForNotificationsTestHidlInteractionProxy392 virtual bool registerForNotifications(
393 [[maybe_unused]] const std::string &serviceName,
394 const sp<hidl::manager::V1_0::IServiceNotification> ¬ification) override {
395 mManagerNotificationInterface = notification;
396 return true;
397 }
398
tryGetServiceTestHidlInteractionProxy399 virtual sp<hardware::camera::provider::V2_4::ICameraProvider> tryGetService(
400 const std::string &serviceName) override {
401 // If no provider has been given, act like the HAL isn't available and return null.
402 if (mTestCameraProvider == nullptr) return nullptr;
403 return getService(serviceName);
404 }
405
getServiceTestHidlInteractionProxy406 virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService(
407 const std::string &serviceName) override {
408 // If no provider has been given, fail; in reality, getService would
409 // block for HALs that don't start correctly, so we should never use
410 // getService when we don't have a valid HAL running
411 if (mTestCameraProvider == nullptr) {
412 ADD_FAILURE() << "getService called with no valid provider; would block indefinitely";
413 // Real getService would block, but that's bad in unit tests. So
414 // just record an error and return nullptr
415 return nullptr;
416 }
417 mLastRequestedServiceNames.push_back(serviceName);
418 return mTestCameraProvider;
419 }
420
listServicesTestHidlInteractionProxy421 virtual hardware::hidl_vec<hardware::hidl_string> listServices() override {
422 // Always provide a list even if there's no actual provider yet, to
423 // simulate stuck HAL situations as well
424 hardware::hidl_vec<hardware::hidl_string> ret = {"test/0"};
425 return ret;
426 }
427 };
428
429 /**
430 * Simple test version of AidlServiceInteractionProxy, to use to inject onRegistered calls to the
431 * CameraProviderManager
432 */
433 struct TestAidlInteractionProxy : public CameraProviderManager::AidlServiceInteractionProxy {
434 std::shared_ptr<TestAidlICameraProvider> mTestAidlCameraProvider;
435
TestAidlInteractionProxyTestAidlInteractionProxy436 TestAidlInteractionProxy() {}
437
setProviderTestAidlInteractionProxy438 void setProvider(std::shared_ptr<TestAidlICameraProvider> provider) {
439 mTestAidlCameraProvider = provider;
440 }
441
442 std::vector<std::string> mLastRequestedServiceNames;
443
~TestAidlInteractionProxyTestAidlInteractionProxy444 virtual ~TestAidlInteractionProxy() {}
445
446 virtual std::shared_ptr<aidl::android::hardware::camera::provider::ICameraProvider>
getServiceTestAidlInteractionProxy447 getService(const std::string& serviceName) override {
448 // If no provider has been given, fail; in reality, getService would
449 // block for HALs that don't start correctly, so we should never use
450 // getService when we don't have a valid HAL running
451 if (mTestAidlCameraProvider == nullptr) {
452 ADD_FAILURE() << __FUNCTION__ << "called with no valid provider;"
453 << " would block indefinitely";
454 // Real getService would block, but that's bad in unit tests. So
455 // just record an error and return nullptr
456 return nullptr;
457 }
458 mLastRequestedServiceNames.push_back(serviceName);
459 return mTestAidlCameraProvider;
460 }
461
462 virtual std::shared_ptr<aidl::android::hardware::camera::provider::ICameraProvider>
tryGetServiceTestAidlInteractionProxy463 tryGetService(const std::string&) override {
464 return mTestAidlCameraProvider;
465 }
466 };
467
468 struct TestStatusListener : public CameraProviderManager::StatusListener {
469 int mPhysicalCameraStatusChangeCount = 0;
470
~TestStatusListenerTestStatusListener471 ~TestStatusListener() {}
472
onDeviceStatusChangedTestStatusListener473 void onDeviceStatusChanged(const std::string &,
474 CameraDeviceStatus) override {}
onDeviceStatusChangedTestStatusListener475 void onDeviceStatusChanged(const std::string &, const std::string &,
476 CameraDeviceStatus) override {
477 mPhysicalCameraStatusChangeCount++;
478 }
onTorchStatusChangedTestStatusListener479 void onTorchStatusChanged(const std::string &,
480 TorchModeStatus) override {}
onTorchStatusChangedTestStatusListener481 void onTorchStatusChanged(const std::string &,
482 TorchModeStatus, SystemCameraKind) override {}
onNewProviderRegisteredTestStatusListener483 void onNewProviderRegistered() override {}
484 };
485
TEST(CameraProviderManagerTest,InitializeDynamicDepthTest)486 TEST(CameraProviderManagerTest, InitializeDynamicDepthTest) {
487 std::vector<hardware::hidl_string> deviceNames;
488 deviceNames.push_back("[email protected]/test/0");
489 hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
490 status_t res;
491 sp<CameraProviderManager> providerManager = new CameraProviderManager();
492 sp<TestStatusListener> statusListener = new TestStatusListener();
493 TestHidlInteractionProxy serviceProxy;
494
495 android::hardware::hidl_vec<uint8_t> chars;
496 CameraMetadata meta;
497 int32_t charKeys[] = { ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE,
498 ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS };
499 meta.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, charKeys,
500 sizeof(charKeys) / sizeof(charKeys[0]));
501 uint8_t depthIsExclusive = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE;
502 meta.update(ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE, &depthIsExclusive, 1);
503 int32_t sizes[] = { HAL_PIXEL_FORMAT_BLOB,
504 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT };
505 meta.update(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, sizes,
506 sizeof(sizes) / sizeof(sizes[0]));
507 sizes[0] = HAL_PIXEL_FORMAT_Y16;
508 meta.update(ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS, sizes,
509 sizeof(sizes) / sizeof(sizes[0]));
510 int64_t durations[] = { HAL_PIXEL_FORMAT_BLOB, 640, 480, 0 };
511 meta.update(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, durations,
512 sizeof(durations) / sizeof(durations[0]));
513 meta.update(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS, durations,
514 sizeof(durations) / sizeof(durations[0]));
515 durations[0]= HAL_PIXEL_FORMAT_Y16;
516 meta.update(ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS, durations,
517 sizeof(durations) / sizeof(durations[0]));
518 meta.update(ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS, durations,
519 sizeof(durations) / sizeof(durations[0]));
520 camera_metadata_t* metaBuffer = const_cast<camera_metadata_t*>(meta.getAndLock());
521 chars.setToExternal(reinterpret_cast<uint8_t*>(metaBuffer),
522 get_camera_metadata_size(metaBuffer));
523
524 sp<TestICameraProvider> provider = new TestICameraProvider(deviceNames,
525 vendorSection, chars);
526 serviceProxy.setProvider(provider);
527
528 res = providerManager->initialize(statusListener, &serviceProxy);
529 ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
530 }
531
TEST(CameraProviderManagerTest,InitializeTest)532 TEST(CameraProviderManagerTest, InitializeTest) {
533 std::vector<hardware::hidl_string> deviceNames;
534 deviceNames.push_back("[email protected]/test/0");
535 deviceNames.push_back("[email protected]/test/0");
536 deviceNames.push_back("[email protected]/test/1");
537 hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
538 status_t res;
539 sp<CameraProviderManager> providerManager = new CameraProviderManager();
540 sp<TestStatusListener> statusListener = new TestStatusListener();
541 TestHidlInteractionProxy serviceProxy;
542 sp<TestICameraProvider> provider = new TestICameraProvider(deviceNames,
543 vendorSection);
544 serviceProxy.setProvider(provider);
545
546 int numProviders = static_cast<int>(serviceProxy.listServices().size());
547
548 res = providerManager->initialize(statusListener, &serviceProxy);
549 ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
550 // Check that both "legacy" and "external" providers (really the same object) are called
551 // once for all the init methods
552 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::SET_CALLBACK], numProviders) <<
553 "Only one call to setCallback per provider expected during init";
554 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::GET_VENDOR_TAGS], numProviders) <<
555 "Only one call to getVendorTags per provider expected during init";
556 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::IS_SET_TORCH_MODE_SUPPORTED],
557 numProviders) <<
558 "Only one call to isSetTorchModeSupported per provider expected during init";
559 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::GET_CAMERA_ID_LIST], numProviders) <<
560 "Only one call to getCameraIdList per provider expected during init";
561 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::NOTIFY_DEVICE_STATE], numProviders) <<
562 "Only one call to notifyDeviceState per provider expected during init";
563
564 hardware::hidl_string testProviderFqInterfaceName =
565 "[email protected]::ICameraProvider";
566 hardware::hidl_string testProviderInstanceName = "test/0";
567 serviceProxy.mManagerNotificationInterface->onRegistration(
568 testProviderFqInterfaceName,
569 testProviderInstanceName, false);
570
571 ASSERT_EQ(serviceProxy.mLastRequestedServiceNames.back(), testProviderInstanceName) <<
572 "Incorrect instance requested from service manager";
573 }
574
TEST(CameraProviderManagerTest,MultipleVendorTagTest)575 TEST(CameraProviderManagerTest, MultipleVendorTagTest) {
576 hardware::hidl_string sectionName = "VendorTestSection";
577 hardware::hidl_string tagName = "VendorTestTag";
578 uint32_t tagId = VENDOR_SECTION << 16;
579 hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
580 CameraMetadataType tagType = CameraMetadataType::BYTE;
581 vendorSection.resize(1);
582 vendorSection[0].sectionName = sectionName;
583 vendorSection[0].tags.resize(1);
584 vendorSection[0].tags[0].tagId = tagId;
585 vendorSection[0].tags[0].tagName = tagName;
586 vendorSection[0].tags[0].tagType = tagType;
587 std::vector<hardware::hidl_string> deviceNames = {"[email protected]/test/0"};
588
589 sp<CameraProviderManager> providerManager = new CameraProviderManager();
590 sp<TestStatusListener> statusListener = new TestStatusListener();
591 TestHidlInteractionProxy serviceProxy;
592
593 sp<TestICameraProvider> provider = new TestICameraProvider(deviceNames,
594 vendorSection);
595 serviceProxy.setProvider(provider);
596
597 auto res = providerManager->initialize(statusListener, &serviceProxy);
598 ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
599
600 hardware::hidl_string testProviderInstanceName = "test/0";
601 hardware::hidl_string testProviderFqInterfaceName =
602 "[email protected]::ICameraProvider";
603 serviceProxy.mManagerNotificationInterface->onRegistration(
604 testProviderFqInterfaceName, testProviderInstanceName, false);
605 ASSERT_EQ(serviceProxy.mLastRequestedServiceNames.back(), testProviderInstanceName) <<
606 "Incorrect instance requested from service manager";
607
608 hardware::hidl_string sectionNameSecond = "SecondVendorTestSection";
609 hardware::hidl_string secondTagName = "SecondVendorTestTag";
610 CameraMetadataType secondTagType = CameraMetadataType::DOUBLE;
611 vendorSection[0].sectionName = sectionNameSecond;
612 vendorSection[0].tags[0].tagId = tagId;
613 vendorSection[0].tags[0].tagName = secondTagName;
614 vendorSection[0].tags[0].tagType = secondTagType;
615 deviceNames = {"[email protected]/test2/1"};
616
617 sp<TestICameraProvider> secondProvider = new TestICameraProvider(
618 deviceNames, vendorSection);
619 serviceProxy.setProvider(secondProvider);
620 hardware::hidl_string testProviderSecondInstanceName = "test2/0";
621 serviceProxy.mManagerNotificationInterface->onRegistration(
622 testProviderFqInterfaceName, testProviderSecondInstanceName, false);
623 ASSERT_EQ(serviceProxy.mLastRequestedServiceNames.back(),
624 testProviderSecondInstanceName) <<
625 "Incorrect instance requested from service manager";
626
627 ASSERT_EQ(NO_ERROR , providerManager->setUpVendorTags());
628 sp<VendorTagDescriptorCache> vendorCache =
629 VendorTagDescriptorCache::getGlobalVendorTagCache();
630 ASSERT_NE(nullptr, vendorCache.get());
631
632 metadata_vendor_id_t vendorId = std::hash<std::string> {} (
633 testProviderInstanceName.c_str());
634 metadata_vendor_id_t vendorIdSecond = std::hash<std::string> {} (
635 testProviderSecondInstanceName.c_str());
636
637 hardware::hidl_string resultTag = vendorCache->getTagName(tagId, vendorId);
638 ASSERT_EQ(resultTag, tagName);
639
640 resultTag = vendorCache->getTagName(tagId, vendorIdSecond);
641 ASSERT_EQ(resultTag, secondTagName);
642
643 // Check whether we can create two separate CameraMetadata instances
644 // using different tag vendor vendors.
645 camera_metadata *metaBuffer = allocate_camera_metadata(10, 20);
646 ASSERT_NE(nullptr, metaBuffer);
647 set_camera_metadata_vendor_id(metaBuffer, vendorId);
648 CameraMetadata metadata(metaBuffer);
649
650 uint8_t byteVal = 10;
651 ASSERT_TRUE(metadata.isEmpty());
652 ASSERT_EQ(OK, metadata.update(tagId, &byteVal, 1));
653 ASSERT_FALSE(metadata.isEmpty());
654 ASSERT_TRUE(metadata.exists(tagId));
655
656 metaBuffer = allocate_camera_metadata(10, 20);
657 ASSERT_NE(nullptr, metaBuffer);
658 set_camera_metadata_vendor_id(metaBuffer, vendorIdSecond);
659 CameraMetadata secondMetadata(metaBuffer);
660
661 ASSERT_TRUE(secondMetadata.isEmpty());
662 double doubleVal = 1.0f;
663 ASSERT_EQ(OK, secondMetadata.update(tagId, &doubleVal, 1));
664 ASSERT_FALSE(secondMetadata.isEmpty());
665 ASSERT_TRUE(secondMetadata.exists(tagId));
666
667 // Check whether CameraMetadata copying works as expected
668 CameraMetadata metadataCopy(metadata);
669 ASSERT_FALSE(metadataCopy.isEmpty());
670 ASSERT_TRUE(metadataCopy.exists(tagId));
671 ASSERT_EQ(OK, metadataCopy.update(tagId, &byteVal, 1));
672 ASSERT_TRUE(metadataCopy.exists(tagId));
673
674 // Check whether values are as expected
675 camera_metadata_entry_t entry = metadata.find(tagId);
676 ASSERT_EQ(1u, entry.count);
677 ASSERT_EQ(byteVal, entry.data.u8[0]);
678 entry = secondMetadata.find(tagId);
679 ASSERT_EQ(1u, entry.count);
680 ASSERT_EQ(doubleVal, entry.data.d[0]);
681
682 // Swap and erase
683 secondMetadata.swap(metadataCopy);
684 ASSERT_TRUE(metadataCopy.exists(tagId));
685 ASSERT_TRUE(secondMetadata.exists(tagId));
686 ASSERT_EQ(OK, secondMetadata.erase(tagId));
687 ASSERT_TRUE(secondMetadata.isEmpty());
688 doubleVal = 0.0f;
689 ASSERT_EQ(OK, metadataCopy.update(tagId, &doubleVal, 1));
690 entry = metadataCopy.find(tagId);
691 ASSERT_EQ(1u, entry.count);
692 ASSERT_EQ(doubleVal, entry.data.d[0]);
693
694 // Append
695 uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_ACTION;
696 secondMetadata.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
697 // Append from two different vendor tag providers is not supported!
698 ASSERT_NE(OK, metadataCopy.append(secondMetadata));
699 ASSERT_EQ(OK, metadataCopy.erase(tagId));
700 metadataCopy.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
701 // However appending from same vendor tag provider should be fine
702 ASSERT_EQ(OK, metadata.append(secondMetadata));
703 // Append from a metadata without vendor tag provider should be supported
704 CameraMetadata regularMetadata(10, 20);
705 uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO;
706 regularMetadata.update(ANDROID_CONTROL_MODE, &controlMode, 1);
707 ASSERT_EQ(OK, secondMetadata.append(regularMetadata));
708 ASSERT_EQ(2u, secondMetadata.entryCount());
709 ASSERT_EQ(2u, metadata.entryCount());
710
711 // Dump
712 metadata.dump(1, 2);
713 metadataCopy.dump(1, 2);
714 secondMetadata.dump(1, 2);
715 }
716
TEST(CameraProviderManagerTest,NotifyStateChangeTest)717 TEST(CameraProviderManagerTest, NotifyStateChangeTest) {
718 std::vector<hardware::hidl_string> deviceNames {
719 "[email protected]/test/0",
720 "[email protected]/test/0",
721 "[email protected]/test/1"};
722
723 hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
724 status_t res;
725 sp<CameraProviderManager> providerManager = new CameraProviderManager();
726 sp<TestStatusListener> statusListener = new TestStatusListener();
727 TestHidlInteractionProxy serviceProxy;
728 sp<TestICameraProvider> provider = new TestICameraProvider(deviceNames,
729 vendorSection);
730 serviceProxy.setProvider(provider);
731
732 res = providerManager->initialize(statusListener, &serviceProxy);
733 ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
734
735 ASSERT_EQ(provider->mCurrentState,
736 static_cast<hardware::hidl_bitfield<DeviceState>>(DeviceState::NORMAL))
737 << "Initial device state not set";
738
739 res = providerManager->notifyDeviceStateChange(
740 static_cast<hardware::hidl_bitfield<DeviceState>>(DeviceState::FOLDED));
741
742 ASSERT_EQ(res, OK) << "Unable to call notifyDeviceStateChange";
743 ASSERT_EQ(provider->mCurrentState,
744 static_cast<hardware::hidl_bitfield<DeviceState>>(DeviceState::FOLDED))
745 << "Unable to change device state";
746
747 }
748
749 // Test that CameraProviderManager doesn't get stuck when the camera HAL isn't really working
TEST(CameraProviderManagerTest,BadHalStartupTest)750 TEST(CameraProviderManagerTest, BadHalStartupTest) {
751
752 std::vector<hardware::hidl_string> deviceNames;
753 deviceNames.push_back("[email protected]/test/0");
754 deviceNames.push_back("[email protected]/test/0");
755 deviceNames.push_back("[email protected]/test/1");
756 hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
757 status_t res;
758
759 sp<CameraProviderManager> providerManager = new CameraProviderManager();
760 sp<TestStatusListener> statusListener = new TestStatusListener();
761 TestHidlInteractionProxy serviceProxy;
762 sp<TestICameraProvider> provider = new TestICameraProvider(deviceNames,
763 vendorSection);
764
765 // Not setting up provider in the service proxy yet, to test cases where a
766 // HAL isn't starting right
767 res = providerManager->initialize(statusListener, &serviceProxy);
768 ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
769
770 // Now set up provider and trigger a registration
771 serviceProxy.setProvider(provider);
772 int numProviders = static_cast<int>(serviceProxy.listServices().size());
773
774 hardware::hidl_string testProviderFqInterfaceName =
775 "[email protected]::ICameraProvider";
776 hardware::hidl_string testProviderInstanceName = "test/0";
777 serviceProxy.mManagerNotificationInterface->onRegistration(
778 testProviderFqInterfaceName,
779 testProviderInstanceName, false);
780
781 // Check that new provider is called once for all the init methods
782 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::SET_CALLBACK], numProviders) <<
783 "Only one call to setCallback per provider expected during register";
784 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::GET_VENDOR_TAGS], numProviders) <<
785 "Only one call to getVendorTags per provider expected during register";
786 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::IS_SET_TORCH_MODE_SUPPORTED],
787 numProviders) <<
788 "Only one call to isSetTorchModeSupported per provider expected during init";
789 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::GET_CAMERA_ID_LIST], numProviders) <<
790 "Only one call to getCameraIdList per provider expected during init";
791 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::NOTIFY_DEVICE_STATE], numProviders) <<
792 "Only one call to notifyDeviceState per provider expected during init";
793
794 ASSERT_EQ(serviceProxy.mLastRequestedServiceNames.back(), testProviderInstanceName) <<
795 "Incorrect instance requested from service manager";
796 }
797
798 // Test that CameraProviderManager can handle races between provider death notifications and
799 // provider registration callbacks
TEST(CameraProviderManagerTest,BinderDeathRegistrationRaceTest)800 TEST(CameraProviderManagerTest, BinderDeathRegistrationRaceTest) {
801
802 std::vector<hardware::hidl_string> deviceNames;
803 deviceNames.push_back("[email protected]/test/0");
804 deviceNames.push_back("[email protected]/test/1");
805 hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
806 status_t res;
807
808 sp<CameraProviderManager> providerManager = new CameraProviderManager();
809 sp<TestStatusListener> statusListener = new TestStatusListener();
810 TestHidlInteractionProxy serviceProxy;
811 sp<TestICameraProvider> provider = new TestICameraProvider(deviceNames,
812 vendorSection);
813
814 // Not setting up provider in the service proxy yet, to test cases where a
815 // HAL isn't starting right
816 res = providerManager->initialize(statusListener, &serviceProxy);
817 ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
818
819 // Now set up provider and trigger a registration
820 serviceProxy.setProvider(provider);
821
822 hardware::hidl_string testProviderFqInterfaceName =
823 "[email protected]::ICameraProvider";
824 hardware::hidl_string testProviderInstanceName = "test/0";
825 serviceProxy.mManagerNotificationInterface->onRegistration(
826 testProviderFqInterfaceName,
827 testProviderInstanceName, false);
828
829 // Simulate artificial delay of the registration callback which arrives before the
830 // death notification
831 serviceProxy.mManagerNotificationInterface->onRegistration(
832 testProviderFqInterfaceName,
833 testProviderInstanceName, false);
834
835 provider->signalInitialBinderDeathRecipient();
836
837 auto deviceCount = static_cast<unsigned> (providerManager->getCameraCount().second);
838 ASSERT_EQ(deviceCount, deviceNames.size()) <<
839 "Unexpected amount of camera devices";
840 }
841
842 // Test that CameraProviderManager does not trigger
843 // onDeviceStatusChanged(NOT_PRESENT) for physical camera before initialize()
844 // returns.
TEST(CameraProviderManagerTest,PhysicalCameraAvailabilityCallbackRaceTest)845 TEST(CameraProviderManagerTest, PhysicalCameraAvailabilityCallbackRaceTest) {
846 std::vector<hardware::hidl_string> deviceNames;
847 deviceNames.push_back("[email protected]/test/0");
848 hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
849
850 sp<CameraProviderManager> providerManager = new CameraProviderManager();
851 sp<TestStatusListener> statusListener = new TestStatusListener();
852 TestHidlInteractionProxy serviceProxy;
853
854 android::hardware::hidl_vec<uint8_t> chars;
855 CameraMetadata meta;
856 int32_t charKeys[] = { ANDROID_REQUEST_AVAILABLE_CAPABILITIES };
857 meta.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, charKeys,
858 sizeof(charKeys) / sizeof(charKeys[0]));
859 uint8_t capabilities[] = { ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA };
860 meta.update(ANDROID_REQUEST_AVAILABLE_CAPABILITIES, capabilities,
861 sizeof(capabilities)/sizeof(capabilities[0]));
862 uint8_t physicalCameraIds[] = { '2', '\0', '3', '\0' };
863 meta.update(ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS, physicalCameraIds,
864 sizeof(physicalCameraIds)/sizeof(physicalCameraIds[0]));
865 camera_metadata_t* metaBuffer = const_cast<camera_metadata_t*>(meta.getAndLock());
866 chars.setToExternal(reinterpret_cast<uint8_t*>(metaBuffer),
867 get_camera_metadata_size(metaBuffer));
868
869 sp<TestICameraProvider> provider = new TestICameraProvider(deviceNames,
870 vendorSection, chars, "[email protected]/test/0", "2");
871 serviceProxy.setProvider(provider);
872
873 status_t res = providerManager->initialize(statusListener, &serviceProxy);
874 ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
875
876 ASSERT_EQ(statusListener->mPhysicalCameraStatusChangeCount, 0)
877 << "Unexpected physical camera status change callback upon provider init.";
878
879 std::unordered_map<std::string, std::set<std::string>> unavailablePhysicalIds;
880 auto cameraIds = providerManager->getCameraDeviceIds(&unavailablePhysicalIds);
881 ASSERT_TRUE(unavailablePhysicalIds.count("0") > 0 && unavailablePhysicalIds["0"].count("2") > 0)
882 << "Unavailable physical camera Ids not set properly.";
883 }
TEST_WITH_FLAGS(CameraProviderManagerTest,AidlVirtualCameraProviderDiscovered,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (vd_flags,virtual_camera_service_discovery)))884 TEST_WITH_FLAGS(CameraProviderManagerTest, AidlVirtualCameraProviderDiscovered,
885 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(vd_flags, virtual_camera_service_discovery))) {
886 sp<CameraProviderManager> providerManager = new CameraProviderManager();
887 sp<TestStatusListener> statusListener = new TestStatusListener();
888 TestAidlInteractionProxy aidlServiceProxy;
889 TestHidlInteractionProxy hidlServiceProxy;
890
891 status_t res = providerManager->initialize(statusListener,
892 &hidlServiceProxy, &aidlServiceProxy);
893 ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
894
895 std::vector<std::string> cameraList = {"[email protected]/virtual/123"};
896
897 std::shared_ptr<TestAidlICameraProvider> aidlProvider =
898 ndk::SharedRefBase::make<TestAidlICameraProvider>(cameraList);
899 ndk::SpAIBinder spBinder = aidlProvider->asBinder();
900 AIBinder* aiBinder = spBinder.get();
901 aidlServiceProxy.setProvider(aidlProvider);
902 providerManager->onServiceRegistration(
903 String16("android.hardware.camera.provider.ICameraProvider/virtual/0"),
904 AIBinder_toPlatformBinder(aiBinder));
905
906 std::unordered_map<std::string, std::set<std::string>> unavailableDeviceIds;
907 auto cameraIds = providerManager->getCameraDeviceIds(&unavailableDeviceIds);
908
909 EXPECT_THAT(cameraIds, ElementsAre("123"));
910 }
911
TEST_WITH_FLAGS(CameraProviderManagerTest,AidlVirtualCameraProviderDiscoveredOnInit,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (vd_flags,virtual_camera_service_discovery)))912 TEST_WITH_FLAGS(CameraProviderManagerTest, AidlVirtualCameraProviderDiscoveredOnInit,
913 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(vd_flags, virtual_camera_service_discovery))) {
914 sp<CameraProviderManager> providerManager = new CameraProviderManager();
915 sp<TestStatusListener> statusListener = new TestStatusListener();
916 TestAidlInteractionProxy aidlServiceProxy;
917 TestHidlInteractionProxy hidlServiceProxy;
918
919 std::vector<std::string> cameraList = {"[email protected]/virtual/123"};
920
921 std::shared_ptr<TestAidlICameraProvider> aidlProvider =
922 ndk::SharedRefBase::make<TestAidlICameraProvider>(cameraList);
923 aidlServiceProxy.setProvider(aidlProvider);
924
925 status_t res = providerManager->initialize(statusListener,
926 &hidlServiceProxy, &aidlServiceProxy);
927 ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
928
929 std::unordered_map<std::string, std::set<std::string>> unavailableDeviceIds;
930 std::vector<std::string> cameraIds = providerManager->getCameraDeviceIds(&unavailableDeviceIds);
931
932 EXPECT_THAT(cameraIds, ElementsAre("123"));
933 }
934