Merge "Camera: expose external camera to API1" (2bf84ab0) · Commits · e / os / android_frameworks_av

services/camera/libcameraservice/CameraFlashlight.cpp

+15 −17

Original line number	Diff line number	Diff line
		@@ -32,13 +32,15 @@

		namespace android {

		using hardware::camera::common::V1_0::TorchModeStatus;

		/////////////////////////////////////////////////////////////////////
		// CameraFlashlight implementation begins
		// used by camera service to control flashflight.
		/////////////////////////////////////////////////////////////////////

		CameraFlashlight::CameraFlashlight(sp<CameraProviderManager> providerManager,
		camera_module_callbacks_t* callbacks) :
		CameraProviderManager::StatusListener* callbacks) :
		mProviderManager(providerManager),
		mCallbacks(callbacks),
		mFlashlightMapInitialized(false) {
		@@ -59,7 +61,7 @@ status_t CameraFlashlight::createFlashlightControl(const String8& cameraId) {
		} else {
		// Only HAL1 devices do not support setTorchMode
		mFlashControl =
		new CameraHardwareInterfaceFlashControl(mProviderManager, *mCallbacks);
		new CameraHardwareInterfaceFlashControl(mProviderManager, mCallbacks);
		}

		return OK;
		@@ -119,7 +121,8 @@ status_t CameraFlashlight::setTorchMode(const String8& cameraId, bool enabled) {
		}

		int CameraFlashlight::getNumberOfCameras() {
		return mProviderManager->getAPI1CompatibleCameraCount();
		size_t len = mProviderManager->getAPI1CompatibleCameraDeviceIds().size();
		return static_cast<int>(len);
		}

		status_t CameraFlashlight::findFlashUnits() {
		@@ -221,9 +224,8 @@ status_t CameraFlashlight::prepareDeviceOpen(const String8& cameraId) {
		int numCameras = getNumberOfCameras();
		for (int i = 0; i < numCameras; i++) {
		if (hasFlashUnitLocked(String8::format("%d", i))) {
		mCallbacks->torch_mode_status_change(mCallbacks,
		String8::format("%d", i).string(),
		TORCH_MODE_STATUS_NOT_AVAILABLE);
		mCallbacks->onTorchStatusChanged(
		String8::format("%d", i), TorchModeStatus::NOT_AVAILABLE);
		}
		}
		}
		@@ -266,9 +268,8 @@ status_t CameraFlashlight::deviceClosed(const String8& cameraId) {
		int numCameras = getNumberOfCameras();
		for (int i = 0; i < numCameras; i++) {
		if (hasFlashUnitLocked(String8::format("%d", i))) {
		mCallbacks->torch_mode_status_change(mCallbacks,
		String8::format("%d", i).string(),
		TORCH_MODE_STATUS_AVAILABLE_OFF);
		mCallbacks->onTorchStatusChanged(
		String8::format("%d", i), TorchModeStatus::AVAILABLE_OFF);
		}
		}
		}
		@@ -315,9 +316,9 @@ status_t ProviderFlashControl::setTorchMode(const String8& cameraId, bool enable

		CameraHardwareInterfaceFlashControl::CameraHardwareInterfaceFlashControl(
		sp<CameraProviderManager> manager,
		const camera_module_callbacks_t& callbacks) :
		CameraProviderManager::StatusListener* callbacks) :
		mProviderManager(manager),
		mCallbacks(&callbacks),
		mCallbacks(callbacks),
		mTorchEnabled(false) {
		}

		@@ -333,8 +334,7 @@ CameraHardwareInterfaceFlashControl::~CameraHardwareInterfaceFlashControl() {
		if (mCallbacks) {
		ALOGV("%s: notify the framework that torch was turned off",
		__FUNCTION__);
		mCallbacks->torch_mode_status_change(mCallbacks,
		mCameraId.string(), TORCH_MODE_STATUS_AVAILABLE_OFF);
		mCallbacks->onTorchStatusChanged(mCameraId, TorchModeStatus::AVAILABLE_OFF);
		}
		}
		}
		@@ -368,8 +368,7 @@ status_t CameraHardwareInterfaceFlashControl::setTorchMode(
		// disabling the torch mode of currently opened device
		disconnectCameraDevice();
		mTorchEnabled = false;
		mCallbacks->torch_mode_status_change(mCallbacks,
		cameraId.string(), TORCH_MODE_STATUS_AVAILABLE_OFF);
		mCallbacks->onTorchStatusChanged(cameraId, TorchModeStatus::AVAILABLE_OFF);
		return OK;
		}

		@@ -379,8 +378,7 @@ status_t CameraHardwareInterfaceFlashControl::setTorchMode(
		}

		mTorchEnabled = true;
		mCallbacks->torch_mode_status_change(mCallbacks,
		cameraId.string(), TORCH_MODE_STATUS_AVAILABLE_ON);
		mCallbacks->onTorchStatusChanged(cameraId, TorchModeStatus::AVAILABLE_ON);
		return OK;
		}

services/camera/libcameraservice/CameraFlashlight.h

+4 −5

Original line number	Diff line number	Diff line
		@@ -19,7 +19,6 @@

		#include <gui/GLConsumer.h>
		#include <gui/Surface.h>
		#include <hardware/camera_common.h>
		#include <utils/KeyedVector.h>
		#include <utils/SortedVector.h>
		#include "common/CameraProviderManager.h"
		@@ -55,7 +54,7 @@ class FlashControlBase : public virtual VirtualLightRefBase {
		class CameraFlashlight : public virtual VirtualLightRefBase {
		public:
		CameraFlashlight(sp<CameraProviderManager> providerManager,
		camera_module_callbacks_t* callbacks);
		CameraProviderManager::StatusListener* callbacks);
		virtual ~CameraFlashlight();

		// Find all flash units. This must be called before other methods. All
		@@ -99,7 +98,7 @@ class CameraFlashlight : public virtual VirtualLightRefBase {

		sp<CameraProviderManager> mProviderManager;

		const camera_module_callbacks_t *mCallbacks;
		CameraProviderManager::StatusListener* mCallbacks;
		SortedVector<String8> mOpenedCameraIds;

		// camera id -> if it has a flash unit
		@@ -134,7 +133,7 @@ class CameraHardwareInterfaceFlashControl : public FlashControlBase {
		public:
		CameraHardwareInterfaceFlashControl(
		sp<CameraProviderManager> manager,
		const camera_module_callbacks_t& callbacks);
		CameraProviderManager::StatusListener* callbacks);
		virtual ~CameraHardwareInterfaceFlashControl();

		// FlashControlBase
		@@ -166,7 +165,7 @@ class CameraHardwareInterfaceFlashControl : public FlashControlBase {
		status_t hasFlashUnitLocked(const String8& cameraId, bool *hasFlash, bool keepDeviceOpen);

		sp<CameraProviderManager> mProviderManager;
		const camera_module_callbacks_t *mCallbacks;
		CameraProviderManager::StatusListener* mCallbacks;
		sp<CameraHardwareInterface> mDevice;
		String8 mCameraId;
		CameraParameters mParameters;

services/camera/libcameraservice/CameraService.cpp

+93 −138

Original line number	Diff line number	Diff line
		@@ -107,79 +107,13 @@ static void setLogLevel(int level) {

		// ----------------------------------------------------------------------------

		extern "C" {
		static void camera_device_status_change(
		const struct camera_module_callbacks* callbacks,
		int camera_id,
		int new_status) {
		sp<CameraService> cs = const_cast<CameraService*>(
		static_cast<const CameraService*>(callbacks));
		String8 id = String8::format("%d", camera_id);

		CameraDeviceStatus newStatus{CameraDeviceStatus::NOT_PRESENT};
		switch (new_status) {
		case CAMERA_DEVICE_STATUS_NOT_PRESENT:
		newStatus = CameraDeviceStatus::NOT_PRESENT;
		break;
		case CAMERA_DEVICE_STATUS_PRESENT:
		newStatus = CameraDeviceStatus::PRESENT;
		break;
		case CAMERA_DEVICE_STATUS_ENUMERATING:
		newStatus = CameraDeviceStatus::ENUMERATING;
		break;
		default:
		ALOGW("Unknown device status change to %d", new_status);
		break;
		}
		cs->onDeviceStatusChanged(id, newStatus);
		}

		static void torch_mode_status_change(
		const struct camera_module_callbacks* callbacks,
		const char* camera_id,
		int new_status) {
		if (!callbacks \|\| !camera_id) {
		ALOGE("%s invalid parameters. callbacks %p, camera_id %p", __FUNCTION__,
		callbacks, camera_id);
		}
		sp<CameraService> cs = const_cast<CameraService*>(
		static_cast<const CameraService*>(callbacks));

		TorchModeStatus status;
		switch (new_status) {
		case TORCH_MODE_STATUS_NOT_AVAILABLE:
		status = TorchModeStatus::NOT_AVAILABLE;
		break;
		case TORCH_MODE_STATUS_AVAILABLE_OFF:
		status = TorchModeStatus::AVAILABLE_OFF;
		break;
		case TORCH_MODE_STATUS_AVAILABLE_ON:
		status = TorchModeStatus::AVAILABLE_ON;
		break;
		default:
		ALOGE("Unknown torch status %d", new_status);
		return;
		}

		cs->onTorchStatusChanged(
		String8(camera_id),
		status);
		}
		} // extern "C"

		// ----------------------------------------------------------------------------

		static const String16 sManageCameraPermission("android.permission.MANAGE_CAMERA");

		CameraService::CameraService() :
		mEventLog(DEFAULT_EVENT_LOG_LENGTH),
		mNumberOfCameras(0), mNumberOfNormalCameras(0),
		mNumberOfCameras(0),
		mSoundRef(0), mInitialized(false) {
		ALOGI("CameraService started (pid=%d)", getpid());

		this->camera_device_status_change = android::camera_device_status_change;
		this->torch_mode_status_change = android::torch_mode_status_change;

		mServiceLockWrapper = std::make_shared<WaitableMutexWrapper>(&mServiceLock);
		}

		@@ -209,6 +143,9 @@ void CameraService::onFirstRef()

		status_t CameraService::enumerateProviders() {
		status_t res;

		std::vector<std::string> deviceIds;
		{
		Mutex::Autolock l(mServiceLock);

		if (nullptr == mCameraProviderManager.get()) {
		@@ -221,9 +158,6 @@ status_t CameraService::enumerateProviders() {
		}
		}

		mNumberOfCameras = mCameraProviderManager->getCameraCount();
		mNumberOfNormalCameras =
		mCameraProviderManager->getAPI1CompatibleCameraCount();

		// Setup vendor tags before we call get_camera_info the first time
		// because HAL might need to setup static vendor keys in get_camera_info
		@@ -239,22 +173,12 @@ status_t CameraService::enumerateProviders() {
		ALOGE("Failed to enumerate flash units: %s (%d)", strerror(-res), res);
		}

		for (auto& cameraId : mCameraProviderManager->getCameraDeviceIds()) {
		String8 id8 = String8(cameraId.c_str());
		bool cameraFound = false;
		{

		Mutex::Autolock lock(mCameraStatesLock);
		auto iter = mCameraStates.find(id8);
		if (iter != mCameraStates.end()) {
		cameraFound = true;
		}
		deviceIds = mCameraProviderManager->getCameraDeviceIds();
		}

		if (!cameraFound) {
		addStates(id8);
		}

		for (auto& cameraId : deviceIds) {
		String8 id8 = String8(cameraId.c_str());
		onDeviceStatusChanged(id8, CameraDeviceStatus::PRESENT);
		}

		@@ -291,6 +215,13 @@ void CameraService::onNewProviderRegistered() {
		enumerateProviders();
		}

		void CameraService::updateCameraNumAndIds() {
		Mutex::Autolock l(mServiceLock);
		mNumberOfCameras = mCameraProviderManager->getCameraCount();
		mNormalDeviceIds =
		mCameraProviderManager->getAPI1CompatibleCameraDeviceIds();
		}

		void CameraService::addStates(const String8 id) {
		std::string cameraId(id.c_str());
		hardware::camera::common::V1_0::CameraResourceCost cost;
		@@ -313,10 +244,13 @@ void CameraService::addStates(const String8 id) {
		if (mFlashlight->hasFlashUnit(id)) {
		mTorchStatusMap.add(id, TorchModeStatus::AVAILABLE_OFF);
		}

		updateCameraNumAndIds();
		logDeviceAdded(id, "Device added");
		}

		void CameraService::removeStates(const String8 id) {
		updateCameraNumAndIds();
		if (mFlashlight->hasFlashUnit(id)) {
		mTorchStatusMap.removeItem(id);
		}
		@@ -361,15 +295,16 @@ void CameraService::onDeviceStatusChanged(const String8& id,
		if (newStatus == StatusInternal::NOT_PRESENT) {
		logDeviceRemoved(id, String8::format("Device status changed from %d to %d", oldStatus,
		newStatus));
		sp<BasicClient> clientToDisconnect;
		{
		// Don't do this in updateStatus to avoid deadlock over mServiceLock
		Mutex::Autolock lock(mServiceLock);

		// Set the device status to NOT_PRESENT, clients will no longer be able to connect
		// to this device until the status changes
		updateStatus(StatusInternal::NOT_PRESENT, id);

		sp<BasicClient> clientToDisconnect;
		{
		// Don't do this in updateStatus to avoid deadlock over mServiceLock
		Mutex::Autolock lock(mServiceLock);

		// Remove cached shim parameters
		state->setShimParams(CameraParameters());

		@@ -472,7 +407,7 @@ Status CameraService::getNumberOfCameras(int32_t type, int32_t* numCameras) {
		Mutex::Autolock l(mServiceLock);
		switch (type) {
		case CAMERA_TYPE_BACKWARD_COMPATIBLE:
		*numCameras = mNumberOfNormalCameras;
		*numCameras = static_cast<int>(mNormalDeviceIds.size());
		break;
		case CAMERA_TYPE_ALL:
		*numCameras = mNumberOfCameras;
		@@ -502,7 +437,8 @@ Status CameraService::getCameraInfo(int cameraId,
		}

		Status ret = Status::ok();
		status_t err = mCameraProviderManager->getCameraInfo(std::to_string(cameraId), cameraInfo);
		status_t err = mCameraProviderManager->getCameraInfo(
		cameraIdIntToStrLocked(cameraId), cameraInfo);
		if (err != OK) {
		ret = STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
		"Error retrieving camera info from device %d: %s (%d)", cameraId,
		@@ -512,13 +448,19 @@ Status CameraService::getCameraInfo(int cameraId,
		return ret;
		}

		int CameraService::cameraIdToInt(const String8& cameraId) {
		int id;
		bool success = base::ParseInt(cameraId.string(), &id, 0);
		if (!success) {
		return -1;
		std::string CameraService::cameraIdIntToStrLocked(int cameraIdInt) {
		if (cameraIdInt < 0 \|\| cameraIdInt >= static_cast<int>(mNormalDeviceIds.size())) {
		ALOGE("%s: input id %d invalid: valid range (0, %zu)",
		__FUNCTION__, cameraIdInt, mNormalDeviceIds.size());
		return std::string{};
		}

		return mNormalDeviceIds[cameraIdInt];
		}
		return id;

		String8 CameraService::cameraIdIntToStr(int cameraIdInt) {
		Mutex::Autolock lock(mServiceLock);
		return String8(cameraIdIntToStrLocked(cameraIdInt).c_str());
		}

		Status CameraService::getCameraCharacteristics(const String16& cameraId,
		@@ -635,8 +577,8 @@ Status CameraService::filterGetInfoErrorCode(status_t err) {

		Status CameraService::makeClient(const sp<CameraService>& cameraService,
		const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId,
		int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode,
		int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
		int api1CameraId, int facing, int clientPid, uid_t clientUid, int servicePid,
		bool legacyMode, int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
		/out/sp<BasicClient>* client) {

		if (halVersion < 0 \|\| halVersion == deviceVersion) {
		@@ -646,8 +588,9 @@ Status CameraService::makeClient(const sp<CameraService>& cameraService,
		case CAMERA_DEVICE_API_VERSION_1_0:
		if (effectiveApiLevel == API_1) { // Camera1 API route
		sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
		*client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId),
		facing, clientPid, clientUid, getpid(), legacyMode);
		*client = new CameraClient(cameraService, tmp, packageName,
		api1CameraId, facing, clientPid, clientUid,
		getpid(), legacyMode);
		} else { // Camera2 API route
		ALOGW("Camera using old HAL version: %d", deviceVersion);
		return STATUS_ERROR_FMT(ERROR_DEPRECATED_HAL,
		@@ -662,8 +605,10 @@ Status CameraService::makeClient(const sp<CameraService>& cameraService,
		case CAMERA_DEVICE_API_VERSION_3_4:
		if (effectiveApiLevel == API_1) { // Camera1 API route
		sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
		*client = new Camera2Client(cameraService, tmp, packageName, cameraIdToInt(cameraId),
		facing, clientPid, clientUid, servicePid, legacyMode);
		*client = new Camera2Client(cameraService, tmp, packageName,
		cameraId, api1CameraId,
		facing, clientPid, clientUid,
		servicePid, legacyMode);
		} else { // Camera2 API route
		sp<hardware::camera2::ICameraDeviceCallbacks> tmp =
		static_cast<hardware::camera2::ICameraDeviceCallbacks*>(cameraCb.get());
		@@ -685,8 +630,9 @@ Status CameraService::makeClient(const sp<CameraService>& cameraService,
		halVersion == CAMERA_DEVICE_API_VERSION_1_0) {
		// Only support higher HAL version device opened as HAL1.0 device.
		sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
		*client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId),
		facing, clientPid, clientUid, servicePid, legacyMode);
		*client = new CameraClient(cameraService, tmp, packageName,
		api1CameraId, facing, clientPid, clientUid,
		servicePid, legacyMode);
		} else {
		// Other combinations (e.g. HAL3.x open as HAL2.x) are not supported yet.
		ALOGE("Invalid camera HAL version %x: HAL %x device can only be"
		@@ -782,7 +728,8 @@ Status CameraService::initializeShimMetadata(int cameraId) {
		Status ret = Status::ok();
		sp<Client> tmp = nullptr;
		if (!(ret = connectHelper<ICameraClient,Client>(
		sp<ICameraClient>{nullptr}, id, static_cast<int>(CAMERA_HAL_API_VERSION_UNSPECIFIED),
		sp<ICameraClient>{nullptr}, id, cameraId,
		static_cast<int>(CAMERA_HAL_API_VERSION_UNSPECIFIED),
		internalPackageName, uid, USE_CALLING_PID,
		API_1, /legacyMode/ false, /shimUpdateOnly/ true,
		/out/ tmp)
		@@ -1235,7 +1182,7 @@ status_t CameraService::handleEvictionsLocked(const String8& cameraId, int clien

		Status CameraService::connect(
		const sp<ICameraClient>& cameraClient,
		int cameraId,
		int api1CameraId,
		const String16& clientPackageName,
		int clientUid,
		int clientPid,
		@@ -1244,9 +1191,10 @@ Status CameraService::connect(

		ATRACE_CALL();
		Status ret = Status::ok();
		String8 id = String8::format("%d", cameraId);

		String8 id = cameraIdIntToStr(api1CameraId);
		sp<Client> client = nullptr;
		ret = connectHelper<ICameraClient,Client>(cameraClient, id,
		ret = connectHelper<ICameraClient,Client>(cameraClient, id, api1CameraId,
		CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName, clientUid, clientPid, API_1,
		/legacyMode/ false, /shimUpdateOnly/ false,
		/out/client);
		@@ -1263,18 +1211,18 @@ Status CameraService::connect(

		Status CameraService::connectLegacy(
		const sp<ICameraClient>& cameraClient,
		int cameraId, int halVersion,
		int api1CameraId, int halVersion,
		const String16& clientPackageName,
		int clientUid,
		/out/
		sp<ICamera>* device) {

		ATRACE_CALL();
		String8 id = String8::format("%d", cameraId);
		String8 id = cameraIdIntToStr(api1CameraId);

		Status ret = Status::ok();
		sp<Client> client = nullptr;
		ret = connectHelper<ICameraClient,Client>(cameraClient, id, halVersion,
		ret = connectHelper<ICameraClient,Client>(cameraClient, id, api1CameraId, halVersion,
		clientPackageName, clientUid, USE_CALLING_PID, API_1,
		/legacyMode/ true, /shimUpdateOnly/ false,
		/out/client);
		@@ -1302,6 +1250,7 @@ Status CameraService::connectDevice(
		String8 id = String8(cameraId);
		sp<CameraDeviceClient> client = nullptr;
		ret = connectHelper<hardware::camera2::ICameraDeviceCallbacks,CameraDeviceClient>(cameraCb, id,
		/api1CameraId/-1,
		CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName,
		clientUid, USE_CALLING_PID, API_2,
		/legacyMode/ false, /shimUpdateOnly/ false,
		@@ -1319,8 +1268,8 @@ Status CameraService::connectDevice(

		template<class CALLBACK, class CLIENT>
		Status CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,
		int halVersion, const String16& clientPackageName, int clientUid, int clientPid,
		apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly,
		int api1CameraId, int halVersion, const String16& clientPackageName, int clientUid,
		int clientPid, apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly,
		/out/sp<CLIENT>& device) {
		binder::Status ret = binder::Status::ok();

		@@ -1403,8 +1352,10 @@ Status CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8&
		}

		sp<BasicClient> tmp = nullptr;
		if(!(ret = makeClient(this, cameraCb, clientPackageName, cameraId, facing, clientPid,
		clientUid, getpid(), legacyMode, halVersion, deviceVersion, effectiveApiLevel,
		if(!(ret = makeClient(this, cameraCb, clientPackageName,
		cameraId, api1CameraId, facing,
		clientPid, clientUid, getpid(), legacyMode,
		halVersion, deviceVersion, effectiveApiLevel,
		/out/&tmp)).isOk()) {
		return ret;
		}
		@@ -2112,7 +2063,8 @@ void CameraService::playSound(sound_kind kind) {
		CameraService::Client::Client(const sp<CameraService>& cameraService,
		const sp<ICameraClient>& cameraClient,
		const String16& clientPackageName,
		const String8& cameraIdStr, int cameraFacing,
		const String8& cameraIdStr,
		int api1CameraId, int cameraFacing,
		int clientPid, uid_t clientUid,
		int servicePid) :
		CameraService::BasicClient(cameraService,
		@@ -2121,7 +2073,7 @@ CameraService::Client::Client(const sp<CameraService>& cameraService,
		cameraIdStr, cameraFacing,
		clientPid, clientUid,
		servicePid),
		mCameraId(CameraService::cameraIdToInt(cameraIdStr))
		mCameraId(api1CameraId)
		{
		int callingPid = getCallingPid();
		LOG1("Client::Client E (pid %d, id %d)", callingPid, mCameraId);
		@@ -2676,7 +2628,10 @@ status_t CameraService::dump(int fd, const Vector<String16>& args) {
		}
		dprintf(fd, "\n== Service global info: ==\n\n");
		dprintf(fd, "Number of camera devices: %d\n", mNumberOfCameras);
		dprintf(fd, "Number of normal camera devices: %d\n", mNumberOfNormalCameras);
		dprintf(fd, "Number of normal camera devices: %zu\n", mNormalDeviceIds.size());
		for (size_t i = 0; i < mNormalDeviceIds.size(); i++) {
		dprintf(fd, " Device %zu maps to \"%s\"\n", i, mNormalDeviceIds[i].c_str());
		}
		String8 activeClientString = mActiveClientManager.toString();
		dprintf(fd, "Active Camera Clients:\n%s", activeClientString.string());
		dprintf(fd, "Allowed user IDs: %s\n", toString(mAllowedUsers).string());

services/camera/libcameraservice/CameraService.h

+22 −8

Original line number	Diff line number	Diff line
		@@ -62,7 +62,6 @@ class CameraService :
		public BinderService<CameraService>,
		public virtual ::android::hardware::BnCameraService,
		public virtual IBinder::DeathRecipient,
		public camera_module_callbacks_t,
		public virtual CameraProviderManager::StatusListener
		{
		friend class BinderService<CameraService>;
		@@ -333,6 +332,7 @@ public:
		const sp<hardware::ICameraClient>& cameraClient,
		const String16& clientPackageName,
		const String8& cameraIdStr,
		int api1CameraId,
		int cameraFacing,
		int clientPid,
		uid_t clientUid,
		@@ -551,7 +551,8 @@ private:
		// Eumerate all camera providers in the system
		status_t enumerateProviders();

		// Add a new camera to camera and torch state lists or remove an unplugged one
		// Add/remove a new camera to camera and torch state lists or remove an unplugged one
		// Caller must not hold mServiceLock
		void addStates(const String8 id);
		void removeStates(const String8 id);

		@@ -578,7 +579,7 @@ private:
		// Single implementation shared between the various connect calls
		template<class CALLBACK, class CLIENT>
		binder::Status connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,
		int halVersion, const String16& clientPackageName,
		int api1CameraId, int halVersion, const String16& clientPackageName,
		int clientUid, int clientPid,
		apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly,
		/out/sp<CLIENT>& device);
		@@ -640,9 +641,16 @@ private:
		void finishConnectLocked(const sp<BasicClient>& client, const DescriptorPtr& desc);

		/**
		* Returns the integer corresponding to the given camera ID string, or -1 on failure.
		* Returns the underlying camera Id string mapped to a camera id int
		* Empty string is returned when the cameraIdInt is invalid.
		*/
		static int cameraIdToInt(const String8& cameraId);
		String8 cameraIdIntToStr(int cameraIdInt);

		/**
		* Returns the underlying camera Id string mapped to a camera id int
		* Empty string is returned when the cameraIdInt is invalid.
		*/
		std::string cameraIdIntToStrLocked(int cameraIdInt);

		/**
		* Remove a single client corresponding to the given camera id from the list of active clients.
		@@ -710,8 +718,14 @@ private:
		*/
		void dumpEventLog(int fd);

		/**
		* This method will acquire mServiceLock
		*/
		void updateCameraNumAndIds();

		int mNumberOfCameras;
		int mNumberOfNormalCameras;

		std::vector<std::string> mNormalDeviceIds;

		// sounds
		MediaPlayer* newMediaPlayer(const char *file);
		@@ -821,8 +835,8 @@ private:

		static binder::Status makeClient(const sp<CameraService>& cameraService,
		const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId,
		int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode,
		int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
		int api1CameraId, int facing, int clientPid, uid_t clientUid, int servicePid,
		bool legacyMode, int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
		/out/sp<BasicClient>* client);

		status_t checkCameraAccess(const String16& opPackageName);

services/camera/libcameraservice/api1/Camera2Client.cpp

+4 −3

Original line number	Diff line number	Diff line
		@@ -49,16 +49,17 @@ static int getCallingPid() {
		Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
		const sp<hardware::ICameraClient>& cameraClient,
		const String16& clientPackageName,
		int cameraId,
		const String8& cameraDeviceId,
		int api1CameraId,
		int cameraFacing,
		int clientPid,
		uid_t clientUid,
		int servicePid,
		bool legacyMode):
		Camera2ClientBase(cameraService, cameraClient, clientPackageName,
		String8::format("%d", cameraId), cameraFacing,
		cameraDeviceId, api1CameraId, cameraFacing,
		clientPid, clientUid, servicePid),
		mParameters(cameraId, cameraFacing)
		mParameters(api1CameraId, cameraFacing)
		{
		ATRACE_CALL();