/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_SERVERS_CAMERA_CAMERAPROVIDER_H
#define ANDROID_SERVERS_CAMERA_CAMERAPROVIDER_H
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <string>
#include <mutex>
#include <camera/CameraParameters2.h>
#include <camera/CameraMetadata.h>
#include <camera/CameraBase.h>
#include <utils/Errors.h>
#include <android/hardware/camera/common/1.0/types.h>
#include <android/hardware/camera/provider/2.5/ICameraProvider.h>
#include <android/hardware/camera/device/3.4/ICameraDeviceSession.h>
#include <android/hidl/manager/1.0/IServiceNotification.h>
#include <camera/VendorTagDescriptor.h>
namespace android {
/**
* The vendor tag descriptor class that takes HIDL vendor tag information as
* input. Not part of VendorTagDescriptor class because that class is used
* in AIDL generated sources which don't have access to HIDL headers.
*/
class HidlVendorTagDescriptor : public VendorTagDescriptor {
public:
/**
* Create a VendorTagDescriptor object from the HIDL VendorTagSection
* vector.
*
* Returns OK on success, or a negative error code.
*/
static status_t createDescriptorFromHidl(
const hardware::hidl_vec<hardware::camera::common::V1_0::VendorTagSection>& vts,
/*out*/
sp<VendorTagDescriptor>& descriptor);
};
/**
* A manager for all camera providers available on an Android device.
*
* Responsible for enumerating providers and the individual camera devices
* they export, both at startup and as providers and devices are added/removed.
*
* Provides methods for requesting information about individual devices and for
* opening them for active use.
*
*/
class CameraProviderManager : virtual public hidl::manager::V1_0::IServiceNotification {
public:
~CameraProviderManager();
// Tiny proxy for the static methods in a HIDL interface that communicate with the hardware
// service manager, to be replacable in unit tests with a fake.
struct ServiceInteractionProxy {
virtual bool registerForNotifications(
const std::string &serviceName,
const sp<hidl::manager::V1_0::IServiceNotification>
¬ification) = 0;
virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService(
const std::string &serviceName) = 0;
virtual ~ServiceInteractionProxy() {}
};
// Standard use case - call into the normal generated static methods which invoke
// the real hardware service manager
struct HardwareServiceInteractionProxy : public ServiceInteractionProxy {
virtual bool registerForNotifications(
const std::string &serviceName,
const sp<hidl::manager::V1_0::IServiceNotification>
¬ification) override {
return hardware::camera::provider::V2_4::ICameraProvider::registerForNotifications(
serviceName, notification);
}
virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService(
const std::string &serviceName) override {
return hardware::camera::provider::V2_4::ICameraProvider::getService(serviceName);
}
};
/**
* Listener interface for device/torch status changes
*/
struct StatusListener : virtual public RefBase {
~StatusListener() {}
virtual void onDeviceStatusChanged(const String8 &cameraId,
hardware::camera::common::V1_0::CameraDeviceStatus newStatus) = 0;
virtual void onTorchStatusChanged(const String8 &cameraId,
hardware::camera::common::V1_0::TorchModeStatus newStatus) = 0;
virtual void onNewProviderRegistered() = 0;
};
/**
* Represents the mode a camera device is currently in
*/
enum class DeviceMode {
TORCH,
CAMERA
};
/**
* Initialize the manager and give it a status listener; optionally accepts a service
* interaction proxy.
*
* The default proxy communicates via the hardware service manager; alternate proxies can be
* used for testing. The lifetime of the proxy must exceed the lifetime of the manager.
*/
status_t initialize(wp<StatusListener> listener,
ServiceInteractionProxy *proxy = &sHardwareServiceInteractionProxy);
/**
* Retrieve the total number of available cameras. This value may change dynamically as cameras
* are added or removed.
*/
int getCameraCount() const;
std::vector<std::string> getCameraDeviceIds() const;
/**
* Retrieve the number of API1 compatible cameras; these are internal and
* backwards-compatible. This is the set of cameras that will be
* accessible via the old camera API.
* The return value may change dynamically due to external camera hotplug.
*/
std::vector<std::string> getAPI1CompatibleCameraDeviceIds() const;
/**
* Return true if a device with a given ID and major version exists
*/
bool isValidDevice(const std::string &id, uint16_t majorVersion) const;
/**
* Return true if a device with a given ID has a flash unit. Returns false
* for devices that are unknown.
*/
bool hasFlashUnit(const std::string &id) const;
/**
* Return the resource cost of this camera device
*/
status_t getResourceCost(const std::string &id,
hardware::camera::common::V1_0::CameraResourceCost* cost) const;
/**
* Return the old camera API camera info
*/
status_t getCameraInfo(const std::string &id,
hardware::CameraInfo* info) const;
/**
* Return API2 camera characteristics - returns NAME_NOT_FOUND if a device ID does
* not have a v3 or newer HAL version.
*/
status_t getCameraCharacteristics(const std::string &id,
CameraMetadata* characteristics) const;
/**
* Check for device support of specific stream combination.
*/
status_t isSessionConfigurationSupported(const std::string& id,
const hardware::camera::device::V3_4::StreamConfiguration &configuration,
bool *status /*out*/) const;
/**
* Return the highest supported device interface version for this ID
*/
status_t getHighestSupportedVersion(const std::string &id,
hardware::hidl_version *v);
/**
* Check if a given camera device support setTorchMode API.
*/
bool supportSetTorchMode(const std::string &id) const;
/**
* Turn on or off the flashlight on a given camera device.
* May fail if the device does not support this API, is in active use, or if the device
* doesn't exist, etc.
*/
status_t setTorchMode(const std::string &id, bool enabled);
/**
* Setup vendor tags for all registered providers
*/
status_t setUpVendorTags();
/**
* Inform registered providers about a device state change, such as folding or unfolding
*/
status_t notifyDeviceStateChange(
android::hardware::hidl_bitfield<hardware::camera::provider::V2_5::DeviceState> newState);
/**
* Open an active session to a camera device.
*
* This fully powers on the camera device hardware, and returns a handle to a
* session to be used for hardware configuration and operation.
*/
status_t openSession(const std::string &id,
const sp<hardware::camera::device::V3_2::ICameraDeviceCallback>& callback,
/*out*/
sp<hardware::camera::device::V3_2::ICameraDeviceSession> *session);
status_t openSession(const std::string &id,
const sp<hardware::camera::device::V1_0::ICameraDeviceCallback>& callback,
/*out*/
sp<hardware::camera::device::V1_0::ICameraDevice> *session);
/**
* Save the ICameraProvider while it is being used by a camera or torch client
*/
void saveRef(DeviceMode usageType, const std::string &cameraId,
sp<hardware::camera::provider::V2_4::ICameraProvider> provider);
/**
* Notify that the camera or torch is no longer being used by a camera client
*/
void removeRef(DeviceMode usageType, const std::string &cameraId);
/**
* IServiceNotification::onRegistration
* Invoked by the hardware service manager when a new camera provider is registered
*/
virtual hardware::Return<void> onRegistration(const hardware::hidl_string& fqName,
const hardware::hidl_string& name,
bool preexisting) override;
/**
* Dump out information about available providers and devices
*/
status_t dump(int fd, const Vector<String16>& args);
/**
* Conversion methods between HAL Status and status_t and strings
*/
static status_t mapToStatusT(const hardware::camera::common::V1_0::Status& s);
static const char* statusToString(const hardware::camera::common::V1_0::Status& s);
/*
* Return provider type for a specific device.
*/
metadata_vendor_id_t getProviderTagIdLocked(const std::string& id,
hardware::hidl_version minVersion = hardware::hidl_version{0,0},
hardware::hidl_version maxVersion = hardware::hidl_version{1000,0}) const;
/*
* Check if a camera is a logical camera. And if yes, return
* the physical camera ids.
*/
bool isLogicalCamera(const std::string& id, std::vector<std::string>* physicalCameraIds);
bool isPublicallyHiddenSecureCamera(const std::string& id);
bool isHiddenPhysicalCamera(const std::string& cameraId);
static const float kDepthARTolerance;
private:
// All private members, unless otherwise noted, expect mInterfaceMutex to be locked before use
mutable std::mutex mInterfaceMutex;
// the status listener update callbacks will lock mStatusMutex
mutable std::mutex mStatusListenerMutex;
wp<StatusListener> mListener;
ServiceInteractionProxy* mServiceProxy;
// Current overall Android device physical status
android::hardware::hidl_bitfield<hardware::camera::provider::V2_5::DeviceState> mDeviceState;
// mProviderLifecycleLock is locked during onRegistration and removeProvider
mutable std::mutex mProviderLifecycleLock;
static HardwareServiceInteractionProxy sHardwareServiceInteractionProxy;
// Mapping from CameraDevice IDs to CameraProviders. This map is used to keep the
// ICameraProvider alive while it is in use by the camera with the given ID for camera
// capabilities
std::unordered_map<std::string, sp<hardware::camera::provider::V2_4::ICameraProvider>>
mCameraProviderByCameraId;
// Mapping from CameraDevice IDs to CameraProviders. This map is used to keep the
// ICameraProvider alive while it is in use by the camera with the given ID for torch
// capabilities
std::unordered_map<std::string, sp<hardware::camera::provider::V2_4::ICameraProvider>>
mTorchProviderByCameraId;
// Lock for accessing mCameraProviderByCameraId and mTorchProviderByCameraId
std::mutex mProviderInterfaceMapLock;
struct ProviderInfo :
virtual public hardware::camera::provider::V2_4::ICameraProviderCallback,
virtual public hardware::hidl_death_recipient
{
const std::string mProviderName;
const metadata_vendor_id_t mProviderTagid;
int mMinorVersion;
sp<VendorTagDescriptor> mVendorTagDescriptor;
bool mSetTorchModeSupported;
bool mIsRemote;
// Current overall Android device physical status
hardware::hidl_bitfield<hardware::camera::provider::V2_5::DeviceState> mDeviceState;
// This pointer is used to keep a reference to the ICameraProvider that was last accessed.
wp<hardware::camera::provider::V2_4::ICameraProvider> mActiveInterface;
sp<hardware::camera::provider::V2_4::ICameraProvider> mSavedInterface;
ProviderInfo(const std::string &providerName,
CameraProviderManager *manager);
~ProviderInfo();
status_t initialize(sp<hardware::camera::provider::V2_4::ICameraProvider>& interface,
hardware::hidl_bitfield<hardware::camera::provider::V2_5::DeviceState>
currentDeviceState);
const sp<hardware::camera::provider::V2_4::ICameraProvider> startProviderInterface();
const std::string& getType() const;
status_t addDevice(const std::string& name,
hardware::camera::common::V1_0::CameraDeviceStatus initialStatus =
hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT,
/*out*/ std::string *parsedId = nullptr);
status_t dump(int fd, const Vector<String16>& args) const;
// ICameraProviderCallbacks interface - these lock the parent mInterfaceMutex
virtual hardware::Return<void> cameraDeviceStatusChange(
const hardware::hidl_string& cameraDeviceName,
hardware::camera::common::V1_0::CameraDeviceStatus newStatus) override;
virtual hardware::Return<void> torchModeStatusChange(
const hardware::hidl_string& cameraDeviceName,
hardware::camera::common::V1_0::TorchModeStatus newStatus) override;
// hidl_death_recipient interface - this locks the parent mInterfaceMutex
virtual void serviceDied(uint64_t cookie, const wp<hidl::base::V1_0::IBase>& who) override;
/**
* Setup vendor tags for this provider
*/
status_t setUpVendorTags();
/**
* Notify provider about top-level device physical state changes
*/
status_t notifyDeviceStateChange(
hardware::hidl_bitfield<hardware::camera::provider::V2_5::DeviceState>
newDeviceState);
// Basic device information, common to all camera devices
struct DeviceInfo {
const std::string mName; // Full instance name
const std::string mId; // ID section of full name
const hardware::hidl_version mVersion;
const metadata_vendor_id_t mProviderTagid;
bool mIsLogicalCamera;
std::vector<std::string> mPhysicalIds;
hardware::CameraInfo mInfo;
sp<IBase> mSavedInterface;
bool mIsPublicallyHiddenSecureCamera = false;
const hardware::camera::common::V1_0::CameraResourceCost mResourceCost;
hardware::camera::common::V1_0::CameraDeviceStatus mStatus;
sp<ProviderInfo> mParentProvider;
bool hasFlashUnit() const { return mHasFlashUnit; }
virtual status_t setTorchMode(bool enabled) = 0;
virtual status_t getCameraInfo(hardware::CameraInfo *info) const = 0;
virtual bool isAPI1Compatible() const = 0;
virtual status_t dumpState(int fd) = 0;
virtual status_t getCameraCharacteristics(CameraMetadata *characteristics) const {
(void) characteristics;
return INVALID_OPERATION;
}
virtual status_t getPhysicalCameraCharacteristics(const std::string& physicalCameraId,
CameraMetadata *characteristics) const {
(void) physicalCameraId;
(void) characteristics;
return INVALID_OPERATION;
}
virtual status_t isSessionConfigurationSupported(
const hardware::camera::device::V3_4::StreamConfiguration &/*configuration*/,
bool * /*status*/) {
return INVALID_OPERATION;
}
template<class InterfaceT>
sp<InterfaceT> startDeviceInterface();
DeviceInfo(const std::string& name, const metadata_vendor_id_t tagId,
const std::string &id, const hardware::hidl_version& version,
const std::vector<std::string>& publicCameraIds,
const hardware::camera::common::V1_0::CameraResourceCost& resourceCost,
sp<ProviderInfo> parentProvider) :
mName(name), mId(id), mVersion(version), mProviderTagid(tagId),
mIsLogicalCamera(false), mResourceCost(resourceCost),
mStatus(hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT),
mParentProvider(parentProvider), mHasFlashUnit(false),
mPublicCameraIds(publicCameraIds) {}
virtual ~DeviceInfo();
protected:
bool mHasFlashUnit;
const std::vector<std::string>& mPublicCameraIds;
template<class InterfaceT>
static status_t setTorchMode(InterfaceT& interface, bool enabled);
template<class InterfaceT>
status_t setTorchModeForDevice(bool enabled) {
// Don't save the ICameraProvider interface here because we assume that this was
// called from CameraProviderManager::setTorchMode(), which does save it.
const sp<InterfaceT> interface = startDeviceInterface<InterfaceT>();
return DeviceInfo::setTorchMode(interface, enabled);
}
};
std::vector<std::unique_ptr<DeviceInfo>> mDevices;
std::unordered_set<std::string> mUniqueCameraIds;
int mUniqueDeviceCount;
std::vector<std::string> mUniqueAPI1CompatibleCameraIds;
// The initial public camera IDs published by the camera provider.
// Currently logical multi-camera is not supported for hot-plug camera.
// And we use this list to keep track of initial public camera IDs
// advertised by the provider, and to distinguish against "hidden"
// physical camera IDs.
std::vector<std::string> mProviderPublicCameraIds;
// HALv1-specific camera fields, including the actual device interface
struct DeviceInfo1 : public DeviceInfo {
typedef hardware::camera::device::V1_0::ICameraDevice InterfaceT;
virtual status_t setTorchMode(bool enabled) override;
virtual status_t getCameraInfo(hardware::CameraInfo *info) const override;
//In case of Device1Info assume that we are always API1 compatible
virtual bool isAPI1Compatible() const override { return true; }
virtual status_t dumpState(int fd) override;
DeviceInfo1(const std::string& name, const metadata_vendor_id_t tagId,
const std::string &id, uint16_t minorVersion,
const hardware::camera::common::V1_0::CameraResourceCost& resourceCost,
sp<ProviderInfo> parentProvider,
const std::vector<std::string>& publicCameraIds,
sp<InterfaceT> interface);
virtual ~DeviceInfo1();
private:
CameraParameters2 mDefaultParameters;
status_t cacheCameraInfo(sp<InterfaceT> interface);
};
// HALv3-specific camera fields, including the actual device interface
struct DeviceInfo3 : public DeviceInfo {
typedef hardware::camera::device::V3_2::ICameraDevice InterfaceT;
virtual status_t setTorchMode(bool enabled) override;
virtual status_t getCameraInfo(hardware::CameraInfo *info) const override;
virtual bool isAPI1Compatible() const override;
virtual status_t dumpState(int fd) override;
virtual status_t getCameraCharacteristics(
CameraMetadata *characteristics) const override;
virtual status_t getPhysicalCameraCharacteristics(const std::string& physicalCameraId,
CameraMetadata *characteristics) const override;
virtual status_t isSessionConfigurationSupported(
const hardware::camera::device::V3_4::StreamConfiguration &configuration,
bool *status /*out*/)
override;
DeviceInfo3(const std::string& name, const metadata_vendor_id_t tagId,
const std::string &id, uint16_t minorVersion,
const hardware::camera::common::V1_0::CameraResourceCost& resourceCost,
sp<ProviderInfo> parentProvider,
const std::vector<std::string>& publicCameraIds, sp<InterfaceT> interface);
virtual ~DeviceInfo3();
private:
CameraMetadata mCameraCharacteristics;
std::unordered_map<std::string, CameraMetadata> mPhysicalCameraCharacteristics;
void queryPhysicalCameraIds();
bool isPublicallyHiddenSecureCamera();
status_t fixupMonochromeTags();
status_t addDynamicDepthTags();
static void getSupportedSizes(const CameraMetadata& ch, uint32_t tag,
android_pixel_format_t format,
std::vector<std::tuple<size_t, size_t>> *sizes /*out*/);
void getSupportedDurations( const CameraMetadata& ch, uint32_t tag,
android_pixel_format_t format,
const std::vector<std::tuple<size_t, size_t>>& sizes,
std::vector<int64_t> *durations/*out*/);
void getSupportedDynamicDepthDurations(const std::vector<int64_t>& depthDurations,
const std::vector<int64_t>& blobDurations,
std::vector<int64_t> *dynamicDepthDurations /*out*/);
static bool isDepthPhotoLibraryPresent();
static void getSupportedDynamicDepthSizes(
const std::vector<std::tuple<size_t, size_t>>& blobSizes,
const std::vector<std::tuple<size_t, size_t>>& depthSizes,
std::vector<std::tuple<size_t, size_t>> *dynamicDepthSizes /*out*/,
std::vector<std::tuple<size_t, size_t>> *internalDepthSizes /*out*/);
status_t removeAvailableKeys(CameraMetadata& c, const std::vector<uint32_t>& keys,
uint32_t keyTag);
status_t fillHeicStreamCombinations(std::vector<int32_t>* outputs,
std::vector<int64_t>* durations,
std::vector<int64_t>* stallDurations,
const camera_metadata_entry& halStreamConfigs,
const camera_metadata_entry& halStreamDurations);
status_t deriveHeicTags();
};
private:
std::string mType;
uint32_t mId;
std::mutex mLock;
CameraProviderManager *mManager;
bool mInitialized = false;
// Templated method to instantiate the right kind of DeviceInfo and call the
// right CameraProvider getCameraDeviceInterface_* method.
template<class DeviceInfoT>
std::unique_ptr<DeviceInfo> initializeDeviceInfo(const std::string &name,
const metadata_vendor_id_t tagId, const std::string &id,
uint16_t minorVersion);
// Helper for initializeDeviceInfo to use the right CameraProvider get method.
template<class InterfaceT>
sp<InterfaceT> startDeviceInterface(const std::string &name);
// Parse provider instance name for type and id
static status_t parseProviderName(const std::string& name,
std::string *type, uint32_t *id);
// Parse device instance name for device version, type, and id.
static status_t parseDeviceName(const std::string& name,
uint16_t *major, uint16_t *minor, std::string *type, std::string *id);
// Generate vendor tag id
static metadata_vendor_id_t generateVendorTagId(const std::string &name);
void removeDevice(std::string id);
};
// Utility to find a DeviceInfo by ID; pointer is only valid while mInterfaceMutex is held
// and the calling code doesn't mutate the list of providers or their lists of devices.
// Finds the first device of the given ID that falls within the requested version range
// minVersion <= deviceVersion < maxVersion
// No guarantees on the order of traversal
ProviderInfo::DeviceInfo* findDeviceInfoLocked(const std::string& id,
hardware::hidl_version minVersion = hardware::hidl_version{0,0},
hardware::hidl_version maxVersion = hardware::hidl_version{1000,0}) const;
status_t addProviderLocked(const std::string& newProvider, bool expected = true);
status_t removeProvider(const std::string& provider);
sp<StatusListener> getStatusListener() const;
bool isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const;
std::vector<sp<ProviderInfo>> mProviders;
void addProviderToMap(
const std::string &cameraId,
sp<hardware::camera::provider::V2_4::ICameraProvider> provider,
bool isTorchUsage);
void removeCameraIdFromMap(
std::unordered_map<std::string, sp<hardware::camera::provider::V2_4::ICameraProvider>> &map,
const std::string &cameraId);
static const char* deviceStatusToString(
const hardware::camera::common::V1_0::CameraDeviceStatus&);
static const char* torchStatusToString(
const hardware::camera::common::V1_0::TorchModeStatus&);
status_t getCameraCharacteristicsLocked(const std::string &id,
CameraMetadata* characteristics) const;
void filterLogicalCameraIdsLocked(std::vector<std::string>& deviceIds) const;
};
} // namespace android
#endif