Merge "libbinder: Add support for C++ Parcelable" am: 49b5443a49 (cf6d7d19) · Commits · e / os / android_frameworks_native-old

include/binder/Parcel.h

+19 −0

Original line number	Original line	Diff line number	Diff line
	@@ -28,6 +28,7 @@
	#include <linux/binder.h>		#include <linux/binder.h>

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

	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------
	namespace android {		namespace android {
	@@ -127,6 +128,10 @@ public:

	status_t writeStrongBinderVector(const std::vector<sp<IBinder>>& val);		status_t writeStrongBinderVector(const std::vector<sp<IBinder>>& val);

			template<typename T>
			status_t writeParcelableVector(const std::vector<T>& val);
			status_t writeParcelable(const Parcelable& parcelable);

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

	@@ -203,6 +208,10 @@ public:
	status_t readStrongBinder(sp<IBinder>* val) const;		status_t readStrongBinder(sp<IBinder>* val) const;
	wp<IBinder> readWeakBinder() const;		wp<IBinder> readWeakBinder() const;

			template<typename T>
			status_t readParcelableVector(std::vector<T>* val) const;
			status_t readParcelable(Parcelable* parcelable) const;

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

	@@ -545,6 +554,16 @@ status_t Parcel::writeTypedVector(const std::vector<T>& val,
	return unsafeWriteTypedVector(val, write_func);		return unsafeWriteTypedVector(val, write_func);
	}		}

			template<typename T>
			status_t Parcel::readParcelableVector(std::vector<T>* val) const {
			return unsafeReadTypedVector(val, &Parcel::readParcelable);
			}

			template<typename T>
			status_t Parcel::writeParcelableVector(const std::vector<T>& val) {
			return unsafeWriteTypedVector(val, &Parcel::writeParcelable);
			}

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

	inline TextOutput& operator<<(TextOutput& to, const Parcel& parcel)		inline TextOutput& operator<<(TextOutput& to, const Parcel& parcel)

include/binder/Parcelable.h

0 → 100644

+51 −0

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

			#ifndef ANDROID_PARCELABLE_H
			#define ANDROID_PARCELABLE_H

			#include <vector>

			#include <utils/Errors.h>
			#include <utils/String16.h>

			namespace android {

			class Parcel;

			// Abstract interface of all parcelables.
			class Parcelable {
			public:
			virtual ~Parcelable() = default;

			// Write \|this\| parcelable to the given \|parcel\|. Keep in mind that
			// implementations of writeToParcel must be manually kept in sync
			// with readFromParcel and the Java equivalent versions of these methods.
			//
			// Returns android::OK on success and an appropriate error otherwise.
			virtual status_t writeToParcel(Parcel* parcel) const = 0;

			// Read data from the given \|parcel\| into \|this\|. After readFromParcel
			// completes, \|this\| should have equivalent state to the object that
			// wrote itself to the parcel.
			//
			// Returns android::OK on success and an appropriate error otherwise.
			virtual status_t readFromParcel(const Parcel* parcel) = 0;
			}; // class Parcelable

			} // namespace android

			#endif // ANDROID_PARCELABLE_H

libs/binder/Parcel.cpp

+20 −0

Original line number	Original line	Diff line number	Diff line
	@@ -957,6 +957,14 @@ status_t Parcel::writeWeakBinder(const wp<IBinder>& val)
	return flatten_binder(ProcessState::self(), val, this);		return flatten_binder(ProcessState::self(), val, this);
	}		}

			status_t Parcel::writeParcelable(const Parcelable& parcelable) {
			status_t status = writeInt32(1); // parcelable is not null.
			if (status != OK) {
			return status;
			}
			return parcelable.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))
	@@ -1567,6 +1575,18 @@ wp<IBinder> Parcel::readWeakBinder() const
	return val;		return val;
	}		}

			status_t Parcel::readParcelable(Parcelable* parcelable) const {
			int32_t have_parcelable = 0;
			status_t status = readInt32(&have_parcelable);
			if (status != OK) {
			return status;
			}
			if (!have_parcelable) {
			return UNEXPECTED_NULL;
			}
			return parcelable->readFromParcel(this);
			}

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