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 #ifndef ANDROID_SERVERS_CAMERA_CAMERAPROVIDER_H
18 #define ANDROID_SERVERS_CAMERA_CAMERAPROVIDER_H
19 
20 #include <vector>
21 #include <unordered_set>
22 #include <string>
23 #include <mutex>
24 
25 #include <camera/CameraParameters2.h>
26 #include <camera/CameraMetadata.h>
27 #include <camera/CameraBase.h>
28 #include <utils/Errors.h>
29 #include <android/hardware/camera/common/1.0/types.h>
30 #include <android/hardware/camera/provider/2.4/ICameraProvider.h>
31 //#include <android/hardware/camera/provider/2.4/ICameraProviderCallbacks.h>
32 #include <android/hidl/manager/1.0/IServiceNotification.h>
33 #include <camera/VendorTagDescriptor.h>
34 
35 namespace android {
36 
37 /**
38  * The vendor tag descriptor class that takes HIDL vendor tag information as
39  * input. Not part of VendorTagDescriptor class because that class is used
40  * in AIDL generated sources which don't have access to HIDL headers.
41  */
42 class HidlVendorTagDescriptor : public VendorTagDescriptor {
43 public:
44     /**
45      * Create a VendorTagDescriptor object from the HIDL VendorTagSection
46      * vector.
47      *
48      * Returns OK on success, or a negative error code.
49      */
50     static status_t createDescriptorFromHidl(
51             const hardware::hidl_vec<hardware::camera::common::V1_0::VendorTagSection>& vts,
52             /*out*/
53             sp<VendorTagDescriptor>& descriptor);
54 };
55 
56 /**
57  * A manager for all camera providers available on an Android device.
58  *
59  * Responsible for enumerating providers and the individual camera devices
60  * they export, both at startup and as providers and devices are added/removed.
61  *
62  * Provides methods for requesting information about individual devices and for
63  * opening them for active use.
64  *
65  */
66 class CameraProviderManager : virtual public hidl::manager::V1_0::IServiceNotification {
67 public:
68 
69     ~CameraProviderManager();
70 
71     // Tiny proxy for the static methods in a HIDL interface that communicate with the hardware
72     // service manager, to be replacable in unit tests with a fake.
73     struct ServiceInteractionProxy {
74         virtual bool registerForNotifications(
75                 const std::string &serviceName,
76                 const sp<hidl::manager::V1_0::IServiceNotification>
77                 &notification) = 0;
78         virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService(
79                 const std::string &serviceName) = 0;
~ServiceInteractionProxyServiceInteractionProxy80         virtual ~ServiceInteractionProxy() {}
81     };
82 
83     // Standard use case - call into the normal generated static methods which invoke
84     // the real hardware service manager
85     struct HardwareServiceInteractionProxy : public ServiceInteractionProxy {
registerForNotificationsHardwareServiceInteractionProxy86         virtual bool registerForNotifications(
87                 const std::string &serviceName,
88                 const sp<hidl::manager::V1_0::IServiceNotification>
89                 &notification) override {
90             return hardware::camera::provider::V2_4::ICameraProvider::registerForNotifications(
91                     serviceName, notification);
92         }
getServiceHardwareServiceInteractionProxy93         virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService(
94                 const std::string &serviceName) override {
95             return hardware::camera::provider::V2_4::ICameraProvider::getService(serviceName);
96         }
97     };
98 
99     /**
100      * Listener interface for device/torch status changes
101      */
102     struct StatusListener : virtual public RefBase {
~StatusListenerStatusListener103         ~StatusListener() {}
104 
105         virtual void onDeviceStatusChanged(const String8 &cameraId,
106                 hardware::camera::common::V1_0::CameraDeviceStatus newStatus) = 0;
107         virtual void onTorchStatusChanged(const String8 &cameraId,
108                 hardware::camera::common::V1_0::TorchModeStatus newStatus) = 0;
109         virtual void onNewProviderRegistered() = 0;
110     };
111 
112     /**
113      * Initialize the manager and give it a status listener; optionally accepts a service
114      * interaction proxy.
115      *
116      * The default proxy communicates via the hardware service manager; alternate proxies can be
117      * used for testing. The lifetime of the proxy must exceed the lifetime of the manager.
118      */
119     status_t initialize(wp<StatusListener> listener,
120             ServiceInteractionProxy *proxy = &sHardwareServiceInteractionProxy);
121 
122     /**
123      * Retrieve the total number of available cameras. This value may change dynamically as cameras
124      * are added or removed.
125      */
126     int getCameraCount() const;
127 
128     std::vector<std::string> getCameraDeviceIds() const;
129 
130     /**
131      * Retrieve the number of API1 compatible cameras; these are internal and
132      * backwards-compatible. This is the set of cameras that will be
133      * accessible via the old camera API.
134      * The return value may change dynamically due to external camera hotplug.
135      */
136     std::vector<std::string> getAPI1CompatibleCameraDeviceIds() const;
137 
138     /**
139      * Return true if a device with a given ID and major version exists
140      */
141     bool isValidDevice(const std::string &id, uint16_t majorVersion) const;
142 
143     /**
144      * Return true if a device with a given ID has a flash unit. Returns false
145      * for devices that are unknown.
146      */
147     bool hasFlashUnit(const std::string &id) const;
148 
149     /**
150      * Return the resource cost of this camera device
151      */
152     status_t getResourceCost(const std::string &id,
153             hardware::camera::common::V1_0::CameraResourceCost* cost) const;
154 
155     /**
156      * Return the old camera API camera info
157      */
158     status_t getCameraInfo(const std::string &id,
159             hardware::CameraInfo* info) const;
160 
161     /**
162      * Return API2 camera characteristics - returns NAME_NOT_FOUND if a device ID does
163      * not have a v3 or newer HAL version.
164      */
165     status_t getCameraCharacteristics(const std::string &id,
166             CameraMetadata* characteristics) const;
167 
168     /**
169      * Return the highest supported device interface version for this ID
170      */
171     status_t getHighestSupportedVersion(const std::string &id,
172             hardware::hidl_version *v);
173 
174     /**
175      * Check if a given camera device support setTorchMode API.
176      */
177     bool supportSetTorchMode(const std::string &id);
178 
179     /**
180      * Turn on or off the flashlight on a given camera device.
181      * May fail if the device does not support this API, is in active use, or if the device
182      * doesn't exist, etc.
183      */
184     status_t setTorchMode(const std::string &id, bool enabled);
185 
186     /**
187      * Setup vendor tags for all registered providers
188      */
189     status_t setUpVendorTags();
190 
191     /**
192      * Open an active session to a camera device.
193      *
194      * This fully powers on the camera device hardware, and returns a handle to a
195      * session to be used for hardware configuration and operation.
196      */
197     status_t openSession(const std::string &id,
198             const sp<hardware::camera::device::V3_2::ICameraDeviceCallback>& callback,
199             /*out*/
200             sp<hardware::camera::device::V3_2::ICameraDeviceSession> *session);
201 
202     status_t openSession(const std::string &id,
203             const sp<hardware::camera::device::V1_0::ICameraDeviceCallback>& callback,
204             /*out*/
205             sp<hardware::camera::device::V1_0::ICameraDevice> *session);
206 
207     /**
208      * IServiceNotification::onRegistration
209      * Invoked by the hardware service manager when a new camera provider is registered
210      */
211     virtual hardware::Return<void> onRegistration(const hardware::hidl_string& fqName,
212             const hardware::hidl_string& name,
213             bool preexisting) override;
214 
215     /**
216      * Dump out information about available providers and devices
217      */
218     status_t dump(int fd, const Vector<String16>& args);
219 
220     /**
221      * Conversion methods between HAL Status and status_t and strings
222      */
223     static status_t mapToStatusT(const hardware::camera::common::V1_0::Status& s);
224     static const char* statusToString(const hardware::camera::common::V1_0::Status& s);
225 
226     /*
227      * Return provider type for a specific device.
228      */
229     metadata_vendor_id_t getProviderTagIdLocked(const std::string& id,
230             hardware::hidl_version minVersion = hardware::hidl_version{0,0},
231             hardware::hidl_version maxVersion = hardware::hidl_version{1000,0}) const;
232 
233     /*
234      * Check if a camera with staticInfo is a logical camera. And if yes, return
235      * the physical camera ids.
236      */
237     static bool isLogicalCamera(const CameraMetadata& staticInfo,
238             std::vector<std::string>* physicalCameraIds);
239 
240 private:
241     // All private members, unless otherwise noted, expect mInterfaceMutex to be locked before use
242     mutable std::mutex mInterfaceMutex;
243 
244     // the status listener update callbacks will lock mStatusMutex
245     mutable std::mutex mStatusListenerMutex;
246     wp<StatusListener> mListener;
247     ServiceInteractionProxy* mServiceProxy;
248 
249     static HardwareServiceInteractionProxy sHardwareServiceInteractionProxy;
250 
251     struct ProviderInfo :
252             virtual public hardware::camera::provider::V2_4::ICameraProviderCallback,
253             virtual public hardware::hidl_death_recipient
254     {
255         const std::string mProviderName;
256         const sp<hardware::camera::provider::V2_4::ICameraProvider> mInterface;
257         const metadata_vendor_id_t mProviderTagid;
258 
259         ProviderInfo(const std::string &providerName,
260                 sp<hardware::camera::provider::V2_4::ICameraProvider>& interface,
261                 CameraProviderManager *manager);
262         ~ProviderInfo();
263 
264         status_t initialize();
265 
266         const std::string& getType() const;
267 
268         status_t addDevice(const std::string& name,
269                 hardware::camera::common::V1_0::CameraDeviceStatus initialStatus =
270                 hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT,
271                 /*out*/ std::string *parsedId = nullptr);
272 
273         status_t dump(int fd, const Vector<String16>& args) const;
274 
275         // ICameraProviderCallbacks interface - these lock the parent mInterfaceMutex
276         virtual hardware::Return<void> cameraDeviceStatusChange(
277                 const hardware::hidl_string& cameraDeviceName,
278                 hardware::camera::common::V1_0::CameraDeviceStatus newStatus) override;
279         virtual hardware::Return<void> torchModeStatusChange(
280                 const hardware::hidl_string& cameraDeviceName,
281                 hardware::camera::common::V1_0::TorchModeStatus newStatus) override;
282 
283         // hidl_death_recipient interface - this locks the parent mInterfaceMutex
284         virtual void serviceDied(uint64_t cookie, const wp<hidl::base::V1_0::IBase>& who) override;
285 
286         // Basic device information, common to all camera devices
287         struct DeviceInfo {
288             const std::string mName;  // Full instance name
289             const std::string mId;    // ID section of full name
290             const hardware::hidl_version mVersion;
291             const metadata_vendor_id_t mProviderTagid;
292 
293             const hardware::camera::common::V1_0::CameraResourceCost mResourceCost;
294 
295             hardware::camera::common::V1_0::CameraDeviceStatus mStatus;
296 
hasFlashUnitProviderInfo::DeviceInfo297             bool hasFlashUnit() const { return mHasFlashUnit; }
298             virtual status_t setTorchMode(bool enabled) = 0;
299             virtual status_t getCameraInfo(hardware::CameraInfo *info) const = 0;
300             virtual bool isAPI1Compatible() const = 0;
301             virtual status_t dumpState(int fd) const = 0;
getCameraCharacteristicsProviderInfo::DeviceInfo302             virtual status_t getCameraCharacteristics(CameraMetadata *characteristics) const {
303                 (void) characteristics;
304                 return INVALID_OPERATION;
305             }
306 
DeviceInfoProviderInfo::DeviceInfo307             DeviceInfo(const std::string& name, const metadata_vendor_id_t tagId,
308                     const std::string &id, const hardware::hidl_version& version,
309                     const hardware::camera::common::V1_0::CameraResourceCost& resourceCost) :
310                     mName(name), mId(id), mVersion(version), mProviderTagid(tagId),
311                     mResourceCost(resourceCost),
312                     mStatus(hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT),
313                     mHasFlashUnit(false) {}
314             virtual ~DeviceInfo();
315         protected:
316             bool mHasFlashUnit;
317 
318             template<class InterfaceT>
319             static status_t setTorchMode(InterfaceT& interface, bool enabled);
320         };
321         std::vector<std::unique_ptr<DeviceInfo>> mDevices;
322         std::unordered_set<std::string> mUniqueCameraIds;
323         int mUniqueDeviceCount;
324         std::vector<std::string> mUniqueAPI1CompatibleCameraIds;
325 
326         // HALv1-specific camera fields, including the actual device interface
327         struct DeviceInfo1 : public DeviceInfo {
328             typedef hardware::camera::device::V1_0::ICameraDevice InterfaceT;
329             const sp<InterfaceT> mInterface;
330 
331             virtual status_t setTorchMode(bool enabled) override;
332             virtual status_t getCameraInfo(hardware::CameraInfo *info) const override;
333             //In case of Device1Info assume that we are always API1 compatible
isAPI1CompatibleProviderInfo::DeviceInfo1334             virtual bool isAPI1Compatible() const override { return true; }
335             virtual status_t dumpState(int fd) const override;
336             DeviceInfo1(const std::string& name, const metadata_vendor_id_t tagId,
337                     const std::string &id, uint16_t minorVersion,
338                     const hardware::camera::common::V1_0::CameraResourceCost& resourceCost,
339                     sp<InterfaceT> interface);
340             virtual ~DeviceInfo1();
341         private:
342             CameraParameters2 mDefaultParameters;
343         };
344 
345         // HALv3-specific camera fields, including the actual device interface
346         struct DeviceInfo3 : public DeviceInfo {
347             typedef hardware::camera::device::V3_2::ICameraDevice InterfaceT;
348             const sp<InterfaceT> mInterface;
349 
350             virtual status_t setTorchMode(bool enabled) override;
351             virtual status_t getCameraInfo(hardware::CameraInfo *info) const override;
352             virtual bool isAPI1Compatible() const override;
353             virtual status_t dumpState(int fd) const override;
354             virtual status_t getCameraCharacteristics(
355                     CameraMetadata *characteristics) const override;
356 
357             DeviceInfo3(const std::string& name, const metadata_vendor_id_t tagId,
358                     const std::string &id, uint16_t minorVersion,
359                     const hardware::camera::common::V1_0::CameraResourceCost& resourceCost,
360                     sp<InterfaceT> interface);
361             virtual ~DeviceInfo3();
362         private:
363             CameraMetadata mCameraCharacteristics;
364         };
365 
366     private:
367         std::string mType;
368         uint32_t mId;
369 
370         std::mutex mLock;
371 
372         CameraProviderManager *mManager;
373 
374         bool mInitialized = false;
375 
376         // Templated method to instantiate the right kind of DeviceInfo and call the
377         // right CameraProvider getCameraDeviceInterface_* method.
378         template<class DeviceInfoT>
379         std::unique_ptr<DeviceInfo> initializeDeviceInfo(const std::string &name,
380                 const metadata_vendor_id_t tagId, const std::string &id,
381                 uint16_t minorVersion) const;
382 
383         // Helper for initializeDeviceInfo to use the right CameraProvider get method.
384         template<class InterfaceT>
385         sp<InterfaceT> getDeviceInterface(const std::string &name) const;
386 
387         // Parse provider instance name for type and id
388         static status_t parseProviderName(const std::string& name,
389                 std::string *type, uint32_t *id);
390 
391         // Parse device instance name for device version, type, and id.
392         static status_t parseDeviceName(const std::string& name,
393                 uint16_t *major, uint16_t *minor, std::string *type, std::string *id);
394 
395         // Generate vendor tag id
396         static metadata_vendor_id_t generateVendorTagId(const std::string &name);
397 
398         void removeDevice(std::string id);
399     };
400 
401     // Utility to find a DeviceInfo by ID; pointer is only valid while mInterfaceMutex is held
402     // and the calling code doesn't mutate the list of providers or their lists of devices.
403     // Finds the first device of the given ID that falls within the requested version range
404     //   minVersion <= deviceVersion < maxVersion
405     // No guarantees on the order of traversal
406     ProviderInfo::DeviceInfo* findDeviceInfoLocked(const std::string& id,
407             hardware::hidl_version minVersion = hardware::hidl_version{0,0},
408             hardware::hidl_version maxVersion = hardware::hidl_version{1000,0}) const;
409 
410     status_t addProviderLocked(const std::string& newProvider, bool expected = true);
411 
412     status_t removeProvider(const std::string& provider);
413     sp<StatusListener> getStatusListener() const;
414 
415     bool isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const;
416 
417     std::vector<sp<ProviderInfo>> mProviders;
418 
419     static const char* deviceStatusToString(
420         const hardware::camera::common::V1_0::CameraDeviceStatus&);
421     static const char* torchStatusToString(
422         const hardware::camera::common::V1_0::TorchModeStatus&);
423 
424     status_t getCameraCharacteristicsLocked(const std::string &id,
425             CameraMetadata* characteristics) const;
426     void filterLogicalCameraIdsLocked(std::vector<std::string>& deviceIds) const;
427 };
428 
429 } // namespace android
430 
431 #endif
432