Camera: Fix race between initialize() and statusCallback (take 2) am: 394ad70e9e (7e157b60) · Commits · e / os / android_frameworks_av

services/camera/libcameraservice/common/CameraProviderManager.cpp

+153 −68

Original line number	Diff line number	Diff line
		@@ -1453,7 +1453,40 @@ status_t CameraProviderManager::ProviderInfo::initialize(
		ALOGI("Camera provider %s ready with %zu camera devices",
		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;
		}

		// 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;
		}

		@@ -1731,17 +1764,42 @@ hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusCh
		CameraDeviceStatus newStatus) {
		sp<StatusListener> listener;
		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);
		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;
		std::string cameraId;
		for (auto& deviceInfo : mDevices) {
		if (deviceInfo->mName == cameraDeviceName) {
		ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),
		deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus));
		deviceInfo->mStatus = newStatus;
		// TODO: Handle device removal (NOT_PRESENT)
		id = deviceInfo->mId;
		cameraId = deviceInfo->mId;
		known = true;
		break;
		}
		@@ -1751,27 +1809,18 @@ hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusCh
		if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
		ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",
		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) {
		removeDevice(id);
		removeDevice(cameraId);
		}
		listener = mManager->getStatusListener();
		initialized = mInitialized;
		if (reCacheConcurrentStreamingCameraIdsLocked() != OK) {
		ALOGE("%s: CameraProvider %s could not re-cache concurrent streaming camera id list ",
		__FUNCTION__, mProviderName.c_str());
		}
		}
		// 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 && initialized) {
		listener->onDeviceStatusChanged(String8(id.c_str()), newStatus);
		}
		return hardware::Void();
		*id = cameraId;
		return OK;
		}

		hardware::Return<void> CameraProviderManager::ProviderInfo::physicalCameraDeviceStatusChange(
		@@ -1780,25 +1829,53 @@ hardware::Return<void> CameraProviderManager::ProviderInfo::physicalCameraDevice
		CameraDeviceStatus newStatus) {
		sp<StatusListener> listener;
		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);
		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;
		std::string cameraId;
		for (auto& deviceInfo : mDevices) {
		if (deviceInfo->mName == cameraDeviceName) {
		id = deviceInfo->mId;

		cameraId = deviceInfo->mId;
		if (!deviceInfo->mIsLogicalCamera) {
		ALOGE("%s: Invalid combination of camera id %s, physical id %s",
		__FUNCTION__, id.c_str(), physicalCameraDeviceName.c_str());
		return hardware::Void();
		__FUNCTION__, cameraId.c_str(), physicalCameraDeviceName.c_str());
		return BAD_VALUE;
		}
		if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),
		physicalCameraDeviceName) == deviceInfo->mPhysicalIds.end()) {
		ALOGE("%s: Invalid combination of camera id %s, physical id %s",
		__FUNCTION__, id.c_str(), physicalCameraDeviceName.c_str());
		return hardware::Void();
		__FUNCTION__, cameraId.c_str(), physicalCameraDeviceName.c_str());
		return BAD_VALUE;
		}
		ALOGI("Camera device %s physical device %s status is now %s",
		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.",
		mProviderName.c_str(), cameraDeviceName.c_str(),
		physicalCameraDeviceName.c_str());
		return hardware::Void();
		}
		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 BAD_VALUE;
		}
		return hardware::Void();

		*id = cameraId;
		*physicalId = physicalCameraDeviceName.c_str();
		return OK;
		}

		hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange(
		@@ -1982,6 +2051,20 @@ status_t CameraProviderManager::ProviderInfo::isConcurrentSessionConfigurationSu
		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>
		std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
		CameraProviderManager::ProviderInfo::initializeDeviceInfo(
		@@ -2685,9 +2768,11 @@ status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string&


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

		}

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

services/camera/libcameraservice/common/CameraProviderManager.h

+30 −0

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

		#include <camera/camera2/ConcurrentCamera.h>
		#include <camera/CameraParameters2.h>
		@@ -403,6 +404,15 @@ private:
		const hardware::hidl_string& physicalCameraDeviceName,
		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
		virtual void serviceDied(uint64_t cookie, const wp<hidl::base::V1_0::IBase>& who) override;

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

		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;
		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;