Remove buffer_hub_binder and related codes (9f9a4612) · Commits · e / os / android_frameworks_native-old

libs/vr/libbufferhub/Android.bp

+0 −2

Original line number	Diff line number	Diff line
		@@ -22,14 +22,12 @@ sourceFiles = [
		"buffer_hub_base.cpp",
		"buffer_hub_rpc.cpp",
		"consumer_buffer.cpp",
		"buffer_client_impl.cpp",
		"ion_buffer.cpp",
		"producer_buffer.cpp",
		]

		sharedLibraries = [
		"libbase",
		"libbinder",
		"libcutils",
		"libhardware",
		"liblog",

libs/vr/libbufferhub/buffer_client_impl.cpp

deleted100644 → 0

+0 −87

Original line number	Diff line number	Diff line
		#include <log/log.h>
		#include <private/dvr/IBufferClient.h>

		namespace android {
		namespace dvr {

		class BpBufferClient : public BpInterface<IBufferClient> {
		public:
		explicit BpBufferClient(const sp<IBinder>& impl)
		: BpInterface<IBufferClient>(impl) {}

		bool isValid() override;

		status_t duplicate(uint64_t* outToken) override;
		};

		IMPLEMENT_META_INTERFACE(BufferClient, "android.dvr.IBufferClient");

		// Transaction code
		enum {
		IS_VALID = IBinder::FIRST_CALL_TRANSACTION,
		DUPLICATE,
		};

		bool BpBufferClient::isValid() {
		Parcel data, reply;
		status_t ret =
		data.writeInterfaceToken(IBufferClient::getInterfaceDescriptor());
		if (ret != OK) {
		ALOGE("BpBufferClient::isValid: failed to write into parcel; errno=%d",
		ret);
		return false;
		}

		ret = remote()->transact(IS_VALID, data, &reply);
		if (ret == OK) {
		return reply.readBool();
		} else {
		ALOGE("BpBufferClient::isValid: failed to transact; errno=%d", ret);
		return false;
		}
		}

		status_t BpBufferClient::duplicate(uint64_t* outToken) {
		Parcel data, reply;
		status_t ret =
		data.writeInterfaceToken(IBufferClient::getInterfaceDescriptor());
		if (ret != OK) {
		ALOGE("BpBufferClient::duplicate: failed to write into parcel; errno=%d",
		ret);
		return ret;
		}

		ret = remote()->transact(DUPLICATE, data, &reply);
		if (ret == OK) {
		*outToken = reply.readUint64();
		return OK;
		} else {
		ALOGE("BpBufferClient::duplicate: failed to transact; errno=%d", ret);
		return ret;
		}
		}

		status_t BnBufferClient::onTransact(uint32_t code, const Parcel& data,
		Parcel* reply, uint32_t flags) {
		switch (code) {
		case IS_VALID: {
		CHECK_INTERFACE(IBufferClient, data, reply);
		return reply->writeBool(isValid());
		}
		case DUPLICATE: {
		CHECK_INTERFACE(IBufferClient, data, reply);
		uint64_t token = 0;
		status_t ret = duplicate(&token);
		if (ret != OK) {
		return ret;
		}
		return reply->writeUint64(token);
		}
		default:
		// Should not reach except binder defined transactions such as dumpsys
		return BBinder::onTransact(code, data, reply, flags);
		}
		}

		} // namespace dvr
		} // namespace android
		No newline at end of file

libs/vr/libbufferhub/include/private/dvr/IBufferClient.h

deleted100644 → 0

+0 −33

Original line number	Diff line number	Diff line
		#ifndef ANDROID_DVR_IBUFFERCLIENT_H
		#define ANDROID_DVR_IBUFFERCLIENT_H

		#include <binder/IInterface.h>
		#include <binder/Parcel.h>

		namespace android {
		namespace dvr {

		// Interface for acessing BufferHubBuffer remotely.
		class IBufferClient : public IInterface {
		public:
		DECLARE_META_INTERFACE(BufferClient);

		// Checks if the buffer node is valid.
		virtual bool isValid() = 0;

		// Duplicates the client. Token_out will be set to a new token when succeed,
		// and not changed when failed.
		virtual status_t duplicate(uint64_t* outToken) = 0;
		};

		// BnInterface for IBufferClient. Should only be created in bufferhub service.
		class BnBufferClient : public BnInterface<IBufferClient> {
		public:
		virtual status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply,
		uint32_t flags = 0);
		};

		} // namespace dvr
		} // namespace android

		#endif // ANDROID_DVR_IBUFFERCLIENT_H
		No newline at end of file

services/vr/bufferhubd/Android.bp

+1 −8

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

		sharedLibraries = [
		"libbase",
		"libbinder",
		"libbufferhubservice",
		"libcutils",
		"libgtest_prod",
		@@ -30,12 +29,9 @@ cc_library_static {
		name: "libbufferhubd",
		srcs: [
		"buffer_channel.cpp",
		"buffer_client.cpp",
		"buffer_hub.cpp",
		"buffer_hub_binder.cpp",
		"consumer_channel.cpp",
		"consumer_queue_channel.cpp",
		"IBufferHub.cpp",
		"producer_channel.cpp",
		"producer_queue_channel.cpp",
		],
		@@ -45,10 +41,7 @@ cc_library_static {
		"-DATRACE_TAG=ATRACE_TAG_GRAPHICS",
		],
		export_include_dirs: ["include"],
		header_libs: [
		"libdvr_headers",
		"libnativewindow_headers",
		],
		header_libs: ["libdvr_headers"],
		shared_libs: sharedLibraries,
		static_libs: [
		"libbufferhub",

services/vr/bufferhubd/IBufferHub.cpp

deleted100644 → 0

+0 −110

Original line number	Diff line number	Diff line
		#include <log/log.h>
		#include <private/dvr/IBufferHub.h>

		namespace android {
		namespace dvr {

		class BpBufferHub : public BpInterface<IBufferHub> {
		public:
		explicit BpBufferHub(const sp<IBinder>& impl)
		: BpInterface<IBufferHub>(impl) {}

		sp<IBufferClient> createBuffer(uint32_t width, uint32_t height,
		uint32_t layer_count, uint32_t format,
		uint64_t usage,
		uint64_t user_metadata_size) override;

		status_t importBuffer(uint64_t token, sp<IBufferClient>* outClient) override;
		};

		IMPLEMENT_META_INTERFACE(BufferHub, "android.dvr.IBufferHub");

		// Transaction code
		enum {
		CREATE_BUFFER = IBinder::FIRST_CALL_TRANSACTION,
		IMPORT_BUFFER,
		};

		sp<IBufferClient> BpBufferHub::createBuffer(uint32_t width, uint32_t height,
		uint32_t layer_count,
		uint32_t format, uint64_t usage,
		uint64_t user_metadata_size) {
		Parcel data, reply;
		status_t ret = OK;
		ret \|= data.writeInterfaceToken(IBufferHub::getInterfaceDescriptor());
		ret \|= data.writeUint32(width);
		ret \|= data.writeUint32(height);
		ret \|= data.writeUint32(layer_count);
		ret \|= data.writeUint32(format);
		ret \|= data.writeUint64(usage);
		ret \|= data.writeUint64(user_metadata_size);

		if (ret != OK) {
		ALOGE("BpBufferHub::createBuffer: failed to write into parcel");
		return nullptr;
		}

		ret = remote()->transact(CREATE_BUFFER, data, &reply);
		if (ret == OK) {
		return interface_cast<IBufferClient>(reply.readStrongBinder());
		} else {
		ALOGE("BpBufferHub::createBuffer: failed to transact; errno=%d", ret);
		return nullptr;
		}
		}

		status_t BpBufferHub::importBuffer(uint64_t token,
		sp<IBufferClient>* outClient) {
		Parcel data, reply;
		status_t ret = OK;
		ret \|= data.writeInterfaceToken(IBufferHub::getInterfaceDescriptor());
		ret \|= data.writeUint64(token);
		if (ret != OK) {
		ALOGE("BpBufferHub::importBuffer: failed to write into parcel");
		return ret;
		}

		ret = remote()->transact(IMPORT_BUFFER, data, &reply);
		if (ret == OK) {
		*outClient = interface_cast<IBufferClient>(reply.readStrongBinder());
		return OK;
		} else {
		ALOGE("BpBufferHub::importBuffer: failed to transact; errno=%d", ret);
		return ret;
		}
		}

		status_t BnBufferHub::onTransact(uint32_t code, const Parcel& data,
		Parcel* reply, uint32_t flags) {
		switch (code) {
		case CREATE_BUFFER: {
		CHECK_INTERFACE(IBufferHub, data, reply);
		uint32_t width = data.readUint32();
		uint32_t height = data.readUint32();
		uint32_t layer_count = data.readUint32();
		uint32_t format = data.readUint32();
		uint64_t usage = data.readUint64();
		uint64_t user_metadata_size = data.readUint64();
		sp<IBufferClient> ret = createBuffer(width, height, layer_count, format,
		usage, user_metadata_size);
		return reply->writeStrongBinder(IInterface::asBinder(ret));
		}
		case IMPORT_BUFFER: {
		CHECK_INTERFACE(IBufferHub, data, reply);
		uint64_t token = data.readUint64();
		sp<IBufferClient> client;
		status_t ret = importBuffer(token, &client);
		if (ret == OK) {
		return reply->writeStrongBinder(IInterface::asBinder(client));
		} else {
		return ret;
		}
		}
		default:
		// Should not reach except binder defined transactions such as dumpsys
		return BBinder::onTransact(code, data, reply, flags);
		}
		}

		} // namespace dvr
		} // namespace android
		No newline at end of file