libbinder: remove Map (93fee8db) · Commits · e / os / android_frameworks_native

libs/binder/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -73,7 +73,6 @@ cc_library_shared {
		"Status.cpp",
		"TextOutput.cpp",
		"IpPrefix.cpp",
		"Value.cpp",
		":libbinder_aidl",
		],

libs/binder/Parcel.cpp

+0 −123

Original line number	Diff line number	Diff line
		@@ -37,7 +37,6 @@
		#include <binder/ProcessState.h>
		#include <binder/Status.h>
		#include <binder/TextOutput.h>
		#include <binder/Value.h>

		#include <cutils/ashmem.h>
		#include <utils/Debug.h>
		@@ -1109,10 +1108,6 @@ status_t Parcel::writeParcelable(const Parcelable& parcelable) {
		return parcelable.writeToParcel(this);
		}

		status_t Parcel::writeValue(const binder::Value& value) {
		return value.writeToParcel(this);
		}

		status_t Parcel::writeNativeHandle(const native_handle* handle)
		{
		if (!handle \|\| handle->version != sizeof(native_handle))
		@@ -1350,120 +1345,6 @@ status_t Parcel::writeNoException()
		return status.writeToParcel(this);
		}

		status_t Parcel::writeMap(const ::android::binder::Map& map_in)
		{
		using ::std::map;
		using ::android::binder::Value;
		using ::android::binder::Map;

		Map::const_iterator iter;
		status_t ret;

		ret = writeInt32(map_in.size());

		if (ret != NO_ERROR) {
		return ret;
		}

		for (iter = map_in.begin(); iter != map_in.end(); ++iter) {
		ret = writeValue(Value(iter->first));
		if (ret != NO_ERROR) {
		return ret;
		}

		ret = writeValue(iter->second);
		if (ret != NO_ERROR) {
		return ret;
		}
		}

		return ret;
		}

		status_t Parcel::writeNullableMap(const std::unique_ptr<binder::Map>& map)
		{
		if (map == nullptr) {
		return writeInt32(-1);
		}

		return writeMap(*map.get());
		}

		status_t Parcel::readMap(::android::binder::Map* map_out)const
		{
		using ::std::map;
		using ::android::String16;
		using ::android::String8;
		using ::android::binder::Value;
		using ::android::binder::Map;

		status_t ret = NO_ERROR;
		int32_t count;

		ret = readInt32(&count);
		if (ret != NO_ERROR) {
		return ret;
		}

		if (count < 0) {
		ALOGE("readMap: Unexpected count: %d", count);
		return (count == -1)
		? UNEXPECTED_NULL
		: BAD_VALUE;
		}

		map_out->clear();

		while (count--) {
		Map::key_type key;
		Value value;

		ret = readValue(&value);
		if (ret != NO_ERROR) {
		return ret;
		}

		if (!value.getString(&key)) {
		ALOGE("readMap: Key type not a string (parcelType = %d)", value.parcelType());
		return BAD_VALUE;
		}

		ret = readValue(&value);
		if (ret != NO_ERROR) {
		return ret;
		}

		(*map_out)[key] = value;
		}

		return ret;
		}

		status_t Parcel::readNullableMap(std::unique_ptr<binder::Map>* map) const
		{
		const size_t start = dataPosition();
		int32_t count;
		status_t status = readInt32(&count);
		map->reset();

		if (status != OK \|\| count == -1) {
		return status;
		}

		setDataPosition(start);
		map->reset(new binder::Map());

		status = readMap(map->get());

		if (status != OK) {
		map->reset();
		}

		return status;
		}



		void Parcel::remove(size_t /start/, size_t /amt/)
		{
		LOG_ALWAYS_FATAL("Parcel::remove() not yet implemented!");
		@@ -2165,10 +2046,6 @@ status_t Parcel::readParcelable(Parcelable* parcelable) const {
		return parcelable->readFromParcel(this);
		}

		status_t Parcel::readValue(binder::Value* value) const {
		return value->readFromParcel(this);
		}

		int32_t Parcel::readExceptionCode() const
		{
		binder::Status status;

libs/binder/TEST_MAPPING

+0 −3

Original line number	Diff line number	Diff line
		@@ -3,9 +3,6 @@
		{
		"name": "binderDriverInterfaceTest"
		},
		{
		"name": "binderValueTypeTest"
		},
		{
		"name": "binderTextOutputTest"
		}

libs/binder/Value.cpp

deleted100644 → 0

+0 −420

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#define LOG_TAG "Value"

		#include <binder/Value.h>

		#include <limits>

		#include <binder/IBinder.h>
		#include <binder/Parcel.h>
		#include <binder/Map.h>
		#include <private/binder/ParcelValTypes.h>
		#include <log/log.h>
		#include <utils/Errors.h>

		using android::BAD_TYPE;
		using android::BAD_VALUE;
		using android::NO_ERROR;
		using android::UNEXPECTED_NULL;
		using android::Parcel;
		using android::sp;
		using android::status_t;
		using std::map;
		using std::set;
		using std::vector;
		using android::binder::Value;
		using android::IBinder;
		using android::os::PersistableBundle;
		using namespace android::binder;

		// ====================================================================

		#define RETURN_IF_FAILED(calledOnce) \
		do { \
		status_t returnStatus = calledOnce; \
		if (returnStatus) { \
		ALOGE("Failed at %s:%d (%s)", __FILE__, __LINE__, __func__); \
		return returnStatus; \
		} \
		} while(false)

		// ====================================================================

		/* These `internal_type_ptr()` functions allow this
		* class to work without C++ RTTI support. This technique
		* only works properly when called directly from this file,
		* but that is OK because that is the only place we will
		* be calling them from. */
		template<class T> const void* internal_type_ptr()
		{
		static const T *marker;
		return (void*)&marker;
		}

		/* Allows the type to be specified by the argument
		* instead of inside angle brackets. */
		template<class T> const void* internal_type_ptr(const T&)
		{
		return internal_type_ptr<T>();
		}

		// ====================================================================

		namespace android {

		namespace binder {

		class Value::ContentBase {
		public:
		virtual ~ContentBase() = default;
		virtual const void* type_ptr() const = 0;
		virtual ContentBase * clone() const = 0;
		virtual bool operator==(const ContentBase& rhs) const = 0;

		#ifdef LIBBINDER_VALUE_SUPPORTS_TYPE_INFO
		virtual const std::type_info &type() const = 0;
		#endif

		template<typename T> bool get(T* out) const;
		};

		/* This is the actual class that holds the value. */
		template<typename T> class Value::Content : public Value::ContentBase {
		public:
		Content() = default;
		explicit Content(const T & value) : mValue(value) { }

		virtual ~Content() = default;

		#ifdef LIBBINDER_VALUE_SUPPORTS_TYPE_INFO
		virtual const std::type_info &type() const override
		{
		return typeid(T);
		}
		#endif

		virtual const void* type_ptr() const override
		{
		return internal_type_ptr<T>();
		}

		virtual ContentBase * clone() const override
		{
		return new Content(mValue);
		};

		virtual bool operator==(const ContentBase& rhs) const override
		{
		if (type_ptr() != rhs.type_ptr()) {
		return false;
		}
		return mValue == static_cast<const Content<T>* >(&rhs)->mValue;
		}

		T mValue;
		};

		template<typename T> bool Value::ContentBase::get(T* out) const
		{
		if (internal_type_ptr(*out) != type_ptr())
		{
		return false;
		}

		out = static_cast<const Content<T>>(this)->mValue;

		return true;
		}

		// ====================================================================

		Value::Value() : mContent(nullptr)
		{
		}

		Value::Value(const Value& value)
		: mContent(value.mContent ? value.mContent->clone() : nullptr)
		{
		}

		Value::~Value()
		{
		delete mContent;
		}

		bool Value::operator==(const Value& rhs) const
		{
		const Value& lhs(*this);

		if (lhs.empty() && rhs.empty()) {
		return true;
		}

		if ( (lhs.mContent == nullptr)
		\|\| (rhs.mContent == nullptr)
		) {
		return false;
		}

		return lhs.mContent == rhs.mContent;
		}

		Value& Value::swap(Value &rhs)
		{
		std::swap(mContent, rhs.mContent);
		return *this;
		}

		Value& Value::operator=(const Value& rhs)
		{
		if (this != &rhs) {
		delete mContent;
		mContent = rhs.mContent
		? rhs.mContent->clone()
		: nullptr;
		}
		return *this;
		}

		bool Value::empty() const
		{
		return mContent == nullptr;
		}

		void Value::clear()
		{
		delete mContent;
		mContent = nullptr;
		}

		int32_t Value::parcelType() const
		{
		const void* t_info(mContent ? mContent->type_ptr() : nullptr);

		if (t_info == internal_type_ptr<bool>()) return VAL_BOOLEAN;
		if (t_info == internal_type_ptr<uint8_t>()) return VAL_BYTE;
		if (t_info == internal_type_ptr<int32_t>()) return VAL_INTEGER;
		if (t_info == internal_type_ptr<int64_t>()) return VAL_LONG;
		if (t_info == internal_type_ptr<double>()) return VAL_DOUBLE;
		if (t_info == internal_type_ptr<String16>()) return VAL_STRING;

		if (t_info == internal_type_ptr<vector<bool>>()) return VAL_BOOLEANARRAY;
		if (t_info == internal_type_ptr<vector<uint8_t>>()) return VAL_BYTEARRAY;
		if (t_info == internal_type_ptr<vector<int32_t>>()) return VAL_INTARRAY;
		if (t_info == internal_type_ptr<vector<int64_t>>()) return VAL_LONGARRAY;
		if (t_info == internal_type_ptr<vector<double>>()) return VAL_DOUBLEARRAY;
		if (t_info == internal_type_ptr<vector<String16>>()) return VAL_STRINGARRAY;

		if (t_info == internal_type_ptr<Map>()) return VAL_MAP;
		if (t_info == internal_type_ptr<PersistableBundle>()) return VAL_PERSISTABLEBUNDLE;

		return VAL_NULL;
		}

		#ifdef LIBBINDER_VALUE_SUPPORTS_TYPE_INFO
		const std::type_info& Value::type() const
		{
		return mContent != nullptr
		? mContent->type()
		: typeid(void);
		}
		#endif // ifdef LIBBINDER_VALUE_SUPPORTS_TYPE_INFO

		#define DEF_TYPE_ACCESSORS(T, TYPENAME) \
		bool Value::is ## TYPENAME() const \
		{ \
		return mContent \
		? internal_type_ptr<T>() == mContent->type_ptr() \
		: false; \
		} \
		bool Value::get ## TYPENAME(T* out) const \
		{ \
		return mContent \
		? mContent->get(out) \
		: false; \
		} \
		void Value::put ## TYPENAME(const T& in) \
		{ \
		*this = in; \
		} \
		Value& Value::operator=(const T& rhs) \
		{ \
		delete mContent; \
		mContent = new Content< T >(rhs); \
		return *this; \
		} \
		Value::Value(const T& value) \
		: mContent(new Content< T >(value)) \
		{ }

		DEF_TYPE_ACCESSORS(bool, Boolean)
		DEF_TYPE_ACCESSORS(int8_t, Byte)
		DEF_TYPE_ACCESSORS(int32_t, Int)
		DEF_TYPE_ACCESSORS(int64_t, Long)
		DEF_TYPE_ACCESSORS(double, Double)
		DEF_TYPE_ACCESSORS(String16, String)

		DEF_TYPE_ACCESSORS(std::vector<bool>, BooleanVector)
		DEF_TYPE_ACCESSORS(std::vector<uint8_t>, ByteVector)
		DEF_TYPE_ACCESSORS(std::vector<int32_t>, IntVector)
		DEF_TYPE_ACCESSORS(std::vector<int64_t>, LongVector)
		DEF_TYPE_ACCESSORS(std::vector<double>, DoubleVector)
		DEF_TYPE_ACCESSORS(std::vector<String16>, StringVector)

		DEF_TYPE_ACCESSORS(::android::binder::Map, Map)
		DEF_TYPE_ACCESSORS(PersistableBundle, PersistableBundle)

		bool Value::getString(String8* out) const
		{
		String16 val;
		bool ret = getString(&val);
		if (ret) {
		*out = String8(val);
		}
		return ret;
		}

		bool Value::getString(::std::string* out) const
		{
		String8 val;
		bool ret = getString(&val);
		if (ret) {
		*out = val.string();
		}
		return ret;
		}

		status_t Value::writeToParcel(Parcel* parcel) const
		{
		// This implementation needs to be kept in sync with the writeValue
		// implementation in frameworks/base/core/java/android/os/Parcel.java

		#define BEGIN_HANDLE_WRITE() \
		do { \
		const void* t_info(mContent?mContent->type_ptr():nullptr); \
		if (false) { }
		#define HANDLE_WRITE_TYPE(T, TYPEVAL, TYPEMETHOD) \
		else if (t_info == internal_type_ptr<T>()) { \
		RETURN_IF_FAILED(parcel->writeInt32(TYPEVAL)); \
		RETURN_IF_FAILED(parcel->TYPEMETHOD(static_cast<const Content<T>*>(mContent)->mValue)); \
		}
		#define HANDLE_WRITE_PARCELABLE(T, TYPEVAL) \
		else if (t_info == internal_type_ptr<T>()) { \
		RETURN_IF_FAILED(parcel->writeInt32(TYPEVAL)); \
		RETURN_IF_FAILED(static_cast<const Content<T>*>(mContent)->mValue.writeToParcel(parcel)); \
		}
		#define END_HANDLE_WRITE() \
		else { \
		ALOGE("writeToParcel: Type not supported"); \
		return BAD_TYPE; \
		} \
		} while (false);

		BEGIN_HANDLE_WRITE()

		HANDLE_WRITE_TYPE(bool, VAL_BOOLEAN, writeBool)
		HANDLE_WRITE_TYPE(int8_t, VAL_BYTE, writeByte)
		HANDLE_WRITE_TYPE(int8_t, VAL_BYTE, writeByte)
		HANDLE_WRITE_TYPE(int32_t, VAL_INTEGER, writeInt32)
		HANDLE_WRITE_TYPE(int64_t, VAL_LONG, writeInt64)
		HANDLE_WRITE_TYPE(double, VAL_DOUBLE, writeDouble)
		HANDLE_WRITE_TYPE(String16, VAL_STRING, writeString16)

		HANDLE_WRITE_TYPE(vector<bool>, VAL_BOOLEANARRAY, writeBoolVector)
		HANDLE_WRITE_TYPE(vector<uint8_t>, VAL_BYTEARRAY, writeByteVector)
		HANDLE_WRITE_TYPE(vector<int8_t>, VAL_BYTEARRAY, writeByteVector)
		HANDLE_WRITE_TYPE(vector<int32_t>, VAL_INTARRAY, writeInt32Vector)
		HANDLE_WRITE_TYPE(vector<int64_t>, VAL_LONGARRAY, writeInt64Vector)
		HANDLE_WRITE_TYPE(vector<double>, VAL_DOUBLEARRAY, writeDoubleVector)
		HANDLE_WRITE_TYPE(vector<String16>, VAL_STRINGARRAY, writeString16Vector)

		HANDLE_WRITE_PARCELABLE(PersistableBundle, VAL_PERSISTABLEBUNDLE)

		END_HANDLE_WRITE()

		return NO_ERROR;

		#undef BEGIN_HANDLE_WRITE
		#undef HANDLE_WRITE_TYPE
		#undef HANDLE_WRITE_PARCELABLE
		#undef END_HANDLE_WRITE
		}

		status_t Value::readFromParcel(const Parcel* parcel)
		{
		// This implementation needs to be kept in sync with the readValue
		// implementation in frameworks/base/core/java/android/os/Parcel.javai

		#define BEGIN_HANDLE_READ() \
		switch(value_type) { \
		default: \
		ALOGE("readFromParcel: Parcel type %d is not supported", value_type); \
		return BAD_TYPE;
		#define HANDLE_READ_TYPE(T, TYPEVAL, TYPEMETHOD) \
		case TYPEVAL: \
		mContent = new Content<T>(); \
		RETURN_IF_FAILED(parcel->TYPEMETHOD(&static_cast<Content<T>*>(mContent)->mValue)); \
		break;
		#define HANDLE_READ_PARCELABLE(T, TYPEVAL) \
		case TYPEVAL: \
		mContent = new Content<T>(); \
		RETURN_IF_FAILED(static_cast<Content<T>*>(mContent)->mValue.readFromParcel(parcel)); \
		break;
		#define END_HANDLE_READ() \
		}

		int32_t value_type = VAL_NULL;

		delete mContent;
		mContent = nullptr;

		RETURN_IF_FAILED(parcel->readInt32(&value_type));

		BEGIN_HANDLE_READ()

		HANDLE_READ_TYPE(bool, VAL_BOOLEAN, readBool)
		HANDLE_READ_TYPE(int8_t, VAL_BYTE, readByte)
		HANDLE_READ_TYPE(int32_t, VAL_INTEGER, readInt32)
		HANDLE_READ_TYPE(int64_t, VAL_LONG, readInt64)
		HANDLE_READ_TYPE(double, VAL_DOUBLE, readDouble)
		HANDLE_READ_TYPE(String16, VAL_STRING, readString16)

		HANDLE_READ_TYPE(vector<bool>, VAL_BOOLEANARRAY, readBoolVector)
		HANDLE_READ_TYPE(vector<uint8_t>, VAL_BYTEARRAY, readByteVector)
		HANDLE_READ_TYPE(vector<int32_t>, VAL_INTARRAY, readInt32Vector)
		HANDLE_READ_TYPE(vector<int64_t>, VAL_LONGARRAY, readInt64Vector)
		HANDLE_READ_TYPE(vector<double>, VAL_DOUBLEARRAY, readDoubleVector)
		HANDLE_READ_TYPE(vector<String16>, VAL_STRINGARRAY, readString16Vector)

		HANDLE_READ_PARCELABLE(PersistableBundle, VAL_PERSISTABLEBUNDLE)

		END_HANDLE_READ()

		return NO_ERROR;

		#undef BEGIN_HANDLE_READ
		#undef HANDLE_READ_TYPE
		#undef HANDLE_READ_PARCELABLE
		#undef END_HANDLE_READ
		}

		} // namespace binder

		} // namespace android

		/* vim: set ts=4 sw=4 tw=0 et :*/

libs/binder/include/binder/Map.h

deleted100644 → 0

+0 −39

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2005 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef ANDROID_MAP_H
		#define ANDROID_MAP_H

		#include <map>
		#include <string>

		// ---------------------------------------------------------------------------
		namespace android {
		namespace binder {

		class Value;

		/**
		* Convenience typedef for ::std::map<::std::string,::android::binder::Value>
		*/
		typedef ::std::map<::std::string, Value> Map;

		} // namespace binder
		} // namespace android

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

		#endif // ANDROID_MAP_H