Snap for 6720487 from d907ae84c6a17a2bac4824cd62734d127d8c90ff to rvc-qpr1-release (5dd527e9) · Commits · e / os / android_frameworks_av

services/camera/libcameraservice/common/CameraProviderManager.cpp

+153 −68

Original line number	Original line	Diff line number	Diff line
	@@ -1453,7 +1453,40 @@ status_t CameraProviderManager::ProviderInfo::initialize(
	ALOGI("Camera provider %s ready with %zu camera devices",		ALOGI("Camera provider %s ready with %zu camera devices",
	mProviderName.c_str(), mDevices.size());		mProviderName.c_str(), mDevices.size());

			// Process cached status callbacks
			std::unique_ptr<std::vector<CameraStatusInfoT>> cachedStatus =
			std::make_unique<std::vector<CameraStatusInfoT>>();
			{
			std::lock_guard<std::mutex> lock(mInitLock);

			for (auto& statusInfo : mCachedStatus) {
			std::string id, physicalId;
			status_t res = OK;
			if (statusInfo.isPhysicalCameraStatus) {
			res = physicalCameraDeviceStatusChangeLocked(&id, &physicalId,
			statusInfo.cameraId, statusInfo.physicalCameraId, statusInfo.status);
			} else {
			res = cameraDeviceStatusChangeLocked(&id, statusInfo.cameraId, statusInfo.status);
			}
			if (res == OK) {
			cachedStatus->emplace_back(statusInfo.isPhysicalCameraStatus,
			id.c_str(), physicalId.c_str(), statusInfo.status);
			}
			}
			mCachedStatus.clear();

	mInitialized = true;		mInitialized = true;
			}

			// The cached status change callbacks cannot be fired directly from this
			// function, due to same-thread deadlock trying to acquire mInterfaceMutex
			// twice.
			if (listener != nullptr) {
			mInitialStatusCallbackFuture = std::async(std::launch::async,
			&CameraProviderManager::ProviderInfo::notifyInitialStatusChange, this,
			listener, std::move(cachedStatus));
			}

	return OK;		return OK;
	}		}

	@@ -1731,17 +1764,42 @@ hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusCh
	CameraDeviceStatus newStatus) {		CameraDeviceStatus newStatus) {
	sp<StatusListener> listener;		sp<StatusListener> listener;
	std::string id;		std::string id;
	bool initialized = false;		std::lock_guard<std::mutex> lock(mInitLock);

			if (!mInitialized) {
			mCachedStatus.emplace_back(false /isPhysicalCameraStatus/,
			cameraDeviceName.c_str(), std::string().c_str(), newStatus);
			return hardware::Void();
			}

	{		{
	std::lock_guard<std::mutex> lock(mLock);		std::lock_guard<std::mutex> lock(mLock);
			if (OK != cameraDeviceStatusChangeLocked(&id, cameraDeviceName, newStatus)) {
			return hardware::Void();
			}
			listener = mManager->getStatusListener();
			}

			// Call without lock held to allow reentrancy into provider manager
			if (listener != nullptr) {
			listener->onDeviceStatusChanged(String8(id.c_str()), newStatus);
			}

			return hardware::Void();
			}

			status_t CameraProviderManager::ProviderInfo::cameraDeviceStatusChangeLocked(
			std::string* id, const hardware::hidl_string& cameraDeviceName,
			CameraDeviceStatus newStatus) {
	bool known = false;		bool known = false;
			std::string cameraId;
	for (auto& deviceInfo : mDevices) {		for (auto& deviceInfo : mDevices) {
	if (deviceInfo->mName == cameraDeviceName) {		if (deviceInfo->mName == cameraDeviceName) {
	ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),		ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),
	deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus));		deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus));
	deviceInfo->mStatus = newStatus;		deviceInfo->mStatus = newStatus;
	// TODO: Handle device removal (NOT_PRESENT)		// TODO: Handle device removal (NOT_PRESENT)
	id = deviceInfo->mId;		cameraId = deviceInfo->mId;
	known = true;		known = true;
	break;		break;
	}		}
	@@ -1751,27 +1809,18 @@ hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusCh
	if (newStatus == CameraDeviceStatus::NOT_PRESENT) {		if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
	ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",		ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",
	mProviderName.c_str(), cameraDeviceName.c_str());		mProviderName.c_str(), cameraDeviceName.c_str());
	return hardware::Void();		return BAD_VALUE;
	}		}
	addDevice(cameraDeviceName, newStatus, &id);		addDevice(cameraDeviceName, newStatus, &cameraId);
	} else if (newStatus == CameraDeviceStatus::NOT_PRESENT) {		} else if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
	removeDevice(id);		removeDevice(cameraId);
	}		}
	listener = mManager->getStatusListener();
	initialized = mInitialized;
	if (reCacheConcurrentStreamingCameraIdsLocked() != OK) {		if (reCacheConcurrentStreamingCameraIdsLocked() != OK) {
	ALOGE("%s: CameraProvider %s could not re-cache concurrent streaming camera id list ",		ALOGE("%s: CameraProvider %s could not re-cache concurrent streaming camera id list ",
	__FUNCTION__, mProviderName.c_str());		__FUNCTION__, mProviderName.c_str());
	}		}
	}		*id = cameraId;
	// Call without lock held to allow reentrancy into provider manager		return OK;
	// Don't send the callback if providerInfo hasn't been initialized.
	// CameraService will initialize device status after provider is
	// initialized
	if (listener != nullptr && initialized) {
	listener->onDeviceStatusChanged(String8(id.c_str()), newStatus);
	}
	return hardware::Void();
	}		}

	hardware::Return<void> CameraProviderManager::ProviderInfo::physicalCameraDeviceStatusChange(		hardware::Return<void> CameraProviderManager::ProviderInfo::physicalCameraDeviceStatusChange(
	@@ -1780,25 +1829,53 @@ hardware::Return<void> CameraProviderManager::ProviderInfo::physicalCameraDevice
	CameraDeviceStatus newStatus) {		CameraDeviceStatus newStatus) {
	sp<StatusListener> listener;		sp<StatusListener> listener;
	std::string id;		std::string id;
			std::string physicalId;
			std::lock_guard<std::mutex> lock(mInitLock);

			if (!mInitialized) {
			mCachedStatus.emplace_back(true /isPhysicalCameraStatus/, cameraDeviceName,
			physicalCameraDeviceName, newStatus);
			return hardware::Void();
			}

	{		{
	std::lock_guard<std::mutex> lock(mLock);		std::lock_guard<std::mutex> lock(mLock);
	if (!mInitialized) return hardware::Void();

			if (OK != physicalCameraDeviceStatusChangeLocked(&id, &physicalId, cameraDeviceName,
			physicalCameraDeviceName, newStatus)) {
			return hardware::Void();
			}

			listener = mManager->getStatusListener();
			}
			// Call without lock held to allow reentrancy into provider manager
			if (listener != nullptr) {
			listener->onDeviceStatusChanged(String8(id.c_str()),
			String8(physicalId.c_str()), newStatus);
			}
			return hardware::Void();
			}

			status_t CameraProviderManager::ProviderInfo::physicalCameraDeviceStatusChangeLocked(
			std::string* id, std::string* physicalId,
			const hardware::hidl_string& cameraDeviceName,
			const hardware::hidl_string& physicalCameraDeviceName,
			CameraDeviceStatus newStatus) {
	bool known = false;		bool known = false;
			std::string cameraId;
	for (auto& deviceInfo : mDevices) {		for (auto& deviceInfo : mDevices) {
	if (deviceInfo->mName == cameraDeviceName) {		if (deviceInfo->mName == cameraDeviceName) {
	id = deviceInfo->mId;		cameraId = deviceInfo->mId;

	if (!deviceInfo->mIsLogicalCamera) {		if (!deviceInfo->mIsLogicalCamera) {
	ALOGE("%s: Invalid combination of camera id %s, physical id %s",		ALOGE("%s: Invalid combination of camera id %s, physical id %s",
	__FUNCTION__, id.c_str(), physicalCameraDeviceName.c_str());		__FUNCTION__, cameraId.c_str(), physicalCameraDeviceName.c_str());
	return hardware::Void();		return BAD_VALUE;
	}		}
	if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),		if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),
	physicalCameraDeviceName) == deviceInfo->mPhysicalIds.end()) {		physicalCameraDeviceName) == deviceInfo->mPhysicalIds.end()) {
	ALOGE("%s: Invalid combination of camera id %s, physical id %s",		ALOGE("%s: Invalid combination of camera id %s, physical id %s",
	__FUNCTION__, id.c_str(), physicalCameraDeviceName.c_str());		__FUNCTION__, cameraId.c_str(), physicalCameraDeviceName.c_str());
	return hardware::Void();		return BAD_VALUE;
	}		}
	ALOGI("Camera device %s physical device %s status is now %s",		ALOGI("Camera device %s physical device %s status is now %s",
	cameraDeviceName.c_str(), physicalCameraDeviceName.c_str(),		cameraDeviceName.c_str(), physicalCameraDeviceName.c_str(),
	@@ -1812,20 +1889,12 @@ hardware::Return<void> CameraProviderManager::ProviderInfo::physicalCameraDevice
	ALOGW("Camera provider %s says an unknown camera device %s-%s is not present. Curious.",		ALOGW("Camera provider %s says an unknown camera device %s-%s is not present. Curious.",
	mProviderName.c_str(), cameraDeviceName.c_str(),		mProviderName.c_str(), cameraDeviceName.c_str(),
	physicalCameraDeviceName.c_str());		physicalCameraDeviceName.c_str());
	return hardware::Void();		return BAD_VALUE;
	}
	listener = mManager->getStatusListener();
	}
	// Call without lock held to allow reentrancy into provider manager
	// Don't send the callback if providerInfo hasn't been initialized.
	// CameraService will initialize device status after provider is
	// initialized
	if (listener != nullptr) {
	String8 physicalId(physicalCameraDeviceName.c_str());
	listener->onDeviceStatusChanged(String8(id.c_str()),
	physicalId, newStatus);
	}		}
	return hardware::Void();
			*id = cameraId;
			*physicalId = physicalCameraDeviceName.c_str();
			return OK;
	}		}

	hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange(		hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange(
	@@ -1982,6 +2051,20 @@ status_t CameraProviderManager::ProviderInfo::isConcurrentSessionConfigurationSu
	return INVALID_OPERATION;		return INVALID_OPERATION;
	}		}

			void CameraProviderManager::ProviderInfo::notifyInitialStatusChange(
			sp<StatusListener> listener,
			std::unique_ptr<std::vector<CameraStatusInfoT>> cachedStatus) {
			for (auto& statusInfo : *cachedStatus) {
			if (statusInfo.isPhysicalCameraStatus) {
			listener->onDeviceStatusChanged(String8(statusInfo.cameraId.c_str()),
			String8(statusInfo.physicalCameraId.c_str()), statusInfo.status);
			} else {
			listener->onDeviceStatusChanged(
			String8(statusInfo.cameraId.c_str()), statusInfo.status);
			}
			}
			}

	template<class DeviceInfoT>		template<class DeviceInfoT>
	std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>		std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
	CameraProviderManager::ProviderInfo::initializeDeviceInfo(		CameraProviderManager::ProviderInfo::initializeDeviceInfo(
	@@ -2685,9 +2768,11 @@ status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string&


	CameraProviderManager::ProviderInfo::~ProviderInfo() {		CameraProviderManager::ProviderInfo::~ProviderInfo() {
			if (mInitialStatusCallbackFuture.valid()) {
			mInitialStatusCallbackFuture.wait();
			}
	// Destruction of ProviderInfo is only supposed to happen when the respective		// Destruction of ProviderInfo is only supposed to happen when the respective
	// CameraProvider interface dies, so do not unregister callbacks.		// CameraProvider interface dies, so do not unregister callbacks.

	}		}

	status_t CameraProviderManager::mapToStatusT(const Status& s) {		status_t CameraProviderManager::mapToStatusT(const Status& s) {

services/camera/libcameraservice/common/CameraProviderManager.h

+30 −0

Original line number	Original line	Diff line number	Diff line
	@@ -22,6 +22,7 @@
	#include <unordered_set>		#include <unordered_set>
	#include <string>		#include <string>
	#include <mutex>		#include <mutex>
			#include <future>

	#include <camera/camera2/ConcurrentCamera.h>		#include <camera/camera2/ConcurrentCamera.h>
	#include <camera/CameraParameters2.h>		#include <camera/CameraParameters2.h>
	@@ -403,6 +404,15 @@ private:
	const hardware::hidl_string& physicalCameraDeviceName,		const hardware::hidl_string& physicalCameraDeviceName,
	hardware::camera::common::V1_0::CameraDeviceStatus newStatus) override;		hardware::camera::common::V1_0::CameraDeviceStatus newStatus) override;

			status_t cameraDeviceStatusChangeLocked(
			std::string* id, const hardware::hidl_string& cameraDeviceName,
			hardware::camera::common::V1_0::CameraDeviceStatus newStatus);
			status_t physicalCameraDeviceStatusChangeLocked(
			std::string* id, std::string* physicalId,
			const hardware::hidl_string& cameraDeviceName,
			const hardware::hidl_string& physicalCameraDeviceName,
			hardware::camera::common::V1_0::CameraDeviceStatus newStatus);

	// hidl_death_recipient interface - this locks the parent mInterfaceMutex		// hidl_death_recipient interface - this locks the parent mInterfaceMutex
	virtual void serviceDied(uint64_t cookie, const wp<hidl::base::V1_0::IBase>& who) override;		virtual void serviceDied(uint64_t cookie, const wp<hidl::base::V1_0::IBase>& who) override;

	@@ -598,7 +608,27 @@ private:

	CameraProviderManager *mManager;		CameraProviderManager *mManager;

			struct CameraStatusInfoT {
			bool isPhysicalCameraStatus = false;
			hardware::hidl_string cameraId;
			hardware::hidl_string physicalCameraId;
			hardware::camera::common::V1_0::CameraDeviceStatus status;
			CameraStatusInfoT(bool isForPhysicalCamera, const hardware::hidl_string& id,
			const hardware::hidl_string& physicalId,
			hardware::camera::common::V1_0::CameraDeviceStatus s) :
			isPhysicalCameraStatus(isForPhysicalCamera), cameraId(id),
			physicalCameraId(physicalId), status(s) {}
			};

			// Lock to synchronize between initialize() and camera status callbacks
			std::mutex mInitLock;
	bool mInitialized = false;		bool mInitialized = false;
			std::vector<CameraStatusInfoT> mCachedStatus;
			// End of scope for mInitLock

			std::future<void> mInitialStatusCallbackFuture;
			void notifyInitialStatusChange(sp<StatusListener> listener,
			std::unique_ptr<std::vector<CameraStatusInfoT>> cachedStatus);

	std::vector<std::unordered_set<std::string>> mConcurrentCameraIdCombinations;		std::vector<std::unordered_set<std::string>> mConcurrentCameraIdCombinations;