libbinder: Add support for Value, Map, and IpPrefix types (6316f5b8) · Commits · e / os / platform_frameworks_native

include/binder/IpPrefix.h

0 → 100644

+87 −0

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.
		*/

		#ifndef ANDROID_IP_PREFIX_H
		#define ANDROID_IP_PREFIX_H

		#include <netinet/in.h>

		#include <binder/Parcelable.h>
		#include <utils/String16.h>
		#include <utils/StrongPointer.h>

		namespace android {

		namespace net {

		/*
		* C++ implementation of the Java class android.net.IpPrefix
		*/
		class IpPrefix : public Parcelable {
		public:
		IpPrefix() = default;
		virtual ~IpPrefix() = default;
		IpPrefix(const IpPrefix& prefix) = default;

		IpPrefix(const struct in6_addr& addr, int32_t plen):
		mUnion(addr), mPrefixLength(plen), mIsIpv6(true) { }

		IpPrefix(const struct in_addr& addr, int32_t plen):
		mUnion(addr), mPrefixLength(plen), mIsIpv6(false) { }

		bool getAddressAsIn6Addr(struct in6_addr* addr) const;
		bool getAddressAsInAddr(struct in_addr* addr) const;

		const struct in6_addr& getAddressAsIn6Addr() const;
		const struct in_addr& getAddressAsInAddr() const;

		bool isIpv6() const;
		bool isIpv4() const;

		int32_t getPrefixLength() const;

		void setAddress(const struct in6_addr& addr);
		void setAddress(const struct in_addr& addr);

		void setPrefixLength(int32_t prefix);

		friend bool operator==(const IpPrefix& lhs, const IpPrefix& rhs);

		friend bool operator!=(const IpPrefix& lhs, const IpPrefix& rhs) {
		return !(lhs == rhs);
		}

		public:
		// Overrides
		status_t writeToParcel(Parcel* parcel) const override;
		status_t readFromParcel(const Parcel* parcel) override;

		private:
		union InternalUnion {
		InternalUnion(const struct in6_addr &addr):mIn6Addr(addr) { };
		InternalUnion(const struct in_addr &addr):mInAddr(addr) { };
		struct in6_addr mIn6Addr;
		struct in_addr mInAddr;
		} mUnion;
		int32_t mPrefixLength;
		bool mIsIpv6;
		};

		} // namespace net

		} // namespace android

		#endif // ANDROID_IP_PREFIX_H

include/binder/Map.h

0 → 100644

+39 −0

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

include/binder/Parcel.h

+15 −0

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

		#include <binder/IInterface.h>
		#include <binder/Parcelable.h>
		#include <binder/Map.h>

		// ---------------------------------------------------------------------------
		namespace android {
		@@ -43,6 +44,10 @@ class ProcessState;
		class String8;
		class TextOutput;

		namespace binder {
		class Value;
		};

		class Parcel {
		friend class IPCThreadState;
		public:
		@@ -162,6 +167,8 @@ public:

		status_t writeParcelable(const Parcelable& parcelable);

		status_t writeValue(const binder::Value& value);

		template<typename T>
		status_t write(const Flattenable<T>& val);

		@@ -173,6 +180,9 @@ public:
		template<typename T>
		status_t writeVectorSize(const std::unique_ptr<std::vector<T>>& val);

		status_t writeMap(const binder::Map& map);
		status_t writeNullableMap(const std::unique_ptr<binder::Map>& map);

		// Place a native_handle into the parcel (the native_handle's file-
		// descriptors are dup'ed, so it is safe to delete the native_handle
		// when this function returns).
		@@ -278,6 +288,8 @@ public:
		template<typename T>
		status_t readParcelable(std::unique_ptr<T>* parcelable) const;

		status_t readValue(binder::Value* value) const;

		template<typename T>
		status_t readStrongBinder(sp<T>* val) const;

		@@ -321,6 +333,9 @@ public:
		template<typename T>
		status_t resizeOutVector(std::unique_ptr<std::vector<T>>* val) const;

		status_t readMap(binder::Map* map)const;
		status_t readNullableMap(std::unique_ptr<binder::Map>* map) const;

		// Like Parcel.java's readExceptionCode(). Reads the first int32
		// off of a Parcel's header, returning 0 or the negative error
		// code on exceptions, but also deals with skipping over rich

include/binder/Value.h

0 → 100644

+186 −0

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.
		*/

		#ifndef ANDROID_VALUE_H
		#define ANDROID_VALUE_H

		#include <stdint.h>
		#include <map>
		#include <set>
		#include <vector>
		#include <string>

		#include <binder/Parcelable.h>
		#include <binder/PersistableBundle.h>
		#include <binder/Map.h>
		#include <utils/String8.h>
		#include <utils/String16.h>
		#include <utils/StrongPointer.h>

		namespace android {

		class Parcel;

		namespace binder {

		/**
		* A limited C++ generic type. The purpose of this class is to allow C++
		* programs to make use of (or implement) Binder interfaces which make use
		* the Java "Object" generic type (either via the use of the Map type or
		* some other mechanism).
		*
		* This class only supports a limited set of types, but additional types
		* may be easily added to this class in the future as needed---without
		* breaking binary compatability.
		*
		* This class was written in such a way as to help avoid type errors by
		* giving each type their own explicity-named accessor methods (rather than
		* overloaded methods).
		*
		* When reading or writing this class to a Parcel, use the `writeValue()`
		* and `readValue()` methods.
		*/
		class Value {
		public:
		Value();
		virtual ~Value();

		Value& swap(Value &);

		bool empty() const;

		void clear();

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

		int32_t parcelType() const;

		bool operator==(const Value& rhs) const;
		bool operator!=(const Value& rhs) const { return !this->operator==(rhs); }

		Value(const Value& value);
		Value(const bool& value);
		Value(const int8_t& value);
		Value(const int32_t& value);
		Value(const int64_t& value);
		Value(const double& value);
		Value(const String16& value);
		Value(const std::vector<bool>& value);
		Value(const std::vector<uint8_t>& value);
		Value(const std::vector<int32_t>& value);
		Value(const std::vector<int64_t>& value);
		Value(const std::vector<double>& value);
		Value(const std::vector<String16>& value);
		Value(const os::PersistableBundle& value);
		Value(const binder::Map& value);

		Value& operator=(const Value& rhs);
		Value& operator=(const int8_t& rhs);
		Value& operator=(const bool& rhs);
		Value& operator=(const int32_t& rhs);
		Value& operator=(const int64_t& rhs);
		Value& operator=(const double& rhs);
		Value& operator=(const String16& rhs);
		Value& operator=(const std::vector<bool>& rhs);
		Value& operator=(const std::vector<uint8_t>& rhs);
		Value& operator=(const std::vector<int32_t>& rhs);
		Value& operator=(const std::vector<int64_t>& rhs);
		Value& operator=(const std::vector<double>& rhs);
		Value& operator=(const std::vector<String16>& rhs);
		Value& operator=(const os::PersistableBundle& rhs);
		Value& operator=(const binder::Map& rhs);

		void putBoolean(const bool& value);
		void putByte(const int8_t& value);
		void putInt(const int32_t& value);
		void putLong(const int64_t& value);
		void putDouble(const double& value);
		void putString(const String16& value);
		void putBooleanVector(const std::vector<bool>& value);
		void putByteVector(const std::vector<uint8_t>& value);
		void putIntVector(const std::vector<int32_t>& value);
		void putLongVector(const std::vector<int64_t>& value);
		void putDoubleVector(const std::vector<double>& value);
		void putStringVector(const std::vector<String16>& value);
		void putPersistableBundle(const os::PersistableBundle& value);
		void putMap(const binder::Map& value);

		bool getBoolean(bool* out) const;
		bool getByte(int8_t* out) const;
		bool getInt(int32_t* out) const;
		bool getLong(int64_t* out) const;
		bool getDouble(double* out) const;
		bool getString(String16* out) const;
		bool getBooleanVector(std::vector<bool>* out) const;
		bool getByteVector(std::vector<uint8_t>* out) const;
		bool getIntVector(std::vector<int32_t>* out) const;
		bool getLongVector(std::vector<int64_t>* out) const;
		bool getDoubleVector(std::vector<double>* out) const;
		bool getStringVector(std::vector<String16>* out) const;
		bool getPersistableBundle(os::PersistableBundle* out) const;
		bool getMap(binder::Map* out) const;

		bool isBoolean() const;
		bool isByte() const;
		bool isInt() const;
		bool isLong() const;
		bool isDouble() const;
		bool isString() const;
		bool isBooleanVector() const;
		bool isByteVector() const;
		bool isIntVector() const;
		bool isLongVector() const;
		bool isDoubleVector() const;
		bool isStringVector() const;
		bool isPersistableBundle() const;
		bool isMap() const;

		// String Convenience Adapters
		// ---------------------------

		Value(const String8& value): Value(String16(value)) { }
		Value(const ::std::string& value): Value(String8(value.c_str())) { }
		void putString(const String8& value) { return putString(String16(value)); }
		void putString(const ::std::string& value) { return putString(String8(value.c_str())); }
		Value& operator=(const String8& rhs) { return *this = String16(rhs); }
		Value& operator=(const ::std::string& rhs) { return *this = String8(rhs.c_str()); }
		bool getString(String8* out) const;
		bool getString(::std::string* out) const;

		private:

		// This allows ::android::Parcel to call the two methods below.
		friend class ::android::Parcel;

		// This is called by ::android::Parcel::writeValue()
		status_t writeToParcel(Parcel* parcel) const;

		// This is called by ::android::Parcel::readValue()
		status_t readFromParcel(const Parcel* parcel);

		template<typename T> class Content;
		class ContentBase;

		ContentBase* mContent;
		};

		} // namespace binder

		} // namespace android

		#endif // ANDROID_VALUE_H

include/private/binder/ParcelValTypes.h

0 → 100644

+45 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2008 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.
		*/

		namespace android {
		namespace binder {

		// Keep in sync with frameworks/base/core/java/android/os/Parcel.java.
		enum {
		VAL_NULL = -1,
		VAL_STRING = 0,
		VAL_INTEGER = 1,
		VAL_MAP = 2,
		VAL_BUNDLE = 3,
		VAL_PARCELABLE = 4,
		VAL_SHORT = 5,
		VAL_LONG = 6,
		VAL_DOUBLE = 8,
		VAL_BOOLEAN = 9,
		VAL_BYTEARRAY = 13,
		VAL_STRINGARRAY = 14,
		VAL_IBINDER = 15,
		VAL_INTARRAY = 18,
		VAL_LONGARRAY = 19,
		VAL_BYTE = 20,
		VAL_SERIALIZABLE = 21,
		VAL_BOOLEANARRAY = 23,
		VAL_PERSISTABLEBUNDLE = 25,
		VAL_DOUBLEARRAY = 28,
		};

		} // namespace binder
		} // namespace android