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_map> 22 #include <unordered_set> 23 #include <set> 24 #include <string> 25 #include <mutex> 26 #include <future> 27 28 #include <camera/camera2/ConcurrentCamera.h> 29 #include <camera/CameraParameters2.h> 30 #include <camera/CameraMetadata.h> 31 #include <camera/CameraBase.h> 32 #include <utils/Errors.h> 33 #include <android/hardware/camera/common/1.0/types.h> 34 #include <android/hardware/camera/provider/2.5/ICameraProvider.h> 35 #include <android/hardware/camera/provider/2.6/ICameraProviderCallback.h> 36 #include <android/hardware/camera/provider/2.6/ICameraProvider.h> 37 #include <android/hardware/camera/provider/2.7/ICameraProvider.h> 38 #include <android/hardware/camera/device/3.7/types.h> 39 #include <android/hidl/manager/1.0/IServiceNotification.h> 40 #include <camera/VendorTagDescriptor.h> 41 42 namespace android { 43 /** 44 * The vendor tag descriptor class that takes HIDL vendor tag information as 45 * input. Not part of VendorTagDescriptor class because that class is used 46 * in AIDL generated sources which don't have access to HIDL headers. 47 */ 48 class HidlVendorTagDescriptor : public VendorTagDescriptor { 49 public: 50 /** 51 * Create a VendorTagDescriptor object from the HIDL VendorTagSection 52 * vector. 53 * 54 * Returns OK on success, or a negative error code. 55 */ 56 static status_t createDescriptorFromHidl( 57 const hardware::hidl_vec<hardware::camera::common::V1_0::VendorTagSection>& vts, 58 /*out*/ 59 sp<VendorTagDescriptor>& descriptor); 60 }; 61 62 enum SystemCameraKind { 63 /** 64 * These camera devices are visible to all apps and system components alike 65 */ 66 PUBLIC = 0, 67 68 /** 69 * These camera devices are visible only to processes having the 70 * android.permission.SYSTEM_CAMERA permission. They are not exposed to 3P 71 * apps. 72 */ 73 SYSTEM_ONLY_CAMERA, 74 75 /** 76 * These camera devices are visible only to HAL clients (that try to connect 77 * on a hwbinder thread). 78 */ 79 HIDDEN_SECURE_CAMERA 80 }; 81 82 #define CAMERA_DEVICE_API_VERSION_1_0 HARDWARE_DEVICE_API_VERSION(1, 0) 83 #define CAMERA_DEVICE_API_VERSION_3_0 HARDWARE_DEVICE_API_VERSION(3, 0) 84 #define CAMERA_DEVICE_API_VERSION_3_1 HARDWARE_DEVICE_API_VERSION(3, 1) 85 #define CAMERA_DEVICE_API_VERSION_3_2 HARDWARE_DEVICE_API_VERSION(3, 2) 86 #define CAMERA_DEVICE_API_VERSION_3_3 HARDWARE_DEVICE_API_VERSION(3, 3) 87 #define CAMERA_DEVICE_API_VERSION_3_4 HARDWARE_DEVICE_API_VERSION(3, 4) 88 #define CAMERA_DEVICE_API_VERSION_3_5 HARDWARE_DEVICE_API_VERSION(3, 5) 89 #define CAMERA_DEVICE_API_VERSION_3_6 HARDWARE_DEVICE_API_VERSION(3, 6) 90 #define CAMERA_DEVICE_API_VERSION_3_7 HARDWARE_DEVICE_API_VERSION(3, 7) 91 92 /** 93 * A manager for all camera providers available on an Android device. 94 * 95 * Responsible for enumerating providers and the individual camera devices 96 * they export, both at startup and as providers and devices are added/removed. 97 * 98 * Provides methods for requesting information about individual devices and for 99 * opening them for active use. 100 * 101 */ 102 class CameraProviderManager : virtual public hidl::manager::V1_0::IServiceNotification { 103 public: 104 105 ~CameraProviderManager(); 106 107 // Tiny proxy for the static methods in a HIDL interface that communicate with the hardware 108 // service manager, to be replacable in unit tests with a fake. 109 struct ServiceInteractionProxy { 110 virtual bool registerForNotifications( 111 const std::string &serviceName, 112 const sp<hidl::manager::V1_0::IServiceNotification> 113 ¬ification) = 0; 114 // Will not wait for service to start if it's not already running 115 virtual sp<hardware::camera::provider::V2_4::ICameraProvider> tryGetService( 116 const std::string &serviceName) = 0; 117 // Will block for service if it exists but isn't running 118 virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService( 119 const std::string &serviceName) = 0; 120 virtual hardware::hidl_vec<hardware::hidl_string> listServices() = 0; ~ServiceInteractionProxyServiceInteractionProxy121 virtual ~ServiceInteractionProxy() {} 122 }; 123 124 // Standard use case - call into the normal generated static methods which invoke 125 // the real hardware service manager 126 struct HardwareServiceInteractionProxy : public ServiceInteractionProxy { registerForNotificationsHardwareServiceInteractionProxy127 virtual bool registerForNotifications( 128 const std::string &serviceName, 129 const sp<hidl::manager::V1_0::IServiceNotification> 130 ¬ification) override { 131 return hardware::camera::provider::V2_4::ICameraProvider::registerForNotifications( 132 serviceName, notification); 133 } tryGetServiceHardwareServiceInteractionProxy134 virtual sp<hardware::camera::provider::V2_4::ICameraProvider> tryGetService( 135 const std::string &serviceName) override { 136 return hardware::camera::provider::V2_4::ICameraProvider::tryGetService(serviceName); 137 } getServiceHardwareServiceInteractionProxy138 virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService( 139 const std::string &serviceName) override { 140 return hardware::camera::provider::V2_4::ICameraProvider::getService(serviceName); 141 } 142 143 virtual hardware::hidl_vec<hardware::hidl_string> listServices() override; 144 }; 145 146 /** 147 * Listener interface for device/torch status changes 148 */ 149 struct StatusListener : virtual public RefBase { ~StatusListenerStatusListener150 ~StatusListener() {} 151 152 virtual void onDeviceStatusChanged(const String8 &cameraId, 153 hardware::camera::common::V1_0::CameraDeviceStatus newStatus) = 0; 154 virtual void onDeviceStatusChanged(const String8 &cameraId, 155 const String8 &physicalCameraId, 156 hardware::camera::common::V1_0::CameraDeviceStatus newStatus) = 0; 157 virtual void onTorchStatusChanged(const String8 &cameraId, 158 hardware::camera::common::V1_0::TorchModeStatus newStatus) = 0; 159 virtual void onNewProviderRegistered() = 0; 160 }; 161 162 /** 163 * Represents the mode a camera device is currently in 164 */ 165 enum class DeviceMode { 166 TORCH, 167 CAMERA 168 }; 169 170 /** 171 * Initialize the manager and give it a status listener; optionally accepts a service 172 * interaction proxy. 173 * 174 * The default proxy communicates via the hardware service manager; alternate proxies can be 175 * used for testing. The lifetime of the proxy must exceed the lifetime of the manager. 176 */ 177 status_t initialize(wp<StatusListener> listener, 178 ServiceInteractionProxy *proxy = &sHardwareServiceInteractionProxy); 179 180 /** 181 * Retrieve the total number of available cameras. 182 * This value may change dynamically as cameras are added or removed. 183 */ 184 std::pair<int, int> getCameraCount() const; 185 186 std::vector<std::string> getCameraDeviceIds() const; 187 188 /** 189 * Retrieve the number of API1 compatible cameras; these are internal and 190 * backwards-compatible. This is the set of cameras that will be 191 * accessible via the old camera API. 192 * The return value may change dynamically due to external camera hotplug. 193 */ 194 std::vector<std::string> getAPI1CompatibleCameraDeviceIds() const; 195 196 /** 197 * Return true if a device with a given ID and major version exists 198 */ 199 bool isValidDevice(const std::string &id, uint16_t majorVersion) const; 200 201 /** 202 * Return true if a device with a given ID has a flash unit. Returns false 203 * for devices that are unknown. 204 */ 205 bool hasFlashUnit(const std::string &id) const; 206 207 /** 208 * Return true if the camera device has native zoom ratio support. 209 */ 210 bool supportNativeZoomRatio(const std::string &id) const; 211 212 /** 213 * Return the resource cost of this camera device 214 */ 215 status_t getResourceCost(const std::string &id, 216 hardware::camera::common::V1_0::CameraResourceCost* cost) const; 217 218 /** 219 * Return the old camera API camera info 220 */ 221 status_t getCameraInfo(const std::string &id, 222 hardware::CameraInfo* info) const; 223 224 /** 225 * Return API2 camera characteristics - returns NAME_NOT_FOUND if a device ID does 226 * not have a v3 or newer HAL version. 227 */ 228 status_t getCameraCharacteristics(const std::string &id, 229 bool overrideForPerfClass, CameraMetadata* characteristics) const; 230 231 status_t isConcurrentSessionConfigurationSupported( 232 const std::vector<hardware::camera2::utils::CameraIdAndSessionConfiguration> 233 &cameraIdsAndSessionConfigs, 234 const std::set<std::string>& perfClassPrimaryCameraIds, 235 int targetSdkVersion, bool *isSupported); 236 237 std::vector<std::unordered_set<std::string>> getConcurrentCameraIds() const; 238 /** 239 * Check for device support of specific stream combination. 240 */ 241 status_t isSessionConfigurationSupported(const std::string& id, 242 const hardware::camera::device::V3_7::StreamConfiguration &configuration, 243 bool *status /*out*/) const; 244 245 /** 246 * Return the highest supported device interface version for this ID 247 */ 248 status_t getHighestSupportedVersion(const std::string &id, 249 hardware::hidl_version *v); 250 251 /** 252 * Check if a given camera device support setTorchMode API. 253 */ 254 bool supportSetTorchMode(const std::string &id) const; 255 256 /** 257 * Turn on or off the flashlight on a given camera device. 258 * May fail if the device does not support this API, is in active use, or if the device 259 * doesn't exist, etc. 260 */ 261 status_t setTorchMode(const std::string &id, bool enabled); 262 263 /** 264 * Setup vendor tags for all registered providers 265 */ 266 status_t setUpVendorTags(); 267 268 /** 269 * Inform registered providers about a device state change, such as folding or unfolding 270 */ 271 status_t notifyDeviceStateChange( 272 android::hardware::hidl_bitfield<hardware::camera::provider::V2_5::DeviceState> newState); 273 274 /** 275 * Open an active session to a camera device. 276 * 277 * This fully powers on the camera device hardware, and returns a handle to a 278 * session to be used for hardware configuration and operation. 279 */ 280 status_t openSession(const std::string &id, 281 const sp<hardware::camera::device::V3_2::ICameraDeviceCallback>& callback, 282 /*out*/ 283 sp<hardware::camera::device::V3_2::ICameraDeviceSession> *session); 284 285 /** 286 * Notify that the camera or torch is no longer being used by a camera client 287 */ 288 void removeRef(DeviceMode usageType, const std::string &cameraId); 289 290 /** 291 * IServiceNotification::onRegistration 292 * Invoked by the hardware service manager when a new camera provider is registered 293 */ 294 virtual hardware::Return<void> onRegistration(const hardware::hidl_string& fqName, 295 const hardware::hidl_string& name, 296 bool preexisting) override; 297 298 /** 299 * Dump out information about available providers and devices 300 */ 301 status_t dump(int fd, const Vector<String16>& args); 302 303 /** 304 * Conversion methods between HAL Status and status_t and strings 305 */ 306 static status_t mapToStatusT(const hardware::camera::common::V1_0::Status& s); 307 static const char* statusToString(const hardware::camera::common::V1_0::Status& s); 308 309 /* 310 * Return provider type for a specific device. 311 */ 312 metadata_vendor_id_t getProviderTagIdLocked(const std::string& id, 313 hardware::hidl_version minVersion = hardware::hidl_version{0,0}, 314 hardware::hidl_version maxVersion = hardware::hidl_version{1000,0}) const; 315 316 /* 317 * Check if a camera is a logical camera. And if yes, return 318 * the physical camera ids. 319 */ 320 bool isLogicalCamera(const std::string& id, std::vector<std::string>* physicalCameraIds); 321 322 status_t getSystemCameraKind(const std::string& id, SystemCameraKind *kind) const; 323 bool isHiddenPhysicalCamera(const std::string& cameraId) const; 324 325 status_t filterSmallJpegSizes(const std::string& cameraId); 326 327 static const float kDepthARTolerance; 328 private: 329 // All private members, unless otherwise noted, expect mInterfaceMutex to be locked before use 330 mutable std::mutex mInterfaceMutex; 331 332 // the status listener update callbacks will lock mStatusMutex 333 mutable std::mutex mStatusListenerMutex; 334 wp<StatusListener> mListener; 335 ServiceInteractionProxy* mServiceProxy; 336 337 // Current overall Android device physical status 338 android::hardware::hidl_bitfield<hardware::camera::provider::V2_5::DeviceState> mDeviceState; 339 340 // mProviderLifecycleLock is locked during onRegistration and removeProvider 341 mutable std::mutex mProviderLifecycleLock; 342 343 static HardwareServiceInteractionProxy sHardwareServiceInteractionProxy; 344 345 // Mapping from CameraDevice IDs to CameraProviders. This map is used to keep the 346 // ICameraProvider alive while it is in use by the camera with the given ID for camera 347 // capabilities 348 std::unordered_map<std::string, sp<hardware::camera::provider::V2_4::ICameraProvider>> 349 mCameraProviderByCameraId; 350 351 // Mapping from CameraDevice IDs to CameraProviders. This map is used to keep the 352 // ICameraProvider alive while it is in use by the camera with the given ID for torch 353 // capabilities 354 std::unordered_map<std::string, sp<hardware::camera::provider::V2_4::ICameraProvider>> 355 mTorchProviderByCameraId; 356 357 // Lock for accessing mCameraProviderByCameraId and mTorchProviderByCameraId 358 std::mutex mProviderInterfaceMapLock; 359 360 struct ProviderInfo : 361 virtual public hardware::camera::provider::V2_6::ICameraProviderCallback, 362 virtual public hardware::hidl_death_recipient 363 { 364 const std::string mProviderName; 365 const std::string mProviderInstance; 366 const metadata_vendor_id_t mProviderTagid; 367 int mMinorVersion; 368 sp<VendorTagDescriptor> mVendorTagDescriptor; 369 bool mSetTorchModeSupported; 370 bool mIsRemote; 371 372 // Current overall Android device physical status 373 hardware::hidl_bitfield<hardware::camera::provider::V2_5::DeviceState> mDeviceState; 374 375 // This pointer is used to keep a reference to the ICameraProvider that was last accessed. 376 wp<hardware::camera::provider::V2_4::ICameraProvider> mActiveInterface; 377 378 sp<hardware::camera::provider::V2_4::ICameraProvider> mSavedInterface; 379 380 ProviderInfo(const std::string &providerName, const std::string &providerInstance, 381 CameraProviderManager *manager); 382 ~ProviderInfo(); 383 384 status_t initialize(sp<hardware::camera::provider::V2_4::ICameraProvider>& interface, 385 hardware::hidl_bitfield<hardware::camera::provider::V2_5::DeviceState> 386 currentDeviceState); 387 388 const sp<hardware::camera::provider::V2_4::ICameraProvider> startProviderInterface(); 389 390 const std::string& getType() const; 391 392 status_t addDevice(const std::string& name, 393 hardware::camera::common::V1_0::CameraDeviceStatus initialStatus = 394 hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT, 395 /*out*/ std::string *parsedId = nullptr); 396 397 status_t dump(int fd, const Vector<String16>& args) const; 398 399 // ICameraProviderCallbacks interface - these lock the parent mInterfaceMutex 400 hardware::Return<void> cameraDeviceStatusChange( 401 const hardware::hidl_string& cameraDeviceName, 402 hardware::camera::common::V1_0::CameraDeviceStatus newStatus) override; 403 hardware::Return<void> torchModeStatusChange( 404 const hardware::hidl_string& cameraDeviceName, 405 hardware::camera::common::V1_0::TorchModeStatus newStatus) override; 406 hardware::Return<void> physicalCameraDeviceStatusChange( 407 const hardware::hidl_string& cameraDeviceName, 408 const hardware::hidl_string& physicalCameraDeviceName, 409 hardware::camera::common::V1_0::CameraDeviceStatus newStatus) override; 410 411 status_t cameraDeviceStatusChangeLocked( 412 std::string* id, const hardware::hidl_string& cameraDeviceName, 413 hardware::camera::common::V1_0::CameraDeviceStatus newStatus); 414 status_t physicalCameraDeviceStatusChangeLocked( 415 std::string* id, std::string* physicalId, 416 const hardware::hidl_string& cameraDeviceName, 417 const hardware::hidl_string& physicalCameraDeviceName, 418 hardware::camera::common::V1_0::CameraDeviceStatus newStatus); 419 420 // hidl_death_recipient interface - this locks the parent mInterfaceMutex 421 virtual void serviceDied(uint64_t cookie, const wp<hidl::base::V1_0::IBase>& who) override; 422 423 /** 424 * Setup vendor tags for this provider 425 */ 426 status_t setUpVendorTags(); 427 428 /** 429 * Notify provider about top-level device physical state changes 430 * 431 * Note that 'mInterfaceMutex' should not be held when calling this method. 432 * It is possible for camera providers to add/remove devices and try to 433 * acquire it. 434 */ 435 status_t notifyDeviceStateChange( 436 hardware::hidl_bitfield<hardware::camera::provider::V2_5::DeviceState> 437 newDeviceState); 438 439 std::vector<std::unordered_set<std::string>> getConcurrentCameraIdCombinations(); 440 441 /** 442 * Notify 'DeviceInfo' instanced about top-level device physical state changes 443 * 444 * Note that 'mInterfaceMutex' should be held when calling this method. 445 */ 446 void notifyDeviceInfoStateChangeLocked( 447 hardware::hidl_bitfield<hardware::camera::provider::V2_5::DeviceState> 448 newDeviceState); 449 450 /** 451 * Query the camera provider for concurrent stream configuration support 452 */ 453 status_t isConcurrentSessionConfigurationSupported( 454 const hardware::hidl_vec< 455 hardware::camera::provider::V2_7::CameraIdAndStreamCombination> 456 &halCameraIdsAndStreamCombinations, 457 bool *isSupported); 458 459 // Basic device information, common to all camera devices 460 struct DeviceInfo { 461 const std::string mName; // Full instance name 462 const std::string mId; // ID section of full name 463 const hardware::hidl_version mVersion; 464 const metadata_vendor_id_t mProviderTagid; 465 bool mIsLogicalCamera; 466 std::vector<std::string> mPhysicalIds; 467 hardware::CameraInfo mInfo; 468 sp<IBase> mSavedInterface; 469 SystemCameraKind mSystemCameraKind = SystemCameraKind::PUBLIC; 470 471 const hardware::camera::common::V1_0::CameraResourceCost mResourceCost; 472 473 hardware::camera::common::V1_0::CameraDeviceStatus mStatus; 474 475 wp<ProviderInfo> mParentProvider; 476 hasFlashUnitProviderInfo::DeviceInfo477 bool hasFlashUnit() const { return mHasFlashUnit; } supportNativeZoomRatioProviderInfo::DeviceInfo478 bool supportNativeZoomRatio() const { return mSupportNativeZoomRatio; } 479 virtual status_t setTorchMode(bool enabled) = 0; 480 virtual status_t getCameraInfo(hardware::CameraInfo *info) const = 0; 481 virtual bool isAPI1Compatible() const = 0; 482 virtual status_t dumpState(int fd) = 0; getCameraCharacteristicsProviderInfo::DeviceInfo483 virtual status_t getCameraCharacteristics(bool overrideForPerfClass, 484 CameraMetadata *characteristics) const { 485 (void) overrideForPerfClass; 486 (void) characteristics; 487 return INVALID_OPERATION; 488 } getPhysicalCameraCharacteristicsProviderInfo::DeviceInfo489 virtual status_t getPhysicalCameraCharacteristics(const std::string& physicalCameraId, 490 CameraMetadata *characteristics) const { 491 (void) physicalCameraId; 492 (void) characteristics; 493 return INVALID_OPERATION; 494 } 495 isSessionConfigurationSupportedProviderInfo::DeviceInfo496 virtual status_t isSessionConfigurationSupported( 497 const hardware::camera::device::V3_7::StreamConfiguration &/*configuration*/, 498 bool * /*status*/) { 499 return INVALID_OPERATION; 500 } 501 virtual status_t filterSmallJpegSizes() = 0; notifyDeviceStateChangeProviderInfo::DeviceInfo502 virtual void notifyDeviceStateChange( 503 hardware::hidl_bitfield<hardware::camera::provider::V2_5::DeviceState> 504 /*newState*/) {} 505 506 template<class InterfaceT> 507 sp<InterfaceT> startDeviceInterface(); 508 DeviceInfoProviderInfo::DeviceInfo509 DeviceInfo(const std::string& name, const metadata_vendor_id_t tagId, 510 const std::string &id, const hardware::hidl_version& version, 511 const std::vector<std::string>& publicCameraIds, 512 const hardware::camera::common::V1_0::CameraResourceCost& resourceCost, 513 sp<ProviderInfo> parentProvider) : 514 mName(name), mId(id), mVersion(version), mProviderTagid(tagId), 515 mIsLogicalCamera(false), mResourceCost(resourceCost), 516 mStatus(hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT), 517 mParentProvider(parentProvider), mHasFlashUnit(false), 518 mSupportNativeZoomRatio(false), mPublicCameraIds(publicCameraIds) {} 519 virtual ~DeviceInfo(); 520 protected: 521 bool mHasFlashUnit; // const after constructor 522 bool mSupportNativeZoomRatio; // const after constructor 523 const std::vector<std::string>& mPublicCameraIds; 524 525 template<class InterfaceT> 526 static status_t setTorchMode(InterfaceT& interface, bool enabled); 527 528 template<class InterfaceT> setTorchModeForDeviceProviderInfo::DeviceInfo529 status_t setTorchModeForDevice(bool enabled) { 530 // Don't save the ICameraProvider interface here because we assume that this was 531 // called from CameraProviderManager::setTorchMode(), which does save it. 532 const sp<InterfaceT> interface = startDeviceInterface<InterfaceT>(); 533 return DeviceInfo::setTorchMode(interface, enabled); 534 } 535 }; 536 std::vector<std::unique_ptr<DeviceInfo>> mDevices; 537 std::unordered_set<std::string> mUniqueCameraIds; 538 int mUniqueDeviceCount; 539 std::vector<std::string> mUniqueAPI1CompatibleCameraIds; 540 // The initial public camera IDs published by the camera provider. 541 // Currently logical multi-camera is not supported for hot-plug camera. 542 // And we use this list to keep track of initial public camera IDs 543 // advertised by the provider, and to distinguish against "hidden" 544 // physical camera IDs. 545 std::vector<std::string> mProviderPublicCameraIds; 546 547 // HALv3-specific camera fields, including the actual device interface 548 struct DeviceInfo3 : public DeviceInfo { 549 typedef hardware::camera::device::V3_2::ICameraDevice InterfaceT; 550 551 virtual status_t setTorchMode(bool enabled) override; 552 virtual status_t getCameraInfo(hardware::CameraInfo *info) const override; 553 virtual bool isAPI1Compatible() const override; 554 virtual status_t dumpState(int fd) override; 555 virtual status_t getCameraCharacteristics( 556 bool overrideForPerfClass, 557 CameraMetadata *characteristics) const override; 558 virtual status_t getPhysicalCameraCharacteristics(const std::string& physicalCameraId, 559 CameraMetadata *characteristics) const override; 560 virtual status_t isSessionConfigurationSupported( 561 const hardware::camera::device::V3_7::StreamConfiguration &configuration, 562 bool *status /*out*/) 563 override; 564 virtual status_t filterSmallJpegSizes() override; 565 virtual void notifyDeviceStateChange( 566 hardware::hidl_bitfield<hardware::camera::provider::V2_5::DeviceState> 567 newState) override; 568 569 DeviceInfo3(const std::string& name, const metadata_vendor_id_t tagId, 570 const std::string &id, uint16_t minorVersion, 571 const hardware::camera::common::V1_0::CameraResourceCost& resourceCost, 572 sp<ProviderInfo> parentProvider, 573 const std::vector<std::string>& publicCameraIds, sp<InterfaceT> interface); 574 virtual ~DeviceInfo3(); 575 private: 576 CameraMetadata mCameraCharacteristics; 577 // Map device states to sensor orientations 578 std::unordered_map<int64_t, int32_t> mDeviceStateOrientationMap; 579 // A copy of mCameraCharacteristics without performance class 580 // override 581 std::unique_ptr<CameraMetadata> mCameraCharNoPCOverride; 582 std::unordered_map<std::string, CameraMetadata> mPhysicalCameraCharacteristics; 583 void queryPhysicalCameraIds(); 584 SystemCameraKind getSystemCameraKind(); 585 status_t fixupMonochromeTags(); 586 status_t addDynamicDepthTags(bool maxResolution = false); 587 status_t deriveHeicTags(bool maxResolution = false); 588 status_t addRotateCropTags(); 589 status_t addPreCorrectionActiveArraySize(); 590 591 static void getSupportedSizes(const CameraMetadata& ch, uint32_t tag, 592 android_pixel_format_t format, 593 std::vector<std::tuple<size_t, size_t>> *sizes /*out*/); 594 static void getSupportedDurations( const CameraMetadata& ch, uint32_t tag, 595 android_pixel_format_t format, 596 const std::vector<std::tuple<size_t, size_t>>& sizes, 597 std::vector<int64_t> *durations/*out*/); 598 static void getSupportedDynamicDepthDurations( 599 const std::vector<int64_t>& depthDurations, 600 const std::vector<int64_t>& blobDurations, 601 std::vector<int64_t> *dynamicDepthDurations /*out*/); 602 static void getSupportedDynamicDepthSizes( 603 const std::vector<std::tuple<size_t, size_t>>& blobSizes, 604 const std::vector<std::tuple<size_t, size_t>>& depthSizes, 605 std::vector<std::tuple<size_t, size_t>> *dynamicDepthSizes /*out*/, 606 std::vector<std::tuple<size_t, size_t>> *internalDepthSizes /*out*/); 607 status_t removeAvailableKeys(CameraMetadata& c, const std::vector<uint32_t>& keys, 608 uint32_t keyTag); 609 status_t fillHeicStreamCombinations(std::vector<int32_t>* outputs, 610 std::vector<int64_t>* durations, 611 std::vector<int64_t>* stallDurations, 612 const camera_metadata_entry& halStreamConfigs, 613 const camera_metadata_entry& halStreamDurations); 614 }; 615 616 private: 617 std::string mType; 618 uint32_t mId; 619 620 std::mutex mLock; 621 622 CameraProviderManager *mManager; 623 624 struct CameraStatusInfoT { 625 bool isPhysicalCameraStatus = false; 626 hardware::hidl_string cameraId; 627 hardware::hidl_string physicalCameraId; 628 hardware::camera::common::V1_0::CameraDeviceStatus status; CameraStatusInfoTProviderInfo::CameraStatusInfoT629 CameraStatusInfoT(bool isForPhysicalCamera, const hardware::hidl_string& id, 630 const hardware::hidl_string& physicalId, 631 hardware::camera::common::V1_0::CameraDeviceStatus s) : 632 isPhysicalCameraStatus(isForPhysicalCamera), cameraId(id), 633 physicalCameraId(physicalId), status(s) {} 634 }; 635 636 // Lock to synchronize between initialize() and camera status callbacks 637 std::mutex mInitLock; 638 bool mInitialized = false; 639 std::vector<CameraStatusInfoT> mCachedStatus; 640 // End of scope for mInitLock 641 642 std::future<void> mInitialStatusCallbackFuture; 643 void notifyInitialStatusChange(sp<StatusListener> listener, 644 std::unique_ptr<std::vector<CameraStatusInfoT>> cachedStatus); 645 646 std::vector<std::unordered_set<std::string>> mConcurrentCameraIdCombinations; 647 648 // Templated method to instantiate the right kind of DeviceInfo and call the 649 // right CameraProvider getCameraDeviceInterface_* method. 650 template<class DeviceInfoT> 651 std::unique_ptr<DeviceInfo> initializeDeviceInfo(const std::string &name, 652 const metadata_vendor_id_t tagId, const std::string &id, 653 uint16_t minorVersion); 654 655 // Helper for initializeDeviceInfo to use the right CameraProvider get method. 656 template<class InterfaceT> 657 sp<InterfaceT> startDeviceInterface(const std::string &name); 658 659 // Parse provider instance name for type and id 660 static status_t parseProviderName(const std::string& name, 661 std::string *type, uint32_t *id); 662 663 // Parse device instance name for device version, type, and id. 664 static status_t parseDeviceName(const std::string& name, 665 uint16_t *major, uint16_t *minor, std::string *type, std::string *id); 666 667 // Generate vendor tag id 668 static metadata_vendor_id_t generateVendorTagId(const std::string &name); 669 670 void removeDevice(std::string id); 671 672 // Expects to have mLock locked 673 status_t reCacheConcurrentStreamingCameraIdsLocked(); 674 // Expects to have mLock locked 675 status_t getConcurrentCameraIdsInternalLocked( 676 sp<hardware::camera::provider::V2_6::ICameraProvider> &interface2_6); 677 }; 678 679 /** 680 * Save the ICameraProvider while it is being used by a camera or torch client 681 */ 682 void saveRef(DeviceMode usageType, const std::string &cameraId, 683 sp<hardware::camera::provider::V2_4::ICameraProvider> provider); 684 685 // Utility to find a DeviceInfo by ID; pointer is only valid while mInterfaceMutex is held 686 // and the calling code doesn't mutate the list of providers or their lists of devices. 687 // Finds the first device of the given ID that falls within the requested version range 688 // minVersion <= deviceVersion < maxVersion 689 // No guarantees on the order of traversal 690 ProviderInfo::DeviceInfo* findDeviceInfoLocked(const std::string& id, 691 hardware::hidl_version minVersion = hardware::hidl_version{0,0}, 692 hardware::hidl_version maxVersion = hardware::hidl_version{1000,0}) const; 693 694 status_t addProviderLocked(const std::string& newProvider, bool preexisting = false); 695 696 status_t tryToInitializeProviderLocked(const std::string& providerName, 697 const sp<ProviderInfo>& providerInfo); 698 699 bool isLogicalCameraLocked(const std::string& id, std::vector<std::string>* physicalCameraIds); 700 701 status_t removeProvider(const std::string& provider); 702 sp<StatusListener> getStatusListener() const; 703 704 bool isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const; 705 706 size_t mProviderInstanceId = 0; 707 std::vector<sp<ProviderInfo>> mProviders; 708 709 void addProviderToMap( 710 const std::string &cameraId, 711 sp<hardware::camera::provider::V2_4::ICameraProvider> provider, 712 bool isTorchUsage); 713 void removeCameraIdFromMap( 714 std::unordered_map<std::string, sp<hardware::camera::provider::V2_4::ICameraProvider>> &map, 715 const std::string &cameraId); 716 717 static const char* deviceStatusToString( 718 const hardware::camera::common::V1_0::CameraDeviceStatus&); 719 static const char* torchStatusToString( 720 const hardware::camera::common::V1_0::TorchModeStatus&); 721 722 status_t getCameraCharacteristicsLocked(const std::string &id, bool overrideForPerfClass, 723 CameraMetadata* characteristics) const; 724 void filterLogicalCameraIdsLocked(std::vector<std::string>& deviceIds) const; 725 726 status_t getSystemCameraKindLocked(const std::string& id, SystemCameraKind *kind) const; 727 std::pair<bool, ProviderInfo::DeviceInfo *> isHiddenPhysicalCameraInternal(const std::string& cameraId) const; 728 729 void collectDeviceIdsLocked(const std::vector<std::string> deviceIds, 730 std::vector<std::string>& normalDeviceIds, 731 std::vector<std::string>& systemCameraDeviceIds) const; 732 733 status_t convertToHALStreamCombinationAndCameraIdsLocked( 734 const std::vector<hardware::camera2::utils::CameraIdAndSessionConfiguration> 735 &cameraIdsAndSessionConfigs, 736 const std::set<std::string>& perfClassPrimaryCameraIds, 737 int targetSdkVersion, 738 hardware::hidl_vec<hardware::camera::provider::V2_7::CameraIdAndStreamCombination> 739 *halCameraIdsAndStreamCombinations, 740 bool *earlyExit); 741 }; 742 743 } // namespace android 744 745 #endif 746