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 <gtest/gtest.h>
27 
28 using namespace android;
29 using namespace android::hardware::camera;
30 using android::hardware::camera::common::V1_0::Status;
31 using android::hardware::camera::common::V1_0::VendorTag;
32 using android::hardware::camera::common::V1_0::VendorTagSection;
33 using android::hardware::camera::common::V1_0::CameraMetadataType;
34 using android::hardware::camera::device::V3_2::ICameraDeviceCallback;
35 using android::hardware::camera::device::V3_2::ICameraDeviceSession;
36 
37 /**
38  * Basic test implementation of a camera ver. 3.2 device interface
39  */
40 struct TestDeviceInterface : public device::V3_2::ICameraDevice {
41     std::vector<hardware::hidl_string> mDeviceNames;
TestDeviceInterfaceTestDeviceInterface42     TestDeviceInterface(std::vector<hardware::hidl_string> deviceNames) :
43         mDeviceNames(deviceNames) {}
44     using getResourceCost_cb = std::function<void(
45             hardware::camera::common::V1_0::Status status,
46             const hardware::camera::common::V1_0::CameraResourceCost& resourceCost)>;
getResourceCostTestDeviceInterface47     virtual ::android::hardware::Return<void> getResourceCost(
48             getResourceCost_cb _hidl_cb) override {
49         hardware::camera::common::V1_0::CameraResourceCost resourceCost = {100,
50                 mDeviceNames};
51         _hidl_cb(Status::OK, resourceCost);
52         return hardware::Void();
53     }
54 
55     using getCameraCharacteristics_cb = std::function<void(
56             hardware::camera::common::V1_0::Status status,
57             const hardware::hidl_vec<uint8_t>& cameraCharacteristics)>;
getCameraCharacteristicsTestDeviceInterface58     hardware::Return<void> getCameraCharacteristics(
59             getCameraCharacteristics_cb _hidl_cb) override {
60         hardware::hidl_vec<uint8_t> cameraCharacteristics;
61         _hidl_cb(Status::OK, cameraCharacteristics);
62         return hardware::Void();
63     }
64 
setTorchModeTestDeviceInterface65     hardware::Return<hardware::camera::common::V1_0::Status> setTorchMode(
66             ::android::hardware::camera::common::V1_0::TorchMode) override {
67         return Status::OK;
68     }
69 
70     using open_cb = std::function<void(
71             ::android::hardware::camera::common::V1_0::Status status,
72              const ::android::sp<ICameraDeviceSession>& session)>;
openTestDeviceInterface73     hardware::Return<void> open(
74             const ::android::sp<ICameraDeviceCallback>&,
75             open_cb _hidl_cb) override {
76         sp<ICameraDeviceSession> deviceSession = nullptr;
77         _hidl_cb(Status::OK, deviceSession);
78         return hardware::Void();
79     }
80 
dumpStateTestDeviceInterface81     hardware::Return<void> dumpState(
82             const ::android::hardware::hidl_handle&) override {
83         return hardware::Void();
84     }
85 };
86 
87 /**
88  * Basic test implementation of a camera provider
89  */
90 struct TestICameraProvider : virtual public provider::V2_4::ICameraProvider {
91     sp<provider::V2_4::ICameraProviderCallback> mCallbacks;
92     std::vector<hardware::hidl_string> mDeviceNames;
93     sp<device::V3_2::ICameraDevice> mDeviceInterface;
94     hardware::hidl_vec<common::V1_0::VendorTagSection> mVendorTagSections;
95 
TestICameraProviderTestICameraProvider96     TestICameraProvider(const std::vector<hardware::hidl_string> &devices,
97             const hardware::hidl_vec<common::V1_0::VendorTagSection> &vendorSection) :
98         mDeviceNames(devices),
99         mDeviceInterface(new TestDeviceInterface(devices)),
100         mVendorTagSections (vendorSection) {}
101 
setCallbackTestICameraProvider102     virtual hardware::Return<Status> setCallback(
103             const sp<provider::V2_4::ICameraProviderCallback>& callbacks) override {
104         mCallbacks = callbacks;
105         return hardware::Return<Status>(Status::OK);
106     }
107 
108     using getVendorTags_cb = std::function<void(Status status,
109             const hardware::hidl_vec<common::V1_0::VendorTagSection>& sections)>;
getVendorTagsTestICameraProvider110     hardware::Return<void> getVendorTags(getVendorTags_cb _hidl_cb) override {
111         _hidl_cb(Status::OK, mVendorTagSections);
112         return hardware::Void();
113     }
114 
115     using isSetTorchModeSupported_cb = std::function<void(
116             ::android::hardware::camera::common::V1_0::Status status,
117              bool support)>;
isSetTorchModeSupportedTestICameraProvider118     virtual ::hardware::Return<void> isSetTorchModeSupported(
119             isSetTorchModeSupported_cb _hidl_cb) override {
120         _hidl_cb(Status::OK, false);
121         return hardware::Void();
122     }
123 
124     using getCameraIdList_cb = std::function<void(Status status,
125             const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames)>;
getCameraIdListTestICameraProvider126     virtual hardware::Return<void> getCameraIdList(getCameraIdList_cb _hidl_cb) override {
127         _hidl_cb(Status::OK, mDeviceNames);
128         return hardware::Void();
129     }
130 
131     using getCameraDeviceInterface_V1_x_cb = std::function<void(Status status,
132             const sp<device::V1_0::ICameraDevice>& device)>;
getCameraDeviceInterface_V1_xTestICameraProvider133     virtual hardware::Return<void> getCameraDeviceInterface_V1_x(
134             const hardware::hidl_string& cameraDeviceName,
135             getCameraDeviceInterface_V1_x_cb _hidl_cb) override {
136         (void) cameraDeviceName;
137         _hidl_cb(Status::OK, nullptr); //TODO: impl. of ver. 1.0 device interface
138                                        //      otherwise enumeration will fail.
139         return hardware::Void();
140     }
141 
142     using getCameraDeviceInterface_V3_x_cb = std::function<void(Status status,
143             const sp<device::V3_2::ICameraDevice>& device)>;
getCameraDeviceInterface_V3_xTestICameraProvider144     virtual hardware::Return<void> getCameraDeviceInterface_V3_x(
145             const hardware::hidl_string&,
146             getCameraDeviceInterface_V3_x_cb _hidl_cb) override {
147         _hidl_cb(Status::OK, mDeviceInterface);
148         return hardware::Void();
149     }
150 
151 };
152 
153 /**
154  * Simple test version of the interaction proxy, to use to inject onRegistered calls to the
155  * CameraProviderManager
156  */
157 struct TestInteractionProxy : public CameraProviderManager::ServiceInteractionProxy {
158     sp<hidl::manager::V1_0::IServiceNotification> mManagerNotificationInterface;
159     sp<TestICameraProvider> mTestCameraProvider;
160 
TestInteractionProxyTestInteractionProxy161     TestInteractionProxy() {}
setProviderTestInteractionProxy162     void setProvider(sp<TestICameraProvider> provider) {
163         mTestCameraProvider = provider;
164     }
165 
166     std::string mLastRequestedServiceName;
167 
~TestInteractionProxyTestInteractionProxy168     virtual ~TestInteractionProxy() {}
169 
registerForNotificationsTestInteractionProxy170     virtual bool registerForNotifications(
171             const std::string &serviceName,
172             const sp<hidl::manager::V1_0::IServiceNotification> &notification) override {
173         (void) serviceName;
174         mManagerNotificationInterface = notification;
175         return true;
176     }
177 
getServiceTestInteractionProxy178     virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService(
179             const std::string &serviceName) override {
180         mLastRequestedServiceName = serviceName;
181         return mTestCameraProvider;
182     }
183 
184 };
185 
186 struct TestStatusListener : public CameraProviderManager::StatusListener {
~TestStatusListenerTestStatusListener187     ~TestStatusListener() {}
188 
onDeviceStatusChangedTestStatusListener189     void onDeviceStatusChanged(const String8 &,
190             hardware::camera::common::V1_0::CameraDeviceStatus) override {}
onTorchStatusChangedTestStatusListener191     void onTorchStatusChanged(const String8 &,
192             hardware::camera::common::V1_0::TorchModeStatus) override {}
onNewProviderRegisteredTestStatusListener193     void onNewProviderRegistered() override {}
194 };
195 
TEST(CameraProviderManagerTest,InitializeTest)196 TEST(CameraProviderManagerTest, InitializeTest) {
197     std::vector<hardware::hidl_string> deviceNames;
198     deviceNames.push_back("device@3.2/test/0");
199     deviceNames.push_back("device@1.0/test/0");
200     deviceNames.push_back("device@3.2/test/1");
201     hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
202     status_t res;
203     sp<CameraProviderManager> providerManager = new CameraProviderManager();
204     sp<TestStatusListener> statusListener = new TestStatusListener();
205     TestInteractionProxy serviceProxy;
206     sp<TestICameraProvider> provider =  new TestICameraProvider(deviceNames,
207             vendorSection);
208     serviceProxy.setProvider(provider);
209 
210     res = providerManager->initialize(statusListener, &serviceProxy);
211     ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
212 
213     hardware::hidl_string legacyInstanceName = "legacy/0";
214     ASSERT_EQ(serviceProxy.mLastRequestedServiceName, legacyInstanceName) <<
215             "Legacy instance not requested from service manager";
216 
217     hardware::hidl_string testProviderFqInterfaceName =
218             "android.hardware.camera.provider@2.4::ICameraProvider";
219     hardware::hidl_string testProviderInstanceName = "test/0";
220     serviceProxy.mManagerNotificationInterface->onRegistration(
221             testProviderFqInterfaceName,
222             testProviderInstanceName, false);
223 
224     ASSERT_EQ(serviceProxy.mLastRequestedServiceName, testProviderInstanceName) <<
225             "Incorrect instance requested from service manager";
226 }
227 
TEST(CameraProviderManagerTest,MultipleVendorTagTest)228 TEST(CameraProviderManagerTest, MultipleVendorTagTest) {
229     hardware::hidl_string sectionName = "VendorTestSection";
230     hardware::hidl_string tagName = "VendorTestTag";
231     uint32_t tagId = VENDOR_SECTION << 16;
232     hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
233     CameraMetadataType tagType = CameraMetadataType::BYTE;
234     vendorSection.resize(1);
235     vendorSection[0].sectionName = sectionName;
236     vendorSection[0].tags.resize(1);
237     vendorSection[0].tags[0].tagId = tagId;
238     vendorSection[0].tags[0].tagName = tagName;
239     vendorSection[0].tags[0].tagType = tagType;
240     std::vector<hardware::hidl_string> deviceNames = {"device@3.2/test/0"};
241 
242     sp<CameraProviderManager> providerManager = new CameraProviderManager();
243     sp<TestStatusListener> statusListener = new TestStatusListener();
244     TestInteractionProxy serviceProxy;
245 
246     sp<TestICameraProvider> provider =  new TestICameraProvider(deviceNames,
247             vendorSection);
248     serviceProxy.setProvider(provider);
249 
250     auto res = providerManager->initialize(statusListener, &serviceProxy);
251     ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
252 
253     hardware::hidl_string testProviderInstanceName = "test/0";
254     hardware::hidl_string testProviderFqInterfaceName =
255             "android.hardware.camera.provider@2.4::ICameraProvider";
256     serviceProxy.mManagerNotificationInterface->onRegistration(
257             testProviderFqInterfaceName, testProviderInstanceName, false);
258     ASSERT_EQ(serviceProxy.mLastRequestedServiceName, testProviderInstanceName) <<
259             "Incorrect instance requested from service manager";
260 
261     hardware::hidl_string sectionNameSecond = "SecondVendorTestSection";
262     hardware::hidl_string secondTagName = "SecondVendorTestTag";
263     CameraMetadataType secondTagType = CameraMetadataType::DOUBLE;
264     vendorSection[0].sectionName = sectionNameSecond;
265     vendorSection[0].tags[0].tagId = tagId;
266     vendorSection[0].tags[0].tagName = secondTagName;
267     vendorSection[0].tags[0].tagType = secondTagType;
268     deviceNames = {"device@3.2/test2/1"};
269 
270     sp<TestICameraProvider> secondProvider =  new TestICameraProvider(
271             deviceNames, vendorSection);
272     serviceProxy.setProvider(secondProvider);
273     hardware::hidl_string testProviderSecondInstanceName = "test2/0";
274     serviceProxy.mManagerNotificationInterface->onRegistration(
275             testProviderFqInterfaceName, testProviderSecondInstanceName, false);
276     ASSERT_EQ(serviceProxy.mLastRequestedServiceName,
277               testProviderSecondInstanceName) <<
278             "Incorrect instance requested from service manager";
279 
280     ASSERT_EQ(NO_ERROR , providerManager->setUpVendorTags());
281     sp<VendorTagDescriptorCache> vendorCache =
282             VendorTagDescriptorCache::getGlobalVendorTagCache();
283     ASSERT_NE(nullptr, vendorCache.get());
284 
285     metadata_vendor_id_t vendorId = std::hash<std::string> {} (
286             testProviderInstanceName.c_str());
287     metadata_vendor_id_t vendorIdSecond = std::hash<std::string> {} (
288             testProviderSecondInstanceName.c_str());
289 
290     hardware::hidl_string resultTag = vendorCache->getTagName(tagId, vendorId);
291     ASSERT_EQ(resultTag, tagName);
292 
293     resultTag = vendorCache->getTagName(tagId, vendorIdSecond);
294     ASSERT_EQ(resultTag, secondTagName);
295 
296     // Check whether we can create two separate CameraMetadata instances
297     // using different tag vendor vendors.
298     camera_metadata *metaBuffer = allocate_camera_metadata(10, 20);
299     ASSERT_NE(nullptr, metaBuffer);
300     set_camera_metadata_vendor_id(metaBuffer, vendorId);
301     CameraMetadata metadata(metaBuffer);
302 
303     uint8_t byteVal = 10;
304     ASSERT_TRUE(metadata.isEmpty());
305     ASSERT_EQ(OK, metadata.update(tagId, &byteVal, 1));
306     ASSERT_FALSE(metadata.isEmpty());
307     ASSERT_TRUE(metadata.exists(tagId));
308 
309     metaBuffer = allocate_camera_metadata(10, 20);
310     ASSERT_NE(nullptr, metaBuffer);
311     set_camera_metadata_vendor_id(metaBuffer, vendorIdSecond);
312     CameraMetadata secondMetadata(metaBuffer);
313 
314     ASSERT_TRUE(secondMetadata.isEmpty());
315     double doubleVal = 1.0f;
316     ASSERT_EQ(OK, secondMetadata.update(tagId, &doubleVal, 1));
317     ASSERT_FALSE(secondMetadata.isEmpty());
318     ASSERT_TRUE(secondMetadata.exists(tagId));
319 
320     // Check whether CameraMetadata copying works as expected
321     CameraMetadata metadataCopy(metadata);
322     ASSERT_FALSE(metadataCopy.isEmpty());
323     ASSERT_TRUE(metadataCopy.exists(tagId));
324     ASSERT_EQ(OK, metadataCopy.update(tagId, &byteVal, 1));
325     ASSERT_TRUE(metadataCopy.exists(tagId));
326 
327     // Check whether values are as expected
328     camera_metadata_entry_t entry = metadata.find(tagId);
329     ASSERT_EQ(1u, entry.count);
330     ASSERT_EQ(byteVal, entry.data.u8[0]);
331     entry = secondMetadata.find(tagId);
332     ASSERT_EQ(1u, entry.count);
333     ASSERT_EQ(doubleVal, entry.data.d[0]);
334 
335     // Swap and erase
336     secondMetadata.swap(metadataCopy);
337     ASSERT_TRUE(metadataCopy.exists(tagId));
338     ASSERT_TRUE(secondMetadata.exists(tagId));
339     ASSERT_EQ(OK, secondMetadata.erase(tagId));
340     ASSERT_TRUE(secondMetadata.isEmpty());
341     doubleVal = 0.0f;
342     ASSERT_EQ(OK, metadataCopy.update(tagId, &doubleVal, 1));
343     entry = metadataCopy.find(tagId);
344     ASSERT_EQ(1u, entry.count);
345     ASSERT_EQ(doubleVal, entry.data.d[0]);
346 
347     // Append
348     uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_ACTION;
349     secondMetadata.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
350     // Append from two different vendor tag providers is not supported!
351     ASSERT_NE(OK, metadataCopy.append(secondMetadata));
352     ASSERT_EQ(OK, metadataCopy.erase(tagId));
353     metadataCopy.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
354     // However appending from same vendor tag provider should be fine
355     ASSERT_EQ(OK, metadata.append(secondMetadata));
356     // Append from a metadata without vendor tag provider should be supported
357     CameraMetadata regularMetadata(10, 20);
358     uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO;
359     regularMetadata.update(ANDROID_CONTROL_MODE, &controlMode, 1);
360     ASSERT_EQ(OK, secondMetadata.append(regularMetadata));
361     ASSERT_EQ(2u, secondMetadata.entryCount());
362     ASSERT_EQ(2u, metadata.entryCount());
363 
364     // Dump
365     metadata.dump(1, 2);
366     metadataCopy.dump(1, 2);
367     secondMetadata.dump(1, 2);
368 }
369