Snap for 12979963 from 462c24b327cf31d434380bc8849d808ac29b327f to 25Q2-release (9ac0237c) · Commits · e / os / android_frameworks_av

camera/aidl/android/hardware/ICameraService.aidl

+0 −8

Original line number	Diff line number	Diff line
		@@ -261,14 +261,6 @@ interface ICameraService
		*/
		@utf8InCpp String getLegacyParameters(int cameraId);

		/**
		* apiVersion constants for supportsCameraApi
		*/
		const int API_VERSION_1 = 1;
		const int API_VERSION_2 = 2;

		// Determines if a particular API version is supported directly for a cameraId.
		boolean supportsCameraApi(@utf8InCpp String cameraId, int apiVersion);
		// Determines if a cameraId is a hidden physical camera of a logical multi-camera.
		boolean isHiddenPhysicalCamera(@utf8InCpp String cameraId);
		// Inject the external camera to replace the internal camera session.

camera/ndk/impl/ACameraManager.cpp

+24 −53

Original line number	Diff line number	Diff line
		@@ -376,17 +376,12 @@ void CameraManagerGlobal::registerAvailCallback(const DeviceContext& deviceConte
		const auto& [_, newlyRegistered] = mCallbacks.insert(cb);
		// Send initial callbacks if callback is newly registered
		if (newlyRegistered) {
		for (auto& [key, statusAndHAL3Support] : mDeviceStatusMap) {
		for (auto& [key, logicalAndPhysicalStatus] : mDeviceStatusMap) {
		if (!isCameraAccessible(deviceContext, key.deviceId)) {
		continue;
		}
		const std::string& cameraId = key.cameraId;
		int32_t status = statusAndHAL3Support.getStatus();
		// Don't send initial callbacks for camera ids which don't support
		// camera2
		if (!statusAndHAL3Support.supportsHAL3) {
		continue;
		}
		int32_t status = logicalAndPhysicalStatus.getStatus();

		// Camera available/unavailable callback
		sp<AMessage> msg = new AMessage(kWhatSendSingleCallback, mHandler);
		@@ -400,7 +395,7 @@ void CameraManagerGlobal::registerAvailCallback(const DeviceContext& deviceConte

		// Physical camera unavailable callback
		std::set<std::string> unavailablePhysicalCameras =
		statusAndHAL3Support.getUnavailablePhysicalIds();
		logicalAndPhysicalStatus.getUnavailablePhysicalIds();
		for (const auto& physicalCameraId : unavailablePhysicalCameras) {
		sp<AMessage> msg = new AMessage(kWhatSendSinglePhysicalCameraCallback, mHandler);
		ACameraManager_PhysicalCameraAvailabilityCallback cbFunc =
		@@ -416,42 +411,23 @@ void CameraManagerGlobal::registerAvailCallback(const DeviceContext& deviceConte
		}
		}

		bool CameraManagerGlobal::supportsCamera2ApiLocked(const std::string &cameraId) {
		bool camera2Support = false;
		auto cs = getCameraServiceLocked();
		if (cs == nullptr) {
		return false;
		}
		binder::Status serviceRet =
		cs->supportsCameraApi(cameraId,
		hardware::ICameraService::API_VERSION_2, &camera2Support);
		if (!serviceRet.isOk()) {
		ALOGE("%s: supportsCameraApi2Locked() call failed for cameraId %s",
		__FUNCTION__, cameraId.c_str());
		return false;
		}
		return camera2Support;
		}

		void CameraManagerGlobal::getCameraIdList(const DeviceContext& context,
		std::vector<std::string>* cameraIds) {
		// Ensure that we have initialized/refreshed the list of available devices
		Mutex::Autolock _l(mLock);
		// Needed to make sure we're connected to cameraservice
		getCameraServiceLocked();
		for (auto& [key, statusAndHAL3Support] : mDeviceStatusMap) {
		for (auto& [key, logicalAndPhysicalStatus] : mDeviceStatusMap) {
		if (!isCameraAccessible(context, key.deviceId)) {
		continue;
		}

		int32_t status = statusAndHAL3Support.getStatus();
		int32_t status = logicalAndPhysicalStatus.getStatus();
		if (status == hardware::ICameraServiceListener::STATUS_NOT_PRESENT \|\|
		status == hardware::ICameraServiceListener::STATUS_ENUMERATING) {
		continue;
		}
		if (!statusAndHAL3Support.supportsHAL3) {
		continue;
		}

		cameraIds->push_back(key.cameraId);
		}
		}
		@@ -649,15 +625,13 @@ void CameraManagerGlobal::onStatusChangedLocked(int32_t status, const int device
		return;
		}

		bool supportsHAL3 = supportsCamera2ApiLocked(cameraId);
		if (firstStatus) {
		mDeviceStatusMap.emplace(std::piecewise_construct, std::forward_as_tuple(key),
		std::forward_as_tuple(status, supportsHAL3));
		std::forward_as_tuple(status));
		} else {
		mDeviceStatusMap[key].updateStatus(status);
		}
		// Iterate through all registered callbacks
		if (supportsHAL3) {
		for (auto cb : mCallbacks) {
		if (!isCameraAccessible(cb.mDeviceContext, deviceId)) {
		continue;
		@@ -671,7 +645,6 @@ void CameraManagerGlobal::onStatusChangedLocked(int32_t status, const int device
		mPendingCallbackCnt++;
		msg->post();
		}
		}
		if (status == hardware::ICameraServiceListener::STATUS_NOT_PRESENT) {
		mDeviceStatusMap.erase(key);
		}
		@@ -705,8 +678,6 @@ void CameraManagerGlobal::onStatusChangedLocked(int32_t status, const int device
		return;
		}

		bool supportsHAL3 = supportsCamera2ApiLocked(cameraId);

		bool updated = false;
		if (status == hardware::ICameraServiceListener::STATUS_PRESENT) {
		updated = mDeviceStatusMap[key].removeUnavailablePhysicalId(physicalCameraId);
		@@ -715,7 +686,7 @@ void CameraManagerGlobal::onStatusChangedLocked(int32_t status, const int device
		}

		// Iterate through all registered callbacks
		if (supportsHAL3 && updated) {
		if (updated) {
		for (auto cb : mCallbacks) {
		if (!isCameraAccessible(cb.mDeviceContext, deviceId)) {
		continue;
		@@ -733,31 +704,31 @@ void CameraManagerGlobal::onStatusChangedLocked(int32_t status, const int device
		}
		}

		int32_t CameraManagerGlobal::StatusAndHAL3Support::getStatus() {
		int32_t CameraManagerGlobal::Status::getStatus() {
		std::lock_guard<std::mutex> lock(mLock);
		return status;
		}

		void CameraManagerGlobal::StatusAndHAL3Support::updateStatus(int32_t newStatus) {
		void CameraManagerGlobal::Status::updateStatus(int32_t newStatus) {
		std::lock_guard<std::mutex> lock(mLock);
		status = newStatus;
		}

		bool CameraManagerGlobal::StatusAndHAL3Support::addUnavailablePhysicalId(
		bool CameraManagerGlobal::Status::addUnavailablePhysicalId(
		const std::string& physicalCameraId) {
		std::lock_guard<std::mutex> lock(mLock);
		auto result = unavailablePhysicalIds.insert(physicalCameraId);
		return result.second;
		}

		bool CameraManagerGlobal::StatusAndHAL3Support::removeUnavailablePhysicalId(
		bool CameraManagerGlobal::Status::removeUnavailablePhysicalId(
		const std::string& physicalCameraId) {
		std::lock_guard<std::mutex> lock(mLock);
		auto count = unavailablePhysicalIds.erase(physicalCameraId);
		return count > 0;
		}

		std::set<std::string> CameraManagerGlobal::StatusAndHAL3Support::getUnavailablePhysicalIds() {
		std::set<std::string> CameraManagerGlobal::Status::getUnavailablePhysicalIds() {
		std::lock_guard<std::mutex> lock(mLock);
		return unavailablePhysicalIds;
		}

camera/ndk/impl/ACameraManager.h

+5 −7

Original line number	Diff line number	Diff line
		@@ -260,18 +260,16 @@ class CameraManagerGlobal final : public RefBase {
		// Utils for status
		static bool validStatus(int32_t status);
		static bool isStatusAvailable(int32_t status);
		bool supportsCamera2ApiLocked(const std::string &cameraId);

		struct StatusAndHAL3Support {
		struct Status {
		private:
		int32_t status = hardware::ICameraServiceListener::STATUS_NOT_PRESENT;
		mutable std::mutex mLock;
		std::set<std::string> unavailablePhysicalIds;
		public:
		const bool supportsHAL3 = false;
		StatusAndHAL3Support(int32_t st, bool HAL3support):
		status(st), supportsHAL3(HAL3support) { };
		StatusAndHAL3Support() = default;
		Status(int32_t st):
		status(st) { };
		Status() = default;

		bool addUnavailablePhysicalId(const std::string& physicalCameraId);
		bool removeUnavailablePhysicalId(const std::string& physicalCameraId);
		@@ -308,7 +306,7 @@ class CameraManagerGlobal final : public RefBase {
		}
		};

		std::map<DeviceStatusMapKey, StatusAndHAL3Support> mDeviceStatusMap;
		std::map<DeviceStatusMapKey, Status> mDeviceStatusMap;

		// For the singleton instance
		static Mutex sLock;

camera/tests/CameraBinderTests.cpp

+0 −9

Original line number	Diff line number	Diff line
		@@ -389,15 +389,6 @@ TEST(CameraServiceBinderTest, CheckBinderCameraService) {

		for (int32_t i = 0; i < numCameras; i++) {
		std::string cameraId = std::to_string(i);
		bool isSupported = false;
		res = service->supportsCameraApi(cameraId,
		hardware::ICameraService::API_VERSION_2, &isSupported);
		EXPECT_TRUE(res.isOk()) << res;

		// We only care about binder calls for the Camera2 API. Camera1 is deprecated.
		if (!isSupported) {
		continue;
		}

		// Check metadata binder call
		CameraMetadata metadata;

camera/tests/CameraCharacteristicsPermission.cpp

+1 −8

Original line number	Diff line number	Diff line
		@@ -66,19 +66,12 @@ void CameraCharacteristicsPermission::TearDown() {
		TEST_F(CameraCharacteristicsPermission, TestCameraPermission) {
		for (int32_t cameraId = 0; cameraId < numCameras; cameraId++) {
		std::string cameraIdStr = std::to_string(cameraId);
		bool isSupported = false;
		auto rc = mCameraService->supportsCameraApi(cameraIdStr,
		hardware::ICameraService::API_VERSION_2, &isSupported);
		EXPECT_TRUE(rc.isOk());
		if (!isSupported) {
		continue;
		}

		CameraMetadata metadata;
		std::vector<int32_t> tagsNeedingPermission;
		AttributionSourceState clientAttribution;
		clientAttribution.deviceId = kDefaultDeviceId;
		rc = mCameraService->getCameraCharacteristics(cameraIdStr,
		auto rc = mCameraService->getCameraCharacteristics(cameraIdStr,
		/targetSdkVersion/__ANDROID_API_FUTURE__,
		/overrideToPortrait/false, clientAttribution, /devicePolicy/0, &metadata);
		ASSERT_TRUE(rc.isOk());