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 <android/hidl/manager/1.0/IServiceManager.h>
22 #include <android/hidl/manager/1.0/IServiceNotification.h>
23 #include <android/hardware/camera/device/3.2/ICameraDeviceCallback.h>
24 #include <android/hardware/camera/device/3.2/ICameraDeviceSession.h>
25 #include <camera_metadata_hidden.h>
26 #include <hidl/HidlBinderSupport.h>
27 #include <gtest/gtest.h>
28 #include <utility>
29
30 using namespace android;
31 using namespace android::hardware::camera;
32 using android::hardware::camera::common::V1_0::Status;
33 using android::hardware::camera::common::V1_0::VendorTag;
34 using android::hardware::camera::common::V1_0::VendorTagSection;
35 using android::hardware::camera::common::V1_0::CameraMetadataType;
36 using android::hardware::camera::device::V3_2::ICameraDeviceCallback;
37 using android::hardware::camera::device::V3_2::ICameraDeviceSession;
38 using android::hardware::camera::provider::V2_5::DeviceState;
39
40 /**
41 * Basic test implementation of a camera ver. 3.2 device interface
42 */
43 struct TestDeviceInterface : public device::V3_2::ICameraDevice {
44 std::vector<hardware::hidl_string> mDeviceNames;
45 android::hardware::hidl_vec<uint8_t> mCharacteristics;
46
TestDeviceInterfaceTestDeviceInterface47 TestDeviceInterface(std::vector<hardware::hidl_string> deviceNames,
48 android::hardware::hidl_vec<uint8_t> chars) :
49 mDeviceNames(deviceNames), mCharacteristics(chars) {}
50
TestDeviceInterfaceTestDeviceInterface51 TestDeviceInterface(std::vector<hardware::hidl_string> deviceNames) :
52 mDeviceNames(deviceNames) {}
53
54 using getResourceCost_cb = std::function<void(
55 hardware::camera::common::V1_0::Status status,
56 const hardware::camera::common::V1_0::CameraResourceCost& resourceCost)>;
getResourceCostTestDeviceInterface57 virtual ::android::hardware::Return<void> getResourceCost(
58 getResourceCost_cb _hidl_cb) override {
59 hardware::camera::common::V1_0::CameraResourceCost resourceCost = {100,
60 mDeviceNames};
61 _hidl_cb(Status::OK, resourceCost);
62 return hardware::Void();
63 }
64
65 using getCameraCharacteristics_cb = std::function<void(
66 hardware::camera::common::V1_0::Status status,
67 const hardware::hidl_vec<uint8_t>& cameraCharacteristics)>;
getCameraCharacteristicsTestDeviceInterface68 hardware::Return<void> getCameraCharacteristics(
69 getCameraCharacteristics_cb _hidl_cb) override {
70 _hidl_cb(Status::OK, mCharacteristics);
71 return hardware::Void();
72 }
73
setTorchModeTestDeviceInterface74 hardware::Return<hardware::camera::common::V1_0::Status> setTorchMode(
75 ::android::hardware::camera::common::V1_0::TorchMode) override {
76 return Status::OK;
77 }
78
79 using open_cb = std::function<void(
80 ::android::hardware::camera::common::V1_0::Status status,
81 const ::android::sp<ICameraDeviceSession>& session)>;
openTestDeviceInterface82 hardware::Return<void> open(
83 const ::android::sp<ICameraDeviceCallback>&,
84 open_cb _hidl_cb) override {
85 sp<ICameraDeviceSession> deviceSession = nullptr;
86 _hidl_cb(Status::OK, deviceSession);
87 return hardware::Void();
88 }
89
dumpStateTestDeviceInterface90 hardware::Return<void> dumpState(
91 const ::android::hardware::hidl_handle&) override {
92 return hardware::Void();
93 }
94 };
95
96 /**
97 * Basic test implementation of a camera provider
98 */
99 struct TestICameraProvider : virtual public provider::V2_5::ICameraProvider {
100 sp<provider::V2_4::ICameraProviderCallback> mCallbacks;
101 std::vector<hardware::hidl_string> mDeviceNames;
102 sp<device::V3_2::ICameraDevice> mDeviceInterface;
103 hardware::hidl_vec<common::V1_0::VendorTagSection> mVendorTagSections;
104
TestICameraProviderTestICameraProvider105 TestICameraProvider(const std::vector<hardware::hidl_string> &devices,
106 const hardware::hidl_vec<common::V1_0::VendorTagSection> &vendorSection) :
107 mDeviceNames(devices),
108 mDeviceInterface(new TestDeviceInterface(devices)),
109 mVendorTagSections (vendorSection) {}
110
TestICameraProviderTestICameraProvider111 TestICameraProvider(const std::vector<hardware::hidl_string> &devices,
112 const hardware::hidl_vec<common::V1_0::VendorTagSection> &vendorSection,
113 android::hardware::hidl_vec<uint8_t> chars) :
114 mDeviceNames(devices),
115 mDeviceInterface(new TestDeviceInterface(devices, chars)),
116 mVendorTagSections (vendorSection) {}
117
setCallbackTestICameraProvider118 virtual hardware::Return<Status> setCallback(
119 const sp<provider::V2_4::ICameraProviderCallback>& callbacks) override {
120 mCalledCounter[SET_CALLBACK]++;
121 mCallbacks = callbacks;
122 return hardware::Return<Status>(Status::OK);
123 }
124
125 using getVendorTags_cb = std::function<void(Status status,
126 const hardware::hidl_vec<common::V1_0::VendorTagSection>& sections)>;
getVendorTagsTestICameraProvider127 hardware::Return<void> getVendorTags(getVendorTags_cb _hidl_cb) override {
128 mCalledCounter[GET_VENDOR_TAGS]++;
129 _hidl_cb(Status::OK, mVendorTagSections);
130 return hardware::Void();
131 }
132
133 using isSetTorchModeSupported_cb = std::function<void(
134 ::android::hardware::camera::common::V1_0::Status status,
135 bool support)>;
isSetTorchModeSupportedTestICameraProvider136 virtual ::hardware::Return<void> isSetTorchModeSupported(
137 isSetTorchModeSupported_cb _hidl_cb) override {
138 mCalledCounter[IS_SET_TORCH_MODE_SUPPORTED]++;
139 _hidl_cb(Status::OK, false);
140 return hardware::Void();
141 }
142
143 using getCameraIdList_cb = std::function<void(Status status,
144 const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames)>;
getCameraIdListTestICameraProvider145 virtual hardware::Return<void> getCameraIdList(getCameraIdList_cb _hidl_cb) override {
146 mCalledCounter[GET_CAMERA_ID_LIST]++;
147 _hidl_cb(Status::OK, mDeviceNames);
148 return hardware::Void();
149 }
150
151 using getCameraDeviceInterface_V1_x_cb = std::function<void(Status status,
152 const sp<device::V1_0::ICameraDevice>& device)>;
getCameraDeviceInterface_V1_xTestICameraProvider153 virtual hardware::Return<void> getCameraDeviceInterface_V1_x(
154 const hardware::hidl_string& cameraDeviceName,
155 getCameraDeviceInterface_V1_x_cb _hidl_cb) override {
156 (void) cameraDeviceName;
157 _hidl_cb(Status::OK, nullptr); //TODO: impl. of ver. 1.0 device interface
158 // otherwise enumeration will fail.
159 return hardware::Void();
160 }
161
162 using getCameraDeviceInterface_V3_x_cb = std::function<void(Status status,
163 const sp<device::V3_2::ICameraDevice>& device)>;
getCameraDeviceInterface_V3_xTestICameraProvider164 virtual hardware::Return<void> getCameraDeviceInterface_V3_x(
165 const hardware::hidl_string&,
166 getCameraDeviceInterface_V3_x_cb _hidl_cb) override {
167 _hidl_cb(Status::OK, mDeviceInterface);
168 return hardware::Void();
169 }
170
notifyDeviceStateChangeTestICameraProvider171 virtual hardware::Return<void> notifyDeviceStateChange(
172 hardware::hidl_bitfield<DeviceState> newState) override {
173 mCalledCounter[NOTIFY_DEVICE_STATE]++;
174 mCurrentState = newState;
175 return hardware::Void();
176 }
177
linkToDeathTestICameraProvider178 virtual ::android::hardware::Return<bool> linkToDeath(
179 const ::android::sp<::android::hardware::hidl_death_recipient>& recipient,
180 uint64_t cookie) {
181 if (mInitialDeathRecipient.get() == nullptr) {
182 mInitialDeathRecipient =
183 std::make_unique<::android::hardware::hidl_binder_death_recipient>(recipient,
184 cookie, this);
185 }
186 return true;
187 }
188
signalInitialBinderDeathRecipientTestICameraProvider189 void signalInitialBinderDeathRecipient() {
190 if (mInitialDeathRecipient.get() != nullptr) {
191 mInitialDeathRecipient->binderDied(nullptr /*who*/);
192 }
193 }
194
195 std::unique_ptr<::android::hardware::hidl_binder_death_recipient> mInitialDeathRecipient;
196
197 enum MethodNames {
198 SET_CALLBACK,
199 GET_VENDOR_TAGS,
200 IS_SET_TORCH_MODE_SUPPORTED,
201 NOTIFY_DEVICE_STATE,
202 GET_CAMERA_ID_LIST,
203
204 METHOD_NAME_COUNT
205 };
206 int mCalledCounter[METHOD_NAME_COUNT] {0};
207
208 hardware::hidl_bitfield<DeviceState> mCurrentState = 0xFFFFFFFF; // Unlikely to be a real state
209 };
210
211 /**
212 * Simple test version of the interaction proxy, to use to inject onRegistered calls to the
213 * CameraProviderManager
214 */
215 struct TestInteractionProxy : public CameraProviderManager::ServiceInteractionProxy {
216 sp<hidl::manager::V1_0::IServiceNotification> mManagerNotificationInterface;
217 sp<TestICameraProvider> mTestCameraProvider;
218
TestInteractionProxyTestInteractionProxy219 TestInteractionProxy() {}
220
setProviderTestInteractionProxy221 void setProvider(sp<TestICameraProvider> provider) {
222 mTestCameraProvider = provider;
223 }
224
225 std::vector<std::string> mLastRequestedServiceNames;
226
~TestInteractionProxyTestInteractionProxy227 virtual ~TestInteractionProxy() {}
228
registerForNotificationsTestInteractionProxy229 virtual bool registerForNotifications(
230 const std::string &serviceName,
231 const sp<hidl::manager::V1_0::IServiceNotification> ¬ification) override {
232 (void) serviceName;
233 mManagerNotificationInterface = notification;
234 return true;
235 }
236
tryGetServiceTestInteractionProxy237 virtual sp<hardware::camera::provider::V2_4::ICameraProvider> tryGetService(
238 const std::string &serviceName) override {
239 // If no provider has been given, act like the HAL isn't available and return null.
240 if (mTestCameraProvider == nullptr) return nullptr;
241 return getService(serviceName);
242 }
243
getServiceTestInteractionProxy244 virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService(
245 const std::string &serviceName) override {
246 // If no provider has been given, fail; in reality, getService would
247 // block for HALs that don't start correctly, so we should never use
248 // getService when we don't have a valid HAL running
249 if (mTestCameraProvider == nullptr) {
250 ADD_FAILURE() << "getService called with no valid provider; would block indefinitely";
251 // Real getService would block, but that's bad in unit tests. So
252 // just record an error and return nullptr
253 return nullptr;
254 }
255 mLastRequestedServiceNames.push_back(serviceName);
256 return mTestCameraProvider;
257 }
258
listServicesTestInteractionProxy259 virtual hardware::hidl_vec<hardware::hidl_string> listServices() override {
260 // Always provide a list even if there's no actual provider yet, to
261 // simulate stuck HAL situations as well
262 hardware::hidl_vec<hardware::hidl_string> ret = {"test/0"};
263 return ret;
264 }
265
266 };
267
268 struct TestStatusListener : public CameraProviderManager::StatusListener {
~TestStatusListenerTestStatusListener269 ~TestStatusListener() {}
270
onDeviceStatusChangedTestStatusListener271 void onDeviceStatusChanged(const String8 &,
272 hardware::camera::common::V1_0::CameraDeviceStatus) override {}
onDeviceStatusChangedTestStatusListener273 void onDeviceStatusChanged(const String8 &, const String8 &,
274 hardware::camera::common::V1_0::CameraDeviceStatus) override {}
onTorchStatusChangedTestStatusListener275 void onTorchStatusChanged(const String8 &,
276 hardware::camera::common::V1_0::TorchModeStatus) override {}
onNewProviderRegisteredTestStatusListener277 void onNewProviderRegistered() override {}
278 };
279
TEST(CameraProviderManagerTest,InitializeDynamicDepthTest)280 TEST(CameraProviderManagerTest, InitializeDynamicDepthTest) {
281 std::vector<hardware::hidl_string> deviceNames;
282 deviceNames.push_back("device@3.2/test/0");
283 hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
284 status_t res;
285 sp<CameraProviderManager> providerManager = new CameraProviderManager();
286 sp<TestStatusListener> statusListener = new TestStatusListener();
287 TestInteractionProxy serviceProxy;
288
289 android::hardware::hidl_vec<uint8_t> chars;
290 CameraMetadata meta;
291 int32_t charKeys[] = { ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE,
292 ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS };
293 meta.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, charKeys,
294 sizeof(charKeys) / sizeof(charKeys[0]));
295 uint8_t depthIsExclusive = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE;
296 meta.update(ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE, &depthIsExclusive, 1);
297 int32_t sizes[] = { HAL_PIXEL_FORMAT_BLOB,
298 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT };
299 meta.update(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, sizes,
300 sizeof(sizes) / sizeof(sizes[0]));
301 sizes[0] = HAL_PIXEL_FORMAT_Y16;
302 meta.update(ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS, sizes,
303 sizeof(sizes) / sizeof(sizes[0]));
304 int64_t durations[] = { HAL_PIXEL_FORMAT_BLOB, 640, 480, 0 };
305 meta.update(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, durations,
306 sizeof(durations) / sizeof(durations[0]));
307 meta.update(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS, durations,
308 sizeof(durations) / sizeof(durations[0]));
309 durations[0]= HAL_PIXEL_FORMAT_Y16;
310 meta.update(ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS, durations,
311 sizeof(durations) / sizeof(durations[0]));
312 meta.update(ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS, durations,
313 sizeof(durations) / sizeof(durations[0]));
314 camera_metadata_t* metaBuffer = const_cast<camera_metadata_t*>(meta.getAndLock());
315 chars.setToExternal(reinterpret_cast<uint8_t*>(metaBuffer),
316 get_camera_metadata_size(metaBuffer));
317
318 sp<TestICameraProvider> provider = new TestICameraProvider(deviceNames,
319 vendorSection, chars);
320 serviceProxy.setProvider(provider);
321
322 res = providerManager->initialize(statusListener, &serviceProxy);
323 ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
324 }
325
TEST(CameraProviderManagerTest,InitializeTest)326 TEST(CameraProviderManagerTest, InitializeTest) {
327 std::vector<hardware::hidl_string> deviceNames;
328 deviceNames.push_back("device@3.2/test/0");
329 deviceNames.push_back("device@1.0/test/0");
330 deviceNames.push_back("device@3.2/test/1");
331 hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
332 status_t res;
333 sp<CameraProviderManager> providerManager = new CameraProviderManager();
334 sp<TestStatusListener> statusListener = new TestStatusListener();
335 TestInteractionProxy serviceProxy;
336 sp<TestICameraProvider> provider = new TestICameraProvider(deviceNames,
337 vendorSection);
338 serviceProxy.setProvider(provider);
339
340 int numProviders = static_cast<int>(serviceProxy.listServices().size());
341
342 res = providerManager->initialize(statusListener, &serviceProxy);
343 ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
344 // Check that both "legacy" and "external" providers (really the same object) are called
345 // once for all the init methods
346 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::SET_CALLBACK], numProviders) <<
347 "Only one call to setCallback per provider expected during init";
348 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::GET_VENDOR_TAGS], numProviders) <<
349 "Only one call to getVendorTags per provider expected during init";
350 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::IS_SET_TORCH_MODE_SUPPORTED],
351 numProviders) <<
352 "Only one call to isSetTorchModeSupported per provider expected during init";
353 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::GET_CAMERA_ID_LIST], numProviders) <<
354 "Only one call to getCameraIdList per provider expected during init";
355 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::NOTIFY_DEVICE_STATE], numProviders) <<
356 "Only one call to notifyDeviceState per provider expected during init";
357
358 hardware::hidl_string testProviderFqInterfaceName =
359 "android.hardware.camera.provider@2.4::ICameraProvider";
360 hardware::hidl_string testProviderInstanceName = "test/0";
361 serviceProxy.mManagerNotificationInterface->onRegistration(
362 testProviderFqInterfaceName,
363 testProviderInstanceName, false);
364
365 ASSERT_EQ(serviceProxy.mLastRequestedServiceNames.back(), testProviderInstanceName) <<
366 "Incorrect instance requested from service manager";
367 }
368
TEST(CameraProviderManagerTest,MultipleVendorTagTest)369 TEST(CameraProviderManagerTest, MultipleVendorTagTest) {
370 hardware::hidl_string sectionName = "VendorTestSection";
371 hardware::hidl_string tagName = "VendorTestTag";
372 uint32_t tagId = VENDOR_SECTION << 16;
373 hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
374 CameraMetadataType tagType = CameraMetadataType::BYTE;
375 vendorSection.resize(1);
376 vendorSection[0].sectionName = sectionName;
377 vendorSection[0].tags.resize(1);
378 vendorSection[0].tags[0].tagId = tagId;
379 vendorSection[0].tags[0].tagName = tagName;
380 vendorSection[0].tags[0].tagType = tagType;
381 std::vector<hardware::hidl_string> deviceNames = {"device@3.2/test/0"};
382
383 sp<CameraProviderManager> providerManager = new CameraProviderManager();
384 sp<TestStatusListener> statusListener = new TestStatusListener();
385 TestInteractionProxy serviceProxy;
386
387 sp<TestICameraProvider> provider = new TestICameraProvider(deviceNames,
388 vendorSection);
389 serviceProxy.setProvider(provider);
390
391 auto res = providerManager->initialize(statusListener, &serviceProxy);
392 ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
393
394 hardware::hidl_string testProviderInstanceName = "test/0";
395 hardware::hidl_string testProviderFqInterfaceName =
396 "android.hardware.camera.provider@2.4::ICameraProvider";
397 serviceProxy.mManagerNotificationInterface->onRegistration(
398 testProviderFqInterfaceName, testProviderInstanceName, false);
399 ASSERT_EQ(serviceProxy.mLastRequestedServiceNames.back(), testProviderInstanceName) <<
400 "Incorrect instance requested from service manager";
401
402 hardware::hidl_string sectionNameSecond = "SecondVendorTestSection";
403 hardware::hidl_string secondTagName = "SecondVendorTestTag";
404 CameraMetadataType secondTagType = CameraMetadataType::DOUBLE;
405 vendorSection[0].sectionName = sectionNameSecond;
406 vendorSection[0].tags[0].tagId = tagId;
407 vendorSection[0].tags[0].tagName = secondTagName;
408 vendorSection[0].tags[0].tagType = secondTagType;
409 deviceNames = {"device@3.2/test2/1"};
410
411 sp<TestICameraProvider> secondProvider = new TestICameraProvider(
412 deviceNames, vendorSection);
413 serviceProxy.setProvider(secondProvider);
414 hardware::hidl_string testProviderSecondInstanceName = "test2/0";
415 serviceProxy.mManagerNotificationInterface->onRegistration(
416 testProviderFqInterfaceName, testProviderSecondInstanceName, false);
417 ASSERT_EQ(serviceProxy.mLastRequestedServiceNames.back(),
418 testProviderSecondInstanceName) <<
419 "Incorrect instance requested from service manager";
420
421 ASSERT_EQ(NO_ERROR , providerManager->setUpVendorTags());
422 sp<VendorTagDescriptorCache> vendorCache =
423 VendorTagDescriptorCache::getGlobalVendorTagCache();
424 ASSERT_NE(nullptr, vendorCache.get());
425
426 metadata_vendor_id_t vendorId = std::hash<std::string> {} (
427 testProviderInstanceName.c_str());
428 metadata_vendor_id_t vendorIdSecond = std::hash<std::string> {} (
429 testProviderSecondInstanceName.c_str());
430
431 hardware::hidl_string resultTag = vendorCache->getTagName(tagId, vendorId);
432 ASSERT_EQ(resultTag, tagName);
433
434 resultTag = vendorCache->getTagName(tagId, vendorIdSecond);
435 ASSERT_EQ(resultTag, secondTagName);
436
437 // Check whether we can create two separate CameraMetadata instances
438 // using different tag vendor vendors.
439 camera_metadata *metaBuffer = allocate_camera_metadata(10, 20);
440 ASSERT_NE(nullptr, metaBuffer);
441 set_camera_metadata_vendor_id(metaBuffer, vendorId);
442 CameraMetadata metadata(metaBuffer);
443
444 uint8_t byteVal = 10;
445 ASSERT_TRUE(metadata.isEmpty());
446 ASSERT_EQ(OK, metadata.update(tagId, &byteVal, 1));
447 ASSERT_FALSE(metadata.isEmpty());
448 ASSERT_TRUE(metadata.exists(tagId));
449
450 metaBuffer = allocate_camera_metadata(10, 20);
451 ASSERT_NE(nullptr, metaBuffer);
452 set_camera_metadata_vendor_id(metaBuffer, vendorIdSecond);
453 CameraMetadata secondMetadata(metaBuffer);
454
455 ASSERT_TRUE(secondMetadata.isEmpty());
456 double doubleVal = 1.0f;
457 ASSERT_EQ(OK, secondMetadata.update(tagId, &doubleVal, 1));
458 ASSERT_FALSE(secondMetadata.isEmpty());
459 ASSERT_TRUE(secondMetadata.exists(tagId));
460
461 // Check whether CameraMetadata copying works as expected
462 CameraMetadata metadataCopy(metadata);
463 ASSERT_FALSE(metadataCopy.isEmpty());
464 ASSERT_TRUE(metadataCopy.exists(tagId));
465 ASSERT_EQ(OK, metadataCopy.update(tagId, &byteVal, 1));
466 ASSERT_TRUE(metadataCopy.exists(tagId));
467
468 // Check whether values are as expected
469 camera_metadata_entry_t entry = metadata.find(tagId);
470 ASSERT_EQ(1u, entry.count);
471 ASSERT_EQ(byteVal, entry.data.u8[0]);
472 entry = secondMetadata.find(tagId);
473 ASSERT_EQ(1u, entry.count);
474 ASSERT_EQ(doubleVal, entry.data.d[0]);
475
476 // Swap and erase
477 secondMetadata.swap(metadataCopy);
478 ASSERT_TRUE(metadataCopy.exists(tagId));
479 ASSERT_TRUE(secondMetadata.exists(tagId));
480 ASSERT_EQ(OK, secondMetadata.erase(tagId));
481 ASSERT_TRUE(secondMetadata.isEmpty());
482 doubleVal = 0.0f;
483 ASSERT_EQ(OK, metadataCopy.update(tagId, &doubleVal, 1));
484 entry = metadataCopy.find(tagId);
485 ASSERT_EQ(1u, entry.count);
486 ASSERT_EQ(doubleVal, entry.data.d[0]);
487
488 // Append
489 uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_ACTION;
490 secondMetadata.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
491 // Append from two different vendor tag providers is not supported!
492 ASSERT_NE(OK, metadataCopy.append(secondMetadata));
493 ASSERT_EQ(OK, metadataCopy.erase(tagId));
494 metadataCopy.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
495 // However appending from same vendor tag provider should be fine
496 ASSERT_EQ(OK, metadata.append(secondMetadata));
497 // Append from a metadata without vendor tag provider should be supported
498 CameraMetadata regularMetadata(10, 20);
499 uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO;
500 regularMetadata.update(ANDROID_CONTROL_MODE, &controlMode, 1);
501 ASSERT_EQ(OK, secondMetadata.append(regularMetadata));
502 ASSERT_EQ(2u, secondMetadata.entryCount());
503 ASSERT_EQ(2u, metadata.entryCount());
504
505 // Dump
506 metadata.dump(1, 2);
507 metadataCopy.dump(1, 2);
508 secondMetadata.dump(1, 2);
509 }
510
TEST(CameraProviderManagerTest,NotifyStateChangeTest)511 TEST(CameraProviderManagerTest, NotifyStateChangeTest) {
512 std::vector<hardware::hidl_string> deviceNames {
513 "device@3.2/test/0",
514 "device@1.0/test/0",
515 "device@3.2/test/1"};
516
517 hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
518 status_t res;
519 sp<CameraProviderManager> providerManager = new CameraProviderManager();
520 sp<TestStatusListener> statusListener = new TestStatusListener();
521 TestInteractionProxy serviceProxy;
522 sp<TestICameraProvider> provider = new TestICameraProvider(deviceNames,
523 vendorSection);
524 serviceProxy.setProvider(provider);
525
526 res = providerManager->initialize(statusListener, &serviceProxy);
527 ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
528
529 ASSERT_EQ(provider->mCurrentState,
530 static_cast<hardware::hidl_bitfield<DeviceState>>(DeviceState::NORMAL))
531 << "Initial device state not set";
532
533 res = providerManager->notifyDeviceStateChange(
534 static_cast<hardware::hidl_bitfield<DeviceState>>(DeviceState::FOLDED));
535
536 ASSERT_EQ(res, OK) << "Unable to call notifyDeviceStateChange";
537 ASSERT_EQ(provider->mCurrentState,
538 static_cast<hardware::hidl_bitfield<DeviceState>>(DeviceState::FOLDED))
539 << "Unable to change device state";
540
541 }
542
543 // Test that CameraProviderManager doesn't get stuck when the camera HAL isn't really working
TEST(CameraProviderManagerTest,BadHalStartupTest)544 TEST(CameraProviderManagerTest, BadHalStartupTest) {
545
546 std::vector<hardware::hidl_string> deviceNames;
547 deviceNames.push_back("device@3.2/test/0");
548 deviceNames.push_back("device@1.0/test/0");
549 deviceNames.push_back("device@3.2/test/1");
550 hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
551 status_t res;
552
553 sp<CameraProviderManager> providerManager = new CameraProviderManager();
554 sp<TestStatusListener> statusListener = new TestStatusListener();
555 TestInteractionProxy serviceProxy;
556 sp<TestICameraProvider> provider = new TestICameraProvider(deviceNames,
557 vendorSection);
558
559 // Not setting up provider in the service proxy yet, to test cases where a
560 // HAL isn't starting right
561 res = providerManager->initialize(statusListener, &serviceProxy);
562 ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
563
564 // Now set up provider and trigger a registration
565 serviceProxy.setProvider(provider);
566 int numProviders = static_cast<int>(serviceProxy.listServices().size());
567
568 hardware::hidl_string testProviderFqInterfaceName =
569 "android.hardware.camera.provider@2.4::ICameraProvider";
570 hardware::hidl_string testProviderInstanceName = "test/0";
571 serviceProxy.mManagerNotificationInterface->onRegistration(
572 testProviderFqInterfaceName,
573 testProviderInstanceName, false);
574
575 // Check that new provider is called once for all the init methods
576 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::SET_CALLBACK], numProviders) <<
577 "Only one call to setCallback per provider expected during register";
578 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::GET_VENDOR_TAGS], numProviders) <<
579 "Only one call to getVendorTags per provider expected during register";
580 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::IS_SET_TORCH_MODE_SUPPORTED],
581 numProviders) <<
582 "Only one call to isSetTorchModeSupported per provider expected during init";
583 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::GET_CAMERA_ID_LIST], numProviders) <<
584 "Only one call to getCameraIdList per provider expected during init";
585 EXPECT_EQ(provider->mCalledCounter[TestICameraProvider::NOTIFY_DEVICE_STATE], numProviders) <<
586 "Only one call to notifyDeviceState per provider expected during init";
587
588 ASSERT_EQ(serviceProxy.mLastRequestedServiceNames.back(), testProviderInstanceName) <<
589 "Incorrect instance requested from service manager";
590 }
591
592 // Test that CameraProviderManager can handle races between provider death notifications and
593 // provider registration callbacks
TEST(CameraProviderManagerTest,BinderDeathRegistrationRaceTest)594 TEST(CameraProviderManagerTest, BinderDeathRegistrationRaceTest) {
595
596 std::vector<hardware::hidl_string> deviceNames;
597 deviceNames.push_back("device@3.2/test/0");
598 deviceNames.push_back("device@3.2/test/1");
599 hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
600 status_t res;
601
602 sp<CameraProviderManager> providerManager = new CameraProviderManager();
603 sp<TestStatusListener> statusListener = new TestStatusListener();
604 TestInteractionProxy serviceProxy;
605 sp<TestICameraProvider> provider = new TestICameraProvider(deviceNames,
606 vendorSection);
607
608 // Not setting up provider in the service proxy yet, to test cases where a
609 // HAL isn't starting right
610 res = providerManager->initialize(statusListener, &serviceProxy);
611 ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
612
613 // Now set up provider and trigger a registration
614 serviceProxy.setProvider(provider);
615
616 hardware::hidl_string testProviderFqInterfaceName =
617 "android.hardware.camera.provider@2.4::ICameraProvider";
618 hardware::hidl_string testProviderInstanceName = "test/0";
619 serviceProxy.mManagerNotificationInterface->onRegistration(
620 testProviderFqInterfaceName,
621 testProviderInstanceName, false);
622
623 // Simulate artificial delay of the registration callback which arrives before the
624 // death notification
625 serviceProxy.mManagerNotificationInterface->onRegistration(
626 testProviderFqInterfaceName,
627 testProviderInstanceName, false);
628
629 provider->signalInitialBinderDeathRecipient();
630
631 auto deviceCount = static_cast<unsigned> (providerManager->getCameraCount().second);
632 ASSERT_EQ(deviceCount, deviceNames.size()) <<
633 "Unexpected amount of camera devices";
634 }
635