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
35namespace 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 */
42class HidlVendorTagDescriptor : public VendorTagDescriptor {
43public:
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 */
66class CameraProviderManager : virtual public hidl::manager::V1_0::IServiceNotification {
67public:
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;
80        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 {
86        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        }
93        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 {
103        ~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
240private:
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
297            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;
302            virtual status_t getCameraCharacteristics(CameraMetadata *characteristics) const {
303                (void) characteristics;
304                return INVALID_OPERATION;
305            }
306
307            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
334            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