Merge "libbinder: remove Map" (2fee0951) · Commits · e / devices / smdk4412 / android_frameworks_native

libs/binder/Android.bp

+0 −1

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

libs/binder/Parcel.cpp

+0 −123

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

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

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

	status_t Parcel::writeNativeHandle(const native_handle* handle)		status_t Parcel::writeNativeHandle(const native_handle* handle)
	{		{
	if (!handle \|\| handle->version != sizeof(native_handle))		if (!handle \|\| handle->version != sizeof(native_handle))
	@@ -1350,120 +1345,6 @@ status_t Parcel::writeNoException()
	return status.writeToParcel(this);		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/)		void Parcel::remove(size_t /start/, size_t /amt/)
	{		{
	LOG_ALWAYS_FATAL("Parcel::remove() not yet implemented!");		LOG_ALWAYS_FATAL("Parcel::remove() not yet implemented!");
	@@ -2165,10 +2046,6 @@ status_t Parcel::readParcelable(Parcelable* parcelable) const {
	return parcelable->readFromParcel(this);		return parcelable->readFromParcel(this);
	}		}

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

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

libs/binder/TEST_MAPPING

+0 −3

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

libs/binder/Value.cpp

deleted100644 → 0

+0 −420

Original line number	Original line	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	Original line	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