Camera: Remove dead legacy code (31abd0ae) · Commits · e / os / android_frameworks_av

services/camera/libcameraservice/device1/CameraHardwareInterface.cpp

+0 −263

Original line number	Diff line number	Diff line
		@@ -29,11 +29,6 @@ using hardware::hidl_handle;
		CameraHardwareInterface::~CameraHardwareInterface()
		{
		ALOGI("Destroying camera %s", mName.string());
		if (mDevice) {
		int rc = mDevice->common.close(&mDevice->common);
		if (rc != OK)
		ALOGE("Could not close camera %s: %d", mName.string(), rc);
		}
		if (mHidlDevice != nullptr) {
		mHidlDevice->close();
		mHidlDevice.clear();
		@@ -42,12 +37,6 @@ CameraHardwareInterface::~CameraHardwareInterface()
		}

		status_t CameraHardwareInterface::initialize(sp<CameraProviderManager> manager) {
		if (mDevice) {
		ALOGE("%s: camera hardware interface has been initialized to libhardware path!",
		__FUNCTION__);
		return INVALID_OPERATION;
		}

		ALOGI("Opening camera %s", mName.string());

		status_t ret = manager->openSession(mName.string(), this, &mHidlDevice);
		@@ -444,23 +433,6 @@ status_t CameraHardwareInterface::setPreviewWindow(const sp<ANativeWindow>& buf)
		}
		return CameraProviderManager::mapToStatusT(
		mHidlDevice->setPreviewWindow(buf.get() ? this : nullptr));
		} else if (mDevice) {
		if (mDevice->ops->set_preview_window) {
		mPreviewWindow = buf;
		if (buf != nullptr) {
		if (mPreviewScalingMode != NOT_SET) {
		setPreviewScalingMode(mPreviewScalingMode);
		}
		if (mPreviewTransform != NOT_SET) {
		setPreviewTransform(mPreviewTransform);
		}
		}
		mHalPreviewWindow.user = this;
		ALOGV("%s &mHalPreviewWindow %p mHalPreviewWindow.user %p",__FUNCTION__,
		&mHalPreviewWindow, mHalPreviewWindow.user);
		return mDevice->ops->set_preview_window(mDevice,
		buf.get() ? &mHalPreviewWindow.nw : 0);
		}
		}
		return INVALID_OPERATION;
		}
		@@ -478,15 +450,6 @@ void CameraHardwareInterface::setCallbacks(notify_callback notify_cb,
		mCbUser = user;

		ALOGV("%s(%s)", __FUNCTION__, mName.string());

		if (mDevice && mDevice->ops->set_callbacks) {
		mDevice->ops->set_callbacks(mDevice,
		sNotifyCb,
		sDataCb,
		sDataCbTimestamp,
		sGetMemory,
		this);
		}
		}

		void CameraHardwareInterface::enableMsgType(int32_t msgType)
		@@ -494,8 +457,6 @@ void CameraHardwareInterface::enableMsgType(int32_t msgType)
		ALOGV("%s(%s)", __FUNCTION__, mName.string());
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		mHidlDevice->enableMsgType(msgType);
		} else if (mDevice && mDevice->ops->enable_msg_type) {
		mDevice->ops->enable_msg_type(mDevice, msgType);
		}
		}

		@@ -504,8 +465,6 @@ void CameraHardwareInterface::disableMsgType(int32_t msgType)
		ALOGV("%s(%s)", __FUNCTION__, mName.string());
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		mHidlDevice->disableMsgType(msgType);
		} else if (mDevice && mDevice->ops->disable_msg_type) {
		mDevice->ops->disable_msg_type(mDevice, msgType);
		}
		}

		@@ -514,8 +473,6 @@ int CameraHardwareInterface::msgTypeEnabled(int32_t msgType)
		ALOGV("%s(%s)", __FUNCTION__, mName.string());
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		return mHidlDevice->msgTypeEnabled(msgType);
		} else if (mDevice && mDevice->ops->msg_type_enabled) {
		return mDevice->ops->msg_type_enabled(mDevice, msgType);
		}
		return false;
		}
		@@ -526,8 +483,6 @@ status_t CameraHardwareInterface::startPreview()
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		return CameraProviderManager::mapToStatusT(
		mHidlDevice->startPreview());
		} else if (mDevice && mDevice->ops->start_preview) {
		return mDevice->ops->start_preview(mDevice);
		}
		return INVALID_OPERATION;
		}
		@@ -537,8 +492,6 @@ void CameraHardwareInterface::stopPreview()
		ALOGV("%s(%s)", __FUNCTION__, mName.string());
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		mHidlDevice->stopPreview();
		} else if (mDevice && mDevice->ops->stop_preview) {
		mDevice->ops->stop_preview(mDevice);
		}
		}

		@@ -547,8 +500,6 @@ int CameraHardwareInterface::previewEnabled()
		ALOGV("%s(%s)", __FUNCTION__, mName.string());
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		return mHidlDevice->previewEnabled();
		} else if (mDevice && mDevice->ops->preview_enabled) {
		return mDevice->ops->preview_enabled(mDevice);
		}
		return false;
		}
		@@ -559,8 +510,6 @@ status_t CameraHardwareInterface::storeMetaDataInBuffers(int enable)
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		return CameraProviderManager::mapToStatusT(
		mHidlDevice->storeMetaDataInBuffers(enable));
		} else if (mDevice && mDevice->ops->store_meta_data_in_buffers) {
		return mDevice->ops->store_meta_data_in_buffers(mDevice, enable);
		}
		return enable ? INVALID_OPERATION: OK;
		}
		@@ -571,8 +520,6 @@ status_t CameraHardwareInterface::startRecording()
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		return CameraProviderManager::mapToStatusT(
		mHidlDevice->startRecording());
		} else if (mDevice && mDevice->ops->start_recording) {
		return mDevice->ops->start_recording(mDevice);
		}
		return INVALID_OPERATION;
		}
		@@ -585,8 +532,6 @@ void CameraHardwareInterface::stopRecording()
		ALOGV("%s(%s)", __FUNCTION__, mName.string());
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		mHidlDevice->stopRecording();
		} else if (mDevice && mDevice->ops->stop_recording) {
		mDevice->ops->stop_recording(mDevice);
		}
		}

		@@ -598,8 +543,6 @@ int CameraHardwareInterface::recordingEnabled()
		ALOGV("%s(%s)", __FUNCTION__, mName.string());
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		return mHidlDevice->recordingEnabled();
		} else if (mDevice && mDevice->ops->recording_enabled) {
		return mDevice->ops->recording_enabled(mDevice);
		}
		return false;
		}
		@@ -624,9 +567,6 @@ void CameraHardwareInterface::releaseRecordingFrame(const sp<IMemory>& mem)
		} else {
		mHidlDevice->releaseRecordingFrame(heapId, bufferIndex);
		}
		} else if (mDevice && mDevice->ops->release_recording_frame) {
		void data = ((uint8_t )heap->base()) + offset;
		return mDevice->ops->release_recording_frame(mDevice, data);
		}
		}

		@@ -653,9 +593,6 @@ void CameraHardwareInterface::releaseRecordingFrameBatch(const std::vector<sp<IM
		ALOGE("%s only supports VideoNativeHandleMetadata mode", __FUNCTION__);
		return;
		}
		} else {
		ALOGE("Non HIDL mode do not support %s", __FUNCTION__);
		return;
		}
		}

		@@ -674,8 +611,6 @@ status_t CameraHardwareInterface::autoFocus()
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		return CameraProviderManager::mapToStatusT(
		mHidlDevice->autoFocus());
		} else if (mDevice && mDevice->ops->auto_focus) {
		return mDevice->ops->auto_focus(mDevice);
		}
		return INVALID_OPERATION;
		}
		@@ -686,8 +621,6 @@ status_t CameraHardwareInterface::cancelAutoFocus()
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		return CameraProviderManager::mapToStatusT(
		mHidlDevice->cancelAutoFocus());
		} else if (mDevice && mDevice->ops->cancel_auto_focus) {
		return mDevice->ops->cancel_auto_focus(mDevice);
		}
		return INVALID_OPERATION;
		}
		@@ -698,8 +631,6 @@ status_t CameraHardwareInterface::takePicture()
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		return CameraProviderManager::mapToStatusT(
		mHidlDevice->takePicture());
		} else if (mDevice && mDevice->ops->take_picture) {
		return mDevice->ops->take_picture(mDevice);
		}
		return INVALID_OPERATION;
		}
		@@ -710,8 +641,6 @@ status_t CameraHardwareInterface::cancelPicture()
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		return CameraProviderManager::mapToStatusT(
		mHidlDevice->cancelPicture());
		} else if (mDevice && mDevice->ops->cancel_picture) {
		return mDevice->ops->cancel_picture(mDevice);
		}
		return INVALID_OPERATION;
		}
		@@ -722,8 +651,6 @@ status_t CameraHardwareInterface::setParameters(const CameraParameters &params)
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		return CameraProviderManager::mapToStatusT(
		mHidlDevice->setParameters(params.flatten().string()));
		} else if (mDevice && mDevice->ops->set_parameters) {
		return mDevice->ops->set_parameters(mDevice, params.flatten().string());
		}
		return INVALID_OPERATION;
		}
		@@ -740,14 +667,6 @@ CameraParameters CameraHardwareInterface::getParameters() const
		});
		String8 tmp(outParam.c_str());
		parms.unflatten(tmp);
		} else if (mDevice && mDevice->ops->get_parameters) {
		char *temp = mDevice->ops->get_parameters(mDevice);
		String8 str_parms(temp);
		if (mDevice->ops->put_parameters)
		mDevice->ops->put_parameters(mDevice, temp);
		else
		free(temp);
		parms.unflatten(str_parms);
		}
		return parms;
		}
		@@ -758,8 +677,6 @@ status_t CameraHardwareInterface::sendCommand(int32_t cmd, int32_t arg1, int32_t
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		return CameraProviderManager::mapToStatusT(
		mHidlDevice->sendCommand((CommandType) cmd, arg1, arg2));
		} else if (mDevice && mDevice->ops->send_command) {
		return mDevice->ops->send_command(mDevice, cmd, arg1, arg2);
		}
		return INVALID_OPERATION;
		}
		@@ -773,8 +690,6 @@ void CameraHardwareInterface::release() {
		if (CC_LIKELY(mHidlDevice != nullptr)) {
		mHidlDevice->close();
		mHidlDevice.clear();
		} else if (mDevice && mDevice->ops->release) {
		mDevice->ops->release(mDevice);
		}
		}

		@@ -790,15 +705,10 @@ status_t CameraHardwareInterface::dump(int fd, const Vector<String16>& /args/)
		Status s = mHidlDevice->dumpState(handle);
		native_handle_delete(handle);
		return CameraProviderManager::mapToStatusT(s);
		} else if (mDevice && mDevice->ops->dump) {
		return mDevice->ops->dump(mDevice, fd);
		}
		return OK; // It's fine if the HAL doesn't implement dump()
		}

		/**
		* Methods for legacy (non-HIDL) path follows
		*/
		void CameraHardwareInterface::sNotifyCb(int32_t msg_type, int32_t ext1,
		int32_t ext2, void *user)
		{
		@@ -868,177 +778,4 @@ void CameraHardwareInterface::sPutMemory(camera_memory_t *data)
		mem->decStrong(mem);
		}

		ANativeWindow* CameraHardwareInterface::sToAnw(void *user)
		{
		CameraHardwareInterface *object =
		reinterpret_cast<CameraHardwareInterface *>(user);
		return object->mPreviewWindow.get();
		}
		#define anw(n) sToAnw(((struct camera_preview_window *)(n))->user)
		#define hwi(n) reinterpret_cast<CameraHardwareInterface *>(\
		((struct camera_preview_window *)(n))->user)

		int CameraHardwareInterface::sDequeueBuffer(struct preview_stream_ops* w,
		buffer_handle_t** buffer, int *stride)
		{
		int rc;
		ANativeWindow *a = anw(w);
		ANativeWindowBuffer* anb;
		rc = native_window_dequeue_buffer_and_wait(a, &anb);
		if (rc == OK) {
		*buffer = &anb->handle;
		*stride = anb->stride;
		}
		return rc;
		}

		#ifndef container_of
		#define container_of(ptr, type, member) ({ \
		const __typeof__(((type ) 0)->member) __mptr = (ptr); \
		(type ) ((char ) __mptr - (char )(&((type )0)->member)); })
		#endif

		int CameraHardwareInterface::sLockBuffer(struct preview_stream_ops* w,
		buffer_handle_t* /buffer/)
		{
		ANativeWindow *a = anw(w);
		(void)a;
		return 0;
		}

		int CameraHardwareInterface::sEnqueueBuffer(struct preview_stream_ops* w,
		buffer_handle_t* buffer)
		{
		ANativeWindow *a = anw(w);
		return a->queueBuffer(a,
		container_of(buffer, ANativeWindowBuffer, handle), -1);
		}

		int CameraHardwareInterface::sCancelBuffer(struct preview_stream_ops* w,
		buffer_handle_t* buffer)
		{
		ANativeWindow *a = anw(w);
		return a->cancelBuffer(a,
		container_of(buffer, ANativeWindowBuffer, handle), -1);
		}

		int CameraHardwareInterface::sSetBufferCount(struct preview_stream_ops* w, int count)
		{
		ANativeWindow *a = anw(w);

		if (a != nullptr) {
		// Workaround for b/27039775
		// Previously, setting the buffer count would reset the buffer
		// queue's flag that allows for all buffers to be dequeued on the
		// producer side, instead of just the producer's declared max count,
		// if no filled buffers have yet been queued by the producer. This
		// reset no longer happens, but some HALs depend on this behavior,
		// so it needs to be maintained for HAL backwards compatibility.
		// Simulate the prior behavior by disconnecting/reconnecting to the
		// window and setting the values again. This has the drawback of
		// actually causing memory reallocation, which may not have happened
		// in the past.
		CameraHardwareInterface *hw = hwi(w);
		native_window_api_disconnect(a, NATIVE_WINDOW_API_CAMERA);
		native_window_api_connect(a, NATIVE_WINDOW_API_CAMERA);
		if (hw->mPreviewScalingMode != NOT_SET) {
		native_window_set_scaling_mode(a, hw->mPreviewScalingMode);
		}
		if (hw->mPreviewTransform != NOT_SET) {
		native_window_set_buffers_transform(a, hw->mPreviewTransform);
		}
		if (hw->mPreviewWidth != NOT_SET) {
		native_window_set_buffers_dimensions(a,
		hw->mPreviewWidth, hw->mPreviewHeight);
		native_window_set_buffers_format(a, hw->mPreviewFormat);
		}
		if (hw->mPreviewUsage != 0) {
		native_window_set_usage(a, hw->mPreviewUsage);
		}
		if (hw->mPreviewSwapInterval != NOT_SET) {
		a->setSwapInterval(a, hw->mPreviewSwapInterval);
		}
		if (hw->mPreviewCrop.left != NOT_SET) {
		native_window_set_crop(a, &(hw->mPreviewCrop));
		}
		}

		return native_window_set_buffer_count(a, count);
		}

		int CameraHardwareInterface::sSetBuffersGeometry(struct preview_stream_ops* w,
		int width, int height, int format)
		{
		int rc;
		ANativeWindow *a = anw(w);
		CameraHardwareInterface *hw = hwi(w);
		hw->mPreviewWidth = width;
		hw->mPreviewHeight = height;
		hw->mPreviewFormat = format;
		rc = native_window_set_buffers_dimensions(a, width, height);
		if (rc == OK) {
		rc = native_window_set_buffers_format(a, format);
		}
		return rc;
		}

		int CameraHardwareInterface::sSetCrop(struct preview_stream_ops *w,
		int left, int top, int right, int bottom)
		{
		ANativeWindow *a = anw(w);
		CameraHardwareInterface *hw = hwi(w);
		hw->mPreviewCrop.left = left;
		hw->mPreviewCrop.top = top;
		hw->mPreviewCrop.right = right;
		hw->mPreviewCrop.bottom = bottom;
		return native_window_set_crop(a, &(hw->mPreviewCrop));
		}

		int CameraHardwareInterface::sSetTimestamp(struct preview_stream_ops *w,
		int64_t timestamp) {
		ANativeWindow *a = anw(w);
		return native_window_set_buffers_timestamp(a, timestamp);
		}

		int CameraHardwareInterface::sSetUsage(struct preview_stream_ops* w, int usage)
		{
		ANativeWindow *a = anw(w);
		CameraHardwareInterface *hw = hwi(w);
		hw->mPreviewUsage = usage;
		return native_window_set_usage(a, usage);
		}

		int CameraHardwareInterface::sSetSwapInterval(struct preview_stream_ops *w, int interval)
		{
		ANativeWindow *a = anw(w);
		CameraHardwareInterface *hw = hwi(w);
		hw->mPreviewSwapInterval = interval;
		return a->setSwapInterval(a, interval);
		}

		int CameraHardwareInterface::sGetMinUndequeuedBufferCount(
		const struct preview_stream_ops *w,
		int *count)
		{
		ANativeWindow *a = anw(w);
		return a->query(a, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, count);
		}

		void CameraHardwareInterface::initHalPreviewWindow()
		{
		mHalPreviewWindow.nw.cancel_buffer = sCancelBuffer;
		mHalPreviewWindow.nw.lock_buffer = sLockBuffer;
		mHalPreviewWindow.nw.dequeue_buffer = sDequeueBuffer;
		mHalPreviewWindow.nw.enqueue_buffer = sEnqueueBuffer;
		mHalPreviewWindow.nw.set_buffer_count = sSetBufferCount;
		mHalPreviewWindow.nw.set_buffers_geometry = sSetBuffersGeometry;
		mHalPreviewWindow.nw.set_crop = sSetCrop;
		mHalPreviewWindow.nw.set_timestamp = sSetTimestamp;
		mHalPreviewWindow.nw.set_usage = sSetUsage;
		mHalPreviewWindow.nw.set_swap_interval = sSetSwapInterval;

		mHalPreviewWindow.nw.get_min_undequeued_buffer_count =
		sGetMinUndequeuedBufferCount;
		}

		}; // namespace android

services/camera/libcameraservice/device1/CameraHardwareInterface.h

+0 −44

Original line number	Diff line number	Diff line
		@@ -90,7 +90,6 @@ class CameraHardwareInterface :

		public:
		explicit CameraHardwareInterface(const char *name):
		mDevice(nullptr),
		mHidlDevice(nullptr),
		mName(name),
		mPreviewScalingMode(NOT_SET),
		@@ -299,7 +298,6 @@ public:
		status_t dump(int fd, const Vector<String16>& /args/) const;

		private:
		camera_device_t *mDevice;
		sp<hardware::camera::device::V1_0::ICameraDevice> mHidlDevice;
		String8 mName;

		@@ -369,41 +367,6 @@ private:

		static void sPutMemory(camera_memory_t *data);

		static ANativeWindow sToAnw(void user);

		static int sDequeueBuffer(struct preview_stream_ops* w,
		buffer_handle_t** buffer, int *stride);

		static int sLockBuffer(struct preview_stream_ops* w,
		buffer_handle_t* /buffer/);

		static int sEnqueueBuffer(struct preview_stream_ops* w,
		buffer_handle_t* buffer);

		static int sCancelBuffer(struct preview_stream_ops* w,
		buffer_handle_t* buffer);

		static int sSetBufferCount(struct preview_stream_ops* w, int count);

		static int sSetBuffersGeometry(struct preview_stream_ops* w,
		int width, int height, int format);

		static int sSetCrop(struct preview_stream_ops *w,
		int left, int top, int right, int bottom);

		static int sSetTimestamp(struct preview_stream_ops *w,
		int64_t timestamp);

		static int sSetUsage(struct preview_stream_ops* w, int usage);

		static int sSetSwapInterval(struct preview_stream_ops *w, int interval);

		static int sGetMinUndequeuedBufferCount(
		const struct preview_stream_ops *w,
		int *count);

		void initHalPreviewWindow();

		std::pair<bool, uint64_t> getBufferId(ANativeWindowBuffer* anb);
		void cleanupCirculatingBuffers();

		@@ -459,13 +422,6 @@ private:

		sp<ANativeWindow> mPreviewWindow;

		struct camera_preview_window {
		struct preview_stream_ops nw;
		void *user;
		};

		struct camera_preview_window mHalPreviewWindow;

		notify_callback mNotifyCb;
		data_callback mDataCb;
		data_callback_timestamp mDataCbTimestamp;

services/camera/libcameraservice/device3/Camera3Device.cpp

+185 −217

Original line number	Diff line number	Diff line
		@@ -3058,24 +3058,20 @@ void Camera3Device::monitorMetadata(TagMonitor::eventSource source,
		Camera3Device::HalInterface::HalInterface(
		sp<ICameraDeviceSession> &session,
		std::shared_ptr<RequestMetadataQueue> queue) :
		mHal3Device(nullptr),
		mHidlSession(session),
		mRequestMetadataQueue(queue) {}

		Camera3Device::HalInterface::HalInterface() :
		mHal3Device(nullptr) {}
		Camera3Device::HalInterface::HalInterface() {}

		Camera3Device::HalInterface::HalInterface(const HalInterface& other) :
		mHal3Device(other.mHal3Device),
		mHidlSession(other.mHidlSession),
		mRequestMetadataQueue(other.mRequestMetadataQueue) {}

		bool Camera3Device::HalInterface::valid() {
		return (mHal3Device != nullptr) \|\| (mHidlSession != nullptr);
		return (mHidlSession != nullptr);
		}

		void Camera3Device::HalInterface::clear() {
		mHal3Device = nullptr;
		mHidlSession.clear();
		}

		@@ -3090,18 +3086,6 @@ status_t Camera3Device::HalInterface::constructDefaultRequestSettings(
		if (!valid()) return INVALID_OPERATION;
		status_t res = OK;

		if (mHal3Device != nullptr) {
		const camera_metadata *r;
		r = mHal3Device->ops->construct_default_request_settings(
		mHal3Device, templateId);
		if (r == nullptr) return BAD_VALUE;
		*requestTemplate = clone_camera_metadata(r);
		if (requestTemplate == nullptr) {
		ALOGE("%s: Unable to clone camera metadata received from HAL",
		__FUNCTION__);
		return INVALID_OPERATION;
		}
		} else {
		common::V1_0::Status status;
		RequestTemplate id;
		switch (templateId) {
		@@ -3155,7 +3139,7 @@ status_t Camera3Device::HalInterface::constructDefaultRequestSettings(
		} else {
		res = CameraProviderManager::mapToStatusT(status);
		}
		}

		return res;
		}

		@@ -3164,9 +3148,6 @@ status_t Camera3Device::HalInterface::configureStreams(camera3_stream_configurat
		if (!valid()) return INVALID_OPERATION;
		status_t res = OK;

		if (mHal3Device != nullptr) {
		res = mHal3Device->ops->configure_streams(mHal3Device, config);
		} else {
		// Convert stream config to HIDL
		std::set<int> activeStreams;
		StreamConfiguration requestedConfiguration;
		@@ -3295,7 +3276,7 @@ status_t Camera3Device::HalInterface::configureStreams(camera3_stream_configurat
		}
		dst->max_buffers = src.maxBuffers;
		}
		}

		return res;
		}

		@@ -3451,14 +3432,11 @@ status_t Camera3Device::HalInterface::processCaptureRequest(
		if (!valid()) return INVALID_OPERATION;
		status_t res = OK;

		if (mHal3Device != nullptr) {
		res = mHal3Device->ops->process_capture_request(mHal3Device, request);
		} else {
		uint32_t numRequestProcessed = 0;
		std::vector<camera3_capture_request_t*> requests(1);
		requests[0] = request;
		res = processBatchCaptureRequests(requests, &numRequestProcessed);
		}

		return res;
		}

		@@ -3467,9 +3445,6 @@ status_t Camera3Device::HalInterface::flush() {
		if (!valid()) return INVALID_OPERATION;
		status_t res = OK;

		if (mHal3Device != nullptr) {
		res = mHal3Device->ops->flush(mHal3Device);
		} else {
		auto err = mHidlSession->flush();
		if (!err.isOk()) {
		ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str());
		@@ -3477,21 +3452,17 @@ status_t Camera3Device::HalInterface::flush() {
		} else {
		res = CameraProviderManager::mapToStatusT(err);
		}
		}

		return res;
		}

		status_t Camera3Device::HalInterface::dump(int fd) {
		status_t Camera3Device::HalInterface::dump(int /fd/) {
		ATRACE_NAME("CameraHal::dump");
		if (!valid()) return INVALID_OPERATION;
		status_t res = OK;

		if (mHal3Device != nullptr) {
		mHal3Device->ops->dump(mHal3Device, fd);
		} else {
		// Handled by CameraProviderManager::dump
		}
		return res;

		return OK;
		}

		status_t Camera3Device::HalInterface::close() {
		@@ -3499,15 +3470,12 @@ status_t Camera3Device::HalInterface::close() {
		if (!valid()) return INVALID_OPERATION;
		status_t res = OK;

		if (mHal3Device != nullptr) {
		mHal3Device->common.close(&mHal3Device->common);
		} else {
		auto err = mHidlSession->close();
		// Interface will be dead shortly anyway, so don't log errors
		if (!err.isOk()) {
		res = DEAD_OBJECT;
		}
		}

		return res;
		}

services/camera/libcameraservice/device3/Camera3Device.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -271,7 +271,6 @@ class Camera3Device :
		void getInflightBufferKeys(std::vector<std::pair<int32_t, int32_t>>* out);

		private:
		camera3_device_t *mHal3Device;
		sp<hardware::camera::device::V3_2::ICameraDeviceSession> mHidlSession;
		std::shared_ptr<RequestMetadataQueue> mRequestMetadataQueue;