libbinder: Add support for C++ Parcelable (97f048d1) · Commits · e / devices / smdk4412 / android_frameworks_native

include/binder/Parcel.h

+19 −0

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

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

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

		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>
		status_t write(const Flattenable<T>& val);

		@@ -203,6 +208,10 @@ public:
		status_t readStrongBinder(sp<IBinder>* val) 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>
		status_t readStrongBinder(sp<T>* val) const;

		@@ -543,6 +552,16 @@ status_t Parcel::writeTypedVector(const std::vector<T>& val,
		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)

include/binder/Parcelable.h

0 → 100644

+51 −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_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	Diff line number	Diff line
		@@ -931,6 +931,14 @@ status_t Parcel::writeWeakBinder(const wp<IBinder>& val)
		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)
		{
		if (!handle \|\| handle->version != sizeof(native_handle))
		@@ -1543,6 +1551,18 @@ wp<IBinder> Parcel::readWeakBinder() const
		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
		{
		binder::Status status;