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